@snowtop/ent 0.1.0-alpha89-16dc3410-33c4-11ed-9fc4-5d4a927887be → 0.1.0-alpha90

package/action/orchestrator.js

@@ -356,6 +356,10 @@ class Orchestrator {
                 privacyError = err;
             }
         }
+        // privacyError should return first since it's less confusing
+        if (privacyError !== null) {
+            return [privacyError];
+        }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
         if (action?.getTriggers) {
@@ -372,9 +376,6 @@ class Orchestrator {
             this.formatAndValidateFields(schemaFields, editedFields2),
             this.validators(validators, action, builder),
         ]);
-        if (privacyError !== null) {
-            errors.unshift(privacyError);
-        }
         errors.push(...errs2);
         return errors;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha89-16dc3410-33c4-11ed-9fc4-5d4a927887be",
+  "version": "0.1.0-alpha90",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.d.ts

@@ -46,7 +46,7 @@ declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFie
     listElemType?: ProcessedType;
     unionFields?: ProcessedField[];
 };
-declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy" | "type"> & {
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy" | "type" | "serverDefault"> & {
     name: string;
     hasDefaultValueOnCreate?: boolean;
     hasDefaultValueOnEdit?: boolean;
@@ -54,6 +54,7 @@ declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOn
     hasFieldPrivacy?: boolean;
     derivedFields?: ProcessedField[];
     type: ProcessedType;
+    serverDefault?: string;
 };
 interface patternsDict {
     [key: string]: ProcessedPattern;
@@ -66,7 +67,7 @@ interface Result {
 declare type PotentialSchemas = {
     [key: string]: any;
 };
-export declare function parseSchema(potentialSchemas: PotentialSchemas, globalSchema?: GlobalSchema): Result;
+export declare function parseSchema(potentialSchemas: PotentialSchemas, globalSchema?: GlobalSchema): Promise<Result>;
 interface ProcessedGlobalSchema {
     globalEdges: ProcessedAssocEdge[];
     extraEdgeFields: ProcessedField[];

package/parse_schema/parse.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
-function processFields(src, patternName) {
+async function processFields(src, patternName) {
     const ret = [];
     let m = {};
     if (Array.isArray(src)) {
@@ -60,26 +60,48 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        if (field.serverDefault !== undefined) {
+            f.serverDefault = await transformServerDefault(name, field, field.serverDefault);
+        }
         transformType(field.type);
         if (field.getDerivedFields) {
-            f.derivedFields = processFields(field.getDerivedFields(name));
+            f.derivedFields = await processFields(field.getDerivedFields(name));
         }
         if (field.type.subFields) {
-            f.type.subFields = processFields(field.type.subFields);
+            f.type.subFields = await processFields(field.type.subFields);
         }
         if (field.type.unionFields) {
-            f.type.unionFields = processFields(field.type.unionFields);
+            f.type.unionFields = await processFields(field.type.unionFields);
         }
         if (field.type.listElemType &&
             field.type.listElemType.subFields &&
             // check to avoid ts-ignore below. exists just for tsc
             f.type.listElemType) {
-            f.type.listElemType.subFields = processFields(field.type.listElemType.subFields);
+            f.type.listElemType.subFields = await processFields(field.type.listElemType.subFields);
         }
         ret.push(f);
     }
     return ret;
 }
+async function transformServerDefault(name, f, value) {
+    if (f.valid) {
+        if (!(await f.valid(value))) {
+            throw new Error(`invalid value ${value} passed to field ${name}`);
+        }
+    }
+    if (f.format) {
+        value = await f.format(value);
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "number":
+        case "bigint":
+        case "string":
+            return `${value}`;
+        default:
+            throw new Error(`invalid value ${value} passed to field ${name}`);
+    }
+}
 function transformImportType(typ) {
     if (!typ.importType) {
         return;
@@ -121,12 +143,12 @@ function processEdgeGroups(processedSchema, edgeGroups) {
         processedSchema.assocEdgeGroups.push(group2);
     }
 }
-function processPattern(patterns, pattern, processedSchema) {
+async function processPattern(patterns, pattern, processedSchema) {
     let ret = {
         ...pattern,
     };
     const name = pattern.name;
-    const fields = processFields(pattern.fields, pattern.name);
+    const fields = await processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
     if (pattern.edges) {
         const edges = processEdges(pattern.edges, pattern.name);
@@ -185,12 +207,12 @@ function processAction(action) {
     ret.actionOnlyFields = actionOnlyFields;
     return ret;
 }
-function parseSchema(potentialSchemas, globalSchema) {
+async function parseSchema(potentialSchemas, globalSchema) {
     let schemas = {};
     let patterns = {};
     let parsedGlobalSchema;
     if (globalSchema) {
-        parsedGlobalSchema = parseGlobalSchema(globalSchema);
+        parsedGlobalSchema = await parseGlobalSchema(globalSchema);
     }
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
@@ -223,7 +245,7 @@ function parseSchema(potentialSchemas, globalSchema) {
         let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                const ret = processPattern(patterns, pattern, processedSchema);
+                const ret = await processPattern(patterns, pattern, processedSchema);
                 patternNames.push(pattern.name);
                 if (ret.transformsSelect) {
                     if (processedSchema.transformsSelect) {
@@ -239,7 +261,7 @@ function parseSchema(potentialSchemas, globalSchema) {
                 }
             }
         }
-        const fields = processFields(schema.fields);
+        const fields = await processFields(schema.fields);
         processedSchema.fields.push(...fields);
         processedSchema.patternNames = patternNames;
         if (schema.edges) {
@@ -254,7 +276,7 @@ function parseSchema(potentialSchemas, globalSchema) {
     return { schemas, patterns, globalSchema: parsedGlobalSchema };
 }
 exports.parseSchema = parseSchema;
-function parseGlobalSchema(s) {
+async function parseGlobalSchema(s) {
     const ret = {
         globalEdges: [],
         extraEdgeFields: [],
@@ -263,7 +285,7 @@ function parseGlobalSchema(s) {
             s.transformEdgeWrite !== undefined,
     };
     if (s.extraEdgeFields) {
-        ret.extraEdgeFields = processFields(s.extraEdgeFields);
+        ret.extraEdgeFields = await processFields(s.extraEdgeFields);
     }
     if (s.edges) {
         ret.globalEdges = processEdges(s.edges);

package/schema/field.js

@@ -459,9 +459,10 @@ class DateField extends BaseField {
         this.type = { dbType: schema_1.DBType.Date };
     }
     format(val) {
-        if (!(val instanceof Date)) {
+        if (typeof val === "string") {
             return val;
         }
+        val = new Date(val);
         let yy = (0, exports.leftPad)(val.getFullYear());
         // lol this API
         // for some reason this is 0-index

package/scripts/read_schema.js

@@ -26,7 +26,6 @@ const glob_1 = __importDefault(require("glob"));
 const path = __importStar(require("path"));
 const pascal_case_1 = require("pascal-case");
 const minimist_1 = __importDefault(require("minimist"));
-const process_1 = require("process");
 const parse_1 = require("../parse_schema/parse");
 const ast_1 = require("../tsc/ast");
 function main() {
@@ -70,13 +69,16 @@ function main() {
         potentialSchemas[(0, pascal_case_1.pascalCase)(schema)] = s;
     }
     //  console.log(potentialSchemas);
-    const result = (0, parse_1.parseSchema)(potentialSchemas, globalSchema);
-    console.log(JSON.stringify(result));
+    // NB: do not change this to async/await
+    // doing so runs it buffer limit on linux (65536 bytes) and we lose data reading in go
+    (0, parse_1.parseSchema)(potentialSchemas, globalSchema).then((result) => {
+        console.log(JSON.stringify(result));
+    });
 }
 try {
     main();
 }
 catch (err) {
     console.error(err);
-    (0, process_1.exit)(1);
+    process.exit(1);
 }