@snowtop/ent 0.1.0-alpha31 → 0.1.0-alpha40

package/action/action.d.ts

@@ -49,11 +49,11 @@ export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt
     changeset(): Promise<Changeset>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-    getTriggers?(): Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getTriggers?(): (Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt> | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[])[];
     getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
     getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
     getInput(): TInput;
-    transformWrite?: (stmt: UpdateOperation<TEnt>) => Promise<TransformedUpdateOperation<TEnt>> | TransformedUpdateOperation<TEnt> | null;
+    transformWrite?: (stmt: UpdateOperation<TEnt, TViewer>) => Promise<TransformedUpdateOperation<TEnt>> | TransformedUpdateOperation<TEnt> | null;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     viewerForEntLoad?(data: Data): TViewer | Promise<TViewer>;

package/action/orchestrator.js

@@ -333,22 +333,46 @@ class Orchestrator {
         ]);
     }
     async triggers(action, builder, triggers) {
-        await Promise.all(triggers.map(async (trigger) => {
-            let ret = await trigger.changeset(builder, action.getInput());
-            if (Array.isArray(ret)) {
-                ret = await Promise.all(ret);
-            }
-            if (Array.isArray(ret)) {
-                for (const v of ret) {
-                    if (typeof v === "object") {
-                        this.changesets.push(v);
-                    }
+        let groups = [];
+        let lastArray = 0;
+        let prevWasArray = false;
+        for (let i = 0; i < triggers.length; i++) {
+            let t = triggers[i];
+            if (Array.isArray(t)) {
+                if (!prevWasArray) {
+                    // @ts-ignore
+                    groups.push(triggers.slice(lastArray, i));
                 }
+                groups.push(t);
+                prevWasArray = true;
+                lastArray++;
             }
-            else if (ret) {
-                this.changesets.push(ret);
+            else {
+                if (i === triggers.length - 1) {
+                    // @ts-ignore
+                    groups.push(triggers.slice(lastArray, i + 1));
+                }
+                prevWasArray = false;
             }
-        }));
+        }
+        for (const triggers of groups) {
+            await Promise.all(triggers.map(async (trigger) => {
+                let ret = await trigger.changeset(builder, action.getInput());
+                if (Array.isArray(ret)) {
+                    ret = await Promise.all(ret);
+                }
+                if (Array.isArray(ret)) {
+                    for (const v of ret) {
+                        if (typeof v === "object") {
+                            this.changesets.push(v);
+                        }
+                    }
+                }
+                else if (ret) {
+                    this.changesets.push(ret);
+                }
+            }));
+        }
     }
     async validators(validators, action, builder) {
         let promises = [];
@@ -379,23 +403,29 @@ class Orchestrator {
         // 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;
+        const sqlOp = this.getSQLStatementOperation();
         if (action?.transformWrite) {
             transformed = await action.transformWrite({
-                viewer: builder.viewer,
-                op: this.getSQLStatementOperation(),
+                builder,
+                input,
+                op: sqlOp,
                 data: editedFields,
-                existingEnt: this.existingEnt,
             });
         }
         else if (!this.disableTransformations) {
             transformed = (0, schema_1.getTransformedUpdateOp)(this.options.schema, {
-                viewer: builder.viewer,
-                op: this.getSQLStatementOperation(),
+                builder,
+                input,
+                op: sqlOp,
                 data: editedFields,
-                existingEnt: this.existingEnt,
             });
         }
         if (transformed) {
+            if (sqlOp === schema_1.SQLStatementOperation.Insert && sqlOp !== transformed.op) {
+                if (!transformed.existingEnt) {
+                    throw new Error(`cannot transform an insert operation without providing an existing ent`);
+                }
+            }
             if (transformed.data) {
                 updateInput = true;
                 for (const k in transformed.data) {
@@ -418,6 +448,8 @@ class Orchestrator {
             if (transformed.existingEnt) {
                 // @ts-ignore
                 this.existingEnt = transformed.existingEnt;
+                // modify existing ent in builder. it's readonly in generated ents but doesn't apply here
+                builder.existingEnt = transformed.existingEnt;
             }
         }
         // transforming before doing default fields so that we don't create a new id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha31",
+  "version": "0.1.0-alpha40",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/schema.d.ts

@@ -82,10 +82,10 @@ export declare enum SQLStatementOperation {
     Update = "update",
     Delete = "delete"
 }
-export interface UpdateOperation<T extends Ent> {
+export interface UpdateOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     op: SQLStatementOperation;
-    existingEnt: T | null;
-    viewer: Viewer;
+    builder: Builder<TEnt, TViewer>;
+    input: Data;
     data?: Map<string, any>;
 }
 export interface TransformedUpdateOperation<T extends Ent> {
@@ -204,7 +204,7 @@ interface objectLoaderOptions {
     instanceKey?: string;
 }
 export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
-export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | null;
+export declare function getTransformedUpdateOp<TEnt extends Ent<TViewer>, TViewer extends Viewer>(value: SchemaInputType, stmt: UpdateOperation<TEnt, TViewer>): TransformedUpdateOperation<TEnt> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,

package/testutils/builder.d.ts

@@ -80,9 +80,12 @@ export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNu
     orchestrator: Orchestrator<T, Data, Viewer>;
     fields: Map<string, any>;
     nodeType: string;
+    m: Map<string, any>;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T>, Viewer, Data> | undefined);
     getInput(): Data;
     updateInput(input: Data): void;
+    storeData(k: string, v: any): void;
+    getStoredData(k: string): any;
     build(): Promise<Changeset>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
@@ -100,7 +103,7 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     builder: SimpleBuilder<T, TExistingEnt>;
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
-    getTriggers(): Trigger<T, SimpleBuilder<T>>[];
+    getTriggers(): (Trigger<T, SimpleBuilder<T>> | Array<Trigger<T, SimpleBuilder<T>>>)[];
     getValidators(): Validator<T, SimpleBuilder<T>>[];
     getObservers(): Observer<T, SimpleBuilder<T>>[];
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;

package/testutils/builder.js

@@ -150,6 +150,7 @@ class SimpleBuilder {
         this.schema = schema;
         this.operation = operation;
         this.existingEnt = existingEnt;
+        this.m = new Map();
         // create dynamic placeholder
         // TODO: do we need to use this as the node when there's an existingEnt
         // same for generated builders.
@@ -230,6 +231,14 @@ class SimpleBuilder {
             }
         }
     }
+    // store data in Builder that can be retrieved by another validator, trigger, observer later in the action
+    storeData(k, v) {
+        this.m.set(k, v);
+    }
+    // retrieve data stored in this Builder with key
+    getStoredData(k) {
+        return this.m.get(k);
+    }
     build() {
         return this.orchestrator.build();
     }

package/tsc/transform_action.d.ts

@@ -11,10 +11,12 @@ export declare class TransformAction implements TransformFile {
         rawString?: undefined;
         traversed?: undefined;
         imports?: undefined;
+        removeImports?: undefined;
     } | {
         rawString: string;
         traversed: boolean;
         imports: Map<string, string[]>;
+        removeImports: string[];
         node?: undefined;
     } | undefined;
 }

package/tsc/transform_action.js

@@ -25,11 +25,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformAction = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const ast_1 = require("../tsc/ast");
-const action_1 = require("../action");
 const viewer_1 = require("../core/viewer");
 const path = __importStar(require("path"));
 const snake_case_1 = require("snake-case");
-function findInput(file, classInfo, sourceFile) {
+// returns input and importPath
+function getBaseFileInfo(file, classInfo, sourceFile) {
     // @ts-ignore
     const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
     for (const imp of importStatements) {
@@ -49,13 +49,19 @@ function findInput(file, classInfo, sourceFile) {
                 .filter((imp) => imp.trim() && imp.endsWith("Input"))
                 .map((v) => v.trim());
             if (inputs.length === 1) {
-                return inputs[0];
+                return {
+                    input: inputs[0],
+                    importPath: impInfo.importPath,
+                };
             }
             if (inputs.length && classInfo.name.endsWith("Action")) {
                 const prefix = classInfo.name.slice(0, classInfo.name.length - 6);
                 inputs = inputs.filter((imp) => imp.slice(0, imp.length - 5) === prefix);
                 if (inputs.length === 1) {
-                    return inputs[0];
+                    return {
+                        input: inputs[0],
+                        importPath: impInfo.importPath,
+                    };
                 }
             }
         }
@@ -66,17 +72,20 @@ let m = {
     triggers: {
         m: "getTriggers",
         i: "Trigger",
+        suffix: "Triggers",
     },
     observers: {
         m: "getObservers",
         i: "Observer",
+        suffix: "Observers",
     },
     validators: {
         m: "getValidators",
         i: "Validator",
+        suffix: "Validators",
     },
 };
-function getConversionInfo(mm) {
+function getConversionInfo(mm, actionName) {
     if (mm.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
         return null;
     }
@@ -89,6 +98,8 @@ function getConversionInfo(mm) {
         text,
         method: v.m,
         interface: v.i,
+        // CreateFooActionTriggers etc
+        methodType: actionName + v.suffix,
     };
 }
 class TransformAction {
@@ -109,21 +120,19 @@ class TransformAction {
         // require action
         const p = require(path.join(process.cwd(), "./" + file.slice(0, -3)));
         const action = new p.default(new viewer_1.LoggedOutViewer(), {});
+        const actionName = action.constructor.name;
         const builder = action.builder.constructor.name;
         const nodeName = action.builder.ent.name;
-        const existingEnt = action.builder.operation === action_1.WriteOperation.Insert
-            ? `${nodeName} | null`
-            : nodeName;
         const viewer = this.customInfo.viewerInfo.name;
-        const input = findInput(file, classInfo, sourceFile);
-        if (!input) {
+        const baseInfo = getBaseFileInfo(file, classInfo, sourceFile);
+        if (!baseInfo) {
             return;
         }
         let klassContents = "";
         let traversed = false;
         let newImports = [];
         for (const mm of node.members) {
-            const conv = getConversionInfo(mm);
+            const conv = getConversionInfo(mm, actionName);
             if (conv !== null) {
                 const property = mm;
                 // if invalid, bounce
@@ -132,10 +141,10 @@ class TransformAction {
                 }
                 traversed = true;
                 const pp = property.initializer.getFullText(sourceFile).trim();
-                const code = `${conv.method}(): ${conv.interface}<${nodeName}, ${builder}<${input}, ${existingEnt}>, ${viewer}, ${input}, ${existingEnt}>[] {
+                const code = `${conv.method}(): ${conv.methodType} {
             return ${pp}
           }`;
-                newImports.push(conv.interface);
+                newImports.push(conv.methodType);
                 klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
             }
             else {
@@ -149,10 +158,9 @@ class TransformAction {
                 [viewer],
             ],
             [
-                (0, ast_1.transformRelative)(file, "src/ent", this.customInfo.relativeImports),
-                [nodeName],
+                (0, ast_1.transformRelative)(file, baseInfo.importPath, this.customInfo.relativeImports),
+                newImports,
             ],
-            ["@snowtop/ent/action", newImports],
             [
                 (0, ast_1.transformRelative)(file, builderPath, this.customInfo.relativeImports),
                 [builder],
@@ -163,6 +171,8 @@ class TransformAction {
             rawString: classInfo.wrapClassContents(klassContents),
             traversed,
             imports,
+            removeImports: ["Trigger", "Observer", "Validator"],
+            // not removing FooBuilder incase it's still somehow used in type of inline builders
         };
     }
 }

package/tsc/transform_schema.js

@@ -91,7 +91,7 @@ function getTransformClassInfo(fileContents, sourceFile, node, transformSchema)
 }
 // intentionally doesn't parse decorators since we don't need it
 function getClassElementInfo(fileContents, member, sourceFile) {
-    if (isFieldElement(member, sourceFile)) {
+    if (isFieldElement(fileContents, member, sourceFile)) {
         return getFieldElementInfo(fileContents, member, sourceFile);
     }
     if (member.kind === typescript_1.default.SyntaxKind.Constructor) {
@@ -201,7 +201,7 @@ function getConstructorElementInfo(fileContents, member, sourceFile) {
         comment: "",
     };
 }
-function isFieldElement(member, sourceFile) {
+function isFieldElement(fileContents, member, sourceFile) {
     if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
         return false;
     }
@@ -215,16 +215,31 @@ function isFieldElement(member, sourceFile) {
         return false;
     }
     if (property.initializer?.kind !== typescript_1.default.SyntaxKind.ArrayLiteralExpression) {
-        console.error("invalid array type");
+        throwErr(fileContents, member, "invalid array type");
         return false;
     }
     return true;
 }
+// if there's an error transforming any of the schemas, we should stop...
+function throwErr(fileContents, node, error) {
+    console.error(error);
+    throw new Error(`error transforming this field ${fileContents.substring(node.getFullStart(), node.getEnd())}`);
+}
 function parseFieldElement(element, sourceFile, fileContents, nested) {
-    if (element.kind !== typescript_1.default.SyntaxKind.CallExpression) {
-        console.error("skipped non-call expression");
+    if (element.kind !== typescript_1.default.SyntaxKind.CallExpression &&
+        element.kind !== typescript_1.default.SyntaxKind.PropertyAccessExpression) {
+        throwErr(fileContents, element, `skipped unknown (non-call|non-property) expression ${element.kind}`);
         return null;
     }
+    if (element.kind === typescript_1.default.SyntaxKind.PropertyAccessExpression) {
+        const ret = parseFieldElement(element.expression, sourceFile, fileContents, true);
+        if (ret !== null) {
+            if (!nested) {
+                ret.suffix = fileContents.substring(ret.callEx.getEnd(), element.getEnd());
+            }
+            return ret;
+        }
+    }
     let callEx = element;
     if (callEx.arguments.length !== 1) {
         // have a situation like:     StringType({ name: "canonicalName" }).trim().toLowerCase(),
@@ -238,12 +253,22 @@ function parseFieldElement(element, sourceFile, fileContents, nested) {
                 return ret;
             }
         }
-        console.error("callExpression with arguments not of length 1");
-        return null;
+        throwErr(fileContents, element, "callExpression with arguments not of length 1");
     }
     let arg = callEx.arguments[0];
     if (arg.kind !== typescript_1.default.SyntaxKind.ObjectLiteralExpression) {
-        console.error("not objectLiteralExpression");
+        // this and the check above for PropertyAccessExpression are to handle things like
+        // FooType({
+        /// ...
+        // }).function(blah)
+        const ret = parseFieldElement(callEx.expression, sourceFile, fileContents, true);
+        if (ret !== null) {
+            if (!nested) {
+                ret.suffix = fileContents.substring(ret.callEx.getEnd(), callEx.getEnd());
+            }
+            return ret;
+        }
+        throwErr(fileContents, element, `not objectLiteralExpression. kind ${arg.kind}`);
         return null;
     }
     let expr = arg;
@@ -263,7 +288,7 @@ function parseFieldElement(element, sourceFile, fileContents, nested) {
         }
     }
     if (!name) {
-        console.error(`couldn't find name property`);
+        throwErr(fileContents, element, `couldn't find name property`);
         return null;
     }
     // remove quotes