@snowtop/ent 0.1.0-alpha115 → 0.1.0-alpha117

package/core/base.d.ts

@@ -1,8 +1,8 @@
 import * as clause from "./clause";
-export interface Loader<T, V> {
+export interface Loader<K, V> {
     context?: Context;
-    load(key: T): Promise<V>;
-    loadMany?(keys: T[]): Promise<(V | null)[]>;
+    load(key: K): Promise<V>;
+    loadMany?(keys: K[]): Promise<(V | null)[]>;
     clearAll(): any;
 }
 export interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
@@ -19,13 +19,13 @@ export interface ConfigurableLoaderFactory<T, V> extends LoaderFactory<T, V> {
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<T, V>;
 }
 export type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause">>;
-export interface PrimableLoader<T, V> extends Loader<T, V> {
-    prime(d: Data): void;
-    primeAll?(d: Data): void;
+export interface PrimableLoader<K, V> extends Loader<K, V> {
+    prime(d: V): void;
+    primeAll?(d: V): void;
 }
 interface cache {
-    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
-    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
+    getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
+    getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
@@ -75,11 +75,11 @@ export interface SelectDataOptions extends SelectBaseDataOptions {
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
-export interface QueryDataOptions {
+export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;
-    clause: clause.Clause;
+    clause: clause.Clause<T, K>;
     orderby?: string;
-    groupby?: string;
+    groupby?: K;
     limit?: number;
     disableTransformations?: boolean;
 }
@@ -113,11 +113,11 @@ export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer =
     ent: EntConstructor<TEnt, TViewer>;
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoaderInfo {
+export interface LoaderInfo<T = Data> {
     tableName: string;
     fields: string[];
     nodeType: string;
-    loaderFactory: LoaderFactory<any, Data | null>;
+    loaderFactory: LoaderFactory<ID, T | null>;
 }
 export interface EditEntOptions<T extends Ent> extends LoadableEntOptions<T>, EditRowOptions {
 }

package/core/clause.d.ts

@@ -1,6 +1,7 @@
-export interface Clause {
+import { Data } from "./base";
+export interface Clause<T extends Data = Data, K = keyof T> {
     clause(idx: number): string;
-    columns(): string[];
+    columns(): K[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
@@ -10,38 +11,25 @@ export interface SensitiveValue {
     value(): any;
     logValue(): any;
 }
-declare class simpleClause implements Clause {
-    protected col: string;
-    private value;
-    private op;
-    private handleNull?;
-    constructor(col: string, value: any, op: string, handleNull?: Clause | undefined);
-    clause(idx: number): string;
-    private nullClause;
-    columns(): string[];
-    values(): any[];
-    logValues(): any[];
-    instanceKey(): string;
-}
-export declare class inClause implements Clause {
+export declare class inClause<T extends Data, K = keyof T> implements Clause<T, K> {
     private col;
     private value;
     private type;
     static getPostgresInClauseValuesThreshold(): number;
-    constructor(col: string, value: any[], type?: string);
+    constructor(col: K, value: any[], type?: string);
     clause(idx: number): string;
-    columns(): string[];
+    columns(): K[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
-declare class compositeClause implements Clause {
+declare class compositeClause<T extends Data, K = keyof T> implements Clause<T, K> {
     private clauses;
     private sep;
     compositeOp: string;
-    constructor(clauses: Clause[], sep: string);
+    constructor(clauses: Clause<T, K>[], sep: string);
     clause(idx: number): string;
-    columns(): string[];
+    columns(): K[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -51,92 +39,92 @@ declare class compositeClause implements Clause {
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayContainsValue(col: string, value: any): Clause;
+export declare function PostgresArrayContainsValue<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 /**
  * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayContains(col: string, value: any[]): Clause;
+export declare function PostgresArrayContains<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
 /**
  * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayNotContainsValue(col: string, value: any): Clause;
+export declare function PostgresArrayNotContainsValue<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 /**
  * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayNotContains(col: string, value: any[]): Clause;
+export declare function PostgresArrayNotContains<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
 /**
  * creates a clause to determine if the arrays overlap, that is, do they have any elements in common
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayOverlaps(col: string, value: any[]): Clause;
+export declare function PostgresArrayOverlaps<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
 /**
  * creates a clause to determine if the arrays do not overlap, that is, do they have any elements in common
  * only works with postgres gin indexes
  * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
  */
-export declare function PostgresArrayNotOverlaps(col: string, value: any[]): Clause;
+export declare function PostgresArrayNotOverlaps<T extends Data, K = keyof T>(col: K, value: any[]): Clause<T, K>;
 /**
  * @deprecated use PostgresArrayContainsValue
  */
-export declare function ArrayEq(col: string, value: any): Clause;
+export declare function ArrayEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 /**
  * @deprecated use PostgresNotArrayContains
  */
-export declare function ArrayNotEq(col: string, value: any): Clause;
-export declare function Eq(col: string, value: any): Clause;
-export declare function NotEq(col: string, value: any): Clause;
-export declare function Greater(col: string, value: any): simpleClause;
-export declare function Less(col: string, value: any): simpleClause;
-export declare function GreaterEq(col: string, value: any): simpleClause;
-export declare function LessEq(col: string, value: any): simpleClause;
-export declare function And(...args: Clause[]): compositeClause;
-export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
-export declare function Or(...args: Clause[]): compositeClause;
-export declare function OrOptional(...args: (Clause | undefined)[]): Clause;
-export declare function In(col: string, ...values: any): Clause;
-export declare function In(col: string, values: any[], type?: string): Clause;
+export declare function ArrayNotEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Eq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function NotEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Greater<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Less<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function GreaterEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function LessEq<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function And<T extends Data, K = keyof T>(...args: Clause<T, K>[]): compositeClause<T, K>;
+export declare function AndOptional<T extends Data, K = keyof T>(...args: (Clause<T, K> | undefined)[]): Clause<T, K>;
+export declare function Or<T extends Data, K = keyof T>(...args: Clause<T, K>[]): compositeClause<T, K>;
+export declare function OrOptional<T extends Data, K = keyof T>(...args: (Clause<T, K> | undefined)[]): Clause<T, K>;
+export declare function In<T extends Data, K = keyof T>(col: K, ...values: any): Clause<T, K>;
+export declare function In<T extends Data, K = keyof T>(col: K, values: any[], type?: string): Clause<T, K>;
 interface TsQuery {
     language: "english" | "french" | "german" | "simple";
     value: string;
 }
-export declare function TsQuery(col: string, val: string | TsQuery): Clause;
-export declare function PlainToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function PhraseToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function WebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorColTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
-export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function PlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function PhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function WebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorColTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorPlainToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorPhraseToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
+export declare function TsVectorWebsearchToTsQuery<T extends Data, K = keyof T>(col: K, val: string | TsQuery): Clause<T, K>;
 export declare function sensitiveValue(val: any): SensitiveValue;
-export declare function JSONObjectFieldKeyASJSON(col: string, field: string): string;
-export declare function JSONObjectFieldKeyAsText(col: string, field: string): string;
+export declare function JSONObjectFieldKeyASJSON<T extends Data, K = keyof T>(col: K, field: string): string;
+export declare function JSONObjectFieldKeyAsText<T extends Data, K = keyof T>(col: K, field: string): string;
 type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
-export declare function JSONPathValuePredicate(dbCol: string, path: string, val: any, pred: predicate): Clause;
-declare class paginationMultipleColumnsSubQueryClause implements Clause {
+export declare function JSONPathValuePredicate<T extends Data, K = keyof T>(dbCol: K, path: string, val: any, pred: predicate): Clause<T, K>;
+declare class paginationMultipleColumnsSubQueryClause<T extends Data, K = keyof T> implements Clause<T, K> {
     private col;
     private op;
     private tableName;
     private uniqueCol;
     private val;
-    constructor(col: string, op: string, tableName: string, uniqueCol: string, val: any);
+    constructor(col: K, op: string, tableName: string, uniqueCol: K, val: any);
     private buildSimpleQuery;
     clause(idx: number): string;
-    columns(): string[];
+    columns(): K[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
-export declare function PaginationMultipleColsSubQuery(col: string, op: string, tableName: string, uniqueCol: string, val: any): paginationMultipleColumnsSubQueryClause;
-export declare function Add(col: string, value: any): Clause;
-export declare function Subtract(col: string, value: any): Clause;
-export declare function Multiply(col: string, value: any): Clause;
-export declare function Divide(col: string, value: any): Clause;
-export declare function Modulo(col: string, value: any): Clause;
+export declare function PaginationMultipleColsSubQuery<T extends Data, K = keyof T>(col: K, op: string, tableName: string, uniqueCol: K, val: any): paginationMultipleColumnsSubQueryClause<Data, K>;
+export declare function Add<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+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 {};

package/core/clause.js

@@ -94,7 +94,7 @@ class isNullClause {
     constructor(col) {
         this.col = col;
     }
-    clause(idx) {
+    clause(_idx) {
         return `${this.col} IS NULL`;
     }
     columns() {

package/core/context.d.ts

@@ -12,8 +12,8 @@ export interface RequestContext<TViewer extends Viewer = Viewer> extends Context
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
     loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
-    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
-    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
+    getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
+    getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     private itemMap;
     private listMap;
     private getkey;

package/core/ent.d.ts

@@ -24,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>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer>, query: CustomQuery): 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 = string | parameterizedQueryOptions | clause.Clause | QueryDataOptions;
+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
@@ -55,10 +55,10 @@ export type CustomQuery = string | parameterizedQueryOptions | clause.Clause | Q
  *   disableTransformations: false
  *  }) // doesn't change the query
  */
-export declare function loadCustomData(options: SelectCustomDataOptions, query: CustomQuery, context: Context | undefined): Promise<Data[]>;
+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(options: CustomCountOptions, query: CustomQuery, context: Context | undefined): Promise<number>;
+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;
@@ -68,16 +68,16 @@ export declare function ___setLogQueryErrorWithError(val: boolean | undefined):
 export declare function performRawQuery(query: string, values: any[], logValues?: any[]): Promise<Data[]>;
 export declare function loadRows(options: LoadRowsOptions): Promise<Data[]>;
 export declare function buildQuery(options: QueryableDataOptions): string;
-interface GroupQueryOptions {
+interface GroupQueryOptions<T extends Data, K = keyof T> {
     tableName: string;
-    clause?: clause.Clause;
-    groupColumn: string;
-    fields: string[];
+    clause?: clause.Clause<T, K>;
+    groupColumn: K;
+    fields: K[];
     values: any[];
     orderby?: string;
     limit: number;
 }
-export declare function buildGroupQuery(options: GroupQueryOptions): [string, clause.Clause];
+export declare function buildGroupQuery<T extends Data = Data, K = keyof T>(options: GroupQueryOptions<T, K>): [string, clause.Clause<T, K>];
 export interface DataOperation<T extends Ent = Ent> {
     preFetch?(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
@@ -217,7 +217,7 @@ interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
 export declare const DefaultLimit = 1000;
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
 export declare function getEdgeClauseAndFields(cls: clause.Clause, options: Pick<loadEdgesOptions, "disableTransformations">): {
-    cls: clause.Clause;
+    cls: clause.Clause<Data, string | number>;
     fields: string[];
 };
 export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;

package/core/ent.js

@@ -437,11 +437,13 @@ async function loadCustomDataImpl(options, query, context) {
         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)) {
         // if a Clause is passed in and we have a default clause
@@ -451,6 +453,7 @@ async function loadCustomDataImpl(options, query, context) {
         // this will have rudimentary caching but nothing crazy
         return loadRows({
             ...options,
+            // @ts-ignore
             clause: getClause(query),
             context: context,
         });
@@ -462,6 +465,7 @@ async function loadCustomDataImpl(options, query, context) {
     else {
         let cls = query.clause;
         if (!query.disableTransformations) {
+            // @ts-ignore
             cls = getClause(cls);
         }
         // this will have rudimentary caching but nothing crazy
@@ -762,6 +766,7 @@ class EditNodeOperation {
                 optionClause = opts.clause;
             }
             if (optionClause) {
+                // @ts-expect-error ID|string mismatch
                 cls = clause.And(cls, optionClause);
             }
         }

package/core/loaders/index_loader.d.ts

@@ -7,7 +7,7 @@ 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): 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/object_loader.d.ts

@@ -1,29 +1,29 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
-export declare class ObjectLoader<T> implements Loader<T, Data | 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 loader;
     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<V>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
-    load(key: T): Promise<Data | null>;
+    load(key: ID): Promise<V | null>;
     clearAll(): void;
-    loadMany(keys: T[]): Promise<Array<Data | null>>;
-    prime(data: Data): void;
-    primeAll(data: Data): void;
+    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<T> implements LoaderFactory<T, Data | 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<T>;
-    addToPrime(factory: ObjectLoaderFactory<T>): this;
+    createLoader(context?: Context): ObjectLoader<V>;
+    addToPrime(factory: ObjectLoaderFactory<V>): this;
 }
 export {};

package/core/loaders/object_loader.js

@@ -45,6 +45,7 @@ async function loadRowsForLoader(options, ids, context) {
             optionClause = options.clause;
         }
         if (optionClause) {
+            // @ts-expect-error id/string mismatch
             cls = clause.And(cls, optionClause);
         }
     }
@@ -60,7 +61,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) {
@@ -162,7 +163,8 @@ class ObjectLoader {
     }
     async loadMany(keys) {
         if (this.loader) {
-            return await this.loader.loadMany(keys);
+            // @ts-expect-error TODO?
+            return this.loader.loadMany(keys);
         }
         return loadRowsForLoader(this.options, keys, this.context);
     }

package/core/loaders/query_loader.d.ts

@@ -19,7 +19,7 @@ interface QueryOptions {
     groupCol?: string;
     clause?: clause.Clause;
     sortColumn?: string;
-    toPrime?: ObjectLoaderFactory<ID>[];
+    toPrime?: ObjectLoaderFactory<Data>[];
 }
 export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<K, Data[]> {
     private options;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha115",
+  "version": "0.1.0-alpha117",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/testutils/fake_data/fake_contact.d.ts

@@ -34,4 +34,4 @@ export interface ContactCreateInput {
 }
 export declare function getContactBuilder(viewer: Viewer, input: ContactCreateInput): SimpleBuilder<FakeContact, null>;
 export declare function createContact(viewer: Viewer, input: ContactCreateInput): Promise<void>;
-export declare const contactLoader: ObjectLoaderFactory<unknown>;
+export declare const contactLoader: ObjectLoaderFactory<Data>;

package/testutils/fake_data/fake_tag.d.ts

@@ -33,4 +33,4 @@ export type TagEditInput = Partial<TagCreateInput>;
 export declare function getTagBuilder(viewer: Viewer, input: TagCreateInput): import("../builder").SimpleBuilder<FakeTag, null>;
 export declare function getTagAction(viewer: Viewer, input: TagCreateInput): SimpleAction<FakeTag, null>;
 export declare function createTag(viewer: Viewer, input: TagCreateInput): Promise<FakeTag>;
-export declare const tagLoader: ObjectLoaderFactory<unknown>;
+export declare const tagLoader: ObjectLoaderFactory<Data>;

package/testutils/fake_data/fake_user.d.ts

@@ -46,7 +46,7 @@ export type UserEditInput = Partial<UserCreateInput>;
 export declare function getUserBuilder(viewer: Viewer, input: UserCreateInput): import("../builder").SimpleBuilder<FakeUser, null>;
 export declare function getUserAction(viewer: Viewer, input: UserCreateInput): SimpleAction<FakeUser, null>;
 export declare function createUser(viewer: Viewer, input: UserCreateInput): Promise<FakeUser>;
-export declare const userLoader: ObjectLoaderFactory<unknown>;
-export declare const userEmailLoader: ObjectLoaderFactory<unknown>;
-export declare const userPhoneNumberLoader: ObjectLoaderFactory<unknown>;
+export declare const userLoader: ObjectLoaderFactory<Data>;
+export declare const userEmailLoader: ObjectLoaderFactory<Data>;
+export declare const userPhoneNumberLoader: ObjectLoaderFactory<Data>;
 export {};