jinaga-server 1.0.0

package/integration-test/jinaga-test/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "jinaga-test",
+  "version": "1.0.0",
+  "description": "Integration tests for Jinaga.JS",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest --reporters jest-compact-reporter",
+    "test:verbose": "jest --silent=false --verbose false"
+  },
+  "jest": {
+    "verbose": false
+  },
+  "author": "Michael L Perry",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.17.2",
+    "jest": "^28.1.0",
+    "jest-compact-reporter": "^1.2.9",
+    "node-forge": "^1.3.0",
+    "passport": "^0.5.2",
+    "pg": "^8.7.1",
+    "tweetnacl": "^1.0.3",
+    "tweetnacl-util": "^0.15.1"
+  }
+}

package/integration-test/postgres/0-init-app-db.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+
+psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-EOSQL
+    SELECT '$APP_USERNAME';
+    CREATE USER $APP_USERNAME WITH
+        LOGIN
+        ENCRYPTED PASSWORD '$APP_PASSWORD'
+        NOSUPERUSER
+        INHERIT
+        NOCREATEDB
+        NOCREATEROLE
+        NOREPLICATION
+        VALID UNTIL 'infinity';
+    CREATE DATABASE $APP_DATABASE;
+EOSQL

package/integration-test/postgres/1-setup.sql

@@ -0,0 +1,219 @@
+--
+-- Create tables for a Jinaga database
+--
+-- Before executing, be sure you have created the database and the dev role.
+--
+-- CREATE DATABASE myapplication;
+-- \connect myapplication
+--
+-- CREATE USER dev WITH
+--   LOGIN
+--   ENCRYPTED PASSWORD 'devpassword'
+--   NOSUPERUSER
+--   INHERIT
+--   NOCREATEDB
+--   NOCREATEROLE
+--   NOREPLICATION
+--   VALID UNTIL 'infinity';
+--
+
+\set appdatabase `echo "$APP_DATABASE"`
+
+\connect :appdatabase
+
+DO
+$do$
+BEGIN
+
+CREATE EXTENSION IF NOT EXISTS intarray;
+
+--
+-- Fact Type
+--
+
+IF (SELECT to_regclass('public.fact_type')) IS NULL THEN
+
+    CREATE TABLE fact_type (
+        fact_type_id serial PRIMARY KEY,
+        name character varying(50) NOT NULL
+    );
+
+
+    ALTER TABLE public.fact_type OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_fact_type ON fact_type (name);
+
+END IF;
+
+--
+-- Role
+--
+
+IF (SELECT to_regclass('public.role')) IS NULL THEN
+
+    CREATE TABLE role (
+        role_id serial PRIMARY KEY,
+        defining_fact_type_id integer NOT NULL,
+        CONSTRAINT fk_defining_fact_type_id
+            FOREIGN KEY (defining_fact_type_id)
+            REFERENCES fact_type (fact_type_id),
+        name character varying(20) NOT NULL
+    );
+
+
+    ALTER TABLE public.role OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_role ON public.role USING btree (defining_fact_type_id, name);
+
+END IF;
+
+--
+-- Fact
+--
+
+IF (SELECT to_regclass('public.fact') IS NULL) THEN
+
+    CREATE TABLE public.fact (
+        fact_id SERIAL PRIMARY KEY,
+        fact_type_id integer NOT NULL,
+        CONSTRAINT fk_fact_type_id
+            FOREIGN KEY (fact_type_id)
+            REFERENCES fact_type (fact_type_id),
+        hash character varying(100),
+        data jsonb,
+        date_learned timestamp NOT NULL
+            DEFAULT (now() at time zone 'utc')
+    );
+
+
+    ALTER TABLE public.fact OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_fact ON public.fact USING btree (hash, fact_type_id);
+
+END IF;
+
+--
+-- Edge
+--
+
+IF (SELECT to_regclass('public.edge') IS NULL) THEN
+
+    CREATE TABLE public.edge (
+        role_id integer NOT NULL,
+        CONSTRAINT fk_role_id
+            FOREIGN KEY (role_id)
+            REFERENCES role (role_id),
+        successor_fact_id integer NOT NULL,
+        CONSTRAINT fk_successor_fact_id
+            FOREIGN KEY (successor_fact_id)
+            REFERENCES fact (fact_id),
+        predecessor_fact_id integer NOT NULL,
+        CONSTRAINT fk_predecessor_fact_id
+            FOREIGN KEY (predecessor_fact_id)
+            REFERENCES fact (fact_id)
+    );
+
+
+    ALTER TABLE public.edge OWNER TO postgres;
+
+    -- Most unique first, for fastest uniqueness check on insert.
+    CREATE UNIQUE INDEX ux_edge ON public.edge USING btree (successor_fact_id, predecessor_fact_id, role_id);
+    -- Covering index based on successor, favoring most likely members of WHERE clause.
+    CREATE INDEX ix_successor ON public.edge USING btree (successor_fact_id, role_id, predecessor_fact_id);
+    -- Covering index based on predecessor, favoring most likely members of WHERE clause.
+    CREATE INDEX ix_predecessor ON public.edge USING btree (predecessor_fact_id, role_id, successor_fact_id);
+
+END IF;
+
+--
+-- Ancestor
+--
+
+IF (SELECT to_regclass('public.ancestor') IS NULL) THEN
+
+    CREATE TABLE public.ancestor (
+        fact_id integer NOT NULL,
+        CONSTRAINT fk_fact_id
+            FOREIGN KEY (fact_id)
+            REFERENCES fact (fact_id),
+        ancestor_fact_id integer NOT NULL,
+        CONSTRAINT fk_ancestor_fact_id
+            FOREIGN KEY (ancestor_fact_id)
+            REFERENCES fact (fact_id)
+    );
+
+
+    ALTER TABLE public.ancestor OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_ancestor ON public.ancestor USING btree (fact_id, ancestor_fact_id);
+
+END IF;
+
+--
+-- Public Key
+--
+
+IF (SELECT to_regclass('public.public_key') IS NULL) THEN
+
+    CREATE TABLE public.public_key (
+        public_key_id serial PRIMARY KEY,
+        public_key character varying(500) NOT NULL
+    );
+
+
+    ALTER TABLE public.public_key OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_public_key ON public.public_key (public_key);
+
+END IF;
+
+--
+-- Signature
+--
+
+IF (SELECT to_regclass('public.signature') IS NULL) THEN
+
+    CREATE TABLE public."signature" (
+        fact_id integer NOT NULL,
+        CONSTRAINT fk_fact_id
+            FOREIGN KEY (fact_id)
+            REFERENCES fact (fact_id),
+        public_key_id integer NOT NULL,
+        CONSTRAINT fk_public_key_id
+            FOREIGN KEY (public_key_id)
+            REFERENCES public_key (public_key_id),
+        signature character varying(400),
+        date_learned timestamp NOT NULL
+            DEFAULT (now() at time zone 'utc')
+    );
+
+
+    ALTER TABLE public."signature" OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_signature ON public."signature" USING btree (fact_id, public_key_id);
+
+END IF;
+
+--
+-- User
+--
+
+IF (SELECT to_regclass('public.user') IS NULL) THEN
+
+    CREATE TABLE public."user" (
+        provider character varying(100),
+        user_identifier character varying(50),
+        private_key character varying(1800),
+        public_key character varying(500)
+    );
+
+
+    ALTER TABLE public."user" OWNER TO postgres;
+
+    CREATE UNIQUE INDEX ux_user ON public."user" USING btree (user_identifier, provider);
+    CREATE UNIQUE INDEX ux_user_public_key ON public."user" (public_key);
+
+END IF;
+
+END
+$do$

package/integration-test/postgres/2-grant.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$APP_DATABASE" <<-EOSQL
+    GRANT SELECT,INSERT ON TABLE public.fact_type TO $APP_USERNAME;
+    GRANT SELECT, USAGE ON SEQUENCE fact_type_fact_type_id_seq TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.role TO $APP_USERNAME;
+    GRANT SELECT, USAGE ON SEQUENCE role_role_id_seq TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.fact TO $APP_USERNAME;
+    GRANT SELECT, USAGE ON SEQUENCE fact_fact_id_seq TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.edge TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.ancestor TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.public_key TO $APP_USERNAME;
+    GRANT SELECT, USAGE ON SEQUENCE public_key_public_key_id_seq TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.signature TO $APP_USERNAME;
+    GRANT SELECT,INSERT ON TABLE public.user TO $APP_USERNAME;
+EOSQL

package/integration-test/postgres/Dockerfile

@@ -0,0 +1,5 @@
+FROM postgres:14.2-alpine
+
+COPY ./0-init-app-db.sh /docker-entrypoint-initdb.d/
+COPY ./1-setup.sql /docker-entrypoint-initdb.d/
+COPY ./2-grant.sh /docker-entrypoint-initdb.d/

package/integration-test/run.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+docker build -t jinaga-postgres-fact-keystore ./postgres
+
+mkdir -p ./jinaga-test/jinaga
+cp -R ../dist ./jinaga-test/jinaga/dist
+cp ../package.json ./jinaga-test/jinaga/package.json
+docker build -t jinaga-test ./jinaga-test
+
+cleanup() {
+    docker compose down -v
+}
+
+trap cleanup EXIT
+
+docker compose up --exit-code-from jinaga-test --renew-anon-volumes

package/integration-test/start_db.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+docker run -d --name jinaga-postgres -p5432:5432 -e POSTGRES_PASSWORD=superuser -e APP_USERNAME=dev -e APP_PASSWORD=devpw -e APP_DATABASE=integrationtest jinaga-postgres-fact-keystore

package/integration-test/stop_db.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+docker stop jinaga-postgres
+docker rm jinaga-postgres

package/integration-test/test.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+npm run build
+
+cp ./dist/index.js ./integration-test/jinaga-test/jinaga.js
+cp ./dist/index.js.map ./integration-test/jinaga-test/
+
+npm --prefix ./integration-test/jinaga-test install
+npm --prefix ./integration-test/jinaga-test run test:verbose

package/interactive/index.js

@@ -0,0 +1,56 @@
+const { SpecificationParser } = require("../dist/specification/specification-parser");
+const { dehydrateFact } = require("../dist/fact/hydrate");
+const { PostgresStore } = require("../dist/postgres/postgres-store")
+const fs = require("fs");
+
+var user = {"publicKey":"-----BEGIN RSA PUBLIC KEY-----\nMIGJAoGBAIBsKomutukULWw2zoTW2ECMrM8VmD2xvfpl3R4qh1whzuXV+A4EfRKMb/UAjEfw\n5nBmWvcObGyYUgygKrlNeOhf3MnDj706rej6ln9cKGL++ZNsJgJsogaAtmkPihWVGi908fdP\nLQrWTF5be0b/ZP258Zs3CTpcRTpTvhzS5TC1AgMBAAE=\n-----END RSA PUBLIC KEY-----\n","type":"Jinaga.User"};
+
+async function run() {
+    try {
+        var postgresStore = new PostgresStore("postgresql://dev:devpw@localhost:5432/improvingu");
+        try {
+            var input = fs.readFileSync(0, 'utf-8');
+            const parser = new SpecificationParser(input);
+            parser.skipWhitespace();
+            const userRecord = dehydrateFact(user)[0];
+            const knownFacts = {
+                me: {
+                    fact: userRecord,
+                    reference: {
+                        type: userRecord.type,
+                        hash: userRecord.hash
+                    }
+                }
+            };
+            var declaration = parser.parseDeclaration(knownFacts);
+            var specification = parser.parseSpecification();
+
+            // Select starting facts that match the inputs
+            const start = specification.given.map(input => {
+                const fact = declaration[input.name];
+                if (!fact) {
+                    throw new Error(`No fact named ${input.name} was declared`);
+                }
+                return fact.reference;
+            });
+
+            const args = process.argv.slice(2);
+            const produceResults = args.includes("--results");
+            if (produceResults) {
+                const results = await postgresStore.resultsFromSpecification(start, specification);
+                console.log(JSON.stringify(results, null, 2));
+            }
+            else {
+                const streams = await postgresStore.streamsFromSpecification(start, [], 3, specification);
+                console.log(JSON.stringify(streams, null, 2));
+            }
+        }
+        finally {
+            postgresStore.close();
+        }
+    } catch (e) {
+        console.error(e);
+    }
+}
+
+run();

package/jest.config.js

@@ -0,0 +1,12 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: [
+    '**/test/**/*Spec.ts',
+  ],
+  reporters:
+	[
+		'./test/reporter.js',
+	],
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "jinaga-server",
+  "version": "1.0.0",
+  "description": "Application-agnostic back end for web applications",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist/ && rimraf integration-test/jinaga-test/jinaga/ && rimraf integration-test/jinaga-test/node_modules/",
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run clean && npm run build && npm run test",
+    "integration": "npm run build && cd ./integration-test && ./run.sh",
+    "interactive": "nodemon -w docs/specification.txt -x \"cat docs/specification.txt | node interactive\"",
+    "interactive:results": "nodemon -w docs/specification.txt -x \"cat docs/specification.txt | node interactive --results\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jinaga/jinaga-server.git"
+  },
+  "keywords": [
+    "messaging"
+  ],
+  "author": "Michael L Perry",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jinaga/jinaga-server/issues"
+  },
+  "homepage": "https://jinaga.com",
+  "devDependencies": {
+    "@types/express": "^4.17.13",
+    "@types/jest": "^27.5.1",
+    "@types/node-forge": "^0.10.10",
+    "@types/passport": "^1.0.7",
+    "@types/pg": "^8.6.1",
+    "jest": "^28.1.0",
+    "nodemon": "^2.0.15",
+    "rimraf": "^3.0.2",
+    "source-map-support": "^0.5.21",
+    "ts-jest": "^28.0.3",
+    "ts-node": "^10.8.0",
+    "typescript": "^4.7.2"
+  },
+  "dependencies": {
+    "express": "^4.18.1",
+    "jinaga": "^4.0.1",
+    "node-forge": "^1.3.1",
+    "passport": "^0.6.0",
+    "pg": "^8.7.1"
+  }
+}

package/scripts/combined.sql

@@ -0,0 +1,46 @@
+BEGIN TRANSACTION;
+
+
+INSERT INTO public.fact (hash, fact_type_id, data)
+	VALUES ('hash1', 1, '{ "data": 1 }'::jsonb), ('hash2', 2, '{ "data": 2 }'::jsonb)
+ON CONFLICT DO NOTHING;
+
+
+INSERT INTO public.edge
+	(role_id, successor_fact_id, predecessor_fact_id)
+SELECT v.role_id, successor.fact_id, predecessor.fact_id
+FROM (VALUES ('hash2', 2, 'hash1', 1, 1)) AS v (successor_hash, successor_fact_type_id, predecessor_hash, predecessor_fact_type_id, role_id)
+JOIN public.fact AS successor
+	ON successor.hash = v.successor_hash AND successor.fact_type_id = v.successor_fact_type_id
+JOIN public.fact AS predecessor
+	ON predecessor.hash = v.predecessor_hash AND predecessor.fact_type_id = v.predecessor_fact_type_id
+ON CONFLICT DO NOTHING;
+
+
+WITH e AS (
+	SELECT successor.fact_id AS successor_fact_id, predecessor.fact_id AS predecessor_fact_id
+	FROM (VALUES ('hash2', 2, 'hash1', 1)) AS v (successor_hash, successor_fact_type_id, predecessor_hash, predecessor_fact_type_id)
+	JOIN public.fact AS successor
+		ON successor.hash = v.successor_hash AND successor.fact_type_id = v.successor_fact_type_id
+	JOIN public.fact AS predecessor
+		ON predecessor.hash = v.predecessor_hash AND predecessor.fact_type_id = v.predecessor_fact_type_id
+)
+INSERT INTO public.ancestor
+	(fact_id, ancestor_fact_id)
+	SELECT e.successor_fact_id, e.predecessor_fact_id
+	FROM e
+UNION ALL
+	SELECT e.successor_fact_id, ancestor_fact_id
+	FROM e
+	JOIN public.ancestor
+		ON ancestor.fact_id = e.predecessor_fact_id
+ON CONFLICT DO NOTHING;
+
+
+SELECT fact.fact_id, v.fact_type_id, v.hash
+FROM public.fact
+JOIN (VALUES ('hash1', 1), ('hash2', 2)) AS v (hash, fact_type_id)
+	ON fact.hash = v.hash AND fact.fact_type_id = v.fact_type_id;
+
+
+ROLLBACK TRANSACTION;

package/scripts/cte.sql

@@ -0,0 +1,55 @@
+WITH new_fact AS (
+    SELECT hash, fact_type_id, data
+    FROM (VALUES ($1, $2::integer, $3::jsonb))
+        AS fv (hash, fact_type_id, data)
+),
+new_edge AS (
+    SELECT successor_hash, successor_fact_type_id, predecessor_hash, predecessor_fact_type_id, role_id
+    FROM (VALUES ($4, $5::integer, $6, $7::integer, $8::integer))
+        AS ev (successor_hash, successor_fact_type_id, predecessor_hash, predecessor_fact_type_id, role_id)
+),
+inserted_fact AS (
+    INSERT INTO public.fact (hash, fact_type_id, data)
+    SELECT hash, fact_type_id, data
+    FROM new_fact
+    RETURNING fact_id, fact_type_id, hash
+),
+edge_id AS (
+    SELECT
+        new_edge.role_id,
+        successor.fact_id AS successor_fact_id,
+        predecessor.fact_id AS predecessor_fact_id
+    FROM new_edge
+    JOIN inserted_fact AS successor
+        ON successor.hash = new_edge.successor_hash
+        AND successor.fact_type_id = new_edge.successor_fact_type_id
+    JOIN (
+        SELECT fact_id, fact_type_id, hash
+        FROM inserted_fact
+        UNION ALL
+        SELECT fact_id, fact_type_id, hash
+        FROM public.fact
+    ) AS predecessor
+        ON predecessor.hash = new_edge.predecessor_hash
+        AND predecessor.fact_type_id = new_edge.predecessor_fact_type_id
+),
+inserted_edge AS (
+    INSERT INTO public.edge
+        (role_id, successor_fact_id, predecessor_fact_id)
+    SELECT role_id, successor_fact_id, predecessor_fact_id
+    FROM edge_id ON CONFLICT DO NOTHING
+),
+inserted_ancestor AS (
+    INSERT INTO public.ancestor
+        (fact_id, ancestor_fact_id)
+        SELECT edge_id.successor_fact_id, edge_id.predecessor_fact_id
+        FROM edge_id
+    UNION ALL
+        SELECT edge_id.successor_fact_id, ancestor_fact_id
+        FROM edge_id
+        JOIN public.ancestor
+            ON ancestor.fact_id = edge_id.predecessor_fact_id
+    ON CONFLICT DO NOTHING
+)
+SELECT fact_id, fact_type_id, hash
+FROM inserted_fact;

package/scripts/separate.sql

@@ -0,0 +1,27 @@
+BEGIN TRANSACTION;
+
+INSERT INTO public.fact (hash, fact_type_id, data)
+	(SELECT hash, fact_type_id, data
+	 FROM (VALUES ('hash1', 1, '{ "data": 1 }'::jsonb), ('hash2', 2, '{ "data": 2 }'::jsonb)) AS v (hash, fact_type_id, data))
+RETURNING fact_id, fact_type_id, hash;
+
+
+INSERT INTO public.edge
+	(role_id, successor_fact_id, predecessor_fact_id)
+	(VALUES (1, 2, 3), (4, 5, 6))
+ON CONFLICT DO NOTHING;
+
+
+INSERT INTO public.ancestor
+	(fact_id, ancestor_fact_id)
+	SELECT 3, predecessor_fact_id
+	FROM (VALUES (1), (2)) AS v (predecessor_fact_id)
+UNION ALL
+	SELECT 1, ancestor_fact_id
+	FROM (VALUES (1), (2)) AS v (predecessor_fact_id)
+	JOIN public.ancestor
+		ON ancestor.fact_id = predecessor_fact_id
+ON CONFLICT DO NOTHING;
+
+
+ROLLBACK TRANSACTION;

package/setup.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+set -e
+
+JINAGA_ADMIN_CONNECTION_STRING=postgresql://$JINAGA_POSTGRES_ADMIN_USER:$JINAGA_POSTGRES_ADMIN_PASSWORD@$JINAGA_POSTGRES_HOST:$JINAGA_POSTGRES_PORT/$JINAGA_POSTGRES_APP_DATABASE
+
+psql -v ON_ERROR_STOP=1 $JINAGA_ADMIN_CONNECTION_STRING <<-EOSQL
+    CREATE USER $JINAGA_POSTGRES_APP_USER WITH
+        LOGIN
+        ENCRYPTED PASSWORD '$JINAGA_POSTGRES_APP_PASSWORD'
+        NOSUPERUSER
+        INHERIT
+        NOCREATEDB
+        NOCREATEROLE
+        NOREPLICATION
+        VALID UNTIL 'infinity';
+    CREATE DATABASE $JINAGA_POSTGRES_APP_DATABASE;
+EOSQL
+
+cat ./setup.sql | psql -v ON_ERROR_STOP=1 $JINAGA_ADMIN_CONNECTION_STRING
+
+psql -v ON_ERROR_STOP=1 $JINAGA_ADMIN_CONNECTION_STRING <<-EOSQL
+    GRANT SELECT,INSERT ON TABLE public.fact_type TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT, USAGE ON SEQUENCE fact_type_fact_type_id_seq TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.role TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT, USAGE ON SEQUENCE role_role_id_seq TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.fact TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT, USAGE ON SEQUENCE fact_fact_id_seq TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.edge TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.ancestor TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.public_key TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT, USAGE ON SEQUENCE public_key_public_key_id_seq TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.signature TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT ON TABLE public.user TO $JINAGA_POSTGRES_APP_USER;
+EOSQL