@noego/proper 0.0.3 → 0.0.5

package/bin/cli.mjs

@@ -1,8 +1,24 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 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 __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) {
@@ -404,26 +420,50 @@ var init_MigrationDirectoryReader = __esm({
   "framework/MigrationDirectoryReader.ts"() {
     init_SqlMigrationBuilder();
     MigrationDirectoryReader = class {
-      constructor(directory, read_strategy, sqlrunner) {
+      constructor(directory, read_strategy, sqlrunner, dialect = "sql") {
         this.directory = directory;
         this.read_strategy = read_strategy;
         this.sqlrunner = sqlrunner;
+        this.dialect = dialect;
+      }
+      /**
+       * Resolves the appropriate file for a migration based on dialect.
+       * Priority: dialect-specific file > generic file
+       */
+      resolveFile(baseName, direction) {
+        const dialectExt = this.dialect === "sql" ? "mysql" : "sqlite";
+        const dialectFile = path.join(this.directory, `${baseName}.${dialectExt}.${direction}.sql`);
+        if (fs.existsSync(dialectFile)) return dialectFile;
+        const genericFile = path.join(this.directory, `${baseName}.${direction}.sql`);
+        if (fs.existsSync(genericFile)) return genericFile;
+        return null;
+      }
+      /**
+       * Checks if a file path is dialect-specific (contains .mysql. or .sqlite. in the name)
+       */
+      isDialectSpecific(filePath) {
+        return /\.(mysql|sqlite)\.(up|down)\.sql$/i.test(filePath);
       }
       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 uniqueKeys = /* @__PURE__ */ new Set();
+        dir_content.forEach((file) => {
+          const key = file.replace(/(?:\.(mysql|sqlite))?\.(up|down)\.(sql|js)/i, "").toLowerCase();
+          uniqueKeys.add(key);
+        });
         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);
+        uniqueKeys.forEach((migration_key) => {
+          const builder = new SqlMigrationBuilder(migration_key);
+          const upFile = this.resolveFile(migration_key, "up");
+          const downFile = this.resolveFile(migration_key, "down");
+          if (upFile) {
+            this.loadMigration(builder, upFile);
+          }
+          if (downFile) {
+            this.loadMigration(builder, downFile);
+          }
+          migration_sorter[migration_key] = builder;
         });
         const keys = Object.keys(migration_sorter);
         keys.sort();
@@ -450,12 +490,16 @@ var init_MigrationDirectoryReader = __esm({
       }
       sql_up(file) {
         let content = fs.readFileSync(file).toString();
-        content = this.read_strategy(content);
+        if (!this.isDialectSpecific(file)) {
+          content = this.read_strategy(content);
+        }
         return content.trim();
       }
       sql_down(file) {
         let content = fs.readFileSync(file).toString();
-        content = this.read_strategy(content);
+        if (!this.isDialectSpecific(file)) {
+          content = this.read_strategy(content);
+        }
         return content.trim();
       }
     };
@@ -559,6 +603,9 @@ var init_MigrationDialectParser = __esm({
 });
 
 // framework/SQLRunner.ts
+function isPromiseLike(value) {
+  return !!value && typeof value.then === "function";
+}
 var BaseSQLRunner, SQLRunner, SQLiteRunner;
 var init_SQLRunner = __esm({
   "framework/SQLRunner.ts"() {
@@ -615,14 +662,85 @@ var init_SQLRunner = __esm({
         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);
           }
         });
       }
@@ -636,12 +754,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);
           }
         });
       }
@@ -657,13 +775,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);
@@ -712,6 +830,9 @@ var init_MigrationRunner = __esm({
     init_SQLRunner();
     init_errors();
     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);
@@ -767,21 +888,27 @@ var init_MigrationRunner = __esm({
       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);
+          const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner, config.database);
           yield setup.setup();
-          return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, conn);
+          return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, driverConnection);
         });
       }
       createEmpty(config) {
@@ -800,7 +927,7 @@ var init_MigrationRunner = __esm({
           }
           const setup = new MigrationSetup(sqlrunner, config);
           const read_strategy = this.getReadStategy(config);
-          const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner);
+          const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner, config.database);
           return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, conn);
         });
       }
@@ -945,6 +1072,11 @@ var init_MigrationRunner = __esm({
           }
         });
       }
+      query(sql, params) {
+        return __async(this, null, function* () {
+          return yield this.sqlrunner.query(sql, params);
+        });
+      }
       init(config_file) {
         return __async(this, null, function* () {
           try {
@@ -1043,6 +1175,229 @@ var init_MigrationRunner = __esm({
   }
 });
 
+// framework/SeedRunner.ts
+import fs4 from "fs";
+import path2 from "path";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+function resolveAlias(name, aliasMap) {
+  var _a;
+  if (!aliasMap) return name;
+  return (_a = aliasMap[name]) != null ? _a : name;
+}
+function walkForFile(rootDir, fileName) {
+  if (!fs4.existsSync(rootDir)) return null;
+  const entries = fs4.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path2.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 module = resolveModule(name, migrationsDir);
+    if (!module) {
+      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: module.kind,
+      name,
+      alias,
+      upPath: module.modulePath,
+      downPath: module.modulePath,
+      dataPath,
+      schemaPath
+    };
+  });
+}
+function loadJson(filePath) {
+  return __async(this, null, function* () {
+    const content = yield fs4.promises.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  });
+}
+function createValidator() {
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  addFormats(ajv);
+  return ajv;
+}
+function validateData(schemaPath, data, validate, log) {
+  return __async(this, null, function* () {
+    if (!validate || !schemaPath) return;
+    const content = yield fs4.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 fs4.promises.readFile(sqlPath, "utf8");
+    yield runner.query(sql);
+  });
+}
+function runModuleSeed(runner, resolved, migrationConfig, options, direction) {
+  return __async(this, null, function* () {
+    const { log } = options;
+    const module = yield import(path2.resolve(resolved.upPath));
+    const handler = module[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);
+  });
+}
+var init_SeedRunner = __esm({
+  "framework/SeedRunner.ts"() {
+    init_MigrationRunner();
+  }
+});
+
 // cli.ts
 import "source-map-support/register";
 var require_cli = __commonJS({
@@ -1051,6 +1406,7 @@ var require_cli = __commonJS({
     init_MigrationFilter();
     init_MigrationRunner();
     init_errors();
+    init_SeedRunner();
     var args = MigrationCLIFactory.setup(process.argv);
     if (!args.commands || args.commands.length === 0) {
       console.error("Error: No command specified");
@@ -1096,8 +1452,9 @@ var require_cli = __commonJS({
             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);
+            if (args.flags.all) {
+            } else {
+              const increment = parseInt(args.flags.increment || "1");
               downgraded = downgraded.slice(0, increment);
             }
             console.log(`Rolling back ${downgraded.length} migration(s)`);
@@ -1169,7 +1526,7 @@ var require_cli = __commonJS({
               throw new CLIError("Invalid format. Use --format table or --format json");
             }
             try {
-              const [results] = yield runner.sqlrunner.query(sql_query);
+              const [results] = yield runner.query(sql_query);
               if (Array.isArray(results) && results.length > 0) {
                 if (format === "json") {
                   console.log(JSON.stringify(results, null, 2));
@@ -1189,6 +1546,40 @@ Returned ${results.length} row(s)`);
             }
             yield runner.close();
             break;
+          case "seed": {
+            const subCommands = commands.slice(1);
+            const actionFlag = (args.flags.action || "").toString().toLowerCase();
+            const firstSub = (subCommands[0] || "").toString().toLowerCase();
+            const action = actionFlag === "down" || firstSub === "down" ? "down" : "up";
+            const positionalNames = actionFlag ? subCommands : firstSub === "up" || firstSub === "down" ? subCommands.slice(1) : subCommands;
+            const aliasFlag = args.flags.alias;
+            const aliasMap = {};
+            if (aliasFlag) {
+              const aliases = Array.isArray(aliasFlag) ? aliasFlag : [aliasFlag];
+              for (const entry of aliases) {
+                const eq = entry.indexOf("=");
+                if (eq > 0) {
+                  const key = entry.slice(0, eq);
+                  const value = entry.slice(eq + 1);
+                  if (key) aliasMap[key] = value;
+                }
+              }
+            }
+            const seedOptions = {
+              migrationsDir: args.flags.migrationsDir || args.flags["migrations-dir"],
+              dataDir: args.flags.dataDir || args.flags["data-dir"],
+              validate: args.flags.validate === void 0 ? true : String(args.flags.validate).toLowerCase() !== "false",
+              transactional: args.flags.transactional,
+              aliasMap: Object.keys(aliasMap).length ? aliasMap : void 0,
+              names: positionalNames.length ? positionalNames : void 0,
+              log: (msg) => console.log(msg)
+            };
+            const reader = new FileMigrationConfigReader(config_file);
+            const migrationConfig = reader.loadFile();
+            yield runSeedsWithRunner(runner, migrationConfig, action, seedOptions);
+            yield runner.close();
+            break;
+          }
           default:
             throw CLIError.unknownCommand(command);
         }
@@ -1220,12 +1611,15 @@ Commands:
 Options:
   -c, --config      Specify the config file (default: proper.json)
   --increment <n>   Limit the number of migrations to apply or roll back
+  --all             Roll back all completed migrations (down command only)
   --format <fmt>    Output format for query command: 'table' (default) or 'json'
 
 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 down                                  Roll back the last applied migration (default: 1)
+  proper down --increment 3                    Roll back the last 3 applied migrations
+  proper down --all                            Roll back all completed migrations
   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