@snowtop/ent 0.1.0-alpha10 → 0.1.0-alpha101

package/scripts/custom_graphql.js

@@ -2,7 +2,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -26,12 +30,13 @@ 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"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const graphql_1 = require("../graphql/graphql");
+const readline = __importStar(require("readline"));
 const imports_1 = require("../imports");
 const process_1 = require("process");
+const child_process_1 = require("child_process");
 // need to use the GQLCapture from the package so that when we call GQLCapture.enable()
 // we're affecting the local paths as opposed to a different instance
 // life is hard
@@ -72,7 +77,7 @@ function processCustomObjects(l, gqlCapture, input) {
         }
     }
 }
-function transformArgs(f) {
+function transformArgs(f, gqlCapture) {
     return (f.args || []).map((v) => {
         const ret = {
             ...v,
@@ -80,7 +85,7 @@ function transformArgs(f) {
         // duplicated from getType in graphql.ts
         if ((0, graphql_1.isCustomType)(ret.type)) {
             ret.type = v.type.type;
-            (0, graphql_1.addCustomType)(v.type);
+            (0, graphql_1.addCustomType)(v.type, gqlCapture);
         }
         // scalar types not supported for now
         ret.tsType = graphql_1.knownAllowedNames.get(v.type);
@@ -95,23 +100,32 @@ function transformResultType(f) {
                 type: f.resultType,
                 tsType: graphql_1.knownAllowedNames.get(f.resultType),
                 list: f.list,
+                connection: f.connection,
                 nullable: f.nullable,
             },
         ]
         : [];
 }
-function processTopLevel(l, l2) {
+function processTopLevel(l, l2, gqlCapture) {
     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),
+            args: transformArgs(custom, gqlCapture),
             results: transformResultType(custom),
+            description: custom.description,
+            extraImports: custom.extraImports,
+            functionContents: custom.functionContents,
         });
     }
 }
+function processCustomTypes(m, gqlCapture) {
+    for (const k in m) {
+        (0, graphql_1.addCustomType)(m[k], gqlCapture);
+    }
+}
 function processCustomFields(fields, gqlCapture, nodeName) {
     const m = gqlCapture.getCustomFields();
     let results = [];
@@ -121,12 +135,53 @@ function processCustomFields(fields, gqlCapture, nodeName) {
             gqlName: f.graphQLName || f.name,
             functionName: f.functionName || f.name,
             fieldType: f.fieldType,
-            args: transformArgs(f),
+            args: transformArgs(f, gqlCapture),
             results: transformResultType(f),
+            description: f.description,
         });
     }
     m.set(nodeName, results);
 }
+async function captureDynamic(filePath, gqlCapture) {
+    if (!filePath) {
+        return;
+    }
+    return await new Promise((resolve, reject) => {
+        // do we eventually need tsconfig-paths here or do we get it by default because child process?
+        const r = (0, child_process_1.spawn)("ts-node", [filePath]);
+        const datas = [];
+        r.stdout.on("data", (data) => {
+            datas.push(data.toString());
+        });
+        r.stderr.on("data", (data) => {
+            reject(new Error(data.toString()));
+        });
+        r.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`error code ${code} on dynamic path`));
+                return;
+            }
+            let json = json5_1.default.parse(datas.join(""));
+            for (const k in json) {
+                const v = json[k];
+                switch (k) {
+                    case "queries":
+                        processTopLevel(v, gqlCapture.getCustomQueries(), gqlCapture);
+                        break;
+                    case "mutations":
+                        processTopLevel(v, gqlCapture.getCustomMutations(), gqlCapture);
+                        break;
+                    case "customTypes":
+                        processCustomTypes(v, gqlCapture);
+                        break;
+                    default:
+                        reject(new Error(`key ${k} is unsupported in dynamic custom graphql. only queries and mutations are supported`));
+                }
+            }
+            resolve(undefined);
+        });
+    });
+}
 async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
     if (jsonPath !== undefined) {
         let json = json5_1.default.parse(fs.readFileSync(jsonPath, {
@@ -144,10 +199,13 @@ async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
             processCustomObjects(json.objects, gqlCapture);
         }
         if (json.queries) {
-            processTopLevel(json.queries, gqlCapture.getCustomQueries());
+            processTopLevel(json.queries, gqlCapture.getCustomQueries(), gqlCapture);
         }
         if (json.mutations) {
-            processTopLevel(json.mutations, gqlCapture.getCustomMutations());
+            processTopLevel(json.mutations, gqlCapture.getCustomMutations(), gqlCapture);
+        }
+        if (json.customTypes) {
+            processCustomTypes(json.customTypes, gqlCapture);
         }
         return;
     }
@@ -208,11 +266,27 @@ async function requireFiles(files) {
         throw new Error(err);
     });
 }
+// filePath is path-to-src
 async function parseImports(filePath) {
-    // only do graphql files...
-    return (0, imports_1.parseCustomImports)(path.join(filePath, "graphql"), {
-        ignore: ["**/generated/**", "**/tests/**"],
-    });
+    return (0, imports_1.parseCustomImports)(filePath, [
+        {
+            // graphql files
+            root: path.join(filePath, "graphql"),
+            opts: {
+                ignore: ["**/generated/**", "**/tests/**"],
+            },
+        },
+        {
+            // can't just use top level ent files but have to check for all (non-generated) files
+            // in src/ent/* because custom edges (or other things) could have @gqlField etc
+            // and then have to look for these imports etc
+            root: path.join(filePath, "ent"),
+            opts: {
+                // not in action files since we can't customize payloads (yet?)
+                ignore: ["**/generated/**", "**/tests/**", "**/actions/**"],
+            },
+        },
+    ]);
 }
 function findGraphQLPath(filePath) {
     while (filePath !== "/") {
@@ -227,21 +301,11 @@ function findGraphQLPath(filePath) {
     }
     return undefined;
 }
+// test as follows:
+// there should be an easier way to do this...
+// also, there should be a way to get the list of objects here that's not manual
+//echo "User\nContact\nContactEmail\nComment" | ts-node-script --log-error --project ./tsconfig.json -r tsconfig-paths/register ../../ts/src/scripts/custom_graphql.ts --path ~/code/ent/examples/simple/src/
 async function main() {
-    // known custom types that are not required
-    // if not in the schema, will be ignored
-    // something like GraphQLUpload gotten via gqlArg({type: gqlFileUpload})
-    // these 2 need this because they're added by the schema
-    // 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",
-        type: "GraphQLTime",
-    });
-    (0, graphql_1.addCustomType)({
-        importPath: "graphql-type-json",
-        type: "GraphQLJSON",
-    });
     const options = (0, minimist_1.default)(process.argv.slice(2));
     if (!options.path) {
         throw new Error("path required");
@@ -266,9 +330,28 @@ async function main() {
         gqlCapture = r.GQLCapture;
         gqlCapture.enable(true);
     }
-    const [inputsRead, _, imports] = await Promise.all([
+    // known custom types that are not required
+    // if not in the schema, will be ignored
+    // something like GraphQLUpload gotten via gqlArg({type: gqlFileUpload})
+    // these 2 need this because they're added by the schema
+    // 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: 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",
+    }, gqlCapture);
+    (0, graphql_1.addCustomType)({
+        importPath: "graphql-type-json",
+        type: "GraphQLJSON",
+    }, gqlCapture);
+    const [inputsRead, _, __, imports] = await Promise.all([
         readInputs(),
         captureCustom(options.path, options.files, options.json_path, gqlCapture),
+        captureDynamic(options.dynamic_path, gqlCapture),
         parseImports(options.path),
     ]);
     const { nodes, nodesMap } = inputsRead;
@@ -325,7 +408,7 @@ async function main() {
     };
     const buildClasses = (fields) => {
         fields.forEach((field) => {
-            if (!nodesMap.has(field.nodeName)) {
+            if (field.nodeName && !nodesMap.has(field.nodeName)) {
                 let info = imports.getInfoForClass(field.nodeName);
                 classes[field.nodeName] = { ...info.class, path: info.file.path };
                 buildFiles(info.file);
@@ -336,6 +419,10 @@ async function main() {
     };
     buildClasses(mutations);
     buildClasses(queries);
+    // call for every field in a node
+    for (const k in fields) {
+        buildClasses(fields[k]);
+    }
     console.log(JSON.stringify({
         args,
         inputs,

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 minimist_1 = __importDefault(require("minimist"));
+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 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/move_types.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 transform_1 = require("../tsc/transform");
+const ast_1 = require("../tsc/ast");
+const typescript_1 = __importStar(require("typescript"));
+const path_1 = __importDefault(require("path"));
+class GatherExportsInGeneratedTypes {
+    constructor() {
+        this.glob = "src/ent/generated/types.ts";
+        this.names = [];
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        const exported = node.modifiers?.filter((mod) => mod.getText(sourceFile) === "export");
+        if (exported?.length) {
+            if (typescript_1.default.isEnumDeclaration(node) ||
+                typescript_1.default.isInterfaceDeclaration(node) ||
+                typescript_1.default.isTypeAliasDeclaration(node)) {
+                this.names.push(node.name.text);
+            }
+            if (typescript_1.default.isFunctionDeclaration(node) && node.name?.text) {
+                this.names.push(node.name.text);
+            }
+        }
+        return { node };
+    }
+}
+class TransformImports {
+    constructor() {
+        this.glob = "src/**/*.ts";
+        this.prettierGlob = "src/**/*.ts";
+        this.impsToMove = new Map();
+        this.cwd = "";
+        this.relative = false;
+        this.cwd = process.cwd();
+        const gt = new GatherExportsInGeneratedTypes();
+        (0, transform_1.transform)(gt);
+        gt.names.forEach((v) => this.impsToMove.set(v, true));
+        this.relative = (0, ast_1.getCustomInfo)().relativeImports ?? this.relative;
+    }
+    getSrcPath(file, text) {
+        if (text.startsWith("src")) {
+            return text;
+        }
+        const dir = path_1.default.dirname(path_1.default.join(this.cwd, file));
+        const fullPath = path_1.default.join(dir, text);
+        return path_1.default.relative(this.cwd, fullPath);
+    }
+    traverseChild(sourceFile, contents, file, node) {
+        if (!(0, typescript_1.isImportDeclaration)(node)) {
+            return { node };
+        }
+        const impInfo = (0, ast_1.getImportInfo)(node, sourceFile);
+        if (!impInfo) {
+            return { node };
+        }
+        const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
+        const pathToWrite = (0, ast_1.transformRelative)(file, "src/ent/generated/types", this.relative);
+        const current = (0, ast_1.transformRelative)(file, text, this.relative);
+        const srcPath = this.getSrcPath(file, text);
+        // nothing to do here
+        if (!srcPath.startsWith("src/ent") || pathToWrite === current) {
+            return { node };
+        }
+        // let's see if we can simplify
+        let seenImports = [];
+        for (let imp of impInfo.imports) {
+            imp = imp.trim();
+            if (this.impsToMove.has(imp)) {
+                seenImports.push(imp);
+            }
+        }
+        if (!seenImports.length) {
+            return { node };
+        }
+        let imports = new Map([[pathToWrite, seenImports]]);
+        return {
+            rawString: (0, ast_1.transformImport)(contents, node, sourceFile, {
+                removeImports: seenImports,
+                transformPath: text,
+            }),
+            traversed: true,
+            imports,
+            allowSeenImportsAdded: true,
+        };
+    }
+}
+//  ts-node-script --swc --project ./tsconfig.json -r tsconfig-paths/register ../../ts/src/scripts/move_types.ts
+function main() {
+    (0, transform_1.transform)(new TransformImports());
+}
+main();

package/scripts/read_schema.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -26,20 +30,28 @@ const glob_1 = __importDefault(require("glob"));
 const path = __importStar(require("path"));
 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`);
@@ -61,13 +73,16 @@ function main() {
         potentialSchemas[(0, pascal_case_1.pascalCase)(schema)] = s;
     }
     //  console.log(potentialSchemas);
-    const result = (0, parse_1.parseSchema)(potentialSchemas);
-    console.log(JSON.stringify(result));
+    // NB: do not change this to async/await
+    // doing so runs it buffer limit on linux (65536 bytes) and we lose data reading in go
+    (0, parse_1.parseSchema)(potentialSchemas, globalSchema).then((result) => {
+        console.log(JSON.stringify(result));
+    });
 }
 try {
     main();
 }
 catch (err) {
     console.error(err);
-    (0, process_1.exit)(1);
+    process.exit(1);
 }

package/testutils/action/complex_schemas.d.ts

@@ -0,0 +1,69 @@
+import { Ent, ID, Viewer, Data } from "../../core/base";
+import { DataOperation } from "../../core/ent";
+import { Action, Builder, Executor, WriteOperation, Trigger, Observer, TriggerReturn } from "../../action/action";
+import { EdgeInputData } from "../../action/orchestrator";
+import { User, Group, Message, Contact, SimpleBuilder, BuilderSchema, SimpleAction, BaseEnt } from "../../testutils/builder";
+import { MockLogs } from "../../testutils/mock_log";
+import { Table } from "../db/temp_db";
+export declare function setupTest(): void;
+export declare function getML(): MockLogs;
+export declare function getOperations(): DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[];
+export declare const UserSchema: BuilderSchema<User>;
+export declare class UserWithBalance extends User {
+}
+export declare const UserBalanceSchema: BuilderSchema<UserWithBalance>;
+export declare class UserWithBalanceWithCheck extends UserWithBalance {
+}
+export declare const UserBalanceWithCheckSchema: BuilderSchema<UserWithBalanceWithCheck>;
+export declare class Account extends BaseEnt {
+    accountID: string;
+    nodeType: string;
+}
+export declare const AccountSchema: BuilderSchema<Account>;
+export declare const ContactSchema: BuilderSchema<Contact>;
+export declare const GroupSchema: BuilderSchema<Group>;
+export declare class GroupMembership extends BaseEnt {
+    nodeType: string;
+}
+export declare const GroupMembershipSchema: BuilderSchema<GroupMembership>;
+export declare class Changelog extends BaseEnt {
+    nodeType: string;
+}
+export declare const ChangelogSchema: BuilderSchema<Changelog>;
+export declare const MessageSchema: BuilderSchema<Message>;
+export declare function executeAction<T extends Ent, E = any>(action: Action<T, Builder<T>>, name?: E): Promise<Executor>;
+export declare function createGroup(): Promise<Group>;
+export declare function createUser(): Promise<User>;
+export declare class MessageAction extends SimpleAction<Message> {
+    constructor(viewer: Viewer, fields: Map<string, any>, operation: WriteOperation, existingEnt: Message | null);
+    getTriggers(): Trigger<Message, SimpleBuilder<Message, Message | null>>[];
+    getObservers(): Observer<Message, SimpleBuilder<Message>>[];
+}
+export declare class UserAction extends SimpleAction<User> {
+    contactAction: SimpleAction<Contact> | undefined;
+    constructor(viewer: Viewer, fields: Map<string, any>, operation: WriteOperation, existingEnt: User | null);
+    getTriggers(): Trigger<User, SimpleBuilder<User>>[];
+    getObservers(): Observer<User, SimpleBuilder<User>>[];
+}
+type getMembershipFunction = (viewer: Viewer, edge: EdgeInputData) => SimpleAction<Ent>;
+export declare class GroupMembershipTrigger implements Trigger<Group, SimpleBuilder<Group>> {
+    private getter;
+    constructor(getter: getMembershipFunction);
+    changeset(builder: SimpleBuilder<Group>, input: Data): TriggerReturn;
+}
+export declare class EditGroupAction extends SimpleAction<Group> {
+    viewer: Viewer;
+    private getter;
+    constructor(viewer: Viewer, schema: BuilderSchema<Group>, fields: Map<string, any>, existingEnt: Group, getter: getMembershipFunction);
+    getTriggers: () => GroupMembershipTrigger[];
+}
+export declare function verifyGroupMembers(group: Group, members: User[]): Promise<ID[]>;
+export declare function loadMemberships(viewer: Viewer, membershipids: ID[]): Promise<GroupMembership[]>;
+export declare function loadChangelogs(viewer: Viewer, clids: ID[]): Promise<Changelog[]>;
+export declare function verifyChangelogFromMeberships(user: User, memberships: GroupMembership[]): Promise<void>;
+export declare class GroupMemberOf extends BaseEnt {
+    nodeType: string;
+}
+export declare const GroupMemberOfSchema: BuilderSchema<GroupMemberOf>;
+export declare const getTables: () => Table[];
+export {};