@snowtop/ent 0.0.30 → 0.0.31

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) {
@@ -330,23 +331,79 @@ class Orchestrator {
                     // 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)) {
+            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));
+            }
+        }
+        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 +412,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;
     }

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.31",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

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;