@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/core/ent.js

@@ -26,41 +26,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = exports.EditNodeOperation = exports.RawQueryOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = void 0;
+exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.getDefaultLimit = exports.setDefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = exports.getEntLoader = exports.rowIsError = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
-const action_1 = require("../action");
 const logger_1 = require("./logger");
 const dataloader_1 = __importDefault(require("dataloader"));
-const schema_1 = require("../schema/");
-// TODO kill this and createDataLoader
-class cacheMap {
-    constructor(options) {
-        this.options = options;
-        this.m = new Map();
-    }
-    get(key) {
-        const ret = this.m.get(key);
-        if (ret) {
-            (0, logger_1.log)("cache", {
-                "dataloader-cache-hit": key,
-                "tableName": this.options.tableName,
-            });
-        }
-        return ret;
-    }
-    set(key, value) {
-        return this.m.set(key, value);
-    }
-    delete(key) {
-        return this.m.delete(key);
-    }
-    clear() {
-        return this.m.clear();
-    }
-}
+const global_schema_1 = require("./global_schema");
+const query_impl_1 = require("./query_impl");
+const loader_1 = require("./loaders/loader");
 class entCacheMap {
     constructor(viewer, options) {
         this.viewer = viewer;
@@ -89,11 +64,11 @@ class entCacheMap {
         return this.m.clear();
     }
 }
-function createDataLoader(options) {
+function createAssocEdgeConfigLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
     if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new cacheMap(options);
+        loaderOptions.cacheMap = new loader_1.CacheMap(options);
     }
     // something here brokwn with strict:true
     return new dataloader_1.default(async (ids) => {
@@ -101,9 +76,11 @@ function createDataLoader(options) {
             return [];
         }
         let col = options.key;
+        // defaults to uuid
+        let typ = options.keyType || "uuid";
         const rowOptions = {
             ...options,
-            clause: clause.In(col, ...ids),
+            clause: clause.DBTypeIn(col, ids, typ),
         };
         // TODO is there a better way of doing this?
         // context not needed because we're creating a loader which has its own cache which is being used here
@@ -126,6 +103,13 @@ class ErrorWrapper {
         this.error = error;
     }
 }
+// note if storing the result of this in something that checks instanceof Error e.g. DataLoader, we need to check instanceof at that callsite
+function rowIsError(row) {
+    // jest does things that break instanceof checks
+    // so we need to check the name as well for native error SqliteError
+    return row instanceof Error || row?.constructor?.name === "SqliteError";
+}
+exports.rowIsError = rowIsError;
 function createEntLoader(viewer, options, map) {
     // share the cache across loaders even if we create a new instance
     const loaderOptions = {};
@@ -143,8 +127,14 @@ function createEntLoader(viewer, options, map) {
         for (let idx = 0; idx < rows.length; idx++) {
             const row = rows[idx];
             // db error
-            if (row instanceof Error) {
-                result[idx] = row;
+            if (rowIsError(row)) {
+                if (row instanceof Error) {
+                    result[idx] = row;
+                }
+                else {
+                    // @ts-ignore SqliteError
+                    result[idx] = new Error(row.message);
+                }
                 continue;
             }
             else if (!row) {
@@ -157,7 +147,7 @@ function createEntLoader(viewer, options, map) {
             }
             else {
                 const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
-                if (r instanceof Error) {
+                if (rowIsError(r)) {
                     result[idx] = new ErrorWrapper(r);
                 }
                 else {
@@ -201,6 +191,7 @@ function getEntLoader(viewer, options) {
     const name = `ent-loader:${viewer.instanceKey()}:${options.loaderFactory.name}`;
     return viewer.context.cache.getLoaderWithLoadMany(name, () => new EntLoader(viewer, options));
 }
+exports.getEntLoader = getEntLoader;
 function getEntKey(viewer, id, options) {
     return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
 }
@@ -231,7 +222,7 @@ loader) {
         return result;
     }
     const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
-    if (r instanceof Error) {
+    if (rowIsError(r)) {
         loader.prime(id, new ErrorWrapper(r));
         return new ErrorWrapper(r);
     }
@@ -321,7 +312,7 @@ async function loadEnts(viewer, options, ...ids) {
     let m = new Map();
     const ret = await getEntLoader(viewer, options).loadMany(ids);
     for (const r of ret) {
-        if (r instanceof Error) {
+        if (rowIsError(r)) {
             throw r;
         }
         if (r instanceof ErrorWrapper) {
@@ -396,6 +387,12 @@ function isParameterizedQuery(opts) {
  *   orderby: 'time',
  *   disableTransformations: false
  *  }) // doesn't change the query
+ *
+ * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
+ * or parallel queries with the same clause are batched together.
+ *
+ * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
+ * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
  */
 async function loadCustomData(options, query, context) {
     const rows = await loadCustomDataImpl(options, query, context);
@@ -414,7 +411,10 @@ exports.loadCustomData = loadCustomData;
 // NOTE: if you use a raw query or paramterized query with this,
 // you should use `SELECT count(*) as count...`
 async function loadCustomCount(options, query, context) {
-    // TODO also need to loaderify this in case we're querying for this a lot...
+    // if clause, we'll use the loader and strong typing/coalescing it provides
+    if (typeof query !== "string" && isClause(query)) {
+        return options.loaderFactory.createCountLoader(context).load(query);
+    }
     const rows = await loadCustomDataImpl({
         ...options,
         fields: ["count(1) as count"],
@@ -429,46 +429,31 @@ function isPrimableLoader(loader) {
     return loader != undefined;
 }
 async function loadCustomDataImpl(options, query, context) {
-    function getClause(cls) {
-        let optClause = options.loaderFactory?.options?.clause;
-        if (typeof optClause === "function") {
-            optClause = optClause();
-        }
-        if (!optClause) {
-            return cls;
-        }
-        return clause.And(cls, optClause);
-    }
     if (typeof query === "string") {
         // no caching, perform raw query
         return performRawQuery(query, [], []);
     }
     else if (isClause(query)) {
-        // if a Clause is passed in and we have a default clause
-        // associated with the query, pass that in
-        // if we want to disableTransformations, need to indicate that with
-        // disableTransformations option
-        // this will have rudimentary caching but nothing crazy
-        return loadRows({
-            ...options,
-            clause: getClause(query),
-            context: context,
-        });
+        const r = await options.loaderFactory
+            .createTypedLoader(context)
+            .load(query);
+        return r;
     }
     else if (isParameterizedQuery(query)) {
         // no caching, perform raw query
         return performRawQuery(query.query, query.values || [], query.logValues);
     }
     else {
+        // this will have rudimentary caching but nothing crazy
         let cls = query.clause;
         if (!query.disableTransformations) {
-            cls = getClause(cls);
+            cls = clause.getCombinedClause(options.loaderFactory.options, query.clause);
         }
-        // this will have rudimentary caching but nothing crazy
         return loadRows({
             ...query,
             ...options,
             context: context,
+            // @ts-expect-error
             clause: cls,
         });
     }
@@ -480,7 +465,7 @@ async function loadDerivedEnt(viewer, data, loader) {
     const r = await applyPrivacyPolicyForEnt(viewer, ent, data, {
         ent: loader,
     });
-    if (r instanceof Error) {
+    if (rowIsError(r)) {
         return null;
     }
     return r;
@@ -503,7 +488,7 @@ async function applyPrivacyPolicyForEnt(viewer, ent, data, fieldPrivacyOptions)
 }
 async function applyPrivacyPolicyForEntX(viewer, ent, data, options) {
     const r = await applyPrivacyPolicyForEnt(viewer, ent, data, options);
-    if (r instanceof Error) {
+    if (rowIsError(r)) {
         throw r;
     }
     if (r === null) {
@@ -517,11 +502,12 @@ async function doFieldPrivacy(viewer, ent, data, options) {
     }
     const promises = [];
     let somethingChanged = false;
+    const clone = { ...data };
     const origData = {
         ...data,
     };
     for (const [k, policy] of options.fieldPrivacy) {
-        const curr = data[k];
+        const curr = clone[k];
         if (curr === null || curr === undefined) {
             continue;
         }
@@ -529,7 +515,7 @@ async function doFieldPrivacy(viewer, ent, data, options) {
             // don't do anything if key is null or for some reason missing
             const r = await (0, privacy_1.applyPrivacyPolicy)(viewer, policy, ent);
             if (!r) {
-                data[k] = null;
+                clone[k] = null;
                 somethingChanged = true;
             }
         })());
@@ -537,7 +523,7 @@ async function doFieldPrivacy(viewer, ent, data, options) {
     await Promise.all(promises);
     if (somethingChanged) {
         // have to create new instance
-        const ent = new options.ent(viewer, data);
+        const ent = new options.ent(viewer, clone);
         ent.__setRawDBData(origData);
         return ent;
     }
@@ -605,7 +591,7 @@ async function performRawQuery(query, values, logValues) {
     catch (e) {
         if (_logQueryWithError) {
             const msg = e.message;
-            throw new Error(`error \`${msg}\` running query: \`${query}\``);
+            throw new Error(`error \`${msg}\` running query: \`${query}\` with values: \`${logValues}\``);
         }
         throw e;
     }
@@ -634,17 +620,18 @@ function buildQuery(options) {
     const fields = options.fields.join(", ");
     // always start at 1
     const whereClause = options.clause.clause(1);
-    let query = `SELECT ${fields} FROM ${options.tableName} WHERE ${whereClause}`;
+    const parts = [];
+    parts.push(`SELECT ${fields} FROM ${options.tableName} WHERE ${whereClause}`);
     if (options.groupby) {
-        query = `${query} GROUP BY ${options.groupby}`;
+        parts.push(`GROUP BY ${options.groupby}`);
     }
     if (options.orderby) {
-        query = `${query} ORDER BY ${options.orderby}`;
+        parts.push(`ORDER BY ${(0, query_impl_1.getOrderByPhrase)(options.orderby)}`);
     }
     if (options.limit) {
-        query = `${query} LIMIT ${options.limit}`;
+        parts.push(`LIMIT ${options.limit}`);
     }
-    return query;
+    return parts.join(" ");
 }
 exports.buildQuery = buildQuery;
 // this is used for queries when we select multiple ids at once
@@ -656,7 +643,7 @@ function buildGroupQuery(options) {
     }
     let orderby = "";
     if (options.orderby) {
-        orderby = `ORDER BY ${options.orderby}`;
+        orderby = `ORDER BY ${(0, query_impl_1.getOrderByPhrase)(options.orderby)}`;
     }
     // window functions work in sqlite!
     //    https://www.sqlite.org/windowfunctions.html
@@ -666,499 +653,6 @@ function buildGroupQuery(options) {
     ];
 }
 exports.buildGroupQuery = buildGroupQuery;
-class RawQueryOperation {
-    constructor(queries) {
-        this.queries = queries;
-    }
-    async performWrite(queryer, context) {
-        for (const q of this.queries) {
-            if (typeof q === "string") {
-                logQuery(q, []);
-                await queryer.query(q);
-            }
-            else {
-                logQuery(q.query, q.logValues || []);
-                await queryer.query(q.query, q.values);
-            }
-        }
-    }
-    performWriteSync(queryer, context) {
-        for (const q of this.queries) {
-            if (typeof q === "string") {
-                logQuery(q, []);
-                queryer.execSync(q);
-            }
-            else {
-                logQuery(q.query, q.logValues || []);
-                queryer.execSync(q.query, q.values);
-            }
-        }
-    }
-}
-exports.RawQueryOperation = RawQueryOperation;
-class EditNodeOperation {
-    constructor(options, existingEnt = null) {
-        this.options = options;
-        this.existingEnt = existingEnt;
-        this.row = null;
-        this.placeholderID = options.placeholderID;
-    }
-    resolve(executor) {
-        if (!this.options.fieldsToResolve.length) {
-            return;
-        }
-        let fields = this.options.fields;
-        this.options.fieldsToResolve.forEach((fieldName) => {
-            let value = fields[fieldName];
-            if (!value) {
-                throw new Error(`trying to resolve field ${fieldName} but not a valid field`);
-            }
-            let ent = executor.resolveValue(value.placeholderID);
-            if (!ent) {
-                throw new Error(`couldn't resolve field \`${fieldName}\` with value ${value.placeholderID}`);
-            }
-            fields[fieldName] = ent.id;
-        });
-        this.options.fields = fields;
-    }
-    hasData(data) {
-        for (const _k in data) {
-            return true;
-        }
-        return false;
-    }
-    async performWrite(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        if (this.existingEnt) {
-            if (this.hasData(options.fields)) {
-                // even this with returning * may not always work if transformed...
-                // we can have a transformed flag to see if it should be returned?
-                this.row = await editRow(queryer, options, "RETURNING *");
-            }
-            else {
-                // @ts-ignore
-                this.row = this.existingEnt["data"];
-            }
-        }
-        else {
-            this.row = await createRow(queryer, options, "RETURNING *");
-        }
-    }
-    reloadRow(queryer, id, options) {
-        // TODO this isn't always an ObjectLoader. should throw or figure out a way to get query
-        // and run this on its own...
-        const loader = this.options.loadEntOptions.loaderFactory.createLoader(options.context);
-        const opts = loader.getOptions();
-        let cls = clause.Eq(options.key, id);
-        if (opts.clause) {
-            let optionClause;
-            if (typeof opts.clause === "function") {
-                optionClause = opts.clause();
-            }
-            else {
-                optionClause = opts.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(cls, optionClause);
-            }
-        }
-        const query = buildQuery({
-            fields: opts.fields.length ? opts.fields : ["*"],
-            tableName: options.tableName,
-            clause: cls,
-        });
-        // special case log here because we're not going through any of the normal
-        // methods here because those are async and this is sync
-        // this is the only place we're doing this so only handling here
-        logQuery(query, [id]);
-        const r = queryer.querySync(query, [id]);
-        if (r.rows.length === 1) {
-            this.row = r.rows[0];
-        }
-    }
-    performWriteSync(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        if (this.existingEnt) {
-            if (this.hasData(this.options.fields)) {
-                editRowSync(queryer, options, "RETURNING *");
-                this.reloadRow(queryer, this.existingEnt.id, options);
-            }
-            else {
-                // @ts-ignore
-                this.row = this.existingEnt["data"];
-            }
-        }
-        else {
-            createRowSync(queryer, options, "RETURNING *");
-            const id = options.fields[options.key];
-            this.reloadRow(queryer, id, options);
-        }
-    }
-    returnedRow() {
-        return this.row;
-    }
-    createdEnt(viewer) {
-        if (!this.row) {
-            return null;
-        }
-        return new this.options.loadEntOptions.ent(viewer, this.row);
-    }
-}
-exports.EditNodeOperation = EditNodeOperation;
-let globalSchema;
-function setGlobalSchema(val) {
-    globalSchema = val;
-}
-exports.setGlobalSchema = setGlobalSchema;
-function clearGlobalSchema() {
-    globalSchema = undefined;
-}
-exports.clearGlobalSchema = clearGlobalSchema;
-// used by tests. no guarantee will always exist
-function __hasGlobalSchema() {
-    return globalSchema !== undefined;
-}
-exports.__hasGlobalSchema = __hasGlobalSchema;
-class EdgeOperation {
-    constructor(builder, edgeInput, options) {
-        this.builder = builder;
-        this.edgeInput = edgeInput;
-        this.options = options;
-    }
-    async preFetch(queryer, context) {
-        let edgeData = await loadEdgeData(this.edgeInput.edgeType);
-        if (!edgeData) {
-            throw new Error(`error loading edge data for ${this.edgeInput.edgeType}`);
-        }
-        this.edgeData = edgeData;
-    }
-    async performWrite(queryer, context) {
-        if (!this.edgeData) {
-            throw new Error(`error fetching edgeData for type ${this.edgeInput.edgeType}`);
-        }
-        switch (this.options.operation) {
-            case action_1.WriteOperation.Delete:
-                return this.performDeleteWrite(queryer, this.edgeData, this.edgeInput, context);
-            case action_1.WriteOperation.Insert:
-            case action_1.WriteOperation.Edit:
-                return this.performInsertWrite(queryer, this.edgeData, this.edgeInput, context);
-        }
-    }
-    performWriteSync(queryer, context) {
-        if (!this.edgeData) {
-            throw new Error(`error fetching edgeData for type ${this.edgeInput.edgeType}`);
-        }
-        switch (this.options.operation) {
-            case action_1.WriteOperation.Delete:
-                return this.performDeleteWriteSync(queryer, this.edgeData, this.edgeInput, context);
-            case action_1.WriteOperation.Insert:
-            case action_1.WriteOperation.Edit:
-                return this.performInsertWriteSync(queryer, this.edgeData, this.edgeInput, context);
-        }
-    }
-    getDeleteRowParams(edgeData, edge, context) {
-        let transformed = null;
-        let op = schema_1.SQLStatementOperation.Delete;
-        let updateData = null;
-        // TODO respect disableTransformations
-        if (globalSchema?.transformEdgeWrite) {
-            transformed = globalSchema.transformEdgeWrite({
-                op: schema_1.SQLStatementOperation.Delete,
-                edge,
-            });
-            if (transformed) {
-                op = transformed.op;
-                if (transformed.op === schema_1.SQLStatementOperation.Insert) {
-                    throw new Error(`cannot currently transform a delete into an insert`);
-                }
-                if (transformed.op === schema_1.SQLStatementOperation.Update) {
-                    if (!transformed.data) {
-                        throw new Error(`cannot transform a delete into an update without providing data`);
-                    }
-                    updateData = transformed.data;
-                }
-            }
-        }
-        return {
-            op,
-            updateData,
-            options: {
-                tableName: edgeData.edgeTable,
-                context,
-            },
-            clause: clause.And(clause.Eq("id1", edge.id1), clause.Eq("id2", edge.id2), clause.Eq("edge_type", edge.edgeType)),
-        };
-    }
-    async performDeleteWrite(q, edgeData, edge, context) {
-        const params = this.getDeleteRowParams(edgeData, edge, context);
-        if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return deleteRows(q, params.options, params.clause);
-        }
-        else {
-            if (params.op !== schema_1.SQLStatementOperation.Update) {
-                throw new Error(`invalid operation ${params.op}`);
-            }
-            await editRow(q, {
-                tableName: params.options.tableName,
-                whereClause: params.clause,
-                fields: params.updateData,
-                fieldsToLog: params.updateData,
-            });
-        }
-    }
-    performDeleteWriteSync(q, edgeData, edge, context) {
-        const params = this.getDeleteRowParams(edgeData, edge, context);
-        if (params.op === schema_1.SQLStatementOperation.Delete) {
-            return deleteRowsSync(q, params.options, params.clause);
-        }
-        else {
-            if (params.op !== schema_1.SQLStatementOperation.Update) {
-                throw new Error(`invalid operation ${params.op}`);
-            }
-            editRowSync(q, {
-                tableName: params.options.tableName,
-                whereClause: params.clause,
-                fields: params.updateData,
-            });
-        }
-    }
-    getInsertRowParams(edgeData, edge, context) {
-        const fields = {
-            id1: edge.id1,
-            id2: edge.id2,
-            id1_type: edge.id1Type,
-            id2_type: edge.id2Type,
-            edge_type: edge.edgeType,
-            data: edge.data || null,
-        };
-        if (edge.time) {
-            fields["time"] = edge.time.toISOString();
-        }
-        else {
-            // todo make this a schema field like what we do in generated base files...
-            // maybe when actions exist?
-            fields["time"] = new Date().toISOString();
-        }
-        const onConflictFields = ["data"];
-        if (globalSchema?.extraEdgeFields) {
-            for (const name in globalSchema.extraEdgeFields) {
-                const f = globalSchema.extraEdgeFields[name];
-                if (f.defaultValueOnCreate) {
-                    const storageKey = (0, schema_1.getStorageKey)(f, name);
-                    fields[storageKey] = f.defaultValueOnCreate(this.builder, {});
-                    // onconflict make sure we override the default values
-                    // e.g. setting deleted_at = null for soft delete
-                    onConflictFields.push(storageKey);
-                }
-            }
-        }
-        // TODO respect disableTransformations
-        let transformed = null;
-        if (globalSchema?.transformEdgeWrite) {
-            transformed = globalSchema.transformEdgeWrite({
-                op: schema_1.SQLStatementOperation.Insert,
-                edge,
-            });
-            if (transformed) {
-                throw new Error(`transforming an insert edge not currently supported`);
-            }
-        }
-        return [
-            {
-                tableName: edgeData.edgeTable,
-                fields: fields,
-                fieldsToLog: fields,
-                context,
-            },
-            `ON CONFLICT(id1, edge_type, id2) DO UPDATE SET ${onConflictFields
-                .map((f) => `${f} = EXCLUDED.${f}`)
-                .join(", ")}`,
-        ];
-    }
-    async performInsertWrite(q, edgeData, edge, context) {
-        const [options, suffix] = this.getInsertRowParams(edgeData, edge, context);
-        await createRow(q, options, suffix);
-    }
-    performInsertWriteSync(q, edgeData, edge, context) {
-        const [options, suffix] = this.getInsertRowParams(edgeData, edge, context);
-        createRowSync(q, options, suffix);
-    }
-    resolveImpl(executor, placeholder, desc) {
-        let ent = executor.resolveValue(placeholder);
-        if (!ent) {
-            throw new Error(`could not resolve placeholder value ${placeholder} for ${desc} for edge ${this.edgeInput.edgeType}`);
-        }
-        if (ent.id === undefined) {
-            throw new Error(`id of resolved ent is not defined`);
-        }
-        return [ent.id, ent.nodeType];
-    }
-    resolve(executor) {
-        if (this.options.id1Placeholder) {
-            [this.edgeInput.id1, this.edgeInput.id1Type] = this.resolveImpl(executor, this.edgeInput.id1, "id1");
-        }
-        if (this.options.id2Placeholder) {
-            [this.edgeInput.id2, this.edgeInput.id2Type] = this.resolveImpl(executor, this.edgeInput.id2, "id2");
-        }
-        if (this.options.dataPlaceholder) {
-            if (!this.edgeInput.data) {
-                throw new Error(`data placeholder set but edgeInput data undefined`);
-            }
-            let [data, _] = this.resolveImpl(executor, this.edgeInput.data.toString(), "data");
-            this.edgeInput.data = data.toString();
-        }
-    }
-    symmetricEdge() {
-        return new EdgeOperation(this.builder, {
-            id1: this.edgeInput.id2,
-            id1Type: this.edgeInput.id2Type,
-            id2: this.edgeInput.id1,
-            id2Type: this.edgeInput.id1Type,
-            edgeType: this.edgeInput.edgeType,
-            time: this.edgeInput.time,
-            data: this.edgeInput.data,
-        }, {
-            operation: this.options.operation,
-            id1Placeholder: this.options.id2Placeholder,
-            id2Placeholder: this.options.id1Placeholder,
-            dataPlaceholder: this.options.dataPlaceholder,
-        });
-    }
-    inverseEdge(edgeData) {
-        return new EdgeOperation(this.builder, {
-            id1: this.edgeInput.id2,
-            id1Type: this.edgeInput.id2Type,
-            id2: this.edgeInput.id1,
-            id2Type: this.edgeInput.id1Type,
-            edgeType: edgeData.inverseEdgeType,
-            time: this.edgeInput.time,
-            data: this.edgeInput.data,
-        }, {
-            operation: this.options.operation,
-            id1Placeholder: this.options.id2Placeholder,
-            id2Placeholder: this.options.id1Placeholder,
-            dataPlaceholder: this.options.dataPlaceholder,
-        });
-    }
-    static resolveIDs(srcBuilder, // id1
-    destID) {
-        let destIDVal;
-        let destPlaceholder = false;
-        if (this.isBuilder(destID)) {
-            destIDVal = destID.placeholderID;
-            destPlaceholder = true;
-        }
-        else {
-            destIDVal = destID;
-        }
-        let srcIDVal;
-        let srcType;
-        let srcPlaceholder = false;
-        if (srcBuilder.existingEnt) {
-            srcIDVal = srcBuilder.existingEnt.id;
-            srcType = srcBuilder.existingEnt.nodeType;
-        }
-        else {
-            srcPlaceholder = true;
-            // get placeholder.
-            srcIDVal = srcBuilder.placeholderID;
-            // expected to be filled later
-            srcType = "";
-        }
-        return [srcIDVal, srcType, srcPlaceholder, destIDVal, destPlaceholder];
-    }
-    static isBuilder(val) {
-        return val.placeholderID !== undefined;
-    }
-    static resolveData(data) {
-        if (!data) {
-            return [undefined, false];
-        }
-        if (this.isBuilder(data)) {
-            return [data.placeholderID.toString(), true];
-        }
-        return [data, false];
-    }
-    static inboundEdge(builder, edgeType, id1, nodeType, options) {
-        let [id2Val, id2Type, id2Placeholder, id1Val, id1Placeholder] = EdgeOperation.resolveIDs(builder, id1);
-        let [data, dataPlaceholder] = EdgeOperation.resolveData(options?.data);
-        const edge = {
-            id1: id1Val,
-            edgeType: edgeType,
-            id2: id2Val,
-            id2Type: id2Type,
-            id1Type: nodeType,
-            ...options,
-        };
-        if (data) {
-            edge.data = data;
-        }
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Insert,
-            id2Placeholder,
-            id1Placeholder,
-            dataPlaceholder,
-        });
-    }
-    static outboundEdge(builder, edgeType, id2, nodeType, options) {
-        let [id1Val, id1Type, id1Placeholder, id2Val, id2Placeholder] = EdgeOperation.resolveIDs(builder, id2);
-        let [data, dataPlaceholder] = EdgeOperation.resolveData(options?.data);
-        const edge = {
-            id1: id1Val,
-            edgeType: edgeType,
-            id2: id2Val,
-            id2Type: nodeType,
-            id1Type: id1Type,
-            ...options,
-        };
-        if (data) {
-            edge.data = data;
-        }
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Insert,
-            id1Placeholder,
-            id2Placeholder,
-            dataPlaceholder,
-        });
-    }
-    static removeInboundEdge(builder, edgeType, id1) {
-        if (!builder.existingEnt) {
-            throw new Error("cannot remove an edge from a non-existing ent");
-        }
-        const edge = {
-            id1: id1,
-            edgeType: edgeType,
-            id2: builder.existingEnt.id,
-            id2Type: "",
-            id1Type: "",
-        };
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Delete,
-        });
-    }
-    static removeOutboundEdge(builder, edgeType, id2) {
-        if (!builder.existingEnt) {
-            throw new Error("cannot remove an edge from a non-existing ent");
-        }
-        const edge = {
-            id2: id2,
-            edgeType: edgeType,
-            id1: builder.existingEnt.id,
-            id2Type: "",
-            id1Type: "",
-        };
-        return new EdgeOperation(builder, edge, {
-            operation: action_1.WriteOperation.Delete,
-        });
-    }
-}
-exports.EdgeOperation = EdgeOperation;
 function isSyncQueryer(queryer) {
     return queryer.execSync !== undefined;
 }
@@ -1228,8 +722,26 @@ function buildInsertQuery(options, suffix) {
     const cols = fields.join(", ");
     const vals = valsString.join(", ");
     let query = `INSERT INTO ${options.tableName} (${cols}) VALUES (${vals})`;
+    if (options.onConflict) {
+        let onConflict = "";
+        if (options.onConflict.onConflictConstraint) {
+            onConflict = `ON CONFLICT ON CONSTRAINT ${options.onConflict.onConflictConstraint}`;
+        }
+        else {
+            onConflict = `ON CONFLICT(${options.onConflict.onConflictCols.join(", ")})`;
+        }
+        if (options.onConflict.updateCols?.length) {
+            onConflict += ` DO UPDATE SET ${options.onConflict.updateCols
+                .map((f) => `${f} = EXCLUDED.${f}`)
+                .join(", ")}`;
+        }
+        else {
+            onConflict += ` DO NOTHING`;
+        }
+        query = query + " " + onConflict;
+    }
     if (suffix) {
-        query = query + " " + suffix;
+        query += " " + suffix;
     }
     return [query, values, logValues];
 }
@@ -1336,27 +848,6 @@ function deleteRowsSync(queryer, options, cls) {
     mutateRowSync(queryer, query, cls.values(), cls.logValues(), options);
 }
 exports.deleteRowsSync = deleteRowsSync;
-class DeleteNodeOperation {
-    constructor(id, options) {
-        this.id = id;
-        this.options = options;
-    }
-    async performWrite(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        return deleteRows(queryer, options, clause.Eq("id", this.id));
-    }
-    performWriteSync(queryer, context) {
-        let options = {
-            ...this.options,
-            context,
-        };
-        return deleteRowsSync(queryer, options, clause.Eq("id", this.id));
-    }
-}
-exports.DeleteNodeOperation = DeleteNodeOperation;
 class AssocEdge {
     constructor(data) {
         this.id1 = data.id1;
@@ -1417,10 +908,11 @@ const assocEdgeFields = [
     "inverse_edge_type",
     "edge_table",
 ];
-exports.assocEdgeLoader = createDataLoader({
+exports.assocEdgeLoader = createAssocEdgeConfigLoader({
     tableName: "assoc_edge_config",
     fields: assocEdgeFields,
     key: "edge_type",
+    keyType: "uuid",
 });
 // we don't expect assoc_edge_config information to change
 // so not using ContextCache but just caching it as needed once per server
@@ -1442,7 +934,7 @@ async function loadEdgeDatas(...edgeTypes) {
         if (!row) {
             return;
         }
-        if (row instanceof Error) {
+        if (rowIsError(row)) {
             throw row;
         }
         m.set(row["edge_type"], new AssocEdgeData(row));
@@ -1459,8 +951,15 @@ const edgeFields = [
     "time",
     "data",
 ];
-exports.DefaultLimit = 1000;
-// TODO default limit from somewhere
+let defaultLimit = 1000;
+function setDefaultLimit(limit) {
+    defaultLimit = limit;
+}
+exports.setDefaultLimit = setDefaultLimit;
+function getDefaultLimit() {
+    return defaultLimit;
+}
+exports.getDefaultLimit = getDefaultLimit;
 function defaultEdgeQueryOptions(id1, edgeType, id2) {
     let cls = clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType));
     if (id2) {
@@ -1468,8 +967,13 @@ function defaultEdgeQueryOptions(id1, edgeType, id2) {
     }
     return {
         clause: cls,
-        orderby: "time DESC",
-        limit: exports.DefaultLimit,
+        orderby: [
+            {
+                column: "time",
+                direction: "DESC",
+            },
+        ],
+        limit: defaultLimit,
     };
 }
 async function loadEdges(options) {
@@ -1478,9 +982,10 @@ async function loadEdges(options) {
 exports.loadEdges = loadEdges;
 function getEdgeClauseAndFields(cls, options) {
     let fields = edgeFields;
-    if (globalSchema?.transformEdgeRead) {
-        const transformClause = globalSchema.transformEdgeRead();
-        if (!options.disableTransformations) {
+    const transformEdgeRead = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeRead;
+    if (transformEdgeRead) {
+        const transformClause = transformEdgeRead();
+        if (!options.queryOptions?.disableTransformations) {
             cls = clause.And(cls, transformClause);
         }
         fields = edgeFields.concat(transformClause.columns());
@@ -1598,7 +1103,7 @@ async function loadNodesByEdge(viewer, id1, edgeType, options) {
 exports.loadNodesByEdge = loadNodesByEdge;
 async function applyPrivacyPolicyForRow(viewer, options, row) {
     const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
-    return r instanceof Error ? null : r;
+    return rowIsError(r) ? null : r;
 }
 exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
 async function applyPrivacyPolicyForRowImpl(viewer, options, row) {
@@ -1656,7 +1161,7 @@ async function getEdgeTypeInGroup(viewer, id1, id2, m) {
     tableToEdgeEnumMap.forEach((edgeEnums, tableName) => {
         promises.push((async () => {
             const edgeTypes = edgeEnums.map((edgeEnum) => m.get(edgeEnum));
-            const { cls, fields } = getEdgeClauseAndFields(clause.And(clause.Eq("id1", id1), clause.In("edge_type", edgeTypes), clause.Eq("id2", id2)), {});
+            const { cls, fields } = getEdgeClauseAndFields(clause.And(clause.Eq("id1", id1), clause.UuidIn("edge_type", edgeTypes), clause.Eq("id2", id2)), {});
             const rows = await loadRows({
                 tableName,
                 fields,