@dogulabs/sql-migrator 1.0.2 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dogulabs/sql-migrator",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -16,7 +16,13 @@
     "url": "git+https://github.com/moons-id/ts-node-sql-migrator.git"
   },
   "keywords": [
-    "migration"
+    "migration",
+    "postgresql",
+    "postgres",
+    "sql",
+    "database",
+    "migrator",
+    "clickhouse"
   ],
   "author": "rizkynovando@gmail.com",
   "license": "GPL-3.0-or-later",
@@ -26,12 +32,15 @@
   "homepage": "https://github.com/moons-id/node-sql-migrator#readme",
   "description": "",
   "dependencies": {
+    "@clickhouse/client": "^1.17.0",
     "@types/pg": "^8.15.5",
     "dotenv": "^17.2.2",
+    "node-vault-client": "^1.0.2",
     "pg": "^8.16.3"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/node-vault-client": "^1.0.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.0"
   }

package/src/config/config.ts

@@ -0,0 +1,75 @@
+import dotenv from 'dotenv';
+import vaultClient from 'node-vault-client';
+
+dotenv.config();
+
+type EnvConfig = {
+  pg: PgConfig;
+  clickHouse: ClickHouseConfig;
+}
+
+type PgConfig = {
+  host: string;
+  port: number;
+  user: string;
+  password: string;
+  database: string;
+  queryTimeout: number;
+  connectionTimeout: number;
+}
+
+type ClickHouseConfig = {
+  port: number;
+  host: string;
+  database: string;
+  pass: string;
+  user: string;
+  ssl: boolean;
+}
+
+const pgConfig: PgConfig = {
+  host: process.env.PG_HOST || 'localhost',
+  port: Number(process.env.PG_PORT) || 5432,
+  user: process.env.PG_USER || '',
+  password: process.env.PG_PASS || '',
+  database: process.env.PG_DB || '',
+  queryTimeout: Number(process.env.PG_QUERY_TIMEOUT) || 30000,
+  connectionTimeout: Number(process.env.PG_CONNECTION_TIMEOUT) || 5000,
+}
+
+const clickHouseConfig: ClickHouseConfig = {
+  port: Number(process.env.CH_PORT) || 0,
+  host: process.env.CH_HOST || 'localhost',
+  database: process.env.CH_DB || '',
+  pass: process.env.CH_PASS || '',
+  user: process.env.CH_USER || '',
+  ssl: process.env.CH_SSL === 'true' || process.env.CH_SSL === '1',
+}
+
+export const envConfig: EnvConfig = {
+  pg: pgConfig,
+  clickHouse: clickHouseConfig,
+};
+
+
+export async function loadVaultConfig() {
+  try {
+    const vault = vaultClient.boot('main', {
+      api: {
+        url: process.env.VAULT_URL ?? '',
+        apiVersion: 'v1',
+      },
+      auth: {
+        type: 'token',
+        config: { token: process.env.VAULT_TOKEN ?? ''},
+      },
+    });
+    const kv = await vault.read(process.env.VAULT_PATH ?? '');
+
+    Object.assign(envConfig, kv.getData())
+    console.log(`Vault loaded from ${process.env.VAULT_URL}, with path ${process.env.VAULT_PATH}`);
+  } catch (e) {
+    console.log(`Vault failed to load: ${(e as Error).message}`);
+    console.log('using .env')
+  }
+}

package/src/index.ts

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
-import fs from 'fs';
-import {join} from 'path';
-import {Pool, PoolClient, PoolConfig} from "pg";
 import 'dotenv/config'
+import { pg } from "./module/pg/pg.js";
+import { ch } from "./module/ch/ch.js";
+import { loadVaultConfig } from "./config/config.js";
+
 
 function getArg(key: string, defaultValue = "") {
   const arg = process.argv.find((a) => a.startsWith(`--${key}=`));
@@ -11,208 +12,25 @@ function getArg(key: string, defaultValue = "") {
 }
 
 async function runMigrations() {
-  const action = getArg("action", "up");
-  const driver = getArg("driver", "postgres");
-  const type =  getArg("type", "migration");
-  const name =  getArg("name", "");
-
-  if (!['migration', 'seed'].includes(type)) {
-    console.log('Invalid type. Please use "migration" or "seed".');
-    process.exit(1);
-  }
-  if (action === 'new' && type === 'seed' && name === '') {
-    console.log('Invalid name. Please use "new seed" following by name.');
-    process.exit(1);
-  }
-
-  try {
-    let pg: Pool | null = null;
-    if (action !== 'new') {
-      const pgConfig: PoolConfig = {
-        host: process.env.PG_HOST,
-        port: Number(process.env.PG_PORT),
-        password: process.env.PG_PASS,
-        user: process.env.PG_USER,
-        database: process.env.PG_DB,
-      }
-
-      if (process.env.PG_CA?.length) {
-        pgConfig.ssl = { ca: process.env.PG_CA }
-      }
-
-      pg = new Pool(pgConfig)
-      await pg.query(`CREATE TABLE IF NOT EXISTS node_migrator_${type}s (
-        id BIGSERIAL PRIMARY KEY,
-        version VARCHAR(255) NOT NULL,
-        created_at TIMESTAMP NOT NULL DEFAULT NOW() 
-      )`);
-    }
-
-    // @ts-ignore
-    const scriptsDir = join(process.cwd(), 'db', driver, type === 'migration' ? 'migration' : 'seed');
-    switch (action) {
-      case 'up':
-        await migrateUp(pg, scriptsDir, type);
-        break;
-      case 'down':
-        await migrateDown(pg, scriptsDir, type);
-        break;
-      case 'reset':
-        await migrateReset(pg, scriptsDir, type);
-        break;
-      case 'new':
-        generateMigration(scriptsDir, name, type);
-        break;
-      default:
-        console.log('Invalid action. Please use "up", "down", or "reset".');
-        process.exit(1);
-    }
-  } catch (e) {
-    console.error('Migration failed: ', (e as Error).message);
-    process.exit(1);
-  } finally {
-    process.exit(0);
+  await loadVaultConfig()
+
+  const action = getArg("action", "up") ?? "up";
+  const driver = getArg("driver", "postgres") ?? "";
+  const type = getArg("type", "migration") ?? "migration";
+  const name = getArg("name", "") ?? "";
+
+  switch (driver) {
+    case "clickhouse":
+      await ch(type, action, name);
+      break;
+    case "postgres":
+      await pg(type, action, name);
+      break;
+    default:
+      await ch(type, action, name);
+      await pg(type, action, name);
+      break;
   }
 }
 
-async function migrateUp(db: Pool|null, scriptsDir: string, type: string) {
-  if (!db) throw Error('Database connection is required')
-  try {
-    console.log(`Pushing database ${type}s...`);
-    const res = await db.query(`SELECT version FROM node_migrator_${type}s`)
-    const versions = res.rows.map((row: {version: string}) => row.version)
-
-    const files = fs.readdirSync(scriptsDir)
-      .filter((file) => {
-        const isVersion =  versions.includes(file.split('_')[0])
-        return !isVersion && file.endsWith('.sql')
-      }).sort()
-
-    for (const file of files) {
-      const migrationPath = join(scriptsDir, file);
-      const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
-
-      const sqls = migrationScripts.split('-- +migrator UP')[1] || ''
-      const sql =  sqls?.split('-- +migrator DOWN')[0] || ''
-      await db.query(sql);
-
-      const version = file.split('_')[0]
-      await db.query(`INSERT INTO node_migrator_${type}s (version) VALUES ($1)`, [version])
-      console.log(`✓ Migration pushed: ${file}`);
-    }
-
-    console.log(`All ${type}s pushed successfully!`);
-  } catch (e) {
-    console.error('Migration UP failed: ', (e as Error).message);
-    process.exit(1);
-  }
-}
-
-async function migrateDown(db: Pool|null, scriptsDir: string, type: string) {
-  if (type === 'seed') {
-    throw new Error("Seeder cannot be reverted. use 'reset' instead.")
-  }
-
-  if (!db) throw Error('Database connection is required')
-  try {
-    console.log(`Rolling back database ${type}s...`);
-    const res = await db.query(`SELECT version FROM node_migrator_${type}s ORDER BY created_at DESC LIMIT 1`)
-    const version = res.rows[0].version
-
-    const file = fs.readdirSync(scriptsDir)
-      .find((file) => file.startsWith(`${version}_`) && file.endsWith('.sql'))
-
-    if (!file) throw Error(`Migration script version ${version} not found`)
-    const migrationPath = join(scriptsDir, file);
-    const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
-
-    const sqls = migrationScripts.split('-- +migrator DOWN')[1] || ''
-    const sql =  sqls?.split('-- +migrator UP')[0] || ''
-    await db.query(sql);
-
-    await db.query(`DELETE FROM node_migrator_${type}s WHERE version = $1`, [version])
-    console.log(`✓ Migration reverted: ${file}`);
-  } catch (e) {
-    console.error('Migration DOWN failed: ', (e as Error).message);
-    process.exit(1);
-  }
-}
-
-async function migrateReset(db: Pool|null, scriptsDir: string, type: string) {
-  if (!db) throw Error('Database connection is required')
-  try {
-    console.log(`Reverting database ${type}s...`);
-    if (type === 'seed') {
-      await db.query("DROP TABLE IF EXISTS node_migrator_seeds");
-      console.log("✓ Seed cleaned");
-      return;
-    }
-    const res = await db.query(`SELECT version FROM node_migrator_${type}s`)
-    const versions = res.rows.map((row: {version: string}) => row.version)
-    const scripts: string[] = []
-    const availableVersions: string[] = []
-
-    const files = fs.readdirSync(scriptsDir)
-      .filter((file) => {
-        const isVersion =  versions.includes(file.split('_')[0])
-        return isVersion && file.endsWith('.sql')
-      }).sort().reverse()
-
-    for (const file of files) {
-      if (files.includes(file)) {
-        scripts.push(file)
-        availableVersions.push(file.split('_')[0] as string)
-      }
-    }
-
-    if (scripts.length !== res.rowCount) {
-      const missingVersions = versions.filter((v: string) => !availableVersions.includes(v))
-      throw Error(`Missing version: ${missingVersions}`)
-    }
-
-    for (const file of scripts) {
-      const migrationPath = join(scriptsDir, file);
-      const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
-
-      const sqls = migrationScripts.split('-- +migrator DOWN')[1] || ''
-      const sql =  sqls?.split('-- +migrator UP')[0] || ''
-      await db.query(sql);
-
-      console.log(`✓ Migration ${file} reverted`);
-    }
-
-    await db.query(`DELETE FROM node_migrator_${type}s`)
-    await db.query("DROP TABLE IF EXISTS node_migrator_seeds");
-    console.log("Migrations rolled back");
-  } catch (e) {
-    console.error('Migration DOWN failed: ', (e as Error).message);
-    process.exit(1);
-  }
-}
-
-function generateMigration(scriptsDir: string, name: string, type: string) {
-  if (name.length < 1) throw Error("name argument required")
-  const timestamp = new Date().toISOString().replace(/\..+/, "").replace(/[^0-9]/g, "")
-  const migrationPath = join(scriptsDir, `${timestamp}_${name}.sql`);
-
-  if (!fs.existsSync(scriptsDir)) {
-    fs.mkdirSync(scriptsDir, { recursive: true });
-  }
-
-  const migrationScripts = `-- +migrator UP
--- +migrator statement BEGIN
-
--- +migrator statement END
-
-
--- +migrator DOWN
--- +migrator statement BEGIN
-
--- +migrator statement END
-`
-  fs.writeFileSync(migrationPath, migrationScripts);
-
-  console.log(`✓ ${type} created: ${timestamp}_${name}.sql`);
-}
-
 await runMigrations();

package/src/module/ch/ch.ts

@@ -0,0 +1,66 @@
+import { migrateUpCh } from "./migrate-up.ch.js";
+import { migrateDownCh } from "./migrate-down.ch.js";
+import { migrateResetCh } from "./migrate-reset.ch.js";
+import { generateMigrationCommon } from "../common/generate-migration.common.js";
+import { createClient } from "@clickhouse/client";
+import { NodeClickHouseClient } from "@clickhouse/client/dist/client.js";
+import { envConfig } from "../../config/config.js";
+import { join } from "path";
+
+
+export async function ch(type: string, action: string, name: string) {
+  if (!['migration', 'seed'].includes(type)) {
+    console.log('Invalid type. Please use "migration" or "seed".');
+    process.exit(1);
+  }
+  if (action === 'new' && type === 'seed' && name === '') {
+    console.log('Invalid name. Please use "new seed" following by name.');
+    process.exit(1);
+  }
+
+  try {
+    const client = createClient({
+      url: `${envConfig.clickHouse.ssl ? "https" : "http"}://${envConfig.clickHouse.host}:${envConfig.clickHouse.port}`,
+      username: envConfig.clickHouse.user,
+      password: envConfig.clickHouse.pass,
+      database: envConfig.clickHouse.database,
+      request_timeout: 10_000,
+    });
+    if (action !== 'new') {
+      await client.query({
+        query: `
+          CREATE TABLE IF NOT EXISTS node_migrator_${type}s (
+            id Int64 PRIMARY KEY,
+            version String NOT NULL,
+            created_at DateTime('UTC') NOT NULL DEFAULT now()
+          )`,
+        format: 'JSONEachRow',
+      });
+    }
+
+    // @ts-ignore
+    const scriptsDir = join(process.cwd(), 'db', 'clickhouse', type === 'migration' ? 'migration' : 'seed');
+    switch (action) {
+      case 'up':
+        await migrateUpCh(client, scriptsDir, type);
+        break;
+      case 'down':
+        await migrateDownCh(client, scriptsDir, type);
+        break;
+      case 'reset':
+        await migrateResetCh(client, scriptsDir, type);
+        break;
+      case 'new':
+        generateMigrationCommon(scriptsDir, name, type);
+        break;
+      default:
+        console.log('Invalid action. Please use "up", "down", or "reset".');
+        process.exit(1);
+    }
+  } catch (e) {
+    console.error('Migration failed: ', (e as Error).message);
+    process.exit(1);
+  } finally {
+    process.exit(0);
+  }
+}

package/src/module/ch/migrate-down.ch.ts

@@ -0,0 +1,44 @@
+import type { NodeClickHouseClient } from "@clickhouse/client/dist/client";
+import fs from "fs";
+import { join } from "path";
+
+
+export async function migrateDownCh(db: NodeClickHouseClient|null, scriptsDir: string, type: string) {
+  if (type === 'seed') {
+    throw new Error("Seeder cannot be reverted. use 'reset' instead.")
+  }
+
+  if (!db) throw Error('Database connection is required')
+  try {
+    console.log(`Rolling back database ${type}s...`);
+
+    const res = await db.query({
+      query: `SELECT version FROM node_migrator_${type}s`,
+      format: 'JSONEachRow',
+    });
+
+    const data = await res.json() as any;
+    const version = data[0].version;
+
+
+    const file = fs.readdirSync(scriptsDir)
+      .find((file) => file.startsWith(`${version}_`) && file.endsWith('.sql'))
+
+    if (!file) throw Error(`Migration script version ${version} not found`)
+    const migrationPath = join(scriptsDir, file);
+    const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
+
+    const sqls = migrationScripts.split('-- +migrator DOWN')[1] || ''
+    const sql =  sqls?.split('-- +migrator UP')[0] || ''
+    await db.exec({ query: sql });
+
+    await db.exec({
+      query: `DELETE FROM node_migrator_${type}s WHERE version = {val1: String}`,
+      query_params: { val1: version },
+    })
+    console.log(`✓ Migration reverted: ${file}`);
+  } catch (e) {
+    console.error('Migration DOWN failed: ', (e as Error).message);
+    process.exit(1);
+  }
+}

package/src/module/ch/migrate-reset.ch.ts

@@ -0,0 +1,63 @@
+import type { NodeClickHouseClient } from "@clickhouse/client/dist/client";
+import fs from "fs";
+import { join } from "path";
+
+
+export async function migrateResetCh(db: NodeClickHouseClient|null, scriptsDir: string, type: string) {
+  if (!db) throw Error('Database connection is required')
+  try {
+    console.log(`Reverting database ${type}s...`);
+    if (type === 'seed') {
+      await db.exec({ query: "DROP TABLE IF EXISTS node_migrator_seeds" });
+      console.log("✓ Seed cleaned");
+      return;
+    }
+
+    const res = await db.query({
+      query: `SELECT version FROM node_migrator_${type}s`,
+      format: 'JSONEachRow',
+    });
+
+    const data = await res.json() as any;
+    const versions = data.map((row: {version: string}) => row.version)
+
+    const scripts: string[] = []
+    const availableVersions: string[] = []
+
+    const files = fs.readdirSync(scriptsDir)
+      .filter((file) => {
+        const isVersion =  versions.includes(file.split('_')[0])
+        return isVersion && file.endsWith('.sql')
+      }).sort().reverse()
+
+    for (const file of files) {
+      if (files.includes(file)) {
+        scripts.push(file)
+        availableVersions.push(file.split('_')[0] as string)
+      }
+    }
+
+    if (scripts.length !== data.length) {
+      const missingVersions = versions.filter((v: string) => !availableVersions.includes(v))
+      throw Error(`Missing version: ${missingVersions}`)
+    }
+
+    for (const file of scripts) {
+      const migrationPath = join(scriptsDir, file);
+      const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
+
+      const sqls = migrationScripts.split('-- +migrator DOWN')[1] || ''
+      const sql =  sqls?.split('-- +migrator UP')[0] || ''
+      await db.exec({ query: sql });
+
+      console.log(`✓ Migration ${file} reverted`);
+    }
+
+    await db.exec({ query: `DELETE FROM node_migrator_${type}s WHERE 1=1` })
+    await db.exec({ query: "DROP TABLE IF EXISTS node_migrator_seeds" });
+    console.log("Migrations rolled back");
+  } catch (e) {
+    console.error('Migration RESET failed: ', (e as Error).message);
+    process.exit(1);
+  }
+}

package/src/module/ch/migrate-up.ch.ts

@@ -0,0 +1,45 @@
+import type { NodeClickHouseClient } from "@clickhouse/client/dist/client";
+import fs from "fs";
+import { join } from "path";
+
+
+export async function migrateUpCh(db: NodeClickHouseClient|null, scriptsDir: string, type: string) {
+  if (!db) throw Error('Database connection is required')
+  try {
+    console.log(`Pushing database ${type}s...`);
+    const res = await db.query({
+      query: `SELECT version FROM node_migrator_${type}s`,
+      format: 'JSONEachRow',
+    });
+
+    const data = await res.json() as any;
+    const versions = data.map((row: {version: string}) => row.version)
+
+    const files = fs.readdirSync(scriptsDir)
+      .filter((file) => {
+        const isVersion =  versions.includes(file.split('_')[0])
+        return !isVersion && file.endsWith('.sql')
+      }).sort()
+
+    for (const file of files) {
+      const migrationPath = join(scriptsDir, file);
+      const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
+
+      const sqls = migrationScripts.split('-- +migrator UP')[1] || ''
+      const sql =  sqls?.split('-- +migrator DOWN')[0] || ''
+      await db.exec({ query: sql });
+
+      const version = file.split('_')[0]
+      await db.exec({
+        query: `INSERT INTO node_migrator_${type}s (version) VALUES ({val: String})`,
+        query_params: { val: version },
+      })
+      console.log(`✓ Migration pushed: ${file}`);
+    }
+
+    console.log(`All ${type}s pushed successfully!`);
+  } catch (e) {
+    console.error('Migration UP failed: ', (e as Error).message);
+    process.exit(1);
+  }
+}

package/src/module/common/generate-migration.common.ts

@@ -0,0 +1,28 @@
+import { join } from "path";
+import fs from "fs";
+
+
+export function generateMigrationCommon(scriptsDir: string, name: string, type: string) {
+  if (name.length < 1) throw Error("name argument required")
+  const timestamp = new Date().toISOString().replace(/\..+/, "").replace(/[^0-9]/g, "")
+  const migrationPath = join(scriptsDir, `${timestamp}_${name}.sql`);
+
+  if (!fs.existsSync(scriptsDir)) {
+    fs.mkdirSync(scriptsDir, { recursive: true });
+  }
+
+  const migrationScripts = `-- +migrator UP
+-- +migrator statement BEGIN
+
+-- +migrator statement END
+
+
+-- +migrator DOWN
+-- +migrator statement BEGIN
+
+-- +migrator statement END
+`
+  fs.writeFileSync(migrationPath, migrationScripts);
+
+  console.log(`✓ ${type} created: ${timestamp}_${name}.sql`);
+}

package/src/module/pg/migrate-down.pg.ts

@@ -0,0 +1,34 @@
+import { Pool } from "pg";
+import fs from "fs";
+import { join } from "path";
+
+
+export async function migrateDownPg(db: Pool|null, scriptsDir: string, type: string) {
+  if (type === 'seed') {
+    throw new Error("Seeder cannot be reverted. use 'reset' instead.")
+  }
+
+  if (!db) throw Error('Database connection is required')
+  try {
+    console.log(`Rolling back database ${type}s...`);
+    const res = await db.query(`SELECT version FROM node_migrator_${type}s ORDER BY created_at DESC LIMIT 1`)
+    const version = res.rows[0].version
+
+    const file = fs.readdirSync(scriptsDir)
+      .find((file) => file.startsWith(`${version}_`) && file.endsWith('.sql'))
+
+    if (!file) throw Error(`Migration script version ${version} not found`)
+    const migrationPath = join(scriptsDir, file);
+    const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
+
+    const sqls = migrationScripts.split('-- +migrator DOWN')[1] || ''
+    const sql =  sqls?.split('-- +migrator UP')[0] || ''
+    await db.query(sql);
+
+    await db.query(`DELETE FROM node_migrator_${type}s WHERE version = $1`, [version])
+    console.log(`✓ Migration reverted: ${file}`);
+  } catch (e) {
+    console.error('Migration DOWN failed: ', (e as Error).message);
+    process.exit(1);
+  }
+}

package/src/module/pg/migrate-reset.pg.ts

@@ -0,0 +1,56 @@
+import { Pool } from "pg";
+import fs from "fs";
+import { join } from "path";
+
+
+export async function migrateResetPg(db: Pool|null, scriptsDir: string, type: string) {
+  if (!db) throw Error('Database connection is required')
+  try {
+    console.log(`Reverting database ${type}s...`);
+    if (type === 'seed') {
+      await db.query("DROP TABLE IF EXISTS node_migrator_seeds");
+      console.log("✓ Seed cleaned");
+      return;
+    }
+    const res = await db.query(`SELECT version FROM node_migrator_${type}s`)
+    const versions = res.rows.map((row: {version: string}) => row.version)
+    const scripts: string[] = []
+    const availableVersions: string[] = []
+
+    const files = fs.readdirSync(scriptsDir)
+      .filter((file) => {
+        const isVersion =  versions.includes(file.split('_')[0] ?? '')
+        return isVersion && file.endsWith('.sql')
+      }).sort().reverse()
+
+    for (const file of files) {
+      if (files.includes(file)) {
+        scripts.push(file)
+        availableVersions.push(file.split('_')[0] as string)
+      }
+    }
+
+    if (scripts.length !== res.rowCount) {
+      const missingVersions = versions.filter((v: string) => !availableVersions.includes(v))
+      throw Error(`Missing version: ${missingVersions}`)
+    }
+
+    for (const file of scripts) {
+      const migrationPath = join(scriptsDir, file);
+      const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
+
+      const sqls = migrationScripts.split('-- +migrator DOWN')[1] || ''
+      const sql =  sqls?.split('-- +migrator UP')[0] || ''
+      await db.query(sql);
+
+      console.log(`✓ Migration ${file} reverted`);
+    }
+
+    await db.query(`DELETE FROM node_migrator_${type}s`)
+    await db.query("DROP TABLE IF EXISTS node_migrator_seeds");
+    console.log("Migrations rolled back");
+  } catch (e) {
+    console.error('Migration RESET failed: ', (e as Error).message);
+    process.exit(1);
+  }
+}

package/src/module/pg/migrate-up.pg.ts

@@ -0,0 +1,37 @@
+import { Pool } from "pg";
+import fs from "fs";
+import { join } from "path";
+
+
+export async function migrateUpPg(db: Pool|null, scriptsDir: string, type: string) {
+  if (!db) throw Error('Database connection is required')
+  try {
+    console.log(`Pushing database ${type}s...`);
+    const res = await db.query(`SELECT version FROM node_migrator_${type}s`)
+    const versions = res.rows.map((row: {version: string}) => row.version)
+
+    const files = fs.readdirSync(scriptsDir)
+      .filter((file) => {
+        const isVersion =  versions.includes(file.split('_')[0] ?? '')
+        return !isVersion && file.endsWith('.sql')
+      }).sort()
+
+    for (const file of files) {
+      const migrationPath = join(scriptsDir, file);
+      const migrationScripts = fs.readFileSync(migrationPath, 'utf8');
+
+      const sqls = migrationScripts.split('-- +migrator UP')[1] || ''
+      const sql =  sqls?.split('-- +migrator DOWN')[0] || ''
+      await db.query(sql);
+
+      const version = file.split('_')[0]
+      await db.query(`INSERT INTO node_migrator_${type}s (version) VALUES ($1)`, [version])
+      console.log(`✓ Migration pushed: ${file}`);
+    }
+
+    console.log(`All ${type}s pushed successfully!`);
+  } catch (e) {
+    console.error('Migration UP failed: ', (e as Error).message);
+    process.exit(1);
+  }
+}

package/src/module/pg/pg.ts

@@ -0,0 +1,69 @@
+import type { PoolConfig } from "pg";
+import { Pool } from "pg";
+import { migrateUpPg } from "./migrate-up.pg.js";
+import { migrateDownPg } from "./migrate-down.pg.js";
+import { migrateResetPg } from "./migrate-reset.pg.js";
+import { generateMigrationCommon } from "../common/generate-migration.common.js";
+import { envConfig } from "../../config/config.js";
+import { join } from "path";
+
+
+export async function pg(type: string, action: string, name: string) {
+  if (!['migration', 'seed'].includes(type)) {
+    console.log('Invalid type. Please use "migration" or "seed".');
+    process.exit(1);
+  }
+  if (action === 'new' && type === 'seed' && name === '') {
+    console.log('Invalid name. Please use "new seed" following by name.');
+    process.exit(1);
+  }
+
+  try {
+    let pg: Pool | null = null;
+    if (action !== 'new') {
+      const pgConfig: PoolConfig = {
+        host: envConfig.pg.host,
+        port: envConfig.pg.port,
+        password: envConfig.pg.password,
+        user: envConfig.pg.user,
+        database: envConfig.pg.database,
+      }
+
+      if (process.env.PG_CA?.length) {
+        pgConfig.ssl = { ca: process.env.PG_CA }
+      }
+
+      pg = new Pool(pgConfig)
+      await pg.query(`CREATE TABLE IF NOT EXISTS node_migrator_${type}s (
+        id BIGSERIAL PRIMARY KEY,
+        version VARCHAR(255) NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT NOW() 
+      )`);
+    }
+
+    // @ts-ignore
+    const scriptsDir = join(process.cwd(), 'db', 'postgres', type === 'migration' ? 'migration' : 'seed');
+    switch (action) {
+      case 'up':
+        await migrateUpPg(pg, scriptsDir, type);
+        break;
+      case 'down':
+        await migrateDownPg(pg, scriptsDir, type);
+        break;
+      case 'reset':
+        await migrateResetPg(pg, scriptsDir, type);
+        break;
+      case 'new':
+        generateMigrationCommon(scriptsDir, name, type);
+        break;
+      default:
+        console.log('Invalid action. Please use "up", "down", or "reset".');
+        process.exit(1);
+    }
+  } catch (e) {
+    console.error('Migration failed: ', (e as Error).message);
+    process.exit(1);
+  } finally {
+    process.exit(0);
+  }
+}

package/tsconfig.json

@@ -1,15 +1,46 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "outDir": "dist",
-    "rootDir": "src",
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "forceConsistentCasingInFileNames": true,
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "target": "esnext",
+    "types": ["node"],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
     "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
     "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true
   },
   "include": ["src"],
   "exclude": ["node_modules", "dist"]