@snowtop/ent 0.1.0-alpha96-2a5ea200-82e5-11ed-8c55-4da1cd949242 → 0.1.0-alpha96

package/schema/schema.js

@@ -56,22 +56,6 @@ exports.getSchema = getSchema;
 function getFields(value) {
     const schema = getSchema(value);
     function addFields(fields) {
-        if (Array.isArray(fields)) {
-            for (const field of fields) {
-                if (field.dbOnly) {
-                    continue;
-                }
-                const name = field.name;
-                if (!name) {
-                    throw new Error(`name required`);
-                }
-                if (field.getDerivedFields !== undefined) {
-                    addFields(field.getDerivedFields(name));
-                }
-                m.set(name, field);
-            }
-            return;
-        }
         for (const name in fields) {
             const field = fields[name];
             if (field.dbOnly) {

package/scripts/custom_graphql.js

@@ -114,6 +114,7 @@ function processTopLevel(l, l2) {
             fieldType: custom.fieldType,
             args: transformArgs(custom),
             results: transformResultType(custom),
+            description: custom.description,
         });
     }
 }
@@ -128,6 +129,7 @@ function processCustomFields(fields, gqlCapture, nodeName) {
             fieldType: f.fieldType,
             args: transformArgs(f),
             results: transformResultType(f),
+            description: f.description,
         });
     }
     m.set(nodeName, results);
@@ -213,11 +215,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 !== "/") {
@@ -232,6 +250,10 @@ 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
@@ -345,6 +367,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/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 {};

package/testutils/action/complex_schemas.js

@@ -0,0 +1,398 @@
+"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)(),
+    recipient: (0, field_1.StringType)(),
+    message: (0, field_1.StringType)(),
+    transient: (0, field_1.BooleanType)({ nullable: true }),
+    expiresAt: (0, field_1.TimestampType)({ nullable: true }),
+}, 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");
+                    builder.orchestrator.addInboundEdge(sender, "senderToMessage", "user");
+                    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

@@ -4,60 +4,45 @@ import { Action, Builder, Changeset, WriteOperation, Validator, Trigger, Observe
 import { FieldMap, Schema } from "../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";
+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>;
@@ -67,13 +52,13 @@ export declare class EntBuilderSchema<T extends Ent> extends EntSchema {
     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>;
+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;
@@ -85,7 +70,7 @@ export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNu
     fields: Map<string, any>;
     nodeType: string;
     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);
+    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;
@@ -106,7 +91,7 @@ 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);
+    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>>[];