jinaga-server 1.0.0

package/src/postgres/maps.ts

@@ -0,0 +1,89 @@
+export type FactTypeMap = Map<string, number>;
+
+export function emptyFactTypeMap() {
+    return new Map<string, number>();
+}
+
+export function copyFactTypeMap(map: FactTypeMap) {
+    return new Map<string, number>(map);
+}
+
+export function addFactType(map: FactTypeMap, name: string, fact_type_id: number) {
+    return map.set(name, fact_type_id);
+}
+
+export function getFactTypeId(map: FactTypeMap, name: string) {
+    return map.get(name);
+}
+
+export function mergeFactTypes(map1: FactTypeMap, map2: FactTypeMap) {
+    return new Map<string, number>([...map1, ...map2]);
+}
+
+export type RoleMap = Map<number, Map<string, number>>;
+
+export function emptyRoleMap() {
+    return new Map<number, Map<string, number>>();
+}
+
+export function copyRoleMap(map: RoleMap) {
+    return new Map<number, Map<string, number>>(map);
+}
+
+export function addRole(map: RoleMap, defining_fact_type_id: number, name: string, role_id: number) {
+    const factTypeRoles = map.get(defining_fact_type_id) || new Map<string, number>();
+    const modifiedFactTypeRoles = factTypeRoles.set(name, role_id);
+    return map.set(defining_fact_type_id, modifiedFactTypeRoles);
+}
+
+export function hasRole(map: RoleMap, defining_fact_type_id: number, name: string) {
+    const roleMap = map.get(defining_fact_type_id);
+    return roleMap && roleMap.has(name);
+}
+
+export function getRoleId(map: RoleMap, defining_fact_type_id: number, name: string) {
+    const roleMap = map.get(defining_fact_type_id);
+    return roleMap && roleMap.get(name);
+}
+
+export function mergeRoleMaps(map1: RoleMap, map2: RoleMap) {
+    let merged = new Map<number, Map<string, number>>(map1);
+    for (const [defining_fact_type_id, roleMap] of map2) {
+        const mergedRoleMap = merged.get(defining_fact_type_id) || new Map<string, number>();
+        const mergedFactTypeRoles = new Map<string, number>([...mergedRoleMap, ...roleMap]);
+        merged = merged.set(defining_fact_type_id, mergedFactTypeRoles);
+    }
+    return merged;
+}
+
+export type FactMap = Map<string, Map<number, number>>;
+
+export function emptyFactMap() {
+    return new Map<string, Map<number, number>>();
+}
+
+export function addFact(map: FactMap, hash: string, fact_type_id: number, fact_id: number) {
+    const typeMap = map.get(hash) || new Map<number, number>();
+    const modifiedTypeMap = typeMap.set(fact_type_id, fact_id);
+    return map.set(hash, modifiedTypeMap);
+}
+
+export function hasFact(map: FactMap, hash: string, fact_type_id: number) {
+    const typeMap = map.get(hash);
+    return typeMap && typeMap.has(fact_type_id);
+}
+
+export function getFactId(map: FactMap, hash: string, fact_type_id: number) {
+    const typeMap = map.get(hash) || new Map<number, number>();
+    return typeMap.get(fact_type_id);
+}
+
+export type PublicKeyMap = Map<string, number>;
+
+export function emptyPublicKeyMap() {
+    return new Map<string, number>();
+}
+
+export function getPublicKeyId(publicKeyMap: PublicKeyMap, publicKey: string) {
+    return publicKeyMap.get(publicKey);
+}

package/src/postgres/postgres-keystore.ts

@@ -0,0 +1,167 @@
+import { canonicalizeFact, computeHash, FactEnvelope, FactRecord, PredecessorCollection, Trace, UserIdentity } from "jinaga";
+import { md, pki, util } from "node-forge";
+import { 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();
+
+    constructor (postgresUri: string) {
+        this.connectionFactory = new ConnectionFactory(postgresUri);
+    }
+
+    async close() {
+        await this.connectionFactory.close();
+    }
+
+    getOrCreateUserFact(userIdentity: UserIdentity): Promise<FactRecord> {
+        return this.getOrCreateIdentityFact('Jinaga.User', userIdentity);
+    }
+
+    getOrCreateDeviceFact(deviceIdentity: UserIdentity): Promise<FactRecord> {
+        return this.getOrCreateIdentityFact('Jinaga.Device', deviceIdentity);
+    }
+
+    getUserFact(userIdentity: UserIdentity): Promise<FactRecord> {
+        return this.getIdentityFact('Jinaga.User', userIdentity);
+    }
+
+    getDeviceFact(deviceIdentity: UserIdentity): Promise<FactRecord> {
+        return this.getIdentityFact('Jinaga.Device', deviceIdentity);
+    }
+
+    async signFacts(userIdentity: UserIdentity, facts: FactRecord[]): Promise<FactEnvelope[]> {
+        if (!userIdentity) {
+            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;
+    }
+
+    private async getOrCreateIdentityFact(type: string, identity: UserIdentity): Promise<FactRecord> {
+        if (!identity) {
+            return null;
+        }
+        const { publicPem } = await this.getOrGenerateKeyPair(identity);
+        const predecessors: PredecessorCollection = {};
+        const fields = {
+            publicKey: publicPem
+        };
+        const hash = computeHash(fields, predecessors);
+        return { type, hash, predecessors, fields };
+    }
+
+    private async getIdentityFact(type: string, identity: UserIdentity): Promise<FactRecord> {
+        if (!identity) {
+            return null;
+        }
+        const { publicPem } = await this.getKeyPair(identity);
+        const predecessors: PredecessorCollection = {};
+        const fields = {
+            publicKey: publicPem
+        };
+        const hash = computeHash(fields, predecessors);
+        return { type, hash, predecessors, fields };
+    }
+
+    private async getKeyPair(userIdentity: UserIdentity): Promise<KeyPair> {
+        const key = getUserIdentityKey(userIdentity);
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const keyPair = await this.connectionFactory.with(connection =>
+            this.selectKeyPair(connection, userIdentity));
+        this.cache.set(key, keyPair);
+        return keyPair;
+    }
+
+    private async selectKeyPair(connection: PoolClient, userIdentity: UserIdentity): Promise<KeyPair> {
+        const { rows } = await connection.query('SELECT public_key, private_key FROM public.user WHERE provider = $1 AND user_identifier = $2',
+            [userIdentity.provider, userIdentity.id]);
+        if (rows.length > 1) {
+            throw new Error('Duplicate entries found in the keystore');
+        }
+        else if (rows.length === 1) {
+            const publicPem = <string>rows[0]["public_key"];
+            const privatePem = rows[0]["private_key"];
+            return { publicPem, privatePem };
+        }
+        else {
+            throw new Error('No entry found in the keystore');
+        }
+    }
+
+    private async getOrGenerateKeyPair(userIdentity: UserIdentity): Promise<KeyPair> {
+        const key = getUserIdentityKey(userIdentity);
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const keyPair = await this.connectionFactory.withTransaction(connection =>
+            this.selectOrInsertKeyPair(connection, userIdentity));
+        this.cache.set(key, keyPair);
+        return keyPair;
+    }
+
+    private async selectOrInsertKeyPair(connection: PoolClient, userIdentity: UserIdentity): Promise<KeyPair> {
+        const { rows } = await connection.query('SELECT public_key, private_key FROM public.user WHERE provider = $1 AND user_identifier = $2',
+            [userIdentity.provider, userIdentity.id]);
+        if (rows.length > 1) {
+            throw new Error('Duplicate entries found in the keystore');
+        }
+        else if (rows.length === 1) {
+            const publicPem: string = rows[0]["public_key"];
+            const privatePem: string = rows[0]["private_key"];
+            return { publicPem, privatePem };
+        }
+        else {
+            const keyPair = await this.generateKeyPair(connection, userIdentity);
+            return keyPair;
+        }
+    }
+
+    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);
+        await connection.query('INSERT INTO public.user (provider, user_identifier, private_key, public_key) VALUES ($1, $2, $3, $4)',
+            [userIdentity.provider, userIdentity.id, privatePem, publicPem]);
+        return { publicPem, privatePem };
+    }
+}
+
+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
+        }]
+    };
+}