@snowtop/ent 0.1.0-alpha → 0.1.0-alpha6

package/scripts/transform_schema.js

@@ -0,0 +1,288 @@
+"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 fs = __importStar(require("fs"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
+const child_process_1 = require("child_process");
+function getTarget(target) {
+    switch (target.toLowerCase()) {
+        case "es2015":
+            return typescript_1.default.ScriptTarget.ES2015;
+        case "es2016":
+            return typescript_1.default.ScriptTarget.ES2016;
+        case "es2017":
+            return typescript_1.default.ScriptTarget.ES2017;
+        case "es2018":
+            return typescript_1.default.ScriptTarget.ES2018;
+        case "es2019":
+            return typescript_1.default.ScriptTarget.ES2019;
+        case "es2020":
+            return typescript_1.default.ScriptTarget.ES2020;
+        case "es2021":
+            return typescript_1.default.ScriptTarget.ES2021;
+        case "es3":
+            return typescript_1.default.ScriptTarget.ES3;
+        case "es5":
+            return typescript_1.default.ScriptTarget.ES5;
+        case "esnext":
+            return typescript_1.default.ScriptTarget.ESNext;
+        default:
+            return typescript_1.default.ScriptTarget.ESNext;
+    }
+}
+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 = options.target
+        ? // @ts-ignore
+            getTarget(options.target)
+        : typescript_1.default.ScriptTarget.ESNext;
+    // 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";
+        let contents = fs.readFileSync(file).toString();
+        // go through the file and print everything back if not starting immediately after other position
+        const sourceFile = typescript_1.default.createSourceFile(file, contents, target, false, typescript_1.default.ScriptKind.TS);
+        const nodes = [];
+        let updateImport = false;
+        const f = {
+            trackNode: function (tni) {
+                nodes.push({
+                    node: tni.node,
+                    importNode: tni.node && typescript_1.default.isImportDeclaration(tni.node),
+                    rawString: tni.rawString,
+                });
+            },
+            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 = transformImport(importNode, sourceFile);
+                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);
+    });
+    (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;
+}
+// TODO need to replace class field member, print that and see what happens
+function traverseClass(fileContents, sourceFile, node, f) {
+    let updated = false;
+    // beginning of class...
+    // including comment
+    let klassContents = fileContents.substring(node.getFullStart(), node.members[0].getFullStart());
+    for (let member of node.members) {
+        if (!isFieldElement(member, sourceFile)) {
+            klassContents += member.getFullText(sourceFile);
+            continue;
+        }
+        // intentionally doesn't parse decorators since we don't need it
+        let fieldMap = "";
+        // fieldMapComment...
+        const comment = getPreText(fileContents, member, sourceFile);
+        if (comment) {
+            fieldMap += comment;
+        }
+        updated = true;
+        // need to change to fields: FieldMap = {code: StringType()};
+        const property = member;
+        const initializer = property.initializer;
+        fieldMap += "fields: FieldMap = {";
+        for (const element of initializer.elements) {
+            const parsed = parseFieldElement(element, sourceFile, fileContents);
+            if (parsed === null) {
+                return false;
+            }
+            const { callEx, name, nameComment, properties } = parsed;
+            let property = "";
+            const fieldComment = getPreText(fileContents, element, sourceFile).trim();
+            if (fieldComment) {
+                property += "\n" + fieldComment + "\n";
+            }
+            if (nameComment) {
+                property += nameComment + "\n";
+            }
+            // e.g. UUIDType, StringType etc
+            let call = callEx.expression.getText(sourceFile);
+            let fnCall = "";
+            if (properties.length) {
+                fnCall = `{${properties.join(",")}}`;
+            }
+            property += `${name}:${call}(${fnCall}),`;
+            fieldMap += property;
+        }
+        fieldMap += "}";
+        klassContents += fieldMap;
+    }
+    klassContents += "\n}";
+    //  console.debug(klassContents);
+    if (!updated) {
+        return updated;
+    }
+    f.trackNode({ rawString: klassContents });
+    return updated;
+}
+function isFieldElement(member, sourceFile) {
+    if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return false;
+    }
+    const property = member;
+    const token = property.name;
+    if (token.escapedText !== "fields") {
+        return false;
+    }
+    const propertytype = property.type?.getText(sourceFile);
+    if (propertytype !== "Field[]") {
+        return false;
+    }
+    if (property.initializer?.kind !== typescript_1.default.SyntaxKind.ArrayLiteralExpression) {
+        console.error("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");
+        return null;
+    }
+    let callEx = element;
+    if (callEx.arguments.length !== 1) {
+        console.error("callExpression with arguments not of length 1");
+        return null;
+    }
+    let arg = callEx.arguments[0];
+    if (arg.kind !== typescript_1.default.SyntaxKind.ObjectLiteralExpression) {
+        console.error("not objectLiteralExpression");
+        return null;
+    }
+    let expr = arg;
+    let name = "";
+    let propertyComment;
+    let properties = [];
+    for (const p of expr.properties) {
+        const p2 = p;
+        // found name property
+        if (p2.name.escapedText === "name") {
+            name = p2.initializer.getText(sourceFile);
+            // check for any comment associated with name: "fooo"
+            propertyComment = getPreText(fileContents, p, sourceFile).trim();
+        }
+        else {
+            properties.push(p.getFullText(sourceFile));
+        }
+    }
+    if (!name) {
+        console.error(`couldn't find name property`);
+        return null;
+    }
+    // remove quotes
+    name = name.slice(1, -1);
+    return {
+        callEx,
+        name,
+        properties,
+        nameComment: propertyComment,
+    };
+}
+function transformImport(importNode, sourceFile) {
+    // 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;
+    }
+    const importText = importNode.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    if (start === -1 || end === -1) {
+        return;
+    }
+    const imports = importText
+        .substring(start + 1, end)
+        //    .trim()
+        .split(",");
+    for (let i = 0; i < imports.length; i++) {
+        const imp = imports[i].trim();
+        if (imp === "Field") {
+            imports[i] = "FieldMap";
+        }
+    }
+    // TODO better to update node instead of doing this but this works for now
+    return ("import " +
+        importText.substring(0, start + 1) +
+        imports.join(", ") +
+        importText.substring(end) +
+        ' from "' +
+        text +
+        '"');
+}
+function getPreText(fileContents, node, sourceFile) {
+    return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
+}
+Promise.resolve(main());

package/testutils/db/test_db.js

@@ -479,8 +479,8 @@ exports.setupSqlite = setupSqlite;
 function getSchemaTable(schema, dialect) {
     const fields = (0, schema_1.getFields)(schema);
     const columns = [];
-    for (const [_, field] of fields) {
-        columns.push(getColumnFromField(field, dialect));
+    for (const [fieldName, field] of fields) {
+        columns.push(getColumnFromField(fieldName, field, dialect));
     }
     return table((0, builder_1.getTableName)(schema), ...columns);
 }
@@ -520,7 +520,7 @@ function getColumnForDbType(t, dialect) {
             return undefined;
     }
 }
-function getColumnFromField(f, dialect) {
+function getColumnFromField(fieldName, f, dialect) {
     switch (f.type.dbType) {
         case schema_1.DBType.List:
             const elemType = f.type.listElemType;
@@ -531,17 +531,17 @@ function getColumnFromField(f, dialect) {
             if (elemFn === undefined) {
                 throw new Error(`unsupported type for ${elemType}`);
             }
-            return list(storageKey(f), elemFn("ignore"), buildOpts(f));
+            return list(storageKey(fieldName, f), elemFn("ignore"), buildOpts(f));
         default:
             const fn = getColumnForDbType(f.type.dbType, dialect);
             if (fn === undefined) {
                 throw new Error(`unsupported type ${f.type.dbType}`);
             }
-            return getColumn(f, fn);
+            return getColumn(fieldName, f, fn);
     }
 }
-function getColumn(f, col) {
-    return col(storageKey(f), buildOpts(f));
+function getColumn(fieldName, f, col) {
+    return col(storageKey(fieldName, f), buildOpts(f));
 }
 function buildOpts(f) {
     let ret = {};
@@ -560,11 +560,11 @@ function buildOpts(f) {
     }
     return ret;
 }
-function storageKey(f) {
+function storageKey(fieldName, f) {
     if (f.storageKey) {
         return f.storageKey;
     }
-    return (0, snake_case_1.snakeCase)(f.name);
+    return (0, snake_case_1.snakeCase)(fieldName);
 }
 function isSyncClient(client) {
     return client.execSync !== undefined;

package/testutils/fake_data/fake_contact.d.ts

@@ -1,6 +1,6 @@
 import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
 import { BuilderSchema, SimpleBuilder } from "../builder";
-import { Field, BaseEntSchema } from "../../schema";
+import { BaseEntSchema, FieldMap } from "../../schema";
 import { NodeType } from "./const";
 import { ObjectLoaderFactory } from "../../core/loaders";
 export declare class FakeContact implements Ent {
@@ -24,7 +24,7 @@ export declare class FakeContact implements Ent {
 }
 export declare class FakeContactSchema extends BaseEntSchema implements BuilderSchema<FakeContact> {
     ent: typeof FakeContact;
-    fields: Field[];
+    fields: FieldMap;
 }
 export interface ContactCreateInput {
     firstName: string;

package/testutils/fake_data/fake_contact.js

@@ -63,21 +63,14 @@ class FakeContactSchema extends schema_1.BaseEntSchema {
     constructor() {
         super(...arguments);
         this.ent = FakeContact;
-        this.fields = [
-            (0, schema_1.StringType)({
-                name: "firstName",
-            }),
-            (0, schema_1.StringType)({
-                name: "lastName",
-            }),
-            (0, schema_1.StringType)({
-                name: "emailAddress",
-            }),
-            (0, schema_1.UUIDType)({
-                name: "userID",
+        this.fields = {
+            firstName: (0, schema_1.StringType)(),
+            lastName: (0, schema_1.StringType)(),
+            emailAddress: (0, schema_1.StringType)(),
+            userID: (0, schema_1.UUIDType)({
                 foreignKey: { schema: "User", column: "ID" },
             }),
-        ];
+        };
     }
 }
 exports.FakeContactSchema = FakeContactSchema;

package/testutils/fake_data/fake_event.d.ts

@@ -1,6 +1,6 @@
 import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
 import { BuilderSchema, SimpleBuilder } from "../builder";
-import { Field, BaseEntSchema } from "../../schema";
+import { BaseEntSchema, FieldMap } from "../../schema";
 import { NodeType } from "./const";
 export declare class FakeEvent implements Ent {
     viewer: Viewer;
@@ -25,7 +25,7 @@ export declare class FakeEvent implements Ent {
 }
 export declare class FakeEventSchema extends BaseEntSchema implements BuilderSchema<FakeEvent> {
     ent: typeof FakeEvent;
-    fields: Field[];
+    fields: FieldMap;
 }
 export interface EventCreateInput {
     startTime: Date;

package/testutils/fake_data/fake_event.js

@@ -67,30 +67,22 @@ class FakeEventSchema extends schema_1.BaseEntSchema {
     constructor() {
         super(...arguments);
         this.ent = FakeEvent;
-        this.fields = [
-            (0, schema_1.TimestampType)({
-                name: "startTime",
+        this.fields = {
+            startTime: (0, schema_1.TimestampType)({
                 index: true,
             }),
-            (0, schema_1.TimestampType)({
-                name: "endTime",
+            endTime: (0, schema_1.TimestampType)({
                 nullable: true,
             }),
-            (0, schema_1.StringType)({
-                name: "title",
-            }),
-            (0, schema_1.StringType)({
-                name: "location",
-            }),
-            (0, schema_1.StringType)({
-                name: "description",
+            title: (0, schema_1.StringType)(),
+            location: (0, schema_1.StringType)(),
+            description: (0, schema_1.StringType)({
                 nullable: true,
             }),
-            (0, schema_1.UUIDType)({
-                name: "userID",
+            userID: (0, schema_1.UUIDType)({
                 foreignKey: { schema: "User", column: "ID" },
             }),
-        ];
+        };
     }
 }
 exports.FakeEventSchema = FakeEventSchema;

package/testutils/fake_data/fake_user.d.ts

@@ -1,6 +1,6 @@
 import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
 import { BuilderSchema, SimpleAction } from "../builder";
-import { Field, BaseEntSchema } from "../../schema";
+import { BaseEntSchema, FieldMap } from "../../schema";
 import { NodeType } from "./const";
 import { IDViewer, IDViewerOptions } from "../../core/viewer";
 import { ObjectLoaderFactory } from "../../core/loaders";
@@ -34,7 +34,7 @@ export declare class FakeUser implements Ent {
 }
 export declare class FakeUserSchema extends BaseEntSchema implements BuilderSchema<FakeUser> {
     ent: typeof FakeUser;
-    fields: Field[];
+    fields: FieldMap;
 }
 export interface UserCreateInput {
     firstName: string;

package/testutils/fake_data/fake_user.js

@@ -93,24 +93,15 @@ class FakeUserSchema extends schema_1.BaseEntSchema {
     constructor() {
         super(...arguments);
         this.ent = FakeUser;
-        this.fields = [
-            (0, schema_1.StringType)({
-                name: "firstName",
-            }),
-            (0, schema_1.StringType)({
-                name: "lastName",
-            }),
-            (0, schema_1.StringType)({
-                name: "emailAddress",
-            }),
-            (0, schema_1.StringType)({
-                name: "phoneNumber",
-            }),
-            (0, schema_1.StringType)({
-                name: "password",
+        this.fields = {
+            firstName: (0, schema_1.StringType)(),
+            lastName: (0, schema_1.StringType)(),
+            emailAddress: (0, schema_1.StringType)(),
+            phoneNumber: (0, schema_1.StringType)(),
+            password: (0, schema_1.StringType)({
                 nullable: true,
             }),
-        ];
+        };
     }
 }
 exports.FakeUserSchema = FakeUserSchema;

package/tsc/compilerOptions.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function readCompilerOptions(filePath: string): ts.CompilerOptions;

package/tsc/compilerOptions.js

@@ -0,0 +1,61 @@
+"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 });
+exports.readCompilerOptions = void 0;
+const fs = __importStar(require("fs"));
+const json5_1 = __importDefault(require("json5"));
+const typescript_1 = __importDefault(require("typescript"));
+const path = __importStar(require("path"));
+function findTSConfigFile(filePath) {
+    while (filePath != "/") {
+        let configPath = `${filePath}/tsconfig.json`;
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+        filePath = path.join(filePath, "..");
+    }
+    return null;
+}
+function readCompilerOptions(filePath) {
+    let configPath = findTSConfigFile(filePath);
+    if (!configPath) {
+        return {};
+    }
+    let json = {};
+    try {
+        json = json5_1.default.parse(fs.readFileSync(configPath, {
+            encoding: "utf8",
+        }));
+    }
+    catch (e) {
+        console.error("couldn't read tsconfig.json file");
+    }
+    let options = json["compilerOptions"] || {};
+    // @ts-ignore
+    if (options.moduleResolution === "node") {
+        options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
+    }
+    return options;
+}
+exports.readCompilerOptions = readCompilerOptions;