@snowtop/ent 0.1.0-alpha2 → 0.1.0-alpha20

package/action/orchestrator.js

@@ -1,14 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
 const schema_1 = require("../schema/schema");
 const action_1 = require("../action");
-const snake_case_1 = require("snake-case");
-const camel_case_1 = require("camel-case");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
+const memoizee_1 = __importDefault(require("memoizee"));
 var edgeDirection;
 (function (edgeDirection) {
     edgeDirection[edgeDirection["inboundEdge"] = 0] = "inboundEdge";
@@ -62,6 +64,9 @@ class Orchestrator {
         this.defaultFieldsByFieldName = {};
         this.defaultFieldsByTSName = {};
         this.viewer = options.viewer;
+        this.actualOperation = this.options.operation;
+        this.existingEnt = this.options.builder.existingEnt;
+        this.memoizedGetFields = (0, memoizee_1.default)(this.getFieldsInfo.bind(this));
     }
     addEdge(edge, op) {
         this.edgeSet.add(edge.edgeType);
@@ -80,6 +85,9 @@ class Orchestrator {
         m1.set(op, m2);
         this.edges.set(edge.edgeType, m1);
     }
+    setDisableTransformations(val) {
+        this.disableTransformations = val;
+    }
     addInboundEdge(id1, edgeType, nodeType, options) {
         this.addEdge(new edgeInputData({
             id: id1,
@@ -135,24 +143,27 @@ class Orchestrator {
     }
     buildMainOp() {
         // this assumes we have validated fields
-        switch (this.options.operation) {
+        switch (this.actualOperation) {
             case action_1.WriteOperation.Delete:
-                return new ent_1.DeleteNodeOperation(this.options.builder.existingEnt.id, {
+                return new ent_1.DeleteNodeOperation(this.existingEnt.id, {
                     tableName: this.options.tableName,
                 });
             default:
+                if (this.actualOperation === action_1.WriteOperation.Edit && !this.existingEnt) {
+                    throw new Error(`existing ent required with operation ${this.actualOperation}`);
+                }
                 const opts = {
                     fields: this.validatedFields,
                     tableName: this.options.tableName,
                     fieldsToResolve: this.fieldsToResolve,
                     key: this.options.key,
-                    ent: this.options.loaderOptions.ent,
+                    loadEntOptions: this.options.loaderOptions,
                     placeholderID: this.options.builder.placeholderID,
                 };
                 if (this.logValues) {
                     opts.fieldsToLog = this.logValues;
                 }
-                this.mainOp = new ent_1.EditNodeOperation(opts, this.options.builder.existingEnt);
+                this.mainOp = new ent_1.EditNodeOperation(opts, this.existingEnt);
                 return this.mainOp;
         }
     }
@@ -219,35 +230,82 @@ class Orchestrator {
         if (!privacyPolicy || !action) {
             throw new Error(`shouldn't get here if no privacyPolicy for action`);
         }
-        if (this.options.operation === action_1.WriteOperation.Insert) {
+        if (this.actualOperation === action_1.WriteOperation.Insert) {
             return new EntCannotCreateEntError(privacyPolicy, action);
         }
-        else if (this.options.operation === action_1.WriteOperation.Edit) {
-            return new EntCannotEditEntError(privacyPolicy, action, this.options.builder.existingEnt);
+        else if (this.actualOperation === action_1.WriteOperation.Edit) {
+            return new EntCannotEditEntError(privacyPolicy, action, this.existingEnt);
         }
-        return new EntCannotDeleteEntError(privacyPolicy, action, this.options.builder.existingEnt);
+        return new EntCannotDeleteEntError(privacyPolicy, action, this.existingEnt);
     }
-    getEntForPrivacyPolicy(editedData) {
-        if (this.options.operation !== action_1.WriteOperation.Insert) {
-            return this.options.builder.existingEnt;
+    getEntForPrivacyPolicyImpl(editedData) {
+        if (this.actualOperation !== action_1.WriteOperation.Insert) {
+            return this.existingEnt;
         }
         // we create an unsafe ent to be used for privacy policies
         return new this.options.builder.ent(this.options.builder.viewer, editedData);
     }
+    getSQLStatementOperation() {
+        switch (this.actualOperation) {
+            case action_1.WriteOperation.Edit:
+                return schema_1.SQLStatementOperation.Update;
+            case action_1.WriteOperation.Insert:
+                return schema_1.SQLStatementOperation.Insert;
+            case action_1.WriteOperation.Delete:
+                return schema_1.SQLStatementOperation.Delete;
+        }
+    }
+    getWriteOpForSQLStamentOp(op) {
+        switch (op) {
+            case schema_1.SQLStatementOperation.Update:
+                return action_1.WriteOperation.Edit;
+            case schema_1.SQLStatementOperation.Insert:
+                return action_1.WriteOperation.Insert;
+            case schema_1.SQLStatementOperation.Update:
+                return action_1.WriteOperation.Delete;
+            default:
+                throw new Error("invalid path");
+        }
+    }
+    // if you're doing custom privacy within an action and want to
+    // get either the unsafe ent or the existing ent that's being edited
+    async getPossibleUnsafeEntForPrivacy() {
+        if (this.actualOperation !== action_1.WriteOperation.Insert) {
+            return this.existingEnt;
+        }
+        const { editedData } = await this.memoizedGetFields();
+        return this.getEntForPrivacyPolicyImpl(editedData);
+    }
+    // this gets the fields that were explicitly set plus any default or transformed values
+    // mainly exists to get default fields e.g. default id to be used in triggers
+    // NOTE: this API may change in the future
+    // doesn't work to get ids for autoincrement keys
+    async getEditedData() {
+        const { editedData } = await this.memoizedGetFields();
+        return editedData;
+    }
+    // Note: this is memoized. call memoizedGetFields instead
+    async getFieldsInfo() {
+        const action = this.options.action;
+        const builder = this.options.builder;
+        // future optimization: can get schemaFields to memoize based on different values
+        const schemaFields = (0, schema_1.getFields)(this.options.schema);
+        const editedFields = await this.options.editedFields();
+        let editedData = await this.getFieldsWithDefaultValues(builder, schemaFields, editedFields, action);
+        return { editedData, editedFields, schemaFields };
+    }
     async validate() {
         // existing ent required for edit or delete operations
-        switch (this.options.operation) {
+        switch (this.actualOperation) {
             case action_1.WriteOperation.Delete:
             case action_1.WriteOperation.Edit:
-                if (!this.options.builder.existingEnt) {
-                    throw new Error("existing ent required with operation");
+                if (!this.existingEnt) {
+                    throw new Error(`existing ent required with operation ${this.actualOperation}`);
                 }
         }
+        const { schemaFields, editedData } = await this.memoizedGetFields();
         const action = this.options.action;
         const builder = this.options.builder;
-        // future optimization: can get schemaFields to memoize based on different values
-        const schemaFields = (0, schema_1.getFields)(this.options.schema);
-        let editedData = this.getFieldsWithDefaultValues(builder, schemaFields, action);
         // this runs in following phases:
         // * set default fields and pass to builder so the value can be checked by triggers/observers/validators
         // * privacy policy (use unsafe ent if we have it)
@@ -255,17 +313,22 @@ class Orchestrator {
         // * validators
         let privacyPolicy = action?.getPrivacyPolicy();
         if (privacyPolicy) {
-            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicy(editedData), this.throwError.bind(this));
+            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicyImpl(editedData), this.throwError.bind(this));
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
-        let triggers = action?.triggers;
-        if (triggers) {
-            await this.triggers(action, builder, triggers);
+        if (action?.getTriggers) {
+            await this.triggers(action, builder, action.getTriggers());
         }
-        let validators = action?.validators || [];
+        let validators = [];
+        if (action?.getValidators) {
+            validators = action.getValidators();
+        }
+        // not ideal we're calling this twice. fix...
+        // needed for now. may need to rewrite some of this?
+        const editedFields2 = await this.options.editedFields();
         await Promise.all([
-            this.formatAndValidateFields(schemaFields),
+            this.formatAndValidateFields(schemaFields, editedFields2),
             this.validators(validators, action, builder),
         ]);
     }
@@ -300,18 +363,71 @@ class Orchestrator {
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
-    getFieldsWithDefaultValues(builder, schemaFields, action) {
-        const editedFields = this.options.editedFields();
+    getInputKey(k) {
+        return this.options.fieldInfo[k].inputKey;
+    }
+    getStorageKey(k) {
+        return this.options.fieldInfo[k].dbCol;
+    }
+    async getFieldsWithDefaultValues(builder, schemaFields, editedFields, action) {
         let data = {};
         let defaultData = {};
         let input = action?.getInput() || {};
         let updateInput = false;
+        // transformations
+        // if action transformations. always do it
+        // if disable transformations set, don't do schema transform and just do the right thing
+        // else apply schema tranformation if it exists
+        let transformed = null;
+        if (action?.transformWrite) {
+            transformed = await action.transformWrite({
+                viewer: builder.viewer,
+                op: this.getSQLStatementOperation(),
+                data: editedFields,
+                existingEnt: this.existingEnt,
+            });
+        }
+        else if (!this.disableTransformations) {
+            transformed = (0, schema_1.getTransformedUpdateOp)(this.options.schema, {
+                viewer: builder.viewer,
+                op: this.getSQLStatementOperation(),
+                data: editedFields,
+                existingEnt: this.existingEnt,
+            });
+        }
+        if (transformed) {
+            if (transformed.data) {
+                updateInput = true;
+                for (const k in transformed.data) {
+                    let field = schemaFields.get(k);
+                    if (!field) {
+                        throw new Error(`tried to transform field with unknown field ${k}`);
+                    }
+                    let val = transformed.data[k];
+                    if (field.format) {
+                        val = field.format(transformed.data[k]);
+                    }
+                    data[this.getStorageKey(k)] = val;
+                    this.defaultFieldsByTSName[this.getInputKey(k)] = val;
+                    // hmm do we need this?
+                    // TODO how to do this for local tests?
+                    // this.defaultFieldsByFieldName[k] = val;
+                }
+            }
+            this.actualOperation = this.getWriteOpForSQLStamentOp(transformed.op);
+            if (transformed.existingEnt) {
+                // @ts-ignore
+                this.existingEnt = transformed.existingEnt;
+            }
+        }
+        // transforming before doing default fields so that we don't create a new id
+        // and anything that depends on the type of operations knows what it is
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
             let defaultValue = undefined;
-            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+            let dbKey = this.getStorageKey(fieldName);
             if (value === undefined) {
-                if (this.options.operation === action_1.WriteOperation.Insert) {
+                if (this.actualOperation === action_1.WriteOperation.Insert) {
                     if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
                         throw new Error(`cannot set both defaultToViewerOnCreate and defaultValueOnCreate`);
                     }
@@ -326,7 +442,7 @@ class Orchestrator {
                     }
                 }
                 if (field.defaultValueOnEdit &&
-                    this.options.operation === action_1.WriteOperation.Edit) {
+                    this.actualOperation === action_1.WriteOperation.Edit) {
                     defaultValue = field.defaultValueOnEdit(builder, input);
                 }
             }
@@ -337,8 +453,7 @@ class Orchestrator {
                 updateInput = true;
                 defaultData[dbKey] = defaultValue;
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
-                // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
-                this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
+                this.defaultFieldsByTSName[this.getInputKey(fieldName)] = defaultValue;
             }
         }
         // if there's data changing, add data
@@ -374,13 +489,13 @@ class Orchestrator {
                 // not setting server default as we're depending on the database handling that.
                 // server default allowed
                 field.serverDefault === undefined &&
-                this.options.operation === action_1.WriteOperation.Insert) {
+                this.actualOperation === action_1.WriteOperation.Insert) {
                 throw new Error(`required field ${fieldName} not set`);
             }
         }
         else if (this.isBuilder(value)) {
             if (field.valid) {
-                const valid = await Promise.resolve(field.valid(value));
+                const valid = await field.valid(value);
                 if (!valid) {
                     throw new Error(`invalid field ${fieldName} with value ${value}`);
                 }
@@ -393,24 +508,22 @@ class Orchestrator {
         else {
             if (field.valid) {
                 // TODO this could be async. handle this better
-                const valid = await Promise.resolve(field.valid(value));
+                const valid = await field.valid(value);
                 if (!valid) {
                     throw new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             if (field.format) {
-                // TODO this could be async e.g. password. handle this better
-                value = await Promise.resolve(field.format(value));
+                value = await field.format(value);
             }
         }
         return value;
     }
-    async formatAndValidateFields(schemaFields) {
-        const op = this.options.operation;
+    async formatAndValidateFields(schemaFields, editedFields) {
+        const op = this.actualOperation;
         if (op === action_1.WriteOperation.Delete) {
             return;
         }
-        const editedFields = this.options.editedFields();
         // build up data to be saved...
         let data = {};
         let logValues = {};
@@ -420,7 +533,7 @@ class Orchestrator {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
-            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+            let dbKey = this.getStorageKey(fieldName);
             value = await this.transformFieldValue(fieldName, field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
@@ -433,7 +546,7 @@ class Orchestrator {
             for (const fieldName in this.defaultFieldsByFieldName) {
                 const defaultValue = this.defaultFieldsByFieldName[fieldName];
                 let field = schemaFields.get(fieldName);
-                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+                let dbKey = this.getStorageKey(fieldName);
                 // no value, let's just default
                 if (data[dbKey] === undefined) {
                     const value = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);
@@ -494,7 +607,7 @@ class Orchestrator {
         const viewer = await this.viewerForEntLoad(row);
         const ent = await (0, ent_1.applyPrivacyPolicyForRow)(viewer, this.options.loaderOptions, row);
         if (!ent) {
-            if (this.options.operation == action_1.WriteOperation.Insert) {
+            if (this.actualOperation == action_1.WriteOperation.Insert) {
                 throw new Error(`was able to create ent but not load it`);
             }
             else {

package/action/privacy.d.ts

@@ -2,11 +2,11 @@ import { Builder } from "./action";
 import { Viewer, ID, Ent, PrivacyResult, PrivacyPolicyRule } from "../core/base";
 export declare class DenyIfBuilder implements PrivacyPolicyRule {
     private id?;
-    constructor(id?: ID | Builder<Ent> | undefined);
+    constructor(id?: ID | Builder<Ent<Viewer<Ent<any> | null, ID | null>>, any, Ent<Viewer<Ent<any> | null, ID | null>> | null> | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }
 export declare class AllowIfBuilder implements PrivacyPolicyRule {
     private id?;
-    constructor(id?: ID | Builder<Ent> | undefined);
+    constructor(id?: ID | Builder<Ent<Viewer<Ent<any> | null, ID | null>>, any, Ent<Viewer<Ent<any> | null, ID | null>> | null> | undefined);
     apply(_v: Viewer, _ent: Ent): Promise<PrivacyResult>;
 }

package/core/base.d.ts

@@ -30,27 +30,27 @@ 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;
 }
 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 interface DataOptions {
@@ -62,6 +62,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 {
 }
@@ -83,14 +84,16 @@ export interface CreateRowOptions extends DataOptions {
 export interface EditRowOptions extends CreateRowOptions {
     key: string;
 }
-interface LoadableEntOptions<T extends Ent> {
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
     loaderFactory: LoaderFactory<any, Data | null>;
-    ent: EntConstructor<T>;
+    ent: EntConstructor<TEnt, TViewer>;
 }
-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 LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectBaseDataOptions {
+    ent: EntConstructor<TEnt, TViewer>;
+    fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
 export interface LoaderInfo {
     tableName: string;
@@ -108,6 +111,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 +120,11 @@ 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> {
-    rules: PrivacyPolicyRule<TEnt>[];
+export interface PrivacyPolicy<TEnt extends Ent = Ent, TViewer = Viewer> {
+    rules: PrivacyPolicyRule<TEnt, TViewer>[];
 }
 export {};

package/core/base.js

@@ -30,7 +30,23 @@ 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,

package/core/clause.d.ts

@@ -12,8 +12,10 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    constructor(col: string, value: any, op: string);
+    private handleSqliteNull?;
+    constructor(col: string, value: any, op: string, handleSqliteNull?: Clause | undefined);
     clause(idx: number): string;
+    private sqliteNull;
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -27,14 +29,33 @@ declare class compositeClause implements Clause {
     logValues(): any[];
     instanceKey(): string;
 }
-export declare function Eq(col: string, value: any): simpleClause;
-export declare function NotEq(col: string, value: any): simpleClause;
+export declare function ArrayEq(col: string, value: any): Clause;
+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;
 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 In(col: string, ...values: any): 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 {};