@snowtop/ent 0.1.0-alpha1 → 0.1.0-alpha13

package/schema/schema.js

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.getFieldsWithPrivacy = exports.getStorageKey = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
+const snake_case_1 = require("snake-case");
+// we also want this transformation to exist on a per-action basis
+// if it exists on an action, we don't do the global schema transformation
+var SQLStatementOperation;
+(function (SQLStatementOperation) {
+    // transform insert e.g. to an update based on whatever logic
+    SQLStatementOperation["Insert"] = "insert";
+    // // transform select e.g. deleted_at. can't change from select to different query type
+    // // but can change the query
+    // Select = "select",
+    // e.g. change updated value
+    SQLStatementOperation["Update"] = "update";
+    // delete -> update theoretically e.g. deleted_at
+    SQLStatementOperation["Delete"] = "delete";
+})(SQLStatementOperation = exports.SQLStatementOperation || (exports.SQLStatementOperation = {}));
 // we want --strictNullChecks flag so nullable is used to type graphql, ts, db
 // should eventually generate (boolean | null) etc
 // supported db types
@@ -28,15 +43,31 @@ var DBType;
 function isSchema(value) {
     return value.fields !== undefined;
 }
-function getFields(value) {
-    let schema;
+function getSchema(value) {
     if (isSchema(value)) {
-        schema = value;
+        return value;
     }
     else {
-        schema = new value();
+        return new value();
     }
+}
+exports.getSchema = getSchema;
+function getFields(value) {
+    const schema = getSchema(value);
     function addFields(fields) {
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                m.set(name, field);
+            }
+            return;
+        }
         for (const name in fields) {
             const field = fields[name];
             if (field.getDerivedFields !== undefined) {
@@ -55,6 +86,108 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
+/**
+ * @deprecated should only be used by tests
+ */
+function getStorageKey(field, fieldName) {
+    return field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+}
+exports.getStorageKey = getStorageKey;
+// returns a mapping of storage key to field privacy
+function getFieldsWithPrivacy(value, fieldMap) {
+    const schema = getSchema(value);
+    function addFields(fields) {
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!field.name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                if (field.privacyPolicy) {
+                    let privacyPolicy;
+                    if (typeof field.privacyPolicy === "function") {
+                        privacyPolicy = field.privacyPolicy();
+                    }
+                    else {
+                        privacyPolicy = field.privacyPolicy;
+                    }
+                    const info = fieldMap[name];
+                    if (!info) {
+                        throw new Error(`field with name ${name} not passed in fieldMap`);
+                    }
+                    m.set(info.dbCol, privacyPolicy);
+                }
+            }
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
+            }
+            if (field.privacyPolicy) {
+                let privacyPolicy;
+                if (typeof field.privacyPolicy === "function") {
+                    privacyPolicy = field.privacyPolicy();
+                }
+                else {
+                    privacyPolicy = field.privacyPolicy;
+                }
+                const info = fieldMap[name];
+                if (!info) {
+                    throw new Error(`field with name ${name} not passed in fieldMap`);
+                }
+                m.set(info.dbCol, privacyPolicy);
+            }
+        }
+    }
+    let m = new Map();
+    if (schema.patterns) {
+        for (const pattern of schema.patterns) {
+            addFields(pattern.fields);
+        }
+    }
+    addFields(schema.fields);
+    return m;
+}
+exports.getFieldsWithPrivacy = getFieldsWithPrivacy;
+function getTransformedReadClause(value) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return;
+    }
+    for (const p of schema.patterns) {
+        // e.g. discarded_at, deleted_at, etc
+        if (p.transformRead) {
+            // return clause.Eq('deleted_at', null);
+            return p.transformRead();
+        }
+    }
+    return;
+}
+exports.getTransformedReadClause = getTransformedReadClause;
+function getObjectLoaderProperties(value, tableName) {
+    return {
+        clause: () => getTransformedReadClause(value),
+        instanceKey: `${tableName}:transformedReadClause`,
+    };
+}
+exports.getObjectLoaderProperties = getObjectLoaderProperties;
+function getTransformedUpdateOp(value, stmt) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return null;
+    }
+    for (const p of schema.patterns) {
+        if (p.transformWrite) {
+            return p.transformWrite(stmt);
+        }
+    }
+    return null;
+}
+exports.getTransformedUpdateOp = getTransformedUpdateOp;
 // this maps to ActionOperation in ent/action.go
 var ActionOperation;
 (function (ActionOperation) {

package/schema/struct_field.d.ts

@@ -0,0 +1,17 @@
+import { BaseField, ListField } from "./field";
+import { FieldOptions, Field, Type, FieldMap } from "./schema";
+export interface StructOptions extends FieldOptions {
+    tsType: string;
+    fields: FieldMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class StructField extends BaseField implements Field {
+    private options;
+    type: Type;
+    constructor(options: StructOptions);
+    format(obj: any, nested?: boolean): string | Object;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function StructType(options: StructOptions): StructField & StructOptions;
+export declare function StructListType(options: StructOptions): ListField;

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_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 {};