jinaga-server 1.0.0

package/dist/postgres/postgres-store.js

@@ -0,0 +1,717 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresStore = void 0;
+const jinaga_1 = require("jinaga");
+const fn_1 = require("../util/fn");
+const connection_1 = require("./connection");
+const edge_record_1 = require("./edge-record");
+const maps_1 = require("./maps");
+const specification_result_sql_1 = require("./specification-result-sql");
+const specification_sql_1 = require("./specification-sql");
+const sql_1 = require("./sql");
+function loadFactReference(r) {
+    return {
+        type: r.type,
+        hash: r.hash
+    };
+}
+function loadFactTuple(labels, row) {
+    const facts = labels.map(label => {
+        const hashColumn = `hash${label.index}`;
+        const hash = row[hashColumn];
+        if (hash === null) {
+            const columns = Object.keys(row);
+            throw new Error(`Cannot find column '${hashColumn}'. Available columns: ${columns.join(', ')}`);
+        }
+        const fact = {
+            type: label.type,
+            hash
+        };
+        return fact;
+    });
+    const bookmark = row.bookmark;
+    return {
+        facts,
+        bookmark: bookmark.join(".")
+    };
+}
+function loadFactPath(pathLength, factTypeNames, r) {
+    let path = [];
+    for (let i = 0; i < pathLength; i++) {
+        const hash = r['hash' + (i + 2)];
+        if (!hash) {
+            throw new Error(`Cannot find column 'hash${i + 2}'`);
+        }
+        path.push({
+            type: factTypeNames[i],
+            hash: hash
+        });
+    }
+    return path;
+}
+class PostgresStore {
+    constructor(postgresUri) {
+        this.factTypeMap = (0, maps_1.emptyFactTypeMap)();
+        this.roleMap = (0, maps_1.emptyRoleMap)();
+        this.connectionFactory = new connection_1.ConnectionFactory(postgresUri);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connectionFactory.close();
+        });
+    }
+    save(envelopes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (envelopes.length > 0) {
+                const facts = envelopes.map(e => e.fact);
+                if (facts.some(f => !f.hash || !f.type)) {
+                    throw new Error('Attempted to save a fact with no hash or type.');
+                }
+                const { newEnvelopes, factTypes, roles } = yield this.connectionFactory.withTransaction((connection) => __awaiter(this, void 0, void 0, function* () {
+                    const factTypes = yield storeFactTypes(facts, this.factTypeMap, connection);
+                    const existingFacts = yield findExistingFacts(facts, factTypes, connection);
+                    const newFacts = facts.filter(f => !(0, maps_1.hasFact)(existingFacts, f.hash, factTypes.get(f.type)));
+                    if (newFacts.length === 0) {
+                        return {
+                            newEnvelopes: [],
+                            factTypes,
+                            roles: (0, maps_1.emptyRoleMap)()
+                        };
+                    }
+                    const roles = yield storeRoles(newFacts, factTypes, (0, maps_1.copyRoleMap)(this.roleMap), connection);
+                    const allFacts = yield insertFactsEdgesAndAncestors(newFacts, factTypes, existingFacts, connection, roles);
+                    const newEnvelopes = envelopes.filter(envelope => newFacts.some((0, jinaga_1.factReferenceEquals)(envelope.fact)));
+                    if (newEnvelopes.length === 0) {
+                        return {
+                            newEnvelopes,
+                            factTypes,
+                            roles
+                        };
+                    }
+                    const publicKeys = yield storePublicKeys(newEnvelopes, connection);
+                    yield insertSignatures(newEnvelopes, allFacts, factTypes, publicKeys, connection);
+                    return {
+                        newEnvelopes,
+                        factTypes,
+                        roles
+                    };
+                }));
+                this.factTypeMap = (0, maps_1.mergeFactTypes)(this.factTypeMap, factTypes);
+                this.roleMap = (0, maps_1.mergeRoleMaps)(this.roleMap, roles);
+                return newEnvelopes;
+            }
+            else {
+                return [];
+            }
+        });
+    }
+    query(start, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (query.steps.length === 0) {
+                return [[start]];
+            }
+            try {
+                const factTypes = yield this.loadFactTypesFromSteps(query.steps, start.type);
+                const roleMap = yield this.loadRolesFromSteps(query.steps, factTypes, start.type);
+                const sqlQuery = (0, sql_1.sqlFromSteps)(start, query.steps, factTypes, roleMap);
+                if (!sqlQuery) {
+                    throw new Error(`Could not generate SQL for query "${query.toDescriptiveString()}" starting at "${start.type}"`);
+                }
+                if (sqlQuery.empty) {
+                    return [];
+                }
+                const { rows } = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                    return yield connection.query(sqlQuery.sql, sqlQuery.parameters);
+                }));
+                return rows.map(row => loadFactPath(sqlQuery.pathLength, sqlQuery.factTypeNames, row));
+            }
+            catch (e) {
+                throw new Error(`Could not generate SQL for query "${query.toDescriptiveString()}" starting at "${start.type}": ${e}`);
+            }
+        });
+    }
+    read(start, specification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factTypes = yield this.loadFactTypesFromSpecification(specification);
+            const roleMap = yield this.loadRolesFromSpecification(specification, factTypes);
+            const composer = (0, specification_result_sql_1.resultSqlFromSpecification)(start, specification, factTypes, roleMap);
+            if (composer === null) {
+                return [];
+            }
+            const sqlQueryTree = composer.getSqlQueries();
+            const resultSets = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                return yield executeQueryTree(sqlQueryTree, connection);
+            }));
+            return composer.compose(resultSets);
+        });
+    }
+    streamsFromSpecification(start, bookmarks, limit, specification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factTypes = yield this.loadFactTypesFromSpecification(specification);
+            const roleMap = yield this.loadRolesFromSpecification(specification, factTypes);
+            const sqlQueries = (0, specification_sql_1.sqlFromSpecification)(start, bookmarks, limit, specification, factTypes, roleMap);
+            const streams = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                const streams = [];
+                for (const sqlQuery of sqlQueries) {
+                    try {
+                        const { rows } = yield connection.query(sqlQuery.sql, sqlQuery.parameters);
+                        const tuples = rows.map(row => loadFactTuple(sqlQuery.labels, row));
+                        streams.push({
+                            labels: sqlQuery.labels.map(l => l.name),
+                            tuples,
+                            bookmark: tuples.length > 0 ? tuples[tuples.length - 1].bookmark : sqlQuery.bookmark
+                        });
+                    }
+                    catch (error) {
+                        throw new Error(`Could not execute query "${sqlQuery.sql}", parameters ${sqlQuery.parameters}:\n${error}`);
+                    }
+                }
+                return streams;
+            }));
+            return streams;
+        });
+    }
+    loadFactTypesFromSteps(steps, startType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factTypes = this.factTypeMap;
+            const unknownFactTypes = [...allFactTypes(steps), startType]
+                .filter(factType => !factTypes.has(factType))
+                .filter(fn_1.distinct);
+            if (unknownFactTypes.length > 0) {
+                const loadedFactTypes = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                    return yield loadFactTypes(unknownFactTypes, connection);
+                }));
+                const merged = (0, maps_1.mergeFactTypes)(this.factTypeMap, loadedFactTypes);
+                this.factTypeMap = merged;
+                return merged;
+            }
+            return factTypes;
+        });
+    }
+    loadFactTypesFromSpecification(specification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factTypes = this.factTypeMap;
+            const unknownFactTypes = (0, jinaga_1.getAllFactTypes)(specification)
+                .filter(factType => !factTypes.has(factType));
+            if (unknownFactTypes.length > 0) {
+                const loadedFactTypes = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                    return yield loadFactTypes(unknownFactTypes, connection);
+                }));
+                const merged = (0, maps_1.mergeFactTypes)(this.factTypeMap, loadedFactTypes);
+                this.factTypeMap = merged;
+                return merged;
+            }
+            return factTypes;
+        });
+    }
+    loadRolesFromSteps(steps, factTypes, initialType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roleMap = this.roleMap;
+            const unknownRoles = allRoles(steps, factTypes, (0, maps_1.getFactTypeId)(factTypes, initialType))
+                .filter(r => !(0, maps_1.hasRole)(roleMap, r.defining_fact_type_id, r.role));
+            if (unknownRoles.length > 0) {
+                const loadedRoles = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                    return yield loadRoles(unknownRoles, roleMap, connection);
+                }));
+                const merged = (0, maps_1.mergeRoleMaps)(this.roleMap, loadedRoles);
+                this.roleMap = merged;
+                return merged;
+            }
+            return roleMap;
+        });
+    }
+    loadRolesFromSpecification(specification, factTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roleMap = this.roleMap;
+            const unknownRoles = (0, jinaga_1.getAllRoles)(specification)
+                .map(r => ({
+                defining_fact_type_id: (0, maps_1.getFactTypeId)(factTypes, r.definingFactType),
+                role: r.name
+            }))
+                .filter(r => !(0, maps_1.hasRole)(roleMap, r.defining_fact_type_id, r.role));
+            if (unknownRoles.length > 0) {
+                const loadedRoles = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                    return yield loadRoles(unknownRoles, roleMap, connection);
+                }));
+                const merged = (0, maps_1.mergeRoleMaps)(this.roleMap, loadedRoles);
+                this.roleMap = merged;
+                return merged;
+            }
+            return roleMap;
+        });
+    }
+    whichExist(references) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (references.length === 0) {
+                return [];
+            }
+            const factTypes = yield this.loadFactTypesFromReferences(references);
+            const factValues = references.map((f, i) => `(\$${i * 2 + 1}, \$${i * 2 + 2}::integer)`);
+            const factParameters = (0, fn_1.flatten)(references, (f) => [f.hash, factTypes.get(f.type)]);
+            const sql = 'SELECT f.fact_type_id, f.hash ' +
+                'FROM public.fact f ' +
+                'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
+                '  ON v.fact_type_id = f.fact_type_id AND v.hash = f.hash ';
+            const result = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                return yield connection.query(sql, factParameters);
+            }));
+            const existing = references.filter(r => result.rows.some(row => row.fact_type_id === factTypes.get(r.type) && row.hash === r.hash));
+            return existing;
+        });
+    }
+    load(references) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (references.length === 0) {
+                return [];
+            }
+            const factTypes = yield this.loadFactTypesFromReferences(references);
+            const factValues = references.map((f, i) => `(\$${i * 2 + 1}, \$${i * 2 + 2}::integer)`);
+            const factParameters = (0, fn_1.flatten)(references, (f) => [f.hash, factTypes.get(f.type)]);
+            const sql = 'SELECT f.fact_type_id, t.name, f.hash, f.data ' +
+                'FROM public.fact f ' +
+                'JOIN public.fact_type t ' +
+                '  ON f.fact_type_id = t.fact_type_id ' +
+                'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
+                '  ON v.fact_type_id = f.fact_type_id AND v.hash = f.hash ' +
+                'UNION ' +
+                'SELECT f2.fact_type_id, t.name, f2.hash, f2.data ' +
+                'FROM public.fact f1 ' +
+                'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
+                '  ON v.fact_type_id = f1.fact_type_id AND v.hash = f1.hash ' +
+                'JOIN public.ancestor a ' +
+                '  ON a.fact_id = f1.fact_id ' +
+                'JOIN public.fact f2 ' +
+                '  ON f2.fact_id = a.ancestor_fact_id ' +
+                'JOIN public.fact_type t ' +
+                '  ON t.fact_type_id = f2.fact_type_id;';
+            const result = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                return yield connection.query(sql, factParameters);
+            }));
+            const resultFactTypes = result.rows.reduce((factTypes, r) => (0, maps_1.addFactType)(factTypes, r.name, r.fact_type_id), (0, maps_1.emptyFactTypeMap)());
+            this.factTypeMap = (0, maps_1.mergeFactTypes)(this.factTypeMap, resultFactTypes);
+            return result.rows.map((r) => {
+                const { fields, predecessors } = r.data;
+                return {
+                    type: r.name,
+                    hash: r.hash,
+                    fields,
+                    predecessors
+                };
+            });
+        });
+    }
+    loadFactTypesFromReferences(references) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factTypes = this.factTypeMap;
+            const newFactTypes = references
+                .map(reference => reference.type)
+                .filter(type => !factTypes.has(type))
+                .filter(fn_1.distinct);
+            if (newFactTypes.length > 0) {
+                const loadedFactTypes = yield this.connectionFactory.with((connection) => __awaiter(this, void 0, void 0, function* () {
+                    return yield loadFactTypes(newFactTypes, connection);
+                }));
+                const mergedFactTypes = (0, maps_1.mergeFactTypes)(factTypes, loadedFactTypes);
+                this.factTypeMap = mergedFactTypes;
+                return mergedFactTypes;
+            }
+            return factTypes;
+        });
+    }
+}
+exports.PostgresStore = PostgresStore;
+function executeQueryTree(sqlQueryTree, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sqlQuery = sqlQueryTree.sqlQuery;
+        const { rows } = yield connection.query(sqlQuery.sql, sqlQuery.parameters);
+        const resultSets = {
+            resultSet: rows,
+            childResultSets: []
+        };
+        for (const child of sqlQueryTree.childQueries) {
+            const childResultSet = yield executeQueryTree(child, connection);
+            resultSets.childResultSets.push(Object.assign({ name: child.name }, childResultSet));
+        }
+        return resultSets;
+    });
+}
+function predecessorTypes(predecessor) {
+    if (Array.isArray(predecessor)) {
+        return predecessor.map(p => p.type);
+    }
+    return [predecessor.type];
+}
+function predecessorCollectionTypes(predecessors) {
+    return Object.keys(predecessors).flatMap(key => predecessorTypes(predecessors[key]));
+}
+function storeFactTypes(facts, factTypes, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const newFactTypes = facts
+            .flatMap(fact => [fact.type, ...predecessorCollectionTypes(fact.predecessors)])
+            .filter(type => !factTypes.has(type))
+            .filter(fn_1.distinct);
+        if (newFactTypes.length === 0) {
+            return factTypes;
+        }
+        // Look up existing fact types
+        const loadedFactTypes = yield loadFactTypes(newFactTypes, connection);
+        const remainingNames = newFactTypes.filter(type => !loadedFactTypes.has(type));
+        if (remainingNames.length === 0) {
+            return (0, maps_1.mergeFactTypes)(loadedFactTypes, factTypes);
+        }
+        // Insert new fact types
+        const values = remainingNames.map((name, index) => `($${index + 1})`);
+        const insertSql = 'INSERT INTO public.fact_type (name) VALUES ' + values.join(', ') +
+            ' RETURNING fact_type_id, name;';
+        const { rows: newRows } = yield connection.query(insertSql, remainingNames);
+        if (newRows.length !== remainingNames.length) {
+            throw new Error('Failed to insert all new fact types.');
+        }
+        const allFactTypes = newRows.reduce((map, row) => (0, maps_1.addFactType)(map, row.name, row.fact_type_id), (0, maps_1.mergeFactTypes)(loadedFactTypes, factTypes));
+        return allFactTypes;
+    });
+}
+function loadFactTypes(factTypeNames, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const lookUpSql = 'SELECT name, fact_type_id FROM public.fact_type WHERE name=ANY($1);';
+        const { rows: existingRows } = yield connection.query(lookUpSql, [factTypeNames]);
+        const factTypeIds = existingRows.reduce((map, row) => (0, maps_1.addFactType)(map, row.name, row.fact_type_id), (0, maps_1.emptyFactTypeMap)());
+        return factTypeIds;
+    });
+}
+function storeRoles(facts, factTypes, roleMap, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Find distinct roles
+        const roles = (0, fn_1.flatten)(facts, fact => {
+            const defining_fact_type_id = factTypes.get(fact.type);
+            return Object.keys(fact.predecessors).map(role => ({
+                role,
+                defining_fact_type_id
+            }));
+        }).filter((role, index, array) => array.findIndex(r => r.role === role.role &&
+            r.defining_fact_type_id === role.defining_fact_type_id) === index);
+        if (roles.length > 0) {
+            // Look up existing roles
+            const roleIds = yield loadRoles(roles, roleMap, connection);
+            const remainingRoles = roles.filter(role => !(0, maps_1.hasRole)(roleIds, role.defining_fact_type_id, role.role));
+            if (remainingRoles.length === 0) {
+                return roleIds;
+            }
+            // Insert new roles
+            const remainingRoleValues = remainingRoles.map((role, index) => `($${index * 2 + 1}, $${index * 2 + 2}::integer)`);
+            const insertSql = 'INSERT INTO public.role (name, defining_fact_type_id) VALUES ' +
+                remainingRoleValues.join(', ') +
+                ' RETURNING role_id, name, defining_fact_type_id;';
+            const remainingRoleParameters = (0, fn_1.flatten)(remainingRoles, (role) => [
+                role.role,
+                role.defining_fact_type_id
+            ]);
+            const { rows: newRows } = yield connection.query(insertSql, remainingRoleParameters);
+            if (newRows.length !== remainingRoles.length) {
+                throw new Error('Failed to insert all new roles.');
+            }
+            const allRoleIds = newRows.reduce((map, row) => (0, maps_1.addRole)(map, row.defining_fact_type_id, row.name, row.role_id), roleIds);
+            return allRoleIds;
+        }
+        else {
+            return roleMap;
+        }
+    });
+}
+function loadRoles(roles, roleMap, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const roleValues = roles.map((role, index) => `($${index * 2 + 1}, $${index * 2 + 2}::integer)`);
+        const roleParameters = (0, fn_1.flatten)(roles, (role) => [
+            role.role,
+            role.defining_fact_type_id
+        ]);
+        const lookUpSql = 'SELECT role.name, role.defining_fact_type_id, role.role_id' +
+            ' FROM public.role' +
+            ' JOIN (VALUES ' + roleValues.join(', ') + ') AS v (name, defining_fact_type_id)' +
+            ' ON v.name = role.name AND v.defining_fact_type_id = role.defining_fact_type_id;';
+        const { rows } = yield connection.query(lookUpSql, roleParameters);
+        const roleIds = rows.reduce((map, row) => (0, maps_1.addRole)(map, row.defining_fact_type_id, row.name, row.role_id), roleMap);
+        return roleIds;
+    });
+}
+function findExistingFacts(facts, factTypes, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (facts.length > 0) {
+            const factReferences = facts.flatMap(fact => [
+                ...predecessorsOf(fact),
+                fact
+            ]);
+            const factValues = factReferences.map((f, i) => `(\$${i * 2 + 1}, \$${i * 2 + 2}::integer)`);
+            const factParameters = factReferences.flatMap((f) => [f.hash, factTypes.get(f.type)]);
+            const sql = 'SELECT fact_id, fact.fact_type_id, fact.hash' +
+                ' FROM public.fact' +
+                ' JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id)' +
+                ' ON v.fact_type_id = fact.fact_type_id AND v.hash = fact.hash;';
+            const { rows } = yield connection.query(sql, factParameters);
+            const existingFacts = rows.reduce((map, row) => (0, maps_1.addFact)(map, row.hash, row.fact_type_id, row.fact_id), (0, maps_1.emptyFactMap)());
+            return existingFacts;
+        }
+        else {
+            return (0, maps_1.emptyFactMap)();
+        }
+    });
+}
+function insertFactsEdgesAndAncestors(facts, factTypes, existingFacts, connection, roles) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (facts.length === 0) {
+            return (0, maps_1.emptyFactMap)();
+        }
+        const { sql, parameters } = sqlInsertFacts(facts, roles, factTypes);
+        const { rows } = yield connection.query(sql, parameters);
+        if (rows.length !== facts.length) {
+            throw new Error('Failed to insert all new facts.');
+        }
+        const allFacts = rows.reduce((map, row) => (0, maps_1.addFact)(map, row.hash, row.fact_type_id, row.fact_id), existingFacts);
+        return allFacts;
+    });
+}
+function sqlInsertFacts(facts, roles, factTypes) {
+    const factValues = facts.map((f, i) => `(\$${i * 3 + 1}, \$${i * 3 + 2}::integer, \$${i * 3 + 3}::jsonb)`);
+    const factParameters = (0, fn_1.flatten)(facts, (f) => [f.hash, factTypes.get(f.type), {
+            fields: f.fields,
+            predecessors: (0, jinaga_1.canonicalPredecessors)(f.predecessors)
+        }]);
+    const edgeRecords = (0, fn_1.flatten)(facts, fact => (0, edge_record_1.makeEdgeRecords)(fact));
+    if (edgeRecords.length > 0) {
+        return sqlInsertFactsEdgesAndAncestors(facts, factParameters, edgeRecords, factTypes, roles, factValues);
+    }
+    else {
+        return {
+            sql: 'INSERT INTO public.fact (hash, fact_type_id, data) VALUES ' +
+                factValues.join(', ') +
+                ' RETURNING fact_id, hash, fact_type_id;',
+            parameters: factParameters
+        };
+    }
+}
+function sqlInsertFactsEdgesAndAncestors(facts, factParameters, edgeRecords, factTypes, roles, factValues) {
+    let parameterOffset = factParameters.length;
+    const edgeValues = edgeRecords.map((e, i) => `(\$${i * 5 + 1 + parameterOffset}, \$${i * 5 + 2 + parameterOffset}::integer, \$${i * 5 + 3 + parameterOffset}, \$${i * 5 + 4 + parameterOffset}::integer, \$${i * 5 + 5 + parameterOffset}::integer)`);
+    const edgeParameters = (0, fn_1.flatten)(edgeRecords, (e) => {
+        const successor_fact_type_id = (0, maps_1.getFactTypeId)(factTypes, e.successor_type);
+        const predecessor_fact_type_id = (0, maps_1.getFactTypeId)(factTypes, e.predecessor_type);
+        return [
+            e.successor_hash,
+            successor_fact_type_id,
+            e.predecessor_hash,
+            predecessor_fact_type_id,
+            (0, maps_1.getRoleId)(roles, successor_fact_type_id, e.role)
+        ];
+    });
+    parameterOffset += edgeParameters.length;
+    const ancestors = ancestorRecords(facts);
+    const ancestorValues = ancestors.map((a, i) => `(\$${i * 4 + 1 + parameterOffset}, \$${i * 4 + 2 + parameterOffset}::integer, \$${i * 4 + 3 + parameterOffset}, \$${i * 4 + 4 + parameterOffset}::integer)`);
+    const ancestorParameters = (0, fn_1.flatten)(ancestors, (a) => [
+        a.fact.hash,
+        factTypes.get(a.fact.type),
+        a.ancestor.hash,
+        factTypes.get(a.ancestor.type)
+    ]);
+    const sql = `WITH new_fact AS (
+    SELECT hash, fact_type_id, data
+    FROM (VALUES ${factValues.join(', ')})
+        AS fv (hash, fact_type_id, data)
+),
+new_edge AS (
+    SELECT successor_hash, successor_fact_type_id, predecessor_hash, predecessor_fact_type_id, role_id
+    FROM (VALUES ${edgeValues.join(', ')})
+        AS ev (successor_hash, successor_fact_type_id, predecessor_hash, predecessor_fact_type_id, role_id)
+),
+new_ancestor AS (
+    SELECT hash, fact_type_id, ancestor_hash, ancestor_fact_type_id
+    FROM (VALUES ${ancestorValues.join(', ')})
+        AS ev (hash, fact_type_id, ancestor_hash, ancestor_fact_type_id)
+),
+inserted_fact AS (
+    INSERT INTO public.fact (hash, fact_type_id, data)
+    SELECT hash, fact_type_id, data
+    FROM new_fact
+    RETURNING fact_id, fact_type_id, hash
+),
+inserted_edge AS (
+    INSERT INTO public.edge
+        (role_id, successor_fact_id, predecessor_fact_id)
+    SELECT
+        new_edge.role_id,
+        successor.fact_id,
+        predecessor.fact_id
+    FROM new_edge
+    JOIN inserted_fact AS successor
+        ON successor.hash = new_edge.successor_hash
+        AND successor.fact_type_id = new_edge.successor_fact_type_id
+    JOIN (
+        SELECT fact_id, fact_type_id, hash
+        FROM inserted_fact
+        UNION ALL
+        SELECT fact_id, fact_type_id, hash
+        FROM public.fact
+    ) AS predecessor
+        ON predecessor.hash = new_edge.predecessor_hash
+        AND predecessor.fact_type_id = new_edge.predecessor_fact_type_id
+    ON CONFLICT DO NOTHING
+),
+ancestor_id AS (
+    SELECT
+        fact.fact_id,
+        ancestor.fact_id AS ancestor_fact_id
+    FROM new_ancestor
+    JOIN inserted_fact AS fact
+        ON fact.hash = new_ancestor.hash
+        AND fact.fact_type_id = new_ancestor.fact_type_id
+    JOIN (
+        SELECT fact_id, fact_type_id, hash
+        FROM inserted_fact
+        UNION ALL
+        SELECT fact_id, fact_type_id, hash
+        FROM public.fact
+    ) AS ancestor
+        ON ancestor.hash = new_ancestor.ancestor_hash
+        AND ancestor.fact_type_id = new_ancestor.ancestor_fact_type_id
+),
+inserted_ancestor AS (
+    INSERT INTO public.ancestor
+        (fact_id, ancestor_fact_id)
+        SELECT ancestor_id.fact_id, ancestor_id.ancestor_fact_id
+        FROM ancestor_id
+    UNION ALL
+        SELECT ancestor_id.fact_id, ancestor.ancestor_fact_id
+        FROM ancestor_id
+        JOIN public.ancestor
+            ON ancestor.fact_id = ancestor_id.ancestor_fact_id
+    ON CONFLICT DO NOTHING
+)
+SELECT fact_id, fact_type_id, hash
+FROM inserted_fact;`;
+    const parameters = [...factParameters, ...edgeParameters, ...ancestorParameters];
+    return { sql, parameters };
+}
+function ancestorRecords(facts) {
+    return facts.flatMap(fact => {
+        const factReference = { hash: fact.hash, type: fact.type };
+        const ancestorReferences = recursivePredecessors(factReference, facts);
+        return ancestorReferences.map(ancestor => ({
+            fact: factReference,
+            ancestor
+        }));
+    });
+}
+function recursivePredecessors(factReference, facts) {
+    return facts
+        .filter(f => f.hash === factReference.hash && f.type === factReference.type)
+        .flatMap(fact => {
+        const predecessorReferences = Object.keys(fact.predecessors).flatMap(role => {
+            const predecessors = fact.predecessors[role];
+            if (Array.isArray(predecessors)) {
+                return predecessors;
+            }
+            else {
+                return [predecessors];
+            }
+        });
+        const ancestorReferences = predecessorReferences.flatMap(predecessor => recursivePredecessors(predecessor, facts));
+        return [...predecessorReferences, ...ancestorReferences];
+    });
+}
+function storePublicKeys(envelopes, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Look up existing fact types
+        const publicKeys = (0, fn_1.flatten)(envelopes, e => e.signatures.map(s => s.publicKey))
+            .filter(fn_1.distinct);
+        const lookUpSql = 'SELECT public_key, public_key_id FROM public.public_key WHERE public_key=ANY($1);';
+        const { rows: existingRows } = yield connection.query(lookUpSql, [publicKeys]);
+        const publicKeyIds = existingRows.reduce((map, row) => (0, maps_1.addFactType)(map, row.public_key, row.public_key_id), (0, maps_1.emptyPublicKeyMap)());
+        const remainingPublicKeys = publicKeys.filter(pk => !publicKeyIds.has(pk));
+        if (remainingPublicKeys.length === 0) {
+            return publicKeyIds;
+        }
+        // Insert new fact types
+        const values = remainingPublicKeys.map((name, index) => `($${index + 1})`);
+        const insertSql = 'INSERT INTO public.public_key (public_key) VALUES ' + values.join(', ') +
+            ' RETURNING public_key, public_key_id;';
+        const { rows: newRows } = yield connection.query(insertSql, remainingPublicKeys);
+        if (newRows.length !== remainingPublicKeys.length) {
+            throw new Error('Failed to insert all new public keys.');
+        }
+        const allPublicKeyIds = newRows.reduce((map, row) => (0, maps_1.addFactType)(map, row.public_key, row.public_key_id), publicKeyIds);
+        return allPublicKeyIds;
+    });
+}
+function insertSignatures(envelopes, allFacts, factTypes, publicKey, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const signatureRecords = (0, fn_1.flatten)(envelopes, envelope => envelope.signatures.map(signature => ({
+            factId: (0, maps_1.getFactId)(allFacts, envelope.fact.hash, (0, maps_1.getFactTypeId)(factTypes, envelope.fact.type)),
+            publicKeyId: (0, maps_1.getPublicKeyId)(publicKey, signature.publicKey),
+            signature: signature.signature
+        })));
+        if (signatureRecords.length > 0) {
+            const signatureValues = signatureRecords.map((s, i) => `($${i * 3 + 1}::integer, $${i * 3 + 2}::integer, $${i * 3 + 3})`);
+            const signatureParameters = (0, fn_1.flatten)(signatureRecords, s => [s.factId, s.publicKeyId, s.signature]);
+            const sql = `INSERT INTO public.signature
+            (fact_id, public_key_id, signature) 
+            (SELECT fact_id, public_key_id, signature 
+             FROM (VALUES ${signatureValues.join(', ')}) AS v(fact_id, public_key_id, signature)) 
+            ON CONFLICT DO NOTHING`;
+            yield connection.query(sql, signatureParameters);
+        }
+    });
+}
+function allFactTypes(steps) {
+    const factTypes = steps
+        .filter(step => step instanceof jinaga_1.PropertyCondition && step.name === 'type')
+        .map(step => step.value);
+    const childFactTypes = steps
+        .filter(step => step instanceof jinaga_1.ExistentialCondition)
+        .flatMap(step => allFactTypes(step.steps));
+    return [...factTypes, ...childFactTypes].filter(fn_1.distinct);
+}
+function allRoles(steps, factTypes, initialTypeId) {
+    let roles = [];
+    let defining_fact_type_id = initialTypeId;
+    let role = undefined;
+    for (const step of steps) {
+        if (step instanceof jinaga_1.PropertyCondition) {
+            if (step.name === 'type') {
+                defining_fact_type_id = (0, maps_1.getFactTypeId)(factTypes, step.value);
+                if (defining_fact_type_id && role) {
+                    roles.push({ defining_fact_type_id, role });
+                }
+                role = undefined;
+            }
+        }
+        else if (step instanceof jinaga_1.Join) {
+            if (step.direction === jinaga_1.Direction.Predecessor) {
+                if (defining_fact_type_id) {
+                    roles.push({ defining_fact_type_id, role: step.role });
+                }
+                role = undefined;
+            }
+            else {
+                role = step.role;
+            }
+            defining_fact_type_id = undefined;
+        }
+        else if (step instanceof jinaga_1.ExistentialCondition) {
+            roles = roles.concat(allRoles(step.steps, factTypes, defining_fact_type_id));
+        }
+    }
+    return roles;
+}
+function predecessorsOf(fact) {
+    const references = Object.values(fact.predecessors).flatMap(predecessor => Array.isArray(predecessor) ? predecessor : [predecessor]);
+    return references;
+}
+//# sourceMappingURL=postgres-store.js.map