@snowtop/ent 0.1.0-alpha6 → 0.1.0-alpha63

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.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) {
@@ -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 [];
@@ -140,8 +142,7 @@ 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) {
@@ -212,7 +213,7 @@ async function loadCustomEnts(viewer, options, query) {
     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);
+        let privacyEnt = await applyPrivacyPolicyForEnt(viewer, ent, row, options);
         if (privacyEnt) {
             result[idx] = privacyEnt;
         }
@@ -258,30 +259,60 @@ exports.loadCustomData = loadCustomData;
 // Derived ents
 async function loadDerivedEnt(viewer, data, loader) {
     const ent = new loader(viewer, data);
-    return await applyPrivacyPolicyForEnt(viewer, ent);
+    return await applyPrivacyPolicyForEnt(viewer, ent, data, {
+        ent: loader,
+    });
 }
 exports.loadDerivedEnt = loadDerivedEnt;
 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 visible = await (0, privacy_1.applyPrivacyPolicy)(viewer, ent.getPrivacyPolicy(), ent);
+        if (!visible) {
+            return null;
         }
+        return doFieldPrivacy(viewer, ent, data, fieldPrivacyOptions);
     }
     return null;
 }
-exports.applyPrivacyPolicyForEnt = applyPrivacyPolicyForEnt;
-async function applyPrivacyPolicyForEntX(viewer, ent) {
+async function applyPrivacyPolicyForEntX(viewer, ent, data, options) {
     // this will throw
-    await (0, privacy_1.applyPrivacyPolicyX)(viewer, ent.privacyPolicy, ent);
+    await (0, privacy_1.applyPrivacyPolicyX)(viewer, ent.getPrivacyPolicy(), ent);
+    return doFieldPrivacy(viewer, ent, data, options);
+}
+async function doFieldPrivacy(viewer, ent, data, options) {
+    if (!options.fieldPrivacy) {
+        return ent;
+    }
+    const promises = [];
+    let somethingChanged = false;
+    for (const [k, policy] of options.fieldPrivacy) {
+        promises.push((async () => {
+            // don't do anything if key is null or for some reason missing
+            const curr = data[k];
+            if (curr === null || curr === undefined) {
+                return;
+            }
+            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 +358,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 +439,7 @@ class EditNodeOperation {
     constructor(options, existingEnt = null) {
         this.options = options;
         this.existingEnt = existingEnt;
+        this.row = null;
         this.placeholderID = options.placeholderID;
     }
     resolve(executor) {
@@ -439,9 +473,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 +487,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(optionClause, cls);
+            }
+        }
         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 +525,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 +546,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 +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,
@@ -543,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 = {
@@ -566,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,
@@ -573,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) {
@@ -610,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,
@@ -626,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,
@@ -694,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,
@@ -715,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,
@@ -733,7 +876,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -748,7 +891,7 @@ class EdgeOperation {
             id2Type: "",
             id1Type: "",
         };
-        return new EdgeOperation(edge, {
+        return new EdgeOperation(builder, edge, {
             operation: action_1.WriteOperation.Delete,
         });
     }
@@ -845,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
@@ -892,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
@@ -946,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({
@@ -1052,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);
@@ -1063,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,
@@ -1082,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) {
@@ -1112,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;
@@ -1146,20 +1310,19 @@ async function applyPrivacyPolicyForRow(viewer, options, row) {
         return null;
     }
     const ent = new options.ent(viewer, row);
-    return await applyPrivacyPolicyForEnt(viewer, ent);
+    return await 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;
 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);
         }

package/core/loaders/assoc_count_loader.d.ts

@@ -1,10 +1,10 @@
 import { ID, Context, Loader, LoaderFactory } from "../base";
 export declare class AssocEdgeCountLoader implements Loader<ID, number> {
     private edgeType;
-    context?: Context | undefined;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private loaderFn;
     private loader;
-    constructor(edgeType: string, context?: Context | undefined);
+    constructor(edgeType: string, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private getLoader;
     load(id: ID): Promise<number>;
     clearAll(): void;

package/core/loaders/assoc_count_loader.js

@@ -41,10 +41,15 @@ class AssocEdgeCountLoader {
         if (!edgeData) {
             throw new Error(`error loading edge data for ${this.edgeType}`);
         }
+        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {
+            // don't need this..
+            id1: "1",
+            edgeType: this.edgeType,
+        });
         this.loader = (0, raw_count_loader_1.createCountDataLoader)({
             tableName: edgeData.edgeTable,
             groupCol: "id1",
-            clause: clause.Eq("edge_type", this.edgeType),
+            clause: cls,
         });
         return this.loader;
     }

package/core/loaders/assoc_edge_loader.d.ts

@@ -20,8 +20,8 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeType;
     private edgeCtr;
     private options?;
-    context?: Context | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context | undefined);
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
@@ -32,7 +32,7 @@ export declare class AssocEdgeLoaderFactory<T extends AssocEdge> implements Load
     name: string;
     constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T> | (() => AssocEdgeConstructor<T>));
     createLoader(context?: Context): AssocLoader<T>;
-    private isFunction;
+    private isConstructor;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): AssocLoader<T>;
 }
 export {};

package/core/loaders/assoc_edge_loader.js

@@ -161,16 +161,17 @@ class AssocEdgeLoaderFactory {
     createLoader(context) {
         return this.createConfigurableLoader({}, context);
     }
-    isFunction(edgeCtr) {
-        // not constructor
-        return !(edgeCtr.prototype && edgeCtr.prototype.constructor === edgeCtr);
+    isConstructor(edgeCtr) {
+        return (edgeCtr.prototype &&
+            edgeCtr.prototype.constructor &&
+            edgeCtr.prototype.constructor.name.length > 0);
     }
     createConfigurableLoader(options, context) {
         let edgeCtr = this.edgeCtr;
         // in generated code, the edge is not necessarily defined at the time of loading
         // so we call this as follows:
         // const loader = new AssocEdgeLoaderFactory(EdgeType.Foo, ()=>DerivedEdgeClass);
-        if (this.isFunction(edgeCtr)) {
+        if (!this.isConstructor(edgeCtr)) {
             edgeCtr = edgeCtr();
         }
         // rename to make TS happy

package/core/loaders/index_loader.js

@@ -4,6 +4,7 @@ exports.IndexLoaderFactory = void 0;
 const query_loader_1 = require("./query_loader");
 // we're keeping this for legacy reasons so as to not break existing callers
 // and to decouple the change here but all callers can safely be changed here to use QueryLoaderFactory
+// @deprecated use QueryLoaderFactory
 class IndexLoaderFactory {
     constructor(options, col, opts) {
         this.factory = new query_loader_1.QueryLoaderFactory({