@snowtop/ent 0.1.0-alpha2 → 0.1.0-alpha3

package/package.json

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

package/parse_schema/parse.d.ts

@@ -1,4 +1,4 @@
-import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
+import { Schema, Field, AssocEdge, AssocEdgeGroup, Action, Type } from "../schema";
 import { ActionField } from "../schema/schema";
 declare enum NullableResult {
     CONTENTS = "contents",
@@ -32,12 +32,18 @@ interface ProcessedPattern {
     assocEdges: ProcessedAssocEdge[];
     fields: ProcessedField[];
 }
-declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate"> & {
+declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
+    subFields?: ProcessedField[];
+    listElemType?: ProcessedType;
+    unionFields?: ProcessedField[];
+};
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "type"> & {
     name: string;
     hasDefaultValueOnCreate?: boolean;
     hasDefaultValueOnEdit?: boolean;
     patternName?: string;
     derivedFields?: ProcessedField[];
+    type: ProcessedType;
 };
 interface patternsDict {
     [key: string]: ProcessedPattern;

package/parse_schema/parse.js

@@ -18,6 +18,7 @@ function processFields(src, patternName) {
     }
     for (const name in m) {
         const field = m[name];
+        //@ts-ignore type and other changed fields with different type in ProcessedField vs Field
         let f = { name, ...field };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
@@ -48,6 +49,18 @@ function processFields(src, patternName) {
         if (field.getDerivedFields) {
             f.derivedFields = processFields(field.getDerivedFields(name));
         }
+        if (field.type.subFields) {
+            f.type.subFields = processFields(field.type.subFields);
+        }
+        if (field.type.unionFields) {
+            f.type.unionFields = 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);
+        }
         ret.push(f);
     }
     return ret;

package/schema/field.d.ts

@@ -146,7 +146,7 @@ export declare class ListField extends BaseField {
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
-    format(val: any): any;
+    format(val: any, nested?: boolean): any;
     minLen(l: number): this;
     maxLen(l: number): this;
     length(l: number): this;

package/schema/field.js

@@ -597,13 +597,17 @@ class ListField extends BaseField {
         }
         return JSON.stringify(val);
     }
-    format(val) {
+    format(val, nested) {
         if (!Array.isArray(val)) {
             throw new Error(`need an array to format`);
         }
         const elemDBType = this.type.listElemType.dbType;
         const jsonType = elemDBType === "JSON" || elemDBType === "JSONB";
-        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        // postgres ish doesn't apply when nested
+        const postgres = !nested && db_1.default.getDialect() === db_1.Dialect.Postgres;
+        if (nested && !this.field.format) {
+            return val;
+        }
         if (!postgres && !this.field.format) {
             return JSON.stringify(val);
         }
@@ -629,6 +633,10 @@ class ListField extends BaseField {
         if (postgres) {
             return postgresRet + "}";
         }
+        // don't JSON.stringify if nested
+        if (nested) {
+            return ret;
+        }
         return JSON.stringify(ret);
     }
     minLen(l) {

package/schema/index.d.ts

@@ -4,3 +4,5 @@ export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBTy
 export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
+export * from "./struct_field";
+export * from "./union_field";

package/schema/index.js

@@ -26,3 +26,5 @@ Object.defineProperty(exports, "BaseEntSchema", { enumerable: true, get: functio
 Object.defineProperty(exports, "BaseEntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.BaseEntSchemaWithTZ; } });
 __exportStar(require("./field"), exports);
 __exportStar(require("./json_field"), exports);
+__exportStar(require("./struct_field"), exports);
+__exportStar(require("./union_field"), exports);

package/schema/schema.d.ts

@@ -97,6 +97,8 @@ export interface Type {
     values?: string[];
     enumMap?: EnumMap;
     importType?: ImportType;
+    subFields?: FieldMap;
+    unionFields?: FieldMap;
 }
 export interface ForeignKey {
     schema: string;
@@ -149,7 +151,7 @@ export interface PolymorphicOptions {
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
-    format?(val: any): any;
+    format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }
 export interface SchemaConstructor {

package/schema/struct_field.d.ts

@@ -0,0 +1,17 @@
+import { BaseField, ListField } from "./field";
+import { FieldOptions, Field, Type, FieldMap } from "./schema";
+export interface StructOptions extends FieldOptions {
+    tsType: string;
+    fields: FieldMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class StructField extends BaseField implements Field {
+    private options;
+    type: Type;
+    constructor(options: StructOptions);
+    format(obj: any, nested?: boolean): string | Object;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function StructType(options: StructOptions): StructField & StructOptions;
+export declare function StructListType(options: StructOptions): ListField;

package/schema/struct_field.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructListType = exports.StructType = exports.StructField = void 0;
+const field_1 = require("./field");
+const schema_1 = require("./schema");
+const camel_case_1 = require("camel-case");
+class StructField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.type.subFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    // right now, we store things in the db in lowerCase format
+    // this will lead to issues if field changes.
+    // TODO: use storageKey and convert back...
+    format(obj, nested) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        let ret = {};
+        for (const k in this.options.fields) {
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined) {
+                continue;
+            }
+            const field = this.options.fields[k];
+            if (field.format) {
+                // indicate nested so this isn't JSON stringified
+                ret[dbKey] = field.format(val, true);
+            }
+            else {
+                ret[dbKey] = val;
+            }
+        }
+        // don't json.stringify if nested
+        if (nested) {
+            return ret;
+        }
+        return JSON.stringify(ret);
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        // TODO probably need to support optional fields...
+        let valid = true;
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined || val === null) {
+                // nullable, nothing to do here
+                if (field.nullable) {
+                    continue;
+                }
+                valid = false;
+                break;
+            }
+            if (!field.valid) {
+                continue;
+            }
+            promises.push(field.valid(val));
+        }
+        if (!valid) {
+            return valid;
+        }
+        const ret = await Promise.all(promises);
+        return ret.every((v) => v);
+    }
+}
+exports.StructField = StructField;
+function StructType(options) {
+    let result = new StructField(options);
+    return Object.assign(result, options);
+}
+exports.StructType = StructType;
+function StructListType(options) {
+    return new field_1.ListField(StructType(options), options);
+}
+exports.StructListType = StructListType;

package/schema/union_field.d.ts

@@ -0,0 +1,22 @@
+import { StructField } from "./struct_field";
+import { FieldOptions, Type } from "./schema";
+import { BaseField, ListField } from "./field";
+export declare type StructMap = {
+    [key: string]: StructField;
+};
+export interface UnionOptions extends FieldOptions {
+    tsType: string;
+    fields: StructMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class UnionField extends BaseField implements FieldOptions {
+    private options;
+    type: Type;
+    m: Map<Object, string>;
+    constructor(options: UnionOptions);
+    format(obj: any, nested?: boolean): string | Object;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function UnionType(options: UnionOptions): UnionField & UnionOptions;
+export declare function UnionListType(options: UnionOptions): ListField;

package/schema/union_field.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionListType = exports.UnionType = exports.UnionField = void 0;
+const schema_1 = require("./schema");
+const field_1 = require("./field");
+class UnionField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.m = new Map();
+        this.type.unionFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        // TODO should throw if not nested?
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    format(obj, nested) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            const fmt = field.format(obj, nested);
+            if (fmt !== "{}") {
+                return fmt;
+            }
+        }
+        // TODO need better logic here
+        // maybe add something ignored to the objec that indicates which key?
+        // or store in map
+        throw new Error(`couldn't format union`);
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            promises.push(field.valid(obj));
+        }
+        const ret = await Promise.all(promises);
+        // only 1 should be valid
+        return ret.filter((v) => v).length === 1;
+    }
+}
+exports.UnionField = UnionField;
+function UnionType(options) {
+    let result = new UnionField(options);
+    return Object.assign(result, options);
+}
+exports.UnionType = UnionType;
+function UnionListType(options) {
+    return new field_1.ListField(UnionType(options), options);
+}
+exports.UnionListType = UnionListType;