@vibeorm/dsl 0.4.0 → 2.0.0-alpha.1

package/src/column.ts

@@ -1,389 +0,0 @@
-/**
- * Column type builders using chainable style with optional config-object fallback
- *
- * @example
- * // Chainable style (encouraged)
- * dsl.string().optional()
- * dsl.string().unique().index()
- * dsl.int().default(42)
- *
- * // Object style (also supported)
- * dsl.string({ optional: true })
- * dsl.string({ unique: true, index: true })
- * dsl.int({ default: 42 })
- */
-
-import type {
-  BigIntColumnConfig,
-  BooleanColumnConfig,
-  BytesColumnConfig,
-  ColumnDef,
-  DatetimeColumnConfig,
-  DecimalColumnConfig,
-  FloatColumnConfig,
-  IdColumnConfig,
-  InlineEnumConfig,
-  IntColumnConfig,
-  JsonColumnConfig,
-  StringColumnConfig,
-  UnsupportedColumnConfig,
-} from "./types.ts";
-
-// ─── Clone Helper ─────────────────────
-
-/**
- * Creates a shallow clone of a ColumnDef, producing fresh __config.
- * Used to prevent shared mutation when columns are spread from templates.
- */
-export function cloneColumnDef(col: ColumnDef): ColumnDef {
-  return {
-    __type: "column",
-    __columnType: col.__columnType,
-    __name: col.__name,
-    __config: { ...col.__config },
-    __enumValues: col.__enumValues,
-    __enumName: col.__enumName,
-  };
-}
-
-// ─── Chainable Column Builder ─────────────────────
-
-/**
- * Chainable column definition that allows method chaining for configuration.
- * Implements ColumnDef for backwards compatibility.
- */
-export class ChainableColumn<T extends ColumnDef["__columnType"]> implements ColumnDef<T> {
-  readonly __type = "column" as const;
-  readonly __columnType: T;
-  __config: ColumnDef["__config"];
-  __name?: string;
-  __enumValues?: readonly string[];
-  __enumName?: string;
-
-  constructor(columnType: T, config: ColumnDef["__config"] = {}) {
-    this.__columnType = columnType;
-    this.__config = { ...config };
-  }
-
-  /**
-   * Mark this column as optional (nullable)
-   */
-  optional(): this {
-    this.__config.optional = true;
-    return this;
-  }
-
-  /**
-   * Add a unique constraint to this column
-   */
-  unique(): this {
-    this.__config.unique = true;
-    return this;
-  }
-
-  /**
-   * Add an index on this column
-   */
-  index(): this {
-    this.__config.index = true;
-    return this;
-  }
-
-  /**
-   * Mark this column as an array type
-   */
-  array(): this {
-    this.__config.array = true;
-    return this;
-  }
-
-  /**
-   * Set a default value for this column
-   */
-  default<V>(value: V): this {
-    this.__config.default = value;
-    return this;
-  }
-
-  /**
-   * Map this column to a different database column name
-   * @example dsl.string().map("user_name")  // @map("user_name")
-   */
-  map(dbColumnName: string): this {
-    this.__config.map = dbColumnName;
-    return this;
-  }
-
-  /**
-   * Set default value using a database-native function
-   * @example dsl.string().dbgenerated("gen_random_uuid()")
-   */
-  dbgenerated(expression: string): this {
-    this.__config.dbgenerated = expression;
-    return this;
-  }
-
-  /**
-   * Add a triple-slash comment above this column in Prisma output.
-   * Useful for Zod generator annotations or documentation.
-   * @example dsl.string().comment("@zod.string.min(1).max(100)")
-   * @example dsl.string().comment("User's display name")
-   */
-  comment(text: string): this {
-    this.__config.comment = text;
-    return this;
-  }
-}
-
-/**
- * Chainable column for string with database-level type annotations
- */
-export class ChainableStringColumn extends ChainableColumn<"string"> {
-  constructor(config: StringColumnConfig = {}) {
-    super("string", config);
-  }
-
-  /**
-   * Set maximum character length - generates @db.VarChar(n) in Prisma
-   * @example dsl.string().maxLength(255)
-   */
-  maxLength(n: number): this {
-    (this.__config as StringColumnConfig).maxLength = n;
-    return this;
-  }
-
-  /**
-   * Mark as database text type - generates @db.Text in Prisma
-   * @example dsl.string().text()
-   */
-  text(): this {
-    (this.__config as StringColumnConfig).text = true;
-    return this;
-  }
-}
-
-/**
- * Chainable column for decimal with precision/scale
- */
-export class ChainableDecimalColumn extends ChainableColumn<"decimal"> {
-  constructor(config: DecimalColumnConfig = {}) {
-    super("decimal", config);
-  }
-
-  /**
-   * Set decimal precision - generates @db.Decimal(precision, scale) in Prisma
-   * @example dsl.decimal().precision(10, 2) // 10 digits total, 2 after decimal
-   */
-  precision(p: number, s?: number): this {
-    (this.__config as DecimalColumnConfig).precision = p;
-    if (s !== undefined) {
-      (this.__config as DecimalColumnConfig).scale = s;
-    }
-    return this;
-  }
-}
-
-/**
- * Chainable column for datetime with additional datetime-specific methods
- */
-export class ChainableDatetimeColumn extends ChainableColumn<"datetime"> {
-  constructor(config: DatetimeColumnConfig = {}) {
-    super("datetime", config);
-  }
-
-  /**
-   * Enable timezone support (@db.Timestamptz in Prisma)
-   */
-  tz(): this {
-    (this.__config as DatetimeColumnConfig).tz = true;
-    return this;
-  }
-
-  /**
-   * Mark as auto-updated on record update (@updatedAt in Prisma)
-   */
-  updatedAt(): this {
-    (this.__config as DatetimeColumnConfig).updatedAt = true;
-    return this;
-  }
-
-  /**
-   * Set default to current timestamp
-   */
-  defaultNow(): this {
-    (this.__config as DatetimeColumnConfig).default = "now";
-    return this;
-  }
-}
-
-/**
- * Chainable column for ID with id-specific methods
- */
-export class ChainableIdColumn extends ChainableColumn<"id"> {
-  constructor(config: IdColumnConfig = {}) {
-    super("id", { ...config, type: config.type ?? "ulid" });
-  }
-
-  /**
-   * Set the ID generator type
-   */
-  type(idType: "ulid" | "cuid" | "uuid" | "autoincrement" | "none"): this {
-    (this.__config as IdColumnConfig).type = idType;
-    return this;
-  }
-}
-
-// ─── Column Factory Functions ─────────────────────
-
-/**
- * Creates a String column
- *
- * @example
- * dsl.string()                    // String, required
- * dsl.string().optional()         // String?
- * dsl.string().unique().index()   // String with @unique and @index
- * dsl.string({ optional: true })  // Object style also supported
- */
-export function string(config: StringColumnConfig = {}): ChainableStringColumn {
-  return new ChainableStringColumn(config);
-}
-
-/**
- * Creates an Int column
- *
- * @example
- * dsl.int()                       // Int, required
- * dsl.int().optional()            // Int?
- * dsl.int().default(0)            // Int with default
- */
-export function int(config: IntColumnConfig = {}): ChainableColumn<"int"> {
-  return new ChainableColumn("int", config);
-}
-
-/**
- * Creates a Float column
- */
-export function float(config: FloatColumnConfig = {}): ChainableColumn<"float"> {
-  return new ChainableColumn("float", config);
-}
-
-/**
- * Creates a Decimal column
- */
-export function decimal(config: DecimalColumnConfig = {}): ChainableDecimalColumn {
-  return new ChainableDecimalColumn(config);
-}
-
-/**
- * Creates a Boolean column
- *
- * @example
- * dsl.boolean()                   // Boolean, required
- * dsl.boolean().default(true)     // Boolean with default
- */
-export function boolean(config: BooleanColumnConfig = {}): ChainableColumn<"boolean"> {
-  return new ChainableColumn("boolean", config);
-}
-
-/**
- * Creates a DateTime column
- *
- * @example
- * dsl.datetime()                           // DateTime
- * dsl.datetime().defaultNow()              // DateTime @default(now())
- * dsl.datetime().defaultNow().updatedAt()  // DateTime @default(now()) @updatedAt
- * dsl.datetime().tz()                      // DateTime @db.Timestamptz()
- */
-export function datetime(config: DatetimeColumnConfig = {}): ChainableDatetimeColumn {
-  return new ChainableDatetimeColumn(config);
-}
-
-/**
- * Creates a Json column
- */
-export function json(config: JsonColumnConfig = {}): ChainableColumn<"json"> {
-  return new ChainableColumn("json", config);
-}
-
-/**
- * Creates an ID column (primary key)
- *
- * @example
- * dsl.id()                        // String @id @default(ulid()) - default
- * dsl.id().type("cuid")           // String @id @default(cuid())
- * dsl.id({ type: "uuid" })        // String @id @default(uuid())
- */
-export function id(config: IdColumnConfig = {}): ChainableIdColumn {
-  return new ChainableIdColumn(config);
-}
-
-/**
- * Creates a Bytes column
- */
-export function bytes(config: BytesColumnConfig = {}): ChainableColumn<"bytes"> {
-  return new ChainableColumn("bytes", config);
-}
-
-/**
- * Creates a BigInt column for arbitrarily large integers
- *
- * @example
- * dsl.bigint()                     // BigInt, required
- * dsl.bigint().optional()          // BigInt?
- * dsl.bigint().default(0)          // BigInt with default
- */
-export function bigint(config: BigIntColumnConfig = {}): ChainableColumn<"bigint"> {
-  return new ChainableColumn("bigint", config);
-}
-
-/**
- * Creates an Unsupported column for database-specific types that Prisma can't represent
- *
- * @example
- * dsl.unsupported("tsvector")                    // For PostgreSQL full-text search
- * dsl.unsupported("geometry(Point, 4326)")       // For PostGIS
- * dsl.unsupported("cidr")                        // For PostgreSQL network types
- */
-export function unsupported(dbType: string): ChainableColumn<"unsupported"> {
-  const config: UnsupportedColumnConfig = { dbType };
-  return new ChainableColumn("unsupported", config);
-}
-
-/**
- * Creates an inline Enum column
- *
- * For standalone enums that can be reused, use dsl.enum({ name, options }) instead.
- *
- * @example
- * // Inline enum (one-off use)
- * dsl.enum({ options: ["a", "b", "c"] })
- * dsl.enum({ options: ["a", "b"] }).default("a")
- * dsl.enum({ options: ["active", "inactive"] }).optional().index()
- */
-export function enumCol<const T extends readonly string[]>(
-  config: InlineEnumConfig<T>
-): ChainableColumn<"enum"> {
-  // Extract options from config, rest goes to __config
-  const { options, ...restConfig } = config;
-  const col = new ChainableColumn("enum", restConfig);
-  col.__enumValues = options;
-  // No __enumName for inline enums - will auto-generate name from model+field
-  return col;
-}
-
-// ─── Column Namespace Export ─────────────────────
-
-export const column = {
-  string,
-  int,
-  bigint,
-  float,
-  decimal,
-  boolean,
-  datetime,
-  json,
-  id,
-  bytes,
-  unsupported,
-  enum: enumCol,
-};

package/src/enum.ts

@@ -1,71 +0,0 @@
-/**
- * Standalone enum support for @vibeorm/dsl
- *
- * Allows defining enums separately and reusing them across models.
- *
- * @example
- * // Define standalone enum
- * const Status = dsl.enum({
- *   name: "Status",
- *   options: ["active", "inactive", "pending"],
- * });
- *
- * // Use in model via .field()
- * const User = dsl.create({
- *   name: "User",
- *   schema: {
- *     ...dsl.base,
- *     status: Status.field().default("active"),
- *   },
- * });
- */
-
-import { ChainableColumn } from "./column.ts";
-import type { EnumFieldConfig } from "./types.ts";
-
-// ─── Standalone Enum Config ─────────────────────
-
-export type StandaloneEnumConfig<T extends readonly string[]> = {
-  name: string;
-  options: T;
-};
-
-// ─── Standalone Enum Definition ─────────────────────
-
-export type EnumDef<T extends readonly string[] = readonly string[]> = {
-  __type: "enum";
-  __name: string;
-  __options: T;
-  field(config?: EnumFieldConfig<T>): ChainableColumn<"enum">;
-};
-
-// ─── Standalone Enum Factory ─────────────────────
-
-/**
- * Creates a standalone enum that can be reused across models
- *
- * @example
- * const Status = createEnum({
- *   name: "Status",
- *   options: ["active", "inactive", "pending"],
- * });
- *
- * // Use in model with chaining
- * status: Status.field().default("active")
- * status: Status.field().optional().index()
- */
-export function createEnum<const T extends readonly string[]>(
-  config: StandaloneEnumConfig<T>
-): EnumDef<T> {
-  return {
-    __type: "enum",
-    __name: config.name,
-    __options: config.options,
-    field(fieldConfig: EnumFieldConfig<T> = {}): ChainableColumn<"enum"> {
-      const col = new ChainableColumn("enum", fieldConfig);
-      col.__enumValues = config.options;
-      col.__enumName = config.name; // Reference to standalone enum
-      return col;
-    },
-  };
-}

package/src/generator/index.ts

@@ -1,5 +0,0 @@
-/**
- * Generator exports
- */
-
-export { generatePrisma } from "./prisma.ts";