@snowtop/ent 0.0.31 → 0.0.32-alpha

package/action/orchestrator.js

@@ -380,16 +380,21 @@ class Orchestrator {
             }
         }
         else if (this.isBuilder(value)) {
-            let builder = 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(builder.placeholderID, builder);
+            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
-                let valid = await Promise.resolve(field.valid(value));
+                const valid = await Promise.resolve(field.valid(value));
                 if (!valid) {
                     throw new Error(`invalid field ${field.name} with value ${value}`);
                 }

package/package.json

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

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[];
@@ -101,9 +101,12 @@ export interface ForeignKey {
     name?: string;
     disableIndex?: boolean;
 }
+declare type loadRowFn = (type: string) => LoadEntOptions<Ent>;
 export interface FieldEdge {
     schema: string;
-    inverseEdge: string;
+    inverseEdge?: string;
+    enforceSchema?: boolean;
+    loadRowByType?: loadRowFn;
 }
 export interface FieldOptions {
     name: string;
@@ -133,7 +136,7 @@ export interface PolymorphicOptions {
 }
 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;
 }