@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha150

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

package/testutils/action/complex_schemas.js

@@ -0,0 +1,405 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTables = exports.GroupMemberOfSchema = exports.GroupMemberOf = exports.verifyChangelogFromMeberships = exports.loadChangelogs = exports.loadMemberships = exports.verifyGroupMembers = exports.EditGroupAction = exports.GroupMembershipTrigger = exports.UserAction = exports.MessageAction = exports.createUser = exports.createGroup = exports.executeAction = exports.MessageSchema = exports.ChangelogSchema = exports.Changelog = exports.GroupMembershipSchema = exports.GroupMembership = exports.GroupSchema = exports.ContactSchema = exports.AccountSchema = exports.Account = exports.UserBalanceWithCheckSchema = exports.UserWithBalanceWithCheck = exports.UserBalanceSchema = exports.UserWithBalance = exports.UserSchema = exports.getOperations = exports.getML = exports.setupTest = void 0;
+const ent_1 = require("../../core/ent");
+const object_loader_1 = require("../../core/loaders/object_loader");
+const action_1 = require("../../action/action");
+const executor_1 = require("../../action/executor");
+const builder_1 = require("../../testutils/builder");
+const viewer_1 = require("../../core/viewer");
+const field_1 = require("../../schema/field");
+const json_field_1 = require("../../schema/json_field");
+const fake_log_1 = require("../../testutils/fake_log");
+const write_1 = require("../../testutils/write");
+const mock_log_1 = require("../../testutils/mock_log");
+const logger_1 = require("../../core/logger");
+const action = __importStar(require("../../action"));
+const convert_1 = require("../../core/convert");
+const uuid_1 = require("uuid");
+const temp_db_1 = require("../db/temp_db");
+const db_1 = require("../../core/db");
+const schema_1 = require("../../schema");
+const ml = new mock_log_1.MockLogs();
+let operations = [];
+const edges = [
+    "fake_edge",
+    "selfContact",
+    "channelMember",
+    "senderToMessage",
+    "workspaceMember",
+    "recipientToMessage",
+    "objectToChangelog",
+    "changelogToParent",
+];
+function setupTest() {
+    beforeEach(async () => {
+        // does assoc_edge_config loader need to be cleared?
+        for (const edge of edges) {
+            await (0, write_1.createRowForTest)({
+                tableName: "assoc_edge_config",
+                fields: {
+                    edge_table: `${edge}_table`,
+                    symmetric_edge: false,
+                    inverse_edge_type: null,
+                    edge_type: edge,
+                    edge_name: "name",
+                    created_at: new Date(),
+                    updated_at: new Date(),
+                },
+            });
+        }
+        ml.clear();
+    });
+    beforeAll(() => {
+        (0, logger_1.setLogLevels)(["query", "error", "cache"]);
+        ml.mock();
+    });
+    afterEach(() => {
+        ml.clear();
+    });
+    afterAll(() => {
+        ml.restore();
+    });
+    afterEach(() => {
+        fake_log_1.FakeLogger.clear();
+        operations = [];
+    });
+}
+exports.setupTest = setupTest;
+function getML() {
+    return ml;
+}
+exports.getML = getML;
+function getOperations() {
+    return operations;
+}
+exports.getOperations = getOperations;
+exports.UserSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    FirstName: (0, field_1.StringType)(),
+    LastName: (0, field_1.StringType)(),
+    EmailAddress: (0, field_1.StringType)({ nullable: true }),
+    AccountID: (0, field_1.UUIDType)({ nullable: true }),
+}, builder_1.User);
+class UserWithBalance extends builder_1.User {
+}
+exports.UserWithBalance = UserWithBalance;
+exports.UserBalanceSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    first_name: (0, field_1.StringType)(),
+    last_name: (0, field_1.StringType)(),
+    email_address: (0, field_1.StringType)({ nullable: true }),
+    balance: (0, field_1.FloatType)(),
+}, UserWithBalance);
+class UserWithBalanceWithCheck extends UserWithBalance {
+}
+exports.UserWithBalanceWithCheck = UserWithBalanceWithCheck;
+exports.UserBalanceWithCheckSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    first_name: (0, field_1.StringType)(),
+    last_name: (0, field_1.StringType)(),
+    email_address: (0, field_1.StringType)({ nullable: true }),
+    balance: (0, field_1.FloatType)(),
+}, UserWithBalanceWithCheck, {
+    constraints: [
+        {
+            type: schema_1.ConstraintType.Check,
+            name: "positive_balance",
+            columns: ["balance"],
+            condition: "balance >= 0",
+        },
+    ],
+});
+class Account extends builder_1.BaseEnt {
+    constructor() {
+        super(...arguments);
+        this.accountID = "";
+        this.nodeType = "Account";
+    }
+}
+exports.Account = Account;
+exports.AccountSchema = (0, builder_1.getBuilderSchemaFromFields)({}, Account);
+exports.ContactSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    FirstName: (0, field_1.StringType)(),
+    LastName: (0, field_1.StringType)(),
+    UserID: (0, field_1.StringType)(),
+}, builder_1.Contact);
+exports.GroupSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    name: (0, field_1.StringType)(),
+    funField: (0, field_1.StringType)({ nullable: true }),
+}, builder_1.Group);
+class GroupMembership extends builder_1.BaseEnt {
+    constructor() {
+        super(...arguments);
+        this.nodeType = "GroupMembership";
+    }
+}
+exports.GroupMembership = GroupMembership;
+exports.GroupMembershipSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    ownerID: (0, field_1.UUIDType)(),
+    addedBy: (0, field_1.UUIDType)(),
+    notificationsEnabled: (0, field_1.BooleanType)(),
+}, GroupMembership);
+class Changelog extends builder_1.BaseEnt {
+    constructor() {
+        super(...arguments);
+        this.nodeType = "Changelog";
+    }
+}
+exports.Changelog = Changelog;
+exports.ChangelogSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    parentID: (0, field_1.UUIDType)({ polymorphic: true }),
+    log: (0, json_field_1.JSONBType)(),
+}, Changelog);
+exports.MessageSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    // TODO both id fields
+    sender: (0, field_1.StringType)({
+        index: true,
+    }),
+    recipient: (0, field_1.StringType)(),
+    message: (0, field_1.StringType)(),
+    transient: (0, field_1.BooleanType)({ nullable: true }),
+    expiresAt: (0, field_1.TimestampType)({ nullable: true }),
+    delivered: (0, field_1.BooleanType)({ defaultValueOnCreate: () => false }),
+}, builder_1.Message);
+jest.spyOn(action, "saveBuilder").mockImplementation(saveBuilder);
+jest.spyOn(action, "saveBuilderX").mockImplementation(saveBuilderX);
+async function saveBuilder(builder) {
+    const changeset = await builder.build();
+    const executor = changeset.executor();
+    operations = await (0, executor_1.executeOperations)(executor, builder.viewer.context, true);
+}
+async function saveBuilderX(builder) {
+    return saveBuilder(builder);
+}
+async function executeAction(action, name) {
+    const exec = await executor(action.builder);
+    if (name !== undefined) {
+        expect(exec).toBeInstanceOf(name);
+    }
+    operations = await (0, executor_1.executeOperations)(exec, action.builder.viewer.context, true);
+    return exec;
+}
+exports.executeAction = executeAction;
+async function executor(builder) {
+    const changeset = await builder.build();
+    return changeset.executor();
+}
+async function createGroup() {
+    let groupID = (0, uuid_1.v4)();
+    let groupFields = {
+        id: groupID,
+        name: "group",
+        created_at: new Date(),
+        updated_at: new Date(),
+    };
+    // need to create the group first
+    await (0, write_1.createRowForTest)({
+        tableName: "groups",
+        fields: groupFields,
+    });
+    return new builder_1.Group(new viewer_1.LoggedOutViewer(), groupFields);
+}
+exports.createGroup = createGroup;
+async function createUser() {
+    const id = (0, uuid_1.v4)();
+    return new builder_1.User(new viewer_1.IDViewer(id), { id });
+}
+exports.createUser = createUser;
+class MessageAction extends builder_1.SimpleAction {
+    constructor(viewer, fields, operation, existingEnt) {
+        super(viewer, exports.MessageSchema, fields, operation, existingEnt);
+    }
+    getTriggers() {
+        return [
+            {
+                changeset: (builder, _input) => {
+                    let sender = builder.fields.get("sender");
+                    let recipient = builder.fields.get("recipient");
+                    if (sender) {
+                        builder.orchestrator.addInboundEdge(sender, "senderToMessage", "user");
+                    }
+                    if (recipient) {
+                        builder.orchestrator.addInboundEdge(recipient, "recipientToMessage", "user");
+                    }
+                },
+            },
+        ];
+    }
+    getObservers() {
+        return [new fake_log_1.EntCreationObserver()];
+    }
+}
+exports.MessageAction = MessageAction;
+class UserAction extends builder_1.SimpleAction {
+    constructor(viewer, fields, operation, existingEnt) {
+        super(viewer, exports.UserSchema, fields, operation, existingEnt);
+    }
+    getTriggers() {
+        return [
+            {
+                changeset: (builder) => {
+                    let firstName = builder.fields.get("FirstName");
+                    let lastName = builder.fields.get("LastName");
+                    this.contactAction = new builder_1.SimpleAction(builder.viewer, exports.ContactSchema, new Map([
+                        ["FirstName", firstName],
+                        ["LastName", lastName],
+                        ["UserID", builder],
+                    ]), action_1.WriteOperation.Insert, null);
+                    this.contactAction.getObservers = () => [
+                        new fake_log_1.EntCreationObserver(),
+                    ];
+                    builder.orchestrator.addOutboundEdge(this.contactAction.builder, "selfContact", "contact");
+                    return this.contactAction.changeset();
+                },
+            },
+        ];
+    }
+    getObservers() {
+        return [new fake_log_1.EntCreationObserver()];
+    }
+}
+exports.UserAction = UserAction;
+class GroupMembershipTrigger {
+    constructor(getter) {
+        this.getter = getter;
+    }
+    changeset(builder, input) {
+        const inputEdges = builder.orchestrator.getInputEdges("workspaceMember", action_1.WriteOperation.Insert);
+        const changesets = [];
+        for (const edge of inputEdges) {
+            // we're going to simplify and assume it doesn't currently exist
+            const memberAction = this.getter(builder.viewer, edge);
+            // store the membership edge in data field of member edge
+            builder.orchestrator.addOutboundEdge(edge.id, "workspaceMember", "User", {
+                data: memberAction.builder,
+            });
+            changesets.push(memberAction.changeset());
+        }
+        return Promise.all(changesets);
+    }
+}
+exports.GroupMembershipTrigger = GroupMembershipTrigger;
+class EditGroupAction extends builder_1.SimpleAction {
+    constructor(viewer, schema, fields, existingEnt, getter) {
+        super(viewer, schema, fields, action_1.WriteOperation.Edit, existingEnt);
+        this.viewer = viewer;
+        this.getter = getter;
+        this.getTriggers = () => [new GroupMembershipTrigger(this.getter)];
+    }
+}
+exports.EditGroupAction = EditGroupAction;
+async function verifyGroupMembers(group, members) {
+    const memberEdges = await (0, ent_1.loadEdges)({
+        edgeType: "workspaceMember",
+        id1: group.id,
+    });
+    const memberIDs = members.map((ent) => ent.id);
+    expect(memberIDs.sort()).toEqual(memberEdges.map((edge) => edge.id2).sort());
+    // @ts-ignore
+    const membershipids = memberEdges
+        .map((edge) => edge.data)
+        .filter((str) => str !== null && str !== undefined);
+    return membershipids;
+}
+exports.verifyGroupMembers = verifyGroupMembers;
+async function loadMemberships(viewer, membershipids) {
+    const tableName = (0, builder_1.getTableName)(exports.GroupMembershipSchema);
+    const ents = await (0, ent_1.loadEnts)(viewer, {
+        tableName,
+        ent: GroupMembership,
+        fields: ["id", "owner_id", "added_by", "notifications_enabled"],
+        loaderFactory: new object_loader_1.ObjectLoaderFactory({
+            tableName,
+            fields: ["id", "owner_id", "added_by", "notifications_enabled"],
+            key: "id",
+        }),
+    }, ...membershipids);
+    return Array.from(ents.values());
+}
+exports.loadMemberships = loadMemberships;
+async function loadChangelogs(viewer, clids) {
+    const ents = await (0, ent_1.loadEnts)(viewer, {
+        tableName: "changelogs",
+        ent: Changelog,
+        fields: ["id", "parent_id", "log"],
+        loaderFactory: new object_loader_1.ObjectLoaderFactory({
+            tableName: "changelogs",
+            fields: ["id", "parent_id", "log"],
+            key: "id",
+        }),
+    }, ...clids);
+    return Array.from(ents.values());
+}
+exports.loadChangelogs = loadChangelogs;
+async function verifyChangelogFromMeberships(user, memberships) {
+    await Promise.all(memberships.map(async (membership) => {
+        const edges = await (0, ent_1.loadEdges)({
+            edgeType: "objectToChangelog",
+            id1: membership.id,
+        });
+        expect(edges.length).toBe(1);
+        const clIDs = edges.map((edge) => edge.id2);
+        const cls = await loadChangelogs(user.viewer, clIDs);
+        expect(cls.length).toBe(1);
+        const cl = cls[0];
+        expect(edges[0].id2).toBe(cl.id);
+        expect((0, convert_1.convertJSON)(cl.data.log)).toMatchObject({
+            // also has ownerID...
+            addedBy: user.id,
+            notificationsEnabled: true,
+        });
+    }));
+}
+exports.verifyChangelogFromMeberships = verifyChangelogFromMeberships;
+class GroupMemberOf extends builder_1.BaseEnt {
+    constructor() {
+        super(...arguments);
+        this.nodeType = "GroupMemberOf";
+    }
+}
+exports.GroupMemberOf = GroupMemberOf;
+exports.GroupMemberOfSchema = (0, builder_1.getBuilderSchemaFromFields)({
+    userID: (0, field_1.UUIDType)({ index: true }),
+    addedBy: (0, field_1.UUIDType)(),
+    groupID: (0, field_1.UUIDType)(),
+    notificationsEnabled: (0, field_1.BooleanType)(),
+}, GroupMemberOf);
+const getTables = () => {
+    const tables = [(0, temp_db_1.assoc_edge_config_table)()];
+    edges.map((edge) => tables.push((0, temp_db_1.assoc_edge_table)(`${edge}_table`)));
+    [
+        exports.AccountSchema,
+        exports.ContactSchema,
+        exports.GroupSchema,
+        exports.UserSchema,
+        exports.MessageSchema,
+        exports.GroupMembershipSchema,
+        exports.ChangelogSchema,
+        exports.GroupMemberOfSchema,
+        exports.UserBalanceSchema,
+        exports.UserBalanceWithCheckSchema,
+    ].map((s) => tables.push((0, temp_db_1.getSchemaTable)(s, db_1.Dialect.SQLite)));
+    return tables;
+};
+exports.getTables = getTables;