@snowtop/ent 0.1.0-alpha → 0.1.0-alpha12

package/schema/struct_field.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructListType = exports.StructType = exports.StructField = void 0;
+const field_1 = require("./field");
+const schema_1 = require("./schema");
+const camel_case_1 = require("camel-case");
+class StructField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.type.subFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    // right now, we store things in the db in lowerCase format
+    // this will lead to issues if field changes.
+    // TODO: use storageKey and convert back...
+    format(obj, nested) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        let ret = {};
+        for (const k in this.options.fields) {
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined) {
+                continue;
+            }
+            const field = this.options.fields[k];
+            if (field.format) {
+                // indicate nested so this isn't JSON stringified
+                ret[dbKey] = field.format(val, true);
+            }
+            else {
+                ret[dbKey] = val;
+            }
+        }
+        // don't json.stringify if nested
+        if (nested) {
+            return ret;
+        }
+        return JSON.stringify(ret);
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        // TODO probably need to support optional fields...
+        let valid = true;
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined || val === null) {
+                // nullable, nothing to do here
+                if (field.nullable) {
+                    continue;
+                }
+                valid = false;
+                break;
+            }
+            if (!field.valid) {
+                continue;
+            }
+            promises.push(field.valid(val));
+        }
+        if (!valid) {
+            return valid;
+        }
+        const ret = await Promise.all(promises);
+        return ret.every((v) => v);
+    }
+}
+exports.StructField = StructField;
+function StructType(options) {
+    let result = new StructField(options);
+    return Object.assign(result, options);
+}
+exports.StructType = StructType;
+function StructListType(options) {
+    return new field_1.ListField(StructType(options), options);
+}
+exports.StructListType = StructListType;

package/schema/union_field.d.ts

@@ -0,0 +1,23 @@
+import { StructField } from "./struct_field";
+import { FieldOptions, Type } from "./schema";
+import { BaseField, ListField } from "./field";
+export declare type StructMap = {
+    [key: string]: StructField;
+};
+export interface UnionOptions extends FieldOptions {
+    tsType: string;
+    fields: StructMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class UnionField extends BaseField implements FieldOptions {
+    private options;
+    type: Type;
+    m: Map<Object, string>;
+    constructor(options: UnionOptions);
+    format(obj: any): string | Object;
+    private validField;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function UnionType(options: UnionOptions): UnionField & UnionOptions;
+export declare function UnionListType(options: UnionOptions): ListField;

package/schema/union_field.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionListType = exports.UnionType = exports.UnionField = void 0;
+const schema_1 = require("./schema");
+const field_1 = require("./field");
+// used to know which key in the union is valid.
+// maybe there's a better way of doing this eventually
+const KEY = "___valid___key___";
+class UnionField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.m = new Map();
+        this.type.unionFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        // TODO should throw if not nested?
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    format(obj) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        const k = obj[KEY];
+        if (k === undefined) {
+            throw new Error(`need to call valid first`);
+        }
+        // now delete it since we don't need it anymore
+        delete obj[KEY];
+        const field = this.options.fields[k];
+        // always nested for now so pass through
+        return field.format(obj, true);
+    }
+    async validField(k, f, obj) {
+        const valid = await f.valid(obj);
+        return {
+            valid,
+            key: k,
+        };
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            promises.push(this.validField(k, field, obj));
+        }
+        let lastKey;
+        let validCt = 0;
+        const ret = await Promise.all(promises);
+        for (const v of ret) {
+            if (v.valid) {
+                validCt++;
+                lastKey = v.key;
+            }
+        }
+        if (lastKey !== undefined) {
+            obj[KEY] = lastKey;
+        }
+        return validCt == 1;
+    }
+}
+exports.UnionField = UnionField;
+function UnionType(options) {
+    let result = new UnionField(options);
+    return Object.assign(result, options);
+}
+exports.UnionType = UnionType;
+function UnionListType(options) {
+    return new field_1.ListField(UnionType(options), options);
+}
+exports.UnionListType = UnionListType;

package/scripts/custom_compiler.js

@@ -25,9 +25,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const typescript_1 = __importDefault(require("typescript"));
 const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const json5_1 = __importDefault(require("json5"));
 const glob_1 = __importDefault(require("glob"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
 // TODO this should probably be its own package but for now it's here
 class Compiler {
     constructor(sourceFiles, moduleSearchLocations) {
@@ -35,7 +34,7 @@ class Compiler {
         this.moduleSearchLocations = moduleSearchLocations;
         this.regexMap = new Map();
         this.resolvers = [];
-        this.options = this.readCompilerOptions();
+        this.options = (0, compilerOptions_1.readCompilerOptions)(".");
         if (this.options.paths) {
             for (let key in this.options.paths) {
                 if (key === "*") {
@@ -105,22 +104,6 @@ class Compiler {
         }
         return undefined;
     }
-    readCompilerOptions() {
-        let json = {};
-        try {
-            json = json5_1.default.parse(fs.readFileSync("./tsconfig.json", {
-                encoding: "utf8",
-            }));
-        }
-        catch (e) {
-            console.error("couldn't read tsconfig.json file");
-        }
-        let options = json["compilerOptions"] || {};
-        if (options.moduleResolution === "node") {
-            options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
-        }
-        return options;
-    }
     createCompilerHost() {
         return {
             getSourceFile: this.getSourceFile,

package/scripts/custom_graphql.js

@@ -24,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const glob_1 = __importDefault(require("glob"));
+const json5_1 = __importDefault(require("json5"));
 const minimist_1 = __importDefault(require("minimist"));
 const graphql_1 = require("../graphql/graphql");
 const readline = __importStar(require("readline"));
@@ -53,7 +54,103 @@ async function readInputs() {
         });
     });
 }
-async function captureCustom(filePath, filesCsv) {
+function processCustomObjects(l, gqlCapture, input) {
+    let m;
+    if (input) {
+        m = gqlCapture.getCustomInputObjects();
+    }
+    else {
+        m = gqlCapture.getCustomObjects();
+    }
+    for (const input of l) {
+        m.set(input.name, {
+            nodeName: input.graphQLName || input.name,
+            className: input.name,
+        });
+        if (input.fields) {
+            processCustomFields(input.fields, gqlCapture, input.name);
+        }
+    }
+}
+function transformArgs(f) {
+    return (f.args || []).map((v) => {
+        const ret = {
+            ...v,
+        };
+        // duplicated from getType in graphql.ts
+        if ((0, graphql_1.isCustomType)(ret.type)) {
+            ret.type = v.type.type;
+            (0, graphql_1.addCustomType)(v.type);
+        }
+        // scalar types not supported for now
+        ret.tsType = graphql_1.knownAllowedNames.get(v.type);
+        return ret;
+    });
+}
+function transformResultType(f) {
+    return f.resultType
+        ? [
+            {
+                name: "",
+                type: f.resultType,
+                tsType: graphql_1.knownAllowedNames.get(f.resultType),
+                list: f.list,
+                nullable: f.nullable,
+            },
+        ]
+        : [];
+}
+function processTopLevel(l, l2) {
+    for (const custom of l) {
+        l2.push({
+            nodeName: custom.class,
+            functionName: custom.functionName || custom.name,
+            gqlName: custom.graphQLName || custom.name,
+            fieldType: custom.fieldType,
+            args: transformArgs(custom),
+            results: transformResultType(custom),
+        });
+    }
+}
+function processCustomFields(fields, gqlCapture, nodeName) {
+    const m = gqlCapture.getCustomFields();
+    let results = [];
+    for (const f of fields) {
+        results.push({
+            nodeName: nodeName,
+            gqlName: f.graphQLName || f.name,
+            functionName: f.functionName || f.name,
+            fieldType: f.fieldType,
+            args: transformArgs(f),
+            results: transformResultType(f),
+        });
+    }
+    m.set(nodeName, results);
+}
+async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
+    if (jsonPath !== undefined) {
+        let json = json5_1.default.parse(fs.readFileSync(jsonPath, {
+            encoding: "utf8",
+        }));
+        if (json.fields) {
+            for (const k in json.fields) {
+                processCustomFields(json.fields[k], gqlCapture, k);
+            }
+        }
+        if (json.inputs) {
+            processCustomObjects(json.inputs, gqlCapture, true);
+        }
+        if (json.objects) {
+            processCustomObjects(json.objects, gqlCapture);
+        }
+        if (json.queries) {
+            processTopLevel(json.queries, gqlCapture.getCustomQueries());
+        }
+        if (json.mutations) {
+            processTopLevel(json.mutations, gqlCapture.getCustomMutations());
+        }
+        return;
+    }
     if (filesCsv !== undefined) {
         let files = filesCsv.split(",");
         for (let i = 0; i < files.length; i++) {
@@ -153,15 +250,25 @@ async function main() {
     if (!gqlPath) {
         throw new Error("could not find graphql path");
     }
-    const r = require(gqlPath);
-    if (!r.GQLCapture) {
-        throw new Error("could not find GQLCapture in module");
+    // use different variable  so that we use the correct GQLCapture as needed
+    // for local dev, get the one from the file system. otherwise, get the one
+    // from node_modules
+    let gqlCapture;
+    if (process.env.LOCAL_SCRIPT_PATH) {
+        const r = require("../graphql/graphql");
+        gqlCapture = r.GQLCapture;
+    }
+    else {
+        const r = require(gqlPath);
+        if (!r.GQLCapture) {
+            throw new Error("could not find GQLCapture in module");
+        }
+        gqlCapture = r.GQLCapture;
+        gqlCapture.enable(true);
     }
-    const GQLCapture = r.GQLCapture;
-    GQLCapture.enable(true);
     const [inputsRead, _, imports] = await Promise.all([
         readInputs(),
-        captureCustom(options.path, options.files),
+        captureCustom(options.path, options.files, options.json_path, gqlCapture),
         parseImports(options.path),
     ]);
     const { nodes, nodesMap } = inputsRead;
@@ -172,14 +279,14 @@ async function main() {
         }
         return result;
     }
-    GQLCapture.resolve(nodes);
-    let args = fromMap(GQLCapture.getCustomArgs());
-    let inputs = fromMap(GQLCapture.getCustomInputObjects());
-    let fields = GQLCapture.getProcessedCustomFields();
-    let queries = GQLCapture.getProcessedCustomQueries();
-    let mutations = GQLCapture.getProcessedCustomMutations();
-    let objects = fromMap(GQLCapture.getCustomObjects());
-    let customTypes = fromMap(GQLCapture.getCustomTypes());
+    gqlCapture.resolve(nodes);
+    let args = fromMap(gqlCapture.getCustomArgs());
+    let inputs = fromMap(gqlCapture.getCustomInputObjects());
+    let fields = gqlCapture.getProcessedCustomFields();
+    let queries = gqlCapture.getProcessedCustomQueries();
+    let mutations = gqlCapture.getProcessedCustomMutations();
+    let objects = fromMap(gqlCapture.getCustomObjects());
+    let customTypes = fromMap(gqlCapture.getCustomTypes());
     let classes = {};
     let allFiles = {};
     const buildClasses2 = (args) => {

package/scripts/move_generated.d.ts

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

package/scripts/move_generated.js

@@ -0,0 +1,142 @@
+"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 path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("../tsc/ast");
+const child_process_1 = require("child_process");
+// src/ent/generated and src/graphql/generated
+function transformPath(old) {
+    const parts = old.split(path.sep);
+    if (parts.length < 3) {
+        return;
+    }
+    const changedParts = parts
+        .slice(0, 2)
+        .concat("generated")
+        .concat(parts.slice(2).filter((v) => v !== "generated"));
+    const newFile = changedParts.join(path.sep);
+    return { changedParts, newFile };
+}
+function moveFiles(files) {
+    files.forEach((file) => {
+        const conv = transformPath(file);
+        if (!conv) {
+            return;
+        }
+        const { changedParts, newFile } = conv;
+        if (file === newFile) {
+            return;
+        }
+        // check if directory exists, if not, create recursive dir
+        const p = changedParts.slice(0, changedParts.length - 1).join(path.sep);
+        const statInfo = fs.statSync(p, { throwIfNoEntry: false });
+        if (!statInfo) {
+            fs.mkdirSync(p, {
+                recursive: true,
+            });
+        }
+        // move file to new location
+        fs.renameSync(file, newFile);
+    });
+}
+function updateImports(files, target, cwd) {
+    files.forEach((file) => {
+        let { contents, sourceFile } = (0, compilerOptions_1.createSourceFile)(target, file);
+        let nodes = [];
+        let updated = false;
+        typescript_1.default.forEachChild(sourceFile, function (node) {
+            let dirPath = path.join(cwd, file, "..");
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const conv = isGeneratedPath(node, sourceFile, dirPath);
+                if (!conv) {
+                    nodes.push({ node });
+                    return;
+                }
+                updated = true;
+                const newImportPath = path.relative(dirPath, conv.newFile);
+                const v = (0, ast_1.updateImportPath)(contents, node, sourceFile, newImportPath);
+                nodes.push({ rawString: v });
+            }
+            else {
+                nodes.push({ node });
+            }
+        });
+        let newContents = "";
+        for (const node of nodes) {
+            if (node.node) {
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                newContents += node.rawString;
+            }
+            else {
+                throw new Error(`malformed node with no node or rawString`);
+            }
+        }
+        if (updated) {
+            fs.writeFileSync(file, newContents);
+        }
+    });
+}
+function main() {
+    const entFiles = glob_1.glob.sync("src/ent/**/generated/**/**.ts");
+    const graphqlFiles = glob_1.glob.sync("src/graphql/**/generated/**/**.ts");
+    moveFiles(entFiles);
+    moveFiles(graphqlFiles);
+    const target = (0, compilerOptions_1.getTargetFromCurrentDir)();
+    const entImportFiles = glob_1.glob.sync("src/ent/**/*.ts", {
+        ignore: ["**/generated/**", "node_modules/**"],
+    });
+    const graphqlImportFiles = glob_1.glob.sync("src/graphql/**/*.ts", {
+        ignore: ["**/generated/**", "node_modules/**"],
+    });
+    const cwd = process.cwd();
+    updateImports(entImportFiles, target, cwd);
+    updateImports(graphqlImportFiles, target, cwd);
+    (0, child_process_1.execSync)("prettier src/ent/*.ts --write");
+    (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)) {
+        return;
+    }
+    const oldPath = path.join(dirPath, text);
+    const relFromRoot = path.relative(".", oldPath);
+    const conv = transformPath(relFromRoot);
+    if (!conv) {
+        return;
+    }
+    if (relFromRoot === conv.newFile) {
+        return;
+    }
+    return conv;
+}
+main();

package/scripts/read_schema.js

@@ -44,7 +44,21 @@ function main() {
         if (!match) {
             throw new Error(`non-typescript file ${p} returned by glob`);
         }
-        potentialSchemas[(0, pascal_case_1.pascalCase)(match[1])] = require(p).default;
+        let schema = match[1];
+        // convert foo_schema.ts -> foo
+        if (schema.endsWith("_schema")) {
+            schema = schema.slice(0, -7);
+        }
+        let relativePath;
+        const index = p.indexOf("src/schema");
+        if (index !== -1) {
+            relativePath = p.substring(index);
+        }
+        const s = require(p).default;
+        if (relativePath !== undefined) {
+            s.schemaPath = relativePath;
+        }
+        potentialSchemas[(0, pascal_case_1.pascalCase)(schema)] = s;
     }
     //  console.log(potentialSchemas);
     const result = (0, parse_1.parseSchema)(potentialSchemas);

package/scripts/transform_code.d.ts

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