@snowtop/ent 0.1.0-alpha3 → 0.1.0-alpha30

package/parse_schema/parse.js

@@ -22,6 +22,7 @@ function processFields(src, patternName) {
         let f = { name, ...field };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
+        f.hasFieldPrivacy = field.privacyPolicy !== undefined;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
@@ -46,6 +47,7 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        transformType(field.type);
         if (field.getDerivedFields) {
             f.derivedFields = processFields(field.getDerivedFields(name));
         }
@@ -65,6 +67,24 @@ function processFields(src, patternName) {
     }
     return ret;
 }
+function transformImportType(typ) {
+    if (!typ.importType) {
+        return;
+    }
+    typ.importType = {
+        ...typ.importType,
+        // these 2 needed for forwards compatibility with new go schema
+        importPath: typ.importType.path,
+        import: typ.importType.type,
+    };
+}
+function transformType(typ) {
+    if (!typ) {
+        return;
+    }
+    transformImportType(typ);
+    transformType(typ.listElemType);
+}
 function processEdges(src, patternName) {
     const ret = [];
     for (const edge of src) {
@@ -89,6 +109,9 @@ function processEdgeGroups(processedSchema, edgeGroups) {
     }
 }
 function processPattern(patterns, pattern, processedSchema) {
+    let ret = {
+        ...pattern,
+    };
     const name = pattern.name;
     const fields = processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
@@ -96,6 +119,10 @@ function processPattern(patterns, pattern, processedSchema) {
         const edges = processEdges(pattern.edges, pattern.name);
         processedSchema.assocEdges.push(...edges);
     }
+    // flag transformsSelect
+    if (pattern.transformRead) {
+        ret.transformsSelect = true;
+    }
     if (patterns[name] === undefined) {
         // intentionally processing separately and not passing pattern.name
         const edges = processEdges(pattern.edges || []);
@@ -103,12 +130,14 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     else {
         // TODO ideally we want to make sure that different patterns don't have the same name
         // can't do a deepEqual check because function calls and therefore different instances in fields
     }
+    return ret;
 }
 var NullableResult;
 (function (NullableResult) {
@@ -149,14 +178,19 @@ function parseSchema(potentialSchemas) {
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
         let schema;
-        if (value.constructor == Object) {
-            schema = value;
-        }
-        else {
-            schema = new value();
+        const name = value.constructor.name;
+        // named class e.g. new BaseEntSchema
+        switch (name) {
+            case "Function":
+                schema = new value();
+                break;
+            default:
+                // implicit schema or named class
+                schema = value;
         }
         let processedSchema = {
             fields: [],
+            schemaPath: schema.schemaPath,
             tableName: schema.tableName,
             enumTable: schema.enumTable,
             dbRows: schema.dbRows,
@@ -169,13 +203,28 @@ function parseSchema(potentialSchemas) {
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
+        let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                processPattern(patterns, pattern, processedSchema);
+                const ret = processPattern(patterns, pattern, processedSchema);
+                patternNames.push(pattern.name);
+                if (ret.transformsSelect) {
+                    if (processedSchema.transformsSelect) {
+                        throw new Error(`can only have one pattern which transforms default querying behavior`);
+                    }
+                    processedSchema.transformsSelect = true;
+                }
+                if (ret.transformsDelete) {
+                    if (processedSchema.transformsDelete) {
+                        throw new Error(`can only have one pattern which transforms default deletion behavior`);
+                    }
+                    processedSchema.transformsDelete = true;
+                }
             }
         }
         const fields = processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);

package/schema/base_schema.d.ts

@@ -1,6 +1,41 @@
-import { Pattern } from "./schema";
+import { Field, FieldMap, Pattern } from "./schema";
+import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
+export interface SchemaConfig extends Schema {
+}
+export declare class EntSchema implements Schema {
+    fields: FieldMap | Field[];
+    tableName: string | undefined;
+    patterns: Pattern[];
+    edges: Edge[] | undefined;
+    edgeGroups: AssocEdgeGroup[] | undefined;
+    actions: Action[] | undefined;
+    enumTable: boolean | undefined;
+    dbRows: {
+        [key: string]: any;
+    }[] | undefined;
+    constraints: Constraint[] | undefined;
+    indices: Index[] | undefined;
+    hideFromGraphQL?: boolean;
+    constructor(cfg: SchemaConfig);
+}
+export declare class EntSchemaWithTZ implements Schema {
+    fields: FieldMap | Field[];
+    tableName: string | undefined;
+    patterns: Pattern[];
+    edges: Edge[] | undefined;
+    edgeGroups: AssocEdgeGroup[] | undefined;
+    actions: Action[] | undefined;
+    enumTable: boolean | undefined;
+    dbRows: {
+        [key: string]: any;
+    }[] | undefined;
+    constraints: Constraint[] | undefined;
+    indices: Index[] | undefined;
+    hideFromGraphQL?: boolean;
+    constructor(cfg: SchemaConfig);
+}
 export declare abstract class BaseEntSchema {
     addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];

package/schema/base_schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = void 0;
+exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.EntSchemaWithTZ = exports.EntSchema = exports.Node = exports.Timestamps = void 0;
 const uuid_1 = require("uuid");
 const field_1 = require("./field");
 let tsFields = {
@@ -66,9 +66,56 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
-// Base ent schema. has Node Pattern by default.
+// Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
+class EntSchema {
+    constructor(cfg) {
+        this.patterns = [exports.Node];
+        this.fields = cfg.fields;
+        this.tableName = cfg.tableName;
+        if (cfg.patterns) {
+            this.patterns.push(...cfg.patterns);
+        }
+        this.edges = cfg.edges;
+        this.edgeGroups = cfg.edgeGroups;
+        this.actions = cfg.actions;
+        this.enumTable = cfg.enumTable;
+        this.dbRows = cfg.dbRows;
+        this.constraints = cfg.constraints;
+        this.indices = cfg.indices;
+        this.hideFromGraphQL = cfg.hideFromGraphQL;
+    }
+}
+exports.EntSchema = EntSchema;
+class EntSchemaWithTZ {
+    constructor(cfg) {
+        this.patterns = [
+            {
+                // default schema added
+                name: "nodeWithTZ",
+                fields: nodeFieldsWithTZ,
+                disableMixin: true,
+            },
+        ];
+        this.fields = cfg.fields;
+        this.tableName = cfg.tableName;
+        if (cfg.patterns) {
+            this.patterns.push(...cfg.patterns);
+        }
+        this.edges = cfg.edges;
+        this.edgeGroups = cfg.edgeGroups;
+        this.actions = cfg.actions;
+        this.enumTable = cfg.enumTable;
+        this.dbRows = cfg.dbRows;
+        this.constraints = cfg.constraints;
+        this.indices = cfg.indices;
+        this.hideFromGraphQL = cfg.hideFromGraphQL;
+    }
+}
+exports.EntSchemaWithTZ = EntSchemaWithTZ;
+// @deprecated use EntSchema
 class BaseEntSchema {
     constructor() {
         this.patterns = [exports.Node];
@@ -78,6 +125,7 @@ class BaseEntSchema {
     }
 }
 exports.BaseEntSchema = BaseEntSchema;
+// @deprecated use EntSchemaWithTZ
 class BaseEntSchemaWithTZ {
     constructor() {
         this.patterns = [
@@ -85,6 +133,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/field.d.ts

@@ -44,7 +44,7 @@ export declare function IntegerType(options?: IntegerOptions): IntegerField;
 export declare class BigIntegerField extends BaseField implements Field {
     type: Type;
 }
-export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
+export declare function BigIntegerType(options?: FieldOptions): BigIntegerField;
 export declare class FloatField extends BaseField implements Field {
     type: Type;
 }

package/schema/field.js

@@ -616,7 +616,7 @@ class ListField extends BaseField {
         for (let i = 0; i < val.length; i++) {
             let formatted = val[i];
             if (this.field.format) {
-                formatted = this.field.format(val[i]);
+                formatted = this.field.format(val[i], nested);
             }
             // postgres supports arrays natively so we
             // structure it in the expected format

package/schema/index.d.ts

@@ -1,7 +1,7 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, } from "./schema";
-export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, } from "./base_schema";
+export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, getTransformedReadClause, getObjectLoaderProperties, } from "./schema";
+export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, SchemaConfig, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
 export * from "./struct_field";

package/schema/index.js

@@ -10,20 +10,27 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.EntSchemaWithTZ = exports.EntSchema = exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "DBType", { enumerable: true, get: function () { return schema_1.DBType; } });
 Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return schema_1.getFields; } });
+Object.defineProperty(exports, "getFieldsWithPrivacy", { enumerable: true, get: function () { return schema_1.getFieldsWithPrivacy; } });
+Object.defineProperty(exports, "getStorageKey", { enumerable: true, get: function () { return schema_1.getStorageKey; } });
 Object.defineProperty(exports, "ActionOperation", { enumerable: true, get: function () { return schema_1.ActionOperation; } });
 Object.defineProperty(exports, "NoFields", { enumerable: true, get: function () { return schema_1.NoFields; } });
 Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return schema_1.ConstraintType; } });
 Object.defineProperty(exports, "requiredField", { enumerable: true, get: function () { return schema_1.requiredField; } });
 Object.defineProperty(exports, "optionalField", { enumerable: true, get: function () { return schema_1.optionalField; } });
+Object.defineProperty(exports, "SQLStatementOperation", { enumerable: true, get: function () { return schema_1.SQLStatementOperation; } });
+Object.defineProperty(exports, "getTransformedReadClause", { enumerable: true, get: function () { return schema_1.getTransformedReadClause; } });
+Object.defineProperty(exports, "getObjectLoaderProperties", { enumerable: true, get: function () { return schema_1.getObjectLoaderProperties; } });
 var base_schema_1 = require("./base_schema");
 Object.defineProperty(exports, "Timestamps", { enumerable: true, get: function () { return base_schema_1.Timestamps; } });
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return base_schema_1.Node; } });
 Object.defineProperty(exports, "BaseEntSchema", { enumerable: true, get: function () { return base_schema_1.BaseEntSchema; } });
 Object.defineProperty(exports, "BaseEntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.BaseEntSchemaWithTZ; } });
+Object.defineProperty(exports, "EntSchema", { enumerable: true, get: function () { return base_schema_1.EntSchema; } });
+Object.defineProperty(exports, "EntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.EntSchemaWithTZ; } });
 __exportStar(require("./field"), exports);
 __exportStar(require("./json_field"), exports);
 __exportStar(require("./struct_field"), exports);

package/schema/schema.d.ts

@@ -1,8 +1,16 @@
-import { Data, Ent, LoaderInfo } from "../core/base";
+import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
 import { Builder } from "../action/action";
+import { Clause } from "../core/clause";
 export declare type FieldMap = {
     [key: string]: Field;
 };
+interface FieldInfo {
+    dbCol: string;
+    inputKey: string;
+}
+export declare type FieldInfoMap = {
+    [key: string]: FieldInfo;
+};
 export default interface Schema {
     fields: FieldMap | Field[];
     tableName?: string;
@@ -61,7 +69,29 @@ export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
     fields: FieldMap | Field[];
+    disableMixin?: boolean;
     edges?: Edge[];
+    transformRead?: () => Clause;
+    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;
+    transformsDelete?: boolean;
+    transformsInsert?: boolean;
+    transformsUpdate?: boolean;
+}
+export declare enum SQLStatementOperation {
+    Insert = "insert",
+    Update = "update",
+    Delete = "delete"
+}
+export interface UpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    existingEnt: T | null;
+    viewer: Viewer;
+    data?: Map<string, any>;
+}
+export interface TransformedUpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    data?: Data;
+    existingEnt?: T | null;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -85,6 +115,7 @@ export declare enum DBType {
 export interface ImportType {
     path: string;
     type: string;
+    [x: string]: any;
 }
 declare type EnumMap = {
     [key: string]: string;
@@ -135,11 +166,13 @@ export interface FieldOptions {
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
     disableUserEditable?: boolean;
+    disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
+    privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
     getDerivedFields?(name: string): FieldMap;
     [x: string]: any;
 }
@@ -158,7 +191,20 @@ export interface SchemaConstructor {
     new (): Schema;
 }
 export declare type SchemaInputType = Schema | SchemaConstructor;
+export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
+/**
+ * @deprecated should only be used by tests
+ */
+export declare function getStorageKey(field: Field, fieldName: string): string;
+export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldMap: FieldInfoMap): Map<string, PrivacyPolicy>;
+export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
+interface objectLoaderOptions {
+    clause?: () => Clause | undefined;
+    instanceKey?: string;
+}
+export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
+export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -201,10 +247,24 @@ export interface Constraint {
     fkey?: ForeignKeyInfo;
     condition?: string;
 }
+export interface FullTextWeight {
+    A?: string[];
+    B?: string[];
+    C?: string[];
+    D?: string[];
+}
+export interface FullText {
+    generatedColumnName?: string;
+    language?: "english" | "french" | "german" | "simple";
+    languageColumn?: string;
+    indexType?: "gin" | "gist";
+    weights?: FullTextWeight;
+}
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
+    fulltext?: FullText;
 }
 export interface ForeignKeyInfo {
     tableName: string;

package/schema/schema.js

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.getFieldsWithPrivacy = exports.getStorageKey = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
+const snake_case_1 = require("snake-case");
+// we also want this transformation to exist on a per-action basis
+// if it exists on an action, we don't do the global schema transformation
+var SQLStatementOperation;
+(function (SQLStatementOperation) {
+    // transform insert e.g. to an update based on whatever logic
+    SQLStatementOperation["Insert"] = "insert";
+    // // transform select e.g. deleted_at. can't change from select to different query type
+    // // but can change the query
+    // Select = "select",
+    // e.g. change updated value
+    SQLStatementOperation["Update"] = "update";
+    // delete -> update theoretically e.g. deleted_at
+    SQLStatementOperation["Delete"] = "delete";
+})(SQLStatementOperation = exports.SQLStatementOperation || (exports.SQLStatementOperation = {}));
 // we want --strictNullChecks flag so nullable is used to type graphql, ts, db
 // should eventually generate (boolean | null) etc
 // supported db types
@@ -28,14 +43,17 @@ var DBType;
 function isSchema(value) {
     return value.fields !== undefined;
 }
-function getFields(value) {
-    let schema;
+function getSchema(value) {
     if (isSchema(value)) {
-        schema = value;
+        return value;
     }
     else {
-        schema = new value();
+        return new value();
     }
+}
+exports.getSchema = getSchema;
+function getFields(value) {
+    const schema = getSchema(value);
     function addFields(fields) {
         if (Array.isArray(fields)) {
             for (const field of fields) {
@@ -68,6 +86,109 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
+/**
+ * @deprecated should only be used by tests
+ */
+function getStorageKey(field, fieldName) {
+    return field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+}
+exports.getStorageKey = getStorageKey;
+// returns a mapping of storage key to field privacy
+function getFieldsWithPrivacy(value, fieldMap) {
+    const schema = getSchema(value);
+    function addFields(fields) {
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!field.name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                if (field.privacyPolicy) {
+                    let privacyPolicy;
+                    if (typeof field.privacyPolicy === "function") {
+                        privacyPolicy = field.privacyPolicy();
+                    }
+                    else {
+                        privacyPolicy = field.privacyPolicy;
+                    }
+                    const info = fieldMap[name];
+                    if (!info) {
+                        throw new Error(`field with name ${name} not passed in fieldMap`);
+                    }
+                    m.set(info.dbCol, privacyPolicy);
+                }
+            }
+            return;
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
+            }
+            if (field.privacyPolicy) {
+                let privacyPolicy;
+                if (typeof field.privacyPolicy === "function") {
+                    privacyPolicy = field.privacyPolicy();
+                }
+                else {
+                    privacyPolicy = field.privacyPolicy;
+                }
+                const info = fieldMap[name];
+                if (!info) {
+                    throw new Error(`field with name ${name} not passed in fieldMap`);
+                }
+                m.set(info.dbCol, privacyPolicy);
+            }
+        }
+    }
+    let m = new Map();
+    if (schema.patterns) {
+        for (const pattern of schema.patterns) {
+            addFields(pattern.fields);
+        }
+    }
+    addFields(schema.fields);
+    return m;
+}
+exports.getFieldsWithPrivacy = getFieldsWithPrivacy;
+function getTransformedReadClause(value) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return;
+    }
+    for (const p of schema.patterns) {
+        // e.g. discarded_at, deleted_at, etc
+        if (p.transformRead) {
+            // return clause.Eq('deleted_at', null);
+            return p.transformRead();
+        }
+    }
+    return;
+}
+exports.getTransformedReadClause = getTransformedReadClause;
+function getObjectLoaderProperties(value, tableName) {
+    return {
+        clause: () => getTransformedReadClause(value),
+        instanceKey: `${tableName}:transformedReadClause`,
+    };
+}
+exports.getObjectLoaderProperties = getObjectLoaderProperties;
+function getTransformedUpdateOp(value, stmt) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return null;
+    }
+    for (const p of schema.patterns) {
+        if (p.transformWrite) {
+            return p.transformWrite(stmt);
+        }
+    }
+    return null;
+}
+exports.getTransformedUpdateOp = getTransformedUpdateOp;
 // this maps to ActionOperation in ent/action.go
 var ActionOperation;
 (function (ActionOperation) {

package/schema/union_field.d.ts

@@ -15,7 +15,8 @@ export declare class UnionField extends BaseField implements FieldOptions {
     type: Type;
     m: Map<Object, string>;
     constructor(options: UnionOptions);
-    format(obj: any, nested?: boolean): string | Object;
+    format(obj: any): string | Object;
+    private validField;
     valid(obj: any): Promise<boolean>;
 }
 export declare function UnionType(options: UnionOptions): UnionField & UnionOptions;

package/schema/union_field.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionListType = exports.UnionType = exports.UnionField = void 0;
 const schema_1 = require("./schema");
 const field_1 = require("./field");
+// used to know which key in the union is valid.
+// maybe there's a better way of doing this eventually
+const KEY = "___valid___key___";
 class UnionField extends field_1.BaseField {
     constructor(options) {
         super();
@@ -19,21 +22,26 @@ class UnionField extends field_1.BaseField {
             this.type.dbType = schema_1.DBType.JSON;
         }
     }
-    format(obj, nested) {
+    format(obj) {
         if (!(obj instanceof Object)) {
             throw new Error("valid was not called");
         }
-        for (const k in this.options.fields) {
-            const field = this.options.fields[k];
-            const fmt = field.format(obj, nested);
-            if (fmt !== "{}") {
-                return fmt;
-            }
+        const k = obj[KEY];
+        if (k === undefined) {
+            throw new Error(`need to call valid first`);
         }
-        // TODO need better logic here
-        // maybe add something ignored to the objec that indicates which key?
-        // or store in map
-        throw new Error(`couldn't format union`);
+        // now delete it since we don't need it anymore
+        delete obj[KEY];
+        const field = this.options.fields[k];
+        // always nested for now so pass through
+        return field.format(obj, true);
+    }
+    async validField(k, f, obj) {
+        const valid = await f.valid(obj);
+        return {
+            valid,
+            key: k,
+        };
     }
     async valid(obj) {
         if (!(obj instanceof Object)) {
@@ -42,11 +50,21 @@ class UnionField extends field_1.BaseField {
         let promises = [];
         for (const k in this.options.fields) {
             const field = this.options.fields[k];
-            promises.push(field.valid(obj));
+            promises.push(this.validField(k, field, obj));
         }
+        let lastKey;
+        let validCt = 0;
         const ret = await Promise.all(promises);
-        // only 1 should be valid
-        return ret.filter((v) => v).length === 1;
+        for (const v of ret) {
+            if (v.valid) {
+                validCt++;
+                lastKey = v.key;
+            }
+        }
+        if (lastKey !== undefined) {
+            obj[KEY] = lastKey;
+        }
+        return validCt == 1;
     }
 }
 exports.UnionField = UnionField;