jinaga-server 3.1.0 → 3.1.2

package/src/http/router.ts

@@ -1,4 +1,4 @@
-import { Handler, MediaType, Response, Router } from "express";
+import { Handler, NextFunction, Request, Response, Router } from "express";
 import {
     Authorization,
     Declaration,
@@ -11,12 +11,14 @@ import {
     FeedResponse,
     FeedsResponse,
     Forbidden,
+    GraphDeserializer,
+    GraphSerializer,
+    GraphSource,
     LoadMessage,
     LoadResponse,
     ProfileMessage,
     ProjectedResult,
     ReferencesByName,
-    SaveMessage,
     Specification,
     SpecificationParser,
     Trace,
@@ -26,11 +28,11 @@ import {
     computeTupleSubsetHash,
     invertSpecification,
     parseLoadMessage,
-    parseSaveMessage
+    parseSaveMessage,
+    verifyEnvelopes
 } from "jinaga";
-
 import { Stream } from "./stream";
-import { GraphSerializer } from "./serializer";
+import { createLineReader } from "./line-reader";
 
 interface ParsedQs { [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[] }
 
@@ -203,15 +205,12 @@ function postString<U>(method: (user: RequestUser, message: string) => Promise<U
 }
 
 function postCreate<T>(
-    parse: (input: any) => T,
+    parse: (request: Request) => T,
     method: (user: RequestUser, message: T) => Promise<void>
 ): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
-        const message = parse(req.body);
-        if (!message) {
-            throw new Error('Ensure that you have called app.use(express.json()).');
-        }
+        const message = parse(req);
         method(user, message)
             .then(_ => {
                 res.sendStatus(201);
@@ -274,6 +273,29 @@ function serializeUserIdentity(user: RequestUser | null): UserIdentity | null {
     };
 }
 
+function inputSaveMessage(req: Request): GraphSource {
+    if (req.is('application/x-jinaga-graph-v1')) {
+        // Convert the request into a function that reads one line at a time.
+        const readLine = createLineReader(req);
+
+        return new GraphDeserializer(readLine);
+    }
+    else {
+        return {
+            read: async (onEnvelopes) => {
+                const message = parseSaveMessage(req.body);
+                if (!message) {
+                    throw new Error('Ensure that you have called app.use(express.json()).');
+                }
+                await onEnvelopes(message.facts.map(fact => ({
+                    fact: fact,
+                    signatures: []
+                })));
+            }
+        };
+    }
+}
+
 function outputGraph(result: FactEnvelope[], res: Response, accepts: (type: string) => string | false) {
     if (accepts("application/x-jinaga-graph-v1")) {
         res.type("application/x-jinaga-graph-v1");
@@ -306,7 +328,12 @@ export interface RequestUser {
 export class HttpRouter {
     handler: Handler;
 
-    constructor(private factManager: FactManager, private authorization: Authorization, private feedCache: FeedCache) {
+    constructor(
+        private factManager: FactManager,
+        private authorization: Authorization,
+        private feedCache: FeedCache,
+        private allowedOrigin: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void)
+    ) {
         const router = Router();
         router.get('/login', getAuthenticate(user => this.login(user)));
         router.post('/load', post(
@@ -315,8 +342,8 @@ export class HttpRouter {
             outputGraph
         ));
         router.post('/save', postCreate(
-            parseSaveMessage,
-            (user, saveMessage) => this.save(user, saveMessage)
+            inputSaveMessage,
+            (user, graphSource) => this.save(user, graphSource)
         ));
 
         router.post('/read', postString((user, input: string) => this.read(user, input)));
@@ -330,6 +357,30 @@ export class HttpRouter {
             (user, params, query) => this.feed(user, params, query),
             (user, params, query) => this.streamFeed(user, params, query)));
 
+        // Respond to OPTIONS requests to describe the methods and content types
+        // that are supported.
+        this.setOptions(router, '/login')
+            .intendedForGet()
+            .returningContent();
+        this.setOptions(router, '/load')
+            .intendedForPost('application/json')
+            .returningContent();
+        this.setOptions(router, '/save')
+            .intendedForPost('application/json', 'application/x-jinaga-graph-v1')
+            .returningNoContent();
+        this.setOptions(router, '/read')
+            .intendedForPost('text/plain')
+            .returningContent();
+        this.setOptions(router, '/write')
+            .intendedForPost('text/plain')
+            .returningNoContent();
+        this.setOptions(router, '/feeds')
+            .intendedForPost('text/plain')
+            .returningContent();
+        this.setOptions(router, '/feeds/:hash')
+            .intendedForGet()
+            .returningContent();
+
         this.handler = router;
     }
 
@@ -347,17 +398,17 @@ export class HttpRouter {
     private async load(user: RequestUser, loadMessage: LoadMessage): Promise<FactEnvelope[]> {
         const userIdentity = serializeUserIdentity(user);
         const result = await this.authorization.load(userIdentity, loadMessage.references);
-        const facts = result.map(r => r.fact);
         return result;
     }
 
-    private async save(user: RequestUser | null, saveMessage: SaveMessage): Promise<void> {
+    private async save(user: RequestUser | null, graphSource: GraphSource): Promise<void> {
         const userIdentity = serializeUserIdentity(user);
-        await this.authorization.save(userIdentity, saveMessage.facts
-            .map(fact => ({
-                fact: fact,
-                signatures: []
-            })));
+        await graphSource.read(async (envelopes) => {
+            if (!verifyEnvelopes(envelopes)) {
+                throw new Forbidden("The signatures on the facts are invalid.");
+            }
+            await this.authorization.save(userIdentity, envelopes);
+        });
     }
 
     private async read(user: RequestUser | null, input: string): Promise<any[]> {
@@ -550,6 +601,77 @@ export class HttpRouter {
             return declaredFact.declared.reference;
         });
     }
+
+    private setOptions(router: Router, path: string): OptionsConfiguration {
+        const addOptions = (allowedMethods: string[], allowedHeaders: string[], allowedTypes: string[]) => {
+            router.options(path, this.applyAllowOrigin((req, res) => {
+                res.set('Allow', allowedMethods.join(', '));
+                res.set('Access-Control-Allow-Methods', allowedMethods.join(', '));
+                res.set('Access-Control-Allow-Headers', allowedHeaders.join(', '));
+                if (allowedTypes.length > 0) {
+                    res.set('Accept-Post', allowedTypes.join(', '));
+                }
+                res.status(204).send();
+            }));
+        }
+
+        return {
+            intendedForGet: () => {
+                addOptions(['GET', 'OPTIONS'], ['Accept', 'Authorization'], []);
+                return {
+                    returningContent: () => { },
+                    returningNoContent: () => { }
+                };
+            },
+            intendedForPost: (...contentTypes: string[]) => {
+                return {
+                    returningContent: () => {
+                        addOptions(
+                            ['POST', 'OPTIONS'],
+                            ['Content-Type', 'Accept', 'Authorization'],
+                            contentTypes);
+                    },
+                    returningNoContent: () => {
+                        addOptions(
+                            ['POST', 'OPTIONS'],
+                            ['Content-Type', 'Authorization'],
+                            contentTypes);
+                    }
+                };
+            }
+        };
+    }
+
+    private applyAllowOrigin(sendResponse: (req: Request, res: Response) => void) {
+        // Specify the allowed origins.
+        return (req: Request, res: Response, next: NextFunction) => {
+            let requestOrigin = req.get('Origin');
+
+            if (typeof this.allowedOrigin === 'string') {
+                // If allowedOrigin is a string, use it as the value of the Access-Control-Allow-Origin header
+                res.set('Access-Control-Allow-Origin', this.allowedOrigin);
+                sendResponse(req, res);
+            } else if (Array.isArray(this.allowedOrigin)) {
+                // If allowedOrigin is an array, check if the request's origin is in the array
+                if (requestOrigin && this.allowedOrigin.includes(requestOrigin)) {
+                    res.set('Access-Control-Allow-Origin', requestOrigin);
+                }
+                sendResponse(req, res);
+            } else if (typeof this.allowedOrigin === 'function' && requestOrigin) {
+                // If allowedOrigin is a function, call it with the request's origin
+                this.allowedOrigin(requestOrigin, (err, allow) => {
+                    if (err) {
+                        next(err);
+                    } else if (allow) {
+                        res.set('Access-Control-Allow-Origin', requestOrigin);
+                    }
+                    sendResponse(req, res);
+                });
+            } else {
+                sendResponse(req, res);
+            }
+        };
+    }
 }
 
 function parseString(input: any): string {
@@ -573,4 +695,14 @@ function extractResults(obj: any): any {
     else {
         return obj;
     }
+}
+
+interface OptionsConfiguration {
+    intendedForGet(): ResponseConfiguration;
+    intendedForPost(...contentTypes: string[]): ResponseConfiguration;
+}
+
+interface ResponseConfiguration {
+    returningContent(): void;
+    returningNoContent(): void;
 }

package/src/index.ts

@@ -2,6 +2,7 @@ export { AuthenticationDevice } from "./authentication/authentication-device";
 export { AuthenticationSession } from "./authentication/authentication-session";
 export { AuthorizationKeystore } from "./authorization/authorization-keystore";
 export { DistributedFactCache } from "./authorization/distributed-fact-cache";
+export { createLineReader } from "./http/line-reader";
 export { HttpRouter, RequestUser } from "./http/router";
 export { Stream } from "./http/stream";
 export { JinagaServer, JinagaServerConfig, JinagaServerInstance, tracePool } from "./jinaga-server";

package/src/jinaga-server.ts

@@ -38,6 +38,7 @@ export type JinagaServerConfig = {
     model?: Model,
     authorization?: (a: AuthorizationRules) => AuthorizationRules,
     distribution?: (d: DistributionRules) => DistributionRules,
+    origin?: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void),
 };
 
 export type JinagaServerInstance = {
@@ -67,7 +68,7 @@ export class JinagaServer {
         const network = new NetworkNoOp();
         const factManager = new FactManager(fork, source, store, network);
         const authorization = createAuthorization(authorizationRules, distributionRules, factManager, store, keystore);
-        const router = new HttpRouter(factManager, authorization, feedCache);
+        const router = new HttpRouter(factManager, authorization, feedCache, config.origin || '*');
         const j: Jinaga = new Jinaga(authentication, factManager, syncStatusNotifier);
 
         async function close() {

package/src/memory/memory-keystore.ts

@@ -1,10 +1,9 @@
-import { computeHash, FactEnvelope, FactRecord, PredecessorCollection, UserIdentity } from "jinaga";
-import { pki } from "node-forge";
+import { computeHash, FactEnvelope, FactRecord, generateKeyPair, KeyPair, PredecessorCollection, UserIdentity } from "jinaga";
 
 import { Keystore } from "../keystore";
 
 export class MemoryKeystore implements Keystore {
-    private keyPairs: { [key: string]: { publicKey: string, privateKey: string }} = {};
+    private keyPairs: { [key: string]: KeyPair} = {};
 
     getOrCreateUserFact(userIdentity: UserIdentity): Promise<FactRecord> {
         return Promise.resolve(this.getOrCreateIdentityFact('Jinaga.User', userIdentity));
@@ -55,7 +54,7 @@ export class MemoryKeystore implements Keystore {
         const key = `${userIdentity.provider}:${userIdentity.id}`;
         const keyPair = this.keyPairs[key];
         if (keyPair) {
-            return keyPair.publicKey;
+            return keyPair.publicPem;
         }
         else {
             return this.generateKeyPair(key);
@@ -66,7 +65,7 @@ export class MemoryKeystore implements Keystore {
         const key = `${userIdentity.provider}:${userIdentity.id}`;
         const keyPair = this.keyPairs[key];
         if (keyPair) {
-            return keyPair.publicKey;
+            return keyPair.publicPem;
         }
         else {
             throw new Error("Public key not found");
@@ -74,10 +73,8 @@ export class MemoryKeystore implements Keystore {
     }
 
     private generateKeyPair(key: string) {
-        const keypair = pki.rsa.generateKeyPair({ bits: 1024 });
-        const privateKey = pki.privateKeyToPem(keypair.privateKey);
-        const publicKey = pki.publicKeyToPem(keypair.publicKey);
-        this.keyPairs[key] = { publicKey, privateKey };
-        return publicKey;
+        const keyPair = generateKeyPair();
+        this.keyPairs[key] = keyPair;
+        return keyPair.privatePem;
     }
 }

package/src/postgres/postgres-keystore.ts

@@ -1,15 +1,9 @@
-import { canonicalizeFact, computeHash, FactEnvelope, FactRecord, PredecessorCollection, Trace, UserIdentity } from "jinaga";
-import { md, pki, util } from "node-forge";
+import { computeHash, FactEnvelope, FactRecord, generateKeyPair, KeyPair, PredecessorCollection, signFacts, UserIdentity } from "jinaga";
 import { Pool, PoolClient } from "pg";
 
 import { Keystore } from "../keystore";
 import { ConnectionFactory } from "./connection";
 
-interface KeyPair {
-    publicPem: string;
-    privatePem: string;
-};
-
 export class PostgresKeystore implements Keystore {
     private connectionFactory: ConnectionFactory;
     private cache: Map<string, KeyPair> = new Map();
@@ -39,10 +33,8 @@ export class PostgresKeystore implements Keystore {
             return facts.map(fact => ({ fact, signatures: [] }));
         }
         
-        const { publicPem, privatePem } = await this.getKeyPair(userIdentity);
-        const privateKey = <pki.rsa.PrivateKey>pki.privateKeyFromPem(privatePem);
-        const envelopes: FactEnvelope[] = facts.map(fact => signFact(fact, publicPem, privateKey));
-        return envelopes;
+        const keyPair = await this.getKeyPair(userIdentity);
+        return signFacts(keyPair, facts);
     }
 
     private async getOrCreateIdentityFact(type: string, identity: UserIdentity): Promise<FactRecord> {
@@ -121,37 +113,13 @@ export class PostgresKeystore implements Keystore {
     }
 
     private async generateKeyPair(connection: PoolClient, userIdentity: UserIdentity): Promise<KeyPair> {
-        const keypair = pki.rsa.generateKeyPair({ bits: 2048 });
-        const privatePem = pki.privateKeyToPem(keypair.privateKey);
-        const publicPem = pki.publicKeyToPem(keypair.publicKey);
+        const keyPair = generateKeyPair();
         await connection.query(`INSERT INTO ${this.schema}.user (provider, user_identifier, private_key, public_key) VALUES ($1, $2, $3, $4)`,
-            [userIdentity.provider, userIdentity.id, privatePem, publicPem]);
-        return { publicPem, privatePem };
+            [userIdentity.provider, userIdentity.id, keyPair.privatePem, keyPair.publicPem]);
+        return keyPair;
     }
 }
 
 function getUserIdentityKey(userIdentity: UserIdentity) {
     return `${userIdentity.provider}-${userIdentity.id}`;
 }
-
-function signFact(fact: FactRecord, publicPem: string, privateKey: pki.rsa.PrivateKey): FactEnvelope {
-    const canonicalString = canonicalizeFact(fact.fields, fact.predecessors);
-    const encodedString = util.encodeUtf8(canonicalString);
-    const digest = md.sha512.create().update(encodedString);
-    const hash = util.encode64(digest.digest().getBytes());
-    if (fact.hash !== hash) {
-        Trace.error(`Hash does not match. "${fact.hash}" !== "${hash}"\nFact: ${canonicalString}`);
-        return {
-            fact,
-            signatures: []
-        };
-    }
-    const signature = util.encode64(privateKey.sign(digest));
-    return {
-        fact,
-        signatures: [{
-            signature,
-            publicKey: publicPem
-        }]
-    };
-}

package/dist/http/serializer.d.ts

@@ -1,11 +0,0 @@
-import { FactEnvelope } from "jinaga";
-export declare class GraphSerializer {
-    private readonly write;
-    private index;
-    private indexByFactReference;
-    private publicKeys;
-    constructor(write: (chunk: string) => void);
-    serialize(result: FactEnvelope[]): void;
-    private getPredecessorIndexes;
-    private getFactIndex;
-}

package/dist/http/serializer.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphSerializer = void 0;
-class GraphSerializer {
-    constructor(write) {
-        this.write = write;
-        this.index = 0;
-        this.indexByFactReference = {};
-        this.publicKeys = [];
-    }
-    serialize(result) {
-        // Write the facts
-        for (const fact of result) {
-            // Skip facts that have already been written
-            const key = fact.fact.type + ":" + fact.fact.hash;
-            if (this.indexByFactReference.hasOwnProperty(key)) {
-                continue;
-            }
-            // Write any new public keys
-            for (const signature of fact.signatures) {
-                if (!this.publicKeys.includes(signature.publicKey)) {
-                    const pkIndex = this.publicKeys.length;
-                    const publicKey = JSON.stringify(signature.publicKey);
-                    this.write(`PK${pkIndex.toString()}\n${publicKey}\n\n`);
-                    this.publicKeys.push(signature.publicKey);
-                }
-            }
-            // Write the fact
-            const factType = JSON.stringify(fact.fact.type);
-            const predecessorIndexes = JSON.stringify(this.getPredecessorIndexes(fact.fact.predecessors));
-            const factFields = JSON.stringify(fact.fact.fields);
-            let output = `${factType}\n${predecessorIndexes}\n${factFields}`;
-            // Write the signatures
-            for (const signature of fact.signatures) {
-                const publicKeyIndex = this.publicKeys.indexOf(signature.publicKey);
-                const publicKey = `PK${publicKeyIndex.toString()}`;
-                const signatureString = JSON.stringify(signature.signature);
-                output += `\n${publicKey}\n${signatureString}`;
-            }
-            output += "\n\n";
-            this.write(output);
-            this.indexByFactReference[key] = this.index;
-            this.index++;
-        }
-    }
-    getPredecessorIndexes(predecessors) {
-        const result = {};
-        for (const role in predecessors) {
-            const reference = predecessors[role];
-            if (Array.isArray(reference)) {
-                result[role] = reference.map(r => this.getFactIndex(r));
-            }
-            else {
-                result[role] = this.getFactIndex(reference);
-            }
-        }
-        return result;
-    }
-    getFactIndex(reference) {
-        const key = reference.type + ":" + reference.hash;
-        if (!this.indexByFactReference.hasOwnProperty(key)) {
-            throw new Error(`Fact reference not found in graph: ${key}`);
-        }
-        return this.indexByFactReference[key];
-    }
-}
-exports.GraphSerializer = GraphSerializer;
-//# sourceMappingURL=serializer.js.map

package/dist/http/serializer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializer.js","sourceRoot":"","sources":["../../src/http/serializer.ts"],"names":[],"mappings":"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"}

package/src/http/serializer.ts

@@ -1,81 +0,0 @@
-import { FactEnvelope, FactReference, PredecessorCollection } from "jinaga";
-
-type IndexPredecessorCollection = {
-    [role: string]: number | number[];
-};
-
-export class GraphSerializer
-{
-    private index = 0;
-    private indexByFactReference: { [key: string]: number } = {};
-    private publicKeys: string[] = [];
-
-    constructor(
-        private readonly write: (chunk: string) => void
-    ) {}
-
-    serialize(result: FactEnvelope[]) {
-        // Write the facts
-        for (const fact of result) {
-            // Skip facts that have already been written
-            const key = fact.fact.type + ":" + fact.fact.hash;
-            if (this.indexByFactReference.hasOwnProperty(key)) {
-                continue;
-            }
-
-            // Write any new public keys
-            for (const signature of fact.signatures) {
-                if (!this.publicKeys.includes(signature.publicKey)) {
-                    const pkIndex = this.publicKeys.length;
-                    const publicKey = JSON.stringify(signature.publicKey);
-                    this.write(`PK${pkIndex.toString()}\n${publicKey}\n\n`);
-                    this.publicKeys.push(signature.publicKey);
-                }
-            }
-
-            // Write the fact
-            const factType = JSON.stringify(fact.fact.type);
-            const predecessorIndexes = JSON.stringify(this.getPredecessorIndexes(fact.fact.predecessors));
-            const factFields = JSON.stringify(fact.fact.fields);
-
-            let output = `${factType}\n${predecessorIndexes}\n${factFields}`;
-
-            // Write the signatures
-            for (const signature of fact.signatures) {
-                const publicKeyIndex = this.publicKeys.indexOf(signature.publicKey);
-                const publicKey = `PK${publicKeyIndex.toString()}`;
-                const signatureString = JSON.stringify(signature.signature);
-
-                output += `\n${publicKey}\n${signatureString}`;
-            }
-
-            output += "\n\n";
-
-            this.write(output);
-
-            this.indexByFactReference[key] = this.index;
-            this.index++;
-        }
-    }
-
-    private getPredecessorIndexes(predecessors: PredecessorCollection): IndexPredecessorCollection {
-        const result: IndexPredecessorCollection = {};
-        for (const role in predecessors) {
-            const reference = predecessors[role];
-            if (Array.isArray(reference)) {
-                result[role] = reference.map(r => this.getFactIndex(r));
-            } else {
-                result[role] = this.getFactIndex(reference);
-            }
-        }
-        return result;
-    }
-
-    private getFactIndex(reference: FactReference): number {
-        const key = reference.type + ":" + reference.hash;
-        if (!this.indexByFactReference.hasOwnProperty(key)) {
-            throw new Error(`Fact reference not found in graph: ${key}`);
-        }
-        return this.indexByFactReference[key];
-    }
-}