@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha90

package/core/clause.d.ts

@@ -1,8 +1,10 @@
 export interface Clause {
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
+    compositeOp?: string;
 }
 export interface SensitiveValue {
     value(): any;
@@ -12,10 +14,23 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    private handleSqliteNull?;
-    constructor(col: string, value: any, op: string, handleSqliteNull?: Clause | undefined);
+    private handleNull?;
+    constructor(col: string, value: any, op: string, handleNull?: Clause | undefined);
     clause(idx: number): string;
-    private sqliteNull;
+    private nullClause;
+    columns(): string[];
+    values(): any[];
+    logValues(): any[];
+    instanceKey(): string;
+}
+export declare class inClause implements Clause {
+    private col;
+    private value;
+    private type;
+    static getPostgresInClauseValuesThreshold(): number;
+    constructor(col: string, value: any[], type?: string);
+    clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -23,18 +38,58 @@ declare class simpleClause implements Clause {
 declare class compositeClause implements Clause {
     private clauses;
     private sep;
+    compositeOp: string;
     constructor(clauses: Clause[], sep: string);
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
+/**
+ * creates a clause to determine if the given value is 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 PostgresArrayContainsValue(col: string, value: any): Clause;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 export declare function ArrayEq(col: string, value: any): Clause;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 export declare function ArrayNotEq(col: string, value: any): Clause;
-export declare function ArrayGreater(col: string, value: any): Clause;
-export declare function ArrayLess(col: string, value: any): Clause;
-export declare function ArrayGreaterEq(col: string, value: any): Clause;
-export declare function ArrayLessEq(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;
@@ -44,7 +99,9 @@ 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;
 interface TsQuery {
     language: "english" | "french" | "german" | "simple";
     value: string;
@@ -58,4 +115,8 @@ export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuer
 export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
 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;
+declare type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
+export declare function JSONPathValuePredicate(dbCol: string, path: string, val: any, pred: predicate): Clause;
 export {};

package/core/clause.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayLessEq = exports.ArrayGreaterEq = exports.ArrayLess = exports.ArrayGreater = exports.ArrayNotEq = exports.ArrayEq = void 0;
+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 &&
@@ -33,35 +33,35 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op, handleSqliteNull) {
+    constructor(col, value, op, handleNull) {
         this.col = col;
         this.value = value;
         this.op = op;
-        this.handleSqliteNull = handleSqliteNull;
+        this.handleNull = handleNull;
     }
     clause(idx) {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.clause(idx);
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.clause(idx);
         }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             return `${this.col} ${this.op} $${idx}`;
         }
         return `${this.col} ${this.op} ?`;
     }
-    sqliteNull() {
-        if (!this.handleSqliteNull || this.value !== null) {
+    nullClause() {
+        if (!this.handleNull || this.value !== null) {
             return;
         }
-        if (db_1.default.getDialect() !== db_1.Dialect.SQLite) {
-            return;
-        }
-        return this.handleSqliteNull;
+        return this.handleNull;
+    }
+    columns() {
+        return [this.col];
     }
     values() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.values();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.values();
         }
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -69,9 +69,9 @@ class simpleClause {
         return [this.value];
     }
     logValues() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.logValues();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.logValues();
         }
         if (isSensitive(this.value)) {
             return [this.value.logValue()];
@@ -79,9 +79,9 @@ class simpleClause {
         return [this.value];
     }
     instanceKey() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.instanceKey();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.instanceKey();
         }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
@@ -93,6 +93,9 @@ class isNullClause {
     clause(idx) {
         return `${this.col} IS NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -110,6 +113,9 @@ class isNotNullClause {
     clause(idx) {
         return `${this.col} IS NOT NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -132,6 +138,9 @@ class arraySimpleClause {
         }
         return `${this.col} ${this.op} ?`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -148,18 +157,105 @@ class arraySimpleClause {
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+class postgresArrayOperator {
+    constructor(col, value, op, not) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+        this.not = not;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            if (this.not) {
+                return `NOT ${this.col} ${this.op} $${idx}`;
+            }
+            return `${this.col} ${this.op} $${idx}`;
+        }
+        throw new Error(`not supported`);
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.value()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.logValue()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    instanceKey() {
+        if (this.not) {
+            return `NOT:${this.col}${this.op}${rawValue(this.value)}`;
+        }
+        return `${this.col}${this.op}${rawValue(this.value)}`;
+    }
+}
+class postgresArrayOperatorList extends postgresArrayOperator {
+    constructor(col, value, op, not) {
+        super(col, value, op, not);
+    }
+    values() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.value();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+    logValues() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.logValue();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+}
 class inClause {
-    constructor(col, value) {
+    constructor(col, value, type = "uuid") {
         this.col = col;
         this.value = value;
+        this.type = type;
+    }
+    static getPostgresInClauseValuesThreshold() {
+        return 70;
     }
     clause(idx) {
-        const dialect = db_1.default.getDialect();
+        // do a simple = when only one item
+        if (this.value.length === 1) {
+            return new simpleClause(this.col, this.value[0], "=").clause(idx);
+        }
+        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        const postgresValuesList = postgres &&
+            this.value.length >= inClause.getPostgresInClauseValuesThreshold();
         let indices;
-        if (dialect === db_1.Dialect.Postgres) {
+        if (postgres) {
             indices = [];
             for (let i = 0; i < this.value.length; i++) {
-                indices.push(`$${idx}`);
+                if (postgresValuesList) {
+                    if (i === 0) {
+                        indices.push(`($${idx}::${this.type})`);
+                    }
+                    else {
+                        indices.push(`($${idx})`);
+                    }
+                }
+                else {
+                    indices.push(`$${idx}`);
+                }
                 idx++;
             }
         }
@@ -167,34 +263,31 @@ class inClause {
             indices = new Array(this.value.length);
             indices.fill("?", 0);
         }
-        const inValue = indices.join(", ");
+        let inValue = indices.join(", ");
+        // wrap in VALUES list for postgres...
+        if (postgresValuesList) {
+            inValue = `VALUES${inValue}`;
+        }
         return `${this.col} IN (${inValue})`;
         // TODO we need to return idx at end to query builder...
         // or anything that's doing a composite query so next clause knows where to start
         // or change to a sqlx.Rebind format
         // here's what sqlx does: https://play.golang.org/p/vPzvYqeAcP0
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const result = [];
-        for (const value of this.value) {
-            if (isSensitive(value)) {
-                result.push(value.value());
-            }
-            else {
-                result.push(value);
-            }
+        for (let value of this.value) {
+            result.push(rawValue(value));
         }
         return result;
     }
     logValues() {
         const result = [];
-        for (const value of this.value) {
-            if (isSensitive(value)) {
-                result.push(value.logValue());
-            }
-            else {
-                result.push(value);
-            }
+        for (let value of this.value) {
+            result.push(isSensitive(value) ? value.logValue() : value);
         }
         return result;
     }
@@ -202,19 +295,33 @@ class inClause {
         return `in:${this.col}:${this.values().join(",")}`;
     }
 }
+exports.inClause = inClause;
 class compositeClause {
     constructor(clauses, sep) {
         this.clauses = clauses;
         this.sep = sep;
+        this.compositeOp = this.sep;
     }
     clause(idx) {
         let clauses = [];
         for (const clause of this.clauses) {
-            clauses.push(clause.clause(idx));
+            let cls = clause.clause(idx);
+            // if composite clause and a different op, add parens so that we enforce order of precedence
+            if (clause.compositeOp && clause.compositeOp !== this.sep) {
+                cls = `(${cls})`;
+            }
+            clauses.push(cls);
             idx = idx + clause.values().length;
         }
         return clauses.join(this.sep);
     }
+    columns() {
+        const ret = [];
+        for (const cls of this.clauses) {
+            ret.push(...cls.columns());
+        }
+        return ret;
+    }
     values() {
         let result = [];
         for (const clause of this.clauses) {
@@ -231,7 +338,14 @@ class compositeClause {
     }
     instanceKey() {
         let keys = [];
-        this.clauses.forEach((clause) => keys.push(clause.instanceKey()));
+        this.clauses.forEach((clause) => {
+            if (clause.compositeOp && clause.compositeOp != this.sep) {
+                keys.push(`(${clause.instanceKey()})`);
+            }
+            else {
+                keys.push(clause.instanceKey());
+            }
+        });
         return keys.join(this.sep);
     }
 }
@@ -264,6 +378,9 @@ class tsQueryClause {
         // FYI this doesn't actually work for sqlite since different
         return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const { value } = this.getInfo();
         return [value];
@@ -298,31 +415,76 @@ class websearchTosQueryClause extends tsQueryClause {
         return "websearch_to_tsquery";
     }
 }
-// TODO we need to check sqlite version...
+// postgres array operators
+// https://www.postgresql.org/docs/current/functions-array.html
+/**
+ * creates a clause to determine if the given value is 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
+ */
+function PostgresArrayContainsValue(col, value) {
+    return new postgresArrayOperator(col, value, "@>");
+}
+exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
+/**
+ * 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
+ */
+function PostgresArrayContains(col, value) {
+    return new postgresArrayOperatorList(col, value, "@>");
+}
+exports.PostgresArrayContains = PostgresArrayContains;
+/**
+ * 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
+ */
+function PostgresArrayNotContainsValue(col, value) {
+    return new postgresArrayOperator(col, value, "@>", true);
+}
+exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
+/**
+ * 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
+ */
+function PostgresArrayNotContains(col, value) {
+    return new postgresArrayOperatorList(col, value, "@>", true);
+}
+exports.PostgresArrayNotContains = PostgresArrayNotContains;
+/**
+ * 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
+ */
+function PostgresArrayOverlaps(col, value) {
+    return new postgresArrayOperatorList(col, value, "&&");
+}
+exports.PostgresArrayOverlaps = PostgresArrayOverlaps;
+/**
+ * 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
+ */
+function PostgresArrayNotOverlaps(col, value) {
+    return new postgresArrayOperatorList(col, value, "&&", true);
+}
+exports.PostgresArrayNotOverlaps = PostgresArrayNotOverlaps;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 function ArrayEq(col, value) {
     return new arraySimpleClause(col, value, "=");
 }
 exports.ArrayEq = ArrayEq;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 function ArrayNotEq(col, value) {
     return new arraySimpleClause(col, value, "!=");
 }
 exports.ArrayNotEq = ArrayNotEq;
-function ArrayGreater(col, value) {
-    return new arraySimpleClause(col, value, ">");
-}
-exports.ArrayGreater = ArrayGreater;
-function ArrayLess(col, value) {
-    return new arraySimpleClause(col, value, "<");
-}
-exports.ArrayLess = ArrayLess;
-function ArrayGreaterEq(col, value) {
-    return new arraySimpleClause(col, value, ">=");
-}
-exports.ArrayGreaterEq = ArrayGreaterEq;
-function ArrayLessEq(col, value) {
-    return new arraySimpleClause(col, value, "<=");
-}
-exports.ArrayLessEq = ArrayLessEq;
 function Eq(col, value) {
     return new simpleClause(col, value, "=", new isNullClause(col));
 }
@@ -364,9 +526,24 @@ function Or(...args) {
     return new compositeClause(args, " OR ");
 }
 exports.Or = Or;
-// TODO this breaks if values.length ===1 and array. todo fix
-function In(col, ...values) {
-    return new inClause(col, values);
+function OrOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return Or(...filtered);
+}
+exports.OrOptional = OrOptional;
+function In(...args) {
+    if (args.length < 2) {
+        throw new Error(`invalid args passed to In`);
+    }
+    // 2nd overload
+    if (Array.isArray(args[1])) {
+        return new inClause(args[0], args[1], args[2]);
+    }
+    return new inClause(args[0], args.slice(1));
 }
 exports.In = In;
 // if string defaults to english
@@ -437,3 +614,55 @@ function sensitiveValue(val) {
     };
 }
 exports.sensitiveValue = sensitiveValue;
+// These don't return Clauses but return helpful things that can be passed to clauses
+// https://www.postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSON-OP-TABLE
+// see test in db_clause.test.ts
+// unclear best time to use this...
+function JSONObjectFieldKeyASJSON(col, field) {
+    return `${col}->'${field}'`;
+}
+exports.JSONObjectFieldKeyASJSON = JSONObjectFieldKeyASJSON;
+function JSONObjectFieldKeyAsText(col, field) {
+    return `${col}->>'${field}'`;
+}
+exports.JSONObjectFieldKeyAsText = JSONObjectFieldKeyAsText;
+class jSONPathValuePredicateClause {
+    constructor(col, path, value, pred) {
+        this.col = col;
+        this.path = path;
+        this.value = value;
+        this.pred = pred;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() !== db_1.Dialect.Postgres) {
+            throw new Error(`not supported`);
+        }
+        return `${this.col} @@ $${idx}`;
+    }
+    columns() {
+        return [this.col];
+    }
+    wrap(val) {
+        return `${this.path} ${this.pred} ${JSON.stringify(val)}`;
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [this.wrap(this.value.value())];
+        }
+        return [this.wrap(this.value)];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [this.wrap(this.value.logValue())];
+        }
+        return [this.wrap(this.value)];
+    }
+    instanceKey() {
+        return `${this.col}${this.path}${rawValue(this.value)}${this.pred}`;
+    }
+}
+// https://www.postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSON-OP-TABLE
+function JSONPathValuePredicate(dbCol, path, val, pred) {
+    return new jSONPathValuePredicateClause(dbCol, path, val, pred);
+}
+exports.JSONPathValuePredicate = JSONPathValuePredicate;

package/core/config.d.ts

@@ -20,6 +20,7 @@ export interface Config {
     log?: logType | logType[];
     codegen?: CodegenConfig;
     customGraphQLJSONPath?: string;
+    globalSchemaPath?: string;
 }
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
@@ -35,6 +36,8 @@ interface CodegenConfig {
     schemaSQLFilePath?: boolean;
     databaseToCompareTo?: string;
     fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
+    templatizedViewer?: importedObject;
+    customAssocEdgePath?: importedObject;
 }
 interface PrettierConfig {
     custom?: boolean;
@@ -45,5 +48,10 @@ interface PrivacyConfig {
     policyName: string;
     class?: boolean;
 }
+interface importedObject {
+    path: string;
+    name: string;
+    alias?: string;
+}
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};

package/core/context.d.ts

@@ -1,17 +1,19 @@
 /// <reference types="node" />
-import { Viewer, Data, Loader } from "./base";
+import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
-export interface RequestContext extends Context {
-    authViewer(viewer: Viewer): Promise<void>;
+export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
+    authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
     request: IncomingMessage;
     response: ServerResponse;
 }
 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>;
     private itemMap;
     private listMap;
     private getkey;