@noego/proper 0.0.1

package/bin/cli.mjs

@@ -0,0 +1,1192 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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());
+  });
+};
+
+// framework/MigrationCLi.ts
+import minimist from "minimist";
+var MigrationCLIFactory;
+var init_MigrationCLi = __esm({
+  "framework/MigrationCLi.ts"() {
+    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 args = argv || process.argv;
+        let startIndex = 0;
+        if ((_a = args[0]) == null ? void 0 : _a.includes("node")) {
+          startIndex = 2;
+        } else if (args[0] && /\.(js|ts|mjs|cjs)$/i.test(args[0])) {
+          startIndex = 1;
+        } else if (args[0] && ["proper", "migration", "sql-proper"].includes(args[0].toLowerCase())) {
+          startIndex = 1;
+        }
+        const cli = minimist(args.slice(startIndex), {
+          alias: {
+            c: "config"
+          }
+        });
+        const _b = cli, { _: commands } = _b, flags = __objRest(_b, ["_"]);
+        return {
+          commands,
+          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);
+  });
+}
+var init_MigrationFilter = __esm({
+  "framework/MigrationFilter.ts"() {
+  }
+});
+
+// framework/errors.ts
+var MigrationError, ConfigurationError, DatabaseConnectionError, MigrationExecutionError, CLIError;
+var init_errors = __esm({
+  "framework/errors.ts"() {
+    MigrationError = class _MigrationError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "MigrationError";
+        Object.setPrototypeOf(this, _MigrationError.prototype);
+      }
+    };
+    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}`);
+      }
+    };
+    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`);
+      }
+    };
+    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);
+      }
+    };
+    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(command) {
+        return new _CLIError(`Unknown command: ${command}. 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, SqlMigrationNode;
+var init_MigrationNode = __esm({
+  "framework/MigrationNode.ts"() {
+    init_errors();
+    MigrationNode = class {
+      constructor(name) {
+        this.name = name || "";
+      }
+    };
+    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;
+var init_SqlMigrationBuilder = __esm({
+  "framework/SqlMigrationBuilder.ts"() {
+    init_MigrationNode();
+    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
+import fs from "fs";
+import path from "path";
+var MigrationDirectoryReader;
+var init_MigrationDirectoryReader = __esm({
+  "framework/MigrationDirectoryReader.ts"() {
+    init_SqlMigrationBuilder();
+    MigrationDirectoryReader = class {
+      constructor(directory, read_strategy, sqlrunner) {
+        this.directory = directory;
+        this.read_strategy = read_strategy;
+        this.sqlrunner = sqlrunner;
+      }
+      loadMigrations(table, connection) {
+        fs.existsSync(this.directory) || fs.mkdirSync(this.directory);
+        const dir_content = fs.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: path.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 = fs.readFileSync(file).toString();
+        content = this.read_strategy(content);
+        return content.trim();
+      }
+      sql_down(file) {
+        let content = fs.readFileSync(file).toString();
+        content = this.read_strategy(content);
+        return content.trim();
+      }
+    };
+  }
+});
+
+// framework/MigrationSetup.ts
+import fs2 from "fs";
+var MigrationSetup;
+var init_MigrationSetup = __esm({
+  "framework/MigrationSetup.ts"() {
+    MigrationSetup = class {
+      constructor(sqlrunner, config) {
+        this.sqlrunner = sqlrunner;
+        this.config = config;
+      }
+      setup() {
+        return __async(this, null, function* () {
+          fs2.existsSync(this.config.migration_folder) || fs2.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;
+}
+var init_MigrationDialectParser = __esm({
+  "framework/MigrationDialectParser.ts"() {
+  }
+});
+
+// framework/SQLRunner.ts
+var BaseSQLRunner, SQLRunner, SQLiteRunner;
+var init_SQLRunner = __esm({
+  "framework/SQLRunner.ts"() {
+    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();
+        });
+      }
+    };
+    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();
+          }
+        });
+      }
+    };
+    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
+import fs3 from "fs";
+import mysql from "mysql2/promise";
+import * as sqlite from "sqlite";
+import * as sqlite3 from "sqlite3";
+function toError(error) {
+  if (error instanceof Error) return error;
+  return new Error(String(error));
+}
+var MigrationRunnerFactory, MySQLMigrationRunner, FileMigrationConfigReader, MigrationCreator;
+var init_MigrationRunner = __esm({
+  "framework/MigrationRunner.ts"() {
+    init_MigrationDirectoryReader();
+    init_MigrationSetup();
+    init_MigrationFilter();
+    init_MigrationDialectParser();
+    init_SQLRunner();
+    init_errors();
+    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 mysql.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);
+        }
+      }
+    };
+    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_file) {
+        return __async(this, null, function* () {
+          try {
+            console.log(`Checking for ${config_file}`);
+            const config_exist = fs3.existsSync(config_file);
+            if (!config_exist) {
+              console.log(`Creating ${config_file}`);
+              const default_config = {
+                "migration_folder": "migrations",
+                "migration_table": "proper_migrations",
+                "database": "sql",
+                "sql": {
+                  "host": "localhost",
+                  "user": "root",
+                  "database": "proper",
+                  "password": ""
+                }
+              };
+              fs3.writeFileSync(config_file, JSON.stringify(default_config, null, 2));
+              console.log(`Created ${config_file}`);
+            }
+          } catch (error) {
+            throw new ConfigurationError(`Failed to initialize config file: ${toError(error).message}`);
+          }
+        });
+      }
+    };
+    FileMigrationConfigReader = class {
+      constructor(configFile) {
+        this.configFile = configFile;
+      }
+      loadFile() {
+        try {
+          const fileContent = fs3.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}`);
+        }
+      }
+    };
+    MigrationCreator = class {
+      constructor(config) {
+        this.config = config;
+      }
+      create(name) {
+        if (!name) {
+          throw new CLIError("Migration name is required");
+        }
+        try {
+          if (!fs3.existsSync(this.config.migration_folder)) {
+            fs3.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`;
+          fs3.writeFileSync(`${this.config.migration_folder}/${filename_up}`, `
+-- Write your up migration here
+            `.trim());
+          fs3.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
+import "source-map-support/register";
+var require_cli = __commonJS({
+  "cli.ts"(exports) {
+    init_MigrationCLi();
+    init_MigrationFilter();
+    init_MigrationRunner();
+    init_errors();
+    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
+    `);
+    }
+  }
+});
+export default require_cli();
+//# sourceMappingURL=cli.mjs.map