@vibeorm/dsl 0.3.0 → 2.0.0-alpha.1

package/src/index.ts

@@ -1,247 +0,0 @@
-/**
- * @vibeorm/dsl - TypeScript DSL for database schema management
- *
- * Relations are defined separately via dsl.defineRelations()
- *
- * @example
- * import { dsl } from "@vibeorm/dsl";
- *
- * // Models - just columns (FK columns declared explicitly)
- * const Workspace = dsl.create({
- *   name: "Workspace",
- *   schema: {
- *     ...dsl.templates.base,
- *     name: dsl.string(),
- *   },
- * });
- *
- * const User = dsl.create({
- *   name: "User",
- *   schema: {
- *     ...dsl.templates.base,
- *     email: dsl.string({ unique: true }),
- *     workspaceId: dsl.string({ index: true }),
- *   },
- *   indexes: (i) => [
- *     i.unique("workspaceId", "email"),
- *   ],
- * });
- *
- * // Relations - centralized and type-safe
- * const relations = dsl.defineRelations({ Workspace, User }, (r) => ({
- *   Workspace: {
- *     users: r.many.User({
- *       from: r.Workspace.id,
- *       to: r.User.workspaceId,
- *     }),
- *   },
- *   User: {
- *     workspace: r.one.Workspace({
- *       from: r.User.workspaceId,
- *       to: r.Workspace.id,
- *     }),
- *   },
- * }));
- *
- * // Schema with relations
- * const schema = dsl.schema({ User, Workspace }, { relations });
- * const prisma = dsl.generate.prisma(schema);
- */
-
-// ─── Column Imports ─────────────────────────────────
-
-import {
-  bigint,
-  boolean,
-  bytes,
-  ChainableColumn,
-  datetime,
-  decimal,
-  enumCol,
-  float,
-  id,
-  int,
-  json,
-  string,
-  unsupported,
-} from "./column.ts";
-
-// ─── Enum Imports ─────────────────────────────────
-
-import { createEnum } from "./enum.ts";
-import type { StandaloneEnumConfig } from "./enum.ts";
-
-// ─── Model Imports ─────────────────────────────────
-
-import { create } from "./model.ts";
-
-// ─── Relations Imports ─────────────────────────────────
-
-import { defineRelations, defineRelationsPart, mergeRelations } from "./relations.ts";
-
-// ─── Schema Imports ─────────────────────────────────
-
-import { domain, schema } from "./schema.ts";
-
-// ─── Generator Imports ─────────────────────────────────
-
-import { generatePrisma } from "./generator/prisma.ts";
-
-// ─── Validation Imports ─────────────────────────────────
-
-import { validateSchema } from "./validate.ts";
-
-// ─── Template Imports ─────────────────────────────────
-
-import {
-  base,
-  baseWithWorkspace,
-  fields,
-  templates,
-  withActive,
-  withAudit,
-  withExternalId,
-  withMetadata,
-  withNameDescription,
-} from "./templates.ts";
-
-// ─── Type Imports ─────────────────────────────────
-
-import type {
-  ColumnDef,
-  EnumDef,
-  InlineEnumConfig,
-  SchemaDef,
-} from "./types.ts";
-
-// ─── Type Exports ─────────────────────────────────
-
-export type {
-  // Cascade action types
-  CascadeAction,
-  // Children types
-  ChildrenBuilder,
-  ChildrenDef,
-  ChildrenRelationConfig,
-  // Column types
-  ColumnDef,
-  ColumnRef,
-  // Enum types
-  EnumDef,
-  EnumFieldConfig,
-  // Generator types
-  GeneratorConfig,
-  GeneratorOutput,
-  // Index types
-  IndexBuilder,
-  IndexCallback,
-  IndexDef,
-  IndexOptions,
-  IndexType,
-  InlineEnumConfig,
-  // Model types
-  ModelDef,
-  // Prisma types
-  PrismaGeneratorConfig,
-  // Relations types
-  ManyRelationDefConfig,
-  OneRelationDefConfig,
-  RelationsBuilder,
-  RelationsMap,
-  RelationsOutput,
-  StoredRelationDef,
-  ThroughRef,
-  // Schema types
-  SchemaDef,
-  SchemaInput,
-} from "./types.ts";
-
-export type { ValidationError } from "./validate.ts";
-
-// ─── Enum Factory ─────────────────────────────────
-
-/**
- * Creates an enum - either standalone (reusable) or inline (one-off)
- *
- * @example
- * // Standalone enum (reusable across models)
- * const Status = dsl.enum({ name: "Status", options: ["active", "inactive"] });
- * // Use in model: status: Status.field({ default: "active" })
- *
- * // Inline enum (one-off use)
- * priority: dsl.enum({ options: ["low", "medium", "high"], default: "medium" })
- */
-function enumFactory<const T extends readonly string[]>(
-  config: StandaloneEnumConfig<T>
-): EnumDef<T>;
-function enumFactory<const T extends readonly string[]>(config: InlineEnumConfig<T>): ChainableColumn<"enum">;
-function enumFactory<const T extends readonly string[]>(
-  config: StandaloneEnumConfig<T> | InlineEnumConfig<T>
-): EnumDef<T> | ChainableColumn<"enum"> {
-  // Standalone enum has 'name' property
-  if ("name" in config && typeof config.name === "string") {
-    return createEnum(config as StandaloneEnumConfig<T>);
-  }
-  // Inline enum
-  return enumCol(config as InlineEnumConfig<T>);
-}
-
-// ─── Main DSL Namespace ─────────────────────────────────
-
-/**
- * Main database schema DSL namespace
- */
-export const dsl = {
-  // Column types
-  string,
-  int,
-  bigint,
-  float,
-  decimal,
-  boolean,
-  datetime,
-  json,
-  id,
-  bytes,
-  unsupported,
-  enum: enumFactory,
-
-  // Model creation
-  create,
-
-  // Relations
-  defineRelations,
-  defineRelationsPart,
-  mergeRelations,
-
-  // Schema composition
-  schema,
-  domain,
-
-  // Validation
-  validateSchema,
-
-  // Generators
-  generate: Object.assign(
-    function generate(schemaDef: SchemaDef): { prisma?: string } {
-      return {
-        prisma: generatePrisma(schemaDef),
-      };
-    },
-    {
-      prisma: generatePrisma,
-    }
-  ),
-
-  // Templates
-  templates: {
-    base,
-    baseWithWorkspace,
-    withMetadata,
-    withActive,
-    withAudit,
-    withExternalId,
-    withNameDescription,
-    fields,
-  },
-};

package/src/model.ts

@@ -1,330 +0,0 @@
-/**
- * Model builder using dsl.create({ name, schema, indexes })
- *
- * v3: Models define ONLY columns (no inline relations)
- * Relations are defined separately via dsl.defineRelations()
- * Children (inline nested models) are still supported via schema callback
- *
- * @example
- * // Simple model - just columns
- * const Workspace = dsl.create({
- *   name: "Workspace",
- *   schema: {
- *     ...dsl.base,
- *     name: dsl.string(),
- *     slug: dsl.string({ unique: true }),
- *   },
- * });
- *
- * // Model with FK column (explicit) and type-safe indexes
- * const Printer = dsl.create({
- *   name: "Printer",
- *   schema: {
- *     ...dsl.base,
- *     name: dsl.string(),
- *     workspaceId: dsl.string({ index: true }),  // FK declared explicitly
- *   },
- *   // TypeScript suggests valid column names
- *   indexes: (i) => [
- *     i.unique("workspaceId", "name"),
- *   ],
- * });
- *
- * // Model with children (inline nested models)
- * const Order = dsl.create({
- *   name: "Order",
- *   schema: (s) => ({
- *     ...dsl.base,
- *     total: dsl.int(),
- *     Items: s.children({
- *       name: "OrderItem",
- *       schema: { id: dsl.id(), quantity: dsl.int() },
- *     }),
- *   }),
- * });
- */
-
-import type {
-  ChildrenBuilder,
-  ChildrenDef,
-  ChildrenSchemaCallback,
-  ColumnDef,
-  IndexBuilder,
-  IndexCallback,
-  IndexDef,
-  IndexOptions,
-  IndexType,
-  ModelDef,
-  SchemaDefinition,
-} from "./types.ts";
-import { cloneColumnDef } from "./column.ts";
-import { createChildrenBuilder } from "./relation.ts";
-
-// ─── Type Guards ─────────────────────────
-
-/**
- * Checks if a value is a ColumnDef
- */
-function isColumnDef(value: unknown): value is ColumnDef {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "__type" in value &&
-    value.__type === "column"
-  );
-}
-
-/**
- * Checks if a value is a ChildrenDef
- */
-function isChildrenDef(value: unknown): value is ChildrenDef {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "__type" in value &&
-    value.__type === "children"
-  );
-}
-
-// ─── Helpers ─────────────────────────────
-
-/**
- * Converts a model name to a FK column name
- * e.g., "Order" -> "orderId"
- */
-function toFkColumnName(modelName: string): string {
-  return modelName.charAt(0).toLowerCase() + modelName.slice(1) + "Id";
-}
-
-// ─── Index Builder ───────────────────────
-
-/**
- * Creates an IndexBuilder with type-safe column references
- *
- * @example
- * indexes: (i) => [
- *   i.on("workspaceId", "name"),     // Composite index
- *   i.unique("workspaceId", "email"), // Unique constraint
- *   i.on("status"),                   // Single column index
- *   i.gin("tags"),                    // GIN index for JSON/arrays
- *   i.on(["content"], { type: "Gist" }), // Index with type option
- * ]
- */
-export function createIndexBuilder<T extends string>(): IndexBuilder<T> {
-  // Helper to create index with optional type
-  const createIndex = (columns: string[], type?: IndexType): IndexDef => ({
-    __type: "index",
-    __columns: columns,
-    __indexType: type,
-  });
-
-  return {
-    /**
-     * Creates a composite index on the specified columns
-     * Optionally accepts an options object with index type
-     */
-    on<C extends T>(...args: C[] | [C[], IndexOptions]): IndexDef {
-      // Check if last arg is options object
-      if (args.length === 2 && Array.isArray(args[0]) && typeof args[1] === "object" && !Array.isArray(args[1])) {
-        const [columns, options] = args as [C[], IndexOptions];
-        return createIndex(columns, options.type);
-      }
-      // Normal variadic columns
-      return createIndex(args as string[]);
-    },
-
-    /**
-     * Creates a unique constraint on the specified columns
-     */
-    unique<C extends T>(...columns: C[]): IndexDef {
-      return {
-        __type: "unique",
-        __columns: columns,
-      };
-    },
-
-    /**
-     * Creates a GIN index (PostgreSQL) - good for JSON, arrays, full-text search
-     */
-    gin<C extends T>(...columns: C[]): IndexDef {
-      return createIndex(columns, "Gin");
-    },
-
-    /**
-     * Creates a GiST index (PostgreSQL) - good for geometric, range, and full-text data
-     */
-    gist<C extends T>(...columns: C[]): IndexDef {
-      return createIndex(columns, "Gist");
-    },
-
-    /**
-     * Creates a Hash index (PostgreSQL) - good for equality comparisons
-     */
-    hash<C extends T>(...columns: C[]): IndexDef {
-      return createIndex(columns, "Hash");
-    },
-
-    /**
-     * Creates a BRIN index (PostgreSQL) - good for large tables with naturally ordered data
-     */
-    brin<C extends T>(...columns: C[]): IndexDef {
-      return createIndex(columns, "Brin");
-    },
-  };
-}
-
-// ─── Schema Processing ───────────────────
-
-/**
- * Processes a schema definition and extracts columns and children
- * Note: Relations are no longer processed here - use defineRelations() instead
- */
-function processSchema(
-  modelName: string,
-  schema: SchemaDefinition | ChildrenSchemaCallback
-): {
-  columns: Map<string, ColumnDef>;
-  children: Map<string, ModelDef>;
-  resolvedSchema: SchemaDefinition;
-} {
-  // Resolve schema if it's a callback (for children support)
-  const resolvedSchema =
-    typeof schema === "function" ? schema(createChildrenBuilder()) : schema;
-
-  const columns = new Map<string, ColumnDef>();
-  const children = new Map<string, ModelDef>();
-
-  for (const [key, value] of Object.entries(resolvedSchema)) {
-    if (isColumnDef(value)) {
-      // Clone to avoid mutating shared instances (e.g., from templates)
-      const cloned = cloneColumnDef(value);
-      cloned.__name = key;
-      columns.set(key, cloned);
-    } else if (isChildrenDef(value)) {
-      // Create child model from children definition
-      const childModel = create({
-        name: value.__name,
-        schema: value.__schema,
-      });
-
-      // Add parent FK to child model
-      const parentFkName = toFkColumnName(modelName);
-      childModel.__columns.set(parentFkName, {
-        __type: "column",
-        __columnType: "string",
-        __name: parentFkName,
-        __config: {
-          index: true,
-        },
-      });
-
-      children.set(key, childModel);
-    }
-  }
-
-  return { columns, children, resolvedSchema };
-}
-
-// ─── Type Helpers ────────────────────────
-
-/**
- * Extract keys from schema where value is a ColumnDef (excludes ChildrenDef)
- */
-export type ColumnKeys<T> = {
-  [K in keyof T]: T[K] extends ColumnDef ? K : never;
-}[keyof T];
-
-/**
- * All valid column names for indexes
- */
-export type SchemaColumnNames<T> = Extract<ColumnKeys<T>, string>;
-
-// ─── Model Config ────────────────────────
-
-/**
- * Config for dsl.create() with type-safe indexes
- */
-export type CreateModelConfig<
-  TSchema extends SchemaDefinition,
-  TColumns extends string = SchemaColumnNames<TSchema>,
-> = {
-  name: string;
-  schema: TSchema | ((s: ChildrenBuilder) => TSchema);
-  indexes?: IndexCallback<TColumns>;
-  /** Map to a different database table name - generates @@map("table_name") */
-  map?: string;
-  /** Compound primary key columns - generates @@id([col1, col2]) */
-  primaryKey?: TColumns[];
-};
-
-// ─── Model Factory ───────────────────────
-
-/**
- * Creates a model definition with type-safe indexes
- *
- * v3: Models only contain columns and children.
- * Relations are defined separately via dsl.defineRelations()
- *
- * @example
- * // Simple model
- * const User = dsl.create({
- *   name: "User",
- *   schema: {
- *     ...dsl.base,
- *     email: dsl.string({ unique: true }),
- *     workspaceId: dsl.string({ index: true }),  // FK declared explicitly
- *   },
- * });
- *
- * // Model with children
- * const Order = dsl.create({
- *   name: "Order",
- *   schema: (s) => ({
- *     ...dsl.base,
- *     Items: s.children({
- *       name: "OrderItem",
- *       schema: { id: dsl.id(), qty: dsl.int() },
- *     }),
- *   }),
- * });
- */
-export function create<
-  const TSchema extends SchemaDefinition,
-  TColumns extends string = SchemaColumnNames<TSchema>,
->(config: CreateModelConfig<TSchema, TColumns>): ModelDef<TSchema> {
-  const { columns, children } = processSchema(config.name, config.schema);
-
-  const model: ModelDef<TSchema> = {
-    __type: "model",
-    __name: config.name,
-    __schema: config.schema,
-    __indexes: config.indexes as IndexCallback | undefined,
-    __columns: columns,
-    __children: children,
-    __map: config.map,
-    __primaryKey: config.primaryKey as string[] | undefined,
-  };
-
-  return model;
-}
-
-// ─── Model Utilities ─────────────────────
-
-/**
- * Gets all column names from a model (for index builder)
- */
-export function getColumnNames(model: ModelDef): string[] {
-  return Array.from(model.__columns.keys());
-}
-
-/**
- * Evaluates index definitions for a model
- */
-export function evaluateIndexes(model: ModelDef): IndexDef[] {
-  if (!model.__indexes) {
-    return [];
-  }
-
-  const indexBuilder = createIndexBuilder<string>();
-  return model.__indexes(indexBuilder);
-}

package/src/relation.ts

@@ -1,75 +0,0 @@
-/**
- * Children builder for inline nested models
- *
- * v3: Relations are now defined separately via dsl.defineRelations()
- * This module only provides the children() builder for inline nested models
- *
- * @example
- * const Order = dsl.create({
- *   name: "Order",
- *   schema: (s) => ({
- *     ...dsl.base,
- *     total: dsl.int(),
- *     Items: s.children({
- *       name: "OrderItem",
- *       schema: {
- *         ...dsl.base,
- *         productId: dsl.string(),
- *         quantity: dsl.int(),
- *       },
- *     }),
- *   }),
- * });
- */
-
-import type {
-  ChildrenBuilder,
-  ChildrenDef,
-  ChildrenRelationConfig,
-} from "./types.ts";
-
-// ─── Children Builder ─────────────────────
-
-/**
- * Creates an inline child model
- * Generates a separate model with automatic FK back to parent
- *
- * @example
- * Files: s.children({
- *   name: "PrintJobFile",
- *   schema: {
- *     ...dsl.base,
- *     fileUrl: dsl.string(),
- *     fileName: dsl.string(),
- *   },
- * })
- *
- * // Or with nested children:
- * Activities: s.children({
- *   name: "PrintJobActivity",
- *   schema: (s2) => ({
- *     ...dsl.base,
- *     type: dsl.string(),
- *     Logs: s2.children({
- *       name: "ActivityLog",
- *       schema: { id: dsl.id(), message: dsl.string() },
- *     }),
- *   }),
- * })
- */
-export function children(config: ChildrenRelationConfig): ChildrenDef {
-  return {
-    __type: "children",
-    __name: config.name,
-    __schema: config.schema,
-  };
-}
-
-/**
- * Creates a ChildrenBuilder for use in schema callbacks
- */
-export function createChildrenBuilder(): ChildrenBuilder {
-  return {
-    children,
-  };
-}