jinaga-server 2.1.8 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinaga-server",
-  "version": "2.1.8",
+  "version": "2.3.0",
   "description": "Application-agnostic back end for web applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "express": "^4.18.1",
-    "jinaga": "^5.1.4",
+    "jinaga": "^5.3.0",
     "node-forge": "^1.3.1",
     "passport": "^0.6.0",
     "pg": "^8.7.1"

package/src/authorization/authorization-keystore.ts

@@ -19,12 +19,12 @@ export class AuthorizationKeystore implements Authorization {
     private authorizationEngine: AuthorizationEngine | null;
 
     constructor(
-        private observableSource: Storage,
+        private store: Storage,
         private keystore: Keystore,
-        authorizationRules: AuthorizationRules | null) {
-
+        authorizationRules: AuthorizationRules | null
+    ) {
         this.authorizationEngine = authorizationRules &&
-            new AuthorizationEngine(authorizationRules, observableSource);
+            new AuthorizationEngine(authorizationRules, store);
     }
 
     async getOrCreateUserFact(userIdentity: UserIdentity) {
@@ -35,29 +35,29 @@ export class AuthorizationKeystore implements Authorization {
                 signatures: []
             }
         ];
-        await this.observableSource.save(envelopes);
+        await this.store.save(envelopes);
         return userFact;
     }
 
     query(userIdentity: UserIdentity, start: FactReference, query: Query) {
-        return this.observableSource.query(start, query);
+        return this.store.query(start, query);
     }
 
     read(userIdentity: UserIdentity, start: FactReference[], specification: Specification) {
-        return this.observableSource.read(start, specification);
+        return this.store.read(start, specification);
     }
 
     feed(userIdentity: UserIdentity, feed: Feed, bookmark: string): Promise<FactFeed> {
-        return this.observableSource.feed(feed, bookmark);
+        return this.store.feed(feed, bookmark);
     }
 
     load(userIdentity: UserIdentity, references: FactReference[]) {
-        return this.observableSource.load(references);
+        return this.store.load(references);
     }
 
     async save(userIdentity: UserIdentity | null, facts: FactRecord[]) {
         if (!this.authorizationEngine) {
-            const envelopes = await this.observableSource.save(facts.map(fact => ({
+            const envelopes = await this.store.save(facts.map(fact => ({
                 fact,
                 signatures: []
             })));
@@ -68,7 +68,7 @@ export class AuthorizationKeystore implements Authorization {
         const authorizedFacts = await this.authorizationEngine.authorizeFacts(facts, userFact);
         if (userIdentity) {
             const signedFacts = await this.keystore.signFacts(userIdentity, authorizedFacts);
-            const envelopes = await this.observableSource.save(signedFacts);
+            const envelopes = await this.store.save(signedFacts);
             return envelopes.map(envelope => envelope.fact);
         }
         else {

package/src/jinaga-server.ts

@@ -5,9 +5,7 @@ import {
     AuthorizationNoOp,
     AuthorizationRules,
     FactManager,
-    Fork,
-    HttpNetwork,
-    Jinaga,
+    Fork, Jinaga,
     MemoryStore,
     Model,
     Network,
@@ -17,17 +15,13 @@ import {
     PassThroughFork,
     Storage,
     SyncStatusNotifier,
-    Trace,
-    TransientFork,
-    UserIdentity,
-    WebClient
+    Trace, UserIdentity
 } from "jinaga";
 import { Pool } from "pg";
 
 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 { MemoryFeedCache } from "./memory/memory-feed-cache";
@@ -37,11 +31,11 @@ import { PostgresStore } from "./postgres/postgres-store";
 
 export type JinagaServerConfig = {
     pgStore?: string | Pool,
+    pgStoreSchema?: string,
     pgKeystore?: string | Pool,
-    httpEndpoint?: string,
+    pgKeystoreSchema?: string,
     model?: Model,
-    authorization?: (a: AuthorizationRules) => AuthorizationRules,
-    httpTimeoutSeconds?: number
+    authorization?: (a: AuthorizationRules) => AuthorizationRules
 };
 
 export type JinagaServerInstance = {
@@ -62,14 +56,14 @@ export class JinagaServer {
         const pools: { [uri: string]: Pool } = {};
         const store = createStore(config, pools);
         const source = new ObservableSourceImpl(store);
-        const fork = createFork(config, store, syncStatusNotifier);
+        const fork = new PassThroughFork(store);
         const keystore = createKeystore(config, pools);
         const authorizationRules = config.authorization ? config.authorization(new AuthorizationRules(config.model)) : null;
         const authorization = createAuthorization(authorizationRules, store, keystore);
         const feedCache = new MemoryFeedCache();
         const router = new HttpRouter(authorization, feedCache);
         const authentication = createAuthentication(store, keystore, authorizationRules);
-        const network = createNetwork(config);
+        const network = new NetworkNoOp();
         const factManager = new FactManager(authentication, fork, source, store, network);
         const j: Jinaga = new Jinaga(factManager, syncStatusNotifier);
 
@@ -92,7 +86,7 @@ export class JinagaServer {
 function createStore(config: JinagaServerConfig, pools: { [uri: string]: Pool }): Storage {
     if (config.pgStore) {
         const pool = getPool(config.pgStore, pools);
-        const store = new PostgresStore(pool);
+        const store = new PostgresStore(pool, validateSchema(config.pgStoreSchema));
         return store;
     }
     else {
@@ -101,25 +95,14 @@ function createStore(config: JinagaServerConfig, pools: { [uri: string]: Pool })
 }
 
 function createFork(config: JinagaServerConfig, store: Storage, 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(store, webClient);
-        return fork;
-    }
-    else {
-        return new PassThroughFork(store);
-    }
+    return new PassThroughFork(store);
 }
 
 function createKeystore(config: JinagaServerConfig, pools: { [uri: string]: Pool }): Keystore | null {
     const uriOrPool = config.pgKeystore;
     if (uriOrPool) {
         const pool = getPool(uriOrPool, pools);
-        const keystore = new PostgresKeystore(pool);
+        const keystore = new PostgresKeystore(pool, validateSchema(config.pgKeystoreSchema));
         return keystore;
     }
     else {
@@ -142,18 +125,7 @@ function createAuthentication(store: Storage, keystore: Keystore | null, authori
 }
 
 function createNetwork(config: JinagaServerConfig): Network {
-    if (config.httpEndpoint) {
-        const httpConnection = new NodeHttpConnection(config.httpEndpoint);
-        const httpTimeoutSeconds = config.httpTimeoutSeconds || 5;
-        const syncStatusNotifier = new SyncStatusNotifier();
-        const webClient = new WebClient(httpConnection, syncStatusNotifier, {
-            timeoutSeconds: httpTimeoutSeconds
-        });
-        return new HttpNetwork(webClient);
-    }
-    else {
-        return new NetworkNoOp();
-    }
+    return new NetworkNoOp();
 }
 
 function getPool(uriOrPool: string | Pool, pools: { [uri: string]: Pool; }): Pool {
@@ -222,4 +194,18 @@ async function withSession(store: Storage, keystore: Keystore | null, authorizat
     const factManager = new FactManager(authentication, fork, observableSource, store, network);
     const j = new Jinaga(factManager, syncStatusNotifier);
     await callback(j);
-}
+}
+
+function validateSchema(schema: string | undefined): string {
+    if (!schema) {
+        return "public";
+    }
+
+    // Verify that the schema is a valid Postgres schema name.
+    // https://www.postgresql.org/docs/9.1/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
+    if (!/^[a-z_][a-z0-9_$]*$/.test(schema)) {
+        throw new Error(`Invalid schema name: ${schema}. Schema names must start with a letter or underscore, and contain only letters, numbers, and underscores.`);
+    }
+
+    return schema;
+}

package/src/postgres/postgres-keystore.ts

@@ -14,7 +14,7 @@ export class PostgresKeystore implements Keystore {
     private connectionFactory: ConnectionFactory;
     private cache: Map<string, KeyPair> = new Map();
 
-    constructor (pool: Pool) {
+    constructor (pool: Pool, private schema: string) {
         this.connectionFactory = new ConnectionFactory(pool);
     }
 
@@ -77,7 +77,7 @@ export class PostgresKeystore implements Keystore {
     }
 
     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',
+        const { rows } = await connection.query(`SELECT public_key, private_key FROM ${this.schema}.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');
@@ -104,7 +104,7 @@ export class PostgresKeystore implements Keystore {
     }
 
     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',
+        const { rows } = await connection.query(`SELECT public_key, private_key FROM ${this.schema}.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');
@@ -124,7 +124,7 @@ export class PostgresKeystore implements Keystore {
         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)',
+        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 };
     }

package/src/postgres/postgres-store.ts

@@ -147,7 +147,7 @@ export class PostgresStore implements Storage {
     private factTypeMap: FactTypeMap = emptyFactTypeMap();
     private roleMap: RoleMap = emptyRoleMap();
 
-    constructor (pool: Pool) {
+    constructor (pool: Pool, private schema: string) {
         this.connectionFactory = new ConnectionFactory(pool);
     }
 
@@ -166,8 +166,8 @@ export class PostgresStore implements Storage {
                 factTypes: FactTypeMap;
                 roles: RoleMap;
             } = await this.connectionFactory.withTransaction(async (connection) => {
-                const factTypes = await storeFactTypes(facts, this.factTypeMap, connection);
-                const existingFacts = await findExistingFacts(facts, factTypes, connection);
+                const factTypes = await storeFactTypes(facts, this.factTypeMap, connection, this.schema);
+                const existingFacts = await findExistingFacts(facts, factTypes, connection, this.schema);
                 const newFacts = facts.filter(f => !hasFact(existingFacts, f.hash, ensureGetFactTypeId(factTypes, f.type)));
                 if (newFacts.length === 0) {
                     return {
@@ -177,8 +177,8 @@ export class PostgresStore implements Storage {
                     };
                 }
 
-                const roles = await storeRoles(newFacts, factTypes, copyRoleMap(this.roleMap), connection);
-                const allFacts = await insertFactsEdgesAndAncestors(newFacts, factTypes, existingFacts, connection, roles);
+                const roles = await storeRoles(newFacts, factTypes, copyRoleMap(this.roleMap), connection, this.schema);
+                const allFacts = await insertFactsEdgesAndAncestors(newFacts, factTypes, existingFacts, connection, roles, this.schema);
                 const newEnvelopes = envelopes.filter(envelope => newFacts.some(
                     factReferenceEquals(envelope.fact)));
                 if (newEnvelopes.length === 0) {
@@ -189,8 +189,8 @@ export class PostgresStore implements Storage {
                     };
                 }
 
-                const publicKeys = await storePublicKeys(newEnvelopes, connection);
-                await insertSignatures(newEnvelopes, allFacts, factTypes, publicKeys, connection);
+                const publicKeys = await storePublicKeys(newEnvelopes, connection, this.schema);
+                await insertSignatures(newEnvelopes, allFacts, factTypes, publicKeys, connection, this.schema);
                 return {
                     newEnvelopes,
                     factTypes,
@@ -215,7 +215,7 @@ export class PostgresStore implements Storage {
             const factTypes = await this.loadFactTypesFromSteps(query.steps, start.type);
             const roleMap = await this.loadRolesFromSteps(query.steps, factTypes, start.type);
 
-            const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap);
+            const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap, this.schema);
             if (!sqlQuery) {
                 throw new Error(`Could not generate SQL for query "${query.toDescriptiveString()}" starting at "${start.type}"`);
             }
@@ -241,7 +241,7 @@ export class PostgresStore implements Storage {
             return [];
         }
 
-        const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap);
+        const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap, this.schema);
         if (composer === null) {
             return [];
         }
@@ -256,7 +256,7 @@ export class PostgresStore implements Storage {
     async feed(feed: Feed, bookmark: string): Promise<FactFeed> {
         const factTypes: FactTypeMap = await this.loadFactTypesFromFeed(feed);
         const roleMap: RoleMap = await this.loadRolesFromFeed(feed, factTypes);
-        const sql = sqlFromFeed(feed, bookmark, 100, factTypes, roleMap);
+        const sql = sqlFromFeed(feed, this.schema, bookmark, 100, factTypes, roleMap);
         if (!sql) {
             return {
                 tuples: [],
@@ -281,7 +281,7 @@ export class PostgresStore implements Storage {
             .filter(distinct);
         if (unknownFactTypes.length > 0) {
             const loadedFactTypes = await this.connectionFactory.with(async (connection) => {
-                return await loadFactTypes(unknownFactTypes, connection);
+                return await loadFactTypes(unknownFactTypes, connection, this.schema);
             });
             const merged = mergeFactTypes(this.factTypeMap, loadedFactTypes);
             this.factTypeMap = merged;
@@ -296,7 +296,7 @@ export class PostgresStore implements Storage {
             .filter(factType => !factTypes.has(factType));
         if (unknownFactTypes.length > 0) {
             const loadedFactTypes = await this.connectionFactory.with(async (connection) => {
-                return await loadFactTypes(unknownFactTypes, connection);
+                return await loadFactTypes(unknownFactTypes, connection, this.schema);
             });
             const merged = mergeFactTypes(this.factTypeMap, loadedFactTypes);
             this.factTypeMap = merged;
@@ -311,7 +311,7 @@ export class PostgresStore implements Storage {
             .filter(factType => !factTypes.has(factType));
         if (unknownFactTypes.length > 0) {
             const loadedFactTypes = await this.connectionFactory.with(async (connection) => {
-                return await loadFactTypes(unknownFactTypes, connection);
+                return await loadFactTypes(unknownFactTypes, connection, this.schema);
             });
             const merged = mergeFactTypes(this.factTypeMap, loadedFactTypes);
             this.factTypeMap = merged;
@@ -326,7 +326,7 @@ export class PostgresStore implements Storage {
             .filter(r => !hasRole(roleMap, r.successor_type_id, r.role));
         if (unknownRoles.length > 0) {
             const loadedRoles = await this.connectionFactory.with(async (connection) => {
-                return await loadRoles(unknownRoles, roleMap, connection);
+                return await loadRoles(unknownRoles, roleMap, connection, this.schema);
             });
             const merged = mergeRoleMaps(this.roleMap, loadedRoles);
             this.roleMap = merged;
@@ -346,7 +346,7 @@ export class PostgresStore implements Storage {
             .filter(r => r.successor_type_id && !hasRole(roleMap, r.successor_type_id, r.role));
         if (unknownRoles.length > 0) {
             const loadedRoles = await this.connectionFactory.with(async (connection) => {
-                return await loadRoles(unknownRoles, roleMap, connection);
+                return await loadRoles(unknownRoles, roleMap, connection, this.schema);
             });
             const merged = mergeRoleMaps(this.roleMap, loadedRoles);
             this.roleMap = merged;
@@ -365,7 +365,7 @@ export class PostgresStore implements Storage {
             .filter(r => r.successor_type_id && !hasRole(roleMap, r.successor_type_id, r.role));
         if (unknownRoles.length > 0) {
             const loadedRoles = await this.connectionFactory.with(async (connection) => {
-                return await loadRoles(unknownRoles, roleMap, connection);
+                return await loadRoles(unknownRoles, roleMap, connection, this.schema);
             });
             const merged = mergeRoleMaps(this.roleMap, loadedRoles);
             this.roleMap = merged;
@@ -387,7 +387,7 @@ export class PostgresStore implements Storage {
             [f.hash, factTypes.get(f.type)]);
         const sql =
             'SELECT f.fact_type_id, f.hash ' +
-            'FROM public.fact f ' +
+            `FROM ${this.schema}.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: ExistsResult = await this.connectionFactory.with(async (connection) => {
@@ -415,21 +415,21 @@ export class PostgresStore implements Storage {
             [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 ' +
+            `FROM ${this.schema}.fact f ` +
+            `JOIN ${this.schema}.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 ' +
+            `FROM ${this.schema}.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 ' +
+            `JOIN ${this.schema}.ancestor a ` +
             '  ON a.fact_id = f1.fact_id ' +
-            'JOIN public.fact f2 ' +
+            `JOIN ${this.schema}.fact f2 ` +
             '  ON f2.fact_id = a.ancestor_fact_id ' +
-            'JOIN public.fact_type t ' +
+            `JOIN ${this.schema}.fact_type t ` +
             '  ON t.fact_type_id = f2.fact_type_id;';
         const result: AncestorResult = await this.connectionFactory.with(async (connection) => {
             return await connection.query(sql, factParameters);
@@ -460,7 +460,7 @@ export class PostgresStore implements Storage {
             .filter(distinct);
         if (newFactTypes.length > 0) {
             const loadedFactTypes = await this.connectionFactory.with(async (connection) => {
-                return await loadFactTypes(newFactTypes, connection);
+                return await loadFactTypes(newFactTypes, connection, this.schema);
             });
             const mergedFactTypes = mergeFactTypes(factTypes, loadedFactTypes);
             this.factTypeMap = mergedFactTypes;
@@ -476,6 +476,14 @@ export class PostgresStore implements Storage {
     saveBookmark(feed: string, bookmark: string): Promise<void> {
         throw new Error("Method not implemented.");
     }
+
+    getMruDate(specificationHash: string): Promise<Date | null> {
+        throw new Error("Method not implemented.");
+    }
+    
+    setMruDate(specificationHash: string, mruDate: Date): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
 }
 
 async function executeQueryTree(sqlQueryTree: SqlQueryTree, connection: PoolClient): Promise<ResultSetTree> {
@@ -506,7 +514,7 @@ function predecessorCollectionTypes(predecessors: PredecessorCollection): string
     return Object.keys(predecessors).flatMap(key => predecessorTypes(predecessors[key]));
 }
 
-async function storeFactTypes(facts: FactRecord[], factTypes: FactTypeMap, connection: PoolClient) {
+async function storeFactTypes(facts: FactRecord[], factTypes: FactTypeMap, connection: PoolClient, schema: string) {
     const newFactTypes = facts
         .flatMap(fact => [fact.type, ...predecessorCollectionTypes(fact.predecessors)])
         .filter(type => !factTypes.has(type))
@@ -516,7 +524,7 @@ async function storeFactTypes(facts: FactRecord[], factTypes: FactTypeMap, conne
     }
 
     // Look up existing fact types
-    const loadedFactTypes = await loadFactTypes(newFactTypes, connection);
+    const loadedFactTypes = await loadFactTypes(newFactTypes, connection, schema);
     const remainingNames = newFactTypes.filter(type => !loadedFactTypes.has(type));
     if (remainingNames.length === 0) {
         return mergeFactTypes(loadedFactTypes, factTypes);
@@ -524,7 +532,7 @@ async function storeFactTypes(facts: FactRecord[], factTypes: FactTypeMap, conne
 
     // Insert new fact types
     const values = remainingNames.map((name, index) => `($${index + 1})`);
-    const insertSql = 'INSERT INTO public.fact_type (name) VALUES ' + values.join(', ') +
+    const insertSql = `INSERT INTO ${schema}.fact_type (name) VALUES ` + values.join(', ') +
         ' RETURNING fact_type_id, name;';
     const { rows: newRows }: FactTypeResult = await connection.query(insertSql, remainingNames);
     if (newRows.length !== remainingNames.length) {
@@ -537,8 +545,8 @@ async function storeFactTypes(facts: FactRecord[], factTypes: FactTypeMap, conne
     return allFactTypes;
 }
 
-async function loadFactTypes(factTypeNames: string[], connection: PoolClient) {
-    const lookUpSql = 'SELECT name, fact_type_id FROM public.fact_type WHERE name=ANY($1);';
+async function loadFactTypes(factTypeNames: string[], connection: PoolClient, schema: string) {
+    const lookUpSql = `SELECT name, fact_type_id FROM ${schema}.fact_type WHERE name=ANY($1);`;
     const { rows: existingRows }: FactTypeResult = await connection.query(lookUpSql, [factTypeNames]);
     const factTypeIds = existingRows.reduce(
         (map, row) => addFactType(map, row.name, row.fact_type_id),
@@ -547,7 +555,7 @@ async function loadFactTypes(factTypeNames: string[], connection: PoolClient) {
     return factTypeIds;
 }
 
-async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap: RoleMap, connection: PoolClient) {
+async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap: RoleMap, connection: PoolClient, schema: string) {
     // Find distinct roles
     const roles = flatten(facts, fact => {
         const successor_type_id = ensureGetFactTypeId(factTypes, fact.type);
@@ -562,7 +570,7 @@ async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap:
 
     if (roles.length > 0) {
         // Look up existing roles
-        const roleIds = await loadRoles(roles, roleMap, connection);
+        const roleIds = await loadRoles(roles, roleMap, connection, schema);
         const remainingRoles = roles.filter(role => !hasRole(
             roleIds, role.successor_type_id, role.role));
         if (remainingRoles.length === 0) {
@@ -572,7 +580,7 @@ async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap:
         // 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 ' +
+        const insertSql = `INSERT INTO ${schema}.role (name, defining_fact_type_id) VALUES ` +
             remainingRoleValues.join(', ') +
             ' RETURNING role_id, name, defining_fact_type_id;';
         const remainingRoleParameters = flatten(remainingRoles, (role) => [
@@ -594,7 +602,7 @@ async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap:
     }
 }
 
-async function loadRoles(roles: { role: string; successor_type_id: number; }[], roleMap: RoleMap, connection: PoolClient) {
+async function loadRoles(roles: { role: string; successor_type_id: number; }[], roleMap: RoleMap, connection: PoolClient, schema: string) {
     const roleValues = roles.map((role, index) =>
         `($${index * 2 + 1}, $${index * 2 + 2}::integer)`);
     const roleParameters = flatten(roles, (role) => [
@@ -603,7 +611,7 @@ async function loadRoles(roles: { role: string; successor_type_id: number; }[],
     ]);
 
     const lookUpSql = 'SELECT role.name, role.defining_fact_type_id, role.role_id' +
-        ' FROM public.role' +
+        ` FROM ${schema}.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 }: RoleResult = await connection.query(lookUpSql, roleParameters);
@@ -614,7 +622,7 @@ async function loadRoles(roles: { role: string; successor_type_id: number; }[],
     return roleIds;
 }
 
-async function findExistingFacts(facts: FactRecord[], factTypes: FactTypeMap, connection: PoolClient) {
+async function findExistingFacts(facts: FactRecord[], factTypes: FactTypeMap, connection: PoolClient, schema: string) {
     if (facts.length > 0) {
         const factReferences: FactReference[] = facts.flatMap(fact => [
             ...predecessorsOf(fact),
@@ -626,7 +634,7 @@ async function findExistingFacts(facts: FactRecord[], factTypes: FactTypeMap, co
             [f.hash, factTypes.get(f.type)]);
 
         const sql = 'SELECT fact_id, fact.fact_type_id, fact.hash' +
-            ' FROM public.fact' +
+            ` FROM ${schema}.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 }: FactResult = await connection.query(sql, factParameters);
@@ -641,12 +649,12 @@ async function findExistingFacts(facts: FactRecord[], factTypes: FactTypeMap, co
     }
 }
 
-async function insertFactsEdgesAndAncestors(facts: FactRecord[], factTypes: FactTypeMap, existingFacts: Map<string, Map<number, number>>, connection: PoolClient, roles: RoleMap) {
+async function insertFactsEdgesAndAncestors(facts: FactRecord[], factTypes: FactTypeMap, existingFacts: Map<string, Map<number, number>>, connection: PoolClient, roles: RoleMap, schema: string) {
     if (facts.length === 0) {
         return emptyFactMap();
     }
 
-    const { sql, parameters } = sqlInsertFacts(facts, roles, factTypes);
+    const { sql, parameters } = sqlInsertFacts(facts, roles, factTypes, schema);
 
     const { rows }: FactResult = await connection.query(sql, parameters);
     if (rows.length !== facts.length) {
@@ -659,7 +667,7 @@ async function insertFactsEdgesAndAncestors(facts: FactRecord[], factTypes: Fact
     return allFacts;
 }
 
-function sqlInsertFacts(facts: FactRecord[], roles: RoleMap, factTypes: FactTypeMap) {
+function sqlInsertFacts(facts: FactRecord[], roles: RoleMap, factTypes: FactTypeMap, schema: string) {
     const factValues = facts.map((f, i) => `(\$${i * 3 + 1}, \$${i * 3 + 2}::integer, \$${i * 3 + 3}::jsonb)`);
     const factParameters = flatten(facts, (f) => [f.hash, ensureGetFactTypeId(factTypes, f.type), {
         fields: f.fields,
@@ -668,11 +676,11 @@ function sqlInsertFacts(facts: FactRecord[], roles: RoleMap, factTypes: FactType
 
     const edgeRecords = flatten(facts, fact => makeEdgeRecords(fact));
     if (edgeRecords.length > 0) {
-        return sqlInsertFactsEdgesAndAncestors(facts, factParameters, edgeRecords, factTypes, roles, factValues);
+        return sqlInsertFactsEdgesAndAncestors(facts, factParameters, edgeRecords, factTypes, roles, factValues, schema);
     }
     else {
         return {
-            sql: 'INSERT INTO public.fact (hash, fact_type_id, data) VALUES ' +
+            sql: `INSERT INTO ${schema}.fact (hash, fact_type_id, data) VALUES ` +
                 factValues.join(', ') +
                 ' RETURNING fact_id, hash, fact_type_id;',
             parameters: factParameters
@@ -680,7 +688,7 @@ function sqlInsertFacts(facts: FactRecord[], roles: RoleMap, factTypes: FactType
     }
 }
 
-function sqlInsertFactsEdgesAndAncestors(facts: FactRecord[], factParameters: (string | number | { fields: {}; predecessors: PredecessorCollection; })[], edgeRecords: EdgeRecord[], factTypes: FactTypeMap, roles: RoleMap, factValues: string[]) {
+function sqlInsertFactsEdgesAndAncestors(facts: FactRecord[], factParameters: (string | number | { fields: {}; predecessors: PredecessorCollection; })[], edgeRecords: EdgeRecord[], factTypes: FactTypeMap, roles: RoleMap, factValues: string[], schema: string) {
     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 = flatten(edgeRecords, (e) => {
@@ -722,13 +730,13 @@ new_ancestor AS (
         AS ev (hash, fact_type_id, ancestor_hash, ancestor_fact_type_id)
 ),
 inserted_fact AS (
-    INSERT INTO public.fact (hash, fact_type_id, data)
+    INSERT INTO ${schema}.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
+    INSERT INTO ${schema}.edge
         (role_id, successor_fact_id, predecessor_fact_id)
     SELECT
         new_edge.role_id,
@@ -743,7 +751,7 @@ inserted_edge AS (
         FROM inserted_fact
         UNION ALL
         SELECT fact_id, fact_type_id, hash
-        FROM public.fact
+        FROM ${schema}.fact
     ) AS predecessor
         ON predecessor.hash = new_edge.predecessor_hash
         AND predecessor.fact_type_id = new_edge.predecessor_fact_type_id
@@ -762,20 +770,20 @@ ancestor_id AS (
         FROM inserted_fact
         UNION ALL
         SELECT fact_id, fact_type_id, hash
-        FROM public.fact
+        FROM ${schema}.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
+    INSERT INTO ${schema}.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
+        JOIN ${schema}.ancestor
             ON ancestor.fact_id = ancestor_id.ancestor_fact_id
     ON CONFLICT DO NOTHING
 )
@@ -816,11 +824,11 @@ function recursivePredecessors(factReference: FactReference, facts: FactRecord[]
         });
 }
 
-async function storePublicKeys(envelopes: FactEnvelope[], connection: PoolClient) {
+async function storePublicKeys(envelopes: FactEnvelope[], connection: PoolClient, schema: string) {
     // Look up existing fact types
     const publicKeys = flatten(envelopes, e => e.signatures.map(s => s.publicKey))
         .filter(distinct);
-    const lookUpSql = 'SELECT public_key, public_key_id FROM public.public_key WHERE public_key=ANY($1);';
+    const lookUpSql = `SELECT public_key, public_key_id FROM ${schema}.public_key WHERE public_key=ANY($1);`;
     const { rows: existingRows }: PublicKeyResult = await connection.query(lookUpSql, [publicKeys]);
     const publicKeyIds = existingRows.reduce(
         (map, row) => addFactType(map, row.public_key, row.public_key_id),
@@ -833,7 +841,7 @@ async function storePublicKeys(envelopes: FactEnvelope[], connection: PoolClient
 
     // Insert new fact types
     const values = remainingPublicKeys.map((name, index) => `($${index + 1})`);
-    const insertSql = 'INSERT INTO public.public_key (public_key) VALUES ' + values.join(', ') +
+    const insertSql = `INSERT INTO ${schema}.public_key (public_key) VALUES ` + values.join(', ') +
         ' RETURNING public_key, public_key_id;';
     const { rows: newRows }: PublicKeyResult = await connection.query(insertSql, remainingPublicKeys);
     if (newRows.length !== remainingPublicKeys.length) {
@@ -846,7 +854,7 @@ async function storePublicKeys(envelopes: FactEnvelope[], connection: PoolClient
     return allPublicKeyIds;
 }
 
-async function insertSignatures(envelopes: FactEnvelope[], allFacts: FactMap, factTypes: FactTypeMap, publicKey: PublicKeyMap, connection: PoolClient) {
+async function insertSignatures(envelopes: FactEnvelope[], allFacts: FactMap, factTypes: FactTypeMap, publicKey: PublicKeyMap, connection: PoolClient, schema: string) {
     const signatureRecords = flatten(envelopes, envelope => envelope.signatures.map(signature => ({
         factId: getFactId(allFacts, envelope.fact.hash, ensureGetFactTypeId(factTypes, envelope.fact.type)),
         publicKeyId: getPublicKeyId(publicKey, signature.publicKey),
@@ -858,7 +866,7 @@ async function insertSignatures(envelopes: FactEnvelope[], allFacts: FactMap, fa
         const signatureParameters = flatten(signatureRecords, s =>
             [s.factId, s.publicKeyId, s.signature]);
 
-        const sql = `INSERT INTO public.signature
+        const sql = `INSERT INTO ${schema}.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))