@snowtop/ent 0.1.0-alpha10 → 0.1.0-alpha101

package/{scripts → tsc}/transform_schema.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -22,111 +26,27 @@ 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");
+exports.TransformSchema = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const fs = __importStar(require("fs"));
-const compilerOptions_1 = require("../tsc/compilerOptions");
-const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const ast_1 = require("../tsc/ast");
-async function main() {
-    // this assumes this is being run from root of directory
-    const options = (0, compilerOptions_1.readCompilerOptions)(".");
-    let files = glob_1.glob.sync("src/schema/*.ts");
-    const target = (0, compilerOptions_1.getTarget)(options.target?.toString());
-    // filter to only event.ts e.g. for comments and whitespace...
-    //  files = files.filter((f) => f.endsWith("event.ts"));
-    files.forEach((file) => {
-        // assume valid file since we do glob above
-        //    const idx = file.lastIndexOf(".ts");
-        //    const writeFile = file.substring(0, idx) + "2" + ".ts";
-        //    console.debug(file);
-        const writeFile = "src/schema/" + path_1.default.basename(file).slice(0, -3) + "_schema.ts";
-        // const writeFile = file;
-        //    console.debug(file, writeFile);
-        // go through the file and print everything back if not starting immediately after other position
-        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
-        const nodes = [];
-        let updateImport = false;
-        let removeImports = [];
-        const f = {
-            trackNode: function (tni) {
-                nodes.push({
-                    node: tni.node,
-                    importNode: tni.node && typescript_1.default.isImportDeclaration(tni.node),
-                    rawString: tni.rawString,
-                });
-                if (tni.removeImports) {
-                    removeImports.push(...tni.removeImports);
-                }
-            },
-            flagUpdateImport() {
-                updateImport = true;
-            },
-        };
-        if (!traverse(contents, sourceFile, f)) {
-            return;
-        }
-        let newContents = "";
-        for (const node of nodes) {
-            if (updateImport && node.importNode) {
-                const importNode = node.node;
-                const transformedImport = (0, ast_1.transformImport)(contents, importNode, sourceFile, {
-                    removeImports,
-                    transform: transformSchema,
-                });
-                if (transformedImport) {
-                    newContents += transformedImport;
-                    continue;
-                }
-            }
-            if (node.node) {
-                newContents += node.node.getFullText(sourceFile);
-            }
-            else if (node.rawString) {
-                newContents += node.rawString;
-            }
-            else {
-                console.error("invalid node");
-            }
-        }
-        //    console.debug(newContents);
-        // ideally there's a flag that indicates if we write
-        fs.writeFileSync(writeFile, newContents);
-        fs.rmSync(file);
-    });
-    (0, child_process_1.execSync)("prettier src/schema/*.ts --write");
-}
-function traverse(fileContents, sourceFile, f) {
-    let traversed = false;
-    typescript_1.default.forEachChild(sourceFile, function (node) {
-        if (typescript_1.default.isClassDeclaration(node)) {
-            traversed = true;
-            // TODO address implicit schema doesn't work here...
-            //        console.debug(sourceFile.fileName, node.kind);
-            if (traverseClass(fileContents, sourceFile, node, f)) {
-                f.flagUpdateImport();
-                return;
-            }
-        }
-        f.trackNode({ node });
-    });
-    return traversed;
-}
-function traverseClass(fileContents, sourceFile, node, f) {
-    const ci = getTransformClassInfo(fileContents, sourceFile, node);
+function traverseClass(fileContents, sourceFile, node, transformSchema) {
+    const ci = getTransformClassInfo(fileContents, sourceFile, node, transformSchema);
     if (!ci) {
-        return false;
+        return;
     }
-    let klassContents = `${ci.comment}const ${ci.name} = new ${ci.class}({\n`;
+    let klassContents = `${ci.comment}const ${ci.name} = new ${transformSchema(ci.class)}({\n`;
     let removeImports = [];
     if (ci.implementsSchema) {
         removeImports.push("Schema");
     }
+    removeImports.push(ci.class);
+    let newImports = [transformSchema(ci.class)];
     for (let member of node.members) {
         const fInfo = getClassElementInfo(fileContents, member, sourceFile);
         if (!fInfo) {
-            return false;
+            return;
         }
         klassContents += `${fInfo.comment}${fInfo.key}:${fInfo.value},\n`;
         if (fInfo.type) {
@@ -141,20 +61,13 @@ function traverseClass(fileContents, sourceFile, node, f) {
         klassContents = "export " + klassContents;
     }
     //  console.debug(klassContents);
-    f.trackNode({ rawString: klassContents, removeImports: removeImports });
-    return true;
-}
-function transformSchema(str) {
-    // only do known class names
-    if (str === "BaseEntSchema" || str === "BaseEntSchemaWithTZ") {
-        return str.substring(4);
-    }
-    return str;
+    return {
+        rawString: klassContents,
+        removeImports: removeImports,
+        newImports,
+    };
 }
-// TODO need to generify this...
-// and then have a schema specific version
-// may make sense to just duplicate this logic...
-function getTransformClassInfo(fileContents, sourceFile, node) {
+function getTransformClassInfo(fileContents, sourceFile, node, transformSchema) {
     const generic = (0, ast_1.getClassInfo)(fileContents, sourceFile, node);
     if (!generic) {
         return;
@@ -165,6 +78,7 @@ function getTransformClassInfo(fileContents, sourceFile, node) {
     }
     let implementsSchema = generic.implements?.some((v) => v == "Schema");
     let classExtends = generic.extends;
+    // nothing transformed here, so nothing to do here
     if (classExtends && classExtends === transformSchema(classExtends)) {
         return undefined;
     }
@@ -181,7 +95,7 @@ function getTransformClassInfo(fileContents, sourceFile, node) {
 }
 // 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) {
@@ -224,7 +138,7 @@ function getFieldElementInfo(fileContents, member, sourceFile) {
         if (parsed === null) {
             return;
         }
-        const { callEx, name, nameComment, properties } = parsed;
+        const { callEx, name, nameComment, properties, suffix } = parsed;
         let property = "";
         const fieldComment = (0, ast_1.getPreText)(fileContents, element, sourceFile).trim();
         if (fieldComment) {
@@ -239,7 +153,7 @@ function getFieldElementInfo(fileContents, member, sourceFile) {
         if (properties.length) {
             fnCall = `{${properties.join(",")}}`;
         }
-        property += `${name}:${call}(${fnCall}),`;
+        property += `${name}:${call}(${fnCall})${suffix || ""},`;
         fieldMap += property;
     }
     fieldMap += "}";
@@ -291,7 +205,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;
     }
@@ -305,24 +219,60 @@ 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;
 }
-function parseFieldElement(element, sourceFile, fileContents) {
-    if (element.kind !== typescript_1.default.SyntaxKind.CallExpression) {
-        console.error("skipped non-call expression");
+// 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 &&
+        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) {
-        console.error("callExpression with arguments not of length 1");
-        return null;
+        // have a situation like:     StringType({ name: "canonicalName" }).trim().toLowerCase(),
+        // need to keep calling this until we find what we want and then get the suffix we should just add to the end of the transformed code
+        if (callEx.expression.kind === typescript_1.default.SyntaxKind.PropertyAccessExpression) {
+            const ret = parseFieldElement(callEx.expression.expression, sourceFile, fileContents, true);
+            if (ret !== null) {
+                if (!nested) {
+                    ret.suffix = fileContents.substring(ret.callEx.getEnd(), callEx.getEnd());
+                }
+                return ret;
+            }
+        }
+        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;
@@ -342,7 +292,7 @@ function parseFieldElement(element, sourceFile, fileContents) {
         }
     }
     if (!name) {
-        console.error(`couldn't find name property`);
+        throwErr(fileContents, element, `couldn't find name property`);
         return null;
     }
     // remove quotes
@@ -354,4 +304,80 @@ function parseFieldElement(element, sourceFile, fileContents) {
         nameComment: propertyComment,
     };
 }
-Promise.resolve(main());
+// find which of these importPaths is being used and use that to replace
+function findSchemaImportPath(sourceFile) {
+    const paths = {
+        "@snowtop/ent": true,
+        "@snowtop/ent/schema": true,
+        "@snowtop/ent/schema/": true,
+    };
+    // @ts-ignore
+    const importStatements = sourceFile.statements.filter((stmt) => typescript_1.default.isImportDeclaration(stmt));
+    for (const imp of importStatements) {
+        const impInfo = (0, ast_1.getImportInfo)(imp, sourceFile);
+        if (!impInfo) {
+            continue;
+        }
+        if (paths[impInfo.importPath] !== undefined) {
+            return impInfo.importPath;
+        }
+    }
+}
+class TransformSchema {
+    // we only end up doing this once because we change the schema representation
+    // so safe to run this multiple times
+    constructor(relativeImports, oldBaseClass, newSchemaClass, transformPath) {
+        this.relativeImports = relativeImports;
+        this.oldBaseClass = oldBaseClass;
+        this.newSchemaClass = newSchemaClass;
+        this.transformPath = transformPath;
+        this.glob = "src/schema/*.ts";
+        this.prettierGlob = "src/schema/*.ts";
+    }
+    transformSchema(className) {
+        if (className === "BaseEntSchema" || className === "BaseEntSchemaWithTZ") {
+            return className.substring(4);
+        }
+        if (className === this.oldBaseClass && this.newSchemaClass) {
+            return this.newSchemaClass;
+        }
+        return className;
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!typescript_1.default.isClassDeclaration(node)) {
+            return { node };
+        }
+        // TODO address implicit schema doesn't work here...
+        const ret = traverseClass(contents, sourceFile, node, this.transformSchema.bind(this));
+        if (ret === undefined) {
+            return;
+        }
+        let imports = new Map();
+        const imp = findSchemaImportPath(sourceFile);
+        if (imp) {
+            if (this.transformPath) {
+                imports.set(imp, []);
+            }
+            else {
+                imports.set(imp, ret.newImports);
+            }
+        }
+        if (this.transformPath) {
+            // add new imports to this path
+            imports.set((0, ast_1.transformRelative)(file, this.transformPath, this.relativeImports), ret.newImports);
+        }
+        return {
+            traversed: true,
+            rawString: ret.rawString,
+            removeImports: ret.removeImports,
+            imports: imports,
+        };
+    }
+    fileToWrite(file) {
+        return "src/schema/" + path_1.default.basename(file).slice(0, -3) + "_schema.ts";
+    }
+    postProcess(file) {
+        fs.rmSync(file);
+    }
+}
+exports.TransformSchema = TransformSchema;

package/graphql/enums.d.ts

@@ -1,3 +0,0 @@
-import { GraphQLEnumValue } from "graphql";
-export declare function convertToGQLEnum(val: string | null, tsValues: string[], gqlValues: GraphQLEnumValue[]): any;
-export declare function convertFromGQLEnum(val: string, tsValues: string[], gqlValues: GraphQLEnumValue[]): string;

package/graphql/enums.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFromGQLEnum = exports.convertToGQLEnum = void 0;
-function convertToGQLEnum(val, tsValues, gqlValues) {
-    for (let i = 0; i < tsValues.length; i++) {
-        let tsVal = tsValues[i];
-        let gqlValue = gqlValues[i];
-        if (val === tsVal) {
-            return gqlValue.value;
-        }
-    }
-    return val;
-}
-exports.convertToGQLEnum = convertToGQLEnum;
-function convertFromGQLEnum(val, tsValues, gqlValues) {
-    for (let i = 0; i < tsValues.length; i++) {
-        let tsVal = tsValues[i];
-        let gqlValue = gqlValues[i];
-        if (val === gqlValue.value) {
-            return tsVal;
-        }
-    }
-    return val;
-}
-exports.convertFromGQLEnum = convertFromGQLEnum;

package/scripts/transform_code.js

@@ -1,114 +0,0 @@
-"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"));
-async function main() {
-    const options = (0, compilerOptions_1.readCompilerOptions)(".");
-    let files = glob_1.glob.sync("src/ent/*.ts");
-    const target = (0, compilerOptions_1.getTarget)(options.target?.toString());
-    files.forEach((file) => {
-        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
-        let traversed = false;
-        let nodes = [];
-        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 which extend a base class e.g. User extends UserBase
-            if (!classInfo || classInfo.extends !== classInfo.name + "Base") {
-                return;
-            }
-            // need to check for PrivacyPolicy import...
-            traversed = true;
-            let klassContents = "";
-            for (const mm of node.members) {
-                if (isPrivacyPolicy(mm)) {
-                    const property = mm;
-                    // if invalid privacy policy, bounce
-                    if (!property.initializer) {
-                        traversed = false;
-                        return;
-                    }
-                    const pp = property.initializer.getFullText(sourceFile);
-                    const code = `getPrivacyPolicy(): PrivacyPolicy<this> {
-            return ${pp}
-          }`;
-                    klassContents += code;
-                }
-                else {
-                    klassContents += mm.getFullText(sourceFile);
-                }
-            }
-            // 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) {
-            return;
-        }
-        let newContents = "";
-        for (const node of nodes) {
-            if (node.node) {
-                if (typescript_1.default.isImportDeclaration(node.node)) {
-                    let transformed = (0, ast_1.transformImport)(contents, node.node, sourceFile, {
-                        newImports: ["PrivacyPolicy"],
-                    });
-                    if (transformed) {
-                        newContents += transformed;
-                        continue;
-                    }
-                }
-                newContents += node.node.getFullText(sourceFile);
-            }
-            else if (node.rawString) {
-                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/*.ts --write");
-}
-function isPrivacyPolicy(mm) {
-    return (mm.kind === typescript_1.default.SyntaxKind.PropertyDeclaration &&
-        mm.name.escapedText === "privacyPolicy");
-}
-main()
-    .then(() => {
-    process.exit(0);
-})
-    .catch((err) => {
-    console.error(err);
-    process.exit(1);
-});