@noego/proper 0.0.1

package/bin/cli.js

@@ -0,0 +1,1140 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// cli.ts
+var import_register = require("source-map-support/register");
+
+// framework/MigrationCLi.ts
+var import_minimist = __toESM(require("minimist"));
+var MigrationCLIFactory = class {
+  /**
+   * Parse command line arguments into commands and flags
+   * @param argv Optional array of command line arguments. If not provided, process.argv will be used.
+   * @returns Object containing parsed commands and flags
+   */
+  static setup(argv) {
+    var _a;
+    const args2 = argv || process.argv;
+    let startIndex = 0;
+    if ((_a = args2[0]) == null ? void 0 : _a.includes("node")) {
+      startIndex = 2;
+    } else if (args2[0] && /\.(js|ts|mjs|cjs)$/i.test(args2[0])) {
+      startIndex = 1;
+    } else if (args2[0] && ["proper", "migration", "sql-proper"].includes(args2[0].toLowerCase())) {
+      startIndex = 1;
+    }
+    const cli = (0, import_minimist.default)(args2.slice(startIndex), {
+      alias: {
+        c: "config"
+      }
+    });
+    const _b = cli, { _: commands2 } = _b, flags = __objRest(_b, ["_"]);
+    return {
+      commands: commands2,
+      flags
+    };
+  }
+};
+
+// framework/MigrationFilter.ts
+function migration_filter(_0) {
+  return __async(this, arguments, function* (migrations, completed = true, keep = []) {
+    if (migrations.length === 0) {
+      return keep;
+    }
+    const [first, ...rest] = migrations;
+    const status = yield first.status();
+    if (status.completed == completed) {
+      keep.push(first);
+    }
+    return migration_filter(rest, completed, keep);
+  });
+}
+
+// framework/MigrationRunner.ts
+var import_fs3 = __toESM(require("fs"));
+var import_promise = __toESM(require("mysql2/promise"));
+var sqlite = __toESM(require("sqlite"));
+var sqlite3 = __toESM(require("sqlite3"));
+
+// framework/MigrationDirectoryReader.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// framework/errors.ts
+var MigrationError = class _MigrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MigrationError";
+    Object.setPrototypeOf(this, _MigrationError.prototype);
+  }
+};
+var ConfigurationError = class _ConfigurationError extends MigrationError {
+  constructor(message) {
+    super(`Configuration Error: ${message}`);
+    this.name = "ConfigurationError";
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+  /**
+   * Helper method for missing database configuration
+   * @param dbType The database type (e.g., 'sql', 'sqlite')
+   * @returns A ConfigurationError with appropriate message
+   */
+  static missingDatabaseConfiguration(dbType) {
+    return new _ConfigurationError(`Missing ${dbType} configuration`);
+  }
+  /**
+   * Helper method for unknown database type
+   * @param dbType The unknown database type
+   * @returns A ConfigurationError with appropriate message
+   */
+  static unknownDatabaseType(dbType) {
+    return new _ConfigurationError(`Unknown database type: ${dbType}`);
+  }
+  /**
+   * Helper method for missing required configuration properties
+   * @param property The name of the missing property
+   * @returns A ConfigurationError with appropriate message
+   */
+  static missingRequiredProperty(property) {
+    return new _ConfigurationError(`Missing required property: ${property}`);
+  }
+};
+var DatabaseConnectionError = class _DatabaseConnectionError extends MigrationError {
+  constructor(message) {
+    super(`Database Connection Error: ${message}`);
+    this.name = "DatabaseConnectionError";
+    Object.setPrototypeOf(this, _DatabaseConnectionError.prototype);
+  }
+  /**
+   * Helper method for connection errors
+   * @param dbType The database type (e.g., 'sql', 'sqlite')
+   * @param details Additional error details
+   * @returns A DatabaseConnectionError with appropriate message
+   */
+  static connectionFailed(dbType, details) {
+    const message = details ? `Failed to connect to ${dbType} database: ${details}` : `Failed to connect to ${dbType} database`;
+    return new _DatabaseConnectionError(message);
+  }
+  /**
+   * Helper method for authentication errors
+   * @param dbType The database type (e.g., 'sql', 'sqlite')
+   * @returns A DatabaseConnectionError with appropriate message
+   */
+  static authenticationFailed(dbType) {
+    return new _DatabaseConnectionError(`Authentication failed for ${dbType} database`);
+  }
+};
+var MigrationExecutionError = class _MigrationExecutionError extends MigrationError {
+  constructor(message, migrationName, sql, originalError) {
+    let fullMessage = `Migration Execution Error${migrationName ? ` in '${migrationName}'` : ""}: ${message}`;
+    if (originalError) {
+      fullMessage += `
+Original Error:
+${originalError.message}`;
+    }
+    super(fullMessage);
+    this.migrationName = migrationName;
+    this.sql = sql;
+    this.originalError = originalError;
+    this.name = "MigrationExecutionError";
+    Object.setPrototypeOf(this, _MigrationExecutionError.prototype);
+  }
+  /**
+   * Helper method for SQL execution errors
+   * @param migrationName The name of the migration
+   * @param sql The SQL that caused the error
+   * @param originalError The original error thrown by the database driver
+   * @returns A MigrationExecutionError with appropriate message
+   */
+  static sqlExecutionFailed(migrationName, sql, originalError) {
+    return new _MigrationExecutionError(
+      originalError.message,
+      migrationName,
+      sql,
+      originalError
+    );
+  }
+  /**
+   * Helper method for missing migration file errors
+   * @param filename The missing file
+   * @returns A MigrationExecutionError with appropriate message
+   */
+  static missingMigrationFile(filename) {
+    return new _MigrationExecutionError(`Migration file not found: ${filename}`);
+  }
+  /**
+   * Helper method for invalid migration file format errors
+   * @param filename The invalid file
+   * @param details Additional error details
+   * @returns A MigrationExecutionError with appropriate message
+   */
+  static invalidMigrationFile(filename, details) {
+    const message = details ? `Invalid migration file format in ${filename}: ${details}` : `Invalid migration file format in ${filename}`;
+    return new _MigrationExecutionError(message);
+  }
+};
+var CLIError = class _CLIError extends MigrationError {
+  constructor(message) {
+    super(`CLI Error: ${message}`);
+    this.name = "CLIError";
+    Object.setPrototypeOf(this, _CLIError.prototype);
+  }
+  /**
+   * Helper method for missing command errors
+   * @returns A CLIError with appropriate message
+   */
+  static missingCommand() {
+    return new _CLIError("No command specified. Run with --help for usage information.");
+  }
+  /**
+   * Helper method for unknown command errors
+   * @param command The unknown command
+   * @returns A CLIError with appropriate message
+   */
+  static unknownCommand(command2) {
+    return new _CLIError(`Unknown command: ${command2}. Run with --help for usage information.`);
+  }
+  /**
+   * Helper method for missing required argument errors
+   * @param argument The missing argument
+   * @returns A CLIError with appropriate message
+   */
+  static missingRequiredArgument(argument) {
+    return new _CLIError(`Missing required argument: ${argument}`);
+  }
+};
+
+// framework/MigrationNode.ts
+var MigrationNode = class {
+  constructor(name) {
+    this.name = name || "";
+  }
+};
+var SqlMigrationNode = class extends MigrationNode {
+  constructor(conn, table, key, up_file, sql_up, down_file, sql_down) {
+    super(key);
+    this.conn = conn;
+    this.table = table;
+    this.key = key;
+    this.up_file = up_file;
+    this.sql_up = sql_up;
+    this.down_file = down_file;
+    this.sql_down = sql_down;
+  }
+  up_sql() {
+    return this.sql_up;
+  }
+  down_sql() {
+    return this.sql_down;
+  }
+  get_key() {
+    return this.key;
+  }
+  status() {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.conn.query(`
+                select * 
+                from ${this.table}
+                where migration_key = ?;
+            `, [this.key]);
+        if (result.length > 0 && result[0].length > 0) {
+          return {
+            completed: true
+          };
+        } else {
+          return {
+            completed: false
+          };
+        }
+      } catch (error) {
+        throw new MigrationExecutionError(
+          `Error checking status for migration`,
+          this.key,
+          void 0,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    });
+  }
+  up() {
+    return __async(this, null, function* () {
+      try {
+        yield this.conn.execute(this.sql_up);
+      } catch (error) {
+        throw new MigrationExecutionError(
+          `Error executing UP migration`,
+          this.key,
+          this.sql_up,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+      try {
+        yield this.conn.execute(`
+                insert into ${this.table} (migration_key,up,down)
+                values (?,?,?)
+            `, [this.key, this.up_file, this.down_file]);
+      } catch (error) {
+        throw new MigrationExecutionError(
+          `Error recording migration completion`,
+          this.key,
+          void 0,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    });
+  }
+  down() {
+    return __async(this, null, function* () {
+      try {
+        yield this.conn.execute(this.sql_down);
+      } catch (error) {
+        throw new MigrationExecutionError(
+          `Error executing DOWN migration`,
+          this.key,
+          this.sql_down,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+      try {
+        yield this.conn.execute(`
+                delete from ${this.table}
+                where migration_key = ?
+            `, [this.key]);
+      } catch (error) {
+        throw new MigrationExecutionError(
+          `Error removing migration record`,
+          this.key,
+          void 0,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    });
+  }
+};
+
+// framework/SqlMigrationBuilder.ts
+var SqlMigrationBuilder = class {
+  constructor(key) {
+    this.key = key;
+    this.up = "";
+    this.up_file = "";
+    this.down = "";
+    this.down_file = "";
+  }
+  set_up(file, up) {
+    this.up_file = file;
+    this.up = up;
+  }
+  set_down(file, down) {
+    this.down_file = file;
+    this.down = down;
+  }
+  build(table, conn) {
+    return new SqlMigrationNode(conn, table, this.key, this.up_file, this.up, this.down_file, this.down);
+  }
+};
+
+// framework/MigrationDirectoryReader.ts
+var MigrationDirectoryReader = class {
+  constructor(directory, read_strategy, sqlrunner) {
+    this.directory = directory;
+    this.read_strategy = read_strategy;
+    this.sqlrunner = sqlrunner;
+  }
+  loadMigrations(table, connection) {
+    import_fs.default.existsSync(this.directory) || import_fs.default.mkdirSync(this.directory);
+    const dir_content = import_fs.default.readdirSync(this.directory, { withFileTypes: true }).filter((file) => file.isFile()).map((file) => file.name);
+    let migration_files = dir_content.map((file) => {
+      return {
+        migration_key: file.replace(/\.(up|down)\.(sql|js)/i, "").toLowerCase(),
+        directory: this.directory,
+        relative_path: import_path.default.join(this.directory, file),
+        file
+      };
+    }).sort();
+    const migration_sorter = {};
+    migration_files.forEach((migration) => {
+      const builder = migration_sorter[migration.migration_key] = migration_sorter[migration.migration_key] || new SqlMigrationBuilder(migration.migration_key);
+      this.loadMigration(builder, migration.relative_path);
+    });
+    const keys = Object.keys(migration_sorter);
+    keys.sort();
+    const built = keys.map((key) => {
+      return migration_sorter[key].build(table, this.sqlrunner);
+    });
+    return built;
+  }
+  loadMigration(builder, file) {
+    const is_sql = /sql$/i.test(file);
+    const is_js = /js$/i.test(file);
+    const is_up = /up\.(js|sql)/i.test(file);
+    const is_down = /down\.(js|sql)/i.test(file);
+    if (is_sql && is_up) {
+      const content = this.sql_up(file);
+      builder.set_up(file, content);
+    } else if (is_sql && is_down) {
+      const content = this.sql_down(file);
+      builder.set_down(file, content);
+    } else {
+      throw new Error(`Invalid migration file: ${file}`);
+    }
+    return builder;
+  }
+  sql_up(file) {
+    let content = import_fs.default.readFileSync(file).toString();
+    content = this.read_strategy(content);
+    return content.trim();
+  }
+  sql_down(file) {
+    let content = import_fs.default.readFileSync(file).toString();
+    content = this.read_strategy(content);
+    return content.trim();
+  }
+};
+
+// framework/MigrationSetup.ts
+var import_fs2 = __toESM(require("fs"));
+var MigrationSetup = class {
+  constructor(sqlrunner, config) {
+    this.sqlrunner = sqlrunner;
+    this.config = config;
+  }
+  setup() {
+    return __async(this, null, function* () {
+      import_fs2.default.existsSync(this.config.migration_folder) || import_fs2.default.mkdirSync(this.config.migration_folder);
+      const tableName = this.config.migration_table;
+      const createTableSql = this.config.database === "sqlite" ? `CREATE TABLE IF NOT EXISTS ${tableName} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                migration_key TEXT,
+                up TEXT,
+                down TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )` : `CREATE TABLE IF NOT EXISTS ${tableName} (
+                id INT AUTO_INCREMENT PRIMARY KEY,
+                migration_key VARCHAR(255),
+                up VARCHAR(255),
+                down VARCHAR(255),
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )`;
+      yield this.sqlrunner.query(createTableSql);
+    });
+  }
+  teardown() {
+    return __async(this, null, function* () {
+      yield this.sqlrunner.execute(`DROP TABLE ${this.config.migration_table}`);
+    });
+  }
+};
+
+// framework/MigrationDialectParser.ts
+function MySqlDialectParser(sql) {
+  const lines = sql.split("\n");
+  let result = "";
+  let isInMySQLBlock = true;
+  const startSQLRegex = /^\s*--\s*\[\s*(sql|mysql)\s*\]\s*$/i;
+  const anyDialectRegex = /^\s*--\s*\[\s*\w+\s*\]\s*$/i;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (startSQLRegex.test(trimmed)) {
+      isInMySQLBlock = true;
+      result += line + "\n";
+      continue;
+    }
+    if (anyDialectRegex.test(trimmed) && !startSQLRegex.test(trimmed)) {
+      isInMySQLBlock = false;
+      continue;
+    }
+    if (!isInMySQLBlock && line.toLowerCase().includes("create index")) {
+      isInMySQLBlock = true;
+    }
+    if (isInMySQLBlock) {
+      result += line + "\n";
+    }
+  }
+  return result;
+}
+function SqliteDialectParser(sql) {
+  const lines = sql.split("\n");
+  let result = "";
+  let isInSqliteBlock = true;
+  const startSqliteRegex = /^\s*--\s*\[\s*sqlite\s*\]\s*$/i;
+  const anyDialectRegex = /^\s*--\s*\[\s*\w+\s*\]\s*$/i;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (startSqliteRegex.test(trimmed)) {
+      isInSqliteBlock = true;
+      result += line + "\n";
+      continue;
+    } else if (anyDialectRegex.test(trimmed) && !startSqliteRegex.test(trimmed)) {
+      isInSqliteBlock = false;
+      continue;
+    }
+    if (!isInSqliteBlock && line.toLowerCase().includes("create index")) {
+      isInSqliteBlock = true;
+    }
+    if (isInSqliteBlock) {
+      result += line + "\n";
+    }
+  }
+  return result;
+}
+
+// framework/SQLRunner.ts
+var BaseSQLRunner = class {
+  /**
+   * Ensures that both MySQL and SQLite return the same tuple shape that callers
+   * expect: `[rowsOrResult, extra]`.  For SQLite there is no `extra` metadata
+   * comparable to MySQL's `FieldPacket[]`, so we just use `undefined`.
+   */
+  query(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      const result = yield this._query(sql, params);
+      return Array.isArray(result) && result.length === 2 ? result : [result, void 0];
+    });
+  }
+  execute(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      const result = yield this._execute(sql, params);
+      return Array.isArray(result) && result.length === 2 ? result : [result, void 0];
+    });
+  }
+  end() {
+    return __async(this, null, function* () {
+      yield this._end();
+    });
+  }
+};
+var SQLRunner = class extends BaseSQLRunner {
+  constructor(connection) {
+    super();
+    this.connection = connection;
+  }
+  // The MySQL driver already returns the correct tuple shapes.
+  _query(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      return yield this.connection.query(sql, params);
+    });
+  }
+  _execute(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      return yield this.connection.execute(sql, params);
+    });
+  }
+  _end() {
+    return __async(this, null, function* () {
+      if (this.connection) {
+        yield this.connection.end();
+      }
+    });
+  }
+};
+var SQLiteRunner = class extends BaseSQLRunner {
+  constructor(connection) {
+    super();
+    this.connection = connection;
+  }
+  _query(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      const stmt = yield this.connection.prepare(sql);
+      try {
+        const rows = yield stmt.all(...params);
+        return rows;
+      } finally {
+        yield stmt.finalize();
+      }
+    });
+  }
+  _execute(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      if (this.isMultiStatement(sql)) {
+        return yield this.executeMultiStatement(sql, params).catch((err) => {
+          console.error(`Error executing multi-statement SQL:
+${sql}
+`, err);
+          throw err;
+        });
+      }
+      const stmt = yield this.connection.prepare(sql);
+      try {
+        const info = yield stmt.run(...params);
+        return info;
+      } finally {
+        yield stmt.finalize();
+      }
+    });
+  }
+  isMultiStatement(sql) {
+    return sql.split(";").length > 1;
+  }
+  executeMultiStatement(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      const statements = sql.split(";").map(
+        (s) => s.split("\n").map(
+          (s2) => this.removeComments(s2)
+        ).filter((s2) => s2.trim() != "").join("\n")
+      ).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};`);
+        try {
+          const info = yield stmt.run(...params);
+          infos2.push(info);
+          return infos2;
+        } finally {
+          yield stmt.finalize();
+        }
+      }), Promise.resolve([null])).then((infos2) => {
+        return infos2.filter((info) => info !== null);
+      });
+      return infos.reduce((acc, latest) => {
+        if (latest) {
+          acc.stmt = latest.stmt;
+          acc.lastID = latest.lastID;
+          acc.changes += latest.changes;
+        }
+        return acc;
+      });
+    });
+  }
+  removeComments(sql) {
+    sql = sql.replace(/--.*$/gm, "");
+    return sql;
+  }
+  _end() {
+    return __async(this, null, function* () {
+      if (this.connection) {
+        yield this.connection.close();
+      }
+    });
+  }
+};
+
+// framework/MigrationRunner.ts
+function toError(error) {
+  if (error instanceof Error) return error;
+  return new Error(String(error));
+}
+var MigrationRunnerFactory = class _MigrationRunnerFactory {
+  static create(configFile, conn) {
+    return __async(this, null, function* () {
+      const configReader = new FileMigrationConfigReader(configFile);
+      const config = configReader.loadFile();
+      if (!conn) {
+        conn = yield this.createConnection(config);
+      }
+      return new _MigrationRunnerFactory().create(config, conn);
+    });
+  }
+  static createConnection(config) {
+    return __async(this, null, function* () {
+      let conn = null;
+      switch (config.database) {
+        case "sql":
+          if (!config.sql) {
+            throw ConfigurationError.missingDatabaseConfiguration("sql");
+          }
+          const settings = Object.assign({
+            password: process.env.SQL_PASSWORD
+          }, config.sql);
+          try {
+            conn = yield import_promise.default.createConnection(settings);
+            return conn;
+          } catch (error) {
+            throw DatabaseConnectionError.connectionFailed("sql", toError(error).message);
+          }
+        case "sqlite":
+          if (!config.sqlite) {
+            throw ConfigurationError.missingDatabaseConfiguration("sqlite");
+          }
+          try {
+            conn = yield sqlite.open({
+              filename: config.sqlite.database,
+              driver: sqlite3.Database
+            });
+            return conn;
+          } catch (error) {
+            throw DatabaseConnectionError.connectionFailed("sqlite", toError(error).message);
+          }
+        default:
+          throw ConfigurationError.unknownDatabaseType(config.database);
+      }
+    });
+  }
+  static createEmpty(configFile) {
+    return __async(this, null, function* () {
+      const configReader = new FileMigrationConfigReader(configFile);
+      const config = configReader.loadFile();
+      return new _MigrationRunnerFactory().createEmpty(config);
+    });
+  }
+  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);
+      }
+      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);
+    });
+  }
+  createEmpty(config) {
+    return __async(this, null, function* () {
+      const conn = null;
+      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);
+      }
+      const setup = new MigrationSetup(sqlrunner, config);
+      const read_strategy = this.getReadStategy(config);
+      const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner);
+      return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, conn);
+    });
+  }
+  getReadStategy(config) {
+    switch (config.database) {
+      case "sql":
+        return MySqlDialectParser;
+      case "sqlite":
+        return SqliteDialectParser;
+      default:
+        throw ConfigurationError.unknownDatabaseType(config.database);
+    }
+  }
+};
+var MySQLMigrationRunner = class {
+  constructor(config, directory, setupRunner, sqlrunner, connection) {
+    this.config = config;
+    this.directory = directory;
+    this.setupRunner = setupRunner;
+    this.sqlrunner = sqlrunner;
+    this.connection = connection;
+  }
+  setup() {
+    return __async(this, null, function* () {
+      try {
+        yield this.setupRunner.setup();
+      } catch (error) {
+        throw new MigrationExecutionError("Failed to set up migration database", void 0, void 0, toError(error));
+      }
+    });
+  }
+  terminate() {
+    return __async(this, null, function* () {
+      try {
+        yield this.setupRunner.teardown();
+      } catch (error) {
+        throw new MigrationExecutionError("Failed to tear down migration database", void 0, void 0, toError(error));
+      }
+    });
+  }
+  getMigrationsHistory() {
+    return __async(this, null, function* () {
+      try {
+        const results = yield this.sqlrunner.query(`
+                select * 
+                from ${this.config.migration_table}
+            `);
+        return results[0];
+      } catch (error) {
+        throw new MigrationExecutionError("Failed to get migration history", void 0, void 0, toError(error));
+      }
+    });
+  }
+  getMigrations() {
+    return __async(this, null, function* () {
+      try {
+        return this.directory.loadMigrations(this.config.migration_table, this.connection);
+      } catch (error) {
+        throw new MigrationExecutionError("Failed to load migrations", void 0, void 0, toError(error));
+      }
+    });
+  }
+  getPendingMigrations() {
+    return __async(this, null, function* () {
+      try {
+        const migrations = yield this.getMigrations();
+        return migration_filter(migrations, false);
+      } catch (error) {
+        if (error instanceof MigrationExecutionError) {
+          throw error;
+        }
+        throw new MigrationExecutionError("Failed to get pending migrations", void 0, void 0, toError(error));
+      }
+    });
+  }
+  getCompletedMigrations() {
+    return __async(this, null, function* () {
+      try {
+        const migrations = yield this.getMigrations();
+        return migration_filter(migrations, true);
+      } catch (error) {
+        if (error instanceof MigrationExecutionError) {
+          throw error;
+        }
+        throw new MigrationExecutionError("Failed to get completed migrations", void 0, void 0, toError(error));
+      }
+    });
+  }
+  migrate(migrationNodes, forward) {
+    return __async(this, null, function* () {
+      for (let node of migrationNodes) {
+        try {
+          if (forward) {
+            yield node.up();
+          } else {
+            yield node.down();
+          }
+        } catch (error) {
+          throw new MigrationExecutionError(
+            `Failed to ${forward ? "apply" : "rollback"} migration`,
+            node.name || String(node),
+            forward ? node.up_sql() : node.down_sql(),
+            toError(error)
+          );
+        }
+      }
+    });
+  }
+  reset() {
+    return __async(this, null, function* () {
+      try {
+        let migrations = yield this.getMigrations();
+        const rollback = yield migration_filter(migrations, true);
+        yield this.migrate(rollback.reverse(), false);
+        migrations = yield this.getMigrations();
+        const rollforward = yield migration_filter(migrations, false);
+        yield this.migrate(rollforward, true);
+      } catch (error) {
+        if (error instanceof MigrationExecutionError) {
+          throw error;
+        }
+        throw new MigrationExecutionError("Failed to reset migrations", void 0, void 0, toError(error));
+      }
+    });
+  }
+  createMigration(name) {
+    try {
+      const creator = new MigrationCreator(this.config);
+      creator.create(name);
+    } catch (error) {
+      throw new MigrationExecutionError(`Failed to create migration: ${name}`, void 0, void 0, toError(error));
+    }
+  }
+  close() {
+    return __async(this, null, function* () {
+      if (this.sqlrunner) {
+        try {
+          yield this.sqlrunner.end();
+        } catch (error) {
+          throw new DatabaseConnectionError(`Failed to close database connection: ${toError(error).message}`);
+        }
+      }
+    });
+  }
+  init(config_file2) {
+    return __async(this, null, function* () {
+      try {
+        console.log(`Checking for ${config_file2}`);
+        const config_exist = import_fs3.default.existsSync(config_file2);
+        if (!config_exist) {
+          console.log(`Creating ${config_file2}`);
+          const default_config = {
+            "migration_folder": "migrations",
+            "migration_table": "proper_migrations",
+            "database": "sql",
+            "sql": {
+              "host": "localhost",
+              "user": "root",
+              "database": "proper",
+              "password": ""
+            }
+          };
+          import_fs3.default.writeFileSync(config_file2, JSON.stringify(default_config, null, 2));
+          console.log(`Created ${config_file2}`);
+        }
+      } catch (error) {
+        throw new ConfigurationError(`Failed to initialize config file: ${toError(error).message}`);
+      }
+    });
+  }
+};
+var FileMigrationConfigReader = class {
+  constructor(configFile) {
+    this.configFile = configFile;
+  }
+  loadFile() {
+    try {
+      const fileContent = import_fs3.default.readFileSync(this.configFile);
+      const config = JSON.parse(fileContent.toString());
+      if (!config.migration_folder) {
+        throw ConfigurationError.missingRequiredProperty("migration_folder");
+      }
+      if (!config.migration_table) {
+        throw ConfigurationError.missingRequiredProperty("migration_table");
+      }
+      if (!config.database) {
+        if (config.sql) {
+          config.database = "sql";
+        } else if (config.sqlite) {
+          config.database = "sqlite";
+        } else {
+          throw ConfigurationError.missingRequiredProperty("database");
+        }
+      }
+      return config;
+    } catch (error) {
+      if (error instanceof ConfigurationError) {
+        throw error;
+      }
+      const err = toError(error);
+      if (err.message.includes("ENOENT")) {
+        throw new ConfigurationError(`Config file not found: ${this.configFile}`);
+      }
+      throw new ConfigurationError(`Failed to load config file: ${err.message}`);
+    }
+  }
+};
+var MigrationCreator = class {
+  constructor(config) {
+    this.config = config;
+  }
+  create(name) {
+    if (!name) {
+      throw new CLIError("Migration name is required");
+    }
+    try {
+      if (!import_fs3.default.existsSync(this.config.migration_folder)) {
+        import_fs3.default.mkdirSync(this.config.migration_folder, { recursive: true });
+      }
+      const now_timestamp = Date.now();
+      const filename_up = `${now_timestamp}_${name}.up.sql`;
+      const filename_down = `${now_timestamp}_${name}.down.sql`;
+      import_fs3.default.writeFileSync(`${this.config.migration_folder}/${filename_up}`, `
+-- Write your up migration here
+            `.trim());
+      import_fs3.default.writeFileSync(`${this.config.migration_folder}/${filename_down}`, `
+-- Write your down migration here
+            `.trim());
+      console.log(`Created migration files:`);
+      console.log(`  ${filename_up}`);
+      console.log(`  ${filename_down}`);
+    } catch (error) {
+      if (error instanceof CLIError) {
+        throw error;
+      }
+      throw new MigrationExecutionError(`Failed to create migration files: ${toError(error).message}`);
+    }
+  }
+};
+
+// cli.ts
+var args = MigrationCLIFactory.setup(process.argv);
+if (!args.commands || args.commands.length === 0) {
+  console.error("Error: No command specified");
+  printUsage();
+  process.exit(1);
+}
+var commands = args.commands;
+var command = commands[0];
+var load_database = !["init", "create", "help"].includes(command.toLowerCase());
+var config_file = args.flags.config || "proper.json";
+if (command.toLowerCase() === "help") {
+  printUsage();
+  process.exit(0);
+}
+console.log(`Loading database: ${load_database}`);
+var pending_runner = load_database ? MigrationRunnerFactory.create(config_file) : MigrationRunnerFactory.createEmpty(config_file);
+pending_runner.then((runner) => __async(null, null, function* () {
+  try {
+    if (load_database) {
+      yield runner.setup();
+    }
+    switch (command.toLowerCase()) {
+      case "up":
+        const migrations_forward = yield runner.getMigrations();
+        let upgraded = yield migration_filter(migrations_forward, false);
+        if (args.flags.increment) {
+          const increment = parseInt(args.flags.increment);
+          upgraded = upgraded.slice(0, increment);
+        }
+        console.log(`Applying ${upgraded.length} migration(s)`);
+        if (upgraded.length > 0) {
+          for (const migration of upgraded) {
+            console.log(`  - ${migration.name}`);
+          }
+          yield runner.migrate(upgraded, true);
+          console.log("Migration completed successfully");
+        } else {
+          console.log("No pending migrations");
+        }
+        yield runner.close();
+        break;
+      case "down":
+        const migrations_rollback = yield runner.getMigrations();
+        let downgraded = yield migration_filter(migrations_rollback, true);
+        downgraded = downgraded.reverse();
+        if (args.flags.increment) {
+          const increment = parseInt(args.flags.increment);
+          downgraded = downgraded.slice(0, increment);
+        }
+        console.log(`Rolling back ${downgraded.length} migration(s)`);
+        if (downgraded.length > 0) {
+          for (const migration of downgraded) {
+            console.log(`  - ${migration.name}`);
+          }
+          yield runner.migrate(downgraded, false);
+          console.log("Rollback completed successfully");
+        } else {
+          console.log("No migrations to roll back");
+        }
+        yield runner.close();
+        break;
+      case "reset":
+        console.log("Resetting all migrations...");
+        yield runner.reset();
+        console.log("Reset completed successfully");
+        yield runner.close();
+        break;
+      case "create":
+        let filename = args.flags.name || commands[1];
+        if (!filename) {
+          throw new CLIError("Migration name is required");
+        }
+        filename = filename.replace(/\s/g, "_");
+        runner.createMigration(filename);
+        runner.close();
+        break;
+      case "init":
+        yield runner.init(config_file);
+        runner.close();
+        break;
+      case "status":
+        const { printTable } = require("console-table-printer");
+        const migrations = yield runner.getMigrations();
+        console.log("Migration Status:");
+        const table = migrations.map((m) => __async(null, null, function* () {
+          const status = yield m.status();
+          return {
+            key: m.get_key(),
+            status: status.completed ? "completed" : "pending"
+          };
+        }));
+        printTable(yield Promise.all(table));
+        runner.close();
+        break;
+      default:
+        throw CLIError.unknownCommand(command);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    if (error.stack && process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}));
+function printUsage() {
+  console.log(`
+SQL Proper - Database migration tool
+
+Usage: 
+  proper <command> [options]
+
+Commands:
+  up       Apply pending migrations
+  down     Roll back completed migrations
+  reset    Roll back all migrations and reapply them
+  create   Create a new migration
+  init     Initialize a new config file
+  status   Show migration status
+  help     Show this help message
+
+Options:
+  -c, --config      Specify the config file (default: proper.json)
+  --increment <n>   Limit the number of migrations to apply or roll back
+
+Examples:
+  proper up                      Apply all pending migrations
+  proper up --increment 1        Apply only the next pending migration
+  proper down                    Roll back the last applied migration
+  proper create my_migration     Create a new migration named "my_migration"
+  proper init                    Create a new config file
+  proper status                  Show the status of all migrations
+  proper -c custom.json up       Use a custom config file
+    `);
+}
+//# sourceMappingURL=cli.js.map