@snowtop/ent 0.1.0-alpha1 → 0.1.0-alpha100

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

@@ -5,19 +5,27 @@ export interface Loader<T, V> {
     loadMany?(keys: T[]): Promise<(V | null)[]>;
     clearAll(): any;
 }
-export interface LoaderFactory<T, V> {
+export interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
+    loadMany(keys: T[]): Promise<V[]>;
+}
+export interface LoaderFactory<K, V> {
     name: string;
-    createLoader(context?: Context): Loader<T, V>;
+    createLoader(context?: Context): Loader<K, V>;
+}
+interface LoaderFactoryWithLoaderMany<T, V> extends LoaderFactory<T, V> {
+    createLoader(context?: Context): LoaderWithLoadMany<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;
 }
 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>;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
@@ -30,29 +38,30 @@ interface queryOptions {
     clause: clause.Clause;
     orderby?: string;
 }
-export interface Context {
-    getViewer(): Viewer;
+export interface Context<TViewer extends Viewer = Viewer> {
+    getViewer(): TViewer;
     cache?: cache;
 }
-export interface Viewer {
-    viewerID: ID | null;
-    viewer: () => Promise<Ent | null>;
+export interface Viewer<TEnt extends any = Ent<any> | null, TID extends any = ID | null> {
+    viewerID: TID;
+    viewer: () => Promise<TEnt>;
     instanceKey: () => string;
-    context?: Context;
+    context?: Context<any>;
 }
-export interface Ent {
+export interface Ent<TViewer extends Viewer = Viewer> {
     id: ID;
-    viewer: Viewer;
-    privacyPolicy: PrivacyPolicy<this>;
+    viewer: TViewer;
+    getPrivacyPolicy(): PrivacyPolicy<this, TViewer>;
     nodeType: string;
+    __setRawDBData<T extends Data = Data>(data: T): any;
 }
 export declare type Data = {
     [key: string]: any;
 };
-export interface EntConstructor<T extends Ent> {
-    new (viewer: Viewer, data: Data): T;
+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;
@@ -62,6 +71,7 @@ export interface SelectBaseDataOptions extends DataOptions {
 }
 export interface SelectDataOptions extends SelectBaseDataOptions {
     key: string;
+    clause?: clause.Clause | (() => clause.Clause | undefined);
 }
 export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
 }
@@ -71,6 +81,7 @@ export interface QueryDataOptions {
     orderby?: string;
     groupby?: string;
     limit?: number;
+    disableTransformations?: boolean;
 }
 export interface LoadRowOptions extends QueryableDataOptions {
 }
@@ -81,16 +92,26 @@ export interface CreateRowOptions extends DataOptions {
     fieldsToLog?: Data;
 }
 export interface EditRowOptions extends CreateRowOptions {
-    key: string;
+    whereClause: clause.Clause;
+    expressions?: Map<string, clause.Clause>;
 }
-interface LoadableEntOptions<T extends Ent> {
-    loaderFactory: LoaderFactory<any, Data | null>;
-    ent: EntConstructor<T>;
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
+    loaderFactory: LoaderFactoryWithOptions;
+    ent: EntConstructor<TEnt, TViewer>;
+}
+export interface LoaderFactoryWithOptions extends LoaderFactoryWithLoaderMany<any, Data | null> {
+    options?: SelectDataOptions;
 }
-export interface LoadEntOptions<T extends Ent> extends LoadableEntOptions<T>, SelectBaseDataOptions {
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoadCustomEntOptions<T extends Ent> extends SelectBaseDataOptions {
-    ent: EntConstructor<T>;
+export interface SelectCustomDataOptions extends SelectBaseDataOptions {
+    loaderFactory: LoaderFactoryWithOptions;
+    prime?: boolean;
+}
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectCustomDataOptions {
+    ent: EntConstructor<TEnt, TViewer>;
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
 export interface LoaderInfo {
     tableName: string;
@@ -108,6 +129,7 @@ declare enum privacyResult {
 export interface PrivacyResult {
     result: privacyResult;
     error?: PrivacyError;
+    getError?(policy: PrivacyPolicy, rule: PrivacyPolicyRule, ent?: Ent): PrivacyError;
 }
 export interface PrivacyError extends Error {
     privacyPolicy: PrivacyPolicy<Ent>;
@@ -116,11 +138,16 @@ export interface PrivacyError extends Error {
 export declare function Allow(): PrivacyResult;
 export declare function Skip(): PrivacyResult;
 export declare function Deny(): PrivacyResult;
-export declare function DenyWithReason(e: PrivacyError): PrivacyResult;
-export interface PrivacyPolicyRule<TEnt extends Ent = Ent> {
-    apply(v: Viewer, ent?: TEnt): Promise<PrivacyResult>;
+export declare function DenyWithReason(e: PrivacyError | string): PrivacyResult;
+export interface PrivacyPolicyRule<TEnt extends Ent = Ent, TViewer = Viewer> {
+    apply(v: TViewer, ent?: TEnt): Promise<PrivacyResult>;
+}
+export interface PrivacyPolicy<TEnt extends Ent = Ent, TViewer = Viewer> {
+    rules: PrivacyPolicyRule<TEnt, TViewer>[];
 }
-export interface PrivacyPolicy<TEnt extends Ent = Ent> {
-    rules: PrivacyPolicyRule<TEnt>[];
+export declare enum WriteOperation {
+    Insert = "insert",
+    Edit = "edit",
+    Delete = "delete"
 }
 export {};

package/core/base.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
+exports.WriteOperation = exports.DenyWithReason = exports.Deny = exports.Skip = exports.Allow = void 0;
 // Privacy
 var privacyResult;
 (function (privacyResult) {
@@ -30,10 +30,32 @@ function Deny() {
     return deny;
 }
 exports.Deny = Deny;
+class DenyWithReasonError extends Error {
+    constructor(privacyPolicy, rule, msg, ent) {
+        super(msg);
+        this.privacyPolicy = privacyPolicy;
+        this.privacyRule = rule;
+        this.ent = ent;
+    }
+}
 function DenyWithReason(e) {
+    if (typeof e === "string") {
+        return {
+            result: privacyResult.Deny,
+            getError(policy, rule, ent) {
+                return new DenyWithReasonError(policy, rule, e, ent);
+            },
+        };
+    }
     return {
         result: privacyResult.Deny,
         error: e,
     };
 }
 exports.DenyWithReason = DenyWithReason;
+var WriteOperation;
+(function (WriteOperation) {
+    WriteOperation["Insert"] = "insert";
+    WriteOperation["Edit"] = "edit";
+    WriteOperation["Delete"] = "delete";
+})(WriteOperation = exports.WriteOperation || (exports.WriteOperation = {}));

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,8 +14,23 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    constructor(col: string, value: any, op: string);
+    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 {
+    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;
@@ -21,20 +38,105 @@ 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;
 }
-export declare function Eq(col: string, value: any): simpleClause;
-export declare function NotEq(col: string, value: any): simpleClause;
+/**
+ * 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 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;
+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 sensitiveValue(val: any): SensitiveValue;
+export declare function JSONObjectFieldKeyASJSON(col: string, field: string): string;
+export declare function JSONObjectFieldKeyAsText(col: string, field: string): string;
+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 {};