@snowtop/ent 0.1.0-alpha6 → 0.1.0-alpha60

package/schema/schema.d.ts

@@ -1,8 +1,23 @@
-import { Data, Ent, LoaderInfo } from "../core/base";
+import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
 import { Builder } from "../action/action";
+import { Clause } from "../core/clause";
+import { AssocEdgeInput } from "../core/ent";
 export declare type FieldMap = {
     [key: string]: Field;
 };
+interface FieldInfo {
+    dbCol: string;
+    inputKey: string;
+}
+export declare type FieldInfoMap = {
+    [key: string]: FieldInfo;
+};
+export interface GlobalSchema {
+    edges?: Edge[];
+    extraEdgeFields?: FieldMap;
+    transformEdgeRead?: () => Clause;
+    transformEdgeWrite?: (stmt: EdgeUpdateOperation) => TransformedEdgeUpdateOperation | null;
+}
 export default interface Schema {
     fields: FieldMap | Field[];
     tableName?: string;
@@ -61,7 +76,37 @@ export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
     fields: FieldMap | Field[];
+    disableMixin?: boolean;
     edges?: Edge[];
+    transformRead?: () => Clause;
+    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;
+    transformsDelete?: boolean;
+    transformsInsert?: boolean;
+    transformsUpdate?: boolean;
+}
+export declare enum SQLStatementOperation {
+    Insert = "insert",
+    Update = "update",
+    Delete = "delete"
+}
+export interface EdgeUpdateOperation {
+    op: SQLStatementOperation;
+    edge: AssocEdgeInput;
+}
+export interface TransformedEdgeUpdateOperation {
+    op: SQLStatementOperation;
+    data?: Data;
+}
+export interface UpdateOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    op: SQLStatementOperation;
+    builder: Builder<TEnt, TViewer>;
+    input: Data;
+    data?: Map<string, any>;
+}
+export interface TransformedUpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    data?: Data;
+    existingEnt?: T | null;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -77,6 +122,7 @@ export declare enum DBType {
     JSONB = "JSONB",
     Enum = "Enum",
     StringEnum = "StringEnum",
+    IntEnum = "IntEnum",
     Date = "Date",
     Time = "Time",
     Timetz = "Timetz",
@@ -85,10 +131,14 @@ export declare enum DBType {
 export interface ImportType {
     path: string;
     type: string;
+    [x: string]: any;
 }
 declare type EnumMap = {
     [key: string]: string;
 };
+declare type IntEnumMap = {
+    [key: string]: number;
+};
 export interface Type {
     dbType: DBType;
     listElemType?: Type;
@@ -96,6 +146,8 @@ export interface Type {
     graphQLType?: string;
     values?: string[];
     enumMap?: EnumMap;
+    intEnumMap?: IntEnumMap;
+    deprecatedIntEnumMap?: IntEnumMap;
     importType?: ImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;
@@ -121,13 +173,16 @@ export interface FieldEdge {
     getLoaderInfoFromSchema?: getLoaderInfoFn;
     disableBuilderType?: boolean;
 }
+interface PrivateOptions {
+    exposeToActions?: boolean;
+}
 export interface FieldOptions {
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
     unique?: boolean;
     hideFromGraphQL?: boolean;
-    private?: boolean;
+    private?: boolean | PrivateOptions;
     sensitive?: boolean;
     graphqlName?: string;
     index?: boolean;
@@ -135,11 +190,13 @@ export interface FieldOptions {
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
     disableUserEditable?: boolean;
+    disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
+    privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
     getDerivedFields?(name: string): FieldMap;
     [x: string]: any;
 }
@@ -158,7 +215,20 @@ export interface SchemaConstructor {
     new (): Schema;
 }
 export declare type SchemaInputType = Schema | SchemaConstructor;
+export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
+/**
+ * @deprecated should only be used by tests
+ */
+export declare function getStorageKey(field: Field, fieldName: string): string;
+export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldMap: FieldInfoMap): Map<string, PrivacyPolicy>;
+export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
+interface objectLoaderOptions {
+    clause?: () => Clause | undefined;
+    instanceKey?: string;
+}
+export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
+export declare function getTransformedUpdateOp<TEnt extends Ent<TViewer>, TViewer extends Viewer>(value: SchemaInputType, stmt: UpdateOperation<TEnt, TViewer>): TransformedUpdateOperation<TEnt> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -201,10 +271,25 @@ export interface Constraint {
     fkey?: ForeignKeyInfo;
     condition?: string;
 }
+export interface FullTextWeight {
+    A?: string[];
+    B?: string[];
+    C?: string[];
+    D?: string[];
+}
+export interface FullText {
+    generatedColumnName?: string;
+    language?: "english" | "french" | "german" | "simple";
+    languageColumn?: string;
+    indexType?: "gin" | "gist";
+    weights?: FullTextWeight;
+}
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
+    fulltext?: FullText;
+    indexType?: "gin" | "btree";
 }
 export interface ForeignKeyInfo {
     tableName: string;

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
@@ -20,6 +35,7 @@ var DBType;
     DBType["JSONB"] = "JSONB";
     DBType["Enum"] = "Enum";
     DBType["StringEnum"] = "StringEnum";
+    DBType["IntEnum"] = "IntEnum";
     DBType["Date"] = "Date";
     DBType["Time"] = "Time";
     DBType["Timetz"] = "Timetz";
@@ -28,14 +44,17 @@ 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) {
@@ -68,6 +87,109 @@ 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);
+                }
+            }
+            return;
+        }
+        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/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++) {
@@ -138,7 +235,11 @@ async function main() {
     // if this list grows too long, need to build this into golang types and passed here
     // TODO foreign non-scalars eventually
     (0, graphql_1.addCustomType)({
-        importPath: "../graphql/scalars/time",
+        importPath: MODULE_PATH,
+        // for go tests...
+        // TODO need a flag that only does this for go tests
+        // breaks when running locally sometimes...
+        secondaryImportPath: "../graphql/scalars/time",
         type: "GraphQLTime",
     });
     (0, graphql_1.addCustomType)({
@@ -153,15 +254,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 +283,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/migrate_v0.1.js

@@ -0,0 +1,36 @@
+"use strict";
+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 transform_schema_1 = require("../tsc/transform_schema");
+const transform_ent_1 = require("../tsc/transform_ent");
+const move_generated_1 = require("../tsc/move_generated");
+const transform_action_1 = require("../tsc/transform_action");
+const minimist_1 = __importDefault(require("minimist"));
+const ast_1 = require("../tsc/ast");
+// todo-sqlite
+//  ts-node-script --swc --project ./tsconfig.json -r tsconfig-paths/register ../../ts/src/scripts/migrate_v0.1.ts --transform_schema --old_base_class BaseEntTodoSchema --new_schema_class TodoEntSchema  --transform_path src/schema/patterns/base
+function main() {
+    const customInfo = (0, ast_1.getCustomInfo)();
+    const options = (0, minimist_1.default)(process.argv.slice(2));
+    // install 0.1.x dependencies
+    // maybe provide options to make this easier if someone wants to do this in steps to see what's happening
+    if (options.move_generated) {
+        (0, move_generated_1.moveGenerated)(customInfo.relativeImports);
+    }
+    // codegen  write-all --disable-custom-graphql
+    if (options.transform_schema) {
+        (0, transform_1.transform)(new transform_schema_1.TransformSchema(customInfo.relativeImports, options.old_base_class, options.new_schema_class, options.transform_path));
+    }
+    // codegen write-all --disable-custom-graphql
+    if (options.transform_ent) {
+        (0, transform_1.transform)(new transform_ent_1.TransformEnt());
+    }
+    if (options.transform_action) {
+        (0, transform_1.transform)(new transform_action_1.TransformAction(customInfo));
+    }
+    // codegen write-all
+}
+main();

package/scripts/read_schema.js

@@ -28,26 +28,49 @@ const pascal_case_1 = require("pascal-case");
 const minimist_1 = __importDefault(require("minimist"));
 const process_1 = require("process");
 const parse_1 = require("../parse_schema/parse");
+const ast_1 = require("../tsc/ast");
 function main() {
     const options = (0, minimist_1.default)(process.argv.slice(2));
     if (!options.path) {
         throw new Error("path required");
     }
+    const customInfo = (0, ast_1.getCustomInfo)();
+    const globalSchemaPath = customInfo.globalSchemaPath || "__global__schema.ts";
+    let globalSchema;
     const r = /(\w+).ts/;
+    // do we still even need this...
     const paths = glob_1.default.sync(path.join(options.path, "*.ts"), {
         ignore: [`\d+_read_schema.ts`],
     });
     let potentialSchemas = {};
     for (const p of paths) {
         const basename = path.basename(p);
+        if (basename === globalSchemaPath) {
+            globalSchema = require(p).default;
+            continue;
+        }
         const match = r.exec(basename);
         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);
+    const result = (0, parse_1.parseSchema)(potentialSchemas, globalSchema);
     console.log(JSON.stringify(result));
 }
 try {