@snowtop/ent 0.1.0-alpha93 → 0.1.0-alpha94

package/core/ent.js

@@ -887,6 +887,7 @@ class EdgeOperation {
                 tableName: params.options.tableName,
                 whereClause: params.clause,
                 fields: params.updateData,
+                fieldsToLog: params.updateData,
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha93",
+  "version": "0.1.0-alpha94",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,6 +10,7 @@
   "dependencies": {
     "@types/node": "^15.0.2",
     "camel-case": "^4.1.2",
+    "cosmiconfig": "^7.0.1",
     "dataloader": "^2.0.0",
     "glob": "^7.1.6",
     "graph-data-structure": "^1.12.0",

package/parse_schema/parse.d.ts

@@ -63,11 +63,22 @@ interface Result {
     schemas: schemasDict;
     patterns: patternsDict;
     globalSchema?: ProcessedGlobalSchema;
+    config?: {
+        rome?: RomeConfig;
+    };
 }
 declare type PotentialSchemas = {
     [key: string]: any;
 };
 export declare function parseSchema(potentialSchemas: PotentialSchemas, globalSchema?: GlobalSchema): Promise<Result>;
+interface RomeConfig {
+    indentStyle?: string;
+    lineWidth?: number;
+    indentSize?: number;
+    quoteStyle?: string;
+    quoteProperties?: string;
+    trailingComma?: string;
+}
 interface ProcessedGlobalSchema {
     globalEdges: ProcessedAssocEdge[];
     extraEdgeFields: ProcessedField[];

package/parse_schema/parse.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
+const cosmiconfig_1 = require("cosmiconfig");
 async function processFields(src, patternName) {
     const ret = [];
     let m = {};
@@ -274,9 +275,55 @@ async function parseSchema(potentialSchemas, globalSchema) {
         }
         schemas[key] = processedSchema;
     }
-    return { schemas, patterns, globalSchema: parsedGlobalSchema };
+    const rome = translatePrettier();
+    return {
+        schemas,
+        patterns,
+        globalSchema: parsedGlobalSchema,
+        config: {
+            rome,
+        },
+    };
 }
 exports.parseSchema = parseSchema;
+function translatePrettier() {
+    const r = (0, cosmiconfig_1.cosmiconfigSync)("prettier").search();
+    if (!r) {
+        return;
+    }
+    const ret = {};
+    if (r.config.printWidth !== undefined) {
+        ret.lineWidth = parseInt(r.config.printWidth);
+    }
+    if (r.config.useTabs) {
+        ret.indentStyle = "tab";
+    }
+    else {
+        ret.indentStyle = "space";
+    }
+    if (r.config.tabWidth !== undefined) {
+        ret.indentSize = parseInt(r.config.tabWidth);
+    }
+    if (r.config.singleQuote) {
+        ret.quoteStyle = "single";
+    }
+    else {
+        ret.quoteStyle = "double";
+    }
+    if (r.config.quoteProps !== undefined) {
+        if (r.config.quoteProps === "consistent") {
+            // rome doesn't support this
+            ret.quoteProperties = "as-needed";
+        }
+        else {
+            ret.quoteProperties = r.config.quoteProps;
+        }
+    }
+    if (r.config.trailingComma !== undefined) {
+        ret.trailingComma = r.config.trailingComma;
+    }
+    return ret;
+}
 async function parseGlobalSchema(s) {
     const ret = {
         globalEdges: [],

package/scripts/move_types.d.ts

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

package/scripts/move_types.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+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 transform_1 = require("../tsc/transform");
+const ast_1 = require("../tsc/ast");
+const typescript_1 = __importStar(require("typescript"));
+const path_1 = __importDefault(require("path"));
+class GatherExportsInGeneratedTypes {
+    constructor() {
+        this.glob = "src/ent/generated/types.ts";
+        this.names = [];
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        const exported = node.modifiers?.filter((mod) => mod.getText(sourceFile) === "export");
+        if (exported?.length) {
+            if (typescript_1.default.isEnumDeclaration(node) ||
+                typescript_1.default.isInterfaceDeclaration(node) ||
+                typescript_1.default.isTypeAliasDeclaration(node)) {
+                this.names.push(node.name.text);
+            }
+            if (typescript_1.default.isFunctionDeclaration(node) && node.name?.text) {
+                this.names.push(node.name.text);
+            }
+        }
+        return { node };
+    }
+}
+class TransformImports {
+    constructor() {
+        this.glob = "src/**/*.ts";
+        this.prettierGlob = "src/**/*.ts";
+        this.impsToMove = new Map();
+        this.cwd = "";
+        this.relative = false;
+        this.cwd = process.cwd();
+        const gt = new GatherExportsInGeneratedTypes();
+        (0, transform_1.transform)(gt);
+        gt.names.forEach((v) => this.impsToMove.set(v, true));
+        this.relative = (0, ast_1.getCustomInfo)().relativeImports ?? this.relative;
+    }
+    getSrcPath(file, text) {
+        if (text.startsWith("src")) {
+            return text;
+        }
+        const dir = path_1.default.dirname(path_1.default.join(this.cwd, file));
+        const fullPath = path_1.default.join(dir, text);
+        return path_1.default.relative(this.cwd, fullPath);
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!(0, typescript_1.isImportDeclaration)(node)) {
+            return { node };
+        }
+        const impInfo = (0, ast_1.getImportInfo)(node, sourceFile);
+        if (!impInfo) {
+            return { node };
+        }
+        const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        const pathToWrite = (0, ast_1.transformRelative)(file, "src/ent/generated/types", this.relative);
+        const current = (0, ast_1.transformRelative)(file, text, this.relative);
+        const srcPath = this.getSrcPath(file, text);
+        // nothing to do here
+        if (!srcPath.startsWith("src/ent") || pathToWrite === current) {
+            return { node };
+        }
+        // let's see if we can simplify
+        let seenImports = [];
+        for (let imp of impInfo.imports) {
+            imp = imp.trim();
+            if (this.impsToMove.has(imp)) {
+                seenImports.push(imp);
+            }
+        }
+        if (!seenImports.length) {
+            return { node };
+        }
+        let imports = new Map([[pathToWrite, seenImports]]);
+        return {
+            rawString: (0, ast_1.transformImport)(contents, node, sourceFile, {
+                removeImports: seenImports,
+                transformPath: text,
+            }),
+            traversed: true,
+            imports,
+            allowSeenImportsAdded: true,
+        };
+    }
+}
+//  ts-node-script --swc --project ./tsconfig.json -r tsconfig-paths/register ../../ts/src/scripts/move_types.ts
+function main() {
+    (0, transform_1.transform)(new TransformImports());
+}
+main();

package/tsc/ast.js

@@ -142,6 +142,9 @@ function transformImport(fileContents, importNode, sourceFile, opts) {
         opts.newImports.forEach((imp) => finalImports.add(imp));
     }
     const comment = getPreText(fileContents, importNode, sourceFile);
+    if (!finalImports.size) {
+        return;
+    }
     return (comment +
         "import " +
         // add default
@@ -239,6 +242,9 @@ function normalizePath(p) {
     if (p.endsWith("..")) {
         return p + "/";
     }
+    if (!p.startsWith("..")) {
+        return "./" + p;
+    }
     return p;
 }
 // also used in parse schema logic

package/tsc/transform.d.ts

@@ -6,6 +6,7 @@ interface TraverseChildResponse {
     traversed?: boolean;
     imports?: Map<string, string[]>;
     removeImports?: string[];
+    allowSeenImportsAdded?: boolean;
 }
 export interface TransformFile {
     glob: string;

package/tsc/transform.js

@@ -51,6 +51,7 @@ function transform(transform) {
         let imports = new Map();
         let removeImports = [];
         let traversed = false;
+        let allowSeenImportsAdded = false;
         let seenImports = new Map();
         typescript_1.default.forEachChild(sourceFile, function (node) {
             if (typescript_1.default.isImportDeclaration(node)) {
@@ -80,6 +81,9 @@ function transform(transform) {
             if (ret.removeImports?.length) {
                 removeImports.push(...ret.removeImports);
             }
+            if (ret.allowSeenImportsAdded) {
+                allowSeenImportsAdded = ret.allowSeenImportsAdded;
+            }
         });
         if (!traversed) {
             return;
@@ -91,14 +95,20 @@ function transform(transform) {
             // 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
+            // TODO account for placement after first comment
             if (!afterProcessed) {
                 for (const [imp, list] of imports) {
                     if (seen.has(imp)) {
                         continue;
                     }
-                    const final = list.filter((v) => !seenImports.has(v));
+                    // this says only add things you haven't seen
+                    // we want to add something we've seen in this case
+                    let final = list;
+                    if (!allowSeenImportsAdded) {
+                        final = list.filter((v) => !seenImports.has(v));
+                    }
                     if (final.length) {
-                        newContents += `\nimport { ${final.join(", ")} } from "${imp}"`;
+                        newContents += `\nimport { ${final.join(", ")} } from "${imp}";\n`;
                     }
                 }
                 afterProcessed = true;