jinaga-server 1.0.0

package/src/http/node-http.ts

@@ -0,0 +1,106 @@
+import * as http from "http";
+import * as https from "https";
+import { HttpConnection, HttpResponse } from "jinaga";
+import * as url from "url";
+
+export class NodeHttpConnection implements HttpConnection {
+    constructor(
+        private url: string) {
+    }
+
+    get(path: string): Promise<{}> {
+        return new Promise<{}>((resolve, reject) => {
+            const { protocol } = url.parse(this.url + path);
+            const get = protocol === "https:" ? https.get : http.get;
+            let data = "";
+            get(this.url + path, response => {
+                response.on("data", chunk => {
+                    data += chunk;
+                });
+
+                response.on("end", () => {
+                    try {
+                        const result = JSON.parse(data);
+                        resolve(result);
+                    }
+                    catch (x) {
+                        reject(x);
+                    }
+                });
+            }).on("error", err => reject(err));
+        });
+    }
+    
+    post(tail: string, body: {}, timeoutSeconds: number): Promise<HttpResponse> {
+        return new Promise<HttpResponse>((resolve, reject) => {
+            const { protocol, host, port, path } = url.parse(this.url + tail);
+            const request = protocol === "https:" ? https.request : http.request;
+            let response = "";
+            const req = request({
+                method: "POST",
+                host, port, path,
+                headers: {
+                    "Accept": "application/json",
+                    "Content-Type": "application/json"
+                },
+                timeout: timeoutSeconds * 1000
+            }, res => {
+                res.on("data", chunk => {
+                    if (chunk instanceof Buffer) {
+                        response += chunk.toString();
+                    }
+                    else {
+                        response += chunk;
+                    }
+                });
+                res.on("error", err => {
+                    resolve({
+                        result: "failure",
+                        error: err.message
+                    });
+                });
+                res.on("end", () => {
+                    if (res.statusCode === 403) {
+                        reject(response);
+                    }
+                    else if (res.statusCode>= 400) {
+                        resolve({
+                            result: "retry",
+                            error: response
+                        });
+                    }
+                    else if (isJsonResult(res.headers["content-type"])) {
+                        try {
+                            const json = JSON.parse(response);
+                            resolve({
+                                result: "success",
+                                response: json
+                            });
+                        }
+                        catch (x) {
+                            reject(x);
+                        }
+                    }
+                    else {
+                        reject(response);
+                    }
+                });
+            });
+
+            req.on("error", err => {
+                resolve({
+                    result: "failure",
+                    error: err.message
+                });
+            });
+
+            req.write(JSON.stringify(body));
+            req.end();
+        });
+    }
+}
+
+function isJsonResult(contentType: string) {
+    const json = contentType.split(";").indexOf("application/json");
+    return json >= 0;
+}

package/src/http/router.ts

@@ -0,0 +1,237 @@
+import { Handler, Router } from "express";
+import {
+    Authorization,
+    Declaration,
+    FactRecord,
+    Forbidden,
+    fromDescriptiveString,
+    LoadMessage,
+    LoadResponse,
+    ProfileMessage,
+    QueryMessage,
+    QueryResponse,
+    SaveMessage,
+    SaveResponse,
+    SpecificationParser,
+    Trace,
+    UserIdentity,
+} from "jinaga";
+
+function get<U>(method: ((req: RequestUser) => Promise<U>)): Handler {
+    return (req, res, next) => {
+        const user = <RequestUser>req.user;
+        if (!user) {
+            res.sendStatus(401);
+        }
+        else {
+            method(user)
+                .then(response => {
+                    res.setHeader('Content-Type', 'application/json');
+                    res.send(JSON.stringify(response));
+                    next();
+                })
+                .catch(error => {
+                    Trace.error(error);
+                    res.sendStatus(500);
+                    next();
+                });
+        }
+    };
+}
+
+function post<T, U>(method: (user: RequestUser, message: T) => Promise<U>): Handler {
+    return (req, res, next) => {
+        const user = <RequestUser>req.user;
+        const message = <T>req.body;
+        if (!message) {
+            throw new Error('Ensure that you have called app.use(express.json()).');
+        }
+        method(user, message)
+            .then(response => {
+                res.setHeader('Content-Type', 'application/json');
+                res.send(JSON.stringify(response));
+                next();
+            })
+            .catch(error => {
+                if (error instanceof Forbidden) {
+                    Trace.warn(error.message);
+                    res.setHeader('Content-Type', 'text/plain');
+                    res.status(403).send(error.message);
+                }
+                else {
+                    Trace.error(error);
+                    res.setHeader('Content-Type', 'text/plain');
+                    res.sendStatus(500).send(error.message);
+                }
+                next();
+            });
+    };
+}
+
+function postString<U>(method: (user: RequestUser, message: string) => Promise<U>): Handler {
+    return (req, res, next) => {
+        const user = <RequestUser>req.user;
+        const input = <string>req.body;
+        if (!input || typeof(input) !== 'string') {
+            res.setHeader('Content-Type', 'text/plain');
+            res.status(500).send('Expected Content-Type text/plain. Ensure that you have called app.use(express.text()).');
+        }
+        else {
+            method(user, input)
+                .then(response => {
+                    res.setHeader('Content-Type', 'application/json');
+                    res.send(JSON.stringify(response, null, 2));
+                    next();
+                })
+                .catch(error => {
+                    if (error instanceof Forbidden) {
+                        Trace.warn(error.message);
+                        res.setHeader('Content-Type', 'text/plain');
+                        res.status(403).send(error.message);
+                    }
+                    else {
+                        Trace.error(error);
+                        res.setHeader('Content-Type', 'text/plain');
+                        res.status(400).send(error.message);
+                    }
+                    next();
+                });
+        }
+    };
+}
+
+function serializeUserIdentity(user: RequestUser) : UserIdentity {
+    if (!user) {
+        return null;
+    }
+    return {
+        provider: user.provider,
+        id: user.id
+    };
+}
+
+export interface RequestUser {
+    provider: string;
+    id: string;
+    profile: ProfileMessage;
+}
+
+export class HttpRouter {
+    handler: Handler;
+
+    constructor(private authorization: Authorization) {
+        const router = Router();
+        router.get('/login', get(user => this.login(user)));
+        router.post('/query', post((user, queryMessage: QueryMessage) => this.query(user, queryMessage)));
+        router.post('/load', post((user, loadMessage: LoadMessage) => this.load(user, loadMessage)));
+        router.post('/save', post((user, saveMessage: SaveMessage) => this.save(user, saveMessage)));
+
+        router.post('/read', postString((user, input: string) => this.read(user, input)));
+        router.post('/write', post((user, input: string) => this.write(user, input)));
+        router.post('/feed', post((user, input: string) => this.feed(user, input)));
+
+        this.handler = router;
+    }
+
+    private async login(user: RequestUser) {
+        const userFact = await this.authorization.getOrCreateUserFact({
+            provider: user.provider,
+            id: user.id
+        });
+        return {
+            userFact: userFact,
+            profile: user.profile
+        };
+    }
+
+    private async query(user: RequestUser, queryMessage: QueryMessage) : Promise<QueryResponse> {
+        const userIdentity = serializeUserIdentity(user);
+        const query = fromDescriptiveString(queryMessage.query);
+        const result = await this.authorization.query(userIdentity, queryMessage.start, query);
+        return {
+            results: result
+        };
+    }
+
+    private async load(user: RequestUser, loadMessage: LoadMessage) : Promise<LoadResponse> {
+        const userIdentity = serializeUserIdentity(user);
+        const result = await this.authorization.load(userIdentity, loadMessage.references);
+        return {
+            facts: result
+        };
+    }
+
+    private async save(user: RequestUser, saveMessage: SaveMessage) : Promise<SaveResponse> {
+        const userIdentity = serializeUserIdentity(user);
+        await this.authorization.save(userIdentity, saveMessage.facts);
+        return {};
+    }
+
+    private async read(user: RequestUser, input: string): Promise<any[]> {
+        const knownFacts = await this.getKnownFacts(user);
+        const parser = new SpecificationParser(input);
+        parser.skipWhitespace();
+        var declaration = parser.parseDeclaration(knownFacts);
+        var specification = parser.parseSpecification();
+
+        // Select starting facts that match the inputs
+        const start = specification.given.map(input => {
+            const declaredFact = declaration.find(d => d.name === input.name);
+            if (!declaredFact) {
+                throw new Error(`No fact named ${input.name} was declared`);
+            }
+            return declaredFact.declared.reference;
+        });
+
+        const userIdentity = serializeUserIdentity(user);
+        const results = await this.authorization.read(userIdentity, start, specification);
+        return results;
+    }
+
+    private async write(user: RequestUser, input: string): Promise<SaveResponse> {
+        const knownFacts = await this.getKnownFacts(user);
+        const parser = new SpecificationParser(input);
+        parser.skipWhitespace();
+        var declaration = parser.parseDeclaration(knownFacts);
+
+        const factRecords: FactRecord[] = [];
+        for (const value of declaration) {
+            if (!value.declared.fact) {
+                throw new Error("References are not allowed while saving.");
+            }
+            factRecords.push(value.declared.fact);
+        }
+
+        const userIdentity = serializeUserIdentity(user);
+        await this.authorization.save(userIdentity, factRecords);
+        return {};
+    }
+
+    private feed(user: RequestUser, input: string): Promise<string> {
+        throw new Error("Method not implemented.");
+    }
+
+    private async getKnownFacts(user: RequestUser): Promise<Declaration> {
+        if (user) {
+            const userFact = await this.authorization.getOrCreateUserFact({
+                provider: user.provider,
+                id: user.id
+            });
+            return [
+                {
+                    name: "me",
+                    declared: {
+                        fact: userFact,
+                        reference: {
+                            type: userFact.type,
+                            hash: userFact.hash
+                        }
+                    }
+                }
+            ];
+        }
+        else {
+            return [];
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { JinagaServer, JinagaServerConfig, JinagaServerInstance } from "./jinaga-server";

package/src/jinaga-server.ts

@@ -0,0 +1,125 @@
+import { Handler, Request } from "express";
+import {
+    Authorization,
+    AuthorizationNoOp,
+    AuthorizationRules,
+    Cache,
+    Feed,
+    FeedImpl,
+    Fork,
+    Jinaga,
+    MemoryStore,
+    PassThroughFork,
+    Storage,
+    SyncStatusNotifier,
+    TransientFork,
+    UserIdentity,
+    WebClient,
+} from "jinaga";
+
+import { AuthenticationDevice } from "./authentication/authentication-device";
+import { AuthenticationSession } from "./authentication/authentication-session";
+import { AuthorizationKeystore } from "./authorization/authorization-keystore";
+import { NodeHttpConnection } from "./http/node-http";
+import { HttpRouter, RequestUser } from "./http/router";
+import { Keystore } from "./keystore";
+import { PostgresKeystore } from "./postgres/postgres-keystore";
+import { PostgresStore } from "./postgres/postgres-store";
+
+
+export type JinagaServerConfig = {
+    pgStore?: string,
+    pgKeystore?: string,
+    httpEndpoint?: string,
+    authorization?: (a: AuthorizationRules) => AuthorizationRules,
+    httpTimeoutSeconds?: number
+};
+
+export type JinagaServerInstance = {
+    handler: Handler,
+    j: Jinaga,
+    withSession: (req: Request, callback: ((j: Jinaga) => Promise<void>)) => Promise<void>,
+    close: () => Promise<void>
+};
+
+const localDeviceIdentity = {
+    provider: 'jinaga',
+    id: 'local'
+};
+
+export class JinagaServer {
+    static create(config: JinagaServerConfig): JinagaServerInstance {
+        const syncStatusNotifier = new SyncStatusNotifier();
+        const store = createStore(config);
+        const feed = new FeedImpl(store);
+        const fork = createFork(config, feed, syncStatusNotifier);
+        const keystore = new PostgresKeystore(config.pgKeystore);
+        const authorizationRules = config.authorization ? config.authorization(new AuthorizationRules()) : null;
+        const authorization = createAuthorization(authorizationRules, fork, keystore);
+        const router = new HttpRouter(authorization);
+        const authentication = new AuthenticationDevice(fork, keystore, localDeviceIdentity);
+        const memory = new MemoryStore();
+        const j: Jinaga = new Jinaga(authentication, memory, syncStatusNotifier);
+
+        async function close() {
+            await keystore.close();
+            await store.close();
+        }
+        return {
+            handler: router.handler,
+            j,
+            withSession: (req, callback) => {
+                return withSession(feed, keystore, authorizationRules, req, callback);
+            },
+            close
+        }
+    }
+}
+
+function createStore(config: JinagaServerConfig): Storage {
+    if (config.pgStore) {
+        const store = new PostgresStore(config.pgStore);
+        const cache = new Cache(store);
+        return cache;
+    }
+    else {
+        return new MemoryStore();
+    }
+}
+
+function createFork(config: JinagaServerConfig, feed: Feed, syncStatusNotifier: SyncStatusNotifier): Fork {
+    if (config.httpEndpoint) {
+        const httpConnection = new NodeHttpConnection(config.httpEndpoint);
+        const httpTimeoutSeconds = config.httpTimeoutSeconds || 5;
+        const webClient = new WebClient(httpConnection, syncStatusNotifier, {
+            timeoutSeconds: httpTimeoutSeconds
+        });
+        const fork = new TransientFork(feed, webClient);
+        return fork;
+    }
+    else {
+        return new PassThroughFork(feed);
+    }
+}
+
+function createAuthorization(authorizationRules: AuthorizationRules | null, feed: Feed, keystore: Keystore | null): Authorization {
+    if (keystore) {
+        const authorization = new AuthorizationKeystore(feed, keystore, authorizationRules);
+        return authorization;
+    }
+    else {
+        return new AuthorizationNoOp(feed);
+    }
+}
+
+async function withSession(feed: Feed, keystore: Keystore, 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 syncStatusNotifier = new SyncStatusNotifier();
+    const j = new Jinaga(authentication, new MemoryStore(), syncStatusNotifier);
+    await callback(j);
+}

package/src/keystore.ts

@@ -0,0 +1,10 @@
+import { FactEnvelope, FactRecord, UserIdentity } from "jinaga";
+
+export interface Keystore {
+    close(): Promise<void>;
+    getOrCreateUserFact(userIdentity: UserIdentity): Promise<FactRecord>;
+    getOrCreateDeviceFact(userIdentity: UserIdentity): Promise<FactRecord>;
+    getUserFact(userIdentity: UserIdentity): Promise<FactRecord>;
+    getDeviceFact(userIdentity: UserIdentity): Promise<FactRecord>;
+    signFacts(userIdentity: UserIdentity, facts: FactRecord[]): Promise<FactEnvelope[]>;
+}

package/src/memory/memory-keystore.ts

@@ -0,0 +1,93 @@
+import { computeHash, FactEnvelope, FactRecord, PredecessorCollection, UserIdentity } from "jinaga";
+import { pki } from "node-forge";
+
+import { Keystore } from "../keystore";
+
+export class MemoryKeystore implements Keystore {
+    private keyPairs: { [key: string]: { publicKey: string, privateKey: string }} = {};
+
+    close(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    getOrCreateUserFact(userIdentity: UserIdentity): Promise<FactRecord> {
+        return Promise.resolve(this.getOrCreateIdentityFact('Jinaga.User', userIdentity));
+    }
+    
+    getOrCreateDeviceFact(userIdentity: UserIdentity): Promise<FactRecord> {
+        return Promise.resolve(this.getOrCreateIdentityFact('Jinaga.Device', userIdentity));
+    }
+
+    getUserFact(userIdentity: UserIdentity): Promise<FactRecord> {
+        return Promise.resolve(this.getIdentityFact('Jinaga.User', userIdentity));
+    }
+    
+    getDeviceFact(userIdentity: UserIdentity): Promise<FactRecord> {
+        return Promise.resolve(this.getIdentityFact('Jinaga.Device', userIdentity));
+    }
+
+    signFacts(userIdentity: UserIdentity, facts: FactRecord[]): Promise<FactEnvelope[]> {
+        return Promise.resolve(facts.map(fact => {
+            return {
+                fact,
+                signatures: []
+            };
+        }));
+    }
+
+    private getOrCreateIdentityFact(type: string, identity: UserIdentity): FactRecord {
+        if (!identity) {
+            return null;
+        }
+        const publicKey = this.getOrCreatePublicKey(identity);
+        const predecessors: PredecessorCollection = {};
+        const fields = {
+            publicKey: publicKey
+        };
+        const hash = computeHash(fields, predecessors);
+        return { type, hash, predecessors, fields };
+    }
+
+    private getIdentityFact(type: string, identity: UserIdentity): FactRecord {
+        if (!identity) {
+            return null;
+        }
+        const publicKey = this.getPublicKey(identity);
+        const predecessors: PredecessorCollection = {};
+        const fields = {
+            publicKey: publicKey
+        };
+        const hash = computeHash(fields, predecessors);
+        return { type, hash, predecessors, fields };
+    }
+
+    private getOrCreatePublicKey(userIdentity: UserIdentity): string {
+        const key = `${userIdentity.provider}:${userIdentity.id}`;
+        const keyPair = this.keyPairs[key];
+        if (keyPair) {
+            return keyPair.publicKey;
+        }
+        else {
+            return this.generateKeyPair(key);
+        }
+    }
+
+    private getPublicKey(userIdentity: UserIdentity): string {
+        const key = `${userIdentity.provider}:${userIdentity.id}`;
+        const keyPair = this.keyPairs[key];
+        if (keyPair) {
+            return keyPair.publicKey;
+        }
+        else {
+            throw new Error("Public key not found");
+        }
+    }
+
+    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;
+    }
+}

package/src/postgres/connection.ts

@@ -0,0 +1,73 @@
+import { Pool, PoolClient } from 'pg';
+import { delay } from "../util/promise";
+
+export type Row = { [key: string]: any };
+
+export class ConnectionFactory {
+    private postgresPool: Pool;
+
+    constructor (postgresUri: string) {
+        this.postgresPool = new Pool({
+            connectionString: postgresUri
+        });
+    }
+
+    async close() {
+        await this.postgresPool.end();
+    }
+
+    withTransaction<T>(callback: (connection: PoolClient) => Promise<T>) {
+        return this.with(async connection => {
+            try {
+                await connection.query('BEGIN');
+                const result = await callback(connection);
+                await connection.query('COMMIT');
+                return result;
+            }
+            catch (e) {
+                await connection.query('ROLLBACK');
+                throw e;
+            }
+        })
+    }
+
+    async with<T>(callback: (connection: PoolClient) => Promise<T>) {
+        let attempt = 0;
+        const pause = [0, 0, 1000, 5000, 15000, 30000];
+        while (attempt < pause.length) {
+            try {
+                const client = await this.createClient();
+                try {
+                    return await callback(client);
+                }
+                finally {
+                    client.release();
+                }
+            }
+            catch (e) {
+                if (!isTransientError(e)) {
+                    throw e;
+                }
+                attempt++;
+                if (attempt === pause.length) {
+                    throw e;
+                }
+            }
+            if (pause[attempt] > 0) {
+                await delay(pause[attempt]);
+            }
+        }
+    }
+
+    private async createClient() {
+        return await this.postgresPool.connect();
+    }
+}
+
+function isTransientError(e: any) {
+    if (e.code === 'ECONNREFUSED') {
+        return true;
+    }
+    console.error("Postgres error:", e);
+    return false;
+}

package/src/postgres/edge-record.ts

@@ -0,0 +1,36 @@
+import { FactRecord, FactReference } from "jinaga";
+
+export type EdgeRecord = {
+    predecessor_hash: string,
+    predecessor_type: string,
+    successor_hash: string,
+    successor_type: string,
+    role: string
+};
+
+function makeEdgeRecord(predecessor: FactReference, successor: FactRecord, role: string): EdgeRecord {
+    if (!predecessor.hash || !predecessor.type || !successor.hash || !successor.type) {
+        throw new Error('Attempting to save edge with null hash or type.');
+    }
+    return {
+        predecessor_hash: predecessor.hash,
+        predecessor_type: predecessor.type,
+        successor_hash: successor.hash,
+        successor_type: successor.type,
+        role
+    };
+}
+
+export function makeEdgeRecords(fact: FactRecord): EdgeRecord[] {
+    let records: EdgeRecord[] = [];
+    for (const role in fact.predecessors) {
+        const predecessor = fact.predecessors[role];
+        if (Array.isArray(predecessor)) {
+            records = records.concat(predecessor.map(p => makeEdgeRecord(p, fact, role)));
+        }
+        else {
+            records.push(makeEdgeRecord(predecessor, fact, role));
+        }
+    }
+    return records;
+}