@snowtop/ent 0.1.0-alpha95 → 0.1.0-alpha96

package/action/action.d.ts

@@ -4,8 +4,8 @@ import { Queryer } from "../core/db";
 import { TransformedUpdateOperation, UpdateOperation } from "../schema";
 import { FieldInfoMap } from "../schema/schema";
 export { WriteOperation };
-declare type MaybeNull<T extends Ent> = T | null;
-declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
 interface BuilderOrchestrator {
     __getOptions(): {
         fieldInfo: FieldInfoMap;
@@ -38,7 +38,7 @@ export interface Changeset {
     changesets?: Changeset[];
     dependencies?: Map<ID, Builder<Ent>>;
 }
-export declare type TriggerReturn = void | Promise<Changeset | void | (Changeset | void)[]> | Promise<Changeset>[];
+export type TriggerReturn = void | Promise<Changeset | void | (Changeset | void)[]> | Promise<Changeset>[];
 export interface Trigger<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     changeset(builder: TBuilder, input: TInput): TriggerReturn;
 }

package/action/executor.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeOperations = exports.ComplexExecutor = exports.ListBasedExecutor = void 0;
 const graph_data_structure_1 = __importDefault(require("graph-data-structure"));
+const ent_1 = require("../core/ent");
 const db_1 = __importDefault(require("../core/db"));
 const logger_1 = require("../core/logger");
 // private to ent
@@ -98,7 +99,7 @@ class ComplexExecutor {
             changesetMap.set(c.placeholderID.toString(), c);
             graph.addNode(c.placeholderID.toString());
             if (c.dependencies) {
-                for (let [key, builder] of c.dependencies) {
+                for (let [_, builder] of c.dependencies) {
                     // dependency should go first...
                     graph.addEdge(builder.placeholderID.toString(), c.placeholderID.toString(), 1);
                 }
@@ -258,6 +259,7 @@ async function executeOperations(executor, context, trackOps) {
             });
         }
         else {
+            (0, ent_1.logQuery)("BEGIN", []);
             await client.query("BEGIN");
             for (const operation of executor) {
                 if (trackOps) {
@@ -269,6 +271,7 @@ async function executeOperations(executor, context, trackOps) {
                 }
                 await operation.performWrite(client, context);
             }
+            (0, ent_1.logQuery)("COMMIT", []);
             await client.query("COMMIT");
         }
         if (executor.postFetch) {
@@ -280,6 +283,8 @@ async function executeOperations(executor, context, trackOps) {
     }
     catch (e) {
         if (!isSyncClient(client)) {
+            // TODO these changes break tests
+            (0, ent_1.logQuery)("ROLLBACK", []);
             await client.query("ROLLBACK");
         }
         (0, logger_1.log)("error", e);

package/action/experimental_action.d.ts

@@ -6,8 +6,8 @@ export interface ActionOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer
     input?: TData;
     operation?: WriteOperation;
 }
-declare type MaybeNull<T extends Ent> = T | null;
-declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
 export interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> extends Builder<TEnt, TViewer, TExistingEnt> {
     valid(): Promise<boolean>;
     validX(): Promise<void>;
@@ -29,6 +29,9 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
     getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
     constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>);
     static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>): Builder<TEnt>;
+    /**
+     * @deprecated use Transaction
+     */
     static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput, TEnt>;
     changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;

package/action/experimental_action.js

@@ -4,6 +4,18 @@ exports.getSimpleInsertAction = exports.getSimpleDeleteAction = exports.getSimpl
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
+    getPrivacyPolicy() {
+        return privacy_1.AlwaysAllowPrivacyPolicy;
+    }
+    getTriggers() {
+        return [];
+    }
+    getObservers() {
+        return [];
+    }
+    getValidators() {
+        return [];
+    }
     constructor(viewer, builderCtr, options) {
         this.viewer = viewer;
         this.builderCtr = builderCtr;
@@ -19,24 +31,15 @@ class BaseAction {
         this.input = options?.input || {};
         this.builder = new builderCtr(viewer, operation, this, options.existingEnt);
     }
-    getPrivacyPolicy() {
-        return privacy_1.AlwaysAllowPrivacyPolicy;
-    }
-    getTriggers() {
-        return [];
-    }
-    getObservers() {
-        return [];
-    }
-    getValidators() {
-        return [];
-    }
     static createBuilder(viewer, builderCtr, options) {
         let action = new BaseAction(viewer, builderCtr, options);
         return action.builder;
     }
     // perform a bulk action in a transaction rooted on ent T
     // it ends up creating triggers and having all the given actions performed in a transaction
+    /**
+     * @deprecated use Transaction
+     */
     static bulkAction(ent, builderCtr, ...actions) {
         let action = new BaseAction(ent.viewer, builderCtr, {
             existingEnt: ent,

package/action/index.d.ts

@@ -1,3 +1,5 @@
 export { WriteOperation, Builder, Changeset, Trigger, Observer, Validator, Action, saveBuilder, saveBuilderX, setEdgeTypeInGroup, TriggerReturn, } from "./action";
 export { OrchestratorOptions, Orchestrator, EntChangeset, EdgeInputData, } from "./orchestrator";
 export { DenyIfBuilder, AllowIfBuilder } from "./privacy";
+export { RelativeFieldValue, RelativeNumberValue, NumberOps, convertRelativeInput, maybeConvertRelativeInputPlusExpressions, } from "./relative_value";
+export { Transaction } from "./transaction";

package/action/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AllowIfBuilder = exports.DenyIfBuilder = exports.EntChangeset = exports.Orchestrator = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
+exports.Transaction = exports.maybeConvertRelativeInputPlusExpressions = exports.convertRelativeInput = exports.NumberOps = exports.AllowIfBuilder = exports.DenyIfBuilder = exports.EntChangeset = exports.Orchestrator = exports.setEdgeTypeInGroup = exports.saveBuilderX = exports.saveBuilder = exports.WriteOperation = void 0;
 var action_1 = require("./action");
 Object.defineProperty(exports, "WriteOperation", { enumerable: true, get: function () { return action_1.WriteOperation; } });
 Object.defineProperty(exports, "saveBuilder", { enumerable: true, get: function () { return action_1.saveBuilder; } });
@@ -12,3 +12,9 @@ Object.defineProperty(exports, "EntChangeset", { enumerable: true, get: function
 var privacy_1 = require("./privacy");
 Object.defineProperty(exports, "DenyIfBuilder", { enumerable: true, get: function () { return privacy_1.DenyIfBuilder; } });
 Object.defineProperty(exports, "AllowIfBuilder", { enumerable: true, get: function () { return privacy_1.AllowIfBuilder; } });
+var relative_value_1 = require("./relative_value");
+Object.defineProperty(exports, "NumberOps", { enumerable: true, get: function () { return relative_value_1.NumberOps; } });
+Object.defineProperty(exports, "convertRelativeInput", { enumerable: true, get: function () { return relative_value_1.convertRelativeInput; } });
+Object.defineProperty(exports, "maybeConvertRelativeInputPlusExpressions", { enumerable: true, get: function () { return relative_value_1.maybeConvertRelativeInputPlusExpressions; } });
+var transaction_1 = require("./transaction");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });

package/action/orchestrator.d.ts

@@ -3,8 +3,9 @@ import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
 import { SchemaInputType, FieldInfoMap } from "../schema/schema";
 import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
-declare type MaybeNull<T extends Ent> = T | null;
-declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+import * as clause from "../core/clause";
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
 export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends Data, TViewer extends Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     viewer: Viewer;
     operation: WriteOperation;
@@ -16,6 +17,7 @@ export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends D
     schema: SchemaInputType;
     editedFields(): Map<string, any> | Promise<Map<string, any>>;
     updateInput?: (data: TInput) => void;
+    expressions?: Map<string, clause.Clause>;
     fieldInfo: FieldInfoMap;
 }
 interface edgeInputDataOpts {

package/action/orchestrator.js

@@ -180,6 +180,10 @@ class Orchestrator {
                 if (this.actualOperation === action_1.WriteOperation.Edit && !this.existingEnt) {
                     throw new Error(`existing ent required with operation ${this.actualOperation}`);
                 }
+                if (this.options.expressions &&
+                    this.actualOperation !== action_1.WriteOperation.Edit) {
+                    throw new Error(`expressions are only supported in edit operations for now`);
+                }
                 const opts = {
                     fields: this.validatedFields,
                     tableName: this.options.tableName,
@@ -188,6 +192,7 @@ class Orchestrator {
                     loadEntOptions: this.options.loaderOptions,
                     placeholderID: this.options.builder.placeholderID,
                     whereClause: clause.Eq(this.options.key, this.existingEnt?.id),
+                    expressions: this.options.expressions,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
@@ -713,6 +718,7 @@ class Orchestrator {
         await this.validX();
         let ops = [this.buildMainOp()];
         await this.buildEdgeOps(ops);
+        // TODO throw if we try and create a new changeset after previously creating one
         return new EntChangeset(this.options.viewer, this.options.builder.placeholderID, this.options.loaderOptions.ent, ops, this.dependencies, this.changesets, this.options);
     }
     async viewerForEntLoad(data) {

package/action/relative_value.d.ts

@@ -0,0 +1,47 @@
+import { Clause } from "../core/clause";
+export interface RelativeFieldValue<T = BigInt | number> {
+    delta: T;
+    sqlExpression: (col: string) => Clause;
+    eval: (curr: T) => T;
+}
+export interface RelativeNumberValue<T> {
+    add?: T;
+    subtract?: T;
+    divide?: T;
+    multiply?: T;
+    modulo?: T;
+}
+declare function addNumber(delta: number): RelativeFieldValue<number>;
+declare function addNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function subtractNumber(delta: number): RelativeFieldValue<number>;
+declare function subtractNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function multiplyNumber(delta: number): RelativeFieldValue<number>;
+declare function multiplyNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function divideNumber(delta: number): RelativeFieldValue<number>;
+declare function divideNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+declare function moduloNumber(delta: number): RelativeFieldValue<number>;
+declare function moduloNumber(delta: BigInt): RelativeFieldValue<BigInt>;
+export declare const NumberOps: {
+    addNumber: typeof addNumber;
+    moduloNumber: typeof moduloNumber;
+    divideNumber: typeof divideNumber;
+    subtractNumber: typeof subtractNumber;
+    multiplyNumber: typeof multiplyNumber;
+};
+export declare function convertRelativeInput(rel: RelativeNumberValue<BigInt>, col: string, existing: BigInt): {
+    value: BigInt;
+    clause: Clause;
+};
+export declare function convertRelativeInput(rel: RelativeNumberValue<number>, col: string, existing: number): {
+    value: number;
+    clause: Clause;
+};
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number>, col: string, existing: number, expressions: Map<string, Clause>): number;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number> | undefined, col: string, existing: number, expressions: Map<string, Clause>): number | undefined;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number> | null, col: string, existing: number | null, expressions: Map<string, Clause>): number | null;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: number | RelativeNumberValue<number> | null | undefined, col: string, existing: number | null, expressions: Map<string, Clause>): number | undefined | null;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt>, col: string, existing: BigInt, expressions: Map<string, Clause>): BigInt;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt> | undefined, col: string, existing: BigInt, expressions: Map<string, Clause>): BigInt | undefined;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt> | null, col: string, existing: BigInt | null, expressions: Map<string, Clause>): BigInt | null;
+export declare function maybeConvertRelativeInputPlusExpressions(rel: BigInt | RelativeNumberValue<BigInt> | null | undefined, col: string, existing: BigInt | null, expressions: Map<string, Clause>): BigInt | null | undefined;
+export {};

package/action/relative_value.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeConvertRelativeInputPlusExpressions = exports.convertRelativeInput = exports.NumberOps = void 0;
+const clause_1 = require("../core/clause");
+function addNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Add)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr + delta;
+        },
+    };
+}
+function subtractNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Subtract)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr - delta;
+        },
+    };
+}
+function multiplyNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Multiply)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr * delta;
+        },
+    };
+}
+function divideNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Divide)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr / delta;
+        },
+    };
+}
+function moduloNumber(delta) {
+    return {
+        delta,
+        sqlExpression(col) {
+            return (0, clause_1.Modulo)(col, delta);
+        },
+        eval(curr) {
+            // @ts-expect-error
+            return curr % delta;
+        },
+    };
+}
+exports.NumberOps = {
+    addNumber,
+    moduloNumber,
+    divideNumber,
+    subtractNumber,
+    multiplyNumber,
+};
+function convertRelativeInput(rel, col, existing) {
+    if (Object.keys(rel).length !== 1) {
+        throw new Error(`only 1 key is expected. ${Object.keys(rel).length} given`);
+    }
+    const ret = (relField) => {
+        return {
+            value: relField.eval(existing),
+            clause: relField.sqlExpression(col),
+        };
+    };
+    if (rel.add !== undefined) {
+        // @ts-expect-error
+        return ret(addNumber(rel.add));
+    }
+    if (rel.subtract !== undefined) {
+        // @ts-expect-error
+        return ret(subtractNumber(rel.subtract));
+    }
+    if (rel.multiply !== undefined) {
+        // @ts-expect-error
+        return ret(multiplyNumber(rel.multiply));
+    }
+    if (rel.divide !== undefined) {
+        // @ts-expect-error
+        return ret(divideNumber(rel.divide));
+    }
+    if (rel.modulo !== undefined) {
+        // @ts-expect-error
+        return ret(moduloNumber(rel.modulo));
+    }
+    throw new Error(`error in convertRelativeInput. shouldn't have gotten here`);
+}
+exports.convertRelativeInput = convertRelativeInput;
+function maybeConvertRelativeInputPlusExpressions(rel, col, existing, expressions) {
+    if (rel === null) {
+        return rel;
+    }
+    if (rel === undefined) {
+        return rel;
+    }
+    if (typeof rel === "bigint" || typeof rel === "number") {
+        return rel;
+    }
+    // // TODO is this the behavior we want? should we coalesce as 0?
+    // if (existing === null) {
+    //   throw new Error(`cannot perform a relative operation on null`);
+    // }
+    // @ts-ignore
+    // shouldn't be failing like it currently is. it thinks rel can be bigint  and it shouldn't be???
+    const { clause, value } = convertRelativeInput(rel, col, existing);
+    expressions.set(col, clause);
+    return value;
+}
+exports.maybeConvertRelativeInputPlusExpressions = maybeConvertRelativeInputPlusExpressions;

package/action/transaction.d.ts

@@ -0,0 +1,10 @@
+import { Ent, Viewer } from "../core/base";
+import { Action, Builder } from "./action";
+type ActionAny = Action<Ent<Viewer<any, any>>, Builder<Ent<Viewer<any, any>>, Viewer<any, any>, any>, Viewer<any, any>, any, any>;
+export declare class Transaction {
+    private viewer;
+    private actions;
+    constructor(viewer: Viewer, actions: ActionAny[]);
+    run(): Promise<void>;
+}
+export {};

package/action/transaction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const executor_1 = require("./executor");
+class Transaction {
+    constructor(viewer, 
+    // independent operations
+    actions) {
+        this.viewer = viewer;
+        this.actions = actions;
+    }
+    async run() {
+        const changesets = [];
+        await Promise.all(this.actions.map(async (action) => {
+            const c = await action.changeset();
+            changesets.push(c);
+        }));
+        const executor = new executor_1.ComplexExecutor(this.viewer, "", // no placeholder, no opers
+        [], new Map(), changesets);
+        await executor.execute();
+    }
+}
+exports.Transaction = Transaction;

package/auth/auth.d.ts

@@ -2,7 +2,7 @@
 import { Viewer } from "../core/base";
 import { RequestContext } from "../core/context";
 import { IncomingMessage, ServerResponse } from "http";
-export declare type AuthViewer = Viewer | null;
+export type AuthViewer = Viewer | null;
 export interface AuthHandler {
     authViewer(ctx: RequestContext): AuthViewer | Promise<AuthViewer>;
 }

package/core/base.d.ts

@@ -18,7 +18,7 @@ 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 declare type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause">>;
+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;
@@ -53,6 +53,7 @@ export interface Ent<TViewer extends Viewer = Viewer> {
     viewer: TViewer;
     getPrivacyPolicy(): PrivacyPolicy<this, TViewer>;
     nodeType: string;
+    __setRawDBData<T extends Data = Data>(data: T): any;
 }
 export declare type Data = {
     [key: string]: any;
@@ -60,7 +61,7 @@ export declare type Data = {
 export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewer> {
     new (viewer: TViewer, data: Data): TEnt;
 }
-export declare type ID = string | number;
+export type ID = string | number;
 export interface DataOptions {
     tableName: string;
     context?: Context;
@@ -92,6 +93,7 @@ export interface CreateRowOptions extends DataOptions {
 }
 export interface EditRowOptions extends CreateRowOptions {
     whereClause: clause.Clause;
+    expressions?: Map<string, clause.Clause>;
 }
 interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
     loaderFactory: LoaderFactoryWithOptions;

package/core/clause.d.ts

@@ -117,7 +117,7 @@ export declare function TsVectorWebsearchToTsQuery(col: string, val: string | Ts
 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 = "==" | ">" | "<" | "!=" | ">=" | "<=";
+type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
 export declare function JSONPathValuePredicate(dbCol: string, path: string, val: any, pred: predicate): Clause;
 declare class paginationMultipleColumnsSubQueryClause implements Clause {
     private col;
@@ -134,4 +134,9 @@ declare class paginationMultipleColumnsSubQueryClause implements Clause {
     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 {};

package/core/clause.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
+exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -229,14 +229,14 @@ class postgresArrayOperatorList extends postgresArrayOperator {
     }
 }
 class inClause {
+    static getPostgresInClauseValuesThreshold() {
+        return 70;
+    }
     constructor(col, value, type = "uuid") {
         this.col = col;
         this.value = value;
         this.type = type;
     }
-    static getPostgresInClauseValuesThreshold() {
-        return 70;
-    }
     clause(idx) {
         // do a simple = when only one item
         if (this.value.length === 1) {
@@ -708,3 +708,24 @@ function PaginationMultipleColsSubQuery(col, op, tableName, uniqueCol, val) {
     return new paginationMultipleColumnsSubQueryClause(col, op, tableName, uniqueCol, val);
 }
 exports.PaginationMultipleColsSubQuery = PaginationMultipleColsSubQuery;
+// These 5 are used on the RHS of an expression
+function Add(col, value) {
+    return new simpleClause(col, value, "+", new isNullClause(col));
+}
+exports.Add = Add;
+function Subtract(col, value) {
+    return new simpleClause(col, value, "-", new isNullClause(col));
+}
+exports.Subtract = Subtract;
+function Multiply(col, value) {
+    return new simpleClause(col, value, "*", new isNullClause(col));
+}
+exports.Multiply = Multiply;
+function Divide(col, value) {
+    return new simpleClause(col, value, "/", new isNullClause(col));
+}
+exports.Divide = Divide;
+function Modulo(col, value) {
+    return new simpleClause(col, value, "%", new isNullClause(col));
+}
+exports.Modulo = Modulo;

package/core/config.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Database, DBDict } from "./db";
-declare type logType = "query" | "warn" | "info" | "error" | "debug";
+type logType = "query" | "warn" | "info" | "error" | "debug";
 declare enum graphqlMutationName {
     NOUN_VERB = "NounVerb",
     VERB_NOUN = "VerbNoun"
@@ -19,6 +19,7 @@ export interface Config {
     db?: Database | DBDict;
     log?: logType | logType[];
     codegen?: CodegenConfig;
+    logQueryWithError?: boolean;
     customGraphQLJSONPath?: string;
     globalSchemaPath?: string;
 }

package/core/config.js

@@ -32,6 +32,7 @@ const js_yaml_1 = require("js-yaml");
 const db_1 = __importDefault(require("./db"));
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
+const ent_1 = require("./ent");
 // ent.config.ts eventually. for now ent.yml
 // or ent.yml?
 var graphqlMutationName;
@@ -60,6 +61,7 @@ function setConfig(cfg) {
             db: cfg.db,
         });
     }
+    (0, ent_1.___setLogQueryErrorWithError)(cfg.logQueryWithError);
 }
 function isBuffer(b) {
     return b.write !== undefined;

package/core/date.js

@@ -10,11 +10,7 @@ function parseDate(val, throwErr) {
     else if (typeof val === "string") {
         dt = luxon_1.DateTime.fromISO(val);
         if (!dt.isValid) {
-            let ms = Date.parse(val);
-            if (ms === NaN) {
-                throw throwErr(`invalid input for type Time ${val}`);
-            }
-            dt = luxon_1.DateTime.fromMillis(ms);
+            dt = luxon_1.DateTime.fromMillis(Date.parse(val));
         }
     }
     else if (val instanceof Date) {

package/core/db.d.ts

@@ -7,7 +7,7 @@ export interface Database extends PoolConfig {
     port?: number;
     sslmode?: string;
 }
-export declare type env = "production" | "test" | "development";
+export type env = "production" | "test" | "development";
 export declare type DBDict = Partial<Record<env, Database>>;
 export declare enum Dialect {
     Postgres = "postgres",
@@ -18,6 +18,11 @@ interface DatabaseInfo {
     config: PoolConfig;
     filePath?: string;
 }
+interface clientConfigArgs {
+    connectionString?: string;
+    dbFile?: string;
+    db?: Database | DBDict;
+}
 export default class DB {
     db: DatabaseInfo;
     static instance: DB;
@@ -30,13 +35,10 @@ export default class DB {
     getNewClient(): Promise<Client>;
     getSQLiteClient(): Sqlite;
     endPool(): Promise<void>;
+    emitsExplicitTransactionStatements(): boolean;
     static getInstance(): DB;
     static getDialect(): Dialect;
-    static initDB(args?: {
-        connectionString?: string;
-        dbFile?: string;
-        db?: Database | DBDict;
-    }): void;
+    static initDB(args?: clientConfigArgs): void;
 }
 export declare const defaultTimestampParser: any;
 export interface Queryer {
@@ -53,6 +55,7 @@ export interface Connection extends Queryer {
     self(): Queryer;
     newClient(): Promise<Client>;
     close(): Promise<void>;
+    runInTransaction?(cb: () => void | Promise<void>): any;
 }
 export interface QueryResultRow {
     [column: string]: any;