@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha150

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

@@ -13,5 +13,6 @@ export declare class AssocEdgeCountLoaderFactory implements LoaderFactory<ID, nu
     private edgeType;
     name: string;
     constructor(edgeType: string);
+    getEdgeType(): string;
     createLoader(context?: Context): AssocEdgeCountLoader;
 }

package/core/loaders/assoc_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];
@@ -41,10 +45,11 @@ 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), {});
         this.loader = (0, raw_count_loader_1.createCountDataLoader)({
             tableName: edgeData.edgeTable,
             groupCol: "id1",
-            clause: clause.Eq("edge_type", this.edgeType),
+            clause: cls,
         });
         return this.loader;
     }
@@ -68,6 +73,9 @@ class AssocEdgeCountLoaderFactory {
         this.edgeType = edgeType;
         this.name = `assocEdgeLoader:count:${edgeType}`;
     }
+    getEdgeType() {
+        return this.edgeType;
+    }
     createLoader(context) {
         return (0, loader_1.getLoader)(this, () => new AssocEdgeCountLoader(this.edgeType, context), context);
     }

package/core/loaders/assoc_edge_loader.d.ts

@@ -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">> | 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;

package/core/loaders/assoc_edge_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];
@@ -57,24 +61,17 @@ function createLoader(options, edgeType, edgeCtr, edgeData) {
         }
         options.orderby = options.orderby || "time 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 [query, cls] = (0, ent_1.buildGroupQuery)({
             tableName: tableName,
-            fields: [
-                "id1",
-                "id2",
-                "edge_type",
-                "id1_type",
-                "id2_type",
-                "data",
-                "time",
-            ],
+            fields,
             values: keys,
             orderby: options.orderby,
-            limit: options.limit || ent_1.DefaultLimit,
+            limit: options.limit || (0, ent_1.getDefaultLimit)(),
             groupColumn: "id1",
-            clause: clause.Eq("edge_type", edgeType),
+            clause: cls1,
         });
         const rows = await (0, ent_1.performRawQuery)(query, cls.values(), cls.logValues());
         for (const row of rows) {

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[]> {
@@ -7,8 +7,8 @@ export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
     constructor(options: SelectBaseDataOptions, col: string, opts?: {
         extraClause?: clause.Clause;
         sortColumn?: string;
-        toPrime?: ObjectLoaderFactory<ID>[];
+        toPrime?: ObjectLoaderFactory<Data>[];
     });
     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/loader.d.ts

@@ -1,6 +1,6 @@
 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 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;

package/core/loaders/loader.js

@@ -37,12 +37,12 @@ class cacheMap {
             // might be a lot?
             // TODO this is not the best log format
             // was designed for ObjectLoader time. Now we have different needs e.g. count, assoc etc
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "dataloader-cache-hit": key,
                 "tableName": this.options.tableName,
             });
             // } else {
-            //   log("query", {
+            //   log("cache", {
             //     "dataloader-cache-miss": key,
             //     "tableName": options.tableName,
             //   });
@@ -50,21 +50,21 @@ class cacheMap {
         return ret;
     }
     set(key, value) {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-set": key,
         //   "tableName": options.tableName,
         // });
         return this.m.set(key, value);
     }
     delete(key) {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-delete": key,
         //   "tableName": options.tableName,
         // });
         return this.m.delete(key);
     }
     clear() {
-        // log("query", {
+        // log("cache", {
         //   "dataloader-cache-clear": true,
         //   "tableName": options.tableName,
         // });

package/core/loaders/object_loader.d.ts

@@ -1,28 +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<Data[]>;
-    prime(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>): void;
+    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 {};