jinaga-server 1.1.4 → 2.0.0

package/replicator/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "jinaga-replicator",
+  "version": "1.0.0",
+  "description": "A unit of fact storage and distribution within a Jinaga network",
+  "main": "dist/replicator/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node dist/replicator"
+  },
+  "keywords": [
+    "Jinaga",
+    "CRDT"
+  ],
+  "author": "Michael L Perry",
+  "license": "MIT",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.18.1",
+    "pg": "^8.7.3"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "typescript": "^4.7.4"
+  }
+}

package/replicator/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+      "target": "es6",
+      "module": "commonjs",
+      "sourceMap": true,
+      "baseUrl": "./dist",
+      "outDir": "./dist",
+      "strict": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "forceConsistentCasingInFileNames": true,
+      "paths": {
+      }
+  }
+}

package/src/authentication/authentication-device.ts

@@ -1,17 +1,19 @@
 import {
     Channel,
     FactEnvelope,
+    FactFeed,
     FactRecord,
     FactReference,
     Feed,
     Fork,
     LoginResponse,
     Observable,
+    ProjectedResult,
     Query,
     Specification,
+    SpecificationListener,
     UserIdentity,
 } from "jinaga";
-import { FactFeed } from "jinaga/dist/storage";
 
 import { Keystore } from "../keystore";
 import { Authentication } from "./authentication";
@@ -40,6 +42,14 @@ export class AuthenticationDevice implements Authentication {
         return this.inner.from(fact, query);
     }
 
+    addSpecificationListener(specification: Specification, onResult: (results: ProjectedResult[]) => Promise<void>): SpecificationListener {
+        return this.inner.addSpecificationListener(specification, onResult);
+    }
+
+    removeSpecificationListener(listener: SpecificationListener): void {
+        this.inner.removeSpecificationListener(listener);
+    }
+
     save(envelopes: FactEnvelope[]): Promise<FactEnvelope[]> {
         return this.inner.save(envelopes);
     }

package/src/authentication/authentication-impl.ts

@@ -1,5 +1,4 @@
-import { Channel, FactEnvelope, FactRecord, FactReference, Feed, Fork, Observable, Query, Specification, WebClient } from "jinaga";
-import { FactFeed } from "jinaga/dist/storage";
+import { Channel, FactEnvelope, FactFeed, FactRecord, FactReference, Feed, Fork, Observable, ProjectedResult, Query, Specification, SpecificationListener, WebClient } from "jinaga";
 
 import { Authentication } from "./authentication";
 
@@ -52,6 +51,14 @@ export class AuthenticationImpl implements Authentication {
         return this.inner.from(fact, query);
     }
 
+    addSpecificationListener(specification: Specification, onResult: (results: ProjectedResult[]) => Promise<void>): SpecificationListener {
+        return this.inner.addSpecificationListener(specification, onResult);
+    }
+
+    removeSpecificationListener(listener: SpecificationListener): void {
+        this.inner.removeSpecificationListener(listener);
+    }
+
     addChannel(fact: FactReference, query: Query): Channel {
         return this.inner.addChannel(fact, query);
     }

package/src/authentication/authentication-noop.ts

@@ -0,0 +1,65 @@
+import { Channel, FactEnvelope, FactFeed, FactPath, FactRecord, FactReference, Feed, Fork, LoginResponse, Observable, ObservableSource, ProjectedResult, Query, Specification, SpecificationListener } from "jinaga";
+import { Authentication } from "./authentication";
+
+export class AuthenticationNoOp implements Authentication {
+
+    constructor(
+        private inner: ObservableSource
+    ) { }
+
+    login(): Promise<LoginResponse> {
+        throw new Error("No keystore is configured.");
+    }
+
+    local(): Promise<FactRecord> {
+        throw new Error("No keystore is configured.");
+    }
+
+    addChannel(fact: FactReference, query: Query): Channel {
+        throw new Error("No keystore is configured.");
+    }
+
+    removeChannel(channel: Channel): void {
+        throw new Error("No keystore is configured.");
+    }
+
+    from(fact: FactReference, query: Query): Observable {
+        return this.inner.from(fact, query);
+    }
+
+    addSpecificationListener(specification: Specification, onResult: (results: ProjectedResult[]) => Promise<void>): SpecificationListener {
+        return this.inner.addSpecificationListener(specification, onResult);
+    }
+
+    removeSpecificationListener(listener: SpecificationListener): void {
+        return this.inner.removeSpecificationListener(listener);
+    }
+
+    close(): Promise<void> {
+        return this.inner.close();
+    }
+
+    save(envelopes: FactEnvelope[]): Promise<FactEnvelope[]> {
+        return this.inner.save(envelopes);
+    }
+
+    query(start: FactReference, query: Query): Promise<FactPath[]> {
+        return this.inner.query(start, query);
+    }
+
+    read(start: FactReference[], specification: Specification): Promise<ProjectedResult[]> {
+        return this.inner.read(start, specification);
+    }
+
+    feed(feed: Feed, bookmark: string): Promise<FactFeed> {
+        return this.inner.feed(feed, bookmark);
+    }
+
+    whichExist(references: FactReference[]): Promise<FactReference[]> {
+        return this.inner.whichExist(references);
+    }
+
+    load(references: FactReference[]): Promise<FactRecord[]> {
+        return this.inner.load(references);
+    }
+}

package/src/authentication/authentication-session.ts

@@ -3,17 +3,19 @@ import {
     AuthorizationRules,
     Channel,
     FactEnvelope,
+    FactFeed,
     FactRecord,
     FactReference,
     Feed,
     LoginResponse,
     Observable,
     ObservableSource,
+    ProjectedResult,
     Query,
     Specification,
+    SpecificationListener,
     UserIdentity,
 } from "jinaga";
-import { FactFeed } from "jinaga/dist/storage";
 
 import { Keystore } from "../keystore";
 import { Authentication } from "./authentication";
@@ -64,6 +66,14 @@ export class AuthenticationSession implements Authentication {
         return this.inner.from(fact, query);
     }
 
+    addSpecificationListener(specification: Specification, onResult: (results: ProjectedResult[]) => Promise<void>): SpecificationListener {
+        return this.inner.addSpecificationListener(specification, onResult);
+    }
+
+    removeSpecificationListener(listener: SpecificationListener): void {
+        this.inner.removeSpecificationListener(listener);
+    }
+
     async save(envelopes: FactEnvelope[]): Promise<FactEnvelope[]> {
         const userFact = await this.keystore.getUserFact(this.userIdentity);
         const facts = envelopes.map(envelope => envelope.fact);

package/src/authentication.ts

@@ -1,15 +1,17 @@
 import {
     FactEnvelope,
+    FactFeed,
     FactRecord,
     FactReference,
     Feed,
     Observable,
     ObservableSource,
+    ProjectedResult,
     Query,
     Specification,
-    WebClient,
+    SpecificationListener,
+    WebClient
 } from "jinaga";
-import { FactFeed } from "jinaga/dist/storage";
 
 export class Principal {
     
@@ -55,4 +57,12 @@ export class Authentication implements ObservableSource {
     from(fact: FactReference, query: Query): Observable {
         return this.inner.from(fact, query);
     }
+
+    addSpecificationListener(specification: Specification, onResult: (results: ProjectedResult[]) => Promise<void>): SpecificationListener {
+        return this.inner.addSpecificationListener(specification, onResult);
+    }
+
+    removeSpecificationListener(listener: SpecificationListener): void {
+        this.inner.removeSpecificationListener(listener);
+    }
 }

package/src/authorization/authorization-keystore.ts

@@ -3,15 +3,15 @@ import {
     AuthorizationEngine,
     AuthorizationRules,
     FactEnvelope,
+    FactFeed,
     FactRecord,
     FactReference,
     Feed,
     ObservableSource,
     Query,
     Specification,
-    UserIdentity,
+    UserIdentity
 } from "jinaga";
-import { FactFeed } from "jinaga/dist/storage";
 
 import { Keystore } from "../keystore";
 
@@ -55,7 +55,7 @@ export class AuthorizationKeystore implements Authorization {
         return this.observableSource.load(references);
     }
 
-    async save(userIdentity: UserIdentity, facts: FactRecord[]) {
+    async save(userIdentity: UserIdentity | null, facts: FactRecord[]) {
         if (!this.authorizationEngine) {
             const envelopes = await this.observableSource.save(facts.map(fact => ({
                 fact,
@@ -64,10 +64,15 @@ export class AuthorizationKeystore implements Authorization {
             return envelopes.map(envelope => envelope.fact);
         }
 
-        const userFact = await this.keystore.getUserFact(userIdentity);
+        const userFact = userIdentity ? await this.keystore.getUserFact(userIdentity) : null;
         const authorizedFacts = await this.authorizationEngine.authorizeFacts(facts, userFact);
-        const signedFacts = await this.keystore.signFacts(userIdentity, authorizedFacts);
-        const envelopes = await this.observableSource.save(signedFacts);
-        return envelopes.map(envelope => envelope.fact);
+        if (userIdentity) {
+            const signedFacts = await this.keystore.signFacts(userIdentity, authorizedFacts);
+            const envelopes = await this.observableSource.save(signedFacts);
+            return envelopes.map(envelope => envelope.fact);
+        }
+        else {
+            return authorizedFacts;
+        }
     }
 }

package/src/debug.ts

@@ -0,0 +1,30 @@
+import express from "express";
+import http from "http";
+import { JinagaServer } from "./jinaga-server";
+import process from "process";
+
+process.on('SIGINT', () => {
+  console.log("\n\nStopping replicator\n");
+  process.exit(0);
+});
+
+const app = express();
+const server = http.createServer(app);
+
+app.set('port', process.env.PORT || 8080);
+app.use(express.json());
+app.use(express.text());
+
+const pgConnection = process.env.JINAGA_POSTGRESQL ||
+  'postgresql://appuser:apppw@localhost:5432/appdb';
+  //'postgresql://repl:replpw@localhost:5432/replicator';
+const { handler } = JinagaServer.create({
+  pgStore: pgConnection
+});
+
+app.use('/jinaga', handler);
+
+server.listen(app.get('port'), () => {
+  console.log(`  Replicator is running at http://localhost:${app.get('port')} in ${app.get('env')} mode`);
+  console.log('  Press CTRL-C to stop\n');
+});

package/src/http/router.ts

@@ -26,7 +26,7 @@ import { FeedCache } from "./feed-cache";
 
 interface ParsedQs { [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[] }
 
-function get<U>(method: ((req: RequestUser, params?: { [key: string]: string }, query?: ParsedQs) => Promise<U>)): Handler {
+function get<U>(method: ((req: RequestUser, params: { [key: string]: string }, query: ParsedQs) => Promise<U>)): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
         method(user, req.params, req.query)
@@ -197,7 +197,7 @@ function postStringCreate(method: (user: RequestUser, message: string) => Promis
     };
 }
 
-function serializeUserIdentity(user: RequestUser) : UserIdentity {
+function serializeUserIdentity(user: RequestUser) : UserIdentity | null {
     if (!user) {
         return null;
     }

package/src/jinaga-server.ts

@@ -18,6 +18,7 @@ import {
 } from "jinaga";
 
 import { AuthenticationDevice } from "./authentication/authentication-device";
+import { AuthenticationNoOp } from "./authentication/authentication-noop";
 import { AuthenticationSession } from "./authentication/authentication-session";
 import { AuthorizationKeystore } from "./authorization/authorization-keystore";
 import { NodeHttpConnection } from "./http/node-http";
@@ -54,17 +55,18 @@ export class JinagaServer {
         const store = createStore(config);
         const source = new ObservableSourceImpl(store);
         const fork = createFork(config, source, syncStatusNotifier);
-        const keystore = new PostgresKeystore(config.pgKeystore);
+        const keystore = createKeystore(config);
         const authorizationRules = config.authorization ? config.authorization(new AuthorizationRules()) : null;
         const authorization = createAuthorization(authorizationRules, fork, keystore);
         const feedCache = new MemoryFeedCache();
         const router = new HttpRouter(authorization, feedCache);
-        const authentication = new AuthenticationDevice(fork, keystore, localDeviceIdentity);
-        const memory = new MemoryStore();
-        const j: Jinaga = new Jinaga(authentication, memory, syncStatusNotifier);
+        const authentication = createAuthentication(keystore, fork);
+        const j: Jinaga = new Jinaga(authentication, syncStatusNotifier);
 
         async function close() {
-            await keystore.close();
+            if (keystore) {
+                await keystore.close();
+            }
             await store.close();
         }
         return {
@@ -104,6 +106,10 @@ function createFork(config: JinagaServerConfig, feed: ObservableSource, syncStat
     }
 }
 
+function createKeystore(config: JinagaServerConfig) {
+    return config.pgKeystore ? new PostgresKeystore(config.pgKeystore) : null;
+}
+
 function createAuthorization(authorizationRules: AuthorizationRules | null, feed: ObservableSource, keystore: Keystore | null): Authorization {
     if (keystore) {
         const authorization = new AuthorizationKeystore(feed, keystore, authorizationRules);
@@ -114,14 +120,18 @@ function createAuthorization(authorizationRules: AuthorizationRules | null, feed
     }
 }
 
-async function withSession(feed: ObservableSource, keystore: Keystore, authorizationRules: AuthorizationRules | null, req: Request, callback: ((j: Jinaga) => Promise<void>)) {
+function createAuthentication(keystore: PostgresKeystore | null, fork: Fork) {
+    return keystore ? new AuthenticationDevice(fork, keystore, localDeviceIdentity) : new AuthenticationNoOp(fork);
+}
+
+async function withSession(feed: ObservableSource, keystore: Keystore | null, authorizationRules: AuthorizationRules | null, req: Request, callback: ((j: Jinaga) => Promise<void>)) {
     const user = <RequestUser>req.user;
     const userIdentity: UserIdentity = {
         provider: user.provider,
         id: user.id
     }
-    const authentication = new AuthenticationSession(feed, keystore, authorizationRules, userIdentity, user.profile.displayName, localDeviceIdentity);
+    const authentication = keystore ? new AuthenticationSession(feed, keystore, authorizationRules, userIdentity, user.profile.displayName, localDeviceIdentity) : new AuthenticationNoOp(feed);
     const syncStatusNotifier = new SyncStatusNotifier();
-    const j = new Jinaga(authentication, new MemoryStore(), syncStatusNotifier);
+    const j = new Jinaga(authentication, syncStatusNotifier);
     await callback(j);
 }

package/src/memory/memory-keystore.ts

@@ -36,9 +36,6 @@ export class MemoryKeystore implements Keystore {
     }
 
     private getOrCreateIdentityFact(type: string, identity: UserIdentity): FactRecord {
-        if (!identity) {
-            return null;
-        }
         const publicKey = this.getOrCreatePublicKey(identity);
         const predecessors: PredecessorCollection = {};
         const fields = {
@@ -49,9 +46,6 @@ export class MemoryKeystore implements Keystore {
     }
 
     private getIdentityFact(type: string, identity: UserIdentity): FactRecord {
-        if (!identity) {
-            return null;
-        }
         const publicKey = this.getPublicKey(identity);
         const predecessors: PredecessorCollection = {};
         const fields = {

package/src/postgres/connection.ts

@@ -31,7 +31,7 @@ export class ConnectionFactory {
         })
     }
 
-    async with<T>(callback: (connection: PoolClient) => Promise<T>) {
+    async with<T>(callback: (connection: PoolClient) => Promise<T>) : Promise<T> {
         let attempt = 0;
         const pause = [0, 0, 1000, 5000, 15000, 30000];
         while (attempt < pause.length) {
@@ -57,6 +57,7 @@ export class ConnectionFactory {
                 await delay(pause[attempt]);
             }
         }
+        throw new Error("Number of attempts exceeded");
     }
 
     private async createClient() {

package/src/postgres/maps.ts

@@ -16,6 +16,14 @@ export function getFactTypeId(map: FactTypeMap, name: string) {
     return map.get(name);
 }
 
+export function ensureGetFactTypeId(factTypes: FactTypeMap, name: string): number {
+    const factTypeId = getFactTypeId(factTypes, name);
+    if (factTypeId === undefined) {
+        throw new Error(`Unknown fact type ${name}`);
+    }
+    return factTypeId;
+}
+
 export function mergeFactTypes(map1: FactTypeMap, map2: FactTypeMap) {
     return new Map<string, number>([...map1, ...map2]);
 }

package/src/postgres/postgres-keystore.ts

@@ -50,9 +50,6 @@ export class PostgresKeystore implements Keystore {
     }
 
     private async getOrCreateIdentityFact(type: string, identity: UserIdentity): Promise<FactRecord> {
-        if (!identity) {
-            return null;
-        }
         const { publicPem } = await this.getOrGenerateKeyPair(identity);
         const predecessors: PredecessorCollection = {};
         const fields = {
@@ -63,9 +60,6 @@ export class PostgresKeystore implements Keystore {
     }
 
     private async getIdentityFact(type: string, identity: UserIdentity): Promise<FactRecord> {
-        if (!identity) {
-            return null;
-        }
         const { publicPem } = await this.getKeyPair(identity);
         const predecessors: PredecessorCollection = {};
         const fields = {
@@ -78,7 +72,7 @@ export class PostgresKeystore implements Keystore {
     private async getKeyPair(userIdentity: UserIdentity): Promise<KeyPair> {
         const key = getUserIdentityKey(userIdentity);
         if (this.cache.has(key)) {
-            return this.cache.get(key);
+            return this.cache.get(key)!;
         }
         const keyPair = await this.connectionFactory.with(connection =>
             this.selectKeyPair(connection, userIdentity));
@@ -105,7 +99,7 @@ export class PostgresKeystore implements Keystore {
     private async getOrGenerateKeyPair(userIdentity: UserIdentity): Promise<KeyPair> {
         const key = getUserIdentityKey(userIdentity);
         if (this.cache.has(key)) {
-            return this.cache.get(key);
+            return this.cache.get(key)!;
         }
         const keyPair = await this.connectionFactory.withTransaction(connection =>
             this.selectOrInsertKeyPair(connection, userIdentity));