@noego/proper 0.0.8 → 0.1.0

package/bin/index.d.mts

@@ -1,4 +1,5 @@
 import mysql from 'mysql2/promise';
+import * as sqlite from 'sqlite';
 
 interface MigrationConfig {
     config_file?: string;
@@ -15,6 +16,20 @@ interface MigrationConfig {
     sqlite?: {
         database: string;
     };
+    /**
+     * PostgreSQL. Either a single `connectionString` (also readable from
+     * `process.env.DATABASE_URL` when omitted) or discrete fields.
+     * `password` falls back to `process.env.PG_PASSWORD`.
+     */
+    pg?: {
+        connectionString?: string;
+        host?: string;
+        user?: string;
+        database?: string;
+        password?: string;
+        port?: number;
+        ssl?: boolean | Record<string, unknown>;
+    };
     seeds?: {
         migrationsDir?: string;
         dataDir?: string;
@@ -31,6 +46,92 @@ interface ISQLRunner {
     execute(sql: string, params?: any[]): Promise<any>;
     end(): Promise<void>;
 }
+/**
+ * Base class that implements the common contract and helper utilities that are
+ * shared between the different dialect runners. The concrete subclasses only
+ * need to implement the three primitive methods `_query`, `_execute` and
+ * `_end` that perform the actual driver-specific interaction.  Everything else
+ * – such as ensuring a uniform return shape – is handled here once.
+ */
+declare abstract class BaseSQLRunner implements ISQLRunner {
+    abstract _query(sql: string, params?: any[]): Promise<any>;
+    abstract _execute(sql: string, params?: any[]): Promise<any>;
+    abstract _end(): Promise<void>;
+    /**
+     * Ensures that both MySQL and SQLite return the same tuple shape that callers
+     * expect: `[rowsOrResult, extra]`.  For SQLite there is no `extra` metadata
+     * comparable to MySQL's `FieldPacket[]`, so we just use `undefined`.
+     */
+    query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    end(): Promise<void>;
+}
+declare class SQLRunner extends BaseSQLRunner {
+    private connection;
+    constructor(connection: mysql.Connection);
+    _query(sql: string, params?: any[]): Promise<[mysql.OkPacket | mysql.RowDataPacket[] | mysql.ResultSetHeader[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | mysql.ProcedureCallPacket, mysql.FieldPacket[]]>;
+    _execute(sql: string, params?: any[]): Promise<[mysql.OkPacket | mysql.RowDataPacket[] | mysql.ResultSetHeader[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | mysql.ProcedureCallPacket, mysql.FieldPacket[]]>;
+    _end(): Promise<void>;
+}
+declare class SQLiteRunner extends BaseSQLRunner {
+    private connection;
+    constructor(connection: sqlite.Database | any);
+    private prepareStatement;
+    private finalizeStatement;
+    private statementAll;
+    private statementRun;
+    _query(sql: string, params?: any[]): Promise<any>;
+    _execute(sql: string, params?: any[]): Promise<any>;
+    /**
+     * Checks if SQL is empty or contains only comments/whitespace.
+     * Returns true if there is no actual SQL to execute.
+     */
+    private isEmptySQL;
+    private isMultiStatement;
+    private executeMultiStatement;
+    private removeComments;
+    _end(): Promise<void>;
+}
+/**
+ * Minimal structural type for a `pg` Client or Pool (or anything shaped like
+ * one, e.g. a Hyperdrive/Neon client). We only rely on `query()` and `end()`.
+ */
+interface PgQueryable {
+    query(text: string, values?: any[]): Promise<{
+        rows: any[];
+        rowCount: number | null;
+    }>;
+    end?(): Promise<void>;
+}
+/**
+ * PostgreSQL runner.
+ *
+ * Proper's internal bookkeeping statements use MySQL-style `?` placeholders;
+ * Postgres wants `$1..$n`, so parameterised statements are rewritten here.
+ * Migration files themselves are executed verbatim with no parameters — a
+ * parameter-less `query()` goes through the simple protocol, which allows
+ * multiple `;`-separated statements in one call, so no client-side splitting
+ * (as SQLite needs) is required.
+ */
+declare class PgRunner extends BaseSQLRunner {
+    private connection;
+    constructor(connection: PgQueryable);
+    /** `?` -> `$1`, `$2`, ... outside of string literals / comments. */
+    static toPositional(sql: string): string;
+    private run;
+    _query(sql: string, params?: any[]): Promise<(any[] | {
+        rows: any[];
+        rowCount: number | null;
+    })[]>;
+    _execute(sql: string, params?: any[]): Promise<({
+        rows: any[];
+        rowCount: number | null;
+    } | {
+        changes: number;
+        lastID: undefined;
+    })[]>;
+    _end(): Promise<void>;
+}
 
 declare abstract class MigrationNode {
     name: string;
@@ -76,10 +177,11 @@ declare class MigrationDirectoryReader {
     private read_strategy;
     private sqlrunner;
     private dialect;
-    constructor(directory: string, read_strategy: any, sqlrunner: ISQLRunner, dialect?: 'sql' | 'sqlite');
+    constructor(directory: string, read_strategy: any, sqlrunner: ISQLRunner, dialect?: 'sql' | 'sqlite' | 'pg');
     /**
      * 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`.
      */
     private resolveFile;
     /**
@@ -176,4 +278,4 @@ type SeedFactory = {
 };
 declare function createSeedFactory(options: SeedFactoryOptions): SeedFactory;
 
-export { type MigrationConfig, MySQLMigrationRunner as MigrationRunner, MigrationRunnerFactory, type SeedContext, type SeedFactory, type SeedFactoryOptions, createSeedFactory, loadMigrationConfig, runSeedsWithRunner };
+export { type ISQLRunner, type MigrationConfig, MySQLMigrationRunner as MigrationRunner, MigrationRunnerFactory, type PgQueryable, PgRunner, SQLRunner, SQLiteRunner, type SeedContext, type SeedFactory, type SeedFactoryOptions, createSeedFactory, loadMigrationConfig, runSeedsWithRunner };

package/bin/index.d.ts

@@ -1,4 +1,5 @@
 import mysql from 'mysql2/promise';
+import * as sqlite from 'sqlite';
 
 interface MigrationConfig {
     config_file?: string;
@@ -15,6 +16,20 @@ interface MigrationConfig {
     sqlite?: {
         database: string;
     };
+    /**
+     * PostgreSQL. Either a single `connectionString` (also readable from
+     * `process.env.DATABASE_URL` when omitted) or discrete fields.
+     * `password` falls back to `process.env.PG_PASSWORD`.
+     */
+    pg?: {
+        connectionString?: string;
+        host?: string;
+        user?: string;
+        database?: string;
+        password?: string;
+        port?: number;
+        ssl?: boolean | Record<string, unknown>;
+    };
     seeds?: {
         migrationsDir?: string;
         dataDir?: string;
@@ -31,6 +46,92 @@ interface ISQLRunner {
     execute(sql: string, params?: any[]): Promise<any>;
     end(): Promise<void>;
 }
+/**
+ * Base class that implements the common contract and helper utilities that are
+ * shared between the different dialect runners. The concrete subclasses only
+ * need to implement the three primitive methods `_query`, `_execute` and
+ * `_end` that perform the actual driver-specific interaction.  Everything else
+ * – such as ensuring a uniform return shape – is handled here once.
+ */
+declare abstract class BaseSQLRunner implements ISQLRunner {
+    abstract _query(sql: string, params?: any[]): Promise<any>;
+    abstract _execute(sql: string, params?: any[]): Promise<any>;
+    abstract _end(): Promise<void>;
+    /**
+     * Ensures that both MySQL and SQLite return the same tuple shape that callers
+     * expect: `[rowsOrResult, extra]`.  For SQLite there is no `extra` metadata
+     * comparable to MySQL's `FieldPacket[]`, so we just use `undefined`.
+     */
+    query(sql: string, params?: any[]): Promise<any>;
+    execute(sql: string, params?: any[]): Promise<any>;
+    end(): Promise<void>;
+}
+declare class SQLRunner extends BaseSQLRunner {
+    private connection;
+    constructor(connection: mysql.Connection);
+    _query(sql: string, params?: any[]): Promise<[mysql.OkPacket | mysql.RowDataPacket[] | mysql.ResultSetHeader[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | mysql.ProcedureCallPacket, mysql.FieldPacket[]]>;
+    _execute(sql: string, params?: any[]): Promise<[mysql.OkPacket | mysql.RowDataPacket[] | mysql.ResultSetHeader[] | mysql.RowDataPacket[][] | mysql.OkPacket[] | mysql.ProcedureCallPacket, mysql.FieldPacket[]]>;
+    _end(): Promise<void>;
+}
+declare class SQLiteRunner extends BaseSQLRunner {
+    private connection;
+    constructor(connection: sqlite.Database | any);
+    private prepareStatement;
+    private finalizeStatement;
+    private statementAll;
+    private statementRun;
+    _query(sql: string, params?: any[]): Promise<any>;
+    _execute(sql: string, params?: any[]): Promise<any>;
+    /**
+     * Checks if SQL is empty or contains only comments/whitespace.
+     * Returns true if there is no actual SQL to execute.
+     */
+    private isEmptySQL;
+    private isMultiStatement;
+    private executeMultiStatement;
+    private removeComments;
+    _end(): Promise<void>;
+}
+/**
+ * Minimal structural type for a `pg` Client or Pool (or anything shaped like
+ * one, e.g. a Hyperdrive/Neon client). We only rely on `query()` and `end()`.
+ */
+interface PgQueryable {
+    query(text: string, values?: any[]): Promise<{
+        rows: any[];
+        rowCount: number | null;
+    }>;
+    end?(): Promise<void>;
+}
+/**
+ * PostgreSQL runner.
+ *
+ * Proper's internal bookkeeping statements use MySQL-style `?` placeholders;
+ * Postgres wants `$1..$n`, so parameterised statements are rewritten here.
+ * Migration files themselves are executed verbatim with no parameters — a
+ * parameter-less `query()` goes through the simple protocol, which allows
+ * multiple `;`-separated statements in one call, so no client-side splitting
+ * (as SQLite needs) is required.
+ */
+declare class PgRunner extends BaseSQLRunner {
+    private connection;
+    constructor(connection: PgQueryable);
+    /** `?` -> `$1`, `$2`, ... outside of string literals / comments. */
+    static toPositional(sql: string): string;
+    private run;
+    _query(sql: string, params?: any[]): Promise<(any[] | {
+        rows: any[];
+        rowCount: number | null;
+    })[]>;
+    _execute(sql: string, params?: any[]): Promise<({
+        rows: any[];
+        rowCount: number | null;
+    } | {
+        changes: number;
+        lastID: undefined;
+    })[]>;
+    _end(): Promise<void>;
+}
 
 declare abstract class MigrationNode {
     name: string;
@@ -76,10 +177,11 @@ declare class MigrationDirectoryReader {
     private read_strategy;
     private sqlrunner;
     private dialect;
-    constructor(directory: string, read_strategy: any, sqlrunner: ISQLRunner, dialect?: 'sql' | 'sqlite');
+    constructor(directory: string, read_strategy: any, sqlrunner: ISQLRunner, dialect?: 'sql' | 'sqlite' | 'pg');
     /**
      * 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`.
      */
     private resolveFile;
     /**
@@ -176,4 +278,4 @@ type SeedFactory = {
 };
 declare function createSeedFactory(options: SeedFactoryOptions): SeedFactory;
 
-export { type MigrationConfig, MySQLMigrationRunner as MigrationRunner, MigrationRunnerFactory, type SeedContext, type SeedFactory, type SeedFactoryOptions, createSeedFactory, loadMigrationConfig, runSeedsWithRunner };
+export { type ISQLRunner, type MigrationConfig, MySQLMigrationRunner as MigrationRunner, MigrationRunnerFactory, type PgQueryable, PgRunner, SQLRunner, SQLiteRunner, type SeedContext, type SeedFactory, type SeedFactoryOptions, createSeedFactory, loadMigrationConfig, runSeedsWithRunner };

package/bin/index.js

@@ -68,6 +68,9 @@ var index_exports = {};
 __export(index_exports, {
   MigrationRunner: () => MySQLMigrationRunner,
   MigrationRunnerFactory: () => MigrationRunnerFactory,
+  PgRunner: () => PgRunner,
+  SQLRunner: () => SQLRunner,
+  SQLiteRunner: () => SQLiteRunner,
   createSeedFactory: () => createSeedFactory,
   loadMigrationConfig: () => loadMigrationConfig,
   runSeedsWithRunner: () => runSeedsWithRunner
@@ -76,9 +79,6 @@ module.exports = __toCommonJS(index_exports);
 
 // 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"));
@@ -370,9 +370,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`);
@@ -383,14 +384,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 = {};
@@ -462,6 +463,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),
@@ -521,31 +528,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 {
@@ -761,12 +772,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);
+  }
+}
 function loadMigrationConfig(configFile) {
   const reader = new FileMigrationConfigReader(configFile);
   return reader.loadFile();
@@ -787,6 +908,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":
@@ -797,7 +919,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);
@@ -807,14 +930,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);
       }
@@ -835,16 +976,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);
@@ -856,17 +988,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);
@@ -879,6 +1001,8 @@ var MigrationRunnerFactory = class _MigrationRunnerFactory {
         return MySqlDialectParser;
       case "sqlite":
         return SqliteDialectParser;
+      case "pg":
+        return PgDialectParser;
       default:
         throw ConfigurationError.unknownDatabaseType(config.database);
     }
@@ -1065,6 +1189,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");
         }
@@ -1118,8 +1244,10 @@ var MigrationCreator = class {
 // framework/SeedRunner.ts
 var import_fs4 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
+var import_url = require("url");
 var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
+var import_api = require("tsx/esm/api");
 function resolveAlias(name, aliasMap) {
   var _a;
   if (!aliasMap) return name;
@@ -1256,6 +1384,10 @@ function runSqlSeed(runner, resolved, direction) {
 function loadSeedModule(modulePath) {
   return __async(this, null, function* () {
     const resolved = import_path2.default.resolve(modulePath);
+    if (resolved.endsWith(".ts")) {
+      const fileUrl = (0, import_url.pathToFileURL)(resolved).href;
+      return (0, import_api.tsImport)(fileUrl, fileUrl);
+    }
     return import(resolved);
   });
 }
@@ -1374,6 +1506,9 @@ function createSeedFactory(options) {
 0 && (module.exports = {
   MigrationRunner,
   MigrationRunnerFactory,
+  PgRunner,
+  SQLRunner,
+  SQLiteRunner,
   createSeedFactory,
   loadMigrationConfig,
   runSeedsWithRunner