@buenojs/bueno 0.8.4 → 0.8.6

package/dist/schema/index.js

@@ -0,0 +1,400 @@
+// @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();
+}
+export {
+  generateDropTable,
+  generateCreateTable,
+  generateCreateIndex,
+  defineTable,
+  createSchema,
+  SchemaBuilder
+};