@snowtop/ent 0.1.0-alpha30 → 0.1.0-alpha35

package/action/action.d.ts

@@ -53,7 +53,7 @@ export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt
     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/experimental_action.d.ts

@@ -36,6 +36,6 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
 interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> {
     new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>, existingEnt: TEnt | null): EntBuilder<TEnt, TViewer, TInput>;
 }
-export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
 export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Action<TEnt, Builder<TEnt, TViewer>, TViewer, TInput>;
 export {};

package/action/orchestrator.js

@@ -379,23 +379,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 +424,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-alpha30",
+  "version": "0.1.0-alpha35",
   "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/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