@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha151

package/testutils/db/value.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultValue = exports.randomEmail = 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}`;
+}
+exports.randomEmail = randomEmail;
+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 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_mock.d.ts

@@ -18,7 +18,8 @@ export declare enum queryType {
     UPDATE = 2,
     BEGIN = 3,
     COMMIT = 4,
-    ROLLBACK = 5
+    ROLLBACK = 5,
+    DELETE = 6
 }
 export interface queryStructure {
     tableName?: string;
@@ -32,11 +33,14 @@ interface internalQueryStructure extends queryStructure {
     suffix?: string;
     setClause?: string;
 }
+/**
+ * @deprecated
+ */
 export declare class QueryRecorder {
     private static queries;
     private static ids;
     private static data;
-    private static getQueryStructure;
+    static getQueryStructure(query: any): internalQueryStructure | null;
     private static recordQuery;
     static newID(): ID;
     static getCurrentIDs(): ID[];
@@ -46,8 +50,16 @@ export declare class QueryRecorder {
     static clear(): void;
     static clearQueries(): void;
     static getCurrentQueries(): queryOptions[];
-    static validateQueryStructuresFromLogs(ml: MockLogs, expected: queryStructure[], skipSelect?: boolean): void;
-    private static validateQuryStructuresImpl;
+    /**
+     * @deprecated will keep this since it's just using ml.logs
+     * which we still want around (I think) but we should eventually
+     * probably stop using this
+     */
+    static validateQueryStructuresFromLogs(ml: MockLogs, expected: queryStructure[], opts?: {
+        skipSelect?: boolean;
+        flagBeginCommit?: boolean;
+    }): void;
+    private static validateQueryStructuresImpl;
     static mockPool(pool: typeof Pool): void;
 }
 export {};

package/testutils/db_mock.js

@@ -29,7 +29,11 @@ var queryType;
     queryType[queryType["BEGIN"] = 3] = "BEGIN";
     queryType[queryType["COMMIT"] = 4] = "COMMIT";
     queryType[queryType["ROLLBACK"] = 5] = "ROLLBACK";
+    queryType[queryType["DELETE"] = 6] = "DELETE";
 })(queryType = exports.queryType || (exports.queryType = {}));
+/**
+ * @deprecated
+ */
 class QueryRecorder {
     // TODO kill use AST or just throw away
     static getQueryStructure(query) {
@@ -76,6 +80,36 @@ class QueryRecorder {
                 };
             }
         }
+        if (/^DELETE/.test(query)) {
+            // regex can't do returning
+            let execArray = /^DELETE FROM (.+) WHERE (.+) /.exec(query);
+            if (execArray) {
+                return {
+                    tableName: execArray[1],
+                    whereClause: execArray[2],
+                    type: queryType.DELETE,
+                    query: execArray[0],
+                };
+            }
+        }
+        if (/^BEGIN/.test(query)) {
+            return {
+                type: queryType.BEGIN,
+                query: query,
+            };
+        }
+        if (/^COMMIT/.test(query)) {
+            return {
+                type: queryType.COMMIT,
+                query: query,
+            };
+        }
+        if (/^ROLLBACK/.test(query)) {
+            return {
+                type: queryType.ROLLBACK,
+                query: query,
+            };
+        }
         return null;
     }
     static recordQuery(query, values) {
@@ -131,7 +165,12 @@ class QueryRecorder {
     static getCurrentQueries() {
         return QueryRecorder.queries;
     }
-    static validateQueryStructuresFromLogs(ml, expected, skipSelect) {
+    /**
+     * @deprecated will keep this since it's just using ml.logs
+     * which we still want around (I think) but we should eventually
+     * probably stop using this
+     */
+    static validateQueryStructuresFromLogs(ml, expected, opts) {
         const queries = ml.logs.map((log) => {
             const qs = QueryRecorder.getQueryStructure(log.query);
             if (!qs) {
@@ -142,12 +181,16 @@ class QueryRecorder {
                 qs,
             };
         });
-        QueryRecorder.validateQuryStructuresImpl(expected, queries, skipSelect);
+        QueryRecorder.validateQueryStructuresImpl(expected, queries, opts);
     }
-    static validateQuryStructuresImpl(expected, queries, skipSelect) {
-        if (skipSelect) {
+    static validateQueryStructuresImpl(expected, queries, opts) {
+        if (opts?.skipSelect) {
             queries = queries.filter((query) => query.qs?.type !== queryType.SELECT);
         }
+        if (!opts?.flagBeginCommit) {
+            queries = queries.filter((query) => query.qs?.type !== queryType.BEGIN &&
+                query.qs?.type !== queryType.COMMIT);
+        }
         //    console.log(queries, expected);
         expect(queries.length).toBe(expected.length);
         for (let i = 0; i < expected.length; i++) {
@@ -167,7 +210,7 @@ class QueryRecorder {
                     expect(query.values).toBe(undefined);
                     break;
                 case queryType.SELECT:
-                    if (!skipSelect) {
+                    if (!opts?.skipSelect) {
                         console.error("validating select query structure not supported yet");
                     }
                     // TODO INSERT and UPDATE tests here...
@@ -185,7 +228,9 @@ class QueryRecorder {
         }
     }
     static mockPool(pool) {
-        const mockedPool = (0, jest_mock_1.mocked)(pool, true);
+        const mockedPool = (0, jest_mock_1.mocked)(pool);
+        // @ts-ignore
+        // TODO what changed in mockImplementation?
         mockedPool.mockImplementation(() => {
             return {
                 totalCount: 1,
@@ -218,10 +263,8 @@ class QueryRecorder {
         });
     }
 }
-exports.QueryRecorder = QueryRecorder;
 QueryRecorder.queries = [];
 QueryRecorder.ids = [];
 // we need pkeys when storing...
 QueryRecorder.data = new Map();
-// TODO
-process.env.DB_CONNECTION_STRING = "INVALID DATABASE";
+exports.QueryRecorder = QueryRecorder;

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;

package/testutils/ent-graphql-tests/index.d.ts

@@ -2,7 +2,7 @@ import { Express, RequestHandler } from "express";
 import { Viewer } from "../../core/base";
 import { GraphQLSchema } from "graphql";
 import supertest from "supertest";
-export declare type Option = [string, any];
+export type Option = [string, any] | [string, any, string];
 interface queryConfig {
     viewer?: Viewer;
     init?: (app: Express) => void;
@@ -11,6 +11,12 @@ interface queryConfig {
     headers?: object;
     debugMode?: boolean;
     args: {};
+    extraVariables?: {
+        [key: string]: {
+            graphqlType: string;
+            value: string;
+        };
+    };
     expectedStatus?: number;
     expectedError?: string | RegExp;
     callback?: (res: supertest.Response) => void;

package/testutils/ent-graphql-tests/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -31,6 +35,7 @@ const graphql_1 = require("graphql");
 const auth_1 = require("../../auth");
 const supertest_1 = __importDefault(require("supertest"));
 const fs = __importStar(require("fs"));
+const util_1 = require("util");
 function server(config) {
     const viewer = config.viewer;
     if (viewer) {
@@ -45,6 +50,7 @@ function server(config) {
     if (config.init) {
         config.init(app);
     }
+    // @ts-ignore something changed. come back
     app.use(express_1.default.json());
     let handlers = config.customHandlers || [];
     handlers.push(async (req, res) => {
@@ -56,9 +62,11 @@ function server(config) {
             request: req,
             schema: config.schema,
             contextFactory: async (executionContext) => {
+                // @ts-ignore something changed. come back
                 return (0, auth_1.buildContext)(req, res);
             },
         });
+        // @ts-ignore something changed. come back
         await (0, graphql_helix_1.sendResult)(result, res);
     });
     app.use(config.graphQLPath || "/graphql", ...handlers);
@@ -108,17 +116,23 @@ function makeGraphQLRequest(config, query, fieldArgs) {
             }
         }
     });
+    let variables = {
+        ...config.args,
+    };
+    for (const k in config.extraVariables) {
+        variables[k] = config.extraVariables[k].value;
+    }
     if (files.size) {
         let ret = test
             .post(config.graphQLPath || "/graphql")
             .set(config.headers || {});
         ret.field("operations", JSON.stringify({
             query: query,
-            variables: config.args,
+            variables: variables,
         }));
         let m = {};
         let idx = 0;
-        for (const [key, val] of files) {
+        for (const [key] of files) {
             m[idx] = [`variables.${key}`];
             idx++;
         }
@@ -141,15 +155,16 @@ function makeGraphQLRequest(config, query, fieldArgs) {
                 .set(config.headers || {})
                 .send({
                 query: query,
-                variables: JSON.stringify(config.args),
+                variables: JSON.stringify(variables),
             }),
         ];
     }
 }
 function buildTreeFromQueryPaths(schema, fieldType, ...options) {
     let fields;
-    if (fieldType instanceof graphql_1.GraphQLObjectType) {
-        fields = fieldType.getFields();
+    const [typ] = getInnerType(fieldType, false);
+    if (typ instanceof graphql_1.GraphQLObjectType) {
+        fields = typ.getFields();
     }
     let topLevelTree = {};
     options.forEach((option) => {
@@ -157,7 +172,7 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
         let parts = [];
         let match = fragmentRegex.exec(path);
         if (match) {
-            // fragment, keep the part of the fragment e.g.  ...onUser, and then split the rest....
+            // fragment, keep the part of the fragment e.g. `...on User`, and then split the rest....
             parts = [match[0], ...match[2].split(".")];
             const typ = schema.getType(match[1]);
             if (!typ) {
@@ -187,10 +202,11 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
             }
             // TODO this needs to be aware of paths etc so this part works for complicated
             // cases but inlineFragmentRoot is a workaround for now.
-            function handleSubtree(obj, tree) {
+            function handleSubtree(obj, tree, parts) {
+                let parts2 = [...parts];
                 if (Array.isArray(obj)) {
                     for (const obj2 of obj) {
-                        handleSubtree(obj2, tree);
+                        handleSubtree(obj2, tree, parts2);
                     }
                     return;
                 }
@@ -199,28 +215,36 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
                         tree[key] = {};
                     }
                     if (typeof obj[key] === "object") {
-                        if (!isScalarField(key)) {
-                            handleSubtree(obj[key], tree[key]);
+                        let parts2 = [...parts, key];
+                        if (!scalarFieldAtLeaf(parts2)) {
+                            handleSubtree(obj[key], tree[key], parts2);
                         }
                     }
                 }
             }
-            // TODO this needs to work for super complicated objects and have fields update as nesting applies...
-            function isScalarField(f) {
-                const subField = fields?.[f];
-                if (!subField) {
+            function scalarFieldAtLeaf(pathFromRoot) {
+                let root = fields;
+                if (!root) {
                     return false;
                 }
-                if (!(0, graphql_1.isWrappingType)(subField.type)) {
+                let subField;
+                for (const p of pathFromRoot) {
+                    subField = root?.[p];
+                    if (subField) {
+                        [subField] = getInnerType(subField.type, false);
+                        if (subField instanceof graphql_1.GraphQLObjectType) {
+                            root = subField.getFields();
+                        }
+                    }
+                }
+                if (!subField) {
                     return false;
                 }
-                // only spread out if an object
-                const [typ, _] = getInnerType(subField.type, true);
-                return (0, graphql_1.isScalarType)(typ);
+                return (0, graphql_1.isScalarType)(subField) || (0, graphql_1.isEnumType)(subField);
             }
             if (i === parts.length - 1 && typeof option[1] === "object") {
-                if (!isScalarField(part)) {
-                    handleSubtree(option[1], tree);
+                if (!scalarFieldAtLeaf(parts)) {
+                    handleSubtree(option[1], tree, parts);
                 }
             }
         }
@@ -302,13 +326,18 @@ async function expectFromRoot(config, ...options) {
     let fieldArgs = field.args;
     let queryParams = [];
     fieldArgs.forEach((fieldArg) => {
-        let arg = config.args[fieldArg.name];
+        const arg = config.args[fieldArg.name];
         // let the graphql runtime handle this (it may be optional for example)
         if (arg === undefined) {
             return;
         }
         queryParams.push(`$${fieldArg.name}: ${fieldArg.type}`);
     });
+    // add extra variables in queryArgs...
+    for (const key in config.extraVariables) {
+        const v = config.extraVariables[key];
+        queryParams.push(`$${key}: ${v.graphqlType}`);
+    }
     let params = [];
     for (let key in config.args) {
         params.push(`${key}: $${key}`);
@@ -347,7 +376,7 @@ async function expectFromRoot(config, ...options) {
     let [st, temp] = makeGraphQLRequest(config, q, fieldArgs);
     const res = await temp.expect("Content-Type", /json/);
     if (config.debugMode) {
-        console.log(res.body);
+        console.log((0, util_1.inspect)(res.body, false, 3));
     }
     // if there's a callback, let everything be done there and we're done
     if (config.callback) {
@@ -389,8 +418,9 @@ async function expectFromRoot(config, ...options) {
         }
     }
     await Promise.all(options.map(async (option) => {
-        let path = option[0];
-        let expected = option[1];
+        const path = option[0];
+        const expected = option[1];
+        const alias = option[2];
         let nullPath;
         let nullParts = [];
         let undefinedPath;
@@ -413,7 +443,7 @@ async function expectFromRoot(config, ...options) {
                 }
             }
         }
-        let parts = splitPath(path);
+        let parts = splitPath(alias ?? path);
         let current = result;
         // possible to make this smarter and better
         // e.g. when building up the tree above

package/testutils/fake_comms.js

@@ -32,5 +32,5 @@ class FakeComms {
         this.sent = [];
     }
 }
-exports.FakeComms = FakeComms;
 FakeComms.sent = [];
+exports.FakeComms = FakeComms;