@snowtop/ent 0.1.0-alpha78 → 0.1.0-alpha80

package/core/clause.js

@@ -184,9 +184,9 @@ class postgresArrayOperator {
     }
     logValues() {
         if (isSensitive(this.value)) {
-            return [this.value.logValue()];
+            return [`{${this.value.logValue()}}`];
         }
-        return [this.value];
+        return [`{${this.value}}`];
     }
     instanceKey() {
         if (this.not) {
@@ -211,6 +211,18 @@ class postgresArrayOperatorList extends postgresArrayOperator {
                 .join(", ")}}`,
         ];
     }
+    logValues() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.logValue();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
 }
 class inClause {
     constructor(col, value, type = "uuid") {

package/package.json

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

package/schema/field.d.ts

@@ -170,6 +170,7 @@ export declare class ListField extends BaseField {
     type: Type;
     private validators;
     constructor(field: Field, options?: FieldOptions);
+    __getElemField(): Field;
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
@@ -180,7 +181,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;

package/schema/field.js

@@ -618,6 +618,9 @@ class ListField extends BaseField {
         };
         Object.assign(this, options);
     }
+    __getElemField() {
+        return this.field;
+    }
     validate(validator) {
         this.validators.push(validator);
         return this;

package/testutils/db/fixture.d.ts

@@ -0,0 +1,10 @@
+import { Client } from "pg";
+import { Data } from "../../core/base";
+import { Schema } from "../../schema";
+interface Options {
+    overrides?: Data;
+    client: Client;
+    tableName: string;
+}
+export declare function writeFixture(schema: Schema, opts: Options): Promise<void>;
+export {};

package/testutils/db/fixture.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFixture = void 0;
+const schema_1 = require("../../schema");
+const value_1 = require("./value");
+const ent_1 = require("../../core/ent");
+async function writeFixture(schema, opts) {
+    const fields = (0, schema_1.getFields)(schema);
+    const d = {};
+    for (const [fieldName, field] of fields) {
+        const col = (0, schema_1.getStorageKey)(field, fieldName);
+        const val = (0, value_1.getDefaultValue)(field, col);
+        d[col] = val;
+    }
+    if (opts.overrides) {
+        for (const k in opts.overrides) {
+            d[k] = opts.overrides[k];
+        }
+    }
+    const q = (0, ent_1.buildInsertQuery)({
+        tableName: opts.tableName,
+        fields: d,
+    });
+    await opts.client.query(q[0], q[1]);
+}
+exports.writeFixture = writeFixture;

package/testutils/db/value.d.ts

@@ -0,0 +1,6 @@
+import { Field, Schema } from "../../schema";
+interface Info {
+    schema: Schema;
+}
+export declare function getDefaultValue(f: Field, col: string, infos?: Map<string, Info>): any;
+export {};

package/testutils/db/value.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultValue = void 0;
+const uuid_1 = require("uuid");
+const schema_1 = require("../../schema");
+const schema_2 = require("../../schema");
+function random() {
+    return Math.random().toString(16).substring(2);
+}
+function randomEmail(domain) {
+    domain = domain || "email.com";
+    return `test+${random()}@${domain}`;
+}
+function randomPhoneNumber() {
+    return `+1${Math.random().toString(10).substring(2, 11)}`;
+}
+function coinFlip() {
+    return Math.floor(Math.random() * 10) >= 5;
+}
+function specialType(typ, col) {
+    let list = m.get(typ.dbType);
+    if (list?.length) {
+        for (const l of list) {
+            let regex = [];
+            if (Array.isArray(l.regex)) {
+                regex = l.regex;
+            }
+            else {
+                regex = [l.regex];
+            }
+            for (const r of regex) {
+                if (r.test(col)) {
+                    return l.newValue();
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function getDefaultValue(f, col, infos) {
+    if (f.defaultValueOnCreate) {
+        // @ts-ignore
+        return f.defaultValueOnCreate();
+    }
+    // half the time, return null for nullable
+    if (f.nullable && coinFlip()) {
+        return null;
+    }
+    const specialVal = specialType(f.type, col);
+    if (specialVal !== undefined) {
+        return specialVal;
+    }
+    return getValueForType(f.type, f, infos);
+}
+exports.getDefaultValue = getDefaultValue;
+function getValueForType(typ, f, infos) {
+    switch (typ.dbType) {
+        case schema_1.DBType.UUID:
+            return (0, uuid_1.v4)();
+        case schema_1.DBType.Boolean:
+            return coinFlip();
+        case schema_1.DBType.Date:
+            return (0, schema_2.DateType)().format(new Date());
+        case schema_1.DBType.Time:
+            return (0, schema_2.TimeType)().format(new Date());
+        case schema_1.DBType.Timetz:
+            return (0, schema_2.TimetzType)().format(new Date());
+        case schema_1.DBType.Timestamp:
+            return (0, schema_2.TimestampType)().format(new Date());
+        case schema_1.DBType.Timestamptz:
+            return (0, schema_2.TimestamptzType)().format(new Date());
+        case schema_1.DBType.String:
+            return random();
+        case schema_1.DBType.Int:
+            return Math.floor(Math.random() * 100000000);
+        case schema_1.DBType.Float:
+            return Math.random() * 100000000;
+        case schema_1.DBType.Enum:
+        case schema_1.DBType.StringEnum:
+            if (typ.values) {
+                const idx = Math.floor(Math.random() * typ.values.length);
+                return typ.values[idx];
+            }
+            if (typ.enumMap) {
+                const vals = Object.values(typ.enumMap);
+                const idx = Math.floor(Math.random() * vals.length);
+                return vals[idx];
+            }
+            if (f.foreignKey) {
+                const schema = f.foreignKey.schema;
+                const col = f.foreignKey.column;
+                if (!infos) {
+                    throw new Error(`infos required for enum with foreignKey`);
+                }
+                const info = infos.get(schema);
+                if (!info) {
+                    throw new Error(`couldn't load data for schema ${schema}`);
+                }
+                if (!info.schema.dbRows) {
+                    throw new Error(`no dbRows for schema ${schema}`);
+                }
+                const idx = Math.floor(Math.random() * info.schema.dbRows.length);
+                return info.schema.dbRows[idx][col];
+            }
+            throw new Error("TODO: enum without values not currently supported");
+        case schema_1.DBType.IntEnum:
+            const vals = Object.values(typ.intEnumMap);
+            const idx = Math.floor(Math.random() * vals.length);
+            return vals[idx];
+        case schema_1.DBType.BigInt:
+            return BigInt(Math.floor(Math.random() * 100000000));
+        case schema_1.DBType.JSONB:
+            // type as list
+            if (typ.listElemType?.dbType === schema_1.DBType.JSONB) {
+                const values = [];
+                for (let i = 0; i < 10; i++) {
+                    values.push(getValueForType(typ.listElemType, f, infos));
+                }
+                if (!f.format) {
+                    throw new Error("invalid format");
+                }
+                return f.format(values);
+            }
+            return (0, schema_2.JSONBType)().format({});
+        case schema_1.DBType.JSON:
+            return (0, schema_2.JSONType)().format({});
+        case schema_1.DBType.List:
+            // just do 10
+            const values = [];
+            for (let i = 0; i < 10; i++) {
+                values.push(getValueForType(f.type.listElemType, f.__getElemField(), infos));
+            }
+            if (!f.format) {
+                throw new Error("invalid format");
+            }
+            return f.format(values);
+        default:
+            throw new Error(`unsupported type ${typ.dbType}`);
+    }
+}
+const emailType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        return (0, schema_2.StringType)().format(randomEmail().toLowerCase());
+    },
+    regex: /^email(_address)|_email$/,
+};
+const pdt = (0, schema_2.StringType)();
+const phoneType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        return randomPhoneNumber();
+    },
+    regex: /^phone(_number)?|_phone$|_phone_number$/,
+};
+const passwordType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        // we don't use password type because when we're generating so many rows, it's too slow...
+        return random();
+    },
+    regex: /^password/,
+};
+const firstNames = [
+    "Daenerys",
+    "Jon",
+    "Arya",
+    "Sansa",
+    "Eddard",
+    "Khal",
+    "Robb",
+    "Joffrey",
+    "Ramsay",
+    "Cersei",
+    "Bolton",
+    "Oberyn",
+    "Jojen",
+    "Petyr",
+    "Brienne",
+    "Ygritte",
+    "Missandei",
+    "Shae",
+    "Sandor",
+    "Theon",
+    "Catelyn",
+    "Gilly",
+    "Samwell",
+    "Jaime",
+    "Stannis",
+    "Tyene",
+    "Obara",
+    "Nymeria",
+    "Elia",
+    "Ellaria",
+    "Myrcella",
+    "Hodor",
+    "Osha",
+    "Meera",
+    "Davos",
+    "Gendry",
+];
+const lastNames = [
+    "Stark",
+    "Targaryen",
+    "Lannister",
+    "Drogo",
+    "Baratheon",
+    "Reed",
+    "Martell",
+    "Tyrell",
+    "Clegane",
+    "Baelish",
+    "Greyjoy",
+    "Tarly",
+    "Sand",
+    "Snow",
+    "Bolton",
+    "Frey",
+    "Tarth",
+    "Payne",
+    "Seaworth",
+];
+const firstNameType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        let idx = Math.floor(firstNames.length * Math.random());
+        return firstNames[idx];
+    },
+    regex: /^first_?(name)?/,
+};
+const lastNameType = {
+    dbType: schema_1.DBType.String,
+    newValue: () => {
+        let idx = Math.floor(lastNames.length * Math.random());
+        return lastNames[idx];
+    },
+    regex: /^last_?(name)?/,
+};
+let types = [
+    phoneType,
+    emailType,
+    passwordType,
+    firstNameType,
+    lastNameType,
+];
+let m = new Map();
+for (const type of types) {
+    let list = m.get(type.dbType) || [];
+    list.push(type);
+    m.set(type.dbType, list);
+}

package/testutils/db_time_zone.d.ts

@@ -0,0 +1,4 @@
+export declare class DBTimeZone {
+    private static getVal;
+    static getDateOffset(d: Date): Promise<string>;
+}

package/testutils/db_time_zone.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBTimeZone = void 0;
+const luxon_1 = require("luxon");
+const schema_1 = require("../schema");
+const db_1 = __importDefault(require("../core/db"));
+let dbCurrentZone = undefined;
+class DBTimeZone {
+    static async getVal() {
+        if (dbCurrentZone !== undefined) {
+            return dbCurrentZone;
+        }
+        const r = await db_1.default.getInstance()
+            .getPool()
+            .query("SELECT current_setting('TIMEZONE');");
+        if (r.rows.length) {
+            dbCurrentZone = r.rows[0].current_setting;
+        }
+        else {
+            dbCurrentZone = null;
+        }
+        return dbCurrentZone;
+    }
+    static async getDateOffset(d) {
+        let zone = await DBTimeZone.getVal();
+        let dt = luxon_1.DateTime.fromJSDate(d);
+        if (zone) {
+            dt = dt.setZone(zone);
+        }
+        // use
+        const val = (0, schema_1.leftPad)(dt.get("offset") / 60);
+        if (val == "00") {
+            return "+00";
+        }
+        return val;
+    }
+}
+exports.DBTimeZone = DBTimeZone;