@snowtop/ent 0.1.0-alpha124 → 0.1.0-alpha125

package/core/loaders/object_loader.js

@@ -26,17 +26,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = void 0;
+exports.ObjectLoaderFactory = 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) {
+async function loadRowsForLoader(options, ids, context) {
     let col = options.key;
-    const cls = (0, clause_1.getCombinedClause)(options, clause.In(col, ...ids));
+    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) {
+            // @ts-expect-error id/string mismatch
+            cls = clause.And(cls, optionClause);
+        }
+    }
     const rowOptions = {
         ...options,
         clause: cls,
@@ -63,29 +75,6 @@ async function loadRowsForIDLoader(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...
@@ -100,66 +89,9 @@ function createDataLoader(options) {
             return [];
         }
         // context not needed because we're creating a loader which has its own cache which is being used here
-        return loadRowsForIDLoader(options, ids);
+        return loadRowsForLoader(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;
@@ -169,8 +101,7 @@ class ObjectLoader {
             console.trace();
         }
         if (context) {
-            this.idLoader = createDataLoader(options);
-            this.clauseLoader = createClauseDataLoder(options);
+            this.loader = createDataLoader(options);
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
@@ -192,17 +123,11 @@ 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.idLoader) {
+        if (this.loader) {
             this.memoizedInitPrime();
             // prime the result if we got primable loaders
-            const result = await this.idLoader.load(key);
+            const result = await this.loader.load(key);
             if (result && this.primedLoaders) {
                 for (const [key, loader] of this.primedLoaders) {
                     const value = result[key];
@@ -213,7 +138,19 @@ class ObjectLoader {
             }
             return result;
         }
-        const cls = (0, clause_1.getCombinedClause)(this.options, clause.Eq(this.options.key, key));
+        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 rowOptions = {
             ...this.options,
             clause: cls,
@@ -221,50 +158,22 @@ 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.idLoader && this.idLoader.clearAll();
-        this.clauseLoader && this.clauseLoader.clearAll();
+        this.loader && this.loader.clearAll();
     }
     async 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) {
+        if (this.loader) {
             // @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 this.loader.loadMany(keys);
         }
-        return res;
+        return loadRowsForLoader(this.options, keys, this.context);
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
-        if (this.idLoader) {
+        if (this.loader) {
             const col = this.options.key;
             const key = data[col];
-            this.idLoader.prime(key, data);
+            this.loader.prime(key, data);
         }
     }
     // prime this loader and any other loaders it's aware of
@@ -281,43 +190,6 @@ 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
@@ -341,15 +213,6 @@ 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

@@ -8,7 +8,7 @@ declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     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, "clause" | "limit" | "orderby">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    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;

package/core/query/shared_test.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTests = void 0;
 const ent_1 = require("../ent");
-const global_schema_1 = require("../global_schema");
 const viewer_1 = require("../viewer");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
@@ -290,7 +289,7 @@ const commonTests = (opts) => {
         return { verify, getCursor };
     }
     if (opts.globalSchema) {
-        (0, global_schema_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
+        (0, ent_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
     }
     let tdb;
     if (opts.sqlite) {

package/graphql/graphql.d.ts

@@ -1,4 +1,3 @@
-import "reflect-metadata";
 import { GraphQLScalarType } from "graphql";
 interface ClassType<T = any> {
     new (...args: any[]): T;
@@ -19,17 +18,29 @@ type Type = GraphQLScalarType | ClassType | string | CustomType;
 export type GraphQLConnection<T> = {
     node: T;
 };
-export interface gqlFieldOptions {
+interface gqlFieldOptionsBase {
     name?: string;
     nullable?: boolean | NullableListOptions;
     description?: string;
     type?: Type | Array<Type> | GraphQLConnection<Type>;
 }
+interface gqlFieldArg extends gqlFieldOptionsBase {
+    isContextArg?: boolean;
+}
+export interface gqlFieldOptions extends gqlFieldOptionsBase {
+    nodeName: string;
+    args?: gqlFieldArg[];
+    async?: boolean;
+    type: NonNullable<gqlFieldOptionsBase["type"]>;
+}
 export interface gqlObjectOptions {
     name?: string;
     description?: string;
 }
-type gqlTopLevelOptions = Exclude<gqlFieldOptions, "nullable">;
+type gqlMutationOptions = Omit<gqlFieldOptions, "nullable" | "type"> & {
+    type?: gqlFieldOptionsBase["type"];
+};
+type gqlQueryOptions = Omit<gqlFieldOptions, "nullable">;
 export declare enum CustomFieldType {
     Accessor = "ACCESSOR",
     Field = "FIELD",
@@ -118,24 +129,20 @@ export declare class GQLCapture {
     static getProcessedCustomMutations(): ProcessedCustomField[];
     static getProcessedCustomQueries(): ProcessedCustomField[];
     private static getProcessedCustomFieldsImpl;
-    private static getResultFromMetadata;
-    static gqlField(options?: gqlFieldOptions): any;
+    private static getField;
+    static gqlField(options: gqlFieldOptions): any;
     private static getCustomField;
-    private static argMap;
-    private static argImpl;
-    static gqlArg(name: string, options?: gqlFieldOptions): any;
-    static gqlContextType(): any;
+    static gqlContextType(): gqlFieldArg;
     static gqlArgType(options?: gqlObjectOptions): any;
     static gqlInputObjectType(options?: gqlObjectOptions): any;
     static gqlObjectType(options?: gqlObjectOptions): any;
     private static customGQLObject;
-    static gqlQuery(options?: gqlTopLevelOptions): any;
-    static gqlMutation(options?: gqlTopLevelOptions): any;
+    static gqlQuery(options: gqlQueryOptions): any;
+    static gqlMutation(options: gqlMutationOptions): any;
     static gqlConnection(type: Type): any;
     static resolve(objects: string[]): void;
 }
 export declare const gqlField: typeof GQLCapture.gqlField;
-export declare const gqlArg: typeof GQLCapture.gqlArg;
 export declare const gqlArgType: typeof GQLCapture.gqlArgType;
 export declare const gqlInputObjectType: typeof GQLCapture.gqlInputObjectType;
 export declare const gqlObjectType: typeof GQLCapture.gqlObjectType;