@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/core/ent.d.ts

@@ -1,10 +1,38 @@
 import { Queryer, SyncQueryer } from "./db";
-import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, CreateRowOptions, QueryDataOptions, SelectCustomDataOptions } from "./base";
-import { Executor } from "../action/action";
+import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, CreateRowOptions, QueryDataOptions, SelectCustomDataOptions, LoaderWithLoadMany } from "./base";
 import * as clause from "./clause";
-import { Builder } from "../action";
 import DataLoader from "dataloader";
-import { GlobalSchema } from "../schema/";
+import { OrderBy } from "./query_impl";
+declare class entCacheMap<TViewer extends Viewer, TEnt extends Ent<TViewer>> {
+    private viewer;
+    private options;
+    private m;
+    private logEnabled;
+    constructor(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>);
+    get(id: ID): any;
+    set(key: string, value: any): Map<any, any>;
+    delete(key: string): boolean;
+    clear(): void;
+}
+declare class ErrorWrapper {
+    error: Error;
+    constructor(error: Error);
+}
+export declare function rowIsError(row: any): row is Error;
+declare class EntLoader<TViewer extends Viewer, TEnt extends Ent<TViewer>> implements LoaderWithLoadMany<ID, TEnt | ErrorWrapper | Error> {
+    private viewer;
+    private options;
+    private loader;
+    private map;
+    constructor(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>);
+    getMap(): entCacheMap<TViewer, TEnt>;
+    load(id: ID): Promise<TEnt | ErrorWrapper>;
+    loadMany(ids: ID[]): Promise<Array<TEnt | ErrorWrapper | Error>>;
+    prime(id: ID, ent: TEnt | ErrorWrapper): void;
+    clear(id: ID): void;
+    clearAll(): void;
+}
+export declare function getEntLoader<TViewer extends Viewer, TEnt extends Ent<TViewer>>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>): EntLoader<TViewer, TEnt>;
 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>;
@@ -24,13 +52,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[]>;
-interface parameterizedQueryOptions {
+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 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<T, K>;
 /**
  * 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
@@ -54,11 +82,15 @@ export type CustomQuery = string | parameterizedQueryOptions | clause.Clause | Q
  *   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(options: SelectCustomDataOptions, query: CustomQuery, context: Context | undefined): Promise<Data[]>;
-interface CustomCountOptions extends DataOptions {
-}
-export declare function loadCustomCount(options: CustomCountOptions, query: CustomQuery, context: Context | undefined): Promise<number>;
+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 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,82 +100,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;
+    orderby?: OrderBy;
     limit: number;
 }
-export declare function buildGroupQuery(options: GroupQueryOptions): [string, clause.Clause];
-export interface DataOperation<T extends Ent = Ent> {
-    preFetch?(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    placeholderID?: ID;
-    returnedRow?(): Data | null;
-    createdEnt?(viewer: Viewer): T | null;
-    resolve?(executor: Executor): void;
-    postFetch?(queryer: Queryer, context?: Context): Promise<void>;
-}
-export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
-    fieldsToResolve: string[];
-    loadEntOptions: LoadEntOptions<T>;
-    placeholderID?: ID;
-    key: string;
-}
-export declare class RawQueryOperation implements DataOperation {
-    private queries;
-    constructor(queries: (string | parameterizedQueryOptions)[]);
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-}
-export declare class EditNodeOperation<T extends Ent> implements DataOperation {
-    options: EditNodeOptions<T>;
-    private existingEnt;
-    row: Data | null;
-    placeholderID?: ID | undefined;
-    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
-    resolve<T extends Ent>(executor: Executor): void;
-    private hasData;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    private reloadRow;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    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;
-    private options;
-    private edgeData;
-    private constructor();
-    preFetch(queryer: Queryer, context?: Context): Promise<void>;
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-    private getDeleteRowParams;
-    private performDeleteWrite;
-    private performDeleteWriteSync;
-    private getInsertRowParams;
-    private performInsertWrite;
-    private performInsertWriteSync;
-    private resolveImpl;
-    resolve(executor: Executor): void;
-    symmetricEdge(): EdgeOperation;
-    inverseEdge(edgeData: AssocEdgeData): EdgeOperation;
-    private static resolveIDs;
-    private static isBuilder;
-    private static resolveData;
-    static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID): EdgeOperation;
-    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID): EdgeOperation;
-}
+export declare function buildGroupQuery<T extends Data = Data, K = keyof T>(options: GroupQueryOptions<T, K>): [string, clause.Clause<T, K>];
 export declare function buildInsertQuery(options: CreateRowOptions, suffix?: string): [string, string[], string[]];
 export declare function createRow(queryer: Queryer, options: CreateRowOptions, suffix: string): Promise<Data | null>;
 export declare function createRowSync(queryer: SyncQueryer, options: CreateRowOptions, suffix: string): Data | null;
@@ -152,13 +118,6 @@ export declare function editRow(queryer: Queryer, options: EditRowOptions, suffi
 export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, suffix?: string): Data | null;
 export declare function deleteRows(queryer: Queryer, options: DataOptions, cls: clause.Clause): Promise<void>;
 export declare function deleteRowsSync(queryer: SyncQueryer, options: DataOptions, cls: clause.Clause): void;
-export declare class DeleteNodeOperation implements DataOperation {
-    private id;
-    private options;
-    constructor(id: ID, options: DataOptions);
-    performWrite(queryer: Queryer, context?: Context): Promise<void>;
-    performWriteSync(queryer: SyncQueryer, context?: Context): void;
-}
 export declare class AssocEdge {
     id1: ID;
     id1Type: string;
@@ -179,17 +138,6 @@ interface cursorOptions {
     conv?: (any: any) => any;
 }
 export declare function getCursor(opts: cursorOptions): string;
-export interface AssocEdgeInputOptions {
-    time?: Date;
-    data?: string | Builder<Ent>;
-}
-export interface AssocEdgeInput extends AssocEdgeInputOptions {
-    id1: ID;
-    id1Type: string;
-    edgeType: string;
-    id2: ID;
-    id2Type: string;
-}
 export declare class AssocEdgeData {
     edgeType: string;
     edgeName: string;
@@ -209,15 +157,15 @@ interface loadEdgesOptions {
     edgeType: string;
     context?: Context;
     queryOptions?: EdgeQueryableDataOptions;
-    disableTransformations?: boolean;
 }
 interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
     ctr: AssocEdgeConstructor<T>;
 }
-export declare const DefaultLimit = 1000;
+export declare function setDefaultLimit(limit: number): void;
+export declare function getDefaultLimit(): number;
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
-export declare function getEdgeClauseAndFields(cls: clause.Clause, options: Pick<loadEdgesOptions, "disableTransformations">): {
-    cls: clause.Clause;
+export declare function getEdgeClauseAndFields(cls: clause.Clause, options: Pick<loadEdgesOptions, "queryOptions">): {
+    cls: clause.Clause<Data, string | number>;
     fields: string[];
 };
 export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;