@snowtop/ent 0.1.0-alpha56 → 0.1.0-alpha58

package/action/orchestrator.js

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -11,6 +30,7 @@ const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
 const memoizee_1 = __importDefault(require("memoizee"));
+const clause = __importStar(require("../core/clause"));
 var edgeDirection;
 (function (edgeDirection) {
     edgeDirection[edgeDirection["inboundEdge"] = 0] = "inboundEdge";
@@ -159,6 +179,7 @@ class Orchestrator {
                     key: this.options.key,
                     loadEntOptions: this.options.loaderOptions,
                     placeholderID: this.options.builder.placeholderID,
+                    whereClause: clause.Eq(this.options.key, this.existingEnt?.id),
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;

package/core/base.d.ts

@@ -82,7 +82,7 @@ export interface CreateRowOptions extends DataOptions {
     fieldsToLog?: Data;
 }
 export interface EditRowOptions extends CreateRowOptions {
-    key: string;
+    whereClause: clause.Clause;
 }
 interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
     loaderFactory: LoaderFactory<any, Data | null>;

package/core/clause.d.ts

@@ -1,5 +1,6 @@
 export interface Clause {
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
@@ -12,10 +13,11 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    private handleSqliteNull?;
-    constructor(col: string, value: any, op: string, handleSqliteNull?: Clause | undefined);
+    private handleNull?;
+    constructor(col: string, value: any, op: string, handleNull?: Clause | undefined);
     clause(idx: number): string;
-    private sqliteNull;
+    private nullClause;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -25,6 +27,7 @@ declare class compositeClause implements Clause {
     private sep;
     constructor(clauses: Clause[], sep: string);
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;

package/core/clause.js

@@ -33,33 +33,33 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op, handleSqliteNull) {
+    constructor(col, value, op, handleNull) {
         this.col = col;
         this.value = value;
         this.op = op;
-        this.handleSqliteNull = handleSqliteNull;
+        this.handleNull = handleNull;
     }
     clause(idx) {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.clause(idx);
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.clause(idx);
         }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             return `${this.col} ${this.op} $${idx}`;
         }
         return `${this.col} ${this.op} ?`;
     }
-    sqliteNull() {
-        if (!this.handleSqliteNull || this.value !== null) {
-            return;
-        }
-        if (db_1.default.getDialect() !== db_1.Dialect.SQLite) {
+    nullClause() {
+        if (!this.handleNull || this.value !== null) {
             return;
         }
-        return this.handleSqliteNull;
+        return this.handleNull;
+    }
+    columns() {
+        return [this.col];
     }
     values() {
-        const sqliteClause = this.sqliteNull();
+        const sqliteClause = this.nullClause();
         if (sqliteClause) {
             return sqliteClause.values();
         }
@@ -69,7 +69,7 @@ class simpleClause {
         return [this.value];
     }
     logValues() {
-        const sqliteClause = this.sqliteNull();
+        const sqliteClause = this.nullClause();
         if (sqliteClause) {
             return sqliteClause.logValues();
         }
@@ -79,7 +79,7 @@ class simpleClause {
         return [this.value];
     }
     instanceKey() {
-        const sqliteClause = this.sqliteNull();
+        const sqliteClause = this.nullClause();
         if (sqliteClause) {
             return sqliteClause.instanceKey();
         }
@@ -93,6 +93,9 @@ class isNullClause {
     clause(idx) {
         return `${this.col} IS NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -110,6 +113,9 @@ class isNotNullClause {
     clause(idx) {
         return `${this.col} IS NOT NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -132,6 +138,9 @@ class arraySimpleClause {
         }
         return `${this.col} ${this.op} ?`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -163,6 +172,9 @@ class postgresArrayContains {
         }
         throw new Error(`not supported`);
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         if (isSensitive(this.value)) {
             return [`{${this.value.value()}}`];
@@ -225,6 +237,9 @@ class inClause {
         // or change to a sqlx.Rebind format
         // here's what sqlx does: https://play.golang.org/p/vPzvYqeAcP0
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const result = [];
         for (const value of this.value) {
@@ -266,6 +281,13 @@ class compositeClause {
         }
         return clauses.join(this.sep);
     }
+    columns() {
+        const ret = [];
+        for (const cls of this.clauses) {
+            ret.push(...cls.columns());
+        }
+        return ret;
+    }
     values() {
         let result = [];
         for (const clause of this.clauses) {
@@ -315,6 +337,9 @@ class tsQueryClause {
         // FYI this doesn't actually work for sqlite since different
         return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const { value } = this.getInfo();
         return [value];

package/core/config.d.ts

@@ -20,6 +20,7 @@ export interface Config {
     log?: logType | logType[];
     codegen?: CodegenConfig;
     customGraphQLJSONPath?: string;
+    globalSchemaPath?: string;
 }
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
@@ -35,7 +36,8 @@ interface CodegenConfig {
     schemaSQLFilePath?: boolean;
     databaseToCompareTo?: string;
     fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
-    templatizedViewer?: templatizedViewer;
+    templatizedViewer?: importedObject;
+    customAssocEdgePath?: importedObject;
 }
 interface PrettierConfig {
     custom?: boolean;
@@ -46,9 +48,10 @@ interface PrivacyConfig {
     policyName: string;
     class?: boolean;
 }
-interface templatizedViewer {
+interface importedObject {
     path: string;
     name: string;
+    alias?: string;
 }
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};

package/core/ent.d.ts

@@ -4,6 +4,7 @@ import { Executor } from "../action/action";
 import * as clause from "./clause";
 import { Builder } from "../action";
 import DataLoader from "dataloader";
+import { GlobalSchema } from "../schema/";
 export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
@@ -52,6 +53,7 @@ export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
     fieldsToResolve: string[];
     loadEntOptions: LoadEntOptions<T>;
     placeholderID?: ID;
+    key: string;
 }
 export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     options: EditNodeOptions<T>;
@@ -67,7 +69,11 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     returnedRow(): Data | null;
     createdEnt(viewer: Viewer): T | null;
 }
+export declare function setGlobalSchema(val: GlobalSchema): void;
+export declare function clearGlobalSchema(): void;
+export declare function __hasGlobalSchema(): boolean;
 export declare class EdgeOperation implements DataOperation {
+    private builder;
     edgeInput: AssocEdgeInput;
     private options;
     private edgeData;
@@ -96,9 +102,9 @@ export declare class EdgeOperation implements DataOperation {
 export declare function buildInsertQuery(options: CreateRowOptions, suffix?: string): [string, string[], string[]];
 export declare function createRow(queryer: Queryer, options: CreateRowOptions, suffix: string): Promise<Data | null>;
 export declare function createRowSync(queryer: SyncQueryer, options: CreateRowOptions, suffix: string): Data | null;
-export declare function buildUpdateQuery(options: EditRowOptions, id: ID, suffix?: string): [string, any[], any[]];
-export declare function editRow(queryer: Queryer, options: EditRowOptions, id: ID, suffix?: string): Promise<Data | null>;
-export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, id: ID, suffix?: string): Data | null;
+export declare function buildUpdateQuery(options: EditRowOptions, suffix?: string): [string, any[], any[]];
+export declare function editRow(queryer: Queryer, options: EditRowOptions, suffix?: string): Promise<Data | null>;
+export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, suffix?: string): Data | null;
 export declare function deleteRows(queryer: Queryer, options: DataOptions, cls: clause.Clause): Promise<void>;
 export declare function deleteRowsSync(queryer: SyncQueryer, options: DataOptions, cls: clause.Clause): void;
 export declare class DeleteNodeOperation implements DataOperation {
@@ -116,7 +122,9 @@ export declare class AssocEdge {
     id2Type: string;
     time: Date;
     data?: string | null;
+    private rawData;
     constructor(data: Data);
+    __getRawData(): Data;
     getCursor(): string;
 }
 interface cursorOptions {
@@ -156,6 +164,7 @@ interface loadEdgesOptions {
     edgeType: string;
     context?: Context;
     queryOptions?: EdgeQueryableDataOptions;
+    disableTransformations?: boolean;
 }
 interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
     ctr: AssocEdgeConstructor<T>;
@@ -163,6 +172,10 @@ interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
 export declare const DefaultLimit = 1000;
 export declare function defaultEdgeQueryOptions(id1: ID, edgeType: string): EdgeQueryableDataOptions;
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
+export declare function getEdgeClauseAndFields(cls: clause.Clause, options: loadEdgesOptions): {
+    cls: clause.Clause;
+    fields: string[];
+};
 export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;
 export declare function loadUniqueEdge(options: loadEdgesOptions): Promise<AssocEdge | null>;
 export declare function loadUniqueNode<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id1: ID, edgeType: string, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;

package/core/ent.js

@@ -22,13 +22,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEdgeTypeInGroup = 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.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.applyPrivacyPolicyForRow = 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 = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRowX = 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) {
@@ -473,7 +475,7 @@ class EditNodeOperation {
             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, this.existingEnt.id, "RETURNING *");
+                this.row = await editRow(queryer, options, "RETURNING *");
             }
             else {
                 // @ts-ignore
@@ -523,7 +525,7 @@ 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 {
@@ -548,8 +550,23 @@ class EditNodeOperation {
     }
 }
 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;
     }
@@ -585,7 +602,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,
@@ -595,11 +636,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 = {
@@ -618,6 +683,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,
@@ -625,7 +714,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) {
@@ -662,7 +753,7 @@ class EdgeOperation {
         }
     }
     symmetricEdge() {
-        return new EdgeOperation({
+        return new EdgeOperation(this.builder, {
             id1: this.edgeInput.id2,
             id1Type: this.edgeInput.id2Type,
             id2: this.edgeInput.id1,
@@ -678,7 +769,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,
@@ -746,7 +837,7 @@ class EdgeOperation {
         if (data) {
             edge.data = data;
         }
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Insert,
             id2Placeholder,
             id1Placeholder,
@@ -767,7 +858,7 @@ class EdgeOperation {
         if (data) {
             edge.data = data;
         }
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Insert,
             id1Placeholder,
             id2Placeholder,
@@ -785,7 +876,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -800,7 +891,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -897,43 +988,42 @@ 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 (suffix) {
         query = query + " " + 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
@@ -944,10 +1034,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
@@ -998,6 +1086,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({
@@ -1104,6 +1198,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);
@@ -1115,10 +1224,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,
@@ -1134,10 +1244,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) {
@@ -1164,11 +1275,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;