PostGraphile 入门 v0.2.0418

[{title: "查看数据结构", completed: false, id: 1552359576677}]

psql -U postgres

create database postodo;
\c postodo

create table todo (
  id serial primary key,
  title text not null,
  completed bool not null default false
)

npm install --save postgraphile
npm install --save @graphile-contrib/pg-simplify-inflector

const express = require('express');
const app = express();
const {postgraphile} = require('postgraphile');

app.use(
    postgraphile('postgres://postgres@localhost/postodo', ['public'], {
        appendPlugins: [PgSimplifyInflectorPlugin],
        graphiql: true,
        simpleCollections: 'both',
        watchPg: true,
    }),
);

app.use('/todo', express.static('./vanillajs'));
app.listen('3000');

createTodo(input: CreateTodoInput!): CreateTodoPayload

mutation($input: CreateTodoInput!) {
  createTodo(input: $input) {
    todo {
      id
      title
      completed
    }
  }
}

query {
  todosList {
    id
    title
    completed
  }
}

Store.prototype.findAll = function (callback) {
    callback = callback || function () {};
    callback.call(this, JSON.parse(localStorage.getItem(this._dbName)));
};

Store.prototype.findAll = function (callback) {
    callback = callback || function () {};
    fetch('/graphql', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            query: `query {
                todosList {
                id
                title
                completed
                }
            }`
        })
    }).then(res => res.json()).then(({data}) => {
        callback.call(this, data.todosList);
    });
};

Store.prototype.find = function (query, callback) {
    if (!callback) {
        return;
    }

    var todos = JSON.parse(localStorage.getItem(this._dbName));

    callback.call(this, todos.filter(function (todo) {
        for (var q in query) {
            if (query[q] !== todo[q]) {
                return false;
            }
        }
        return true;
    }));
};

Store.prototype.find = function (callback) {
    callback = callback || function () {};
    fetch('/graphql', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            query: `query($condition: TodoCondition) {
                todosList(condition: $condition) {
                id
                title
                completed
                }
            }`,
            variables: {
                condition: query,
            },
        }),
    }).then(res => res.json()).then(({data}) => {
        callback.call(this, data.todosList);
    });
});

Store.prototype.save = function (updateData, callback, id) {
    var todos = JSON.parse(localStorage.getItem(this._dbName));

    callback = callback || function() {};

    // If an ID was actually given, find the item and update each property
    if (id) {
        for (var i = 0; i < todos.length; i++) {
            if (todos[i].id === id) {
                for (var key in updateData) {
                    todos[i][key] = updateData[key];
                }
                break;
            }
        }

        localStorage.setItem(this._dbName, JSON.stringify(todos));
        callback.call(this, todos);
    } else {
        // Generate an ID
        updateData.id = new Date().getTime();

        todos.push(updateData);
        localStorage.setItem(this._dbName, JSON.stringify(todos));
        callback.call(this, [updateData]);
    }
}

fetch('/graphql', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        query: `mutation($title: String!) {
            createTodo(input: {todo: {
                title: $title
            }}) {
                todo {
                    id
                    title
                    completed
                }
            }
        }`,
        variables: {
            title: updateData.title
        }
    })
}).then(res => res.json()).then(({data}) => {
    callback.call(this, [data.createTodo.todo]);
});

Store.prototype.save = function(updateData, callback, id) {
    var todos = JSON.parse(localStorage.getItem(this._dbName));

    callback = callback || function() {};

    // If an ID was actually given, find the item and update each property
    if (id) {
        fetch('/graphql', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({
                query: `mutation ($input: UpdateTodoByIdInput!) {
                    updateTodoById(input: $input) {
                        todo {
                            id
                            title
                            completed
                        }
                    }
                }`,
                variables: {
                    input: {
                        id: id,
                        patch: updateData,
                    },
                },
            }),
        }).then(res => res.json()).then(() => {
            this.findAll(callback);
        });
    } else {
        fetch('/graphql', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({
                query: `mutation($title: String!) {
                    createTodo(input: {todo: {
                        title: $title
                    }}) {
                        todo {
                            id
                            title
                            completed
                        }
                    }
                }`,
                variables: {
                    title: updateData.title,
                },
            }),
        }).then(res => res.json()).then(({data}) => {
            callback.call(this, [data.createTodo.todo]);
        });
    }
};

mutation ($input: DeleteTodoByIdInput!) {
  deleteTodoById(input: $input) {
    deletedTodoId
  }
}

Store.prototype.remove = function (id, callback) {
    var todos = JSON.parse(localStorage.getItem(this._dbName));

    for (var i = 0; i < todos.length; i++) {
        if (todos[i].id == id) {
            todos.splice(i, 1);
            break;
        }
    }

    localStorage.setItem(this._dbName, JSON.stringify(todos));
    callback.call(this, todos);
};

Store.prototype.remove = function (id, callback) {
    fetch('/graphql', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            query: `mutation($input: DeleteTodoByIdInput!) {
                deleteTodoById(input: $input) {
                    deletedTodoId
                }
            }`,
            variables: {
                input: {
                    id: id,
                },
            },
        }),
    }).then(res => res.json()).then(() => {
        this.findAll(callback);
    });
};

DELETE FROM todo WHERE completed = true;

CREATE FUNCTION remove_completed() RETURNS void AS '
    DELETE FROM todo WHERE completed = true;
' LANGUAGE SQL

self.view.bind('removeCompleted', function () {
  self.model.storage.removeCompletedItems();
});

Store.prototype.removecompletedItems = function (callback) {
    fetch('/graphql', {
        method: 'post',
        headers: {
            'content-type': 'application/json'
        },
        body: json.stringify({
            query: `mutation ($input: removecompletedinput!) {
                removecompleted(input: $input) {
                    clientmutationid
                }
            }`,
            variables: {
                input: {}
            }
        })
    }).then(res => res.json()).then(() => {
        this.findAll(callback);
    });
};

CREATE TABLE "user" (
    id serial primary key,
    email text not null,
    password text not null
);

CREATE EXTENSION pgcrypto;

CREATE FUNCTION register(email text, pass text) returns INTEGER AS $BODY$
    INSERT INTO "user" ("email", "password") VALUES (
        email,
        crypt(pass, gen_salt('md5'))
    ) RETURNING "id";
$BODY$ LANGUAGE SQL;

mutation ($email: String, $pass: String) {
  register(input: {email: $email, pass: $pass}) {
    integer
  }
}

CREATE FUNCTION public.unique_zuoluo()
    RETURNS text[]
    LANGUAGE 'sql'
    STABLE 
AS $BODY$
    SELECT ARRAY(SELECT DISTINCT zuoluo FROM public.qrinfo)
$BODY$;

query {
  uniqueZuoluo
}

{
  "data": {
    "uniqueZuoluo": [
      "郭家峙村",
      "小郭家峙村"
    ]
  }
}