@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

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,120 @@
+"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 modifiers = typescript_1.default.canHaveModifiers(node)
+            ? typescript_1.default.getModifiers(node)
+            : undefined;
+        const exported = 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];
@@ -22,24 +26,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const glob_1 = __importDefault(require("glob"));
+const glob = __importStar(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/;
-    const paths = glob_1.default.sync(path.join(options.path, "*.ts"), {
+    // do we still even need this...
+    const paths = glob.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 "../../action/operations";
+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 {};