@buenojs/bueno 0.8.3 → 0.8.5

package/dist/migrations/index.js

@@ -0,0 +1,571 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/database/schema/index.ts
+class ColumnBuilder {
+  column;
+  constructor(type) {
+    this.column = { type, nullable: false };
+  }
+  nullable() {
+    this.column.nullable = true;
+    return this;
+  }
+  notNull() {
+    this.column.nullable = false;
+    return this;
+  }
+  default(value) {
+    this.column.default = value;
+    return this;
+  }
+  primaryKey() {
+    this.column.primaryKey = true;
+    return this;
+  }
+  unique() {
+    this.column.unique = true;
+    return this;
+  }
+  length(len) {
+    this.column.length = len;
+    return this;
+  }
+  precision(p, s) {
+    this.column.precision = p;
+    if (s !== undefined)
+      this.column.scale = s;
+    return this;
+  }
+  references(table, column, options) {
+    this.column.references = {
+      table,
+      column,
+      ...options
+    };
+    return this;
+  }
+  check(expression) {
+    this.column.check = expression;
+    return this;
+  }
+  comment(text) {
+    this.column.comment = text;
+    return this;
+  }
+  build() {
+    return { ...this.column };
+  }
+}
+
+class SchemaBuilder {
+  name;
+  columns = {};
+  indexes = [];
+  constraints = [];
+  tableComment;
+  constructor(tableName) {
+    this.name = tableName;
+  }
+  serial(name) {
+    const builder = new ColumnBuilder("serial");
+    builder.primaryKey();
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  integer(name) {
+    const builder = new ColumnBuilder("integer");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  bigint(name) {
+    const builder = new ColumnBuilder("bigint");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  decimal(name) {
+    const builder = new ColumnBuilder("decimal");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  varchar(name, length = 255) {
+    const builder = new ColumnBuilder("varchar");
+    builder.length(length);
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  text(name) {
+    const builder = new ColumnBuilder("text");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  boolean(name) {
+    const builder = new ColumnBuilder("boolean");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  date(name) {
+    const builder = new ColumnBuilder("date");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  timestamp(name) {
+    const builder = new ColumnBuilder("timestamp");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  timestamptz(name) {
+    const builder = new ColumnBuilder("timestamptz");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  json(name) {
+    const builder = new ColumnBuilder("json");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  jsonb(name) {
+    const builder = new ColumnBuilder("jsonb");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  uuid(name) {
+    const builder = new ColumnBuilder("uuid");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  blob(name) {
+    const builder = new ColumnBuilder("blob");
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  enum(name, values) {
+    const builder = new ColumnBuilder("enum");
+    builder.column.enum = values;
+    this.columns[name] = builder.build();
+    return builder;
+  }
+  column(name, options) {
+    this.columns[name] = options;
+    return this;
+  }
+  index(columns, options) {
+    this.indexes.push({
+      columns,
+      ...options
+    });
+    return this;
+  }
+  unique(columns, name) {
+    this.constraints.push({
+      type: "unique",
+      columns,
+      name
+    });
+    return this;
+  }
+  foreignKey(columns, reference, name) {
+    this.constraints.push({
+      type: "foreign",
+      columns,
+      reference,
+      name
+    });
+    return this;
+  }
+  check(expression, name) {
+    this.constraints.push({
+      type: "check",
+      columns: [],
+      check: expression,
+      name
+    });
+    return this;
+  }
+  comment(text) {
+    this.tableComment = text;
+    return this;
+  }
+  build() {
+    return {
+      name: this.name,
+      columns: { ...this.columns },
+      indexes: [...this.indexes],
+      constraints: [...this.constraints],
+      comment: this.tableComment
+    };
+  }
+}
+function generateCreateTable(schema, driver = "postgresql") {
+  const columnDefs = [];
+  const primaryKeys = [];
+  for (const [name, col] of Object.entries(schema.columns)) {
+    const parts = [name, mapColumnType(col, driver)];
+    if (col.primaryKey) {
+      primaryKeys.push(name);
+      if (driver === "sqlite" && col.type === "serial") {
+        parts[1] = "INTEGER PRIMARY KEY AUTOINCREMENT";
+      }
+    }
+    if (!col.nullable && !col.primaryKey) {
+      parts.push("NOT NULL");
+    }
+    if (col.unique && !col.primaryKey) {
+      parts.push("UNIQUE");
+    }
+    if (col.default !== undefined) {
+      parts.push(`DEFAULT ${formatDefault(col.default, driver)}`);
+    }
+    if (col.references) {
+      const ref = col.references;
+      parts.push(`REFERENCES ${ref.table}(${ref.column})`);
+      if (ref.onDelete)
+        parts.push(`ON DELETE ${ref.onDelete}`);
+      if (ref.onUpdate)
+        parts.push(`ON UPDATE ${ref.onUpdate}`);
+    }
+    columnDefs.push(parts.join(" "));
+  }
+  if (primaryKeys.length > 1) {
+    columnDefs.push(`PRIMARY KEY (${primaryKeys.join(", ")})`);
+  }
+  for (const constraint of schema.constraints ?? []) {
+    if (constraint.type === "unique") {
+      const name = constraint.name || `uq_${schema.name}_${constraint.columns.join("_")}`;
+      columnDefs.push(`CONSTRAINT ${name} UNIQUE (${constraint.columns.join(", ")})`);
+    } else if (constraint.type === "check" && constraint.check) {
+      const name = constraint.name || `chk_${schema.name}`;
+      columnDefs.push(`CONSTRAINT ${name} CHECK (${constraint.check})`);
+    }
+  }
+  let sql = `CREATE TABLE ${schema.name} (
+  ${columnDefs.join(`,
+  `)}
+)`;
+  if (driver === "postgresql" && schema.comment) {
+    sql += `;
+COMMENT ON TABLE ${schema.name} IS '${schema.comment}'`;
+  }
+  return `${sql};`;
+}
+function generateDropTable(tableName, ifExists = true) {
+  if (ifExists) {
+    return `DROP TABLE IF EXISTS ${tableName};`;
+  }
+  return `DROP TABLE ${tableName};`;
+}
+function generateCreateIndex(tableName, index, driver = "postgresql") {
+  const name = index.name || `idx_${tableName}_${index.columns.join("_")}`;
+  const unique = index.unique ? "UNIQUE " : "";
+  const type = index.type && driver === "postgresql" ? `USING ${index.type} ` : "";
+  return `CREATE ${unique}INDEX ${name} ON ${tableName} ${type}(${index.columns.join(", ")});`;
+}
+function mapColumnType(col, driver) {
+  const typeMap = {
+    serial: {
+      postgresql: "SERIAL",
+      mysql: "INT AUTO_INCREMENT",
+      sqlite: "INTEGER"
+    },
+    integer: {
+      postgresql: "INTEGER",
+      mysql: "INT",
+      sqlite: "INTEGER"
+    },
+    bigint: {
+      postgresql: "BIGINT",
+      mysql: "BIGINT",
+      sqlite: "INTEGER"
+    },
+    decimal: {
+      postgresql: col.precision ? `DECIMAL(${col.precision}, ${col.scale ?? 0})` : "DECIMAL",
+      mysql: col.precision ? `DECIMAL(${col.precision}, ${col.scale ?? 0})` : "DECIMAL",
+      sqlite: "REAL"
+    },
+    varchar: {
+      postgresql: col.length ? `VARCHAR(${col.length})` : "VARCHAR",
+      mysql: col.length ? `VARCHAR(${col.length})` : "VARCHAR(255)",
+      sqlite: "TEXT"
+    },
+    text: {
+      postgresql: "TEXT",
+      mysql: "TEXT",
+      sqlite: "TEXT"
+    },
+    boolean: {
+      postgresql: "BOOLEAN",
+      mysql: "TINYINT(1)",
+      sqlite: "INTEGER"
+    },
+    date: {
+      postgresql: "DATE",
+      mysql: "DATE",
+      sqlite: "TEXT"
+    },
+    timestamp: {
+      postgresql: "TIMESTAMP",
+      mysql: "DATETIME",
+      sqlite: "TEXT"
+    },
+    timestamptz: {
+      postgresql: "TIMESTAMPTZ",
+      mysql: "DATETIME",
+      sqlite: "TEXT"
+    },
+    json: {
+      postgresql: "JSON",
+      mysql: "JSON",
+      sqlite: "TEXT"
+    },
+    jsonb: {
+      postgresql: "JSONB",
+      mysql: "JSON",
+      sqlite: "TEXT"
+    },
+    uuid: {
+      postgresql: "UUID",
+      mysql: "CHAR(36)",
+      sqlite: "TEXT"
+    },
+    blob: {
+      postgresql: "BYTEA",
+      mysql: "BLOB",
+      sqlite: "BLOB"
+    },
+    enum: {
+      postgresql: col.enum ? `ENUM(${col.enum.map((e) => `'${e}'`).join(", ")})` : "VARCHAR",
+      mysql: col.enum ? `ENUM(${col.enum.map((e) => `'${e}'`).join(", ")})` : "VARCHAR",
+      sqlite: "TEXT"
+    }
+  };
+  return typeMap[col.type][driver];
+}
+function formatDefault(value, driver) {
+  if (value === null)
+    return "NULL";
+  if (value === true)
+    return driver === "sqlite" ? "1" : "TRUE";
+  if (value === false)
+    return driver === "sqlite" ? "0" : "FALSE";
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string") {
+    if (value.toUpperCase() === "NOW()" || value.toUpperCase() === "CURRENT_TIMESTAMP") {
+      return driver === "mysql" ? "CURRENT_TIMESTAMP" : value.toUpperCase();
+    }
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return String(value);
+}
+function createSchema(tableName) {
+  return new SchemaBuilder(tableName);
+}
+function defineTable(name, define) {
+  const builder = new SchemaBuilder(name);
+  define(builder);
+  return builder.build();
+}
+
+// src/database/migrations/index.ts
+class MigrationRunner {
+  db;
+  migrationsTable;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.migrationsTable = options.migrationsTable ?? "_migrations";
+  }
+  async ensureMigrationsTable() {
+    await this.db.raw(`
+      CREATE TABLE IF NOT EXISTS ${this.migrationsTable} (
+        id VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+  }
+  async getExecutedMigrations() {
+    await this.ensureMigrationsTable();
+    const results = await this.db.raw(`SELECT id, name, executed_at FROM ${this.migrationsTable} ORDER BY id ASC`);
+    return results.map((r) => ({
+      id: r.id,
+      name: r.name,
+      executedAt: new Date(r.executed_at)
+    }));
+  }
+  async getPendingMigrations(migrations) {
+    const executed = await this.getExecutedMigrations();
+    const executedIds = new Set(executed.map((m) => m.id));
+    return migrations.filter((m) => !executedIds.has(m.id)).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  async runMigration(migration) {
+    await this.db.transaction(async () => {
+      await migration.up(this);
+      await this.db.raw(`INSERT INTO ${this.migrationsTable} (id, name) VALUES (?, ?)`, [migration.id, migration.name]);
+    });
+  }
+  async migrate(migrations) {
+    const pending = await this.getPendingMigrations(migrations);
+    const executed = [];
+    for (const migration of pending) {
+      await this.runMigration(migration);
+      executed.push(migration.id);
+      console.log(`Executed migration: ${migration.id} - ${migration.name}`);
+    }
+    return { executed };
+  }
+  async rollback(migrations, steps = 1) {
+    const executed = await this.getExecutedMigrations();
+    const rolledBack = [];
+    const migrationsById = new Map(migrations.map((m) => [m.id, m]));
+    const toRollback = executed.sort((a, b) => b.id.localeCompare(a.id)).slice(0, steps);
+    for (const record of toRollback) {
+      const migration = migrationsById.get(record.id);
+      if (!migration) {
+        console.warn(`Migration not found: ${record.id}`);
+        continue;
+      }
+      await this.db.transaction(async () => {
+        await migration.down(this);
+        await this.db.raw(`DELETE FROM ${this.migrationsTable} WHERE id = ?`, [
+          record.id
+        ]);
+      });
+      rolledBack.push(record.id);
+      console.log(`Rolled back migration: ${record.id} - ${record.name}`);
+    }
+    return { rolledBack };
+  }
+  async reset(migrations) {
+    const executed = await this.getExecutedMigrations();
+    return this.rollback(migrations, executed.length);
+  }
+  async refresh(migrations) {
+    const { rolledBack } = await this.reset(migrations);
+    const { executed } = await this.migrate(migrations);
+    return { rolledBack, executed };
+  }
+  async createTable(schema) {
+    const sql = generateCreateTable(schema, "postgresql");
+    await this.db.raw(sql);
+    for (const index of schema.indexes ?? []) {
+      await this.createIndex(schema.name, index);
+    }
+  }
+  async dropTable(name) {
+    const sql = generateDropTable(name);
+    await this.db.raw(sql);
+  }
+  async createIndex(tableName, index) {
+    const sql = generateCreateIndex(tableName, index, "postgresql");
+    await this.db.raw(sql);
+  }
+  async dropIndex(name) {
+    await this.db.raw(`DROP INDEX IF EXISTS ${name}`);
+  }
+  async addColumn(table, name, type, options) {
+    let sql = `ALTER TABLE ${table} ADD COLUMN ${name} ${type}`;
+    if (options?.default !== undefined) {
+      sql += ` DEFAULT ${typeof options.default === "string" ? `'${options.default}'` : options.default}`;
+    }
+    if (!options?.nullable) {
+      sql += " NOT NULL";
+    }
+    await this.db.raw(sql);
+  }
+  async dropColumn(table, name) {
+    await this.db.raw(`ALTER TABLE ${table} DROP COLUMN ${name}`);
+  }
+  async renameColumn(table, oldName, newName) {
+    await this.db.raw(`ALTER TABLE ${table} RENAME COLUMN ${oldName} TO ${newName}`);
+  }
+  async addForeignKey(table, columns, reference, options) {
+    const name = options?.name ?? `fk_${table}_${columns.join("_")}`;
+    let sql = `ALTER TABLE ${table} ADD CONSTRAINT ${name} FOREIGN KEY (${columns.join(", ")}) REFERENCES ${reference.table}(${reference.columns.join(", ")})`;
+    if (options?.onDelete)
+      sql += ` ON DELETE ${options.onDelete}`;
+    if (options?.onUpdate)
+      sql += ` ON UPDATE ${options.onUpdate}`;
+    await this.db.raw(sql);
+  }
+  async dropForeignKey(table, name) {
+    await this.db.raw(`ALTER TABLE ${table} DROP CONSTRAINT ${name}`);
+  }
+  async raw(sql) {
+    await this.db.raw(sql);
+  }
+}
+
+class MigrationBuilder {
+  id;
+  name;
+  upFn = async () => {};
+  downFn = async () => {};
+  constructor(id, name) {
+    this.id = id;
+    this.name = name;
+  }
+  up(fn) {
+    this.upFn = fn;
+    return this;
+  }
+  down(fn) {
+    this.downFn = fn;
+    return this;
+  }
+  build() {
+    return {
+      id: this.id,
+      name: this.name,
+      up: this.upFn,
+      down: this.downFn
+    };
+  }
+}
+function createMigration(id, name) {
+  return new MigrationBuilder(id, name);
+}
+function createMigrationRunner(db, options) {
+  return new MigrationRunner(db, options);
+}
+function generateMigrationId() {
+  const now = new Date;
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hour = String(now.getHours()).padStart(2, "0");
+  const minute = String(now.getMinutes()).padStart(2, "0");
+  const second = String(now.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hour}${minute}${second}`;
+}
+export {
+  generateMigrationId,
+  createMigrationRunner,
+  createMigration,
+  MigrationRunner,
+  MigrationBuilder
+};