@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/core/global_schema.d.ts

@@ -0,0 +1,7 @@
+import { Field, GlobalSchema } from "../schema/schema";
+export declare function setGlobalSchema(val: GlobalSchema): void;
+export declare function clearGlobalSchema(): void;
+export declare function __hasGlobalSchema(): boolean;
+export declare function __getGlobalSchema(): GlobalSchema | undefined;
+export declare function __getGlobalSchemaFields(): Map<string, Field>;
+export declare function __getGlobalSchemaField(type: string): Field | undefined;

package/core/global_schema.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__getGlobalSchemaField = exports.__getGlobalSchemaFields = exports.__getGlobalSchema = exports.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = void 0;
+const schema_1 = require("../schema/schema");
+let globalSchema;
+let globalSchemaFields = new Map();
+function isGlobalSchemaField(f) {
+    switch (f.type.dbType) {
+        case schema_1.DBType.Enum:
+        case schema_1.DBType.StringEnum:
+        case schema_1.DBType.IntEnum:
+        case schema_1.DBType.JSON:
+        case schema_1.DBType.JSONB:
+            return true;
+    }
+    return false;
+}
+function setGlobalSchema(val) {
+    globalSchema = val;
+    if (val.fields) {
+        for (const [k, v] of Object.entries(val.fields)) {
+            if (isGlobalSchemaField(v) && v.type.type) {
+                globalSchemaFields.set(v.type.type, v);
+            }
+        }
+    }
+}
+exports.setGlobalSchema = setGlobalSchema;
+function clearGlobalSchema() {
+    globalSchema = undefined;
+    globalSchemaFields.clear();
+}
+exports.clearGlobalSchema = clearGlobalSchema;
+// used by tests. no guarantee will always exist
+function __hasGlobalSchema() {
+    return globalSchema !== undefined;
+}
+exports.__hasGlobalSchema = __hasGlobalSchema;
+// used by tests. no guarantee will always exist
+function __getGlobalSchema() {
+    return globalSchema;
+}
+exports.__getGlobalSchema = __getGlobalSchema;
+function __getGlobalSchemaFields() {
+    return globalSchemaFields;
+}
+exports.__getGlobalSchemaFields = __getGlobalSchemaFields;
+function __getGlobalSchemaField(type) {
+    return globalSchemaFields.get(type);
+}
+exports.__getGlobalSchemaField = __getGlobalSchemaField;

package/core/loaders/assoc_count_loader.d.ts

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

package/core/loaders/assoc_count_loader.js

@@ -33,9 +33,10 @@ const loader_1 = require("./loader");
 const raw_count_loader_1 = require("./raw_count_loader");
 const memoizee_1 = __importDefault(require("memoizee"));
 class AssocEdgeCountLoader {
-    constructor(edgeType, context) {
+    constructor(edgeType, context, options) {
         this.edgeType = edgeType;
         this.context = context;
+        this.options = options;
         if (context) {
             this.loaderFn = (0, memoizee_1.default)(this.getLoader);
         }
@@ -45,7 +46,9 @@ class AssocEdgeCountLoader {
         if (!edgeData) {
             throw new Error(`error loading edge data for ${this.edgeType}`);
         }
-        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {});
+        const { cls } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", this.edgeType), {
+            queryOptions: this.options,
+        });
         this.loader = (0, raw_count_loader_1.createCountDataLoader)({
             tableName: edgeData.edgeTable,
             groupCol: "id1",
@@ -58,6 +61,7 @@ class AssocEdgeCountLoader {
             return (0, ent_1.loadRawEdgeCountX)({
                 id1: id,
                 edgeType: this.edgeType,
+                queryOptions: this.options,
             });
         }
         const loader = await this.loaderFn();
@@ -79,5 +83,9 @@ class AssocEdgeCountLoaderFactory {
     createLoader(context) {
         return (0, loader_1.getLoader)(this, () => new AssocEdgeCountLoader(this.edgeType, context), context);
     }
+    createConfigurableLoader(options, context) {
+        const key = `${this.name}:disableTransformations:${options.disableTransformations}`;
+        return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeCountLoader(this.edgeType, context, options), context);
+    }
 }
 exports.AssocEdgeCountLoaderFactory = AssocEdgeCountLoaderFactory;

package/core/loaders/assoc_edge_loader.d.ts

@@ -1,6 +1,6 @@
 import { Context, ID, EdgeQueryableDataOptions, Loader, LoaderFactory } from "../base";
 import { AssocEdge, AssocEdgeConstructor } from "../ent";
-interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
+export interface AssocLoader<T extends AssocEdge> extends Loader<ID, T[]> {
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
 }
 export declare class AssocEdgeLoader<T extends AssocEdge> implements Loader<ID, T[]> {
@@ -21,7 +21,7 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeCtr;
     private options?;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby" | "disableTransformations">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;
@@ -35,4 +35,3 @@ export declare class AssocEdgeLoaderFactory<T extends AssocEdge> implements Load
     private isConstructor;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): AssocLoader<T>;
 }
-export {};

package/core/loaders/assoc_edge_loader.js

@@ -36,7 +36,7 @@ const memoizee_1 = __importDefault(require("memoizee"));
 function createLoader(options, edgeType, edgeCtr, edgeData) {
     const loaderOptions = {};
     if ((0, logger_1.logEnabled)("query")) {
-        loaderOptions.cacheMap = new loader_1.cacheMap({
+        loaderOptions.cacheMap = new loader_1.CacheMap({
             tableName: edgeData.edgeTable,
         });
     }
@@ -59,17 +59,24 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
             // store the index....
             m.set(keys[i], i);
         }
-        options.orderby = options.orderby || "time DESC";
+        options.orderby = options.orderby || [
+            {
+                column: "time",
+                direction: "DESC",
+            },
+        ];
         // TODO defaultEdgeQueryOptions
-        options.limit = options.limit || ent_1.DefaultLimit;
+        options.limit = options.limit || (0, ent_1.getDefaultLimit)();
         const tableName = edgeData.edgeTable;
-        const { cls: cls1, fields } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", edgeType), {});
+        const { cls: cls1, fields } = (0, ent_1.getEdgeClauseAndFields)(clause.Eq("edge_type", edgeType), {
+            queryOptions: options,
+        });
         const [query, cls] = (0, ent_1.buildGroupQuery)({
             tableName: tableName,
             fields,
             values: keys,
             orderby: options.orderby,
-            limit: options.limit || ent_1.DefaultLimit,
+            limit: options.limit || (0, ent_1.getDefaultLimit)(),
             groupColumn: "id1",
             clause: cls1,
         });
@@ -114,6 +121,7 @@ class AssocEdgeLoader {
             id2,
             context: this.context,
             ctr: this.edgeCtr,
+            queryOptions: this.options,
         });
     }
     clearAll() {
@@ -129,7 +137,7 @@ class AssocDirectEdgeLoader {
         this.context = context;
     }
     async load(id) {
-        return await (0, ent_1.loadCustomEdges)({
+        return (0, ent_1.loadCustomEdges)({
             id1: id,
             edgeType: this.edgeType,
             context: this.context,
@@ -143,6 +151,7 @@ class AssocDirectEdgeLoader {
             edgeType: this.edgeType,
             id2,
             context: this.context,
+            queryOptions: this.options,
             ctr: this.edgeCtr,
         });
     }
@@ -181,7 +190,7 @@ class AssocEdgeLoaderFactory {
             return new AssocDirectEdgeLoader(this.edgeType, edgeCtr, options, context);
         }
         // we create a loader which can combine first X queries in the same fetch
-        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}`;
+        const key = `${this.name}:limit:${options.limit}:orderby:${options.orderby}:disableTransformations:${options.disableTransformations}`;
         return (0, loader_1.getCustomLoader)(key, () => new AssocEdgeLoader(this.edgeType, ctr, options, context), context);
     }
 }

package/core/loaders/index.d.ts

@@ -2,5 +2,4 @@ export { ObjectLoader, ObjectLoaderFactory } from "./object_loader";
 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 { QueryLoaderFactory } from "./query_loader";

package/core/loaders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryLoaderFactory = 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.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; } });
@@ -14,7 +14,5 @@ var assoc_edge_loader_1 = require("./assoc_edge_loader");
 Object.defineProperty(exports, "AssocDirectEdgeLoader", { enumerable: true, get: function () { return assoc_edge_loader_1.AssocDirectEdgeLoader; } });
 Object.defineProperty(exports, "AssocEdgeLoader", { enumerable: true, get: function () { return assoc_edge_loader_1.AssocEdgeLoader; } });
 Object.defineProperty(exports, "AssocEdgeLoaderFactory", { enumerable: true, get: function () { return assoc_edge_loader_1.AssocEdgeLoaderFactory; } });
-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, "QueryLoaderFactory", { enumerable: true, get: function () { return query_loader_1.QueryLoaderFactory; } });

package/core/loaders/loader.d.ts

@@ -1,7 +1,7 @@
 import { Loader, LoaderFactory, Context, DataOptions } from "../base";
-export declare function getLoader<T, V>(factory: LoaderFactory<T, V>, create: () => Loader<T, V>, context?: Context): Loader<T, V>;
-export declare function getCustomLoader<T, V>(key: string, create: () => Loader<T, V>, context?: Context): Loader<T, V>;
-export declare class cacheMap {
+export declare function getLoader<K, V>(factory: LoaderFactory<K, V>, create: () => Loader<K, V>, context?: Context): Loader<K, V>;
+export declare function getCustomLoader<K, V>(key: string, create: () => Loader<K, V>, context?: Context): Loader<K, V>;
+export declare class CacheMap {
     private options;
     private m;
     constructor(options: DataOptions);

package/core/loaders/loader.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cacheMap = exports.getCustomLoader = exports.getLoader = void 0;
+exports.CacheMap = exports.getCustomLoader = exports.getLoader = void 0;
 const logger_1 = require("../logger");
 // this is like factory factory FML
 // helper function to handle context vs not
@@ -25,7 +25,7 @@ function getCustomLoader(key, create, context) {
     return context.cache.getLoader(key, create);
 }
 exports.getCustomLoader = getCustomLoader;
-class cacheMap {
+class CacheMap {
     constructor(options) {
         this.options = options;
         this.m = new Map();
@@ -41,34 +41,17 @@ class cacheMap {
                 "dataloader-cache-hit": key,
                 "tableName": this.options.tableName,
             });
-            // } else {
-            //   log("cache", {
-            //     "dataloader-cache-miss": key,
-            //     "tableName": options.tableName,
-            //   });
         }
         return ret;
     }
     set(key, value) {
-        // log("cache", {
-        //   "dataloader-cache-set": key,
-        //   "tableName": options.tableName,
-        // });
         return this.m.set(key, value);
     }
     delete(key) {
-        // log("cache", {
-        //   "dataloader-cache-delete": key,
-        //   "tableName": options.tableName,
-        // });
         return this.m.delete(key);
     }
     clear() {
-        // log("cache", {
-        //   "dataloader-cache-clear": true,
-        //   "tableName": options.tableName,
-        // });
         return this.m.clear();
     }
 }
-exports.cacheMap = cacheMap;
+exports.CacheMap = CacheMap;

package/core/loaders/object_loader.d.ts

@@ -1,29 +1,49 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
-export declare class ObjectLoader<T> implements Loader<T, Data | null> {
+import * as clause from "../clause";
+export declare class ObjectLoader<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData> implements Loader<ID, TResultData | null>, Loader<clause.Clause<TQueryData, K>, TResultData[] | null> {
     private options;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
-    private loader;
+    private idLoader;
+    private clauseLoader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<TResultData>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
-    load(key: T): Promise<Data | null>;
+    load(key: ID): Promise<TResultData | null>;
+    load(key: clause.Clause<TQueryData, K>): Promise<TResultData[] | null>;
+    private loadID;
+    private loadClause;
+    clearAll(): void;
+    loadMany(keys: ID[]): Promise<Array<TResultData | null>>;
+    loadMany(keys: clause.Clause<TQueryData, K>[]): Promise<Array<TResultData[] | null>>;
+    private loadIDMany;
+    private loadClauseMany;
+    prime(data: TResultData): void;
+    primeAll(data: TResultData): void;
+}
+export declare class ObjectCountLoader<V extends Data = Data, K = keyof V> implements Loader<clause.Clause<V, K>, number> {
+    private options;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    private loader;
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    getOptions(): SelectDataOptions;
+    load(key: clause.Clause<V, K>): Promise<number>;
     clearAll(): void;
-    loadMany(keys: T[]): Promise<Array<Data | null>>;
-    prime(data: Data): void;
-    primeAll(data: Data): void;
+    loadMany(keys: clause.Clause<V, K>[]): Promise<Array<number>>;
 }
 interface ObjectLoaderOptions extends SelectDataOptions {
     instanceKey?: string;
 }
-export declare class ObjectLoaderFactory<T> implements LoaderFactory<T, Data | null> {
+export declare class ObjectLoaderFactory<V extends Data = Data> implements LoaderFactory<ID, V | null>, LoaderFactory<clause.Clause<V>, V[] | null> {
     options: ObjectLoaderOptions;
     name: string;
     private toPrime;
     constructor(options: ObjectLoaderOptions);
-    createLoader(context?: Context): ObjectLoader<T>;
-    addToPrime(factory: ObjectLoaderFactory<T>): this;
+    createLoader(context?: Context): ObjectLoader<V>;
+    createTypedLoader<TQueryData extends Data = Data, TResultData extends Data = Data, K = keyof TQueryData>(context?: Context): ObjectLoader<TQueryData, TResultData, K>;
+    createCountLoader<K = keyof V>(context?: Context): ObjectCountLoader<V, K>;
+    addToPrime(factory: ObjectLoaderFactory<V>): this;
 }
 export {};