@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/core/loaders/object_loader.js

@@ -26,28 +26,17 @@ 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 loadRowsForLoader(options, ids, context) {
+async function loadRowsForIDLoader(options, ids, context) {
     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(cls, optionClause);
-        }
-    }
+    const cls = (0, clause_1.getCombinedClause)(options, clause.DBTypeIn(col, ids, options.keyType || "uuid"));
     const rowOptions = {
         ...options,
         clause: cls,
@@ -60,7 +49,7 @@ async function loadRowsForLoader(options, ids, context) {
         // store the index....
         m.set(ids[i], i);
     }
-    const rows = await (0, ent_1.loadRows)(rowOptions);
+    const rows = (await (0, ent_1.loadRows)(rowOptions));
     for (const row of rows) {
         const id = row[col];
         if (id === undefined) {
@@ -74,6 +63,29 @@ async function loadRowsForLoader(options, ids, context) {
     }
     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...
@@ -81,16 +93,73 @@ 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 [];
         }
         // context not needed because we're creating a loader which has its own cache which is being used here
-        return loadRowsForLoader(options, ids);
+        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,
+            });
+        }
+        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 [];
+        }
+        const ret = [];
+        for await (const clause of clauses) {
+            const data = await loadRowsForClauseLoader(options, clause);
+            ret.push(data);
+        }
+        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) {
         this.options = options;
@@ -100,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));
     }
@@ -122,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];
@@ -137,19 +213,7 @@ 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(cls, optionClause);
-            }
-        }
+        const cls = (0, clause_1.getCombinedClause)(this.options, clause.Eq(this.options.key, key));
         const rowOptions = {
             ...this.options,
             clause: cls,
@@ -157,21 +221,50 @@ class ObjectLoader {
         };
         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 [];
+        }
+        if (typeof keys[0] === "string" || typeof keys[0] === "number") {
+            return this.loadIDMany(keys);
+        }
+        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 loadRowsForLoader(this.options, keys, this.context);
+        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
@@ -188,6 +281,43 @@ class ObjectLoader {
     }
 }
 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
@@ -211,6 +341,15 @@ 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) {

package/core/loaders/query_loader.d.ts

@@ -1,14 +1,14 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory, Data } from "../base";
 import * as clause from "../clause";
 import { ObjectLoaderFactory } from "./object_loader";
-export declare function getOrderBy(sortCol: string, orderby?: string): string;
+import { OrderBy } from "../query_impl";
 declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     private options;
     private queryOptions?;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private memoizedInitPrime;
     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);
+    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;
@@ -18,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;

package/core/loaders/query_loader.js

@@ -26,25 +26,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = exports.getOrderBy = 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) {
-    if (orderby) {
-        return orderby;
-    }
-    let sortColLower = sortCol.toLowerCase();
-    let orderbyDirection = " DESC";
-    if (sortColLower.endsWith("asc") || sortCol.endsWith("desc")) {
-        orderbyDirection = "";
-    }
-    return `${sortCol}${orderbyDirection}`;
+function getOrderByLocal(options, queryOptions) {
+    return (options.orderby ??
+        queryOptions?.orderby ?? [
+        {
+            column: "created_at",
+            direction: "DESC",
+        },
+    ]);
 }
-exports.getOrderBy = getOrderBy;
 async function simpleCase(options, id, queryOptions) {
     let cls;
     if (options.groupCol) {
@@ -62,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) {
@@ -109,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,
         });

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

@@ -59,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) {
@@ -69,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/privacy.d.ts

@@ -1,4 +1,4 @@
-import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer } from "./base";
+import { Ent, ID, LoadEntOptions, PrivacyError, PrivacyPolicy, PrivacyPolicyRule, PrivacyResult, Viewer, EdgeQueryableDataOptionsConfigureLoader } from "./base";
 export declare class EntPrivacyError extends Error implements PrivacyError {
     privacyPolicy: PrivacyPolicy;
     privacyRule: PrivacyPolicyRule;
@@ -115,51 +115,60 @@ export declare class AllowIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfEdgeExistsRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerInboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerOutboundEdgeExistsRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private id1;
     private id2;
     private edgeType;
-    constructor(id1: ID, id2: ID, edgeType: string);
+    private options?;
+    constructor(id1: ID, id2: ID, edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerInboundEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class DenyIfViewerOutboundEdgeDoesNotExistRule implements PrivacyPolicyRule {
     private edgeType;
-    constructor(edgeType: string);
+    private options?;
+    constructor(edgeType: string, options?: EdgeQueryableDataOptionsConfigureLoader | undefined);
     apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfConditionAppliesRule implements PrivacyPolicyRule {