@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

package/core/loaders/object_loader.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -22,13 +26,66 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+exports.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
+const clause_1 = require("../clause");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
+async function loadRowsForIDLoader(options, ids, context) {
+    let col = options.key;
+    const cls = (0, clause_1.getCombinedClause)(options, clause.DBTypeIn(col, ids, options.keyType || "uuid"));
+    const rowOptions = {
+        ...options,
+        clause: cls,
+        context,
+    };
+    let m = new Map();
+    let result = [];
+    for (let i = 0; i < ids.length; i++) {
+        result.push(null);
+        // store the index....
+        m.set(ids[i], i);
+    }
+    const rows = (await (0, ent_1.loadRows)(rowOptions));
+    for (const row of rows) {
+        const id = row[col];
+        if (id === undefined) {
+            throw new Error(`need to query for column ${col} when using an object loader because the query may not be sorted and we need the id to maintain sort order`);
+        }
+        const idx = m.get(id);
+        if (idx === undefined) {
+            throw new Error(`malformed query. got ${id} back but didn't query for it`);
+        }
+        result[idx] = row;
+    }
+    return result;
+}
+async function loadRowsForClauseLoader(options, clause) {
+    const rowOptions = {
+        ...options,
+        // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
+        clause: (0, clause_1.getCombinedClause)(options, clause),
+    };
+    return (await (0, ent_1.loadRows)(rowOptions));
+}
+async function loadCountForClauseLoader(options, clause) {
+    const rowOptions = {
+        ...options,
+        // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
+        clause: (0, clause_1.getCombinedClause)(options, clause),
+    };
+    const row = await (0, ent_1.loadRow)({
+        ...rowOptions,
+        fields: ["count(*) as count"],
+    });
+    if (!row) {
+        return 0;
+    }
+    return parseInt(row.count, 10);
+}
 // optional clause...
 // so ObjectLoaderFactory and createDataLoader need to take a new optional field which is a clause that's always added here
 // and we need a disableTransform which skips loader completely and uses loadRow...
@@ -36,49 +93,72 @@ function createDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
     if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.cacheMap(options);
+        loaderOptions.cacheMap = new loader_1.CacheMap(options);
     }
     return new dataloader_1.default(async (ids) => {
         if (!ids.length) {
             return [];
         }
-        let col = options.key;
-        let cls = clause.In(col, ...ids);
-        if (options.clause) {
-            let optionClause;
-            if (typeof options.clause === "function") {
-                optionClause = options.clause();
-            }
-            else {
-                optionClause = options.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(optionClause, cls);
-            }
+        // context not needed because we're creating a loader which has its own cache which is being used here
+        return loadRowsForIDLoader(options, ids);
+    }, loaderOptions);
+}
+class clauseCacheMap {
+    constructor(options, count) {
+        this.options = options;
+        this.count = count;
+        this.m = new Map();
+    }
+    get(key) {
+        const key2 = key.instanceKey();
+        const ret = this.m.get(key2);
+        if (ret) {
+            (0, logger_1.log)("cache", {
+                "dataloader-cache-hit": key2 + (this.count ? ":count" : ""),
+                "tableName": this.options.tableName,
+            });
         }
-        const rowOptions = {
-            ...options,
-            clause: cls,
-        };
-        let m = new Map();
-        let result = [];
-        for (let i = 0; i < ids.length; i++) {
-            result.push(null);
-            // store the index....
-            m.set(ids[i], i);
+        return ret;
+    }
+    set(key, value) {
+        return this.m.set(key.instanceKey(), value);
+    }
+    delete(key) {
+        return this.m.delete(key.instanceKey());
+    }
+    clear() {
+        return this.m.clear();
+    }
+}
+function createClauseDataLoder(options) {
+    return new dataloader_1.default(async (clauses) => {
+        if (!clauses.length) {
+            return [];
         }
-        // context not needed because we're creating a loader which has its own cache which is being used here
-        const rows = await (0, ent_1.loadRows)(rowOptions);
-        for (const row of rows) {
-            const id = row[col];
-            const idx = m.get(id);
-            if (idx === undefined) {
-                throw new Error(`malformed query. got ${id} back but didn't query for it`);
-            }
-            result[idx] = row;
+        const ret = [];
+        for await (const clause of clauses) {
+            const data = await loadRowsForClauseLoader(options, clause);
+            ret.push(data);
         }
-        return result;
-    }, loaderOptions);
+        return ret;
+    }, {
+        cacheMap: new clauseCacheMap(options),
+    });
+}
+function createClauseCountDataLoader(options) {
+    return new dataloader_1.default(async (clauses) => {
+        if (!clauses.length) {
+            return [];
+        }
+        const ret = [];
+        for await (const clause of clauses) {
+            const data = await loadCountForClauseLoader(options, clause);
+            ret.push(data);
+        }
+        return ret;
+    }, {
+        cacheMap: new clauseCacheMap(options, true),
+    });
 }
 class ObjectLoader {
     constructor(options, context, toPrime) {
@@ -89,7 +169,8 @@ class ObjectLoader {
             console.trace();
         }
         if (context) {
-            this.loader = createDataLoader(options);
+            this.idLoader = createDataLoader(options);
+            this.clauseLoader = createClauseDataLoder(options);
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
@@ -111,11 +192,17 @@ class ObjectLoader {
         this.primedLoaders = primedLoaders;
     }
     async load(key) {
+        if (typeof key === "string" || typeof key === "number") {
+            return this.loadID(key);
+        }
+        return this.loadClause(key);
+    }
+    async loadID(key) {
         // simple case. we get parallelization etc
-        if (this.loader) {
+        if (this.idLoader) {
             this.memoizedInitPrime();
             // prime the result if we got primable loaders
-            const result = await this.loader.load(key);
+            const result = await this.idLoader.load(key);
             if (result && this.primedLoaders) {
                 for (const [key, loader] of this.primedLoaders) {
                     const value = result[key];
@@ -126,69 +213,119 @@ class ObjectLoader {
             }
             return result;
         }
-        let cls = clause.Eq(this.options.key, key);
-        if (this.options.clause) {
-            let optionClause;
-            if (typeof this.options.clause === "function") {
-                optionClause = this.options.clause();
-            }
-            else {
-                optionClause = this.options.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(optionClause, cls);
-            }
-        }
+        const cls = (0, clause_1.getCombinedClause)(this.options, clause.Eq(this.options.key, key));
         const rowOptions = {
             ...this.options,
             clause: cls,
             context: this.context,
         };
-        return await (0, ent_1.loadRow)(rowOptions);
+        return (0, ent_1.loadRow)(rowOptions);
+    }
+    async loadClause(key) {
+        if (this.clauseLoader) {
+            return this.clauseLoader.load(key);
+        }
+        return loadRowsForClauseLoader(this.options, key);
     }
     clearAll() {
-        this.loader && this.loader.clearAll();
+        this.idLoader && this.idLoader.clearAll();
+        this.clauseLoader && this.clauseLoader.clearAll();
     }
     async loadMany(keys) {
-        if (this.loader) {
-            return await this.loader.loadMany(keys);
+        if (!keys.length) {
+            return [];
         }
-        let cls = clause.In(this.options.key, ...keys);
-        if (this.options.clause) {
-            let optionClause;
-            if (typeof this.options.clause === "function") {
-                optionClause = this.options.clause();
-            }
-            else {
-                optionClause = this.options.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(optionClause, cls);
-            }
+        if (typeof keys[0] === "string" || typeof keys[0] === "number") {
+            return this.loadIDMany(keys);
         }
-        const rowOptions = {
-            ...this.options,
-            clause: cls,
-            context: this.context,
-        };
-        return await (0, ent_1.loadRows)(rowOptions);
+        return this.loadClauseMany(keys);
+    }
+    loadIDMany(keys) {
+        if (this.idLoader) {
+            // @ts-expect-error TODO?
+            return this.idLoader.loadMany(keys);
+        }
+        return loadRowsForIDLoader(this.options, keys, this.context);
+    }
+    async loadClauseMany(keys) {
+        if (this.clauseLoader) {
+            // @ts-expect-error TODO?
+            return this.clauseLoader.loadMany(keys);
+        }
+        const res = [];
+        for await (const key of keys) {
+            const rows = await loadRowsForClauseLoader(this.options, key);
+            res.push(rows);
+        }
+        return res;
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
-        if (this.loader) {
+        if (this.idLoader) {
             const col = this.options.key;
             const key = data[col];
-            this.loader.prime(key, data);
+            this.idLoader.prime(key, data);
+        }
+    }
+    // prime this loader and any other loaders it's aware of
+    primeAll(data) {
+        this.prime(data);
+        if (this.primedLoaders) {
+            for (const [key, loader] of this.primedLoaders) {
+                const value = data[key];
+                if (value !== undefined) {
+                    loader.prime(data);
+                }
+            }
         }
     }
 }
 exports.ObjectLoader = ObjectLoader;
+class ObjectCountLoader {
+    constructor(options, context) {
+        this.options = options;
+        this.context = context;
+        if (context) {
+            this.loader = createClauseCountDataLoader(options);
+        }
+    }
+    getOptions() {
+        return this.options;
+    }
+    async load(key) {
+        if (this.loader) {
+            return this.loader.load(key);
+        }
+        return loadCountForClauseLoader(this.options, key);
+    }
+    clearAll() {
+        this.loader && this.loader.clearAll();
+    }
+    async loadMany(keys) {
+        if (!keys.length) {
+            return [];
+        }
+        if (this.loader) {
+            // @ts-expect-error
+            return this.loader.loadMany(keys);
+        }
+        const res = [];
+        for await (const key of keys) {
+            const r = await loadCountForClauseLoader(this.options, key);
+            res.push(r);
+        }
+        return res;
+    }
+}
+exports.ObjectCountLoader = ObjectCountLoader;
+// NOTE: if not querying for all columns
+// have to query for the id field as one of the fields
+// because it's used to maintain sort order of the queried ids
 class ObjectLoaderFactory {
     constructor(options) {
         this.options = options;
         this.toPrime = [];
-        // we don't wanna do it here because we want it to be delayed
-        let instanceKey = "";
+        let instanceKey = options.instanceKey || "";
         if (typeof this.options.clause === "function") {
             if (!options.instanceKey) {
                 throw new Error(`need to pass an instanceKey to ObjectLoader if clause is a function`);
@@ -204,10 +341,20 @@ class ObjectLoaderFactory {
             return new ObjectLoader(this.options, context, this.toPrime);
         }, context);
     }
+    createTypedLoader(context) {
+        const loader = this.createLoader(context);
+        return loader;
+    }
+    createCountLoader(context) {
+        return (0, loader_1.getCustomLoader)(`${this.name}:count_loader`, () => {
+            return new ObjectCountLoader(this.options, context);
+        }, context);
+    }
     // keep track of loaders to prime. needs to be done not in the constructor
     // because there's usually self references here
     addToPrime(factory) {
         this.toPrime.push(factory);
+        return this;
     }
 }
 exports.ObjectLoaderFactory = ObjectLoaderFactory;

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[]> {
+import { OrderBy } from "../query_impl";
+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, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;
@@ -25,8 +18,8 @@ interface QueryOptions {
     tableName: string;
     groupCol?: string;
     clause?: clause.Clause;
-    sortColumn?: string;
-    toPrime?: ObjectLoaderFactory<ID>[];
+    orderby?: OrderBy;
+    toPrime?: ObjectLoaderFactory<Data>[];
 }
 export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<K, Data[]> {
     private options;
@@ -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

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -22,20 +26,21 @@ 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 = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
-function getOrderBy(sortCol, orderby) {
-    let sortColLower = sortCol.toLowerCase();
-    let orderbyDirection = " DESC";
-    if (sortColLower.endsWith("asc") || sortCol.endsWith("desc")) {
-        orderbyDirection = "";
-    }
-    return orderby || `${sortCol}${orderbyDirection}`;
+function getOrderByLocal(options, queryOptions) {
+    return (options.orderby ??
+        queryOptions?.orderby ?? [
+        {
+            column: "created_at",
+            direction: "DESC",
+        },
+    ]);
 }
 async function simpleCase(options, id, queryOptions) {
     let cls;
@@ -54,20 +59,18 @@ async function simpleCase(options, id, queryOptions) {
     if (queryOptions?.clause) {
         cls = clause.And(cls, queryOptions.clause);
     }
-    let sortCol = options.sortColumn || "created_at";
     return await (0, ent_1.loadRows)({
         ...options,
         clause: cls,
-        orderby: getOrderBy(sortCol, queryOptions?.orderby),
-        limit: queryOptions?.limit || ent_1.DefaultLimit,
+        orderby: getOrderByLocal(options, queryOptions),
+        limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
     });
 }
 function createLoader(options, queryOptions) {
-    let sortCol = options.sortColumn || "created_at";
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
     if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.cacheMap(options);
+        loaderOptions.cacheMap = new loader_1.CacheMap(options);
     }
     return new dataloader_1.default(async (keys) => {
         if (!keys.length) {
@@ -101,8 +104,8 @@ function createLoader(options, queryOptions) {
             tableName: options.tableName,
             fields: options.fields,
             values: keys,
-            orderby: getOrderBy(sortCol, queryOptions?.orderby),
-            limit: queryOptions?.limit || ent_1.DefaultLimit,
+            orderby: getOrderByLocal(options, queryOptions),
+            limit: queryOptions?.limit || (0, ent_1.getDefaultLimit)(),
             groupColumn: col,
             clause: extraClause,
         });
@@ -120,16 +123,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 +210,6 @@ class QueryLoader {
         this.loader && this.loader.clearAll();
     }
 }
-exports.QueryLoader = QueryLoader;
 class QueryLoaderFactory {
     constructor(options) {
         this.options = options;
@@ -194,11 +227,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/loaders/raw_count_loader.d.ts

@@ -4,6 +4,7 @@ import * as clause from "../clause";
 interface QueryCountOptions {
     tableName: string;
     groupCol?: string;
+    groupColType?: string;
     clause?: clause.Clause;
 }
 export declare function createCountDataLoader<K extends any>(options: QueryCountOptions): DataLoader<K, number, K>;

package/core/loaders/raw_count_loader.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -55,7 +59,7 @@ function createCountDataLoader(options) {
     const loaderOptions = {};
     // if query logging is enabled, we should log what's happening with loader
     if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.cacheMap(options);
+        loaderOptions.cacheMap = new loader_1.CacheMap(options);
     }
     return new dataloader_1.default(async (keys) => {
         if (!keys.length) {
@@ -65,7 +69,8 @@ function createCountDataLoader(options) {
         if (keys.length == 1 || !options.groupCol) {
             return simpleCase(options, keys[0]);
         }
-        let cls = clause.In(options.groupCol, ...keys);
+        let typ = options.groupColType || "uuid";
+        let cls = clause.DBTypeIn(options.groupCol, keys, typ);
         if (options.clause) {
             cls = clause.And(cls, options.clause);
         }

package/core/logger.d.ts

@@ -1,4 +1,4 @@
-declare type logType = "query" | "warn" | "info" | "error" | "debug";
+type logType = "query" | "warn" | "info" | "error" | "debug" | "cache";
 export declare function setLogLevels(levels: logType | logType[]): void;
 export declare function clearLogLevels(): void;
 export declare function log(level: logType, msg: any): void;

package/core/logger.js

@@ -7,6 +7,7 @@ var m = {
     info: "log",
     error: "error",
     debug: "debug",
+    cache: "log",
 };
 var logLevels = new Map();
 function setLogLevels(levels) {