@noego/proper 0.0.3 → 0.0.4

package/bin/index.d.ts

@@ -0,0 +1,169 @@
+import mysql from 'mysql2/promise';
+
+interface MigrationConfig {
+    config_file?: string;
+    migration_table: string;
+    migration_folder: string;
+    database: string;
+    sql?: {
+        host: string;
+        user: string;
+        database: string;
+        password?: string;
+        port?: number;
+    };
+    sqlite?: {
+        database: string;
+    };
+    seeds?: {
+        migrationsDir?: string;
+        dataDir?: string;
+        list?: string[];
+    };
+}
+
+interface MigrationStatus {
+    completed: boolean;
+}
+
+interface ISQLRunner {
+    query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    end(): Promise<void>;
+}
+
+declare abstract class MigrationNode {
+    name: string;
+    constructor(name?: string);
+    abstract get_key(): string;
+    abstract status(): Promise<MigrationStatus>;
+    abstract up(): Promise<void>;
+    abstract down(): Promise<void>;
+    abstract up_sql(): string;
+    abstract down_sql(): string;
+}
+declare class SqlMigrationNode extends MigrationNode {
+    private conn;
+    private table;
+    private key;
+    private up_file;
+    private sql_up;
+    private down_file;
+    private sql_down;
+    up_sql(): string;
+    down_sql(): string;
+    get_key(): string;
+    constructor(conn: ISQLRunner, table: string, key: string, up_file: string, sql_up: string, down_file: string, sql_down: string);
+    status(): Promise<MigrationStatus>;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}
+
+declare class SqlMigrationBuilder {
+    private key;
+    private up;
+    private up_file;
+    private down;
+    private down_file;
+    constructor(key: string);
+    set_up(file: string, up: string): void;
+    set_down(file: string, down: string): void;
+    build(table: string, conn: ISQLRunner): SqlMigrationNode;
+}
+
+declare class MigrationDirectoryReader {
+    private directory;
+    private read_strategy;
+    private sqlrunner;
+    constructor(directory: string, read_strategy: any, sqlrunner: ISQLRunner);
+    loadMigrations(table: string, connection: any): MigrationNode[];
+    loadMigration(builder: SqlMigrationBuilder, file: string): SqlMigrationBuilder;
+    sql_up(file: string): string;
+    sql_down(file: string): string;
+}
+
+declare class MigrationSetup {
+    private sqlrunner;
+    private config;
+    constructor(sqlrunner: ISQLRunner, config: MigrationConfig);
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+}
+
+declare function loadMigrationConfig(configFile: string): MigrationConfig;
+declare class MigrationRunnerFactory {
+    private static isSQLRunner;
+    static create(configFile: string, conn?: any): Promise<MySQLMigrationRunner>;
+    static createConnection(config: MigrationConfig): Promise<any>;
+    static createEmpty(configFile: string): Promise<MySQLMigrationRunner>;
+    create(config: MigrationConfig, conn: any): Promise<MySQLMigrationRunner>;
+    createEmpty(config: MigrationConfig): Promise<MySQLMigrationRunner>;
+    private getReadStategy;
+}
+interface MigrationHistory {
+    name: string;
+    up: string;
+    down: string;
+}
+interface IMigrationRunner {
+    setup(): Promise<void>;
+    terminate(): Promise<void>;
+    getMigrationsHistory(): Promise<MigrationHistory[]>;
+    getMigrations(): Promise<MigrationNode[]>;
+    getPendingMigrations(): Promise<MigrationNode[]>;
+    getCompletedMigrations(): Promise<MigrationNode[]>;
+    migrate(migrationNodes: MigrationNode[], forward: boolean): Promise<void>;
+    reset(): Promise<void>;
+    createMigration(name: string): void;
+    close(): Promise<void>;
+    init(config_file: string): Promise<void>;
+    query(sql: string, params?: any[]): Promise<any>;
+}
+declare class MySQLMigrationRunner implements IMigrationRunner {
+    private config;
+    private directory;
+    private setupRunner;
+    private sqlrunner;
+    private connection;
+    constructor(config: MigrationConfig, directory: MigrationDirectoryReader, setupRunner: MigrationSetup, sqlrunner: ISQLRunner, connection: mysql.Connection);
+    setup(): Promise<void>;
+    terminate(): Promise<void>;
+    getMigrationsHistory(): Promise<MigrationHistory[]>;
+    getMigrations(): Promise<MigrationNode[]>;
+    getPendingMigrations(): Promise<MigrationNode[]>;
+    getCompletedMigrations(): Promise<MigrationNode[]>;
+    migrate(migrationNodes: MigrationNode[], forward: boolean): Promise<void>;
+    reset(): Promise<void>;
+    createMigration(name: string): void;
+    close(): Promise<void>;
+    query(sql: string, params?: any[]): Promise<any>;
+    init(config_file: string): Promise<void>;
+}
+
+type SeedTransactionalMode = 'runner' | 'seed' | 'none';
+type SeedOptions = {
+    migrationsDir?: string;
+    dataDir?: string;
+    validate?: boolean;
+    transactional?: SeedTransactionalMode;
+    aliasMap?: Record<string, string>;
+    preloadedData?: Record<string, unknown>;
+    log?: (msg: string) => void;
+    names?: string[];
+};
+type SeedContext = {
+    data: unknown;
+    log?: (msg: string) => void;
+    dialect: string;
+};
+declare function runSeedsWithRunner(runner: IMigrationRunner, migrationConfig: MigrationConfig, direction: 'up' | 'down', options: SeedOptions): Promise<void>;
+type SeedFactoryOptions = SeedOptions & {
+    configFile?: string;
+};
+type SeedFactory = {
+    up(names?: string[]): Promise<void>;
+    down(names?: string[]): Promise<void>;
+};
+declare function createSeedFactory(options: SeedFactoryOptions): SeedFactory;
+
+export { type MigrationConfig, MySQLMigrationRunner as MigrationRunner, MigrationRunnerFactory, type SeedContext, type SeedFactory, type SeedFactoryOptions, createSeedFactory, loadMigrationConfig, runSeedsWithRunner };

package/bin/index.js

@@ -1,9 +1,26 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -50,7 +67,10 @@ var __async = (__this, __arguments, generator) => {
 var index_exports = {};
 __export(index_exports, {
   MigrationRunner: () => MySQLMigrationRunner,
-  MigrationRunnerFactory: () => MigrationRunnerFactory
+  MigrationRunnerFactory: () => MigrationRunnerFactory,
+  createSeedFactory: () => createSeedFactory,
+  loadMigrationConfig: () => loadMigrationConfig,
+  runSeedsWithRunner: () => runSeedsWithRunner
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -524,6 +544,9 @@ var BaseSQLRunner = class {
     });
   }
 };
+function isPromiseLike(value) {
+  return !!value && typeof value.then === "function";
+}
 var SQLRunner = class extends BaseSQLRunner {
   constructor(connection) {
     super();
@@ -553,14 +576,85 @@ var SQLiteRunner = class extends BaseSQLRunner {
     super();
     this.connection = connection;
   }
+  prepareStatement(sql) {
+    return __async(this, null, function* () {
+      if (typeof this.connection.prepare !== "function") {
+        throw new Error("SQLite connection does not support prepare()");
+      }
+      const stmt = this.connection.prepare(sql);
+      return isPromiseLike(stmt) ? yield stmt : stmt;
+    });
+  }
+  finalizeStatement(stmt) {
+    return __async(this, null, function* () {
+      if (!stmt || typeof stmt.finalize !== "function") return;
+      const result = stmt.finalize();
+      if (isPromiseLike(result)) {
+        yield result;
+      }
+    });
+  }
+  statementAll(stmt, params) {
+    return __async(this, null, function* () {
+      if (typeof stmt.all !== "function") {
+        throw new Error("SQLite statement does not support all()");
+      }
+      if (stmt.all.length >= 2) {
+        return yield new Promise((resolve, reject) => {
+          const callback = (err, rows) => {
+            if (err) return reject(err);
+            resolve(rows || []);
+          };
+          try {
+            if (params.length > 0) {
+              stmt.all(params, callback);
+            } else {
+              stmt.all(callback);
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+      const result = stmt.all(...params);
+      return isPromiseLike(result) ? yield result : result;
+    });
+  }
+  statementRun(stmt, params) {
+    return __async(this, null, function* () {
+      if (typeof stmt.run !== "function") {
+        throw new Error("SQLite statement does not support run()");
+      }
+      if (stmt.run.length >= 2) {
+        return yield new Promise((resolve, reject) => {
+          const callback = function(err) {
+            var _a;
+            if (err) return reject(err);
+            resolve({ changes: (_a = this == null ? void 0 : this.changes) != null ? _a : 0, lastID: this == null ? void 0 : this.lastID });
+          };
+          try {
+            if (params.length > 0) {
+              stmt.run(params, callback);
+            } else {
+              stmt.run(callback);
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+      const result = stmt.run(...params);
+      return isPromiseLike(result) ? yield result : result;
+    });
+  }
   _query(_0) {
     return __async(this, arguments, function* (sql, params = []) {
-      const stmt = yield this.connection.prepare(sql);
+      const stmt = yield this.prepareStatement(sql);
       try {
-        const rows = yield stmt.all(...params);
+        const rows = yield this.statementAll(stmt, params);
         return rows;
       } finally {
-        yield stmt.finalize();
+        yield this.finalizeStatement(stmt);
       }
     });
   }
@@ -574,12 +668,12 @@ ${sql}
           throw err;
         });
       }
-      const stmt = yield this.connection.prepare(sql);
+      const stmt = yield this.prepareStatement(sql);
       try {
-        const info = yield stmt.run(...params);
+        const info = yield this.statementRun(stmt, params);
         return info;
       } finally {
-        yield stmt.finalize();
+        yield this.finalizeStatement(stmt);
       }
     });
   }
@@ -595,13 +689,13 @@ ${sql}
       ).filter((s) => s.trim() !== "");
       const infos = yield statements.reduce((prev, statement) => __async(this, null, function* () {
         const infos2 = yield prev;
-        const stmt = yield this.connection.prepare(`${statement};`);
+        const stmt = yield this.prepareStatement(`${statement};`);
         try {
-          const info = yield stmt.run(...params);
+          const info = yield this.statementRun(stmt, params);
           infos2.push(info);
           return infos2;
         } finally {
-          yield stmt.finalize();
+          yield this.finalizeStatement(stmt);
         }
       }), Promise.resolve([null])).then((infos2) => {
         return infos2.filter((info) => info !== null);
@@ -634,7 +728,14 @@ function toError(error) {
   if (error instanceof Error) return error;
   return new Error(String(error));
 }
+function loadMigrationConfig(configFile) {
+  const reader = new FileMigrationConfigReader(configFile);
+  return reader.loadFile();
+}
 var MigrationRunnerFactory = class _MigrationRunnerFactory {
+  static isSQLRunner(conn) {
+    return !!conn && typeof conn.query === "function" && typeof conn.execute === "function" && typeof conn.end === "function";
+  }
   static create(configFile, conn) {
     return __async(this, null, function* () {
       const configReader = new FileMigrationConfigReader(configFile);
@@ -690,21 +791,27 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
   create(config, conn) {
     return __async(this, null, function* () {
       let sqlrunner;
-      switch (config.database) {
-        case "sql":
-          sqlrunner = new SQLRunner(conn);
-          break;
-        case "sqlite":
-          sqlrunner = new SQLiteRunner(conn);
-          break;
-        default:
-          throw ConfigurationError.unknownDatabaseType(config.database);
+      let driverConnection = conn;
+      if (_MigrationRunnerFactory.isSQLRunner(conn)) {
+        sqlrunner = conn;
+        driverConnection = null;
+      } else {
+        switch (config.database) {
+          case "sql":
+            sqlrunner = new SQLRunner(conn);
+            break;
+          case "sqlite":
+            sqlrunner = new SQLiteRunner(conn);
+            break;
+          default:
+            throw ConfigurationError.unknownDatabaseType(config.database);
+        }
       }
       const setup = new MigrationSetup(sqlrunner, config);
       const read_strategy = this.getReadStategy(config);
       const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner);
       yield setup.setup();
-      return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, conn);
+      return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, driverConnection);
     });
   }
   createEmpty(config) {
@@ -868,6 +975,11 @@ var MySQLMigrationRunner = class {
       }
     });
   }
+  query(sql, params) {
+    return __async(this, null, function* () {
+      return yield this.sqlrunner.query(sql, params);
+    });
+  }
   init(config_file) {
     return __async(this, null, function* () {
       try {
@@ -963,9 +1075,262 @@ var MigrationCreator = class {
     }
   }
 };
+
+// framework/SeedRunner.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
+function resolveAlias(name, aliasMap) {
+  var _a;
+  if (!aliasMap) return name;
+  return (_a = aliasMap[name]) != null ? _a : name;
+}
+function walkForFile(rootDir, fileName) {
+  if (!import_fs4.default.existsSync(rootDir)) return null;
+  const entries = import_fs4.default.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = import_path2.default.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      const found = walkForFile(full, fileName);
+      if (found) return found;
+    } else if (entry.isFile() && entry.name === fileName) {
+      return full;
+    }
+  }
+  return null;
+}
+function resolveMigrationsDir(migrationConfig, options) {
+  var _a;
+  const fromOptions = options.migrationsDir;
+  const fromConfig = (_a = migrationConfig.seeds) == null ? void 0 : _a.migrationsDir;
+  const dir = fromOptions != null ? fromOptions : fromConfig;
+  if (!dir) {
+    throw new Error("Seed migrationsDir not configured. Set seeds.migrationsDir in proper.json or pass it explicitly.");
+  }
+  return dir;
+}
+function mergeSeedConfig(migrationConfig, options) {
+  var _a, _b, _c, _d;
+  const names = options.names && options.names.length ? options.names : ((_a = migrationConfig.seeds) == null ? void 0 : _a.list) && migrationConfig.seeds.list.length ? migrationConfig.seeds.list : [];
+  if (!names.length) {
+    throw new Error("No seed names provided and no seeds.list defined in proper config");
+  }
+  const migrationsDir = resolveMigrationsDir(migrationConfig, options);
+  const dataDir = (_c = options.dataDir) != null ? _c : (_b = migrationConfig.seeds) == null ? void 0 : _b.dataDir;
+  const validate = options.validate !== void 0 ? options.validate : true;
+  const transactional = (_d = options.transactional) != null ? _d : "none";
+  const finalOptions = __spreadProps(__spreadValues({}, options), {
+    migrationsDir,
+    dataDir,
+    validate,
+    transactional
+  });
+  return { names, finalOptions };
+}
+function resolveSqlPair(name, migrationsDir) {
+  const up = walkForFile(migrationsDir, `${name}.up.sql`);
+  const down = walkForFile(migrationsDir, `${name}.down.sql`);
+  if (up && down) {
+    return { upPath: up, downPath: down };
+  }
+  return null;
+}
+function resolveModule(name, migrationsDir) {
+  const ts = walkForFile(migrationsDir, `${name}.ts`);
+  if (ts) return { kind: "ts", modulePath: ts };
+  const js = walkForFile(migrationsDir, `${name}.js`);
+  if (js) return { kind: "js", modulePath: js };
+  return null;
+}
+function resolveSeed(name, migrationConfig, options) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const migrationsDir = resolveMigrationsDir(migrationConfig, options);
+    const alias = resolveAlias(name, options.aliasMap);
+    const sqlPair = resolveSqlPair(name, migrationsDir);
+    if (sqlPair) {
+      return {
+        kind: "sql",
+        name,
+        alias,
+        upPath: sqlPair.upPath,
+        downPath: sqlPair.downPath,
+        dataPath: null,
+        schemaPath: null
+      };
+    }
+    const module2 = resolveModule(name, migrationsDir);
+    if (!module2) {
+      throw new Error(`Seed implementation not found for "${name}" under ${migrationsDir}`);
+    }
+    const dataDir = (_b = options.dataDir) != null ? _b : (_a = migrationConfig.seeds) == null ? void 0 : _a.dataDir;
+    let dataPath = null;
+    let schemaPath = null;
+    if (dataDir) {
+      dataPath = walkForFile(dataDir, `${alias}.json`);
+      schemaPath = walkForFile(dataDir, `${alias}.schema.json`);
+    }
+    return {
+      kind: module2.kind,
+      name,
+      alias,
+      upPath: module2.modulePath,
+      downPath: module2.modulePath,
+      dataPath,
+      schemaPath
+    };
+  });
+}
+function loadJson(filePath) {
+  return __async(this, null, function* () {
+    const content = yield import_fs4.default.promises.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  });
+}
+function createValidator() {
+  const ajv = new import_ajv.default({ allErrors: true, strict: false });
+  (0, import_ajv_formats.default)(ajv);
+  return ajv;
+}
+function validateData(schemaPath, data, validate, log) {
+  return __async(this, null, function* () {
+    if (!validate || !schemaPath) return;
+    const content = yield import_fs4.default.promises.readFile(schemaPath, "utf8");
+    const schema = JSON.parse(content);
+    const ajv = createValidator();
+    const validateFn = ajv.compile(schema);
+    const ok = validateFn(data);
+    if (!ok) {
+      log == null ? void 0 : log(`Validation failed for seed data (${schemaPath})`);
+      throw new Error(`Seed data validation failed: ${ajv.errorsText(validateFn.errors || [])}`);
+    }
+  });
+}
+function runSqlSeed(runner, resolved, direction) {
+  return __async(this, null, function* () {
+    const sqlPath = direction === "up" ? resolved.upPath : resolved.downPath;
+    const sql = yield import_fs4.default.promises.readFile(sqlPath, "utf8");
+    yield runner.query(sql);
+  });
+}
+function runModuleSeed(runner, resolved, migrationConfig, options, direction) {
+  return __async(this, null, function* () {
+    const { log } = options;
+    const module2 = yield import(import_path2.default.resolve(resolved.upPath));
+    const handler = module2[direction];
+    if (typeof handler !== "function") {
+      throw new Error(`Seed module "${resolved.name}" does not export ${direction}()`);
+    }
+    let data = null;
+    if (options.preloadedData && Object.prototype.hasOwnProperty.call(options.preloadedData, resolved.name)) {
+      data = options.preloadedData[resolved.name];
+    } else if (resolved.dataPath) {
+      data = yield loadJson(resolved.dataPath);
+    }
+    yield validateData(resolved.schemaPath, data, options.validate, log);
+    const ctx = {
+      data,
+      log,
+      dialect: migrationConfig.database || "sql"
+    };
+    yield handler(runner, ctx);
+  });
+}
+function runSingleSeed(runner, migrationConfig, name, options, direction) {
+  return __async(this, null, function* () {
+    const resolved = yield resolveSeed(name, migrationConfig, options);
+    if (resolved.kind === "sql") {
+      yield runSqlSeed(runner, resolved, direction);
+    } else {
+      yield runModuleSeed(runner, resolved, migrationConfig, options, direction);
+    }
+  });
+}
+function withTransactionalMode(runner, migrationConfig, names, options, direction) {
+  return __async(this, null, function* () {
+    const mode = options.transactional;
+    if (mode === "runner") {
+      yield runner.query("BEGIN");
+      try {
+        for (const name of names) {
+          yield runSingleSeed(runner, migrationConfig, name, options, direction);
+        }
+        yield runner.query("COMMIT");
+      } catch (err) {
+        try {
+          yield runner.query("ROLLBACK");
+        } catch (e) {
+        }
+        throw err;
+      }
+      return;
+    }
+    if (mode === "seed") {
+      for (const name of names) {
+        yield runner.query("BEGIN");
+        try {
+          yield runSingleSeed(runner, migrationConfig, name, options, direction);
+          yield runner.query("COMMIT");
+        } catch (err) {
+          try {
+            yield runner.query("ROLLBACK");
+          } catch (e) {
+          }
+          throw err;
+        }
+      }
+      return;
+    }
+    for (const name of names) {
+      yield runSingleSeed(runner, migrationConfig, name, options, direction);
+    }
+  });
+}
+function runSeedsWithRunner(runner, migrationConfig, direction, options) {
+  return __async(this, null, function* () {
+    const { names, finalOptions } = mergeSeedConfig(migrationConfig, options);
+    yield withTransactionalMode(runner, migrationConfig, names, finalOptions, direction);
+  });
+}
+function createSeedFactory(options) {
+  var _a;
+  const configFile = (_a = options.configFile) != null ? _a : "proper.json";
+  return {
+    up(names) {
+      return __async(this, null, function* () {
+        const runner = yield MigrationRunnerFactory.create(configFile);
+        const migrationConfig = loadMigrationConfig(configFile);
+        try {
+          yield runSeedsWithRunner(runner, migrationConfig, "up", __spreadProps(__spreadValues({}, options), {
+            names: names && names.length ? names : options.names
+          }));
+        } finally {
+          yield runner.close();
+        }
+      });
+    },
+    down(names) {
+      return __async(this, null, function* () {
+        const runner = yield MigrationRunnerFactory.create(configFile);
+        const migrationConfig = loadMigrationConfig(configFile);
+        try {
+          yield runSeedsWithRunner(runner, migrationConfig, "down", __spreadProps(__spreadValues({}, options), {
+            names: names && names.length ? names : options.names
+          }));
+        } finally {
+          yield runner.close();
+        }
+      });
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MigrationRunner,
-  MigrationRunnerFactory
+  MigrationRunnerFactory,
+  createSeedFactory,
+  loadMigrationConfig,
+  runSeedsWithRunner
 });
 //# sourceMappingURL=index.js.map