@snowtop/ent 0.1.0-alpha124 → 0.1.0-alpha126

package/core/base.d.ts

@@ -1,5 +1,4 @@
 import * as clause from "./clause";
-import { ObjectLoaderFactory } from "./loaders";
 export interface Loader<K, V> {
     context?: Context;
     load(key: K): Promise<V>;
@@ -96,21 +95,21 @@ export interface EditRowOptions extends CreateRowOptions {
     whereClause: clause.Clause;
     expressions?: Map<string, clause.Clause>;
 }
-interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> {
-    loaderFactory: ObjectLoaderFactory<TData>;
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
+    loaderFactory: LoaderFactoryWithOptions;
     ent: EntConstructor<TEnt, TViewer>;
 }
-export interface LoaderFactoryWithOptions<T extends Data = Data> extends LoaderFactoryWithLoaderMany<any, T | null> {
+export interface LoaderFactoryWithOptions extends LoaderFactoryWithLoaderMany<any, Data | null> {
     options?: SelectDataOptions;
 }
-export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends LoadableEntOptions<TEnt, TViewer, TData>, SelectBaseDataOptions {
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface SelectCustomDataOptions<T extends Data = Data> extends SelectBaseDataOptions {
-    loaderFactory: ObjectLoaderFactory<T>;
+export interface SelectCustomDataOptions extends SelectBaseDataOptions {
+    loaderFactory: LoaderFactoryWithOptions;
     prime?: boolean;
 }
-export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends SelectCustomDataOptions<TData> {
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectCustomDataOptions {
     ent: EntConstructor<TEnt, TViewer>;
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }

package/core/clause.d.ts

@@ -1,4 +1,4 @@
-import { Data, SelectDataOptions } from "./base";
+import { Data } from "./base";
 export interface Clause<T extends Data = Data, K = keyof T> {
     clause(idx: number): string;
     columns(): K[];
@@ -102,5 +102,4 @@ export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any
 export declare function Multiply<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Divide<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
-export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Omit<SelectDataOptions, "key">, cls: Clause<V, K>): Clause<V, K>;
 export {};

package/core/clause.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
+exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -731,20 +731,3 @@ function Modulo(col, value) {
     return new simpleClause(col, value, "%", new isNullClause(col));
 }
 exports.Modulo = Modulo;
-function getCombinedClause(options, cls) {
-    if (options.clause) {
-        let optionClause;
-        if (typeof options.clause === "function") {
-            optionClause = options.clause();
-        }
-        else {
-            optionClause = options.clause;
-        }
-        if (optionClause) {
-            // @ts-expect-error different types
-            cls = And(cls, optionClause);
-        }
-    }
-    return cls;
-}
-exports.getCombinedClause = getCombinedClause;

package/core/ent.d.ts

@@ -4,6 +4,7 @@ import { Executor } from "../action/action";
 import * as clause from "./clause";
 import { Builder } from "../action";
 import DataLoader from "dataloader";
+import { GlobalSchema } from "../schema/";
 export declare function getEntKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): string;
 export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
@@ -23,13 +24,13 @@ export declare function loadEntsList<TEnt extends Ent<TViewer>, TViewer extends
  * @deperecated use loadCustomEnts
  */
 export declare function loadEntsFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, clause: clause.Clause, options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
-export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer, TQueryData extends Data = Data, TResultData extends Data = TQueryData, TKey = keyof TQueryData>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer, TResultData>, query: CustomQuery<TQueryData, TKey>): Promise<TEnt[]>;
+export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer, TQueryData extends Data = Data, TResultData extends Data = TQueryData, TKey = keyof TQueryData>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer>, query: CustomQuery<TQueryData, TKey>): Promise<TEnt[]>;
 interface parameterizedQueryOptions {
     query: string;
     values?: any[];
     logValues?: any[];
 }
-export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameterizedQueryOptions | clause.Clause<T, K> | QueryDataOptions<T, K>;
+export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameterizedQueryOptions | clause.Clause<T, K> | QueryDataOptions;
 /**
  * Note that if there's default read transformations (e.g. soft delete) and a clause is passed in
  * either as Clause or QueryDataOptions without {disableTransformations: true}, the default transformation
@@ -53,15 +54,11 @@ export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameter
  *   orderby: 'time',
  *   disableTransformations: false
  *  }) // doesn't change the query
- *
- * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
- * or parallel queries with the same clause are batched together.
- *
- * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
- * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
  */
-export declare function loadCustomData<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData>(options: SelectCustomDataOptions<TResultData>, query: CustomQuery<TQueryData, K>, context: Context | undefined): Promise<TResultData[]>;
-export declare function loadCustomCount<T extends Data = Data, K = keyof T>(options: SelectCustomDataOptions<T>, query: CustomQuery<T, K>, context: Context | undefined): Promise<number>;
+export declare function loadCustomData<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData>(options: SelectCustomDataOptions, query: CustomQuery<TQueryData, K>, context: Context | undefined): Promise<TResultData[]>;
+interface CustomCountOptions extends DataOptions {
+}
+export declare function loadCustomCount<T extends Data = Data, K = keyof T>(options: CustomCountOptions, query: CustomQuery<T, K>, context: Context | undefined): Promise<number>;
 export declare function loadDerivedEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt | null>;
 export declare function loadDerivedEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt>;
 export declare function logQuery(query: string, logValues: any[]): void;
@@ -117,6 +114,9 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     returnedRow(): Data | null;
     createdEnt(viewer: Viewer): T | null;
 }
+export declare function setGlobalSchema(val: GlobalSchema): void;
+export declare function clearGlobalSchema(): void;
+export declare function __hasGlobalSchema(): boolean;
 export declare class EdgeOperation implements DataOperation {
     private builder;
     edgeInput: AssocEdgeInput;

package/core/ent.js

@@ -26,16 +26,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.RawQueryOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = void 0;
+exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = exports.EditNodeOperation = exports.RawQueryOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
 const action_1 = require("../action");
 const logger_1 = require("./logger");
 const dataloader_1 = __importDefault(require("dataloader"));
-const schema_1 = require("../schema/schema");
-const global_schema_1 = require("./global_schema");
+const schema_1 = require("../schema/");
 // TODO kill this and createDataLoader
 class cacheMap {
     constructor(options) {
@@ -397,12 +396,6 @@ function isParameterizedQuery(opts) {
  *   orderby: 'time',
  *   disableTransformations: false
  *  }) // doesn't change the query
- *
- * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
- * or parallel queries with the same clause are batched together.
- *
- * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
- * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
  */
 async function loadCustomData(options, query, context) {
     const rows = await loadCustomDataImpl(options, query, context);
@@ -421,10 +414,7 @@ exports.loadCustomData = loadCustomData;
 // NOTE: if you use a raw query or paramterized query with this,
 // you should use `SELECT count(*) as count...`
 async function loadCustomCount(options, query, context) {
-    // if clause, we'll use the loader and strong typing/coalescing it provides
-    if (typeof query !== "string" && isClause(query)) {
-        return options.loaderFactory.createCountLoader(context).load(query);
-    }
+    // TODO also need to loaderify this in case we're querying for this a lot...
     const rows = await loadCustomDataImpl({
         ...options,
         fields: ["count(1) as count"],
@@ -439,31 +429,50 @@ function isPrimableLoader(loader) {
     return loader != undefined;
 }
 async function loadCustomDataImpl(options, query, context) {
+    function getClause(cls) {
+        let optClause = options.loaderFactory?.options?.clause;
+        if (typeof optClause === "function") {
+            optClause = optClause();
+        }
+        if (!optClause) {
+            return cls;
+        }
+        // @ts-expect-error string|ID mismatch
+        return clause.And(cls, optClause);
+    }
     if (typeof query === "string") {
         // no caching, perform raw query
         return performRawQuery(query, [], []);
+        // @ts-ignore
     }
     else if (isClause(query)) {
-        const r = await options.loaderFactory
-            .createTypedLoader(context)
-            .load(query);
-        return r;
+        // if a Clause is passed in and we have a default clause
+        // associated with the query, pass that in
+        // if we want to disableTransformations, need to indicate that with
+        // disableTransformations option
+        // this will have rudimentary caching but nothing crazy
+        return loadRows({
+            ...options,
+            // @ts-ignore
+            clause: getClause(query),
+            context: context,
+        });
     }
     else if (isParameterizedQuery(query)) {
         // no caching, perform raw query
         return performRawQuery(query.query, query.values || [], query.logValues);
     }
     else {
-        // this will have rudimentary caching but nothing crazy
         let cls = query.clause;
         if (!query.disableTransformations) {
-            cls = clause.getCombinedClause(options.loaderFactory.options, query.clause);
+            // @ts-ignore
+            cls = getClause(cls);
         }
+        // this will have rudimentary caching but nothing crazy
         return loadRows({
             ...query,
             ...options,
             context: context,
-            // @ts-expect-error
             clause: cls,
         });
     }
@@ -600,7 +609,7 @@ async function performRawQuery(query, values, logValues) {
     catch (e) {
         if (_logQueryWithError) {
             const msg = e.message;
-            throw new Error(`error \`${msg}\` running query: \`${query}\` with values: \`${logValues}\``);
+            throw new Error(`error \`${msg}\` running query: \`${query}\``);
         }
         throw e;
     }
@@ -807,6 +816,20 @@ class EditNodeOperation {
     }
 }
 exports.EditNodeOperation = EditNodeOperation;
+let globalSchema;
+function setGlobalSchema(val) {
+    globalSchema = val;
+}
+exports.setGlobalSchema = setGlobalSchema;
+function clearGlobalSchema() {
+    globalSchema = undefined;
+}
+exports.clearGlobalSchema = clearGlobalSchema;
+// used by tests. no guarantee will always exist
+function __hasGlobalSchema() {
+    return globalSchema !== undefined;
+}
+exports.__hasGlobalSchema = __hasGlobalSchema;
 class EdgeOperation {
     constructor(builder, edgeInput, options) {
         this.builder = builder;
@@ -849,9 +872,8 @@ class EdgeOperation {
         let op = schema_1.SQLStatementOperation.Delete;
         let updateData = null;
         // TODO respect disableTransformations
-        const transformedEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
-        if (transformedEdgeWrite) {
-            transformed = transformedEdgeWrite({
+        if (globalSchema?.transformEdgeWrite) {
+            transformed = globalSchema.transformEdgeWrite({
                 op: schema_1.SQLStatementOperation.Delete,
                 edge,
             });
@@ -929,10 +951,9 @@ class EdgeOperation {
             fields["time"] = new Date().toISOString();
         }
         const onConflictFields = ["data"];
-        const extraEdgeFields = (0, global_schema_1.__getGlobalSchema)()?.extraEdgeFields;
-        if (extraEdgeFields) {
-            for (const name in extraEdgeFields) {
-                const f = extraEdgeFields[name];
+        if (globalSchema?.extraEdgeFields) {
+            for (const name in globalSchema.extraEdgeFields) {
+                const f = globalSchema.extraEdgeFields[name];
                 if (f.defaultValueOnCreate) {
                     const storageKey = (0, schema_1.getStorageKey)(f, name);
                     fields[storageKey] = f.defaultValueOnCreate(this.builder, {});
@@ -944,9 +965,8 @@ class EdgeOperation {
         }
         // TODO respect disableTransformations
         let transformed = null;
-        const transformEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
-        if (transformEdgeWrite) {
-            transformed = transformEdgeWrite({
+        if (globalSchema?.transformEdgeWrite) {
+            transformed = globalSchema.transformEdgeWrite({
                 op: schema_1.SQLStatementOperation.Insert,
                 edge,
             });
@@ -1463,9 +1483,8 @@ async function loadEdges(options) {
 exports.loadEdges = loadEdges;
 function getEdgeClauseAndFields(cls, options) {
     let fields = edgeFields;
-    const transformEdgeRead = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeRead;
-    if (transformEdgeRead) {
-        const transformClause = transformEdgeRead();
+    if (globalSchema?.transformEdgeRead) {
+        const transformClause = globalSchema.transformEdgeRead();
         if (!options.disableTransformations) {
             cls = clause.And(cls, transformClause);
         }

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, "clause" | "limit" | "orderby">> | 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, "limit" | "orderby" | "clause">> | 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/object_loader.d.ts

@@ -1,49 +1,29 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
-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> {
+export declare class ObjectLoader<V = Data> implements Loader<ID, V | null> {
     private options;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
-    private idLoader;
-    private clauseLoader;
+    private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<TResultData>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<V>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
-    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>;
+    load(key: ID): Promise<V | null>;
     clearAll(): void;
-    loadMany(keys: clause.Clause<V, K>[]): Promise<Array<number>>;
+    loadMany(keys: ID[]): Promise<Array<V | null>>;
+    prime(data: V): void;
+    primeAll(data: V): void;
 }
 interface ObjectLoaderOptions extends SelectDataOptions {
     instanceKey?: string;
 }
-export declare class ObjectLoaderFactory<V extends Data = Data> implements LoaderFactory<ID, V | null>, LoaderFactory<clause.Clause<V>, V[] | null> {
+export declare class ObjectLoaderFactory<V = Data> implements LoaderFactory<ID, V | null> {
     options: ObjectLoaderOptions;
     name: string;
     private toPrime;
     constructor(options: ObjectLoaderOptions);
     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 {};