@snowtop/ent 0.1.2 → 0.1.3

package/action/action.d.ts

@@ -60,6 +60,21 @@ export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt
     changesetWithOptions_BETA?(options: ChangesetOptions): Promise<Changeset>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
+    /**
+     * beta API that may change. used to indicate that we should fail privacy errors
+     * silently instead of throwing an error
+     *
+     * valid will still return false
+     * validX() will still throw an error
+     * save() and saveX() will just fail silently instead of throwing an error
+     *
+     * NOTE: this doesn't make sense on a create action since we'd still try and load the ent
+     * and if it that doesn't exist, we'd throw an error
+     *
+     * so this is only useful on update or delete actions when there's an existing ent to load
+     * or when there isn't any expected return value.
+     */
+    __failPrivacySilently?(): boolean;
     getTriggers?(): (Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt> | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[])[];
     getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
     getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];

package/action/operations.d.ts

@@ -42,6 +42,14 @@ export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
     onConflict?: CreateRowOptions["onConflict"];
     builder: Builder<T>;
 }
+export declare class NoOperation<T extends Ent> implements DataOperation<T> {
+    builder: Builder<any>;
+    private row;
+    constructor(builder: Builder<any>, existingEnt?: Ent | null);
+    performWrite(queryer: Queryer, context?: Context): Promise<void>;
+    performWriteSync(queryer: SyncQueryer, context?: Context): void;
+    returnedRow(): Data | null;
+}
 export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     options: EditNodeOptions<T>;
     private existingEnt;

package/action/operations.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConditionalNodeOperation = exports.ConditionalOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.RawQueryOperation = exports.DeleteNodeOperation = void 0;
+exports.ConditionalNodeOperation = exports.ConditionalOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.NoOperation = exports.RawQueryOperation = exports.DeleteNodeOperation = void 0;
 const clause = __importStar(require("../core/clause"));
 const action_1 = require("../action");
 const schema_1 = require("../schema/schema");
@@ -82,6 +82,20 @@ class RawQueryOperation {
     }
 }
 exports.RawQueryOperation = RawQueryOperation;
+class NoOperation {
+    constructor(builder, existingEnt = null) {
+        this.builder = builder;
+        this.row = null;
+        // @ts-ignore
+        this.row = existingEnt?.data;
+    }
+    async performWrite(queryer, context) { }
+    performWriteSync(queryer, context) { }
+    returnedRow() {
+        return this.row;
+    }
+}
+exports.NoOperation = NoOperation;
 class EditNodeOperation {
     constructor(options, existingEnt = null) {
         this.options = options;

package/action/orchestrator.js

@@ -867,12 +867,29 @@ class Orchestrator {
         return this.validate();
     }
     async buildPlusChangeset(conditionalBuilder, conditionalOverride) {
-        // validate everything first
-        await this.validX();
-        let ops = [
-            this.buildMainOp(conditionalOverride ? conditionalBuilder : undefined),
-        ];
-        await this.buildEdgeOps(ops, conditionalBuilder, conditionalOverride);
+        let ops = [];
+        let processOps = true;
+        if (this.options.action?.__failPrivacySilently &&
+            this.options.action.__failPrivacySilently()) {
+            const res = await this.valid();
+            if (!res) {
+                processOps = false;
+                const op = new operations_1.NoOperation(this.options.builder, this.existingEnt);
+                this.mainOp = op;
+                ops = [op];
+                // we need an op that just returns the existing ent
+            }
+        }
+        else {
+            // validate everything first
+            await this.validX();
+        }
+        if (processOps) {
+            ops = [
+                this.buildMainOp(conditionalOverride ? conditionalBuilder : undefined),
+            ];
+            await this.buildEdgeOps(ops, conditionalBuilder, conditionalOverride);
+        }
         // TODO throw if we try and create a new changeset after previously creating one
         // TODO test actualOperation value
         // observers is fine since they're run after and we have the actualOperation value...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/testutils/builder.d.ts

@@ -98,6 +98,7 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     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>>;
+    __failPrivacySilently(): boolean;
     getInput(): Data;
     changeset(): Promise<Changeset>;
     changesetWithOptions_BETA(options: ChangesetOptions): Promise<Changeset>;

package/testutils/builder.js

@@ -285,6 +285,9 @@ class SimpleAction {
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
+    __failPrivacySilently() {
+        return false;
+    }
     getInput() {
         const ret = {};
         for (const [k, v] of this.fields) {