@noego/proper 0.0.3 → 0.0.5

package/bin/index.js

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