@snowtop/ent 0.0.30 → 0.0.32-alpha.3

package/action/action.d.ts

@@ -7,7 +7,7 @@ export declare enum WriteOperation {
     Delete = "delete"
 }
 export interface Builder<T extends Ent> {
-    existingEnt?: Ent;
+    existingEnt?: T;
     ent: EntConstructor<T>;
     placeholderID: ID;
     readonly viewer: Viewer;

package/action/experimental_action.d.ts

@@ -1,4 +1,4 @@
-import { Viewer, Ent } from "../core/base";
+import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
 export interface ActionOptions<T extends Ent> {
     existingEnt?: T | null;
@@ -35,4 +35,6 @@ export declare class BaseAction<T extends Ent> implements Action<T> {
 interface BuilderConstructor<T extends Ent> {
     new (viewer: Viewer, operation: WriteOperation, action: Action<T>, existingEnt?: T | undefined): EntBuilder<T>;
 }
+export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Action<TEnt>;
 export {};

package/action/experimental_action.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAction = void 0;
+exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
@@ -66,3 +66,28 @@ class BaseAction {
     }
 }
 exports.BaseAction = BaseAction;
+// this provides a way to just update a row in the database.
+// skips privacy, triggers, observers, etc
+// does do field validation
+// note that only editable fields in the builder can be passed here
+async function updateRawObject(viewer, builderCtr, existingEnt, input) {
+    const action = new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Edit,
+        input,
+    });
+    return action.saveX();
+}
+exports.updateRawObject = updateRawObject;
+// creates an action which has no privacy, triggers, observers etc
+// does do field validation
+// useful to batch a bunch of writes together with BaseAction.bulkAction
+// note that only editable fields in the builder can be passed here
+function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
+    return new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Edit,
+        input,
+    });
+}
+exports.getSimpleEditAction = getSimpleEditAction;

package/action/orchestrator.d.ts

@@ -59,6 +59,8 @@ export declare class Orchestrator<T extends Ent> {
     private validators;
     private isBuilder;
     private getFieldsWithDefaultValues;
+    private hasData;
+    private transformFieldValue;
     private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;

package/action/orchestrator.js

@@ -303,6 +303,7 @@ class Orchestrator {
     getFieldsWithDefaultValues(builder, schemaFields, action) {
         const editedFields = this.options.editedFields();
         let data = {};
+        let defaultData = {};
         let input = action?.getInput() || {};
         let updateInput = false;
         for (const [fieldName, field] of schemaFields) {
@@ -327,26 +328,86 @@ class Orchestrator {
                 if (field.defaultValueOnEdit &&
                     this.options.operation === action_1.WriteOperation.Edit) {
                     defaultValue = field.defaultValueOnEdit(builder, input);
-                    // TODO special case this if this is the only thing changing and don't do the write.
                 }
             }
-            data[dbKey] = value;
+            if (value !== undefined) {
+                data[dbKey] = value;
+            }
             if (defaultValue !== undefined) {
                 updateInput = true;
-                data[dbKey] = defaultValue;
+                defaultData[dbKey] = defaultValue;
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
                 // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
                 this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
             }
         }
-        if (updateInput && this.options.updateInput) {
-            // this basically fixes #605. just needs to be exposed correctly
-            this.options.updateInput(this.defaultFieldsByTSName);
+        // if there's data changing, add data
+        if (this.hasData(data)) {
+            data = {
+                ...data,
+                ...defaultData,
+            };
+            if (updateInput && this.options.updateInput) {
+                // this basically fixes #605. just needs to be exposed correctly
+                this.options.updateInput(this.defaultFieldsByTSName);
+            }
         }
         return data;
     }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
+    async transformFieldValue(field, dbKey, value) {
+        // now format and validate...
+        if (value === null) {
+            if (!field.nullable) {
+                throw new Error(`field ${field.name} set to null for non-nullable field`);
+            }
+        }
+        else if (value === undefined) {
+            if (!field.nullable &&
+                // required field can be skipped if server default set
+                // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
+                // not setting server default as we're depending on the database handling that.
+                // server default allowed
+                field.serverDefault === undefined &&
+                this.options.operation === action_1.WriteOperation.Insert) {
+                throw new Error(`required field ${field.name} not set`);
+            }
+        }
+        else if (this.isBuilder(value)) {
+            if (field.valid) {
+                const valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                }
+            }
+            // keep track of dependencies to resolve
+            this.dependencies.set(value.placeholderID, value);
+            // keep track of fields to resolve
+            this.fieldsToResolve.push(dbKey);
+        }
+        else {
+            if (field.valid) {
+                // TODO this could be async. handle this better
+                const valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                }
+            }
+            if (field.format) {
+                // TODO this could be async e.g. password. handle this better
+                value = await Promise.resolve(field.format(value));
+            }
+        }
+        return value;
+    }
     async formatAndValidateFields(schemaFields) {
-        if (this.options.operation == action_1.WriteOperation.Delete) {
+        const op = this.options.operation;
+        if (op === action_1.WriteOperation.Delete) {
             return;
         }
         const editedFields = this.options.editedFields();
@@ -355,53 +416,32 @@ class Orchestrator {
         let logValues = {};
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
-            if (value === undefined) {
+            if (value === undefined && op === action_1.WriteOperation.Insert) {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
             let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
-            // now format and validate...
-            if (value === null) {
-                if (!field.nullable) {
-                    throw new Error(`field ${field.name} set to null for non-nullable field`);
-                }
-            }
-            else if (value === undefined) {
-                if (!field.nullable &&
-                    // required field can be skipped if server default set
-                    // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
-                    // not setting server default as we're depending on the database handling that.
-                    // server default allowed
-                    field.serverDefault === undefined &&
-                    this.options.operation === action_1.WriteOperation.Insert) {
-                    throw new Error(`required field ${field.name} not set`);
-                }
-            }
-            else if (this.isBuilder(value)) {
-                let builder = value;
-                // keep track of dependencies to resolve
-                this.dependencies.set(builder.placeholderID, builder);
-                // keep track of fields to resolve
-                this.fieldsToResolve.push(dbKey);
-            }
-            else {
-                if (field.valid) {
-                    // TODO this could be async. handle this better
-                    let valid = await Promise.resolve(field.valid(value));
-                    if (!valid) {
-                        throw new Error(`invalid field ${field.name} with value ${value}`);
-                    }
-                }
-                if (field.format) {
-                    // TODO this could be async e.g. password. handle this better
-                    value = await Promise.resolve(field.format(value));
-                }
-            }
+            value = await this.transformFieldValue(field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
             }
         }
+        //  we ignored default values while editing.
+        // if we're editing and there's data, add default values
+        if (op === action_1.WriteOperation.Edit && this.hasData(data)) {
+            for (const fieldName in this.defaultFieldsByFieldName) {
+                const defaultValue = this.defaultFieldsByFieldName[fieldName];
+                let field = schemaFields.get(fieldName);
+                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                // no value, let's just default
+                if (data[dbKey] === undefined) {
+                    const value = await this.transformFieldValue(field, dbKey, defaultValue);
+                    data[dbKey] = value;
+                    logValues[dbKey] = field.logValue(value);
+                }
+            }
+        }
         this.validatedFields = data;
         this.logValues = logValues;
     }
@@ -423,7 +463,6 @@ class Orchestrator {
         await this.validX();
         let ops = [this.buildMainOp()];
         await this.buildEdgeOps(ops);
-        //    console.log("post build");
         return new EntChangeset(this.options.viewer, this.options.builder.placeholderID, this.options.loaderOptions.ent, ops, this.dependencies, this.changesets, this.options);
     }
     async viewerForEntLoad(data) {

package/core/ent.d.ts

@@ -61,6 +61,7 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     placeholderID?: ID | undefined;
     constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
     resolve<T extends Ent>(executor: Executor): void;
+    private hasData;
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     private reloadRow;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;

package/core/ent.js

@@ -421,13 +421,24 @@ class EditNodeOperation {
         });
         this.options.fields = fields;
     }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
     async performWrite(queryer, context) {
         let options = {
             ...this.options,
             context,
         };
         if (this.existingEnt) {
-            this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+            if (this.hasData(options.fields)) {
+                this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+            }
+            else {
+                this.row = this.existingEnt["data"];
+            }
         }
         else {
             this.row = await createRow(queryer, options, "RETURNING *");
@@ -455,8 +466,13 @@ class EditNodeOperation {
             context,
         };
         if (this.existingEnt) {
-            editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
-            this.reloadRow(queryer, this.existingEnt.id, options);
+            if (this.hasData(this.options.fields)) {
+                editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
+                this.reloadRow(queryer, this.existingEnt.id, options);
+            }
+            else {
+                this.row = this.existingEnt["data"];
+            }
         }
         else {
             createRowSync(queryer, options, "RETURNING *");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.30",
+  "version": "0.0.32-alpha.3",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.js

@@ -16,6 +16,14 @@ function processFields(processedSchema, src) {
                 f["polymorphic"] = field.polymorphic;
             }
         }
+        // convert string to object to make API consumed by go simple
+        if (f.fieldEdge && f.fieldEdge.inverseEdge) {
+            if (typeof f.fieldEdge.inverseEdge === "string") {
+                f.fieldEdge.inverseEdge = {
+                    name: f.fieldEdge.inverseEdge,
+                };
+            }
+        }
         processedSchema.fields.push(f);
     }
 }

package/schema/base_schema.js

@@ -37,7 +37,7 @@ let nodeField = (0, field_1.UUIDType)({
         return (0, uuid_1.v4)();
     },
 });
-let nodeFields = [nodeField].concat(tsFields);
+let nodeFields = [nodeField, ...tsFields];
 let nodeFieldsWithTZ = [
     nodeField,
     (0, field_1.TimestampType)({

package/schema/field.d.ts

@@ -17,8 +17,11 @@ export declare abstract class BaseField {
     logValue(val: any): any;
 }
 export declare class UUIDField extends BaseField implements Field {
+    private options;
     type: Type;
     constructor(options: FieldOptions);
+    private isBuilder;
+    valid(val: any): Promise<boolean>;
 }
 export declare function UUIDType(options: FieldOptions): UUIDField;
 export interface IntegerOptions extends FieldOptions {

package/schema/field.js

@@ -37,6 +37,7 @@ exports.BaseField = BaseField;
 class UUIDField extends BaseField {
     constructor(options) {
         super();
+        this.options = options;
         this.type = { dbType: schema_1.DBType.UUID };
         const polymorphic = options.polymorphic;
         if (polymorphic) {
@@ -80,6 +81,26 @@ class UUIDField extends BaseField {
                 ];
             }
         }
+        if (options.fieldEdge?.enforceSchema && !options.fieldEdge.loadRowByType) {
+            throw new Error(`cannot enforceSchema if loadRowByType wasn't passed in`);
+        }
+    }
+    isBuilder(val) {
+        return val.placeholderID !== undefined;
+    }
+    async valid(val) {
+        if (!this.options.fieldEdge?.enforceSchema) {
+            return true;
+        }
+        const loadRowByType = this.options.fieldEdge.loadRowByType;
+        const loadRowOptions = loadRowByType(this.options.fieldEdge.schema);
+        if (this.isBuilder(val)) {
+            // if builder, the ent type of the builder and the ent type returned by the load constructor should match
+            return val.ent === loadRowOptions.ent;
+        }
+        // TODO we need context here to make sure that we hit local cache
+        const row = await loadRowOptions.loaderFactory.createLoader().load(val);
+        return row !== null;
     }
 }
 exports.UUIDField = UUIDField;

package/schema/schema.d.ts

@@ -1,4 +1,4 @@
-import { Data, Ent } from "../core/base";
+import { Data, Ent, LoadEntOptions } from "../core/base";
 import { Builder } from "../action/action";
 export default interface Schema {
     fields: Field[];
@@ -100,10 +100,21 @@ export interface ForeignKey {
     column: string;
     name?: string;
     disableIndex?: boolean;
+    disableBuilderType?: boolean;
+}
+declare type loadRowFn = (type: string) => LoadEntOptions<Ent>;
+export interface InverseFieldEdge {
+    name: string;
+    edgeConstName?: string;
+    tableName?: string;
+    hideFromGraphQL?: boolean;
 }
 export interface FieldEdge {
     schema: string;
-    inverseEdge: string;
+    inverseEdge?: string | InverseFieldEdge;
+    enforceSchema?: boolean;
+    loadRowByType?: loadRowFn;
+    disableBuilderType?: boolean;
 }
 export interface FieldOptions {
     name: string;
@@ -130,10 +141,11 @@ export interface FieldOptions {
 export interface PolymorphicOptions {
     types?: string[];
     hideFromInverseGraphQL?: boolean;
+    disableBuilderType?: boolean;
 }
 export interface Field extends FieldOptions {
     type: Type;
-    valid?(val: any): boolean;
+    valid?(val: any): Promise<boolean> | boolean;
     format?(val: any): any;
     logValue(val: any): any;
 }

package/testutils/builder.d.ts

@@ -66,12 +66,12 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
-    existingEnt: Ent | undefined;
+    existingEnt: T | undefined;
     ent: EntConstructor<T>;
     placeholderID: ID;
     orchestrator: Orchestrator<T>;
     fields: Map<string, any>;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: Ent | undefined, action?: Action<T> | undefined);
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T> | undefined);
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
@@ -100,5 +100,6 @@ export declare class SimpleAction<T extends Ent> implements Action<T> {
     save(): Promise<T | null>;
     saveX(): Promise<T>;
     editedEnt(): Promise<T | null>;
+    editedEntX(): Promise<T>;
 }
 export {};

package/testutils/builder.js

@@ -203,16 +203,19 @@ class SimpleAction {
     async save() {
         await (0, action_1.saveBuilder)(this.builder);
         if (this.builder.operation !== action_1.WriteOperation.Delete) {
-            return await this.builder.orchestrator.editedEnt();
+            return this.builder.orchestrator.editedEnt();
         }
         return null;
     }
     async saveX() {
         await (0, action_1.saveBuilderX)(this.builder);
-        return await this.builder.orchestrator.editedEntX();
+        return this.builder.orchestrator.editedEntX();
     }
     async editedEnt() {
-        return await this.builder.orchestrator.editedEnt();
+        return this.builder.orchestrator.editedEnt();
+    }
+    async editedEntX() {
+        return this.builder.orchestrator.editedEntX();
     }
 }
 exports.SimpleAction = SimpleAction;