@noego/proper 0.0.9 → 0.1.0

package/bin/cli.js

@@ -124,9 +124,6 @@ function migration_filter(_0) {
 
 // framework/MigrationRunner.ts
 var import_fs3 = __toESM(require("fs"));
-var import_promise = __toESM(require("mysql2/promise"));
-var sqlite = __toESM(require("sqlite"));
-var sqlite3 = __toESM(require("sqlite3"));
 
 // framework/MigrationDirectoryReader.ts
 var import_fs = __toESM(require("fs"));
@@ -418,9 +415,10 @@ var MigrationDirectoryReader = class {
   /**
    * Resolves the appropriate file for a migration based on dialect.
    * Priority: dialect-specific file > generic file
+   * File extensions: `.mysql.up.sql`, `.sqlite.up.sql`, `.pg.up.sql`.
    */
   resolveFile(baseName, direction) {
-    const dialectExt = this.dialect === "sql" ? "mysql" : "sqlite";
+    const dialectExt = this.dialect === "sql" ? "mysql" : this.dialect;
     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`);
@@ -431,14 +429,14 @@ var MigrationDirectoryReader = class {
    * 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);
+    return /\.(mysql|sqlite|pg)\.(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);
     const uniqueKeys = /* @__PURE__ */ new Set();
     dir_content.forEach((file) => {
-      const key = file.replace(/(?:\.(mysql|sqlite))?\.(up|down)\.(sql|js)/i, "").toLowerCase();
+      const key = file.replace(/(?:\.(mysql|sqlite|pg))?\.(up|down)\.(sql|js)/i, "").toLowerCase();
       uniqueKeys.add(key);
     });
     const migration_sorter = {};
@@ -510,6 +508,12 @@ var MigrationSetup = class {
                 up TEXT,
                 down TEXT,
                 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )` : this.config.database === "pg" ? `CREATE TABLE IF NOT EXISTS ${tableName} (
+                id SERIAL PRIMARY KEY,
+                migration_key TEXT,
+                up TEXT,
+                down TEXT,
+                created_at TIMESTAMPTZ DEFAULT now()
             )` : `CREATE TABLE IF NOT EXISTS ${tableName} (
                 id INT AUTO_INCREMENT PRIMARY KEY,
                 migration_key VARCHAR(255),
@@ -554,31 +558,35 @@ function MySqlDialectParser(sql) {
   }
   return result;
 }
-function SqliteDialectParser(sql) {
-  const lines = sql.split("\n");
-  let result = "";
-  let isInSqliteBlock = true;
-  const startSqliteRegex = /^\s*--\s*\[\s*sqlite\s*\]\s*$/i;
+function markerDialectParser(names) {
+  const startRegex = new RegExp(`^\\s*--\\s*\\[\\s*(${names.join("|")})\\s*\\]\\s*$`, "i");
   const anyDialectRegex = /^\s*--\s*\[\s*\w+\s*\]\s*$/i;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (startSqliteRegex.test(trimmed)) {
-      isInSqliteBlock = true;
-      result += line + "\n";
-      continue;
-    } else if (anyDialectRegex.test(trimmed) && !startSqliteRegex.test(trimmed)) {
-      isInSqliteBlock = false;
-      continue;
-    }
-    if (!isInSqliteBlock && line.toLowerCase().includes("create index")) {
-      isInSqliteBlock = true;
-    }
-    if (isInSqliteBlock) {
-      result += line + "\n";
+  return function(sql) {
+    const lines = sql.split("\n");
+    let result = "";
+    let capturing = true;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (startRegex.test(trimmed)) {
+        capturing = true;
+        result += line + "\n";
+        continue;
+      } else if (anyDialectRegex.test(trimmed)) {
+        capturing = false;
+        continue;
+      }
+      if (!capturing && line.toLowerCase().includes("create index")) {
+        capturing = true;
+      }
+      if (capturing) {
+        result += line + "\n";
+      }
     }
-  }
-  return result;
+    return result;
+  };
 }
+var SqliteDialectParser = markerDialectParser(["sqlite"]);
+var PgDialectParser = markerDialectParser(["pg", "postgres", "postgresql"]);
 
 // framework/SQLRunner.ts
 var BaseSQLRunner = class {
@@ -794,12 +802,122 @@ ${sql}
     });
   }
 };
+var PgRunner = class _PgRunner extends BaseSQLRunner {
+  constructor(connection) {
+    super();
+    this.connection = connection;
+  }
+  /** `?` -> `$1`, `$2`, ... outside of string literals / comments. */
+  static toPositional(sql) {
+    let out = "";
+    let n = 0;
+    let inSingle = false;
+    let inDouble = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < sql.length; i++) {
+      const ch = sql[i];
+      const next = sql[i + 1];
+      if (inLineComment) {
+        out += ch;
+        if (ch === "\n") inLineComment = false;
+        continue;
+      }
+      if (inBlockComment) {
+        out += ch;
+        if (ch === "*" && next === "/") {
+          out += next;
+          i++;
+          inBlockComment = false;
+        }
+        continue;
+      }
+      if (inSingle) {
+        out += ch;
+        if (ch === "'") inSingle = false;
+        continue;
+      }
+      if (inDouble) {
+        out += ch;
+        if (ch === '"') inDouble = false;
+        continue;
+      }
+      if (ch === "-" && next === "-") {
+        out += ch;
+        inLineComment = true;
+        continue;
+      }
+      if (ch === "/" && next === "*") {
+        out += ch + next;
+        i++;
+        inBlockComment = true;
+        continue;
+      }
+      if (ch === "'") {
+        out += ch;
+        inSingle = true;
+        continue;
+      }
+      if (ch === '"') {
+        out += ch;
+        inDouble = true;
+        continue;
+      }
+      if (ch === "?") {
+        out += `$${++n}`;
+        continue;
+      }
+      out += ch;
+    }
+    return out;
+  }
+  run(sql, params) {
+    return __async(this, null, function* () {
+      if (params.length > 0) {
+        return yield this.connection.query(_PgRunner.toPositional(sql), params);
+      }
+      return yield this.connection.query(sql);
+    });
+  }
+  _query(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      const result = yield this.run(sql, params);
+      return [result.rows, result];
+    });
+  }
+  _execute(_0) {
+    return __async(this, arguments, function* (sql, params = []) {
+      var _a;
+      const result = yield this.run(sql, params);
+      return [{ changes: (_a = result.rowCount) != null ? _a : 0, lastID: void 0 }, result];
+    });
+  }
+  _end() {
+    return __async(this, null, function* () {
+      if (this.connection && typeof this.connection.end === "function") {
+        yield this.connection.end();
+      }
+    });
+  }
+};
 
 // framework/MigrationRunner.ts
 function toError(error) {
   if (error instanceof Error) return error;
   return new Error(String(error));
 }
+function makeRunner(database, conn) {
+  switch (database) {
+    case "sql":
+      return new SQLRunner(conn);
+    case "sqlite":
+      return new SQLiteRunner(conn);
+    case "pg":
+      return new PgRunner(conn);
+    default:
+      throw ConfigurationError.unknownDatabaseType(database);
+  }
+}
 var MigrationRunnerFactory = class _MigrationRunnerFactory {
   static isSQLRunner(conn) {
     return !!conn && typeof conn.query === "function" && typeof conn.execute === "function" && typeof conn.end === "function";
@@ -816,6 +934,7 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
   }
   static createConnection(config) {
     return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
       let conn = null;
       switch (config.database) {
         case "sql":
@@ -826,7 +945,8 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
             password: process.env.SQL_PASSWORD
           }, config.sql);
           try {
-            conn = yield import_promise.default.createConnection(settings);
+            const mysql = yield import("mysql2/promise");
+            conn = yield ((_b = (_a = mysql.default) == null ? void 0 : _a.createConnection) != null ? _b : mysql.createConnection)(settings);
             return conn;
           } catch (error) {
             throw DatabaseConnectionError.connectionFailed("sql", toError(error).message);
@@ -836,14 +956,32 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
             throw ConfigurationError.missingDatabaseConfiguration("sqlite");
           }
           try {
-            conn = yield sqlite.open({
+            const sqlite = yield import("sqlite");
+            const sqlite3 = yield import("sqlite3");
+            conn = yield ((_d = (_c = sqlite.default) == null ? void 0 : _c.open) != null ? _d : sqlite.open)({
               filename: config.sqlite.database,
-              driver: sqlite3.Database
+              driver: (_f = (_e = sqlite3.default) == null ? void 0 : _e.Database) != null ? _f : sqlite3.Database
             });
             return conn;
           } catch (error) {
             throw DatabaseConnectionError.connectionFailed("sqlite", toError(error).message);
           }
+        case "pg":
+          if (!config.pg && !process.env.DATABASE_URL) {
+            throw ConfigurationError.missingDatabaseConfiguration("pg");
+          }
+          try {
+            const pgcfg = (_g = config.pg) != null ? _g : {};
+            const connectionString = (_h = pgcfg.connectionString) != null ? _h : process.env.DATABASE_URL;
+            const settings2 = connectionString ? { connectionString, ssl: pgcfg.ssl } : __spreadProps(__spreadValues({}, pgcfg), { password: (_i = pgcfg.password) != null ? _i : process.env.PG_PASSWORD });
+            const pg = yield import("pg");
+            const Client = (_k = (_j = pg.default) == null ? void 0 : _j.Client) != null ? _k : pg.Client;
+            conn = new Client(settings2);
+            yield conn.connect();
+            return conn;
+          } catch (error) {
+            throw DatabaseConnectionError.connectionFailed("pg", toError(error).message);
+          }
         default:
           throw ConfigurationError.unknownDatabaseType(config.database);
       }
@@ -864,16 +1002,7 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
         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);
-        }
+        sqlrunner = makeRunner(config.database, conn);
       }
       const setup = new MigrationSetup(sqlrunner, config);
       const read_strategy = this.getReadStategy(config);
@@ -885,17 +1014,7 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
   createEmpty(config) {
     return __async(this, null, function* () {
       const conn = null;
-      let sqlrunner;
-      switch (config.database) {
-        case "sql":
-          sqlrunner = new SQLRunner(conn);
-          break;
-        case "sqlite":
-          sqlrunner = new SQLiteRunner(conn);
-          break;
-        default:
-          throw ConfigurationError.unknownDatabaseType(config.database);
-      }
+      const sqlrunner = makeRunner(config.database, conn);
       const setup = new MigrationSetup(sqlrunner, config);
       const read_strategy = this.getReadStategy(config);
       const migration_files = new MigrationDirectoryReader(config.migration_folder, read_strategy, sqlrunner, config.database);
@@ -908,6 +1027,8 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
         return MySqlDialectParser;
       case "sqlite":
         return SqliteDialectParser;
+      case "pg":
+        return PgDialectParser;
       default:
         throw ConfigurationError.unknownDatabaseType(config.database);
     }
@@ -1094,6 +1215,8 @@ var FileMigrationConfigReader = class {
           config.database = "sql";
         } else if (config.sqlite) {
           config.database = "sqlite";
+        } else if (config.pg) {
+          config.database = "pg";
         } else {
           throw ConfigurationError.missingRequiredProperty("database");
         }
@@ -1376,6 +1499,10 @@ function runSeedsWithRunner(runner, migrationConfig, direction, options) {
 
 // cli.ts
 var args = MigrationCLIFactory.setup(process.argv);
+if (args.flags.help) {
+  printUsage();
+  process.exit(0);
+}
 if (!args.commands || args.commands.length === 0) {
   console.error("Error: No command specified");
   printUsage();