@snowtop/ent 0.0.3-4.alpha1 → 0.0.3-5.alpha

package/package.json

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

package/parse_schema/parse.d.ts

@@ -1,4 +1,4 @@
-import { Schema, AssocEdge, AssocEdgeGroup, Action } from "../schema";
+import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
 import { ActionField } from "../schema/schema";
 declare enum NullableResult {
     CONTENTS = "contents",
@@ -12,10 +12,11 @@ declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActi
     patternName?: string;
     edgeActions?: OutputAction[];
 };
-declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups"> & {
+declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & {
     actions: OutputAction[];
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
+    fields: ProcessedField[];
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -29,7 +30,13 @@ interface schemasDict {
 interface ProcessedPattern {
     name: string;
     assocEdges: ProcessedAssocEdge[];
+    fields: ProcessedField[];
 }
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate"> & {
+    hasDefaultValueOnCreate?: boolean;
+    hasDefaultValueOnEdit?: boolean;
+    patternName?: string;
+};
 interface patternsDict {
     [key: string]: ProcessedPattern;
 }

package/parse_schema/parse.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
-function processFields(processedSchema, src) {
+function processFields(src, patternName) {
+    const ret = [];
     for (const field of src) {
         let f = { ...field };
-        f["hasDefaultValueOnCreate"] = field.defaultValueOnCreate != undefined;
-        f["hasDefaultValueOnEdit"] = field.defaultValueOnEdit != undefined;
+        f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
+        f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
             if (typeof field.polymorphic === "boolean") {
-                f["polymorphic"] = {};
+                f.polymorphic = {};
             }
             else {
-                f["polymorphic"] = field.polymorphic;
+                f.polymorphic = field.polymorphic;
             }
         }
         // convert string to object to make API consumed by go simple
@@ -24,16 +25,22 @@ function processFields(processedSchema, src) {
                 };
             }
         }
-        processedSchema.fields.push(f);
+        if (patternName) {
+            f.patternName = patternName;
+        }
+        ret.push(f);
     }
+    return ret;
 }
-function processEdges(dst, src, patternName) {
+function processEdges(src, patternName) {
+    const ret = [];
     for (const edge of src) {
         let edge2 = { ...edge };
         edge2.edgeActions = edge.edgeActions?.map((action) => processAction(action));
         edge2.patternName = patternName;
-        dst.push(edge2);
+        ret.push(edge2);
     }
+    return ret;
 }
 function processEdgeGroups(processedSchema, edgeGroups) {
     // array-ify this
@@ -49,26 +56,26 @@ function processEdgeGroups(processedSchema, edgeGroups) {
     }
 }
 function processPattern(patterns, pattern, processedSchema) {
-    // TODO kill
-    let name = pattern.name || "node";
+    const name = pattern.name;
+    const fields = processFields(pattern.fields, pattern.name);
+    processedSchema.fields.push(...fields);
+    if (pattern.edges) {
+        const edges = processEdges(pattern.edges, pattern.name);
+        processedSchema.assocEdges.push(...edges);
+    }
     if (patterns[name] === undefined) {
-        const edges = [];
-        if (pattern.edges) {
-            processEdges(edges, pattern.edges);
-        }
+        // intentionally processing separately and not passing pattern.name
+        const edges = processEdges(pattern.edges || []);
         patterns[name] = {
             name: pattern.name,
             assocEdges: edges,
+            fields: fields,
         };
     }
     else {
         // TODO ideally we want to make sure that different patterns don't have the same name
         // can't do a deepEqual check because function calls and therefore different instances in fields
     }
-    processFields(processedSchema, pattern.fields);
-    if (pattern.edges) {
-        processEdges(processedSchema.assocEdges, pattern.edges, pattern.name);
-    }
 }
 var NullableResult;
 (function (NullableResult) {
@@ -133,9 +140,11 @@ function parseSchema(potentialSchemas) {
                 processPattern(patterns, pattern, processedSchema);
             }
         }
-        processFields(processedSchema, schema.fields);
+        const fields = processFields(schema.fields);
+        processedSchema.fields.push(...fields);
         if (schema.edges) {
-            processEdges(processedSchema.assocEdges, schema.edges);
+            const edges = processEdges(schema.edges);
+            processedSchema.assocEdges.push(...edges);
         }
         if (schema.edgeGroups) {
             processEdgeGroups(processedSchema, schema.edgeGroups);

package/schema/field.js

@@ -100,7 +100,7 @@ class UUIDField extends BaseField {
             throw new Error(`couldn't get loaderInfo for ${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
+            // if builder, the nodeType of the builder and the nodeType of the loaderInfo should match
             return val.nodeType === loaderInfo.nodeType;
         }
         // TODO we need context here to make sure that we hit local cache