@snowtop/ent 0.1.0-alpha10 → 0.1.0-alpha101

package/parse_schema/parse.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
-function processFields(src, patternName) {
+const cosmiconfig_1 = require("cosmiconfig");
+async function processFields(src, patternName) {
     const ret = [];
     let m = {};
     if (Array.isArray(src)) {
@@ -36,6 +37,19 @@ function processFields(src, patternName) {
         else {
             delete f.polymorphic;
         }
+        if (field.private) {
+            // convert boolean into object
+            // we keep boolean as an option to keep API simple
+            if (typeof field.private === "boolean") {
+                f.private = {};
+            }
+            else {
+                f.private = field.private;
+            }
+        }
+        else {
+            delete f.private;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -47,26 +61,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;
@@ -108,12 +144,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);
@@ -130,6 +166,7 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     else {
@@ -171,9 +208,13 @@ function processAction(action) {
     ret.actionOnlyFields = actionOnlyFields;
     return ret;
 }
-function parseSchema(potentialSchemas) {
+async function parseSchema(potentialSchemas, globalSchema) {
     let schemas = {};
     let patterns = {};
+    let parsedGlobalSchema;
+    if (globalSchema) {
+        parsedGlobalSchema = await parseGlobalSchema(globalSchema);
+    }
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
         let schema;
@@ -189,6 +230,7 @@ function parseSchema(potentialSchemas) {
         }
         let processedSchema = {
             fields: [],
+            fieldOverrides: schema.fieldOverrides,
             schemaPath: schema.schemaPath,
             tableName: schema.tableName,
             enumTable: schema.enumTable,
@@ -202,9 +244,11 @@ function parseSchema(potentialSchemas) {
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
+        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) {
                         throw new Error(`can only have one pattern which transforms default querying behavior`);
@@ -219,8 +263,9 @@ function parseSchema(potentialSchemas) {
                 }
             }
         }
-        const fields = processFields(schema.fields);
+        const fields = await processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);
@@ -230,6 +275,68 @@ function parseSchema(potentialSchemas) {
         }
         schemas[key] = processedSchema;
     }
-    return { schemas, patterns };
+    const rome = translatePrettier();
+    return {
+        schemas,
+        patterns,
+        globalSchema: parsedGlobalSchema,
+        config: {
+            rome,
+        },
+    };
 }
 exports.parseSchema = parseSchema;
+function translatePrettier() {
+    const r = (0, cosmiconfig_1.cosmiconfigSync)("prettier").search();
+    if (!r) {
+        return;
+    }
+    const ret = {};
+    if (r.config.printWidth !== undefined) {
+        ret.lineWidth = parseInt(r.config.printWidth);
+    }
+    if (r.config.useTabs) {
+        ret.indentStyle = "tab";
+    }
+    else {
+        ret.indentStyle = "space";
+    }
+    if (r.config.tabWidth !== undefined) {
+        ret.indentSize = parseInt(r.config.tabWidth);
+    }
+    if (r.config.singleQuote) {
+        ret.quoteStyle = "single";
+    }
+    else {
+        ret.quoteStyle = "double";
+    }
+    if (r.config.quoteProps !== undefined) {
+        if (r.config.quoteProps === "consistent") {
+            // rome doesn't support this
+            ret.quoteProperties = "as-needed";
+        }
+        else {
+            ret.quoteProperties = r.config.quoteProps;
+        }
+    }
+    if (r.config.trailingComma !== undefined) {
+        ret.trailingComma = r.config.trailingComma;
+    }
+    return ret;
+}
+async function parseGlobalSchema(s) {
+    const ret = {
+        globalEdges: [],
+        extraEdgeFields: [],
+        initForEdges: !!s.extraEdgeFields ||
+            s.transformEdgeRead !== undefined ||
+            s.transformEdgeWrite !== undefined,
+    };
+    if (s.extraEdgeFields) {
+        ret.extraEdgeFields = await processFields(s.extraEdgeFields);
+    }
+    if (s.edges) {
+        ret.globalEdges = processEdges(s.edges);
+    }
+    return ret;
+}

package/schema/base_schema.d.ts

@@ -1,11 +1,12 @@
-import { Field, FieldMap, Pattern } from "./schema";
+import { FieldMap, Pattern, FieldOverrideMap } from "./schema";
 import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
 export interface SchemaConfig extends Schema {
 }
 export declare class EntSchema implements Schema {
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    fieldOverrides: FieldOverrideMap | undefined;
     tableName: string | undefined;
     patterns: Pattern[];
     edges: Edge[] | undefined;
@@ -21,7 +22,8 @@ export declare class EntSchema implements Schema {
     constructor(cfg: SchemaConfig);
 }
 export declare class EntSchemaWithTZ implements Schema {
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    fieldOverrides: FieldOverrideMap | undefined;
     tableName: string | undefined;
     patterns: Pattern[];
     edges: Edge[] | undefined;

package/schema/base_schema.js

@@ -66,6 +66,7 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
 // Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
@@ -73,6 +74,7 @@ class EntSchema {
     constructor(cfg) {
         this.patterns = [exports.Node];
         this.fields = cfg.fields;
+        this.fieldOverrides = cfg.fieldOverrides;
         this.tableName = cfg.tableName;
         if (cfg.patterns) {
             this.patterns.push(...cfg.patterns);
@@ -95,9 +97,11 @@ class EntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
         this.fields = cfg.fields;
+        this.fieldOverrides = cfg.fieldOverrides;
         this.tableName = cfg.tableName;
         if (cfg.patterns) {
             this.patterns.push(...cfg.patterns);
@@ -131,6 +135,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/field.d.ts

@@ -1,3 +1,4 @@
+import { Builder } from "../action/action";
 import { Field, FieldMap, FieldOptions, ForeignKey, PolymorphicOptions, Type } from "./schema";
 export declare abstract class BaseField {
     name: string;
@@ -24,31 +25,36 @@ export declare class UUIDField extends BaseField implements Field {
     valid(val: any): Promise<boolean>;
 }
 export declare function UUIDType(options?: FieldOptions): UUIDField;
-export interface IntegerOptions extends FieldOptions {
-    min?: number;
-    max?: number;
+export interface IntegerOptions extends NumberOptions<number> {
 }
-export declare class IntegerField extends BaseField implements Field {
+export interface NumberOptions<T> extends FieldOptions {
+    min?: T;
+    max?: T;
+}
+export declare class NumberField<T> extends BaseField {
     type: Type;
     private validators;
     private options;
-    constructor(options?: IntegerOptions);
-    getOptions(): IntegerOptions;
+    constructor(options?: NumberOptions<T>);
+    getOptions(): NumberOptions<T>;
     private handleOptions;
-    min(l: number): this;
-    max(l: number): this;
+    min(l: T): this;
+    max(l: T): this;
     valid(val: any): boolean;
     validate(validator: (str: number) => boolean): this;
 }
+export declare class IntegerField extends NumberField<number> implements Field {
+    type: Type;
+}
 export declare function IntegerType(options?: IntegerOptions): IntegerField;
-export declare class BigIntegerField extends BaseField implements Field {
+export declare class BigIntegerField extends NumberField<BigInt> implements Field {
     type: Type;
 }
-export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
-export declare class FloatField extends BaseField implements Field {
+export declare function BigIntegerType(options?: NumberOptions<BigInt>): BigIntegerField;
+export declare class FloatField extends NumberField<number> implements Field {
     type: Type;
 }
-export declare function FloatType(options?: FieldOptions): FloatField;
+export declare function FloatType(options?: NumberOptions<number>): FloatField;
 export declare class BooleanField extends BaseField implements Field {
     type: Type;
 }
@@ -88,6 +94,18 @@ export declare class StringField extends BaseField implements Field {
     trimLeft(): this;
     trimRight(): this;
 }
+interface PolymorphicStringOptions extends StringOptions {
+    parentFieldToValidate: string;
+    types?: string[];
+}
+export declare class PolymorphicStringField extends StringField {
+    private opts;
+    private camelCaseVals;
+    constructor(opts: PolymorphicStringOptions);
+    validateWithFullData(val: any, b: Builder<any>): boolean;
+    valid(val: any): boolean;
+    format(val: any): any;
+}
 export declare function StringType(options?: StringOptions): StringField;
 export interface TimestampOptions extends FieldOptions {
     withTimezone?: boolean;
@@ -118,31 +136,66 @@ export declare class DateField extends BaseField implements Field {
     format(val: any): any;
 }
 export declare function DateType(options?: FieldOptions): DateField;
-declare type EnumMap = {
+declare type StringEnumMap = {
     [key: string]: string;
 };
+/**
+ * @deprecated use StringEnumOptions
+ */
 export interface EnumOptions extends FieldOptions {
     values?: string[];
-    map?: EnumMap;
+    map?: StringEnumMap;
     tsType?: string;
     graphQLType?: string;
     createEnumType?: boolean;
+    disableUnknownType?: boolean;
 }
+/**
+ * @deprecated Use StringEnumField
+ */
 export declare class EnumField extends BaseField implements Field {
     type: Type;
     private values?;
     private map?;
-    constructor(options: EnumOptions);
-    convertForGQL(value: string): string;
+    constructor(options: StringEnumOptions);
+    valid(val: any): boolean;
+    format(val: any): any;
+}
+export declare class StringEnumField extends EnumField {
+}
+export interface PolymorphicStringEnumOptions extends EnumOptions {
+    parentFieldToValidate: string;
+}
+export interface StringEnumOptions extends EnumOptions {
+}
+export declare function EnumType(options: StringEnumOptions): EnumField;
+declare type IntEnumMap = {
+    [key: string]: number;
+};
+export interface IntegerEnumOptions extends FieldOptions {
+    map: IntEnumMap;
+    deprecated?: IntEnumMap;
+    tsType?: string;
+    graphQLType?: string;
+}
+export declare class IntegerEnumField extends BaseField implements Field {
+    type: Type;
+    private map;
+    constructor(options: IntegerEnumOptions);
     valid(val: any): boolean;
     format(val: any): any;
 }
-export declare function EnumType(options: EnumOptions): EnumField;
+export declare function IntegerEnumType(options: IntegerEnumOptions): IntegerEnumField;
+interface ListOptions extends FieldOptions {
+    disableJSONStringify?: boolean;
+}
 export declare class ListField extends BaseField {
     private field;
+    private options?;
     type: Type;
     private validators;
-    constructor(field: Field, options?: FieldOptions);
+    constructor(field: Field, options?: ListOptions | undefined);
+    __getElemField(): Field;
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
@@ -153,7 +206,7 @@ export declare class ListField extends BaseField {
     range(start: any, stop: any): this;
 }
 export declare function StringListType(options?: StringOptions): ListField;
-export declare function IntListType(options: FieldOptions): ListField;
+export declare function IntListType(options?: FieldOptions): ListField;
 export declare function IntegerListType(options?: FieldOptions): ListField;
 export declare function FloatListType(options?: FieldOptions): ListField;
 export declare function BigIntegerListType(options: FieldOptions): ListField;
@@ -163,6 +216,7 @@ export declare function TimestamptzListType(options?: TimestampOptions): ListFie
 export declare function TimeListType(options?: TimeOptions): ListField;
 export declare function TimetzListType(options: TimeOptions): ListField;
 export declare function DateListType(options?: FieldOptions): ListField;
-export declare function EnumListType(options: EnumOptions): ListField;
+export declare function EnumListType(options: StringEnumOptions): ListField;
+export declare function IntegerEnumListType(options: IntegerEnumOptions): ListField;
 export declare function UUIDListType(options?: FieldOptions): ListField;
 export {};