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

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;

package/testutils/builder.d.ts

@@ -2,88 +2,82 @@ import { Ent, ID, Viewer, Data, EntConstructor, PrivacyPolicy } from "../core/ba
 import { Orchestrator } from "../action/orchestrator";
 import { Action, Builder, Changeset, WriteOperation, Validator, Trigger, Observer } from "../action";
 import { FieldMap, Schema } from "../schema";
-import { SchemaConfig } from "../schema/base_schema";
+import { SchemaConfig, EntSchema } from "../schema/base_schema";
 import { FieldInfoMap } from "../schema/schema";
-export declare class User implements Ent {
+import { Clause } from "src/core/clause";
+import { ChangesetOptions } from "../action/action";
+export declare class BaseEnt {
+    viewer: Viewer;
+    readonly data: Data;
+    readonly id: ID;
+    constructor(viewer: Viewer, data: Data);
+    getKey(): string;
+    getPrivacyPolicy(): PrivacyPolicy;
+    __setRawDBData(data: Data): void;
+}
+export declare class User extends BaseEnt implements Ent {
     viewer: Viewer;
     data: Data;
-    id: ID;
     accountID: string;
     nodeType: string;
-    getPrivacyPolicy(): PrivacyPolicy<this>;
     firstName: string;
     constructor(viewer: Viewer, data: Data);
 }
-export declare class Event implements Ent {
-    viewer: Viewer;
-    data: Data;
-    id: ID;
+export declare class Event extends BaseEnt implements Ent {
     accountID: string;
     nodeType: string;
-    getPrivacyPolicy(): PrivacyPolicy<this>;
-    constructor(viewer: Viewer, data: Data);
 }
-export declare class Contact implements Ent {
-    viewer: Viewer;
-    data: Data;
-    id: ID;
+export declare class Contact extends BaseEnt implements Ent {
     accountID: string;
     nodeType: string;
     getPrivacyPolicy(): PrivacyPolicy<this>;
-    constructor(viewer: Viewer, data: Data);
 }
-export declare class Group implements Ent {
-    viewer: Viewer;
-    data: Data;
-    id: ID;
+export declare class Group extends BaseEnt implements Ent {
     accountID: string;
     nodeType: string;
     getPrivacyPolicy(): PrivacyPolicy<this>;
-    constructor(viewer: Viewer, data: Data);
 }
-export declare class Message implements Ent {
-    viewer: Viewer;
-    data: Data;
-    id: ID;
+export declare class Message extends BaseEnt implements Ent {
     accountID: string;
     nodeType: string;
-    getPrivacyPolicy(): PrivacyPolicy<this>;
-    constructor(viewer: Viewer, data: Data);
 }
-export declare class Address implements Ent {
-    viewer: Viewer;
-    data: Data;
-    id: ID;
+export declare class Address extends BaseEnt implements Ent {
     accountID: string;
     nodeType: string;
-    getPrivacyPolicy(): PrivacyPolicy<this>;
-    constructor(viewer: Viewer, data: Data);
 }
 export interface BuilderSchema<T extends Ent> extends Schema {
     ent: EntConstructor<T>;
 }
+export declare class EntBuilderSchema<T extends Ent> extends EntSchema {
+    ent: EntConstructor<T>;
+    constructor(ent: EntConstructor<T>, cfg: SchemaConfig);
+}
 export declare function getBuilderSchema<T extends Ent>(cfg: SchemaConfig, ent: EntConstructor<T>): BuilderSchema<T>;
-export declare function getBuilderSchemaFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
+export declare function getBuilderSchemaFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>, opts?: Partial<Exclude<SchemaConfig, "fields">>): BuilderSchema<T>;
 export declare function getBuilderSchemaTZFromFields<T extends Ent>(fields: FieldMap, ent: EntConstructor<T>): BuilderSchema<T>;
 export declare function getSchemaName(value: BuilderSchema<Ent>): string;
 export declare function getTableName(value: BuilderSchema<Ent>): string;
 export declare function getFieldInfo(value: BuilderSchema<Ent>): FieldInfoMap;
-declare type MaybeNull<T extends Ent> = T | null;
-declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
-export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Builder<T> {
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Builder<T, Viewer, TExistingEnt> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
     existingEnt: TExistingEnt;
-    ent: EntConstructor<T>;
+    ent: EntConstructor<T, Viewer>;
     placeholderID: ID;
-    orchestrator: Orchestrator<T, Data, Viewer>;
+    orchestrator: Orchestrator<T, Data, Viewer, TExistingEnt>;
     fields: Map<string, any>;
     nodeType: string;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T>, Viewer, Data> | undefined);
+    m: Map<string, any>;
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation, existingEnt: TExistingEnt, action?: Action<T, SimpleBuilder<T, TExistingEnt>, Viewer, Data, TExistingEnt> | undefined, expressions?: Map<string, Clause>);
     getInput(): Data;
     updateInput(input: Data): void;
+    storeData(k: string, v: any): void;
+    getStoredData(k: string): any;
     build(): Promise<Changeset>;
+    buildWithOptions_BETA(options: ChangesetOptions): Promise<Changeset>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
     save(): Promise<void>;
@@ -99,15 +93,17 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     private fields;
     builder: SimpleBuilder<T, TExistingEnt>;
     viewerForEntLoad: viewerEntLoadFunc | undefined;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt);
-    getTriggers(): Trigger<T, SimpleBuilder<T>>[];
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation: WriteOperation | undefined, existingEnt: TExistingEnt, expressions?: Map<string, Clause>);
+    getTriggers(): (Trigger<T, SimpleBuilder<T>> | Array<Trigger<T, SimpleBuilder<T>>>)[];
     getValidators(): Validator<T, SimpleBuilder<T>>[];
     getObservers(): Observer<T, SimpleBuilder<T>>[];
     getPrivacyPolicy(): PrivacyPolicy<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>;
     getInput(): Data;
     changeset(): Promise<Changeset>;
+    changesetWithOptions_BETA(options: ChangesetOptions): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
+    validWithErrors(): Promise<Error[]>;
     save(): Promise<T | null>;
     saveX(): Promise<T>;
     editedEnt(): Promise<T | null>;