@snowtop/ent 0.1.0-alpha47 → 0.1.0-alpha53

package/action/executor.d.ts

@@ -10,7 +10,7 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private operations;
     private options?;
     private idx;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Viewer<Ent<any> | null, ID | null>, Data, T | null> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, T | null> | undefined);
     private lastOp;
     private createdEnt;
     resolveValue(val: ID): Ent | null;
@@ -29,7 +29,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private lastOp;
     private allOperations;
     private executors;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Viewer, Data>);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;

package/action/experimental_action.d.ts

@@ -1,11 +1,14 @@
+import { Orchestrator } from "@snowtop/ent/action";
 import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
-export interface ActionOptions<T extends Ent, TData extends Data> {
-    existingEnt?: T | null;
+export interface ActionOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    existingEnt: TExistingEnt;
     input?: TData;
     operation?: WriteOperation;
 }
-interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> extends Builder<TEnt, TViewer> {
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> extends Builder<TEnt, TViewer, TExistingEnt> {
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<void>;
@@ -13,19 +16,20 @@ interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput e
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
     getInput(): TInput;
+    orchestrator: Orchestrator<TEnt, TInput, TViewer, TExistingEnt>;
 }
-export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> implements Action<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput> {
+export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> implements Action<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt> {
     viewer: TViewer;
-    builderCtr: BuilderConstructor<TEnt, TViewer, TInput>;
-    builder: EntBuilder<TEnt, TViewer, TInput>;
+    builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>;
+    builder: EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
     private input;
     getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, import("../core/base").ID | null>>, Viewer<Ent<any> | null, import("../core/base").ID | null>>;
-    getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>[];
-    constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null);
-    static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, options?: ActionOptions<TEnt, TInput> | null): Builder<TEnt>;
-    static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput>;
+    getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>);
+    static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>): Builder<TEnt>;
+    static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput, TEnt>;
     changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
@@ -33,9 +37,11 @@ export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewe
     saveX(): Promise<TEnt>;
     getInput(): TInput;
 }
-interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data> {
-    new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt, TViewer, TInput>, TViewer, TInput>, existingEnt: TEnt | null): EntBuilder<TEnt, TViewer, TInput>;
+export interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, any, TViewer, TInput, TExistingEnt>, existingEnt: TExistingEnt): EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
 }
-export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
-export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput>, existingEnt: TEnt, input: TInput): Action<TEnt, Builder<TEnt, TViewer>, TViewer, TInput>;
+export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleDeleteAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleInsertAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, null>, input: TInput): BaseAction<TEnt, TViewer, TInput, null>;
 export {};

package/action/experimental_action.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
+exports.getSimpleInsertAction = exports.getSimpleDeleteAction = exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
@@ -17,7 +17,7 @@ class BaseAction {
             }
         }
         this.input = options?.input || {};
-        this.builder = new builderCtr(viewer, operation, this, options?.existingEnt || null);
+        this.builder = new builderCtr(viewer, operation, this, options.existingEnt);
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
@@ -85,6 +85,7 @@ async function updateRawObject(viewer, builderCtr, existingEnt, input) {
     return action.saveX();
 }
 exports.updateRawObject = updateRawObject;
+// TODO need to fix types for all these
 // 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
@@ -97,3 +98,19 @@ function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
     });
 }
 exports.getSimpleEditAction = getSimpleEditAction;
+function getSimpleDeleteAction(viewer, builderCtr, existingEnt, input) {
+    return new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Delete,
+        input,
+    });
+}
+exports.getSimpleDeleteAction = getSimpleDeleteAction;
+function getSimpleInsertAction(viewer, builderCtr, input) {
+    return new BaseAction(viewer, builderCtr, {
+        operation: action_1.WriteOperation.Insert,
+        input,
+        existingEnt: null,
+    });
+}
+exports.getSimpleInsertAction = getSimpleInsertAction;

package/action/orchestrator.d.ts

@@ -5,7 +5,7 @@ import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
 declare type MaybeNull<T extends Ent> = T | null;
 declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
-export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends Data, TViewer extends Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
@@ -48,7 +48,7 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private existingEnt;
     private disableTransformations;
     private memoizedGetFields;
-    constructor(options: OrchestratorOptions<TEnt, TViewer, TInput, TExistingEnt>);
+    constructor(options: OrchestratorOptions<TEnt, TInput, TViewer, TExistingEnt>);
     private addEdge;
     setDisableTransformations(val: boolean): void;
     addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
@@ -66,6 +66,11 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private getWriteOpForSQLStamentOp;
     getPossibleUnsafeEntForPrivacy(): Promise<TEnt>;
     getEditedData(): Promise<Data>;
+    /**
+     * @returns validated and formatted fields that would be written to the db
+     * throws an error if called before valid() or validX() has been called
+     */
+    getValidatedFields(): Data;
     private getFieldsInfo;
     private validate;
     private triggers;
@@ -79,6 +84,14 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
+    /**
+     * @experimental API that's not guaranteed to remain in the future which returns
+     * a list of errors encountered
+     * 0 errors indicates valid
+     * NOTE that this currently doesn't catch errors returned by validators().
+     * If those throws, this still throws and doesn't return them
+     */
+    validWithErrors(): Promise<Error[]>;
     build(): Promise<EntChangeset<TEnt>>;
     private viewerForEntLoad;
     returnedRow(): Promise<Data | null>;
@@ -94,7 +107,7 @@ export declare class EntChangeset<T extends Ent> implements Changeset {
     changesets?: Changeset[] | undefined;
     private options?;
     private _executor;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Viewer<Ent<any> | null, ID | null>, Data, MaybeNull<T>> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
     executor(): Executor;
 }
 export {};

package/action/orchestrator.js

@@ -284,6 +284,16 @@ class Orchestrator {
         const { editedData } = await this.memoizedGetFields();
         return editedData;
     }
+    /**
+     * @returns validated and formatted fields that would be written to the db
+     * throws an error if called before valid() or validX() has been called
+     */
+    getValidatedFields() {
+        if (this.validatedFields === null) {
+            throw new Error(`trying to call getValidatedFields before validating fields`);
+        }
+        return this.validatedFields;
+    }
     // Note: this is memoized. call memoizedGetFields instead
     async getFieldsInfo() {
         const action = this.options.action;
@@ -312,8 +322,14 @@ class Orchestrator {
         // * triggers
         // * validators
         let privacyPolicy = action?.getPrivacyPolicy();
+        let privacyError = null;
         if (privacyPolicy) {
-            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicyImpl(editedData), this.throwError.bind(this));
+            try {
+                await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicyImpl(editedData), this.throwError.bind(this));
+            }
+            catch (err) {
+                privacyError = err;
+            }
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
@@ -327,10 +343,14 @@ class Orchestrator {
         // not ideal we're calling this twice. fix...
         // needed for now. may need to rewrite some of this?
         const editedFields2 = await this.options.editedFields();
-        await Promise.all([
+        const [errors, _] = await Promise.all([
             this.formatAndValidateFields(schemaFields, editedFields2),
             this.validators(validators, action, builder),
         ]);
+        if (privacyError !== null) {
+            errors.unshift(privacyError);
+        }
+        return errors;
     }
     async triggers(action, builder, triggers) {
         let groups = [];
@@ -375,6 +395,8 @@ class Orchestrator {
         }
     }
     async validators(validators, action, builder) {
+        // TODO need to catch errors and return it...
+        // don't need it initially since what we need this for doesn't have the errors
         let promises = [];
         validators.forEach((validator) => {
             let res = validator.validate(builder, action.getInput());
@@ -511,7 +533,7 @@ class Orchestrator {
         // now format and validate...
         if (value === null) {
             if (!field.nullable) {
-                throw new Error(`field ${fieldName} set to null for non-nullable field`);
+                return new Error(`field ${fieldName} set to null for non-nullable field`);
             }
         }
         else if (value === undefined) {
@@ -522,14 +544,14 @@ class Orchestrator {
                 // server default allowed
                 field.serverDefault === undefined &&
                 this.actualOperation === action_1.WriteOperation.Insert) {
-                throw new Error(`required field ${fieldName} not set`);
+                return new Error(`required field ${fieldName} not set`);
             }
         }
         else if (this.isBuilder(value)) {
             if (field.valid) {
                 const valid = await field.valid(value);
                 if (!valid) {
-                    throw new Error(`invalid field ${fieldName} with value ${value}`);
+                    return new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             // keep track of dependencies to resolve
@@ -542,7 +564,7 @@ class Orchestrator {
                 // TODO this could be async. handle this better
                 const valid = await field.valid(value);
                 if (!valid) {
-                    throw new Error(`invalid field ${fieldName} with value ${value}`);
+                    return new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             if (field.format) {
@@ -552,9 +574,10 @@ class Orchestrator {
         return value;
     }
     async formatAndValidateFields(schemaFields, editedFields) {
+        const errors = [];
         const op = this.actualOperation;
         if (op === action_1.WriteOperation.Delete) {
-            return;
+            return [];
         }
         // build up data to be saved...
         let data = {};
@@ -566,7 +589,13 @@ class Orchestrator {
                 value = this.defaultFieldsByFieldName[fieldName];
             }
             let dbKey = this.getStorageKey(fieldName);
-            value = await this.transformFieldValue(fieldName, field, dbKey, value);
+            let ret = await this.transformFieldValue(fieldName, field, dbKey, value);
+            if (ret instanceof Error) {
+                errors.push(ret);
+            }
+            else {
+                value = ret;
+            }
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
@@ -581,28 +610,48 @@ class Orchestrator {
                 let dbKey = this.getStorageKey(fieldName);
                 // no value, let's just default
                 if (data[dbKey] === undefined) {
-                    const value = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);
-                    data[dbKey] = value;
-                    logValues[dbKey] = field.logValue(value);
+                    const ret = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);
+                    if (ret instanceof Error) {
+                        errors.push(ret);
+                    }
+                    else {
+                        data[dbKey] = ret;
+                        logValues[dbKey] = field.logValue(ret);
+                    }
                 }
             }
         }
         this.validatedFields = data;
         this.logValues = logValues;
+        return errors;
     }
     async valid() {
-        try {
-            await this.validate();
-        }
-        catch (e) {
-            (0, logger_1.log)("error", e);
+        const errors = await this.validate();
+        if (errors.length) {
+            errors.map((err) => (0, logger_1.log)("error", err));
             return false;
         }
         return true;
     }
     async validX() {
+        const errors = await this.validate();
+        if (errors.length) {
+            // just throw the first one...
+            // TODO we should ideally throw all of them
+            throw errors[0];
+        }
+    }
+    /**
+     * @experimental API that's not guaranteed to remain in the future which returns
+     * a list of errors encountered
+     * 0 errors indicates valid
+     * NOTE that this currently doesn't catch errors returned by validators().
+     * If those throws, this still throws and doesn't return them
+     */
+    async validWithErrors() {
         return this.validate();
     }
+    // TODO validWithErrors
     async build() {
         // validate everything first
         await this.validX();

package/package.json

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

package/schema/field.js

@@ -642,6 +642,10 @@ class ListField extends BaseField {
     }
     postgresVal(val, jsonType) {
         if (!jsonType) {
+            // support empty strings in list
+            if (val === "") {
+                val = '"' + val + '"';
+            }
             return val;
         }
         return JSON.stringify(val);

package/testutils/builder.d.ts

@@ -70,18 +70,18 @@ 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>;
-export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Builder<T> {
+export declare class SimpleBuilder<T extends Ent, TExistingEnt extends TMaybleNullableEnt<T> = MaybeNull<T>> implements Builder<T, Viewer, TExistingEnt> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
     existingEnt: TExistingEnt;
-    ent: EntConstructor<T>;
+    ent: EntConstructor<T, Viewer>;
     placeholderID: ID;
-    orchestrator: Orchestrator<T, Data, Viewer>;
+    orchestrator: Orchestrator<T, Data, Viewer, TExistingEnt>;
     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>, Viewer, Data> | 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);
     getInput(): Data;
     updateInput(input: Data): void;
     storeData(k: string, v: any): void;
@@ -111,6 +111,7 @@ export declare class SimpleAction<T extends Ent, TExistingEnt extends TMaybleNul
     changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
+    validWithErrors(): Promise<Error[]>;
     save(): Promise<T | null>;
     saveX(): Promise<T>;
     editedEnt(): Promise<T | null>;

package/testutils/builder.js

@@ -296,6 +296,9 @@ class SimpleAction {
     validX() {
         return this.builder.orchestrator.validX();
     }
+    validWithErrors() {
+        return this.builder.orchestrator.validWithErrors();
+    }
     async save() {
         await (0, action_1.saveBuilder)(this.builder);
         if (this.builder.operation !== action_1.WriteOperation.Delete) {