@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha16

package/action/action.d.ts

@@ -49,9 +49,9 @@ export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt
     changeset(): Promise<Changeset>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-    triggers?: Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-    observers?: Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
-    validators?: Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getTriggers?(): 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;
     valid(): Promise<boolean>;

package/action/executor.js

@@ -47,11 +47,11 @@ class ListBasedExecutor {
     }
     async executeObservers() {
         const action = this.options?.action;
-        if (!this.options || !action || !action.observers) {
+        if (!this.options || !action || !action.getObservers) {
             return;
         }
         const builder = this.options.builder;
-        await Promise.all(action.observers.map(async (observer) => {
+        await Promise.all(action.getObservers().map(async (observer) => {
             await observer.observe(builder, action.getInput());
         }));
     }

package/action/experimental_action.d.ts

@@ -19,10 +19,10 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
     builderCtr: BuilderConstructor<TEnt, TViewer, TInput>;
     builder: EntBuilder<TEnt, TViewer, TInput>;
     private input;
-    triggers: Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    observers: Observer<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    validators: Validator<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, import("../core/base").ID | null>>, Viewer<Ent<any> | null, import("../core/base").ID | null>>;
+    getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
+    getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
+    getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
     constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null);
     static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null): Builder<TEnt>;
     static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput>;

package/action/experimental_action.js

@@ -7,9 +7,6 @@ class BaseAction {
     constructor(viewer, builderCtr, options) {
         this.viewer = viewer;
         this.builderCtr = builderCtr;
-        this.triggers = [];
-        this.observers = [];
-        this.validators = [];
         let operation = options?.operation;
         if (!operation) {
             if (options?.existingEnt) {
@@ -25,6 +22,15 @@ class BaseAction {
     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;
@@ -35,7 +41,7 @@ class BaseAction {
         let action = new BaseAction(ent.viewer, builderCtr, {
             existingEnt: ent,
         });
-        action.triggers = [
+        action.getTriggers = () => [
             {
                 changeset: () => {
                     return actions.map((action) => action.changeset());

package/action/orchestrator.js

@@ -317,11 +317,13 @@ class Orchestrator {
         }
         // 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 = [];
+        if (action?.getValidators) {
+            validators = action.getValidators();
         }
-        let validators = action?.validators || [];
         // not ideal we're calling this twice. fix...
         // needed for now. may need to rewrite some of this?
         const editedFields2 = await this.options.editedFields();

package/core/config.d.ts

@@ -35,6 +35,7 @@ interface CodegenConfig {
     schemaSQLFilePath?: boolean;
     databaseToCompareTo?: string;
     fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
+    templatizedViewer?: templatizedViewer;
 }
 interface PrettierConfig {
     custom?: boolean;
@@ -45,5 +46,9 @@ interface PrivacyConfig {
     policyName: string;
     class?: boolean;
 }
+interface templatizedViewer {
+    path: string;
+    name: string;
+}
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};

package/package.json

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

package/scripts/move_generated.js

@@ -122,12 +122,11 @@ function main() {
     (0, child_process_1.execSync)("prettier src/graphql/*.ts --write");
 }
 function isGeneratedPath(node, sourceFile, dirPath) {
-    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
     // it's relative and has generated in there, continue
-    if (!((text.startsWith("..") || text.startsWith("./")) &&
-        text.indexOf("/generated") !== -1)) {
+    if (!(0, ast_1.isRelativeGeneratedImport)(node, sourceFile)) {
         return;
     }
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
     const oldPath = path.join(dirPath, text);
     const relFromRoot = path.relative(".", oldPath);
     const conv = transformPath(relFromRoot);

package/scripts/transform_actions.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/transform_actions.js

@@ -0,0 +1,266 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = require("glob");
+const typescript_1 = __importDefault(require("typescript"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
+const ast_1 = require("../tsc/ast");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const action_1 = require("../action");
+const viewer_1 = require("../core/viewer");
+const path = __importStar(require("path"));
+const js_yaml_1 = require("js-yaml");
+function transformRelative(file, importPath, relative) {
+    if (!relative || !importPath.startsWith("src")) {
+        return importPath;
+    }
+    const fileFullPath = path.join(process.cwd(), file);
+    const impFullPath = path.join(process.cwd(), importPath);
+    // relative path is from directory
+    return normalizePath(path.relative(path.dirname(fileFullPath), impFullPath));
+}
+function normalizePath(p) {
+    if (p.endsWith("..")) {
+        return p + "/";
+    }
+    return p;
+}
+function findInput(file, sourceFile) {
+    // @ts-ignore
+    const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
+    for (const imp of importStatements) {
+        const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        if ((0, ast_1.isRelativeGeneratedImport)(imp, sourceFile)) {
+            // base file and we're importing from it
+            // e.g. in create_user_action, we're importing from create_user_action_base
+            if (path.basename(file).slice(0, -3) + "_base" !== path.basename(text)) {
+                continue;
+            }
+            const impInfo = (0, ast_1.getImportInfo)(imp, sourceFile);
+            if (!impInfo) {
+                continue;
+            }
+            const inputs = impInfo.imports
+                .filter((imp) => imp.trim() && imp.endsWith("Input"))
+                .map((v) => v.trim());
+            if (inputs.length === 1) {
+                return inputs[0];
+            }
+        }
+    }
+    return null;
+}
+function getCustomInfo() {
+    let yaml = {};
+    let relativeImports = false;
+    try {
+        yaml = (0, js_yaml_1.load)(fs.readFileSync(path.join(process.cwd(), "ent.yml"), {
+            encoding: "utf8",
+        }));
+        relativeImports = yaml?.codegen?.relativeImports || false;
+        if (yaml?.codegen?.templatizedViewer) {
+            return {
+                viewerInfo: yaml.codegen.templatizedViewer,
+                relativeImports,
+            };
+        }
+    }
+    catch (e) { }
+    return {
+        viewerInfo: {
+            path: "@snowtop/ent",
+            name: "Viewer",
+        },
+        relativeImports,
+    };
+}
+async function main() {
+    let files = glob_1.glob.sync("src/ent/**/actions/**/*_action.ts");
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    const customInfo = getCustomInfo();
+    const viewerInfo = customInfo.viewerInfo;
+    files.forEach((file) => {
+        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
+        let traversed = false;
+        let nodes = [];
+        // require action
+        const p = require(path.join(process.cwd(), "./" + file.slice(0, -3)));
+        const action = new p.default(new viewer_1.LoggedOutViewer(), {});
+        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 = customInfo.viewerInfo.name;
+        const input = findInput(file, sourceFile);
+        if (!input) {
+            return;
+        }
+        let newImports = [];
+        typescript_1.default.forEachChild(sourceFile, function (node) {
+            if (!typescript_1.default.isClassDeclaration(node) || !node.heritageClauses) {
+                nodes.push({ node });
+                return;
+            }
+            let classInfo = (0, ast_1.getClassInfo)(contents, sourceFile, node);
+            // only do classes
+            if (!classInfo) {
+                return;
+            }
+            let klassContents = "";
+            for (const mm of node.members) {
+                const conv = getConversionInfo(mm);
+                if (conv !== null) {
+                    const property = mm;
+                    // if invalid, bounce
+                    if (!property.initializer) {
+                        traversed = false;
+                        return;
+                    }
+                    traversed = true;
+                    const pp = property.initializer.getFullText(sourceFile).trim();
+                    const code = `${conv.method}(): ${conv.interface}<${nodeName}, ${builder}<${input}, ${existingEnt}>, ${viewer}, ${input}, ${existingEnt}>[] {
+            return ${pp}
+          }`;
+                    newImports.push(conv.interface);
+                    klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
+                }
+                else {
+                    klassContents += mm.getFullText(sourceFile);
+                }
+            }
+            // wrap comments and transform to export class Foo extends Bar { ${inner} }
+            nodes.push({ rawString: classInfo.wrapClassContents(klassContents) });
+        });
+        // if traversed, overwrite.
+        if (!traversed) {
+            return;
+        }
+        let newContents = "";
+        let afterProcessed = false;
+        let imports = new Map([
+            [
+                transformRelative(file, viewerInfo.path, customInfo.relativeImports),
+                [viewer],
+            ],
+            [
+                transformRelative(file, "src/ent", customInfo.relativeImports),
+                [nodeName],
+            ],
+            ["@snowtop/ent/action", newImports],
+        ]);
+        let seen = new Map();
+        const processAfterImport = () => {
+            // do this for the first non-import node we see
+            // we want to add new imports to end of imports and there's an assumption that imports are ordered
+            // at top of file
+            if (!afterProcessed) {
+                for (const [imp, list] of imports) {
+                    if (seen.has(imp)) {
+                        continue;
+                    }
+                    newContents += `\nimport { ${list.join(", ")} } from "${imp}"`;
+                }
+                afterProcessed = true;
+            }
+        };
+        for (const node of nodes) {
+            if (node.node) {
+                if (typescript_1.default.isImportDeclaration(node.node)) {
+                    const impInfo = (0, ast_1.getImportInfo)(node.node, sourceFile);
+                    if (impInfo) {
+                        const impPath = normalizePath(impInfo.importPath);
+                        // normalize paths...
+                        const list = imports.get(impPath);
+                        if (list) {
+                            let transformed = (0, ast_1.transformImport)(contents, node.node, sourceFile, {
+                                newImports: list,
+                                // don't use normalized path here, we wanna use the path that's in code...
+                                transformPath: impInfo.importPath,
+                            });
+                            if (transformed) {
+                                newContents += transformed;
+                                seen.set(impPath, true);
+                                continue;
+                            }
+                        }
+                    }
+                }
+                else {
+                    if (!typescript_1.default.isExportDeclaration(node.node)) {
+                        processAfterImport();
+                    }
+                }
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                processAfterImport();
+                newContents += node.rawString;
+            }
+            else {
+                throw new Error(`malformed node with no node or rawString`);
+            }
+            fs.writeFileSync(file, newContents);
+        }
+    });
+    (0, child_process_1.execSync)("prettier src/ent/**/actions/**/*.ts --write");
+}
+let m = {
+    triggers: {
+        m: "getTriggers",
+        i: "Trigger",
+    },
+    observers: {
+        m: "getObservers",
+        i: "Observer",
+    },
+    validators: {
+        m: "getValidators",
+        i: "Validator",
+    },
+};
+function getConversionInfo(mm) {
+    if (mm.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return null;
+    }
+    const text = mm.name.escapedText;
+    const v = m[text];
+    if (v === undefined) {
+        return null;
+    }
+    return {
+        text,
+        method: v.m,
+        interface: v.i,
+    };
+}
+main()
+    .then(() => {
+    process.exit(0);
+})
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/scripts/transform_code.js

@@ -45,7 +45,6 @@ async function main() {
             if (!classInfo || classInfo.extends !== classInfo.name + "Base") {
                 return;
             }
-            // need to check for PrivacyPolicy import...
             traversed = true;
             let klassContents = "";
             for (const mm of node.members) {
@@ -60,7 +59,7 @@ async function main() {
                     const code = `getPrivacyPolicy(): PrivacyPolicy<this> {
             return ${pp}
           }`;
-                    klassContents += code;
+                    klassContents += (0, ast_1.getPreText)(contents, mm, sourceFile) + code;
                 }
                 else {
                     klassContents += mm.getFullText(sourceFile);
@@ -68,7 +67,6 @@ async function main() {
             }
             // wrap comments and transform to export class Foo extends Bar { ${inner} }
             nodes.push({ rawString: classInfo.wrapClassContents(klassContents) });
-            //      console.debug(classInfo.wrapClassContents(klassContents));
         });
         // if traversed, overwrite.
         if (!traversed) {

package/testutils/builder.d.ts

@@ -98,11 +98,11 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     viewer: Viewer;
     private fields;
     builder: SimpleBuilder<T, TExistingEnt>;
-    validators: Validator<T, SimpleBuilder<T>>[];
-    triggers: Trigger<T, SimpleBuilder<T>>[];
-    observers: Observer<T, SimpleBuilder<T>>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
+    getTriggers(): 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>>;
     getInput(): Data;
     changeset(): Promise<Changeset>;

package/testutils/builder.js

@@ -257,11 +257,17 @@ class SimpleAction {
     constructor(viewer, schema, fields, operation = action_1.WriteOperation.Insert, existingEnt) {
         this.viewer = viewer;
         this.fields = fields;
-        this.validators = [];
-        this.triggers = [];
-        this.observers = [];
         this.builder = new SimpleBuilder(this.viewer, schema, fields, operation, existingEnt, this);
     }
+    getTriggers() {
+        return [];
+    }
+    getValidators() {
+        return [];
+    }
+    getObservers() {
+        return [];
+    }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }

package/tsc/ast.d.ts

@@ -15,7 +15,18 @@ interface transformOpts {
     removeImports?: string[];
     newImports?: string[];
     transform?: transformImportFn;
+    transformPath?: string;
 }
 export declare function transformImport(fileContents: string, importNode: ts.ImportDeclaration, sourceFile: ts.SourceFile, opts?: transformOpts): string | undefined;
 export declare function updateImportPath(fileContents: string, importNode: ts.ImportDeclaration, sourceFile: ts.SourceFile, newPath: string): string | undefined;
+export declare function isRelativeImport(node: ts.ImportDeclaration, sourceFile: ts.SourceFile): boolean;
+export declare function isRelativeGeneratedImport(node: ts.ImportDeclaration, sourceFile: ts.SourceFile): boolean;
+interface importInfo {
+    imports: string[];
+    start: number;
+    end: number;
+    importText: string;
+    importPath: string;
+}
+export declare function getImportInfo(imp: ts.ImportDeclaration, sourceFile: ts.SourceFile): importInfo | undefined;
 export {};

package/tsc/ast.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateImportPath = exports.transformImport = exports.getClassInfo = exports.getPreText = void 0;
+exports.getImportInfo = exports.isRelativeGeneratedImport = exports.isRelativeImport = exports.updateImportPath = exports.transformImport = exports.getClassInfo = exports.getPreText = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 function getPreText(fileContents, node, sourceFile) {
     return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
@@ -82,21 +82,23 @@ exports.getClassInfo = getClassInfo;
 function transformImport(fileContents, importNode, sourceFile, opts) {
     // remove quotes too
     const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
-    if (text !== "@snowtop/ent" &&
-        text !== "@snowtop/ent/schema" &&
-        text !== "@snowtop/ent/schema/") {
-        return;
+    if (opts?.transformPath) {
+        if (text !== opts.transformPath) {
+            return;
+        }
     }
-    const importText = importNode.importClause?.getText(sourceFile) || "";
-    const start = importText.indexOf("{");
-    const end = importText.lastIndexOf("}");
-    if (start === -1 || end === -1) {
+    else {
+        if (text !== "@snowtop/ent" &&
+            text !== "@snowtop/ent/schema" &&
+            text !== "@snowtop/ent/schema/") {
+            return;
+        }
+    }
+    const impInfo = getImportInfo(importNode, sourceFile);
+    if (!impInfo) {
         return;
     }
-    const imports = importText
-        .substring(start + 1, end)
-        //    .trim()
-        .split(",");
+    const { imports, start, end, importText } = impInfo;
     let removeImportsMap = {};
     if (opts?.removeImports) {
         opts.removeImports.forEach((imp) => (removeImportsMap[imp] = true));
@@ -152,3 +154,34 @@ function updateImportPath(fileContents, importNode, sourceFile, newPath) {
         '";');
 }
 exports.updateImportPath = updateImportPath;
+function isRelativeImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return text.startsWith("..") || text.startsWith("./");
+}
+exports.isRelativeImport = isRelativeImport;
+function isRelativeGeneratedImport(node, sourceFile) {
+    const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    return ((text.startsWith("..") || text.startsWith("./")) &&
+        text.indexOf("/generated") !== -1);
+}
+exports.isRelativeGeneratedImport = isRelativeGeneratedImport;
+function getImportInfo(imp, sourceFile) {
+    const importText = imp.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    if (start === -1 || end === -1) {
+        return;
+    }
+    return {
+        importPath: text,
+        importText,
+        start,
+        end,
+        imports: importText
+            .substring(start + 1, end)
+            //.trim()
+            .split(","),
+    };
+}
+exports.getImportInfo = getImportInfo;