@snowtop/ent 0.1.0-alpha160-test7 → 0.1.0-alpha161-test1

package/src/testutils/db/value.ts

@@ -1,294 +0,0 @@
-import { v4 } from "uuid";
-import { DBType, Field, Schema, Type } from "../../schema";
-import {
-  DateType,
-  TimeType,
-  TimetzType,
-  TimestampType,
-  TimestamptzType,
-  JSONBType,
-  JSONType,
-  StringType,
-} from "../../schema";
-
-function random(): string {
-  return Math.random().toString(16).substring(2);
-}
-
-export function randomEmail(domain?: string): string {
-  domain = domain || "email.com";
-
-  return `test+${random()}@${domain}`;
-}
-
-function randomPhoneNumber(): string {
-  return `+1${Math.random().toString(10).substring(2, 11)}`;
-}
-
-function coinFlip() {
-  return Math.floor(Math.random() * 10) >= 5;
-}
-
-function specialType(typ: Type, col: string) {
-  let list = m.get(typ.dbType);
-  if (list?.length) {
-    for (const l of list) {
-      let regex: RegExp[] = [];
-      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;
-}
-
-interface Info {
-  schema: Schema;
-}
-
-export function getDefaultValue(
-  f: Field,
-  col: string,
-  infos?: Map<string, Info>,
-): any {
-  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);
-}
-
-function getValueForType(typ: Type, f: Field, infos?: Map<string, Info>) {
-  switch (typ.dbType) {
-    case DBType.UUID:
-      return v4();
-    case DBType.Boolean:
-      return coinFlip();
-    case DBType.Date:
-      return DateType().format(new Date());
-    case DBType.Time:
-      return TimeType().format(new Date());
-    case DBType.Timetz:
-      return TimetzType().format(new Date());
-    case DBType.Timestamp:
-      return TimestampType().format(new Date());
-    case DBType.Timestamptz:
-      return TimestamptzType().format(new Date());
-    case DBType.String:
-      return random();
-    case DBType.Int:
-      return Math.floor(Math.random() * 100000000);
-    case DBType.Float:
-      return Math.random() * 100000000;
-    case DBType.Enum:
-    case 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 DBType.IntEnum:
-      const vals = Object.values(typ.intEnumMap!);
-      const idx = Math.floor(Math.random() * vals.length);
-      return vals[idx];
-
-    case DBType.BigInt:
-      return BigInt(Math.floor(Math.random() * 100000000));
-    case DBType.JSONB:
-      // type as list
-      if (typ.listElemType?.dbType === DBType.JSONB) {
-        const values: any[] = [];
-
-        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 JSONBType().format({});
-    case DBType.JSON:
-      return JSONType().format({});
-    case DBType.List:
-      // just do 10
-      const values: any[] = [];
-
-      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}`);
-  }
-}
-
-interface commonType {
-  dbType: DBType;
-  newValue: () => any;
-  regex: [RegExp] | RegExp;
-}
-
-const emailType = {
-  dbType: DBType.String,
-  newValue: () => {
-    return StringType().format(randomEmail().toLowerCase());
-  },
-  regex: /^email(_address)|_email$/,
-};
-
-const phoneType = {
-  dbType: DBType.String,
-  newValue: () => {
-    return randomPhoneNumber();
-  },
-  regex: /^phone(_number)?|_phone$|_phone_number$/,
-};
-
-const passwordType = {
-  dbType: 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: DBType.String,
-  newValue: () => {
-    let idx = Math.floor(firstNames.length * Math.random());
-    return firstNames[idx];
-  },
-  regex: /^first_?(name)?/,
-};
-
-const lastNameType = {
-  dbType: DBType.String,
-  newValue: () => {
-    let idx = Math.floor(lastNames.length * Math.random());
-    return lastNames[idx];
-  },
-  regex: /^last_?(name)?/,
-};
-
-let types: commonType[] = [
-  phoneType,
-  emailType,
-  passwordType,
-  firstNameType,
-  lastNameType,
-];
-
-let m: Map<DBType, commonType[]> = new Map();
-for (const type of types) {
-  let list = m.get(type.dbType) || [];
-  list.push(type);
-  m.set(type.dbType, list);
-}

package/src/testutils/db_mock.ts

@@ -1,351 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { Pool, PoolClient } from "pg";
-import { mocked } from "jest-mock";
-import { ID, Data } from "../core/base";
-import { Clause } from "../core/clause";
-
-import { performQuery, queryResult, getDataToReturn } from "./parse_sql";
-import { MockLogs } from "./mock_log";
-
-const eventEmitter = {
-  on: jest.fn(),
-  addListener: jest.fn(),
-  removeListener: jest.fn(),
-  once: jest.fn(),
-  off: jest.fn(),
-  removeAllListeners: jest.fn(),
-  setMaxListeners: jest.fn(),
-  getMaxListeners: jest.fn(),
-  listeners: jest.fn(),
-  rawListeners: jest.fn(),
-  emit: jest.fn(),
-  listenerCount: jest.fn(),
-  prependListener: jest.fn(),
-  prependOnceListener: jest.fn(),
-  eventNames: jest.fn(),
-};
-
-export interface queryOptions {
-  query: string;
-  values?: any[];
-  qs?: internalQueryStructure | null;
-}
-
-export interface mockOptions {
-  tableName: string;
-  //  columns?: string[];
-  clause: Clause;
-  result: (values: any[]) => {};
-}
-
-export enum queryType {
-  SELECT,
-  INSERT,
-  UPDATE,
-  BEGIN,
-  COMMIT,
-  ROLLBACK,
-  DELETE,
-}
-
-export interface queryStructure {
-  tableName?: string;
-  type: queryType;
-  //  columns?: string[];
-  values?: any[];
-}
-
-interface internalQueryStructure extends queryStructure {
-  query: string;
-  columns?: string[];
-  whereClause?: string;
-  suffix?: string;
-  setClause?: string;
-}
-
-/**
- * @deprecated
- */
-export class QueryRecorder {
-  private static queries: queryOptions[] = [];
-  private static ids: ID[] = [];
-
-  // we need pkeys when storing...
-  private static data: Map<string, Data[]> = new Map();
-
-  // TODO kill use AST or just throw away
-  static getQueryStructure(query): internalQueryStructure | null {
-    // we parsing sql now??
-    // slowing building sqlshim?
-    // make it so that we return the values entered back when mocking the db
-
-    if (/^INSERT/.test(query)) {
-      let execArray = /INSERT INTO (.+) \((.+)\) VALUES \((.+)\) (.+)?/.exec(
-        query,
-      );
-      if (execArray) {
-        return {
-          tableName: execArray[1],
-          columns: execArray[2].split(", "),
-          type: queryType.INSERT,
-          query: execArray[0],
-          suffix: execArray[4],
-        };
-      }
-      return null;
-    }
-
-    if (/^SELECT/.test(query)) {
-      let execArray = /^SELECT (.+) FROM (.+) WHERE (.+)?/.exec(query);
-      if (execArray) {
-        return {
-          tableName: execArray[2],
-          whereClause: execArray[3],
-          type: queryType.SELECT,
-          query: execArray[0],
-          columns: execArray[1].split(", "),
-        };
-      }
-    }
-
-    if (/^UPDATE/.test(query)) {
-      // regex can't do returning
-      let execArray = /^UPDATE (.+) SET (.+) WHERE (.+) /.exec(query);
-      if (execArray) {
-        return {
-          tableName: execArray[1],
-          // not completely accurate
-          whereClause: execArray[3],
-          type: queryType.UPDATE,
-          query: execArray[0],
-          setClause: execArray[2],
-          //          colummns: execArray[1].split(", "),
-        };
-      }
-    }
-
-    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;
-  }
-
-  private static recordQuery(
-    query: string,
-    values: any[],
-  ): queryResult | undefined {
-    let qs = QueryRecorder.getQueryStructure(query);
-    QueryRecorder.queries.push({
-      query: query,
-      values: values,
-      qs: qs,
-    });
-
-    return performQuery(query, values, QueryRecorder.data);
-  }
-
-  static newID(): ID {
-    let id = uuidv4();
-    QueryRecorder.ids.push(id);
-    return id;
-  }
-
-  static getCurrentIDs(): ID[] {
-    return QueryRecorder.ids;
-  }
-
-  static getLastID(): ID {
-    const l = QueryRecorder.ids.length;
-    if (!l) {
-      throw new Error(`no ID`);
-    }
-    return QueryRecorder.ids[l - 1];
-  }
-
-  static getData() {
-    return QueryRecorder.data;
-  }
-
-  static filterData(tableName: string, filterfn: (row: Data) => boolean) {
-    const rows = QueryRecorder.data.get(tableName) || [];
-    let result: Data[] = [];
-    for (const row of rows) {
-      // transform the data into whatever the return value should be before filtering
-      const row2 = getDataToReturn(row, undefined, true);
-      if (filterfn(row2)) {
-        result.push(row2);
-      }
-    }
-    return result;
-  }
-
-  static clear() {
-    QueryRecorder.queries = [];
-    QueryRecorder.ids = [];
-    QueryRecorder.data = new Map();
-  }
-
-  static clearQueries() {
-    // clears queries but keeps data
-    // this is useful for situations like write this data before each test
-    // but each test shouldn't have to account for this
-    QueryRecorder.queries = [];
-  }
-
-  static getCurrentQueries(): queryOptions[] {
-    return QueryRecorder.queries;
-  }
-
-  /**
-   * @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;
-    },
-  ) {
-    const queries = ml.logs.map((log) => {
-      const qs = QueryRecorder.getQueryStructure(log.query);
-      if (!qs) {
-        throw new Error(`invalid query ${log.querya}`);
-      }
-      return {
-        query: log.query,
-        qs,
-      };
-    });
-
-    QueryRecorder.validateQueryStructuresImpl(expected, queries, opts);
-  }
-
-  private static validateQueryStructuresImpl(
-    expected: queryStructure[],
-    queries: queryOptions[],
-    opts?: {
-      skipSelect?: boolean;
-      flagBeginCommit?: boolean;
-    },
-  ) {
-    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++) {
-      let expectedStructure = expected[i];
-      let query = queries[i];
-      switch (expectedStructure.type) {
-        case queryType.BEGIN:
-          expect(query.query).toBe("BEGIN");
-          expect(query.values).toBe(undefined);
-          break;
-        case queryType.ROLLBACK:
-          expect(query.query).toBe("ROLLBACK");
-          expect(query.values).toBe(undefined);
-          break;
-        case queryType.COMMIT:
-          expect(query.query).toBe("COMMIT");
-          expect(query.values).toBe(undefined);
-          break;
-        case queryType.SELECT:
-          if (!opts?.skipSelect) {
-            console.error(
-              "validating select query structure not supported yet",
-            );
-          }
-          // TODO INSERT and UPDATE tests here...
-          // should be easy...
-          break;
-        case queryType.INSERT:
-          expect(query.query.startsWith("INSERT")).toBe(true);
-          expect(query.qs?.tableName).toBe(expectedStructure.tableName);
-          break;
-        case queryType.UPDATE:
-          expect(query.query.startsWith("UPDATE")).toBe(true);
-          expect(query.qs?.tableName).toBe(expectedStructure.tableName);
-          break;
-      }
-    }
-  }
-
-  static mockPool(pool: typeof Pool) {
-    const mockedPool = mocked(pool);
-    // @ts-ignore
-    // TODO what changed in mockImplementation?
-    mockedPool.mockImplementation((): Pool => {
-      return {
-        totalCount: 1,
-        idleCount: 1,
-        waitingCount: 1,
-        connect: async (): Promise<PoolClient> => {
-          return {
-            connect: jest.fn(),
-            release: jest.fn(),
-            query: jest
-              .fn()
-              .mockImplementation((query: string, values: any[]) => {
-                return QueryRecorder.recordQuery(query, values);
-              }),
-            copyFrom: jest.fn(),
-            copyTo: jest.fn(),
-            pauseDrain: jest.fn(),
-            resumeDrain: jest.fn(),
-            escapeIdentifier: jest.fn(),
-            escapeLiteral: jest.fn(),
-
-            // EventEmitter
-            ...eventEmitter,
-          };
-        },
-        end: jest.fn(),
-        query: jest.fn().mockImplementation(QueryRecorder.recordQuery),
-
-        // EventEmitter
-        ...eventEmitter,
-      };
-    });
-  }
-}

package/src/testutils/db_time_zone.ts

@@ -1,40 +0,0 @@
-import { DateTime } from "luxon";
-import { leftPad } from "../schema";
-import DB from "../core/db";
-
-let dbCurrentZone: string | null | undefined = undefined;
-export class DBTimeZone {
-  private static async getVal(): Promise<string | null> {
-    if (dbCurrentZone !== undefined) {
-      return dbCurrentZone;
-    }
-
-    const r = await DB.getInstance()
-      .getPool()
-      .query("SELECT current_setting('TIMEZONE');");
-
-    if (r.rows.length) {
-      dbCurrentZone = r.rows[0].current_setting as string;
-    } else {
-      dbCurrentZone = null;
-    }
-    return dbCurrentZone;
-  }
-
-  static async getDateOffset(d: Date) {
-    let zone = await DBTimeZone.getVal();
-
-    let dt = DateTime.fromJSDate(d);
-    if (zone) {
-      dt = dt.setZone(zone);
-    }
-
-    // use
-    const val = leftPad(dt.get("offset") / 60);
-
-    if (val == "00") {
-      return "+00";
-    }
-    return val;
-  }
-}