@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/core/base.d.ts

@@ -1,8 +1,10 @@
 import * as clause from "./clause";
-export interface Loader<T, V> {
+import { ObjectLoaderFactory } from "./loaders";
+import { OrderBy } from "./query_impl";
+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> {
@@ -18,14 +20,15 @@ interface LoaderFactoryWithLoaderMany<T, V> extends LoaderFactory<T, V> {
 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 type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause" | "disableTransformations">>;
+export type EdgeQueryableDataOptionsConfigureLoader = Pick<EdgeQueryableDataOptions, "disableTransformations">;
+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;
@@ -36,7 +39,7 @@ interface queryOptions {
     fields: string[];
     tableName: string;
     clause: clause.Clause;
-    orderby?: string;
+    orderby?: OrderBy;
 }
 export interface Context<TViewer extends Viewer = Viewer> {
     getViewer(): TViewer;
@@ -71,15 +74,16 @@ export interface SelectBaseDataOptions extends DataOptions {
 }
 export interface SelectDataOptions extends SelectBaseDataOptions {
     key: string;
+    keyType?: string;
     clause?: clause.Clause | (() => clause.Clause | undefined);
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
-export interface QueryDataOptions {
+export interface QueryDataOptions<T extends Data = Data, K = keyof T> {
     distinct?: boolean;
-    clause: clause.Clause;
-    orderby?: string;
-    groupby?: string;
+    clause: clause.Clause<T, K>;
+    orderby?: OrderBy;
+    groupby?: K;
     limit?: number;
     disableTransformations?: boolean;
 }
@@ -87,37 +91,43 @@ export interface LoadRowOptions extends QueryableDataOptions {
 }
 export interface LoadRowsOptions extends QueryableDataOptions {
 }
+interface OnConflictOptions {
+    onConflictCols: string[];
+    onConflictConstraint?: string;
+    updateCols?: string[];
+}
 export interface CreateRowOptions extends DataOptions {
     fields: Data;
     fieldsToLog?: Data;
+    onConflict?: OnConflictOptions;
 }
-export interface EditRowOptions extends CreateRowOptions {
+export interface EditRowOptions extends Omit<CreateRowOptions, "onConflict"> {
     whereClause: clause.Clause;
     expressions?: Map<string, clause.Clause>;
 }
-interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
-    loaderFactory: LoaderFactoryWithOptions;
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> {
+    loaderFactory: ObjectLoaderFactory<TData>;
     ent: EntConstructor<TEnt, TViewer>;
 }
-export interface LoaderFactoryWithOptions extends LoaderFactoryWithLoaderMany<any, Data | null> {
+export interface LoaderFactoryWithOptions<T extends Data = Data> extends LoaderFactoryWithLoaderMany<any, T | null> {
     options?: SelectDataOptions;
 }
-export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends LoadableEntOptions<TEnt, TViewer, TData>, SelectBaseDataOptions {
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface SelectCustomDataOptions extends SelectBaseDataOptions {
-    loaderFactory: LoaderFactoryWithOptions;
+export interface SelectCustomDataOptions<T extends Data = Data> extends SelectBaseDataOptions {
+    loaderFactory: ObjectLoaderFactory<T>;
     prime?: boolean;
 }
-export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectCustomDataOptions {
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends SelectCustomDataOptions<TData> {
     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, ID, SelectDataOptions } 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,133 +11,115 @@ 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 {
+type InClauseOperator = "IN" | "NOT IN";
+export declare class inClause<T extends Data, K = keyof T> implements Clause<T, K> {
     private col;
     private value;
     private type;
+    protected op: InClauseOperator;
     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 {
-    private clauses;
-    private sep;
-    compositeOp: string;
-    constructor(clauses: Clause[], sep: string);
-    clause(idx: number): string;
-    columns(): string[];
-    values(): any[];
-    logValues(): any[];
-    instanceKey(): string;
+export declare class notInClause<T extends Data, K = keyof T> extends inClause<T, K> {
+    protected op: InClauseOperator;
 }
 /**
  * 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;
+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>[]): Clause<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>[]): Clause<T, K>;
+export declare function OrOptional<T extends Data, K = keyof T>(...args: (Clause<T, K> | undefined)[]): Clause<T, K>;
+/**
+ * @deprecated use UUidIn, TextIn, IntegerIn, or TypeIn
+ */
+export declare function In<T extends Data, K = keyof T>(col: K, ...values: any): Clause<T, K>;
+/**
+ * @deprecated use UUidIn, TextIn, IntegerIn, or TypeIn
+ */
+export declare function In<T extends Data, K = keyof T>(col: K, values: any[], type?: string): Clause<T, K>;
+export declare function UuidIn<T extends Data, K = keyof T>(col: K, values: ID[]): Clause<T, K>;
+export declare function IntegerIn<T extends Data, K = keyof T>(col: K, values: number[]): Clause<T, K>;
+export declare function TextIn<T extends Data, K = keyof T>(col: K, values: any[]): Clause<T, K>;
+export declare function DBTypeIn<T extends Data, K = keyof T>(col: K, values: any[], typ: string): Clause<T, K>;
+export declare function UuidNotIn<T extends Data, K = keyof T>(col: K, values: ID[]): Clause<T, K>;
+export declare function IntegerNotIn<T extends Data, K = keyof T>(col: K, values: number[]): Clause<T, K>;
+export declare function TextNotIn<T extends Data, K = keyof T>(col: K, values: any[]): Clause<T, K>;
+export declare function DBTypeNotIn<T extends Data, K = keyof T>(col: K, values: any[], typ: 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): keyof T;
+export declare function JSONObjectFieldKeyAsText<T extends Data, K = keyof T>(col: K, field: string): keyof T;
 type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
-export declare function JSONPathValuePredicate(dbCol: string, path: string, val: any, pred: predicate): Clause;
-declare class paginationMultipleColumnsSubQueryClause implements Clause {
-    private col;
-    private op;
-    private tableName;
-    private uniqueCol;
-    private val;
-    constructor(col: string, op: string, tableName: string, uniqueCol: string, val: any);
-    private buildSimpleQuery;
-    clause(idx: number): string;
-    columns(): string[];
-    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 JSONPathValuePredicate<T extends Data, K = keyof T>(dbCol: K, path: string, val: any, pred: predicate): Clause<T, K>;
+export declare function PaginationMultipleColsSubQuery<T extends Data, K = keyof T>(col: K, op: string, tableName: string, uniqueCol: K, val: any): Clause<T, 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 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.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.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.DBTypeNotIn = exports.TextNotIn = exports.IntegerNotIn = exports.UuidNotIn = exports.DBTypeIn = exports.TextIn = exports.IntegerIn = exports.UuidIn = 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.notInClause = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -94,7 +94,7 @@ class isNullClause {
     constructor(col) {
         this.col = col;
     }
-    clause(idx) {
+    clause(_idx) {
         return `${this.col} IS NULL`;
     }
     columns() {
@@ -236,11 +236,17 @@ class inClause {
         this.col = col;
         this.value = value;
         this.type = type;
+        this.op = "IN";
     }
     clause(idx) {
         // do a simple = when only one item
         if (this.value.length === 1) {
-            return new simpleClause(this.col, this.value[0], "=").clause(idx);
+            if (this.op === "IN") {
+                return new simpleClause(this.col, this.value[0], "=").clause(idx);
+            }
+            else {
+                return new simpleClause(this.col, this.value[0], "!=").clause(idx);
+            }
         }
         const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
         const postgresValuesList = postgres &&
@@ -272,7 +278,7 @@ class inClause {
         if (postgresValuesList) {
             inValue = `VALUES${inValue}`;
         }
-        return `${this.col} IN (${inValue})`;
+        return `${this.col} ${this.op} (${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
@@ -296,10 +302,17 @@ class inClause {
         return result;
     }
     instanceKey() {
-        return `in:${this.col}:${this.values().join(",")}`;
+        return `${this.op.toLowerCase()}:${this.col}:${this.values().join(",")}`;
     }
 }
 exports.inClause = inClause;
+class notInClause extends inClause {
+    constructor() {
+        super(...arguments);
+        this.op = "NOT IN";
+    }
+}
+exports.notInClause = notInClause;
 class compositeClause {
     constructor(clauses, sep) {
         this.clauses = clauses;
@@ -550,6 +563,46 @@ function In(...args) {
     return new inClause(args[0], args.slice(1));
 }
 exports.In = In;
+function UuidIn(col, values) {
+    return new inClause(col, values, "uuid");
+}
+exports.UuidIn = UuidIn;
+function IntegerIn(col, values) {
+    return new inClause(col, values, "integer");
+}
+exports.IntegerIn = IntegerIn;
+function TextIn(col, values) {
+    return new inClause(col, values, "text");
+}
+exports.TextIn = TextIn;
+/*
+ * if not uuid or text, pass the db type that can be used to cast this query
+ * if we end up with a large list of ids
+ */
+function DBTypeIn(col, values, typ) {
+    return new inClause(col, values, typ);
+}
+exports.DBTypeIn = DBTypeIn;
+function UuidNotIn(col, values) {
+    return new notInClause(col, values, "uuid");
+}
+exports.UuidNotIn = UuidNotIn;
+function IntegerNotIn(col, values) {
+    return new notInClause(col, values, "integer");
+}
+exports.IntegerNotIn = IntegerNotIn;
+function TextNotIn(col, values) {
+    return new notInClause(col, values, "text");
+}
+exports.TextNotIn = TextNotIn;
+/*
+ * if not uuid or text, pass the db type that can be used to cast this query
+ * if we end up with a large list of ids
+ */
+function DBTypeNotIn(col, values, typ) {
+    return new notInClause(col, values, typ);
+}
+exports.DBTypeNotIn = DBTypeNotIn;
 // if string defaults to english
 // https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
 // to_tsquery
@@ -623,10 +676,12 @@ exports.sensitiveValue = sensitiveValue;
 // see test in db_clause.test.ts
 // unclear best time to use this...
 function JSONObjectFieldKeyASJSON(col, field) {
+    // type as keyof T to make it easier to use in other queries
     return `${col}->'${field}'`;
 }
 exports.JSONObjectFieldKeyASJSON = JSONObjectFieldKeyASJSON;
 function JSONObjectFieldKeyAsText(col, field) {
+    // type as keyof T to make it easier to use in other queries
     return `${col}->>'${field}'`;
 }
 exports.JSONObjectFieldKeyAsText = JSONObjectFieldKeyAsText;
@@ -729,3 +784,20 @@ 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/config.d.ts

@@ -18,8 +18,11 @@ export interface Config {
     dbFile?: string;
     db?: Database | DBDict;
     log?: logType | logType[];
-    codegen?: CodegenConfig;
     logQueryWithError?: boolean;
+    defaultConnectionLimit?: number;
+}
+export interface ConfigWithCodegen extends Config {
+    codegen?: CodegenConfig;
     customGraphQLJSONPath?: string;
     dynamicScriptCustomGraphQLJSONPath?: string;
     globalSchemaPath?: string;
@@ -41,6 +44,7 @@ interface CodegenConfig {
     templatizedViewer?: importedObject;
     customAssocEdgePath?: importedObject;
     globalImportPath?: string;
+    userOveriddenFiles?: string[];
 }
 interface PrettierConfig {
     custom?: boolean;

package/core/config.js

@@ -62,6 +62,9 @@ function setConfig(cfg) {
         });
     }
     (0, ent_1.___setLogQueryErrorWithError)(cfg.logQueryWithError);
+    if (cfg.defaultConnectionLimit) {
+        (0, ent_1.setDefaultLimit)(cfg.defaultConnectionLimit);
+    }
 }
 function isBuffer(b) {
     return b.write !== undefined;

package/core/const.d.ts

@@ -0,0 +1,3 @@
+export declare const PACKAGE = "@snowtop/ent";
+export declare const GRAPHQL_PATH = "@snowtop/ent/graphql";
+export declare const SCHEMA_PATH = "@snowtop/ent/schema";

package/core/const.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_PATH = exports.GRAPHQL_PATH = exports.PACKAGE = void 0;
+exports.PACKAGE = "@snowtop/ent";
+exports.GRAPHQL_PATH = "@snowtop/ent/graphql";
+exports.SCHEMA_PATH = "@snowtop/ent/schema";

package/core/context.d.ts

@@ -3,6 +3,7 @@ import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
+import { OrderBy } from "./query_impl";
 export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
     authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
@@ -12,8 +13,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;
@@ -27,6 +28,6 @@ interface queryOptions {
     fields: string[];
     tableName: string;
     clause: clause.Clause;
-    orderby?: string;
+    orderby?: OrderBy;
 }
 export {};

package/core/context.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextCache = void 0;
 const logger_1 = require("./logger");
+const query_impl_1 = require("./query_impl");
 class ContextCache {
     constructor() {
         this.loaders = new Map();
@@ -39,7 +40,7 @@ class ContextCache {
             options.clause.instanceKey(),
         ];
         if (options.orderby) {
-            parts.push(options.orderby);
+            parts.push((0, query_impl_1.getOrderByPhrase)(options.orderby));
         }
         return parts.join(",");
     }

package/core/db.d.ts

@@ -22,6 +22,7 @@ interface clientConfigArgs {
     connectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;
+    cfg?: PoolConfig;
 }
 export default class DB {
     db: DatabaseInfo;

package/core/db.js

@@ -46,9 +46,7 @@ function parseConnectionString(str, args) {
             dialect: Dialect.SQLite,
             config: {
                 connectionString: str,
-                // TODO would like to do this for other args e.g. max being set but would have to update tests
-                // e.g. src/core/config.test.ts which tests this
-                // ...args?.db,
+                ...args?.cfg,
             },
             filePath,
         };
@@ -56,10 +54,8 @@ function parseConnectionString(str, args) {
     return {
         dialect: Dialect.Postgres,
         config: {
+            ...args?.cfg,
             connectionString: str,
-            // TODO would like to do this for other args e.g. max being set but would have to update tests
-            // e.g. src/core/config.test.ts which tests this
-            // ...args?.db,
         },
     };
 }
@@ -143,7 +139,9 @@ class DB {
         }
         else {
             let sqlite = require("better-sqlite3");
-            this.q = new Sqlite(sqlite(db.filePath || ""));
+            const dbb = sqlite(db.filePath || "");
+            dbb.pragma("journal_mode = WAL");
+            this.q = new Sqlite(dbb);
         }
     }
     getConnection() {
@@ -242,6 +240,8 @@ class Sqlite {
             r = this.db.prepare(query).get(this.convertValues(values));
         }
         else {
+            // TODO querySync() with no values seems to do the wrong thing...
+            // e.g. querySync('select count(*) as count from table') returns nonsense
             r = this.db.prepare(query).run();
         }
         return {