@snowtop/ent 0.1.0-alpha → 0.1.0-alpha12

package/scripts/transform_code.js

@@ -0,0 +1,113 @@
+"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() {
+    let files = glob_1.glob.sync("src/ent/*.ts");
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    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);
+});

package/scripts/transform_schema.d.ts

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

package/scripts/transform_schema.js

@@ -0,0 +1,355 @@
+"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");
+const path_1 = __importDefault(require("path"));
+const ast_1 = require("../tsc/ast");
+async function main() {
+    let files = glob_1.glob.sync("src/schema/*.ts");
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    // 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);
+    if (!ci) {
+        return false;
+    }
+    let klassContents = `${ci.comment}const ${ci.name} = new ${ci.class}({\n`;
+    let removeImports = [];
+    if (ci.implementsSchema) {
+        removeImports.push("Schema");
+    }
+    for (let member of node.members) {
+        const fInfo = getClassElementInfo(fileContents, member, sourceFile);
+        if (!fInfo) {
+            return false;
+        }
+        klassContents += `${fInfo.comment}${fInfo.key}:${fInfo.value},\n`;
+        if (fInfo.type) {
+            removeImports.push(fInfo.type);
+        }
+    }
+    klassContents += "\n})";
+    if (ci.export && ci.default) {
+        klassContents += `\n export default ${ci.name};`;
+    }
+    else if (ci.export) {
+        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;
+}
+// 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) {
+    const generic = (0, ast_1.getClassInfo)(fileContents, sourceFile, node);
+    if (!generic) {
+        return;
+    }
+    let className = generic.name;
+    if (!className?.endsWith("Schema")) {
+        className += "Schema";
+    }
+    let implementsSchema = generic.implements?.some((v) => v == "Schema");
+    let classExtends = generic.extends;
+    if (classExtends && classExtends === transformSchema(classExtends)) {
+        return undefined;
+    }
+    if (!className || !node.heritageClauses || !classExtends) {
+        return undefined;
+    }
+    let ci = {
+        ...generic,
+        name: className,
+        class: classExtends,
+        implementsSchema,
+    };
+    return ci;
+}
+// intentionally doesn't parse decorators since we don't need it
+function getClassElementInfo(fileContents, member, sourceFile) {
+    if (isFieldElement(member, sourceFile)) {
+        return getFieldElementInfo(fileContents, member, sourceFile);
+    }
+    if (member.kind === typescript_1.default.SyntaxKind.Constructor) {
+        return getConstructorElementInfo(fileContents, member, sourceFile);
+    }
+    if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return;
+    }
+    // other properties
+    const property = member;
+    if (!property.initializer) {
+        return;
+    }
+    const token = property.name;
+    return {
+        key: token.escapedText.toString(),
+        value: property.initializer?.getFullText(sourceFile),
+        comment: (0, ast_1.getPreText)(fileContents, member, sourceFile),
+        type: getType(property, sourceFile),
+    };
+}
+function getType(property, sourceFile) {
+    let propertytype = property.type?.getText(sourceFile) || "";
+    let ends = ["| null", "[]"];
+    for (const end of ends) {
+        if (propertytype.endsWith(end)) {
+            propertytype = propertytype.slice(0, -1 * end.length);
+        }
+    }
+    return propertytype;
+}
+function getFieldElementInfo(fileContents, member, sourceFile) {
+    let fieldMap = "";
+    // need to change to fields: {code: StringType()};
+    const property = member;
+    const initializer = property.initializer;
+    fieldMap += "{";
+    for (const element of initializer.elements) {
+        const parsed = parseFieldElement(element, sourceFile, fileContents);
+        if (parsed === null) {
+            return;
+        }
+        const { callEx, name, nameComment, properties } = parsed;
+        let property = "";
+        const fieldComment = (0, ast_1.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 += "}";
+    return {
+        key: "fields",
+        value: fieldMap,
+        comment: (0, ast_1.getPreText)(fileContents, member, sourceFile),
+        type: getType(property, sourceFile),
+    };
+}
+function getConstructorElementInfo(fileContents, member, sourceFile) {
+    const c = member;
+    //remove {}
+    let fullText = c.body?.getFullText(sourceFile) || "";
+    fullText = fullText.trim().slice(1, -1).trim();
+    // convert something like
+    /*
+    constructor() {
+      super();
+      this.addPatterns(
+        new Feedback(),
+        new DayOfWeek(),
+        new Feedback(),
+        new DayOfWeek(),
+      );
+    }
+      */
+    // into this.addPatterns(new Feedback(),new DayOfWeek(),new Feedback(),new DayOfWeek(),)
+    const lines = fullText
+        .split("\n")
+        .map((line) => line.trim())
+        .join("")
+        .split(";")
+        .filter((f) => f != "super()" && f != "");
+    // at this point there should be only line for what we handle
+    if (lines.length != 1) {
+        return;
+    }
+    const line = lines[0];
+    const addPatterns = "this.addPatterns(";
+    if (!line.startsWith(addPatterns)) {
+        return;
+    }
+    return {
+        key: "patterns",
+        // remove this.addPatterns at the front, remove trailing ) at the end
+        // if there's a trailing comma, it'll be handled by prettier
+        value: `[${line.slice(addPatterns.length, -1)}]`,
+        comment: "",
+    };
+}
+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 = (0, ast_1.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,
+    };
+}
+Promise.resolve(main());

package/testutils/builder.d.ts

@@ -1,14 +1,16 @@
-import { Ent, ID, Viewer, Data, EntConstructor } from "../core/base";
+import { Ent, ID, Viewer, Data, EntConstructor, PrivacyPolicy } from "../core/base";
 import { Orchestrator } from "../action/orchestrator";
 import { Action, Builder, Changeset, WriteOperation, Validator, Trigger, Observer } from "../action";
-import { Schema } from "../schema";
+import { FieldMap, Schema } from "../schema";
+import { SchemaConfig } from "../schema/base_schema";
+import { FieldInfoMap } from "../schema/schema";
 export declare class User implements Ent {
     viewer: Viewer;
     data: Data;
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<this>;
     firstName: string;
     constructor(viewer: Viewer, data: Data);
 }
@@ -18,7 +20,7 @@ export declare class Event implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<this>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Contact implements Ent {
@@ -27,7 +29,7 @@ export declare class Contact implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<this>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Group implements Ent {
@@ -36,7 +38,7 @@ export declare class Group implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<this>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Message implements Ent {
@@ -45,7 +47,7 @@ export declare class Message implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<this>;
     constructor(viewer: Viewer, data: Data);
 }
 export declare class Address implements Ent {
@@ -54,14 +56,18 @@ export declare class Address implements Ent {
     id: ID;
     accountID: string;
     nodeType: string;
-    privacyPolicy: import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<this>;
     constructor(viewer: Viewer, data: Data);
 }
 export interface BuilderSchema<T extends Ent> extends Schema {
     ent: EntConstructor<T>;
 }
+export declare function getBuilderSchema<T extends Ent>(cfg: SchemaConfig, ent: EntConstructor<T>): BuilderSchema<T>;
+export declare function getBuilderSchemaFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
+export declare function getBuilderSchemaTZFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
 export declare function getSchemaName(value: BuilderSchema<Ent>): string;
 export declare function getTableName(value: BuilderSchema<Ent>): string;
+export declare function getFieldInfo(value: BuilderSchema<Ent>): FieldInfoMap;
 export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     viewer: Viewer;
     private schema;
@@ -73,6 +79,7 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     fields: Map<string, any>;
     nodeType: string;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T, SimpleBuilder<T>, Data> | undefined);
+    updateInput(input: Data): void;
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
@@ -93,7 +100,7 @@ export declare class SimpleAction<T extends Ent> implements Action<T, SimpleBuil
     observers: Observer<SimpleBuilder<T>, Data>[];
     viewerForEntLoad: viewerEntLoadFunc | undefined;
     constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined);
-    getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent>;
+    getPrivacyPolicy(): PrivacyPolicy<Ent>;
     getInput(): Data;
     changeset(): Promise<Changeset<T>>;
     valid(): Promise<boolean>;