miqro 1.6.8 → 1.7.2

package/src/test/common/runner.ts

@@ -1,121 +0,0 @@
-import { Console } from "console";
-import { format } from "util";
-
-export type TestFunction = () => void | Promise<void>;
-const DEFAULT_TIMEOUT = 2000;
-
-interface Test { run: TestFunction; title: string; category?: string; fullName: string; }
-
-const tests: Test[] = [];
-
-export const getTestCount = () => tests.length;
-
-export const it = (title: string, impl: TestFunction, options?: {
-  category?: string;
-  timeout?: number;
-  before?: TestFunction;
-  after?: TestFunction;
-}, logger: {
-  log: (...args: any[]) => void
-} | Console = new Console(process.stdout)): void => {
-  const category = options && options.category ? options.category : undefined;
-  const fullName = `${category ? `${category} [` : ""}${title}${category ? "]" : ""}`;
-  tests.push({
-    run: () => new Promise((resolve, reject) => {
-      const timeoutMS = options && options.timeout ? options.timeout : DEFAULT_TIMEOUT;
-      const timeout = setTimeout(() => {
-        reject(new Error(format("%s failed\x1b[31m\n%s timeout %o\x1b", fullName, fullName, timeoutMS)));
-      }, timeoutMS);
-      try {
-        (async () => {
-          if (options && options.before) {
-            await options.before();
-          }
-          const startMS = Date.now();
-          await impl();
-          const took = Date.now() - startMS;
-          if (options && options.after) {
-            await options.after();
-          }
-          return took;
-        })().then((took) => {
-          clearTimeout(timeout);
-          logger.log("\x1b[32mpassed %s (took %sms)\x1b[0m", fullName, took);
-          resolve();
-        }).catch(e => {
-          clearTimeout(timeout);
-          reject(new Error(format("%s failed\n%s finished with errors %o", fullName, fullName, e)));
-        });
-      } catch (e) {
-        clearTimeout(timeout);
-        reject(new Error(format("%s failed\n%s finished with errors %o", fullName, fullName, e)));
-      }
-    }), title,
-    category,
-    fullName
-  });
-};
-
-export const runTests = async (title?: string | string[], logger: {
-  error: (...args: any[]) => void;
-} | Console = new Console(process.stdout)): Promise<{
-  passed: number;
-  total: number;
-  ignored: number;
-  failed: {
-    error: any;
-    fullName: string;
-  }[];
-}> => {
-  const titles = title ? title instanceof Array ? title : [title] : [undefined];
-  const ret: {
-    passed: number;
-    total: number;
-    ignored: number;
-    failed: {
-      error: any;
-      fullName: string;
-    }[];
-  } = {
-    total: tests.length,
-    ignored: 0,
-    passed: 0,
-    failed: []
-  };
-  for (const test of tests) {
-    for (const title of titles) {
-      if (title && test.fullName.indexOf(title) !== -1 || !title) {
-        try {
-          await test.run();
-          ret.passed++;
-        } catch (e) {
-          logger.error("\x1b[31m%s\x1b[0m", e);
-          ret.failed.push({
-            error: e,
-            fullName: test.fullName
-          })
-        }
-      } else {
-        ret.ignored++;
-      }
-    }
-  }
-  return ret;
-};
-
-export const runTestModules = async (modules: string[], title?: string | string[], logger: {
-  error: (...args: any[]) => void;
-} | Console = new Console(process.stdout)): Promise<{
-  passed: number;
-  total: number;
-  ignored: number;
-  failed: {
-    error: any;
-    fullName: string;
-  }[];
-}> => {
-  for (const path of modules) {
-    require(path);
-  }
-  return await runTests(title, logger);
-}

package/src/test/index.ts

@@ -1 +0,0 @@
-export * from "./common";

package/src/utils/db/automigrations/deep-diff/index.ts

@@ -1,264 +0,0 @@
-// https://github.com/flitbit/diff/blob/master/index.js
-
-class Diff<LHS = any, RHS = any> {
-    public rhs: RHS | undefined;
-    public lhs: LHS | undefined;
-    constructor(public kind: "A" | "E" | "N" | "D", public path: string[] | undefined) {
-    }
-}
-
-class DiffEdit<L, R> extends Diff<L, R> {
-    constructor(path: string[], lhs: L, rhs: R) {
-        super("E", path);
-        this.lhs = lhs;
-        this.rhs = rhs;
-    }
-}
-
-class DiffNew<L, R> extends Diff<L, R> {
-    constructor(path: string[] | undefined, rhs: R) {
-        super("N", path);
-        this.rhs = rhs;
-    }
-}
-
-class DiffDeleted<L, R> extends Diff<L, R>{
-    constructor(path: string[] | undefined, public lhs: L) {
-        super("D", path);
-        this.lhs = lhs;
-    }
-}
-
-class DiffArray extends Diff {
-    public item: any;
-    constructor(path: string[], public index: number, item: any) {
-        super("A", path);
-        this.item = item;
-    }
-}
-
-const realTypeOf = (subject: any) => {
-    const type = typeof subject;
-    if (type !== 'object') {
-        return type;
-    }
-
-    if (subject === Math) {
-        return 'math';
-    } else if (subject === null) {
-        return 'null';
-    } else if (Array.isArray(subject)) {
-        return 'array';
-    } else if (Object.prototype.toString.call(subject) === '[object Date]') {
-        return 'date';
-    } else if (typeof subject.toString === 'function' && /^\/.*\//.test(subject.toString())) {
-        return 'regexp';
-    }
-    return 'object';
-}
-
-// http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
-const hashThisString = (string: string): number => {
-    let hash = 0;
-    if (string.length === 0) { return hash; }
-    for (let i = 0; i < string.length; i++) {
-        const char = string.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return hash;
-}
-
-// Gets a hash of the given object in an array order-independent fashion
-// also object key order independent (easier since they can be alphabetized)
-const getOrderIndependentHash = (object: any): number => {
-    let accum = 0;
-    const type = realTypeOf(object);
-
-    if (type === 'array') {
-        object.forEach(function (item: any) {
-            // Addition is commutative so this is order indep
-            accum += getOrderIndependentHash(item);
-        });
-
-        const arrayString = '[type: array, hash: ' + accum + ']';
-        return accum + hashThisString(arrayString);
-    }
-
-    if (type === 'object') {
-        for (const key in object) {
-            if (object.hasOwnProperty(key)) {
-                const keyValueString = '[ type: object, key: ' + key + ', value hash: ' + getOrderIndependentHash(object[key]) + ']';
-                accum += hashThisString(keyValueString);
-            }
-        }
-
-        return accum;
-    }
-
-    // Non object, non array...should be good?
-    const stringToHash = '[ type: ' + type + ' ; value: ' + object + ']';
-    return accum + hashThisString(stringToHash);
-}
-
-const deepDiff = (lhs: any, rhs: any, changes: any[], prefilter?: PreFilter<any, any>, path?: string[] | null, key?: string | null | number, stack?: { lhs?: any; rhs?: any; }[] | null, orderIndependent?: boolean) => {
-    changes = changes || [];
-    path = path || [];
-    stack = stack || [];
-    const currentPath = path.slice(0);
-    if (typeof key !== 'undefined' && key !== null) {
-        if (prefilter) {
-            if (typeof (prefilter) === 'function' && prefilter(currentPath, key)) {
-                return;
-            } else if (typeof (prefilter) === 'object') {
-                if (prefilter.prefilter && prefilter.prefilter(currentPath, key)) {
-                    return;
-                }
-                if (prefilter.normalize) {
-                    const alt = prefilter.normalize(currentPath, key, lhs, rhs);
-                    if (alt) {
-                        lhs = alt[0];
-                        rhs = alt[1];
-                    }
-                }
-            }
-        }
-        currentPath.push(key as string);
-    }
-
-    // Use string comparison for regexes
-    if (realTypeOf(lhs) === 'regexp' && realTypeOf(rhs) === 'regexp') {
-        lhs = lhs.toString();
-        rhs = rhs.toString();
-    }
-
-    const ltype = typeof lhs;
-    const rtype = typeof rhs;
-    let i, j, k, other;
-
-    const ldefined = ltype !== 'undefined' ||
-        (stack && (stack.length > 0) && stack[stack.length - 1].lhs &&
-            Object.getOwnPropertyDescriptor(stack[stack.length - 1].lhs, key as string));
-    const rdefined = rtype !== 'undefined' ||
-        (stack && (stack.length > 0) && stack[stack.length - 1].rhs &&
-            Object.getOwnPropertyDescriptor(stack[stack.length - 1].rhs, key as string));
-
-    if (!ldefined && rdefined) {
-        changes.push(new DiffNew(currentPath, rhs));
-    } else if (!rdefined && ldefined) {
-        changes.push(new DiffDeleted(currentPath, lhs));
-    } else if (realTypeOf(lhs) !== realTypeOf(rhs)) {
-        changes.push(new DiffEdit(currentPath, lhs, rhs));
-    } else if (realTypeOf(lhs) === 'date' && (lhs - rhs) !== 0) {
-        changes.push(new DiffEdit(currentPath, lhs, rhs));
-    } else if (ltype === 'object' && lhs !== null && rhs !== null) {
-        for (i = stack.length - 1; i > -1; --i) {
-            if (stack[i].lhs === lhs) {
-                other = true;
-                break;
-            }
-        }
-        if (!other) {
-            stack.push({ lhs: lhs, rhs: rhs });
-            if (Array.isArray(lhs)) {
-                // If order doesn't matter, we need to sort our arrays
-                if (orderIndependent) {
-                    lhs.sort(function (a, b) {
-                        return getOrderIndependentHash(a) - getOrderIndependentHash(b);
-                    });
-
-                    rhs.sort(function (a: any, b: any) {
-                        return getOrderIndependentHash(a) - getOrderIndependentHash(b);
-                    });
-                }
-                i = rhs.length - 1;
-                j = lhs.length - 1;
-                while (i > j) {
-                    changes.push(new DiffArray(currentPath, i, new DiffNew(undefined, rhs[i--])));
-                }
-                while (j > i) {
-                    changes.push(new DiffArray(currentPath, j, new DiffDeleted(undefined, lhs[j--])));
-                }
-                for (; i >= 0; --i) {
-                    deepDiff(lhs[i], rhs[i], changes, prefilter, currentPath, i, stack, orderIndependent);
-                }
-            } else {
-
-                const akeys = Object.keys(lhs).concat(Object.getOwnPropertySymbols(lhs) as any[] as string[]);
-                const pkeys = Object.keys(rhs).concat(Object.getOwnPropertySymbols(rhs) as any[] as string[]);
-                for (i = 0; i < akeys.length; ++i) {
-                    k = akeys[i];
-                    other = pkeys.indexOf(k);
-                    if (other >= 0) {
-                        deepDiff(lhs[k], rhs[k], changes, prefilter, currentPath, k, stack, orderIndependent);
-                        pkeys[other] = null as any;
-                    } else {
-                        deepDiff(lhs[k], undefined, changes, prefilter, currentPath, k, stack, orderIndependent);
-                    }
-                }
-                for (i = 0; i < pkeys.length; ++i) {
-                    k = pkeys[i];
-                    if (k) {
-                        deepDiff(undefined, rhs[k], changes, prefilter, currentPath, k, stack, orderIndependent);
-                    }
-                }
-            }
-            stack.length = stack.length - 1;
-        } else if (lhs !== rhs) {
-            // lhs is contains a cycle at this element and it differs from rhs
-            changes.push(new DiffEdit(currentPath, lhs, rhs));
-        }
-    } else if (lhs !== rhs) {
-        if (!(ltype === 'number' && isNaN(lhs) && isNaN(rhs))) {
-            changes.push(new DiffEdit(currentPath, lhs, rhs));
-        }
-    }
-}
-
-/* eslint-disable  @typescript-eslint/explicit-module-boundary-types */
-const observableDiff = (lhs: any, rhs: any, observer?: (difference: any) => void, prefilter?: PreFilter<any, any>, orderIndependent?: boolean): Diff<any, any>[] => {
-    const changes: Diff<any, any>[] = [];
-    deepDiff(lhs, rhs, changes, prefilter, null, null, null, orderIndependent);
-    if (observer) {
-        for (let i = 0; i < changes.length; ++i) {
-            observer(changes[i]);
-        }
-    }
-    return changes;
-}
-
-/* eslint-disable  @typescript-eslint/explicit-module-boundary-types */
-const accumulateDiff = (lhs: any, rhs: any, prefilter?: PreFilter<any, any>, accum?: Diff<any, any>[] | undefined): Array<Diff<any, any>> | undefined => {
-    const observer = (accum) ?
-        function (difference: any) {
-            if (difference) {
-                accum.push(difference);
-            }
-        } : undefined;
-    const changes = observableDiff(lhs, rhs, observer, prefilter);
-    return (accum) ? accum : (changes.length) ? changes : undefined;
-}
-
-export type PreFilterFunction = (path: any[], key: any) => boolean;
-export interface PreFilterObject<LHS, RHS = LHS> {
-    prefilter?(path: any[], key: any): boolean;
-    normalize?(currentPath: any, key: any, lhs: LHS, rhs: RHS): [LHS, RHS] | undefined;
-}
-export type PreFilter<LHS, RHS = LHS> = PreFilterFunction | PreFilterObject<LHS, RHS>;
-
-export interface Accumulator<LHS, RHS = LHS> {
-    push(diff: Diff<LHS, RHS>): void;
-    length: number;
-}
-
-export type Observer<LHS, RHS = LHS> = (diff: Diff<LHS, RHS>) => void;
-
-export type Filter<LHS, RHS = LHS> = (target: LHS, source: RHS, change: Diff<LHS, RHS>) => boolean;
-
-export type DeepDiff<LHS, RHS = LHS> = (lhs: LHS, rhs: RHS, prefilter?: PreFilter<LHS, RHS>) => Array<Diff<LHS, RHS>> | undefined;
-
-export const DEEPDIFF: {
-    diff: DeepDiff<any>
-} = {
-    diff: accumulateDiff
-};

package/src/utils/db/automigrations/index.ts

@@ -1,151 +0,0 @@
-import { getLogger } from "@miqro/core";
-import fs from "fs";
-import path from "path";
-import { loadModels, loadSequelizeRC } from "..";
-import { getMigration, MigrationState, parseDifference, reverseModels, sortActions, writeMigration } from "./migrate";
-
-export const syncMakeMigrationsImpl = (): void => {
-  // Windows support
-  if (!process.env.PWD) {
-    process.env.PWD = process.cwd();
-  }
-
-  const sequelizeRC = loadSequelizeRC();
-
-  // noinspection SpellCheckingInspection
-  const logger = getLogger("makemigrations");
-
-  try {
-    if (!fs.existsSync(sequelizeRC["models-path"])) {
-      logger.error("Can't find models directory. Use `sequelize init` to create it");
-      return;
-    }
-
-    if (!fs.existsSync(sequelizeRC["migrations-path"])) {
-      logger.error("Can't find migrations directory. Use `sequelize init` to create it");
-      return;
-    }
-
-    // load last state
-    let previousState: MigrationState;
-
-    try {
-      previousState = JSON.parse(fs.readFileSync(path.join(sequelizeRC["migrations-path"], "_current.json")).toString());
-    } catch (e) {
-      previousState = {
-        revision: 0,
-        tables: {}
-      };
-    }
-
-    const { modelsModule } = loadModels({ ["models-path"]: sequelizeRC["models-path"] });
-
-    // current state
-    const currentState: MigrationState = {
-      revision: previousState.revision + 1,
-      tables: reverseModels(modelsModule.Sequelize, modelsModule.sequelize, modelsModule.sequelize.models, logger)
-    };
-
-
-    // backup _current file
-    if (fs.existsSync(path.join(sequelizeRC["migrations-path"], "_current.json"))) {
-      fs.writeFileSync(path.join(sequelizeRC["migrations-path"], "_current_bak.json"),
-        fs.readFileSync(path.join(sequelizeRC["migrations-path"], "_current.json"))
-      );
-    }
-
-    // save current state
-    currentState.revision = previousState.revision + 1;
-    fs.writeFileSync(path.join(sequelizeRC["migrations-path"], "_current.json"), JSON.stringify(currentState, null, 4));
-  } catch (e) {
-    logger.error(e);
-    throw e;
-  }
-};
-
-// noinspection SpellCheckingInspection
-export const makemigrationsImpl = (): string | undefined | null => {
-
-  // Windows support
-  if (!process.env.PWD) {
-    process.env.PWD = process.cwd();
-  }
-
-  const sequelizeRC = loadSequelizeRC();
-
-  // noinspection SpellCheckingInspection
-  const logger = getLogger("makemigrations");
-
-  try {
-    if (!fs.existsSync(sequelizeRC["models-path"])) {
-      logger.error("Can't find models directory. Use `sequelize init` to create it");
-      return;
-    }
-
-    if (!fs.existsSync(sequelizeRC["migrations-path"])) {
-      logger.error("Can't find migrations directory. Use `sequelize init` to create it");
-      return;
-    }
-
-    // load last state
-    let previousState: MigrationState;
-
-    try {
-      previousState = JSON.parse(fs.readFileSync(path.join(sequelizeRC["migrations-path"], "_current.json")).toString());
-    } catch (e) {
-      previousState = {
-        revision: 0,
-        tables: {}
-      };
-    }
-
-    const { modelsModule } = loadModels({ ["models-path"]: sequelizeRC["models-path"] });
-
-    // current state
-    const currentState: MigrationState = {
-      revision: previousState.revision + 1,
-      tables: reverseModels(modelsModule.Sequelize, modelsModule.sequelize, modelsModule.sequelize.models, logger)
-    };
-
-    const actions = parseDifference(previousState.tables, currentState.tables, logger);
-
-    // sort actions
-    sortActions(actions);
-
-    const migration = getMigration(actions);
-
-    if (migration.commandsUp.length === 0) {
-      logger.info("No changes found");
-      return null;
-    }
-
-    // log migration actions
-    migration.consoleOut.forEach((v) => {
-      logger.info("[Actions] " + v);
-    });
-
-    // backup _current file
-    if (fs.existsSync(path.join(sequelizeRC["migrations-path"], "_current.json"))) {
-      fs.writeFileSync(path.join(sequelizeRC["migrations-path"], "_current_bak.json"),
-        fs.readFileSync(path.join(sequelizeRC["migrations-path"], "_current.json"))
-      );
-    }
-
-    // save current state
-    currentState.revision = previousState.revision + 1;
-    fs.writeFileSync(path.join(sequelizeRC["migrations-path"], "_current.json"), JSON.stringify(currentState, null, 4));
-
-    // write migration to file
-    const info = writeMigration(currentState.revision,
-      migration,
-      sequelizeRC["migrations-path"],
-      "noname",
-      "");
-
-    logger.info(`New migration to revision ${currentState.revision} has been saved to file '${info.filename}'`);
-    return info.filename;
-  } catch (e) {
-    logger.error(e);
-    throw e;
-  }
-};