@snowtop/ent 0.1.0-alpha89 → 0.1.0-alpha89-16dc3410-33c4-11ed-9fc4-5d4a927887be

package/core/db.d.ts

@@ -77,6 +77,7 @@ interface SqliteRunResult {
 }
 interface SqliteDatabase {
     memory: boolean;
+    exec(query: string): SqliteStatement;
     prepare(query: string): SqliteStatement;
     close(): void;
     transaction(fn: (...params: any[]) => any): SqliteTransaction;

package/core/ent.d.ts

@@ -229,6 +229,6 @@ interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptio
 export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
 export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
 export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt | null>;
-export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
+export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt[]>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};

package/core/ent.js

@@ -348,25 +348,12 @@ async function loadEntsFromClause(viewer, clause, options) {
         context: viewer.context,
     };
     const rows = await loadRows(rowOptions);
-    return await applyPrivacyPolicyForRows(viewer, rows, options);
+    return applyPrivacyPolicyForRowsDeprecated(viewer, rows, options);
 }
 exports.loadEntsFromClause = loadEntsFromClause;
 async function loadCustomEnts(viewer, options, query) {
     const rows = await loadCustomData(options, query, viewer.context);
-    const result = new Array(rows.length);
-    if (!rows.length) {
-        return [];
-    }
-    const entLoader = getEntLoader(viewer, options);
-    await Promise.all(rows.map(async (row, idx) => {
-        const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, entLoader);
-        if (r instanceof ErrorWrapper) {
-            return;
-        }
-        result[idx] = r;
-    }));
-    // filter ents that aren't visible because of privacy
-    return result.filter((r) => r !== undefined);
+    return applyPrivacyPolicyForRows(viewer, rows, options);
 }
 exports.loadCustomEnts = loadCustomEnts;
 function isClause(opts) {
@@ -1550,10 +1537,8 @@ async function applyPrivacyPolicyForRowX(viewer, options, row) {
     const ent = new options.ent(viewer, row);
     return await applyPrivacyPolicyForEntX(viewer, ent, row, options);
 }
-// TODO this needs to be changed to use ent cache as needed...
-// most current callsites fine not using it
-// custom_query is one that should be updated
-async function applyPrivacyPolicyForRows(viewer, rows, options) {
+// deprecated. doesn't use entcache
+async function applyPrivacyPolicyForRowsDeprecated(viewer, rows, options) {
     let m = new Map();
     // apply privacy logic
     await Promise.all(rows.map(async (row) => {
@@ -1564,6 +1549,22 @@ async function applyPrivacyPolicyForRows(viewer, rows, options) {
     }));
     return m;
 }
+async function applyPrivacyPolicyForRows(viewer, rows, options) {
+    const result = new Array(rows.length);
+    if (!rows.length) {
+        return [];
+    }
+    const entLoader = getEntLoader(viewer, options);
+    await Promise.all(rows.map(async (row, idx) => {
+        const r = await applyPrivacyPolicyForRowAndStoreInEntLoader(viewer, row, options, entLoader);
+        if (r instanceof ErrorWrapper) {
+            return;
+        }
+        result[idx] = r;
+    }));
+    // filter ents that aren't visible because of privacy
+    return result.filter((r) => r !== undefined);
+}
 exports.applyPrivacyPolicyForRows = applyPrivacyPolicyForRows;
 async function loadEdgeWithConst(viewer, id1, id2, edgeEnum, edgeType) {
     const edge = await loadEdgeForID2({

package/core/loaders/index.d.ts

@@ -3,4 +3,4 @@ export { RawCountLoader, RawCountLoaderFactory } from "./raw_count_loader";
 export { AssocEdgeCountLoader, AssocEdgeCountLoaderFactory, } from "./assoc_count_loader";
 export { AssocDirectEdgeLoader, AssocEdgeLoader, AssocEdgeLoaderFactory, } from "./assoc_edge_loader";
 export { IndexLoaderFactory } from "./index_loader";
-export { QueryLoader, QueryDirectLoader, QueryLoaderFactory, } from "./query_loader";
+export { QueryLoaderFactory } from "./query_loader";

package/core/loaders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.QueryDirectLoader = exports.QueryLoader = exports.IndexLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+exports.QueryLoaderFactory = exports.IndexLoaderFactory = exports.AssocEdgeLoaderFactory = exports.AssocEdgeLoader = exports.AssocDirectEdgeLoader = exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = exports.RawCountLoaderFactory = exports.RawCountLoader = exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
 var object_loader_1 = require("./object_loader");
 Object.defineProperty(exports, "ObjectLoader", { enumerable: true, get: function () { return object_loader_1.ObjectLoader; } });
 Object.defineProperty(exports, "ObjectLoaderFactory", { enumerable: true, get: function () { return object_loader_1.ObjectLoaderFactory; } });
@@ -17,6 +17,4 @@ Object.defineProperty(exports, "AssocEdgeLoaderFactory", { enumerable: true, get
 var index_loader_1 = require("./index_loader");
 Object.defineProperty(exports, "IndexLoaderFactory", { enumerable: true, get: function () { return index_loader_1.IndexLoaderFactory; } });
 var query_loader_1 = require("./query_loader");
-Object.defineProperty(exports, "QueryLoader", { enumerable: true, get: function () { return query_loader_1.QueryLoader; } });
-Object.defineProperty(exports, "QueryDirectLoader", { enumerable: true, get: function () { return query_loader_1.QueryDirectLoader; } });
 Object.defineProperty(exports, "QueryLoaderFactory", { enumerable: true, get: function () { return query_loader_1.QueryLoaderFactory; } });

package/core/loaders/index_loader.d.ts

@@ -1,4 +1,4 @@
-import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions } from "../base";
+import { ID, SelectBaseDataOptions, Context, Data, LoaderFactory, EdgeQueryableDataOptions, Loader } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
 export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
@@ -10,5 +10,5 @@ export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
         toPrime?: ObjectLoaderFactory<ID>[];
     });
     createLoader(context?: Context): any;
-    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): import("../base").Loader<unknown, Data[]> | import("./query_loader").QueryDirectLoader<unknown>;
+    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<ID, Data[]>;
 }

package/core/loaders/query_loader.d.ts

@@ -1,21 +1,14 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
-export declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
+export declare function getOrderBy(sortCol: string, orderby?: string): string;
+declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
-    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
-    load(id: K): Promise<Data[]>;
-    clearAll(): void;
-}
-export declare class QueryLoader<K extends any> implements Loader<K, Data[]> {
-    private options;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
-    private queryOptions?;
-    private loader;
-    private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: QueryOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined);
+    private primedLoaders;
+    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;
@@ -34,5 +27,6 @@ export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<
     constructor(options: QueryOptions);
     createLoader(context?: Context): any;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<unknown, Data[]> | QueryDirectLoader<unknown>;
+    static createConfigurableLoader(name: string, queryOptions: QueryOptions, options: EdgeQueryableDataOptions, context?: Context): Loader<unknown, Data[]> | QueryDirectLoader<unknown>;
 }
 export {};

package/core/loaders/query_loader.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.QueryLoader = exports.QueryDirectLoader = void 0;
+exports.QueryLoaderFactory = exports.getOrderBy = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
@@ -30,13 +30,17 @@ const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
 function getOrderBy(sortCol, orderby) {
+    if (orderby) {
+        return orderby;
+    }
     let sortColLower = sortCol.toLowerCase();
     let orderbyDirection = " DESC";
     if (sortColLower.endsWith("asc") || sortCol.endsWith("desc")) {
         orderbyDirection = "";
     }
-    return orderby || `${sortCol}${orderbyDirection}`;
+    return `${sortCol}${orderbyDirection}`;
 }
+exports.getOrderBy = getOrderBy;
 async function simpleCase(options, id, queryOptions) {
     let cls;
     if (options.groupCol) {
@@ -120,16 +124,47 @@ function createLoader(options, queryOptions) {
     }, loaderOptions);
 }
 class QueryDirectLoader {
-    constructor(options, queryOptions) {
+    constructor(options, queryOptions, context) {
         this.options = options;
         this.queryOptions = queryOptions;
+        this.context = context;
+        this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
+    }
+    initPrime() {
+        if (!this.context || !this.options?.toPrime) {
+            return;
+        }
+        let primedLoaders = new Map();
+        this.options.toPrime.forEach((prime) => {
+            const l2 = prime.createLoader(this.context);
+            if (l2.prime === undefined) {
+                return;
+            }
+            primedLoaders.set(prime.options.key, l2);
+        });
+        this.primedLoaders = primedLoaders;
     }
     async load(id) {
-        return simpleCase(this.options, id, this.queryOptions);
+        const rows = await simpleCase(this.options, id, this.queryOptions);
+        if (this.context) {
+            this.memoizedInitPrime();
+            if (this.primedLoaders) {
+                for (const row of rows) {
+                    for (const [key, loader] of this.primedLoaders) {
+                        const value = row[key];
+                        if (value !== undefined) {
+                            loader.prime(row);
+                        }
+                    }
+                }
+            }
+        }
+        return rows;
     }
     clearAll() { }
 }
-exports.QueryDirectLoader = QueryDirectLoader;
+// note, you should never call this directly
+// there's scenarios where QueryDirectLoader is needed instead of this...
 class QueryLoader {
     constructor(options, context, queryOptions) {
         this.options = options;
@@ -176,7 +211,6 @@ class QueryLoader {
         this.loader && this.loader.clearAll();
     }
 }
-exports.QueryLoader = QueryLoader;
 class QueryLoaderFactory {
     constructor(options) {
         this.options = options;
@@ -194,11 +228,14 @@ class QueryLoaderFactory {
         return (0, loader_1.getLoader)(this, () => new QueryLoader(this.options, context), context);
     }
     createConfigurableLoader(options, context) {
-        if (options?.clause || !context) {
-            return new QueryDirectLoader(this.options, options);
+        return QueryLoaderFactory.createConfigurableLoader(this.name, this.options, options, context);
+    }
+    static createConfigurableLoader(name, queryOptions, options, context) {
+        if (options.clause || !context) {
+            return new QueryDirectLoader(queryOptions, options, context);
         }
-        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}`;
-        return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(this.options, context, options), context);
+        const key = `${name}:limit:${options.limit}:orderby:${options.orderby}`;
+        return (0, loader_1.getCustomLoader)(key, () => new QueryLoader(queryOptions, context, options), context);
     }
 }
 exports.QueryLoaderFactory = QueryLoaderFactory;

package/core/query/custom_clause_query.d.ts

@@ -0,0 +1,24 @@
+import { Data, EdgeQueryableDataOptions, Ent, ID, LoadEntOptions, Viewer } from "../base";
+import { Clause } from "../clause";
+import { BaseEdgeQuery, IDInfo } from "./query";
+interface CustomClauseQueryOptions<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    clause: Clause;
+    name: string;
+    sortColumn?: string;
+    disableTransformations?: boolean;
+}
+export declare class CustomClauseQuery<TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<any, TDest, Data> {
+    viewer: TViewer;
+    private options;
+    private clause;
+    constructor(viewer: TViewer, options: CustomClauseQueryOptions<TDest, TViewer>);
+    sourceEnt(_id: ID): Promise<null>;
+    queryRawCount(): Promise<number>;
+    queryAllRawCount(): Promise<Map<ID, number>>;
+    protected loadRawIDs(_addID: (src: ID) => void): Promise<void>;
+    protected loadRawData(_infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
+    dataToID(edge: Data): ID;
+    protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;
+}
+export {};

package/core/query/custom_clause_query.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomClauseQuery = void 0;
+const clause_1 = require("../clause");
+const ent_1 = require("../ent");
+const query_loader_1 = require("../loaders/query_loader");
+const query_1 = require("./query");
+function getClause(opts) {
+    let cls = opts.clause;
+    if (opts.disableTransformations) {
+        return cls;
+    }
+    let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
+    if (typeof optClause === "function") {
+        optClause = optClause();
+    }
+    if (!optClause) {
+        return cls;
+    }
+    return (0, clause_1.AndOptional)(cls, optClause);
+}
+class CustomClauseQuery extends query_1.BaseEdgeQuery {
+    constructor(viewer, options) {
+        super(viewer, options.sortColumn || "created_at");
+        this.viewer = viewer;
+        this.options = options;
+        this.clause = getClause(options);
+    }
+    async sourceEnt(_id) {
+        return null;
+    }
+    async queryRawCount() {
+        const row = await (0, ent_1.loadRow)({
+            tableName: this.options.loadEntOptions.tableName,
+            // sqlite needs as count otherwise it returns count(1)
+            fields: ["count(1) as count"],
+            clause: this.clause,
+            context: this.viewer.context,
+        });
+        return parseInt(row?.count, 10) || 0;
+    }
+    async queryAllRawCount() {
+        throw new Error(`queryAllRawCount doesn't make sense in CustomClauseQuery`);
+    }
+    // nothing to do here
+    async loadRawIDs(_addID) { }
+    async loadRawData(_infos, options) {
+        if (!options.orderby) {
+            options.orderby = `${this.options.sortColumn} DESC`;
+        }
+        if (!options.limit) {
+            options.limit = ent_1.DefaultLimit;
+        }
+        let sortCol = this.options.sortColumn || "created_at";
+        const rows = await (0, ent_1.loadRows)({
+            tableName: this.options.loadEntOptions.tableName,
+            fields: this.options.loadEntOptions.fields,
+            clause: (0, clause_1.AndOptional)(this.clause, options.clause),
+            orderby: (0, query_loader_1.getOrderBy)(sortCol, options?.orderby),
+            limit: options?.limit || ent_1.DefaultLimit,
+            context: this.viewer.context,
+        });
+        this.edges.set(1, rows);
+    }
+    dataToID(edge) {
+        return edge.id;
+    }
+    async loadEntsFromEdges(id, rows) {
+        return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.loadEntOptions);
+    }
+}
+exports.CustomClauseQuery = CustomClauseQuery;

package/core/query/custom_query.d.ts

@@ -1,22 +1,37 @@
 import { Data, Ent, ID, EdgeQueryableDataOptions, LoadEntOptions, Viewer, LoaderFactory, ConfigurableLoaderFactory } from "../base";
+import { Clause } from "../clause";
 import { BaseEdgeQuery, IDInfo, EdgeQuery } from "./query";
-export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+export interface CustomEdgeQueryOptionsDeprecated<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     src: TSource | ID;
     countLoaderFactory: LoaderFactory<ID, number>;
     dataLoaderFactory: ConfigurableLoaderFactory<ID, Data[]>;
     options: LoadEntOptions<TDest, TViewer>;
     sortColumn?: string;
 }
+export interface CustomEdgeQueryOptions<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    src: TSource | ID;
+    loadEntOptions: LoadEntOptions<TDest, TViewer>;
+    groupCol?: string;
+    clause?: Clause;
+    name: string;
+    sortColumn?: string;
+    disableTransformations?: boolean;
+}
 export declare abstract class CustomEdgeQueryBase<TSource extends Ent<TViewer>, TDest extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends BaseEdgeQuery<TSource, TDest, Data> implements EdgeQuery<TSource, TDest, Data> {
     viewer: TViewer;
     private options;
     private id;
-    constructor(viewer: TViewer, options: CustomEdgeQueryOptions<TSource, TDest, TViewer>);
+    private opts;
+    constructor(viewer: TViewer, options: CustomEdgeQueryOptionsDeprecated<TSource, TDest, TViewer> | CustomEdgeQueryOptions<TSource, TDest, TViewer>);
     abstract sourceEnt(id: ID): Promise<Ent | null>;
     private idVisible;
+    private isDeprecatedOptions;
+    private getCountLoader;
+    private getQueryLoader;
     queryRawCount(): Promise<number>;
     queryAllRawCount(): Promise<Map<ID, number>>;
     protected loadRawIDs(addID: (src: ID | TSource) => void): Promise<void>;
+    private getLoadEntOptions;
     protected loadRawData(infos: IDInfo[], options: EdgeQueryableDataOptions): Promise<void>;
     dataToID(edge: Data): ID;
     protected loadEntsFromEdges(id: ID, rows: Data[]): Promise<TDest[]>;

package/core/query/custom_query.js

@@ -1,11 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomEdgeQueryBase = void 0;
+const clause_1 = require("../clause");
 const ent_1 = require("../ent");
+const loaders_1 = require("../loaders");
 const query_1 = require("./query");
+function getClause(opts) {
+    let cls = opts.clause;
+    if (opts.disableTransformations) {
+        return cls;
+    }
+    let optClause = opts.loadEntOptions.loaderFactory?.options?.clause;
+    if (typeof optClause === "function") {
+        optClause = optClause();
+    }
+    if (!optClause) {
+        return cls;
+    }
+    return (0, clause_1.AndOptional)(cls, optClause);
+}
+function getRawCountLoader(viewer, opts) {
+    if (!viewer.context?.cache) {
+        return new loaders_1.RawCountLoader({
+            tableName: opts.loadEntOptions.tableName,
+            groupCol: opts.groupCol,
+            clause: getClause(opts),
+        });
+    }
+    const name = `custom_query_count_loader:${opts.name}`;
+    return viewer.context.cache.getLoader(name, () => new loaders_1.RawCountLoader({
+        tableName: opts.loadEntOptions.tableName,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+    }));
+}
+function getQueryLoader(viewer, opts, options) {
+    const loader = opts.loadEntOptions.loaderFactory;
+    const name = `custom_query_loader:${opts.name}`;
+    return loaders_1.QueryLoaderFactory.createConfigurableLoader(name, {
+        tableName: opts.loadEntOptions.tableName,
+        fields: opts.loadEntOptions.fields,
+        groupCol: opts.groupCol,
+        clause: getClause(opts),
+        toPrime: [loader],
+    }, options, viewer.context);
+}
 class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
     constructor(viewer, options) {
-        super(viewer, options.sortColumn || "created_at");
+        // @ts-ignore
+        super(viewer, options?.sortColumn || "created_at");
         this.viewer = viewer;
         this.options = options;
         options.sortColumn = options.sortColumn || "created_at";
@@ -15,6 +58,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         else {
             this.id = options.src;
         }
+        this.opts = this.getLoadEntOptions();
     }
     async idVisible() {
         const ids = await this.genIDInfosToFetch();
@@ -23,14 +67,28 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         }
         return !ids[0].invalidated;
     }
+    isDeprecatedOptions(options) {
+        return (options
+            .countLoaderFactory !== undefined);
+    }
+    getCountLoader() {
+        if (this.isDeprecatedOptions(this.options)) {
+            return this.options.countLoaderFactory.createLoader(this.viewer.context);
+        }
+        return getRawCountLoader(this.viewer, this.options);
+    }
+    getQueryLoader(options) {
+        if (this.isDeprecatedOptions(this.options)) {
+            return this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
+        }
+        return getQueryLoader(this.viewer, this.options, options);
+    }
     async queryRawCount() {
         const idVisible = await this.idVisible();
         if (!idVisible) {
             return 0;
         }
-        return await this.options.countLoaderFactory
-            .createLoader(this.viewer.context)
-            .load(this.id);
+        return this.getCountLoader().load(this.id);
     }
     async queryAllRawCount() {
         let count = 0;
@@ -43,17 +101,27 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
     async loadRawIDs(addID) {
         addID(this.options.src);
     }
+    getLoadEntOptions() {
+        let opts;
+        if (this.isDeprecatedOptions(this.options)) {
+            opts = this.options.options;
+        }
+        else {
+            opts = this.options.loadEntOptions;
+        }
+        return opts;
+    }
     async loadRawData(infos, options) {
-        const loader = this.options.dataLoaderFactory.createConfigurableLoader(options, this.viewer.context);
+        if (infos.length !== 1) {
+            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
+        }
         if (!options.orderby) {
             options.orderby = `${this.options.sortColumn} DESC`;
         }
         if (!options.limit) {
             options.limit = ent_1.DefaultLimit;
         }
-        if (infos.length !== 1) {
-            throw new Error(`expected 1 info passed to loadRawData. ${infos.length} passed`);
-        }
+        const loader = this.getQueryLoader(options);
         const info = infos[0];
         if (info.invalidated) {
             this.edges.set(this.id, []);
@@ -66,8 +134,7 @@ class CustomEdgeQueryBase extends query_1.BaseEdgeQuery {
         return edge.id;
     }
     async loadEntsFromEdges(id, rows) {
-        const ents = await (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.options.options);
-        return Array.from(ents.values());
+        return (0, ent_1.applyPrivacyPolicyForRows)(this.viewer, rows, this.opts);
     }
 }
 exports.CustomEdgeQueryBase = CustomEdgeQueryBase;

package/core/query/index.d.ts

@@ -1,3 +1,4 @@
 export { EdgeQuery, BaseEdgeQuery, EdgeQueryFilter, PaginationInfo, } from "./query";
 export { AssocEdgeQueryBase, EdgeQuerySource } from "./assoc_query";
 export { CustomEdgeQueryBase } from "./custom_query";
+export { CustomClauseQuery } from "./custom_clause_query";

package/core/query/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomEdgeQueryBase = exports.AssocEdgeQueryBase = exports.BaseEdgeQuery = void 0;
+exports.CustomClauseQuery = exports.CustomEdgeQueryBase = exports.AssocEdgeQueryBase = exports.BaseEdgeQuery = void 0;
 var query_1 = require("./query");
 Object.defineProperty(exports, "BaseEdgeQuery", { enumerable: true, get: function () { return query_1.BaseEdgeQuery; } });
 var assoc_query_1 = require("./assoc_query");
 Object.defineProperty(exports, "AssocEdgeQueryBase", { enumerable: true, get: function () { return assoc_query_1.AssocEdgeQueryBase; } });
 var custom_query_1 = require("./custom_query");
 Object.defineProperty(exports, "CustomEdgeQueryBase", { enumerable: true, get: function () { return custom_query_1.CustomEdgeQueryBase; } });
+var custom_clause_query_1 = require("./custom_clause_query");
+Object.defineProperty(exports, "CustomClauseQuery", { enumerable: true, get: function () { return custom_clause_query_1.CustomClauseQuery; } });

package/core/query/query.js

@@ -89,7 +89,13 @@ class FirstFilter {
         // todo may not be desc
         // and if asc
         // clause below should switch to greater...
-        options.orderby = `${this.sortCol} DESC`;
+        const sortCol = this.sortCol.toLowerCase();
+        if (sortCol.endsWith("desc") || sortCol.endsWith("asc")) {
+            options.orderby = `${this.sortCol}`;
+        }
+        else {
+            options.orderby = `${this.sortCol} DESC`;
+        }
         // we sort by most recent first
         // so when paging, we fetch afterCursor X
         if (this.offset) {
@@ -100,6 +106,7 @@ class FirstFilter {
                 options.clause = clause.Less(this.sortCol, new Date(this.offset).toISOString());
             }
         }
+        // console.debug("filter opts", options, this.options);
         return options;
     }
     // TODO?

package/core/query/shared_test.js

@@ -12,6 +12,7 @@ const logger_1 = require("../logger");
 const test_edge_global_schema_1 = require("../../testutils/test_edge_global_schema");
 const builder_1 = require("../../testutils/builder");
 const action_1 = require("../../action");
+const mock_log_1 = require("../../testutils/mock_log");
 class TestQueryFilter {
     constructor(filter, newQuery, ents, defaultViewer) {
         this.filter = filter;
@@ -20,11 +21,15 @@ class TestQueryFilter {
         this.defaultViewer = defaultViewer;
         this.allContacts = [];
         this.filteredContacts = [];
+        // @ts-ignore
+        const q = this.newQuery(this.defaultViewer);
+        // TODO sad not generic enough
+        this.customQuery =
+            q instanceof index_1.UserToContactsFkeyQuery ||
+                q instanceof index_1.UserToContactsFkeyQueryDeprecated;
     }
-    async beforeEach() {
-        //    console.log("sss");
+    async createData() {
         [this.user, this.allContacts] = await (0, test_helpers_1.createAllContacts)();
-        //    console.log(this.user, this.contacts);
         //    this.allContacts = this.allContacts.reverse();
         this.filteredContacts = this.ents(this.allContacts);
         db_mock_1.QueryRecorder.clearQueries();
@@ -61,16 +66,55 @@ class TestQueryFilter {
     verifyEdges(edges) {
         const q = this.getQuery();
         // TODO sad not generic enough
-        if (q instanceof index_1.UserToContactsFkeyQuery) {
+        if (this.customQuery) {
             (0, test_helpers_1.verifyUserToContactRawData)(this.user, edges, this.filteredContacts);
         }
         else {
             (0, test_helpers_1.verifyUserToContactEdges)(this.user, edges, this.filteredContacts);
         }
     }
-    async testEnts() {
-        const entsMap = await this.getQuery(new viewer_1.IDViewer(this.user.id)).queryEnts();
-        this.verifyEnts(entsMap);
+    async testEnts(v) {
+        const ents = await this.getQuery(v || new viewer_1.IDViewer(this.user.id)).queryEnts();
+        this.verifyEnts(ents);
+        return ents;
+    }
+    async testEntsCache() {
+        if (!this.customQuery) {
+            return;
+        }
+        (0, logger_1.setLogLevels)(["query", "cache"]);
+        const ml = new mock_log_1.MockLogs();
+        ml.mock();
+        const v = new test_context_1.TestContext(new viewer_1.IDViewer(this.user.id)).getViewer();
+        const ents = await this.testEnts(v);
+        expect(ml.logs.length).toBe(1);
+        expect(ml.logs[0].query).toMatch(/SELECT (.+) FROM /);
+        await Promise.all(ents.map((ent) => index_1.FakeContact.loadX(v, ent.id)));
+        expect(ml.logs.length).toBe(this.filteredContacts.length + 1);
+        for (const log of ml.logs.slice(1)) {
+            expect(log["ent-cache-hit"]).toBeDefined();
+        }
+        ml.restore();
+        (0, logger_1.clearLogLevels)();
+    }
+    async testDataCache() {
+        if (!this.customQuery) {
+            return;
+        }
+        (0, logger_1.setLogLevels)(["query", "cache"]);
+        const ml = new mock_log_1.MockLogs();
+        ml.mock();
+        const v = new test_context_1.TestContext(new viewer_1.IDViewer(this.user.id)).getViewer();
+        const ents = await this.testEnts(v);
+        expect(ml.logs.length).toBe(1);
+        expect(ml.logs[0].query).toMatch(/SELECT (.+) FROM /);
+        await Promise.all(ents.map((ent) => index_1.FakeContact.loadRawData(ent.id, v.context)));
+        expect(ml.logs.length).toBe(this.filteredContacts.length + 1);
+        for (const log of ml.logs.slice(1)) {
+            expect(log["dataloader-cache-hit"]).toBeDefined();
+        }
+        ml.restore();
+        (0, logger_1.clearLogLevels)();
     }
     verifyEnts(ents) {
         (0, test_helpers_1.verifyUserToContacts)(this.user, ents, this.filteredContacts);
@@ -203,17 +247,21 @@ const commonTests = (opts) => {
     }
     let tdb;
     if (opts.sqlite) {
-        (0, temp_db_1.setupSqlite)(`sqlite:///shared_test+${opts.uniqKey}.db`, () => (0, test_helpers_1.tempDBTables)(opts.globalSchema));
+        (0, temp_db_1.setupSqlite)(`sqlite:///shared_test+${opts.uniqKey}.db`, () => (0, test_helpers_1.tempDBTables)(opts.globalSchema), {
+            disableDeleteAfterEachTest: true,
+        });
     }
     beforeAll(async () => {
         // want error on by default in tests?
         (0, logger_1.setLogLevels)(["error", "warn", "info"]);
         if (opts.livePostgresDB) {
             tdb = await (0, test_helpers_1.setupTempDB)();
+            return;
         }
+        await (0, test_helpers_1.createEdges)();
     });
     beforeEach(async () => {
-        if (opts.livePostgresDB) {
+        if (opts.livePostgresDB || opts.sqlite) {
             return;
         }
         await (0, test_helpers_1.createEdges)();
@@ -233,7 +281,7 @@ const commonTests = (opts) => {
             return contacts.reverse();
         }, getViewer());
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
@@ -258,6 +306,12 @@ const commonTests = (opts) => {
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("after delete", () => {
         const filter = new TestQueryFilter((q) => {
@@ -268,7 +322,7 @@ const commonTests = (opts) => {
             return [];
         }, getViewer());
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
             const action = new builder_1.SimpleAction(filter.user.viewer, index_1.FakeUserSchema, new Map(), action_1.WriteOperation.Edit, filter.user);
             await Promise.all(filter.allContacts.map(async (contact) => {
                 action.builder.orchestrator.removeOutboundEdge(contact.id, index_1.EdgeType.UserToContacts);
@@ -307,6 +361,12 @@ const commonTests = (opts) => {
                 await opts.rawDataVerify(filter.user);
             }
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("first. no cursor", () => {
         const N = 2;
@@ -317,7 +377,7 @@ const commonTests = (opts) => {
             return contacts.reverse().slice(0, N);
         }, getViewer());
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
@@ -342,6 +402,12 @@ const commonTests = (opts) => {
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("last", () => {
         const N = 2;
@@ -353,7 +419,7 @@ const commonTests = (opts) => {
             return contacts.slice(0, N).reverse();
         }, getViewer());
         beforeEach(async () => {
-            await filter.beforeEach();
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
@@ -378,6 +444,12 @@ const commonTests = (opts) => {
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     describe("first after cursor", () => {
         const idx = 2;
@@ -388,8 +460,18 @@ const commonTests = (opts) => {
             // < check so we shouldn't get that index
             return contacts.reverse().slice(idx + 1, idx + N);
         }, getViewer());
+        beforeAll(async () => {
+            if (opts.livePostgresDB || opts.sqlite) {
+                await filter.createData();
+            }
+        });
+        // TODO do we still need QueryRecorder?
+        // should just delete this...
         beforeEach(async () => {
-            await filter.beforeEach();
+            if (opts.livePostgresDB || opts.sqlite) {
+                return;
+            }
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
@@ -414,6 +496,12 @@ const commonTests = (opts) => {
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     test("first. after each cursor", async () => {
         let [user, contacts] = await (0, test_helpers_1.createAllContacts)();
@@ -456,8 +544,17 @@ const commonTests = (opts) => {
             // > check so we don't want that index
             return contacts.reverse().slice(0, idx).reverse(); // because of order returned
         }, getViewer());
+        beforeAll(async () => {
+            if (opts.livePostgresDB || opts.sqlite) {
+                await filter.createData();
+            }
+        });
+        // same TODO above
         beforeEach(async () => {
-            await filter.beforeEach();
+            if (opts.livePostgresDB || opts.sqlite) {
+                return;
+            }
+            await filter.createData();
         });
         test("ids", async () => {
             await filter.testIDs();
@@ -482,6 +579,12 @@ const commonTests = (opts) => {
         test("all", async () => {
             await filter.testAll();
         });
+        test("ents cache", async () => {
+            await filter.testEntsCache();
+        });
+        test("data cache", async () => {
+            await filter.testDataCache();
+        });
     });
     test("last. before each cursor", async () => {
         let [user, contacts] = await (0, test_helpers_1.createAllContacts)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha89",
+  "version": "0.1.0-alpha89-16dc3410-33c4-11ed-9fc4-5d4a927887be",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/scripts/custom_graphql.js

@@ -95,6 +95,7 @@ function transformResultType(f) {
                 type: f.resultType,
                 tsType: graphql_1.knownAllowedNames.get(f.resultType),
                 list: f.list,
+                connection: f.connection,
                 nullable: f.nullable,
             },
         ]

package/testutils/db/temp_db.js

@@ -304,7 +304,12 @@ function table(name, ...items) {
                     parts.push("PRIMARY KEY");
                 }
                 if (col.default !== undefined) {
-                    parts.push(`DEFAULT ${col.default}`);
+                    if (db_1.Dialect.SQLite === db_1.default.getDialect()) {
+                        parts.push(`DEFAULT "${col.default}"`);
+                    }
+                    else {
+                        parts.push(`DEFAULT ${col.default}`);
+                    }
                 }
                 if (col.unique) {
                     parts.push("UNIQUE");
@@ -384,6 +389,7 @@ class TempDB {
                 else {
                     process.env.DB_CONNECTION_STRING = `postgres://localhost/${this.db}?`;
                 }
+                db_1.default.initDB();
             }
             else {
                 // will probably be setup via loadConfig

package/testutils/fake_data/fake_contact.d.ts

@@ -1,4 +1,4 @@
-import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
+import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy, Context } from "../../core/base";
 import { SimpleBuilder } from "../builder";
 import { NodeType } from "./const";
 import { ObjectLoaderFactory } from "../../core/loaders";
@@ -20,6 +20,7 @@ export declare class FakeContact implements Ent {
     static loaderOptions(): LoadEntOptions<FakeContact>;
     static load(v: Viewer, id: ID): Promise<FakeContact | null>;
     static loadX(v: Viewer, id: ID): Promise<FakeContact>;
+    static loadRawData(id: ID, context?: Context): Promise<Data | null>;
 }
 export declare const FakeContactSchema: import("../builder").BuilderSchema<FakeContact>;
 export interface ContactCreateInput {

package/testutils/fake_data/fake_contact.js

@@ -60,6 +60,11 @@ class FakeContact {
     static async loadX(v, id) {
         return (0, ent_1.loadEntX)(v, id, FakeContact.loaderOptions());
     }
+    static async loadRawData(id, context) {
+        return FakeContact.loaderOptions()
+            .loaderFactory.createLoader(context)
+            .load(id);
+    }
 }
 exports.FakeContact = FakeContact;
 exports.FakeContactSchema = (0, builder_1.getBuilderSchemaFromFields)({

package/testutils/fake_data/fake_event.d.ts

@@ -24,6 +24,8 @@ export declare class FakeEvent implements Ent {
 }
 export declare const FakeEventSchema: import("../builder").BuilderSchema<FakeEvent>;
 export interface EventCreateInput {
+    createdAt?: Date;
+    updatedAt?: Date;
     startTime: Date;
     endTime?: Date | null;
     location: string;

package/testutils/fake_data/test_helpers.d.ts

@@ -26,6 +26,7 @@ interface options {
     interval: number;
     userInput?: Partial<UserCreateInput>;
     eventInputs?: Partial<EventCreateInput>[];
+    startTime?: number | Date;
 }
 export declare function createAllEvents(opts: options): Promise<[FakeUser, FakeEvent[]]>;
 export {};

package/testutils/fake_data/test_helpers.js

@@ -41,6 +41,8 @@ function getEventInput(user, input) {
         title: "title",
         description: "fun event",
         userID: user.id,
+        createdAt: new Date(),
+        updatedAt: new Date(),
         ...input,
     };
 }
@@ -232,7 +234,7 @@ async function createAllEvents(opts) {
     let arr = new Array(opts.howMany);
     arr.fill(1);
     // start at date in case something else has used a date already
-    (0, jest_date_mock_1.advanceTo)(mock_date_1.MockDate.getDate());
+    (0, jest_date_mock_1.advanceTo)(opts.startTime || mock_date_1.MockDate.getDate());
     const events = await Promise.all(arr.map(async (v, idx) => {
         // just to make times deterministic so that tests can consistently work
         if (opts.interval > 0) {

package/testutils/fake_data/user_query.d.ts

@@ -5,7 +5,6 @@ import * as clause from "../../core/clause";
 import { AssocEdgeQueryBase, EdgeQuerySource } from "../../core/query/assoc_query";
 import { FakeUser, FakeEvent, FakeContact, EventToAttendeesQuery, EventToDeclinedQuery, EventToHostsQuery, EventToInvitedQuery, EventToMaybeQuery } from "./internal";
 import { RawCountLoaderFactory } from "../../core/loaders/raw_count_loader";
-import { IndexLoaderFactory } from "../../core/loaders/index_loader";
 import { QueryLoaderFactory } from "../../core/loaders/query_loader";
 export declare class UserToContactsQuery extends AssocEdgeQueryBase<FakeUser, FakeContact, AssocEdge> {
     constructor(viewer: Viewer, src: EdgeQuerySource<FakeUser>);
@@ -13,7 +12,12 @@ export declare class UserToContactsQuery extends AssocEdgeQueryBase<FakeUser, Fa
     sourceEnt(id: ID): Promise<FakeUser | null>;
 }
 export declare const userToContactsCountLoaderFactory: RawCountLoaderFactory;
-export declare const userToContactsDataLoaderFactory: IndexLoaderFactory;
+export declare const userToContactsDataLoaderFactory: QueryLoaderFactory<unknown>;
+export declare class UserToContactsFkeyQueryDeprecated extends CustomEdgeQueryBase<FakeUser, FakeContact> {
+    constructor(viewer: Viewer, src: ID | FakeUser);
+    static query(viewer: Viewer, src: FakeUser | ID): UserToContactsFkeyQueryDeprecated;
+    sourceEnt(id: ID): Promise<FakeUser | null>;
+}
 export declare class UserToContactsFkeyQuery extends CustomEdgeQueryBase<FakeUser, FakeContact> {
     constructor(viewer: Viewer, src: ID | FakeUser);
     static query(viewer: Viewer, src: FakeUser | ID): UserToContactsFkeyQuery;
@@ -84,8 +88,6 @@ export declare class UserToHostedEventsQuery extends AssocEdgeQueryBase<FakeUser
 }
 export declare const getNextWeekClause: () => clause.Clause;
 export declare function getCompleteClause(id: ID): clause.Clause;
-export declare const userToEventsInNextWeekCountLoaderFactory: RawCountLoaderFactory;
-export declare const userToEventsInNextWeekDataLoaderFactory: QueryLoaderFactory<unknown>;
 export declare class UserToEventsInNextWeekQuery extends CustomEdgeQueryBase<FakeUser, FakeEvent> {
     constructor(viewer: Viewer, src: ID | FakeUser);
     static query(viewer: Viewer, src: FakeUser | ID): UserToEventsInNextWeekQuery;

package/testutils/fake_data/user_query.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserToFollowingQuery = exports.UserToEventsInNextWeekQuery = exports.userToEventsInNextWeekDataLoaderFactory = exports.userToEventsInNextWeekCountLoaderFactory = exports.getCompleteClause = exports.getNextWeekClause = exports.UserToHostedEventsQuery = exports.UserToEventsAttendingQuery = exports.UserToIncomingFriendRequestsQuery = exports.UserToFriendRequestsQuery = exports.UserToCustomEdgeQuery = exports.CustomEdge = exports.UserToFriendsQuery = exports.UserToContactsFkeyQuery = exports.userToContactsDataLoaderFactory = exports.userToContactsCountLoaderFactory = exports.UserToContactsQuery = void 0;
+exports.UserToFollowingQuery = exports.UserToEventsInNextWeekQuery = exports.getCompleteClause = exports.getNextWeekClause = exports.UserToHostedEventsQuery = exports.UserToEventsAttendingQuery = exports.UserToIncomingFriendRequestsQuery = exports.UserToFriendRequestsQuery = exports.UserToCustomEdgeQuery = exports.CustomEdge = exports.UserToFriendsQuery = exports.UserToContactsFkeyQuery = exports.UserToContactsFkeyQueryDeprecated = exports.userToContactsDataLoaderFactory = exports.userToContactsCountLoaderFactory = exports.UserToContactsQuery = void 0;
 const custom_query_1 = require("../../core/query/custom_query");
 const ent_1 = require("../../core/ent");
 const clause = __importStar(require("../../core/clause"));
@@ -28,7 +28,6 @@ const internal_1 = require("./internal");
 const raw_count_loader_1 = require("../../core/loaders/raw_count_loader");
 const assoc_count_loader_1 = require("../../core/loaders/assoc_count_loader");
 const assoc_edge_loader_1 = require("../../core/loaders/assoc_edge_loader");
-const index_loader_1 = require("../../core/loaders/index_loader");
 const fake_contact_1 = require("./fake_contact");
 const jest_date_mock_1 = require("jest-date-mock");
 const luxon_1 = require("luxon");
@@ -52,10 +51,12 @@ exports.userToContactsCountLoaderFactory = new raw_count_loader_1.RawCountLoader
     ...internal_1.FakeContact.loaderOptions(),
     groupCol: "user_id",
 });
-exports.userToContactsDataLoaderFactory = new index_loader_1.IndexLoaderFactory(internal_1.FakeContact.loaderOptions(), "user_id", {
+exports.userToContactsDataLoaderFactory = new query_loader_1.QueryLoaderFactory({
+    ...internal_1.FakeContact.loaderOptions(),
+    groupCol: "user_id",
     toPrime: [fake_contact_1.contactLoader],
 });
-class UserToContactsFkeyQuery extends custom_query_1.CustomEdgeQueryBase {
+class UserToContactsFkeyQueryDeprecated extends custom_query_1.CustomEdgeQueryBase {
     constructor(viewer, src) {
         super(viewer, {
             src,
@@ -65,6 +66,24 @@ class UserToContactsFkeyQuery extends custom_query_1.CustomEdgeQueryBase {
             options: internal_1.FakeContact.loaderOptions(),
         });
     }
+    static query(viewer, src) {
+        return new UserToContactsFkeyQueryDeprecated(viewer, src);
+    }
+    sourceEnt(id) {
+        return internal_1.FakeUser.load(this.viewer, id);
+    }
+}
+exports.UserToContactsFkeyQueryDeprecated = UserToContactsFkeyQueryDeprecated;
+// this replaces UserToContactsFkeyQueryDeprecated
+class UserToContactsFkeyQuery extends custom_query_1.CustomEdgeQueryBase {
+    constructor(viewer, src) {
+        super(viewer, {
+            src,
+            loadEntOptions: internal_1.FakeContact.loaderOptions(),
+            groupCol: "user_id",
+            name: "user_to_contacts",
+        });
+    }
     static query(viewer, src) {
         return new UserToContactsFkeyQuery(viewer, src);
     }
@@ -257,27 +276,15 @@ function getCompleteClause(id) {
     return clause.And(clause.Eq("user_id", id), (0, exports.getNextWeekClause)());
 }
 exports.getCompleteClause = getCompleteClause;
-exports.userToEventsInNextWeekCountLoaderFactory = new raw_count_loader_1.RawCountLoaderFactory({
-    ...internal_1.FakeEvent.loaderOptions(),
-    groupCol: "user_id",
-    clause: (0, exports.getNextWeekClause)(),
-});
-exports.userToEventsInNextWeekDataLoaderFactory = new query_loader_1.QueryLoaderFactory({
-    ...internal_1.FakeEvent.loaderOptions(),
-    groupCol: "user_id",
-    clause: (0, exports.getNextWeekClause)(),
-    toPrime: [fake_contact_1.contactLoader],
-    sortColumn: "start_time",
-});
 class UserToEventsInNextWeekQuery extends custom_query_1.CustomEdgeQueryBase {
     constructor(viewer, src) {
         super(viewer, {
             src,
-            // we want to reuse this and not create a new one every time...
-            countLoaderFactory: exports.userToEventsInNextWeekCountLoaderFactory,
-            dataLoaderFactory: exports.userToEventsInNextWeekDataLoaderFactory,
-            options: internal_1.FakeEvent.loaderOptions(),
-            // hmm TODO shouldn't need to write this twice...
+            ...internal_1.FakeEvent.loaderOptions(),
+            groupCol: "user_id",
+            clause: (0, exports.getNextWeekClause)(),
+            loadEntOptions: internal_1.FakeEvent.loaderOptions(),
+            name: "events_in_next_week",
             sortColumn: "start_time",
         });
     }