@skalfa/skalfa-api-core 1.0.2

package/src/commands/runner/da-migration.ts

@@ -0,0 +1,333 @@
+import fs from "fs";
+import path from "path";
+import { Command } from "commander";
+import { logger } from "@utils";
+// @ts-ignore
+import * as utils from "@utils";
+
+const da = (utils as any).da;
+const daClient = (utils as any).daClient;
+
+const DW_MIGRATIONS_DIR = path.resolve("./src/database/da.migrations");
+
+const MIGRATION_TABLE = `${process.env.DA_DATABASE || "default"}.migrations`;
+
+// ================================
+// ## Create Migration Table
+// ================================
+async function ensureMigrationTable() {
+  if (!da) {
+    logger.error("ClickHouse connection (da) is not available. Ensure @skalfa/da is installed.");
+    process.exit(1);
+  }
+  await da.exec(`
+    CREATE TABLE IF NOT EXISTS ${MIGRATION_TABLE} (
+      name String,
+      executed_at DateTime DEFAULT now()
+    )
+    ENGINE = MergeTree()
+    ORDER BY (name)
+  `);
+}
+
+// ================================
+// ## Ensure OLAP Database Exists
+// ================================
+async function ensureDatabaseExists() {
+  // @ts-ignore
+  const { createClient } = await import("@clickhouse/client");
+  let dac = createClient({
+    url: "http://" + (process.env.DA_HOST || '127.0.0.1') + ':' + (process.env.DA_PORT || '8123'),
+    username: process.env.DA_USERNAME || 'default',
+    password: process.env.DA_PASSWORD || '',
+  });
+
+  logger.info(`Database ${process.env.DA_DATABASE || "default"} not found. Create new database...`);
+  await dac.query({ query: `CREATE DATABASE IF NOT EXISTS ${process.env.DA_DATABASE || "default"}` });
+  logger.info(`Database ${process.env.DA_DATABASE || "default"} successfully created.`);
+}
+
+// ================================
+// ## GET LIST OF APPLIED MIGRATIONS
+// ================================
+async function getMigratedNames(): Promise<string[]> {
+  try {
+    const rows = (await da.from("migrations").select("name").get()) as any[];
+    return rows.map((r: any) => r.name);
+  } catch {
+    return [];
+  }
+}
+
+// ================================
+// ## SAVE MIGRATION RECORD
+// ================================
+async function recordMigration(name: string) {
+  await daClient.insert({ table: "migrations", values: [{ name }], format: "JSONEachRow" });
+}
+
+// ================================
+// ## RUN ALL MIGRATIONS
+// ================================
+export const daMigrateCommand = new Command("da:migrate")
+  .description("Run all OLAP (ClickHouse) migrations")
+  .action(async () => {
+    logger.info("Preparing run migration...");
+
+    await ensureDatabaseExists();
+    await ensureMigrationTable();
+
+    const applied = await getMigratedNames();
+
+    if (!fs.existsSync(DW_MIGRATIONS_DIR)) {
+      logger.info("No OLAP migrations directory found.");
+      process.exit(0);
+    }
+    const files = getMigrationFiles(DW_MIGRATIONS_DIR).sort((a, b) => a.localeCompare(b));
+
+    let count = 0;
+
+    for (const file of files) {
+      if (applied.includes(file)) continue;
+      const relative = path.relative(DW_MIGRATIONS_DIR, file);
+
+      if (applied.includes(relative)) continue;
+
+      const filePath = file;
+      const migrationPath = path.relative(DW_MIGRATIONS_DIR, filePath);
+
+      if (applied.includes(migrationPath)) continue;
+
+      const mod = await import(filePath);
+
+      if (!mod.default) continue;
+
+      const migration = new mod.default();
+
+      if (typeof migration.up !== "function") {
+        logger.error(`Migration file ${file} missing up()`);
+        continue;
+      }
+
+      await migration.up();
+      await recordMigration(migrationPath);
+
+      logger.info(`Migrated: ${migrationPath}`);
+      count++;
+    }
+
+    if (count === 0) logger.info("Nothing to migrate.");
+    else logger.info(`Success run all migration!`);
+
+    process.exit(0);
+  });
+
+// ================================
+// ## FRESH MIGRATE (DROP ALL)
+// ================================
+export const daMigrateFreshCommand = new Command("da:migrate:fresh")
+  .description("DROP ALL OLAP TABLES and rerun migrations")
+  .action(async () => {
+    logger.info("Preparing run migrations...");
+
+    if (!da) {
+      logger.error("ClickHouse connection (da) is not available.");
+      process.exit(1);
+    }
+
+    const tables = (await da.select("name").from("system.tables").where("database", "=", process.env.DA_DATABASE || "elysia_light").get()) as any[];
+
+    for (const t of tables) {
+      await da.exec(`DROP TABLE IF EXISTS ${t.name}`);
+    }
+
+    await ensureMigrationTable();
+    logger.info("Database has been freshed......");
+
+    if (!fs.existsSync(DW_MIGRATIONS_DIR)) {
+      logger.info("No OLAP migrations directory found.");
+      process.exit(0);
+    }
+    const files = getMigrationFiles(DW_MIGRATIONS_DIR).sort((a, b) => a.localeCompare(b));
+
+    for (const file of files) {
+      const filePath = file;
+      const migrationPath = path.relative(DW_MIGRATIONS_DIR, filePath);
+
+      const mod = await import(filePath);
+
+      if (!mod.default) continue;
+
+      const migration = new mod.default();
+
+      await migration.up();
+      await recordMigration(migrationPath);
+      logger.info(`Migrated: ${migrationPath}`);
+    }
+
+    logger.info(`Success run all migration!`);
+    process.exit(0);
+  });
+
+function getMigrationFiles(dir: string): string[] {
+  if (!fs.existsSync(dir)) return [];
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  let files: string[] = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      files = files.concat(getMigrationFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+// ==============================>
+// ## DA / OLAP : Migration 
+// ==============================>
+export abstract class DAMigration {
+  raw(query: string) {
+    return this.exec(query);
+  }
+
+  protected async exec(query: string) {
+    if (!daClient) {
+      logger.error("daClient is not available.");
+      return;
+    }
+    await daClient.query({ query });
+    return;
+  }
+
+  createTable(
+    name: string,
+    callback: (table: TableBuilder) => void,
+    options?: Partial<TableOptions>
+  ) {
+    const builder = new TableBuilder(name);
+    callback(builder);
+    const sql = builder.build(options);
+    return this.exec(sql);
+  }
+
+  dropTable(name: string) {
+    return this.exec(`DROP TABLE IF EXISTS ${name}`);
+  }
+
+  alterTable(
+    name: string,
+    callback: (alter: AlterBuilder) => void
+  ) {
+    const builder = new AlterBuilder(name);
+    callback(builder);
+    const sql = builder.build();
+    return this.exec(sql);
+  }
+}
+
+// ====================================>
+// ## DA / OLAP : Table Builder (CREATE TABLE)
+// ====================================>
+export interface TableOptions {
+  engine: string;
+  orderBy: string[];
+  partitionBy?: string;
+  ttl?: string;
+}
+
+export class TableBuilder {
+  private table: string;
+  private columns: string[] = [];
+
+  constructor(table: string) {
+    this.table = table;
+  }
+
+  uuid(name: string = "id") {
+    this.columns.push(`${name} UUID DEFAULT generateUUIDv7()`);
+  }
+
+  string(name: string) {
+    this.columns.push(`${name} String`);
+  }
+
+  uint64(name: string) {
+    this.columns.push(`${name} UInt64`);
+  }
+
+  int32(name: string) {
+    this.columns.push(`${name} Int32`);
+  }
+
+  json(name: string) {
+    this.columns.push(`${name} JSON`);
+  }
+
+  dateTime(name: string) {
+    this.columns.push(`${name} DateTime`);
+  }
+
+  build(options?: Partial<TableOptions>) {
+    const engine = options?.engine || "MergeTree";
+    const orderBy = options?.orderBy?.join(", ") || "id";
+    const partition = options?.partitionBy ? `PARTITION BY ${options.partitionBy}` : "";
+    const ttl = options?.ttl ? `TTL ${options.ttl}` : "";
+
+    return `
+      CREATE TABLE IF NOT EXISTS ${this.table} (
+        ${this.columns.join(",\n        ")}
+      )
+      ENGINE = ${engine}
+      ${partition}
+      ORDER BY (${orderBy})
+      ${ttl}
+    `.trim();
+  }
+}
+
+// ====================================>
+// ## DA / OLAP : Alter Builder (ALTER TABLE)
+// ====================================>
+export class AlterBuilder {
+  private table: string;
+  private actions: string[] = [];
+
+  constructor(table: string) {
+    this.table = table;
+  }
+
+  addColumn(name: string, type: string, defaultValue?: any) {
+    const def = defaultValue !== undefined ? ` DEFAULT ${this.format(defaultValue)}` : "";
+    this.actions.push(`ADD COLUMN IF NOT EXISTS ${name} ${type}${def}`);
+  }
+
+  dropColumn(name: string) {
+    this.actions.push(`DROP COLUMN IF EXISTS ${name}`);
+  }
+
+  modifyColumn(name: string, newType: string) {
+    this.actions.push(`MODIFY COLUMN ${name} ${newType}`);
+  }
+
+  commentColumn(name: string, comment: string) {
+    this.actions.push(`COMMENT COLUMN ${name} '${comment.replace(/'/g, "''")}'`);
+  }
+
+  private format(value: any) {
+    if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "1" : "0";
+    return value;
+  }
+
+  build() {
+    return `ALTER TABLE ${this.table} \n${this.actions.join("\n")} `;
+  }
+}

package/src/commands/runner/migration.ts

@@ -0,0 +1,245 @@
+import fs from "fs";
+import path from "path";
+import knex, { Knex } from "knex";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { runSeeder } from "./seeder";
+
+declare module "knex" {
+  namespace Knex {
+    interface CreateTableBuilder {
+      foreignIdFor(tableName: string, column?: string): Knex.ColumnBuilder;
+      softDelete(column?: string): Knex.ColumnBuilder;
+    }
+  }
+}
+
+const TableBuilder = require("knex/lib/schema/tablebuilder");
+
+TableBuilder.prototype.foreignIdFor = function (
+  this: Knex.CreateTableBuilder,
+  tableName: string,
+  column = `${conversion.strSingular(tableName)}_id`
+) {
+  return this.bigInteger(column).unsigned().index();
+};
+
+TableBuilder.prototype.softDelete = function (
+  this: Knex.CreateTableBuilder,
+  column = `deleted_at`
+) {
+  return this.timestamp(column).index();
+};
+
+// =====================================>
+// ## Command: migrate
+// =====================================>
+export const migrateCommand = new Command("migrate")
+  .description("Run all migration")
+  .option("--seed", "Run seeder after migrate")
+  .action(async (options) => {
+    await ensureDatabaseExists(process.env.DB_DATABASE || "db_elysia_light");
+
+    const { db } = await import("@skalfa/skalfa-orm");
+
+    if (!db) {
+      logger.error("Database connection (db) is not available. Ensure @skalfa/skalfa-orm is installed.");
+      process.exit(1);
+    }
+
+    const hasTable = await db.schema.hasTable("migrations");
+    if (!hasTable) {
+      await db.schema.createTable("migrations", (table: any) => {
+        table.increments("id").primary();
+        table.string("name").notNullable();
+        table.timestamp("batch").defaultTo(db.raw("CURRENT_TIMESTAMP"));
+      });
+    }
+
+    await runMigrationFile();
+
+    if (options.seed) {
+      await runSeeder();
+    }
+
+    process.exit(0);
+  });
+
+// =====================================>
+// ## Command: migrate:fresh
+// =====================================>
+export const migrateFreshCommand = new Command("migrate:fresh")
+  .description("Fresh and run all migration")
+  .option("--seed", "Run seeder after migrate")
+  .action(async (options) => {
+    await ensureDatabaseExists(process.env.DB_DATABASE || "db_elysia_light");
+
+    const { db } = await import("@skalfa/skalfa-orm");
+
+    if (!db) {
+      logger.error("Database connection (db) is not available. Ensure @skalfa/skalfa-orm is installed.");
+      process.exit(1);
+    }
+
+    await db.raw(`DROP SCHEMA public CASCADE;`);
+    await db.raw(`CREATE SCHEMA public;`);
+
+    logger.info("Database schema has been freshed...");
+
+    await db.schema.createTable("migrations", (table: any) => {
+      table.increments("id").primary();
+      table.string("name").notNullable();
+      table.timestamp("batch").defaultTo(db.raw("CURRENT_TIMESTAMP"));
+    });
+
+    await runMigrationFile();
+
+    if (options.seed) {
+      await runSeeder();
+    }
+
+    process.exit(0);
+  });
+
+// =====================================>
+// ## Command: migration helpers
+// =====================================>
+async function runMigrationFile() {
+  const { db } = await import("@skalfa/skalfa-orm");
+
+  if (!db) {
+    logger.error("Database connection (db) is not available.");
+    return;
+  }
+
+  const migrations = await db.table("migrations").select("name");
+  const migrated = migrations.map((row: any) => row.name);
+
+  const migrationsDir = fs.existsSync(path.resolve("./database/migrations"))
+    ? path.resolve("./database/migrations")
+    : path.resolve("./src/database/migrations");
+  if (!fs.existsSync(migrationsDir)) {
+    logger.info("No migrations directory found.");
+    return;
+  }
+  const files = getMigrationFiles(migrationsDir).sort((a, b) => a.localeCompare(b));
+
+  let countMigrated = 0;
+
+  logger.info("Running migrations...");
+
+  for (const file of files) {
+    const migrationFile = path.relative(migrationsDir, file);
+
+    if (migrated.includes(migrationFile)) continue;
+
+    const mod = await import(file);
+
+    if (mod.up) {
+      await mod.up(db);
+      await db.table("migrations").insert({ name: migrationFile });
+      logger.info(`Migrated: ${migrationFile}`);
+    }
+
+    countMigrated++;
+  }
+
+  if (countMigrated > 0) {
+    logger.info(`Success run all migration!`);
+  } else {
+    logger.info(`Nothing to migrate!`);
+  }
+}
+
+function getMigrationFiles(dir: string, baseDir = dir): string[] {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  let files: string[] = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      files = files.concat(getMigrationFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+async function ensureDatabaseExists(databaseName: string) {
+  const driver = (process.env.DB_CONNECTION || "pg").toLowerCase();
+
+  switch (driver) {
+    case "pg":
+    case "pgsql": {
+      const tempDb = knex({
+        client: "pg",
+        connection: {
+          host: process.env.DB_HOST || "127.0.0.1",
+          port: Number(process.env.DB_PORT) || 5432,
+          user: process.env.DB_USERNAME || "postgres",
+          password: process.env.DB_PASSWORD || "password",
+          database: "postgres",
+        },
+      });
+
+      try {
+        const result = await tempDb
+          .select("datname")
+          .from("pg_database")
+          .where("datname", databaseName)
+          .first();
+
+        if (!result) {
+          logger.info(`Database ${databaseName} not found. Create new database...`);
+          await tempDb.raw(`CREATE DATABASE "${databaseName}"`);
+          logger.info(`Database ${databaseName} successfully created.`);
+        }
+      } catch (err) {
+        logger.error(`Check or create database error: ${err}`);
+      } finally {
+        await tempDb.destroy();
+      }
+
+      break;
+    }
+
+    case "mysql":
+    case "mysql2": {
+      const tempDb = knex({
+        client: "mysql2",
+        connection: {
+          host: process.env.DB_HOST || "127.0.0.1",
+          port: Number(process.env.DB_PORT) || 3306,
+          user: process.env.DB_USERNAME || "root",
+          password: process.env.DB_PASSWORD || "",
+        },
+      });
+
+      try {
+        const [rows]: any = await tempDb.raw(
+          `SHOW DATABASES LIKE ?`,
+          [databaseName]
+        );
+
+        if (!rows || rows.length === 0) {
+          logger.info(`Database ${databaseName} not found. Create new database...`);
+          await tempDb.raw(`CREATE DATABASE \`${databaseName}\``);
+          logger.info(`Database ${databaseName} successfully created.`);
+        }
+      } catch (err) {
+        logger.error(`Check or create database error: ${err}`);
+      } finally {
+        await tempDb.destroy();
+      }
+
+      break;
+    }
+
+    default:
+      throw new Error(`Driver ${driver} belum didukung oleh ensureDatabaseExists().`);
+  }
+}

package/src/commands/runner/seeder.ts

@@ -0,0 +1,44 @@
+import fs from "fs";
+import path from "path";
+import { Command } from "commander";
+import { logger } from "@utils";
+
+// =====================================>
+// ## Command: seeder
+// =====================================>
+export const seederCommand = new Command("seeder")
+  .description("Run all database seeders")
+  .action(async () => {
+    try {
+      await runSeeder();
+      process.exit(0);
+    } catch (error) {
+      logger.error(`Error running seeds: ${error}`);
+      process.exit(1);
+    }
+  });
+
+export const runSeeder = async () => {
+  const seedersDir = fs.existsSync(path.join(process.cwd(), "database", "seeders"))
+    ? path.join(process.cwd(), "database", "seeders")
+    : path.join(process.cwd(), "src", "database", "seeders");
+  if (!fs.existsSync(seedersDir)) {
+    logger.info("No seeders directory found.");
+    return;
+  }
+  const files = fs.readdirSync(seedersDir).filter(f => f.endsWith(".ts"));
+
+  logger.info("Running seeders...");
+
+  for (const file of files) {
+    const seederPath = path.join(seedersDir, file);
+    const { default: seeder } = await import(seederPath);
+
+    if (typeof seeder === "function") {
+      await seeder();
+      logger.info(`Planted: ${file}`);
+    }
+  }
+
+  logger.info("Success run all seeders!");
+};