@noego/proper 0.0.2 → 0.0.4

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)
@@ -561,6 +576,9 @@ var BaseSQLRunner = class {
     });
   }
 };
+function isPromiseLike(value) {
+  return !!value && typeof value.then === "function";
+}
 var SQLRunner = class extends BaseSQLRunner {
   constructor(connection) {
     super();
@@ -590,14 +608,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 +700,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 +721,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 +761,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 +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);
       yield setup.setup();
-      return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, conn);
+      return new MySQLMigrationRunner(config, migration_files, setup, sqlrunner, driverConnection);
     });
   }
   createEmpty(config) {
@@ -905,6 +1003,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 +1104,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 +1368,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)`);
@@ -1096,6 +1418,84 @@ pending_runner.then((runner) => __async(null, null, function* () {
         printTable(yield Promise.all(table));
         runner.close();
         break;
+      case "query":
+        const sql_query = args.flags.query || commands[1];
+        const format = (args.flags.format || "table").toLowerCase();
+        if (!sql_query) {
+          throw new CLIError('SQL query is required. Usage: proper query "SELECT * FROM table"');
+        }
+        const trimmed_query = sql_query.trim().toUpperCase();
+        const is_select = trimmed_query.startsWith("SELECT");
+        const is_cte = trimmed_query.startsWith("WITH");
+        if (!is_select && !is_cte) {
+          throw new CLIError("Only SELECT queries and CTEs (WITH clauses) are allowed");
+        }
+        const dangerous_keywords = ["INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER", "TRUNCATE", "GRANT", "REVOKE"];
+        const has_dangerous_keyword = dangerous_keywords.some((keyword) => {
+          const regex = new RegExp(`\\b${keyword}\\b`, "i");
+          return regex.test(sql_query);
+        });
+        if (has_dangerous_keyword) {
+          throw new CLIError("Query contains disallowed keywords. Only SELECT and CTE queries are permitted");
+        }
+        if (!["table", "json"].includes(format)) {
+          throw new CLIError("Invalid format. Use --format table or --format json");
+        }
+        try {
+          const [results] = yield runner.query(sql_query);
+          if (Array.isArray(results) && results.length > 0) {
+            if (format === "json") {
+              console.log(JSON.stringify(results, null, 2));
+            } else {
+              const { printTable: printTable2 } = require("console-table-printer");
+              printTable2(results);
+            }
+            console.log(`
+Returned ${results.length} row(s)`);
+          } else if (Array.isArray(results) && results.length === 0) {
+            console.log("Query returned 0 rows");
+          } else {
+            console.log("Query executed successfully");
+          }
+        } catch (error) {
+          throw new CLIError(`Query execution failed: ${error.message}`);
+        }
+        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);
     }
@@ -1111,7 +1511,7 @@ function printUsage() {
   console.log(`
 SQL Proper - Database migration tool
 
-Usage: 
+Usage:
   proper <command> [options]
 
 Commands:
@@ -1121,20 +1521,27 @@ Commands:
   create   Create a new migration
   init     Initialize a new config file
   status   Show migration status
+  query    Execute a SQL query and display results
   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
+  --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 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
+  proper up                                    Apply all pending migrations
+  proper up --increment 1                      Apply only the next pending 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
+  proper query "select * from users"           Execute a SQL query
+  proper query "select * from users" --format json   Execute a query and output as JSON
+  proper -c custom.json up                     Use a custom config file
     `);
 }
 //# sourceMappingURL=cli.js.map