@snowtop/ent 0.1.0-alpha7 → 0.1.0-alpha75

package/core/ent.js

@@ -22,14 +22,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.loadEdges = exports.defaultEdgeQueryOptions = 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.EditNodeOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.applyPrivacyPolicyForEntX = exports.applyPrivacyPolicyForEnt = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = void 0;
-exports.getEdgeTypeInGroup = void 0;
+exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.defaultEdgeQueryOptions = 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.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.loadRow = exports.loadRowX = exports.loadDerivedEntX = exports.loadDerivedEnt = 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 = 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) {
@@ -39,7 +40,7 @@ class cacheMap {
     get(key) {
         const ret = this.m.get(key);
         if (ret) {
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key,
                 "tableName": this.options.tableName,
             });
@@ -62,6 +63,7 @@ function createDataLoader(options) {
     if ((0, logger_1.logEnabled)("query")) {
         loaderOptions.cacheMap = new cacheMap(options);
     }
+    // something here brokwn with strict:true
     return new dataloader_1.default(async (ids) => {
         if (!ids.length) {
             return [];
@@ -85,10 +87,58 @@ function createDataLoader(options) {
         return result;
     }, loaderOptions);
 }
+function getEntKey(viewer, id, options) {
+    return `${viewer.instanceKey()}:${options.loaderFactory.name}:${id}`;
+}
+exports.getEntKey = getEntKey;
+// fetches the ent from cache if cache exists.
+function entFromCacheMaybe(viewer, id, options) {
+    const cache = viewer.context?.cache?.getEntCache();
+    if (!cache) {
+        return {};
+    }
+    const key = getEntKey(viewer, id, options);
+    const r = cache.get(key);
+    if (r !== undefined) {
+        (0, logger_1.log)("cache", {
+            "ent-cache-hit": key,
+        });
+    }
+    return {
+        key,
+        ent: r instanceof Error ? undefined : r,
+        error: r instanceof Error ? r : undefined,
+        cache,
+    };
+}
 // Ent accessors
+async function applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info) {
+    const ent = await applyPrivacyPolicyForRow(viewer, options, row);
+    if (info.cache && info.key) {
+        info.cache.set(info.key, ent);
+    }
+    return ent instanceof Error ? null : ent;
+}
+async function applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info) {
+    const ent = await applyPrivacyPolicyForRowImpl(viewer, options, row);
+    if (info.cache && info.key) {
+        info.cache.set(info.key, ent);
+    }
+    if (ent instanceof Error) {
+        throw ent;
+    }
+    if (ent === null) {
+        throw new Error(`TODO`);
+    }
+    return ent;
+}
 async function loadEnt(viewer, id, options) {
+    const info = entFromCacheMaybe(viewer, id, options);
+    if (info.ent !== undefined) {
+        return info.ent;
+    }
     const row = await options.loaderFactory.createLoader(viewer.context).load(id);
-    return await applyPrivacyPolicyForRow(viewer, options, row);
+    return applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
 }
 exports.loadEnt = loadEnt;
 // this is the same implementation-wise (right now) as loadEnt. it's just clearer that it's not loaded via ID.
@@ -97,18 +147,36 @@ async function loadEntViaKey(viewer, key, options) {
     const row = await options.loaderFactory
         .createLoader(viewer.context)
         .load(key);
-    return await applyPrivacyPolicyForRow(viewer, options, row);
+    if (!row) {
+        return null;
+    }
+    // TODO every row.id needs to be audited...
+    const info = entFromCacheMaybe(viewer, row.id, options);
+    if (info.ent !== undefined) {
+        return info.ent;
+    }
+    return applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
 }
 exports.loadEntViaKey = loadEntViaKey;
+// need a cached error...
 async function loadEntX(viewer, id, options) {
+    const info = entFromCacheMaybe(viewer, id, options);
+    if (info.error !== undefined) {
+        throw info.error;
+    }
+    if (info.ent !== undefined && info.ent !== null) {
+        return info.ent;
+    }
     const row = await options.loaderFactory.createLoader(viewer.context).load(id);
     if (!row) {
         // todo make this better
         throw new Error(`${options.loaderFactory.name}: couldn't find row for value ${id}`);
     }
-    return await applyPrivacyPolicyForRowX(viewer, options, row);
+    return applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info);
 }
 exports.loadEntX = loadEntX;
+// TODO test this and loadEntViaKey
+// replace loadEntViaClause??
 async function loadEntXViaKey(viewer, key, options) {
     const row = await options.loaderFactory
         .createLoader(viewer.context)
@@ -117,9 +185,19 @@ async function loadEntXViaKey(viewer, key, options) {
         // todo make this better
         throw new Error(`${options.loaderFactory.name}: couldn't find row for value ${key}`);
     }
-    return await applyPrivacyPolicyForRowX(viewer, options, row);
+    const info = entFromCacheMaybe(viewer, row.id, options);
+    if (info.error !== undefined) {
+        throw info.error;
+    }
+    if (info.ent !== undefined && info.ent !== null) {
+        return info.ent;
+    }
+    return applyPrivacyPolicyForRowAndStoreInCacheX(viewer, options, row, info);
 }
 exports.loadEntXViaKey = loadEntXViaKey;
+/**
+ * @deprecated use loadCustomEnts
+ */
 async function loadEntFromClause(viewer, options, clause) {
     const rowOptions = {
         ...options,
@@ -127,12 +205,15 @@ async function loadEntFromClause(viewer, options, clause) {
         context: viewer.context,
     };
     const row = await loadRow(rowOptions);
-    return await applyPrivacyPolicyForRow(viewer, options, row);
+    return applyPrivacyPolicyForRow(viewer, options, row);
 }
 exports.loadEntFromClause = loadEntFromClause;
 // same as loadEntFromClause
 // only works for ents where primary key is "id"
 // use loadEnt with a loaderFactory if different
+/**
+ * @deprecated use loadCustomEnts
+ */
 async function loadEntXFromClause(viewer, options, clause) {
     const rowOptions = {
         ...options,
@@ -140,41 +221,69 @@ async function loadEntXFromClause(viewer, options, clause) {
         context: viewer.context,
     };
     const row = await loadRowX(rowOptions);
-    const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEntX(viewer, ent);
+    return await applyPrivacyPolicyForRowX(viewer, options, row);
 }
 exports.loadEntXFromClause = loadEntXFromClause;
 async function loadEnts(viewer, options, ...ids) {
     if (!ids.length) {
         return new Map();
     }
-    let loaded = false;
-    let rows = [];
-    // TODO loadMany everywhere
-    const l = options.loaderFactory.createLoader(viewer.context);
-    if (l.loadMany) {
-        loaded = true;
-        rows = await l.loadMany(ids);
-    }
-    // TODO rewrite all of this
+    // result
     let m = new Map();
-    if (loaded) {
-        let rows2 = [];
-        for (const row of rows) {
-            if (!row) {
-                continue;
+    const cache = viewer.context?.cache?.getEntCache();
+    let toFetch = [];
+    if (cache) {
+        for (const id of ids) {
+            const key = getEntKey(viewer, id, options);
+            const ent = cache.get(key);
+            if (ent !== undefined) {
+                (0, logger_1.log)("cache", {
+                    "ent-cache-hit": key,
+                });
+                if (ent === null) {
+                    // TODO this should return null if not loadable...
+                    continue;
+                }
+                // @ts-ignore
+                m.set(id, ent);
             }
-            if (row instanceof Error) {
-                throw row;
+            else {
+                toFetch.push(id);
             }
-            rows2.push(row);
         }
-        m = await applyPrivacyPolicyForRows(viewer, rows2, options);
     }
     else {
-        m = await loadEntsFromClause(viewer, 
-        // this is always "id" if not using an ObjectLoaderFactory
-        clause.In("id", ...ids), options);
+        toFetch = ids;
+    }
+    // all in ent cache!
+    if (!toFetch.length) {
+        return m;
+    }
+    const l = options.loaderFactory.createLoader(viewer.context);
+    const rows = await l.loadMany(toFetch);
+    let rows2 = [];
+    for (const row of rows) {
+        if (!row) {
+            continue;
+        }
+        if (row instanceof Error) {
+            throw row;
+        }
+        rows2.push(row);
+    }
+    const m2 = await applyPrivacyPolicyForRows(viewer, rows2, options);
+    for (const row of rows2) {
+        const id = row[options.loaderFactory.options?.key || "id"];
+        const ent = m2.get(id);
+        if (cache) {
+            // put back in cache...
+            // store null for rows that can't be seen
+            cache.set(getEntKey(viewer, id, options), ent ?? null);
+        }
+        if (ent !== undefined) {
+            // TODO this should return null if not loadable...?
+            m.set(id, ent);
+        }
     }
     return m;
     // TODO do we want to change this to be a map not a list so that it's easy to check for existence?
@@ -197,6 +306,9 @@ async function loadEntsList(viewer, options, ...ids) {
 exports.loadEntsList = loadEntsList;
 // we return a map here so that any sorting for queries that exist
 // can be done in O(N) time
+/**
+ * @deperecated use loadCustomEnts
+ */
 async function loadEntsFromClause(viewer, clause, options) {
     const rowOptions = {
         ...options,
@@ -211,8 +323,18 @@ async function loadCustomEnts(viewer, options, query) {
     const rows = await loadCustomData(options, query, viewer.context);
     const result = new Array(rows.length);
     await Promise.all(rows.map(async (row, idx) => {
-        const ent = new options.ent(viewer, row);
-        let privacyEnt = await applyPrivacyPolicyForEnt(viewer, ent);
+        // TODO what if key is different
+        const info = entFromCacheMaybe(viewer, row.id, options);
+        if (info.ent !== undefined) {
+            if (info.ent === null) {
+                // we're done here
+                return;
+            }
+            // @ts-ignore
+            result[idx] = info.ent;
+            return;
+        }
+        const privacyEnt = await applyPrivacyPolicyForRowAndStoreInCache(viewer, options, row, info);
         if (privacyEnt) {
             result[idx] = privacyEnt;
         }
@@ -225,63 +347,163 @@ function isClause(opts) {
     const cls = opts;
     return cls.clause !== undefined && cls.values !== undefined;
 }
-function isRawQuery(opts) {
+function isParameterizedQuery(opts) {
     return opts.query !== undefined;
 }
+/**
+ * Note that if there's default read transformations (e.g. soft delete) and a clause is passed in
+ * either as Clause or QueryDataOptions without {disableTransformations: true}, the default transformation
+ * (e.g. soft delete) is applied.
+ *
+ * Passing a full SQL string or Paramterized SQL string doesn't apply it and the given string is sent to the
+ * database as written.
+ *
+ * e.g.
+ * Foo.loadCustom(opts, 'SELECT * FROM foo') // doesn't change the query
+ * Foo.loadCustom(opts, { query: 'SELECT * FROM foo WHERE id = ?', values: [1]}) // doesn't change the query
+ * Foo.loadCustom(opts, query.Eq('time', Date.now())) // changes the query
+ * Foo.loadCustom(opts, {
+ *   clause:  query.LessEq('time', Date.now()),
+ *   limit: 100,
+ *   orderby: 'time',
+ *  }) // changes the query
+ * Foo.loadCustom(opts, {
+ *   clause:  query.LessEq('time', Date.now()),
+ *   limit: 100,
+ *   orderby: 'time',
+ *   disableTransformations: false
+ *  }) // doesn't change the query
+ */
 async function loadCustomData(options, query, context) {
+    const rows = await loadCustomDataImpl(options, query, context);
+    // prime the data so that subsequent fetches of the row with this id are a cache hit.
+    if (options.prime) {
+        const loader = options.loaderFactory.createLoader(context);
+        if (isPrimableLoader(loader) && loader.primeAll !== undefined) {
+            for (const row of rows) {
+                loader.primeAll(row);
+            }
+        }
+    }
+    return rows;
+}
+exports.loadCustomData = loadCustomData;
+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 await performRawQuery(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 await loadRows({
+        return loadRows({
             ...options,
-            clause: query,
+            clause: getClause(query),
             context: context,
         });
     }
-    else if (isRawQuery(query)) {
+    else if (isParameterizedQuery(query)) {
         // no caching, perform raw query
-        return await performRawQuery(query.query, query.values || [], query.logValues);
+        return performRawQuery(query.query, query.values || [], query.logValues);
     }
     else {
+        let cls = query.clause;
+        if (!query.disableTransformations) {
+            cls = getClause(cls);
+        }
         // this will have rudimentary caching but nothing crazy
-        return await loadRows({
+        return loadRows({
             ...query,
             ...options,
             context: context,
+            clause: cls,
         });
     }
 }
-exports.loadCustomData = loadCustomData;
 // Derived ents
+// no ent caching
 async function loadDerivedEnt(viewer, data, loader) {
     const ent = new loader(viewer, data);
-    return await applyPrivacyPolicyForEnt(viewer, ent);
+    const r = await applyPrivacyPolicyForEnt(viewer, ent, data, {
+        ent: loader,
+    });
+    if (r instanceof Error) {
+        return null;
+    }
+    return r;
 }
 exports.loadDerivedEnt = loadDerivedEnt;
+// won't have caching yet either
 async function loadDerivedEntX(viewer, data, loader) {
     const ent = new loader(viewer, data);
-    return await applyPrivacyPolicyForEntX(viewer, ent);
+    return await applyPrivacyPolicyForEntX(viewer, ent, data, { ent: loader });
 }
 exports.loadDerivedEntX = loadDerivedEntX;
-async function applyPrivacyPolicyForEnt(viewer, ent) {
+// everything calls into this two so should be fine
+// TODO is there a smarter way to not instantiate two objects here?
+async function applyPrivacyPolicyForEnt(viewer, ent, data, fieldPrivacyOptions) {
     if (ent) {
-        const visible = await (0, privacy_1.applyPrivacyPolicy)(viewer, ent.privacyPolicy, ent);
-        if (visible) {
-            return ent;
+        const error = await (0, privacy_1.applyPrivacyPolicyImpl)(viewer, ent.getPrivacyPolicy(), ent);
+        if (error === null) {
+            return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
         }
+        return error;
     }
     return null;
 }
-exports.applyPrivacyPolicyForEnt = applyPrivacyPolicyForEnt;
-async function applyPrivacyPolicyForEntX(viewer, ent) {
-    // this will throw
-    await (0, privacy_1.applyPrivacyPolicyX)(viewer, ent.privacyPolicy, ent);
+async function applyPrivacyPolicyForEntX(viewer, ent, data, options) {
+    const r = await applyPrivacyPolicyForEnt(viewer, ent, data, options);
+    if (r instanceof Error) {
+        throw r;
+    }
+    if (r === null) {
+        throw new Error(`couldn't apply privacyPoliy for ent ${ent.id}`);
+    }
+    return r;
+}
+async function doFieldPrivacy(viewer, ent, data, options) {
+    if (!options.fieldPrivacy) {
+        return ent;
+    }
+    const promises = [];
+    let somethingChanged = false;
+    for (const [k, policy] of options.fieldPrivacy) {
+        const curr = data[k];
+        if (curr === null || curr === undefined) {
+            continue;
+        }
+        promises.push((async () => {
+            // 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;
+                somethingChanged = true;
+            }
+        })());
+    }
+    await Promise.all(promises);
+    if (somethingChanged) {
+        // have to create new instance
+        return new options.ent(viewer, data);
+    }
     return ent;
 }
-exports.applyPrivacyPolicyForEntX = applyPrivacyPolicyForEntX;
 function logQuery(query, logValues) {
     (0, logger_1.log)("query", {
         query: query,
@@ -327,6 +549,8 @@ async function loadRow(options) {
         return res.rows[0];
     }
     catch (e) {
+        // an example of an error being suppressed
+        // another one. TODO https://github.com/lolopinto/ent/issues/862
         (0, logger_1.log)("error", e);
         return null;
     }
@@ -406,6 +630,7 @@ class EditNodeOperation {
     constructor(options, existingEnt = null) {
         this.options = options;
         this.existingEnt = existingEnt;
+        this.row = null;
         this.placeholderID = options.placeholderID;
     }
     resolve(executor) {
@@ -439,9 +664,12 @@ class EditNodeOperation {
         };
         if (this.existingEnt) {
             if (this.hasData(options.fields)) {
-                this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+                // 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"];
             }
         }
@@ -450,20 +678,36 @@ class EditNodeOperation {
         }
     }
     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: ["*"],
+            fields: opts.fields.length ? opts.fields : ["*"],
             tableName: options.tableName,
-            clause: clause.Eq(options.key, id),
+            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) {
-            throw new Error(`couldn't reload row for ${id}`);
+        if (r.rows.length === 1) {
+            this.row = r.rows[0];
         }
-        this.row = r.rows[0];
     }
     performWriteSync(queryer, context) {
         let options = {
@@ -472,10 +716,11 @@ class EditNodeOperation {
         };
         if (this.existingEnt) {
             if (this.hasData(this.options.fields)) {
-                editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
+                editRowSync(queryer, options, "RETURNING *");
                 this.reloadRow(queryer, this.existingEnt.id, options);
             }
             else {
+                // @ts-ignore
                 this.row = this.existingEnt["data"];
             }
         }
@@ -492,12 +737,27 @@ class EditNodeOperation {
         if (!this.row) {
             return null;
         }
-        return new this.options.ent(viewer, this.row);
+        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(edgeInput, options) {
+    constructor(builder, edgeInput, options) {
+        this.builder = builder;
         this.edgeInput = edgeInput;
         this.options = options;
     }
@@ -533,7 +793,31 @@ class EdgeOperation {
         }
     }
     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,
@@ -543,11 +827,35 @@ class EdgeOperation {
     }
     async performDeleteWrite(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
-        return deleteRows(q, params.options, params.clause);
+        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,
+            });
+        }
     }
     performDeleteWriteSync(q, edgeData, edge, context) {
         const params = this.getDeleteRowParams(edgeData, edge, context);
-        return deleteRowsSync(q, params.options, params.clause);
+        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 = {
@@ -566,6 +874,30 @@ class EdgeOperation {
             // 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,
@@ -573,7 +905,9 @@ class EdgeOperation {
                 fieldsToLog: fields,
                 context,
             },
-            "ON CONFLICT(id1, edge_type, id2) DO UPDATE SET data = EXCLUDED.data",
+            `ON CONFLICT(id1, edge_type, id2) DO UPDATE SET ${onConflictFields
+                .map((f) => `${f} = EXCLUDED.${f}`)
+                .join(", ")}`,
         ];
     }
     async performInsertWrite(q, edgeData, edge, context) {
@@ -610,7 +944,7 @@ class EdgeOperation {
         }
     }
     symmetricEdge() {
-        return new EdgeOperation({
+        return new EdgeOperation(this.builder, {
             id1: this.edgeInput.id2,
             id1Type: this.edgeInput.id2Type,
             id2: this.edgeInput.id1,
@@ -626,7 +960,7 @@ class EdgeOperation {
         });
     }
     inverseEdge(edgeData) {
-        return new EdgeOperation({
+        return new EdgeOperation(this.builder, {
             id1: this.edgeInput.id2,
             id1Type: this.edgeInput.id2Type,
             id2: this.edgeInput.id1,
@@ -694,7 +1028,7 @@ class EdgeOperation {
         if (data) {
             edge.data = data;
         }
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Insert,
             id2Placeholder,
             id1Placeholder,
@@ -715,7 +1049,7 @@ class EdgeOperation {
         if (data) {
             edge.data = data;
         }
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Insert,
             id1Placeholder,
             id2Placeholder,
@@ -733,7 +1067,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -748,7 +1082,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -845,32 +1179,36 @@ function createRowSync(queryer, options, suffix) {
     return null;
 }
 exports.createRowSync = createRowSync;
-function buildUpdateQuery(options, id, suffix) {
+function buildUpdateQuery(options, suffix) {
     let valsString = [];
     let values = [];
     let logValues = [];
     const dialect = db_1.default.getDialect();
     let idx = 1;
     for (const key in options.fields) {
-        values.push(options.fields[key]);
+        const val = options.fields[key];
+        values.push(val);
         if (options.fieldsToLog) {
             logValues.push(options.fieldsToLog[key]);
         }
+        // TODO would be nice to use clause here. need update version of the queries so that
+        // we don't have to handle dialect specifics here
+        // can't use clause because of IS NULL
+        // valsString.push(clause.Eq(key, val).clause(idx));
         if (dialect === db_1.Dialect.Postgres) {
             valsString.push(`${key} = $${idx}`);
-            idx++;
         }
         else {
             valsString.push(`${key} = ?`);
         }
+        idx++;
     }
     const vals = valsString.join(", ");
     let query = `UPDATE ${options.tableName} SET ${vals} WHERE `;
-    if (dialect === db_1.Dialect.Postgres) {
-        query = query + `${options.key} = $${idx}`;
-    }
-    else {
-        query = query + `${options.key} = ?`;
+    query = query + options.whereClause.clause(idx);
+    values.push(...options.whereClause.values());
+    if (options.fieldsToLog) {
+        logValues.push(...options.whereClause.logValues());
     }
     if (suffix) {
         query = query + " " + suffix;
@@ -878,10 +1216,8 @@ function buildUpdateQuery(options, id, suffix) {
     return [query, values, logValues];
 }
 exports.buildUpdateQuery = buildUpdateQuery;
-async function editRow(queryer, options, id, suffix) {
-    const [query, values, logValues] = buildUpdateQuery(options, id, suffix);
-    // add id as value to prepared query
-    values.push(id);
+async function editRow(queryer, options, suffix) {
+    const [query, values, logValues] = buildUpdateQuery(options, suffix);
     const res = await mutateRow(queryer, query, values, logValues, options);
     if (res?.rowCount == 1) {
         // for now assume id primary key
@@ -892,10 +1228,8 @@ async function editRow(queryer, options, id, suffix) {
     return null;
 }
 exports.editRow = editRow;
-function editRowSync(queryer, options, id, suffix) {
-    const [query, values, logValues] = buildUpdateQuery(options, id, suffix);
-    // add id as value to prepared query
-    values.push(id);
+function editRowSync(queryer, options, suffix) {
+    const [query, values, logValues] = buildUpdateQuery(options, suffix);
     const res = mutateRowSync(queryer, query, values, logValues, options);
     if (res?.rowCount == 1) {
         // for now assume id primary key
@@ -946,6 +1280,12 @@ class AssocEdge {
         this.edgeType = data.edge_type;
         this.time = data.time;
         this.data = data.data;
+        this.rawData = data;
+    }
+    __getRawData() {
+        // incase there's extra db fields. useful for tests
+        // in production, a subclass of this should be in use so we won't need this...
+        return this.rawData;
     }
     getCursor() {
         return getCursor({
@@ -1052,6 +1392,21 @@ async function loadEdges(options) {
     return loadCustomEdges({ ...options, ctr: AssocEdge });
 }
 exports.loadEdges = loadEdges;
+function getEdgeClauseAndFields(cls, options) {
+    let fields = edgeFields;
+    if (globalSchema?.transformEdgeRead) {
+        const transformClause = globalSchema.transformEdgeRead();
+        if (!options.disableTransformations) {
+            cls = clause.And(cls, transformClause);
+        }
+        fields = edgeFields.concat(transformClause.columns());
+    }
+    return {
+        cls,
+        fields,
+    };
+}
+exports.getEdgeClauseAndFields = getEdgeClauseAndFields;
 async function loadCustomEdges(options) {
     const { id1, edgeType, context } = options;
     const edgeData = await loadEdgeData(edgeType);
@@ -1063,10 +1418,11 @@ async function loadCustomEdges(options) {
     if (options.queryOptions?.clause) {
         cls = clause.And(cls, options.queryOptions.clause);
     }
+    const { cls: actualClause, fields } = getEdgeClauseAndFields(cls, options);
     const rows = await loadRows({
         tableName: edgeData.edgeTable,
-        fields: edgeFields,
-        clause: cls,
+        fields: fields,
+        clause: actualClause,
         orderby: options.queryOptions?.orderby || defaultOptions.orderby,
         limit: options.queryOptions?.limit || defaultOptions.limit,
         context,
@@ -1082,10 +1438,11 @@ async function loadUniqueEdge(options) {
     if (!edgeData) {
         throw new Error(`error loading edge data for ${edgeType}`);
     }
+    const { cls, fields } = getEdgeClauseAndFields(clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)), options);
     const row = await loadRow({
         tableName: edgeData.edgeTable,
-        fields: edgeFields,
-        clause: clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)),
+        fields: fields,
+        clause: cls,
         context,
     });
     if (!row) {
@@ -1112,11 +1469,12 @@ async function loadRawEdgeCountX(options) {
     if (!edgeData) {
         throw new Error(`error loading edge data for ${edgeType}`);
     }
+    const { cls } = getEdgeClauseAndFields(clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)), options);
     const row = await loadRowX({
         tableName: edgeData.edgeTable,
         // sqlite needs as count otherwise it returns count(1)
         fields: ["count(1) as count"],
-        clause: clause.And(clause.Eq("id1", id1), clause.Eq("edge_type", edgeType)),
+        clause: cls,
         context,
     });
     return parseInt(row["count"], 10) || 0;
@@ -1142,24 +1500,27 @@ 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;
+}
+exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
+async function applyPrivacyPolicyForRowImpl(viewer, options, row) {
     if (!row) {
         return null;
     }
     const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEnt(viewer, ent);
+    return applyPrivacyPolicyForEnt(viewer, ent, row, options);
 }
-exports.applyPrivacyPolicyForRow = applyPrivacyPolicyForRow;
 async function applyPrivacyPolicyForRowX(viewer, options, row) {
     const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEntX(viewer, ent);
+    return await applyPrivacyPolicyForEntX(viewer, ent, row, options);
 }
-exports.applyPrivacyPolicyForRowX = applyPrivacyPolicyForRowX;
+// TODO this needs to be changed to use ent cache as needed...
 async function applyPrivacyPolicyForRows(viewer, rows, options) {
     let m = new Map();
     // apply privacy logic
     await Promise.all(rows.map(async (row) => {
-        const ent = new options.ent(viewer, row);
-        let privacyEnt = await applyPrivacyPolicyForEnt(viewer, ent);
+        let privacyEnt = await applyPrivacyPolicyForRow(viewer, options, row);
         if (privacyEnt) {
             m.set(privacyEnt.id, privacyEnt);
         }