jinaga-server 2.3.0 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinaga-server",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Application-agnostic back end for web applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/authentication/authentication-device.ts

@@ -6,7 +6,7 @@ export class AuthenticationDevice implements Authentication {
     private authorizationEngine: AuthorizationEngine | null;
 
     constructor(
-        private inner: Storage,
+        inner: Storage,
         private keystore: Keystore,
         authorizationRules: AuthorizationRules | null,
         private localDeviceIdentity: UserIdentity

package/src/authorization/authorization-keystore.ts

@@ -43,8 +43,9 @@ export class AuthorizationKeystore implements Authorization {
         return this.store.query(start, query);
     }
 
-    read(userIdentity: UserIdentity, start: FactReference[], specification: Specification) {
-        return this.store.read(start, specification);
+    async read(userIdentity: UserIdentity, start: FactReference[], specification: Specification) {
+        const projectedResult = await this.store.read(start, specification);
+        return projectedResult.map(p => p.result);
     }
 
     feed(userIdentity: UserIdentity, feed: Feed, bookmark: string): Promise<FactFeed> {

package/src/index.ts

@@ -1 +1,11 @@
+export { AuthenticationDevice } from "./authentication/authentication-device";
+export { AuthenticationSession } from "./authentication/authentication-session";
+export { AuthorizationKeystore } from "./authorization/authorization-keystore";
+export { Keystore } from "./keystore";
+export { FeedCache } from "./http/feed-cache";
+export { HttpRouter, RequestUser } from "./http/router";
 export { JinagaServer, JinagaServerConfig, JinagaServerInstance, tracePool } from "./jinaga-server";
+export { MemoryFeedCache } from "./memory/memory-feed-cache";
+export { MemoryKeystore } from "./memory/memory-keystore";
+export { PostgresKeystore } from "./postgres/postgres-keystore";
+export { PostgresStore } from "./postgres/postgres-store";

package/src/jinaga-server.ts

@@ -5,17 +5,17 @@ import {
     AuthorizationNoOp,
     AuthorizationRules,
     FactManager,
-    Fork, Jinaga,
+    Jinaga,
     MemoryStore,
     Model,
-    Network,
     NetworkNoOp,
     ObservableSource,
     ObservableSourceImpl,
     PassThroughFork,
     Storage,
     SyncStatusNotifier,
-    Trace, UserIdentity
+    Trace,
+    UserIdentity
 } from "jinaga";
 import { Pool } from "pg";
 
@@ -94,10 +94,6 @@ function createStore(config: JinagaServerConfig, pools: { [uri: string]: Pool })
     }
 }
 
-function createFork(config: JinagaServerConfig, store: Storage, syncStatusNotifier: SyncStatusNotifier): Fork {
-    return new PassThroughFork(store);
-}
-
 function createKeystore(config: JinagaServerConfig, pools: { [uri: string]: Pool }): Keystore | null {
     const uriOrPool = config.pgKeystore;
     if (uriOrPool) {
@@ -124,10 +120,6 @@ function createAuthentication(store: Storage, keystore: Keystore | null, authori
     return keystore ? new AuthenticationDevice(store, keystore, authorizationRules, localDeviceIdentity) : new AuthenticationNoOp();
 }
 
-function createNetwork(config: JinagaServerConfig): Network {
-    return new NetworkNoOp();
-}
-
 function getPool(uriOrPool: string | Pool, pools: { [uri: string]: Pool; }): Pool {
     if (typeof uriOrPool === 'string') {
         const uri = uriOrPool;

package/src/postgres/postgres-store.ts

@@ -478,11 +478,11 @@ export class PostgresStore implements Storage {
     }
 
     getMruDate(specificationHash: string): Promise<Date | null> {
-        throw new Error("Method not implemented.");
+        return Promise.resolve(null);
     }
     
     setMruDate(specificationHash: string, mruDate: Date): Promise<void> {
-        throw new Error("Method not implemented.");
+        return Promise.resolve();
     }
 }
 

package/src/postgres/specification-sql.ts

@@ -25,8 +25,6 @@ interface SpecificationSqlQuery {
 
 interface InputDescription {
     factIndex: number;
-    factTypeId: number;
-    factHash: string;
     factTypeParameter: number;
     factHashParameter: number;
 }
@@ -42,7 +40,6 @@ interface EdgeDescription {
 }
 interface NotExistsConditionDescription {
     edges: EdgeDescription[];
-    notExistsConditions: NotExistsConditionDescription[];
 }
 class QueryDescription {
     constructor(
@@ -174,11 +171,24 @@ function generateNotExistsWhereClause(schema: string, notExistsWhereClause: NotE
 }
 
 function parseBookmark(bookmark: string): number[] {
-    if (bookmark === undefined || bookmark === null || bookmark === "") {
-        return [];
+    try {
+        if (bookmark === undefined || bookmark === null || bookmark === "") {
+            return [];
+        }
+        else {
+            return bookmark.split(".").map(str => strictParseInt(str));
+        }
     }
-    else {
-        return bookmark.split(".").map(str => parseInt(str));
+    catch (e) {
+        throw new Error(`Invalid bookmark: "${bookmark}"`);
+    }
+
+    function strictParseInt(str: string): number {
+        const parsed = parseInt(str);
+        if (isNaN(parsed)) {
+            throw new Error("NaN");
+        }
+        return parsed;
     }
 }
 
@@ -271,9 +281,7 @@ class DescriptionBuilder {
         const factHashParameter = addParameter(input.factHash);
         return {
             factIndex: input.factIndex,
-            factTypeId,
             factTypeParameter,
-            factHash: input.factHash,
             factHashParameter
         };
     }
@@ -319,13 +327,9 @@ class DescriptionBuilder {
         const edges = condition.edges.map(edge =>
             this.buildEdgeDescription(feed, edge, addParameter)
         );
-        const notExistsConditions = condition.notExistsConditions.map(condition =>
-            this.buildNotExistsConditionDescription(feed, condition, addParameter)
-        );
 
         return {
-            edges,
-            notExistsConditions
+            edges
         }
     }
 }

package/src/util/fn.ts

@@ -6,16 +6,6 @@ function safeFlatten<U>(results: U[][]) {
   return flat ? flat : [];
 }
 
-export async function flattenAsync<T, U>(collection: T[], selector: (element: T) => Promise<U[]>) {
-    if (collection.length === 0) {
-        return [];
-    }
-    else {
-        const results = await Promise.all(collection.map(selector));
-        return safeFlatten(results);
-    }
-}
-
 export function flatten<T, U>(collection: T[], selector: (element: T) => U[]) {
     if (collection.length === 0) {
         return [];
@@ -25,39 +15,6 @@ export function flatten<T, U>(collection: T[], selector: (element: T) => U[]) {
     }
 }
 
-export async function mapAsync<T, U>(collection: T[], action: (element: T) => Promise<U>) {
-    if (collection.length === 0) {
-        return [];
-    }
-    else {
-        return await Promise.all(collection.map(action));
-    }
-}
-
-export async function filterAsync<T>(collection: T[], predicate: (element: T) => Promise<boolean>) {
-    if (collection.length === 0) {
-        return [];
-    }
-    else {
-        const filters = await Promise.all(collection.map(async element => ({
-            include: await predicate(element),
-            element
-        })));
-
-        return filters.filter(f => f.include).map(f => f.element);
-    }
-}
-
-export function findIndex<T>(array: T[], predicate: ((element: T) => boolean)): number {
-    for (let index = 0; index < array.length; index++) {
-        if (predicate(array[index])) {
-            return index;
-        }
-    }
-
-    return -1;
-}
-
 export function distinct<T>(value: T, index: number, self: T[]) { 
     return self.indexOf(value) === index;
 }

package/test/postgres/postgresReadSpec.ts

@@ -184,6 +184,57 @@ describe("Postgres read", () => {
         ]);
     });
 
+    it("should read nested existential conditions", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                project: Project [
+                    project->company: Company = company
+                    !E {
+                        deleted: Project.Deleted [
+                            deleted->project: Project = project
+                            !E {
+                                restored: Project.Restored [
+                                    restored->deleted: Project.Deleted = deleted
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            } => project
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT f2.hash as hash2, f2.fact_id as id2, f2.data as data2 ` +
+            `FROM public.fact f1 ` +
+            `JOIN public.edge e1 ` +
+                `ON e1.predecessor_fact_id = f1.fact_id ` +
+                `AND e1.role_id = $3 ` +
+            `JOIN public.fact f2 ` +
+                `ON f2.fact_id = e1.successor_fact_id ` +
+            `WHERE f1.fact_type_id = $1 AND f1.hash = $2 ` +
+            `AND NOT EXISTS (` +
+                `SELECT 1 ` +
+                `FROM public.edge e2 ` +
+                `JOIN public.fact f3 ` +
+                    `ON f3.fact_id = e2.successor_fact_id ` +
+                `WHERE e2.predecessor_fact_id = f2.fact_id ` +
+                    `AND e2.role_id = $4 ` +
+                `AND NOT EXISTS (` +
+                    `SELECT 1 ` +
+                    `FROM public.edge e3 ` +
+                    `JOIN public.fact f4 ` +
+                        `ON f4.fact_id = e3.successor_fact_id ` +
+                    `WHERE e3.predecessor_fact_id = f3.fact_id ` +
+                        `AND e3.role_id = $5` +
+                `)` +
+            `) ` +
+            `ORDER BY f2.fact_id ASC`
+        );
+        expect(tree.sqlQuery.parameters).toEqual
+    });
+
     it("should read complex specifications", () => {
         const { composer, factTypes, roleMap } = sqlFor(`
             (company: Company, user: Jinaga.User) {

package/dist/util/maps.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=maps.js.map

package/dist/util/maps.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"maps.js","sourceRoot":"","sources":["../../src/util/maps.ts"],"names":[],"mappings":""}

package/docs/registrations.sql

@@ -1,22 +0,0 @@
-SELECT F3.HASH AS HASH3,
-	F4.HASH AS HASH4,
-	F6.HASH AS HASH6,
-	sort(array[F3.FACT_ID, F4.FACT_ID, F6.FACT_ID], 'desc') as bookmark
-FROM PUBLIC.FACT F1
-JOIN PUBLIC.EDGE E1 ON E1.PREDECESSOR_FACT_ID = F1.FACT_ID
-AND E1.ROLE_ID = 44
-JOIN PUBLIC.FACT F3 ON F3.FACT_ID = E1.SUCCESSOR_FACT_ID
-JOIN PUBLIC.EDGE E2 ON E2.PREDECESSOR_FACT_ID = F3.FACT_ID
-AND e2.ROLE_ID = 46
-JOIN PUBLIC.FACT F4 ON F4.FACT_ID = E2.SUCCESSOR_FACT_ID
-JOIN PUBLIC.EDGE E4 ON E4.PREDECESSOR_FACT_ID = F4.FACT_ID
-AND E4.ROLE_ID = 18
-JOIN PUBLIC.FACT F6 ON F6.FACT_ID = E4.SUCCESSOR_FACT_ID
-JOIN PUBLIC.EDGE E5 ON E5.SUCCESSOR_FACT_ID = F6.FACT_ID
-AND E5.ROLE_ID = 23
-JOIN PUBLIC.FACT F2 ON F2.FACT_ID = E5.PREDECESSOR_FACT_ID
-WHERE F1.FACT_TYPE_ID = 35
-	AND F1.HASH = '5kIRDvVO/wP4v7G9vhDAPMVi2q0cXsZtp9YuyAjan7yyDUhFFPiwwNnzTor6jFdkC11CYnDmoZueMAqxF9MPTQ=='
-	AND F2.FACT_TYPE_ID = 24
-	AND F2.HASH = '0WWlFbZH+gMoP3QGXO7/mf6hIQC/2iN7wd0peEQKFVvnJMp3gTVvi4eXfVd3DSa81MSzAVp7zVxXIiRnJTF0Kw=='
-ORDER BY bookmark ASC

package/docs/sql/example.sql

@@ -1,49 +0,0 @@
-     SELECT f4.hash AS hash4, f4.fact_id AS id4, f4.data AS data4
-          , f7.hash AS hash7, f7.fact_id AS id7, f7.data AS data7
-          , f9.hash AS hash9, f9.fact_id AS id9, f9.data AS data9
-       FROM public.fact f1
-       JOIN public.edge e1
-         ON e1.predecessor_fact_id = f1.fact_id
-        AND e1.role_id = $3
-       JOIN public.fact f3
-         ON f3.fact_id = e1.successor_fact_id
-       JOIN public.edge e2
-         ON e2.predecessor_fact_id = f3.fact_id
-        AND e2.role_id = $4
-       JOIN public.fact f4
-         ON f4.fact_id = e2.successor_fact_id
-       JOIN public.edge e5
-         ON e5.predecessor_fact_id = f4.fact_id
-        AND e5.role_id = $7
-       JOIN public.fact f7
-         ON f7.fact_id = e5.successor_fact_id
-       JOIN public.edge e6
-         ON e6.successor_fact_id = f7.fact_id
-        AND e6.role_id = $10
-       JOIN public.fact f2
-         ON f2.fact_id = e6.predecessor_fact_id
-       JOIN public.edge e8
-         ON e8.predecessor_fact_id = f4.fact_id
-        AND e8.role_id = $12
-       JOIN public.fact f9
-         ON f9.fact_id = e8.successor_fact_id
-      WHERE 1=1
-       AND f1.fact_type_id = $1
-        AND f1.hash = $2
-        AND f2.fact_type_id = $8
-        AND f2.hash = $9
-        AND NOT EXISTS (SELECT 1
-                          FROM public.edge e3
-                          JOIN public.fact f5
-                            ON f5.fact_id = e3.successor_fact_id
-                         WHERE 1=1
-                           AND e3.predecessor_fact_id = f4.fact_id
-                           AND e3.role_id = $5)
-        AND NOT EXISTS (SELECT 1
-                          FROM public.edge e7
-                          JOIN public.fact f8
-                            ON f8.fact_id = e7.successor_fact_id
-                         WHERE 1=1
-                           AND e7.predecessor_fact_id = f7.fact_id
-                           AND e7.role_id = $11)
-   ORDER BY f4.fact_id ASC, f7.fact_id ASC, f9.fact_id ASC

package/docs/sql-generator.gv

@@ -1,25 +0,0 @@
-digraph {
-    subgraph cluster_states {
-        color=transparent
-        PredecessorType -> PredecessorJoin [label="Predecessor\nemit edge"]
-        PredecessorJoin -> PredecessorType [label="Type"]
-        PredecessorType -> SuccessorJoin [label="Successor" constraint=false]
-
-        SuccessorType -> SuccessorJoin [label="Successor"]
-        SuccessorJoin -> SuccessorType [label="Type\nemit edge"]
-        SuccessorType -> PredecessorJoin [label="Predecessor\nemit fact\nemit edge" constraint=false]
-    }
-
-    subgraph cluster_terminal {
-        color=transparent
-        success
-        error
-    }
-
-    SuccessorJoin -> error [label="end"]
-    SuccessorType -> success [label="end\nemit fact"]
-    PredecessorType -> success [label="end\nemit fact"]
-    PredecessorJoin -> success [label="end\nemit fact"]
-
-    // {rank=same; SuccessorType; success }
-}