@noego/proper 0.0.3 → 0.0.5

package/bin/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/bin/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/bin/cli.js

@@ -1,12 +1,27 @@
 #!/usr/bin/env node
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -393,26 +408,50 @@ var SqlMigrationBuilder = class {
 
 // framework/MigrationDirectoryReader.ts
 var 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 = import_path.default.join(this.directory, `${baseName}.${dialectExt}.${direction}.sql`);
+    if (import_fs.default.existsSync(dialectFile)) return dialectFile;
+    const genericFile = import_path.default.join(this.directory, `${baseName}.${direction}.sql`);
+    if (import_fs.default.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) {
     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 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();
@@ -439,12 +478,16 @@ var MigrationDirectoryReader = class {
   }
   sql_up(file) {
     let content = import_fs.default.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 = import_fs.default.readFileSync(file).toString();
-    content = this.read_strategy(content);
+    if (!this.isDialectSpecific(file)) {
+      content = this.read_strategy(content);
+    }
     return content.trim();
   }
 };
@@ -561,6 +604,9 @@ var BaseSQLRunner = class {
     });
   }
 };
+function isPromiseLike(value) {
+  return !!value && typeof value.then === "function";
+}
 var SQLRunner = class extends BaseSQLRunner {
   constructor(connection) {
     super();
@@ -590,14 +636,85 @@ var SQLiteRunner = class extends BaseSQLRunner {
     super();
     this.connection = connection;
   }
+  prepareStatement(sql) {
+    return __async(this, null, function* () {
+      if (typeof this.connection.prepare !== "function") {
+        throw new Error("SQLite connection does not support prepare()");
+      }
+      const stmt = this.connection.prepare(sql);
+      return isPromiseLike(stmt) ? yield stmt : stmt;
+    });
+  }
+  finalizeStatement(stmt) {
+    return __async(this, null, function* () {
+      if (!stmt || typeof stmt.finalize !== "function") return;
+      const result = stmt.finalize();
+      if (isPromiseLike(result)) {
+        yield result;
+      }
+    });
+  }
+  statementAll(stmt, params) {
+    return __async(this, null, function* () {
+      if (typeof stmt.all !== "function") {
+        throw new Error("SQLite statement does not support all()");
+      }
+      if (stmt.all.length >= 2) {
+        return yield new Promise((resolve, reject) => {
+          const callback = (err, rows) => {
+            if (err) return reject(err);
+            resolve(rows || []);
+          };
+          try {
+            if (params.length > 0) {
+              stmt.all(params, callback);
+            } else {
+              stmt.all(callback);
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+      const result = stmt.all(...params);
+      return isPromiseLike(result) ? yield result : result;
+    });
+  }
+  statementRun(stmt, params) {
+    return __async(this, null, function* () {
+      if (typeof stmt.run !== "function") {
+        throw new Error("SQLite statement does not support run()");
+      }
+      if (stmt.run.length >= 2) {
+        return yield new Promise((resolve, reject) => {
+          const callback = function(err) {
+            var _a;
+            if (err) return reject(err);
+            resolve({ changes: (_a = this == null ? void 0 : this.changes) != null ? _a : 0, lastID: this == null ? void 0 : this.lastID });
+          };
+          try {
+            if (params.length > 0) {
+              stmt.run(params, callback);
+            } else {
+              stmt.run(callback);
+            }
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+      const result = stmt.run(...params);
+      return isPromiseLike(result) ? yield result : result;
+    });
+  }
   _query(_0) {
     return __async(this, arguments, function* (sql, params = []) {
-      const stmt = yield this.connection.prepare(sql);
+      const stmt = yield this.prepareStatement(sql);
       try {
-        const rows = yield stmt.all(...params);
+        const rows = yield this.statementAll(stmt, params);
         return rows;
       } finally {
-        yield stmt.finalize();
+        yield this.finalizeStatement(stmt);
       }
     });
   }
@@ -611,12 +728,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);
       }
     });
   }
@@ -632,13 +749,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);
@@ -672,6 +789,9 @@ function toError(error) {
   return new Error(String(error));
 }
 var MigrationRunnerFactory = class _MigrationRunnerFactory {
+  static isSQLRunner(conn) {
+    return !!conn && typeof conn.query === "function" && typeof conn.execute === "function" && typeof conn.end === "function";
+  }
   static create(configFile, conn) {
     return __async(this, null, function* () {
       const configReader = new FileMigrationConfigReader(configFile);
@@ -727,21 +847,27 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
   create(config, conn) {
     return __async(this, null, function* () {
       let sqlrunner;
-      switch (config.database) {
-        case "sql":
-          sqlrunner = new SQLRunner(conn);
-          break;
-        case "sqlite":
-          sqlrunner = new SQLiteRunner(conn);
-          break;
-        default:
-          throw ConfigurationError.unknownDatabaseType(config.database);
+      let driverConnection = conn;
+      if (_MigrationRunnerFactory.isSQLRunner(conn)) {
+        sqlrunner = conn;
+        driverConnection = null;
+      } else {
+        switch (config.database) {
+          case "sql":
+            sqlrunner = new SQLRunner(conn);
+            break;
+          case "sqlite":
+            sqlrunner = new SQLiteRunner(conn);
+            break;
+          default:
+            throw ConfigurationError.unknownDatabaseType(config.database);
+        }
       }
       const setup = new MigrationSetup(sqlrunner, config);
       const read_strategy = this.getReadStategy(config);
-      const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner);
+      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) {
@@ -760,7 +886,7 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
       }
       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);
     });
   }
@@ -905,6 +1031,11 @@ var MySQLMigrationRunner = class {
       }
     });
   }
+  query(sql, params) {
+    return __async(this, null, function* () {
+      return yield this.sqlrunner.query(sql, params);
+    });
+  }
   init(config_file2) {
     return __async(this, null, function* () {
       try {
@@ -1001,6 +1132,224 @@ var MigrationCreator = class {
   }
 };
 
+// framework/SeedRunner.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
+function resolveAlias(name, aliasMap) {
+  var _a;
+  if (!aliasMap) return name;
+  return (_a = aliasMap[name]) != null ? _a : name;
+}
+function walkForFile(rootDir, fileName) {
+  if (!import_fs4.default.existsSync(rootDir)) return null;
+  const entries = import_fs4.default.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = import_path2.default.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      const found = walkForFile(full, fileName);
+      if (found) return found;
+    } else if (entry.isFile() && entry.name === fileName) {
+      return full;
+    }
+  }
+  return null;
+}
+function resolveMigrationsDir(migrationConfig, options) {
+  var _a;
+  const fromOptions = options.migrationsDir;
+  const fromConfig = (_a = migrationConfig.seeds) == null ? void 0 : _a.migrationsDir;
+  const dir = fromOptions != null ? fromOptions : fromConfig;
+  if (!dir) {
+    throw new Error("Seed migrationsDir not configured. Set seeds.migrationsDir in proper.json or pass it explicitly.");
+  }
+  return dir;
+}
+function mergeSeedConfig(migrationConfig, options) {
+  var _a, _b, _c, _d;
+  const names = options.names && options.names.length ? options.names : ((_a = migrationConfig.seeds) == null ? void 0 : _a.list) && migrationConfig.seeds.list.length ? migrationConfig.seeds.list : [];
+  if (!names.length) {
+    throw new Error("No seed names provided and no seeds.list defined in proper config");
+  }
+  const migrationsDir = resolveMigrationsDir(migrationConfig, options);
+  const dataDir = (_c = options.dataDir) != null ? _c : (_b = migrationConfig.seeds) == null ? void 0 : _b.dataDir;
+  const validate = options.validate !== void 0 ? options.validate : true;
+  const transactional = (_d = options.transactional) != null ? _d : "none";
+  const finalOptions = __spreadProps(__spreadValues({}, options), {
+    migrationsDir,
+    dataDir,
+    validate,
+    transactional
+  });
+  return { names, finalOptions };
+}
+function resolveSqlPair(name, migrationsDir) {
+  const up = walkForFile(migrationsDir, `${name}.up.sql`);
+  const down = walkForFile(migrationsDir, `${name}.down.sql`);
+  if (up && down) {
+    return { upPath: up, downPath: down };
+  }
+  return null;
+}
+function resolveModule(name, migrationsDir) {
+  const ts = walkForFile(migrationsDir, `${name}.ts`);
+  if (ts) return { kind: "ts", modulePath: ts };
+  const js = walkForFile(migrationsDir, `${name}.js`);
+  if (js) return { kind: "js", modulePath: js };
+  return null;
+}
+function resolveSeed(name, migrationConfig, options) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const migrationsDir = resolveMigrationsDir(migrationConfig, options);
+    const alias = resolveAlias(name, options.aliasMap);
+    const sqlPair = resolveSqlPair(name, migrationsDir);
+    if (sqlPair) {
+      return {
+        kind: "sql",
+        name,
+        alias,
+        upPath: sqlPair.upPath,
+        downPath: sqlPair.downPath,
+        dataPath: null,
+        schemaPath: null
+      };
+    }
+    const module2 = resolveModule(name, migrationsDir);
+    if (!module2) {
+      throw new Error(`Seed implementation not found for "${name}" under ${migrationsDir}`);
+    }
+    const dataDir = (_b = options.dataDir) != null ? _b : (_a = migrationConfig.seeds) == null ? void 0 : _a.dataDir;
+    let dataPath = null;
+    let schemaPath = null;
+    if (dataDir) {
+      dataPath = walkForFile(dataDir, `${alias}.json`);
+      schemaPath = walkForFile(dataDir, `${alias}.schema.json`);
+    }
+    return {
+      kind: module2.kind,
+      name,
+      alias,
+      upPath: module2.modulePath,
+      downPath: module2.modulePath,
+      dataPath,
+      schemaPath
+    };
+  });
+}
+function loadJson(filePath) {
+  return __async(this, null, function* () {
+    const content = yield import_fs4.default.promises.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  });
+}
+function createValidator() {
+  const ajv = new import_ajv.default({ allErrors: true, strict: false });
+  (0, import_ajv_formats.default)(ajv);
+  return ajv;
+}
+function validateData(schemaPath, data, validate, log) {
+  return __async(this, null, function* () {
+    if (!validate || !schemaPath) return;
+    const content = yield import_fs4.default.promises.readFile(schemaPath, "utf8");
+    const schema = JSON.parse(content);
+    const ajv = createValidator();
+    const validateFn = ajv.compile(schema);
+    const ok = validateFn(data);
+    if (!ok) {
+      log == null ? void 0 : log(`Validation failed for seed data (${schemaPath})`);
+      throw new Error(`Seed data validation failed: ${ajv.errorsText(validateFn.errors || [])}`);
+    }
+  });
+}
+function runSqlSeed(runner, resolved, direction) {
+  return __async(this, null, function* () {
+    const sqlPath = direction === "up" ? resolved.upPath : resolved.downPath;
+    const sql = yield import_fs4.default.promises.readFile(sqlPath, "utf8");
+    yield runner.query(sql);
+  });
+}
+function runModuleSeed(runner, resolved, migrationConfig, options, direction) {
+  return __async(this, null, function* () {
+    const { log } = options;
+    const module2 = yield import(import_path2.default.resolve(resolved.upPath));
+    const handler = module2[direction];
+    if (typeof handler !== "function") {
+      throw new Error(`Seed module "${resolved.name}" does not export ${direction}()`);
+    }
+    let data = null;
+    if (options.preloadedData && Object.prototype.hasOwnProperty.call(options.preloadedData, resolved.name)) {
+      data = options.preloadedData[resolved.name];
+    } else if (resolved.dataPath) {
+      data = yield loadJson(resolved.dataPath);
+    }
+    yield validateData(resolved.schemaPath, data, options.validate, log);
+    const ctx = {
+      data,
+      log,
+      dialect: migrationConfig.database || "sql"
+    };
+    yield handler(runner, ctx);
+  });
+}
+function runSingleSeed(runner, migrationConfig, name, options, direction) {
+  return __async(this, null, function* () {
+    const resolved = yield resolveSeed(name, migrationConfig, options);
+    if (resolved.kind === "sql") {
+      yield runSqlSeed(runner, resolved, direction);
+    } else {
+      yield runModuleSeed(runner, resolved, migrationConfig, options, direction);
+    }
+  });
+}
+function withTransactionalMode(runner, migrationConfig, names, options, direction) {
+  return __async(this, null, function* () {
+    const mode = options.transactional;
+    if (mode === "runner") {
+      yield runner.query("BEGIN");
+      try {
+        for (const name of names) {
+          yield runSingleSeed(runner, migrationConfig, name, options, direction);
+        }
+        yield runner.query("COMMIT");
+      } catch (err) {
+        try {
+          yield runner.query("ROLLBACK");
+        } catch (e) {
+        }
+        throw err;
+      }
+      return;
+    }
+    if (mode === "seed") {
+      for (const name of names) {
+        yield runner.query("BEGIN");
+        try {
+          yield runSingleSeed(runner, migrationConfig, name, options, direction);
+          yield runner.query("COMMIT");
+        } catch (err) {
+          try {
+            yield runner.query("ROLLBACK");
+          } catch (e) {
+          }
+          throw err;
+        }
+      }
+      return;
+    }
+    for (const name of names) {
+      yield runSingleSeed(runner, migrationConfig, name, options, direction);
+    }
+  });
+}
+function runSeedsWithRunner(runner, migrationConfig, direction, options) {
+  return __async(this, null, function* () {
+    const { names, finalOptions } = mergeSeedConfig(migrationConfig, options);
+    yield withTransactionalMode(runner, migrationConfig, names, finalOptions, direction);
+  });
+}
+
 // cli.ts
 var args = MigrationCLIFactory.setup(process.argv);
 if (!args.commands || args.commands.length === 0) {
@@ -1047,8 +1396,9 @@ pending_runner.then((runner) => __async(null, null, function* () {
         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)`);
@@ -1120,7 +1470,7 @@ pending_runner.then((runner) => __async(null, null, function* () {
           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));
@@ -1140,6 +1490,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);
     }
@@ -1171,12 +1555,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