@vibeorm/dsl 0.3.0 → 2.0.0-alpha.1

package/src/types.ts

@@ -1,381 +0,0 @@
-/**
- * Core types for @vibeorm/dsl
- *
- * v3 Changes:
- * - Relations are now defined separately via defineRelations()
- * - Models only contain columns (and children for inline nested models)
- * - Full type-safety for relation column references
- */
-
-// ─── Column Types ─────────────────────────
-
-export type ColumnType =
-  | "string"
-  | "int"
-  | "bigint"
-  | "float"
-  | "decimal"
-  | "boolean"
-  | "datetime"
-  | "json"
-  | "id"
-  | "bytes"
-  | "enum"
-  | "unsupported";
-
-export type IdGeneratorType = "ulid" | "cuid" | "uuid" | "autoincrement" | "none";
-
-export type CascadeAction = "Cascade" | "Restrict" | "NoAction" | "SetNull" | "SetDefault";
-
-/** PostgreSQL index types supported by Prisma */
-export type IndexType = "BTree" | "Hash" | "Gin" | "Gist" | "SpGist" | "Brin";
-
-/** Base column config options */
-export type BaseColumnConfig = {
-  optional?: boolean;
-  index?: boolean;
-  unique?: boolean;
-  array?: boolean;
-  map?: string; // @map("column_name") - map to different database column name
-  dbgenerated?: string; // @default(dbgenerated("...")) - database-native default
-  comment?: string; // Generates /// comment above column in Prisma (for Zod generators, docs, etc.)
-  [key: string]: unknown;
-};
-
-export type StringColumnConfig = BaseColumnConfig & {
-  default?: string;
-  maxLength?: number; // @db.VarChar(n)
-  text?: boolean; // @db.Text
-};
-
-export type IntColumnConfig = BaseColumnConfig & {
-  default?: number;
-};
-
-export type FloatColumnConfig = BaseColumnConfig & {
-  default?: number;
-};
-
-export type DecimalColumnConfig = BaseColumnConfig & {
-  default?: string;
-  precision?: number; // @db.Decimal(precision, scale)
-  scale?: number; // @db.Decimal(precision, scale)
-};
-
-export type BooleanColumnConfig = BaseColumnConfig & {
-  default?: boolean;
-};
-
-export type DatetimeColumnConfig = BaseColumnConfig & {
-  default?: "now";
-  updatedAt?: boolean;
-  tz?: boolean;
-};
-
-export type JsonColumnConfig = BaseColumnConfig & {
-  default?: unknown;
-};
-
-export type IdColumnConfig = BaseColumnConfig & {
-  type?: IdGeneratorType;
-};
-
-export type BytesColumnConfig = BaseColumnConfig;
-
-export type BigIntColumnConfig = BaseColumnConfig & {
-  default?: bigint | number;
-};
-
-export type UnsupportedColumnConfig = BaseColumnConfig & {
-  dbType: string; // The raw database type string, e.g. "tsvector", "geometry(Point, 4326)"
-};
-
-/** v2: Object-based enum config */
-export type InlineEnumConfig<T extends readonly string[] = readonly string[]> =
-  BaseColumnConfig & {
-    options: T;
-    default?: T[number];
-  };
-
-// ─── Standalone Enum Types ────────────────
-
-export type EnumFieldConfig<T extends readonly string[] = readonly string[]> =
-  BaseColumnConfig & {
-    default?: T[number];
-  };
-
-/**
- * EnumDef represents a standalone enum.
- * The field() method returns a ChainableEnumColumn that supports full method chaining.
- */
-export type EnumDef<T extends readonly string[] = readonly string[]> = {
-  __type: "enum";
-  __name: string;
-  __options: T;
-  // Returns a chainable column with full support for .optional(), .index(), .default()
-  field(config?: EnumFieldConfig<T>): ChainableEnumColumn<T>;
-};
-
-/**
- * Chainable enum column type for proper type inference with method chaining.
- * This mirrors ChainableColumn but with proper default typing for enums.
- */
-export type ChainableEnumColumn<T extends readonly string[] = readonly string[]> =
-  ColumnDef<"enum"> & {
-    optional(): ChainableEnumColumn<T>;
-    index(): ChainableEnumColumn<T>;
-    unique(): ChainableEnumColumn<T>;
-    array(): ChainableEnumColumn<T>;
-    default(value: T[number]): ChainableEnumColumn<T>;
-  };
-
-// ─── Column Definition ────────────────────
-
-export type ColumnDef<T extends ColumnType = ColumnType> = {
-  __type: "column";
-  __columnType: T;
-  __name?: string;
-  __config: BaseColumnConfig;
-  __enumValues?: readonly string[];
-  __enumName?: string; // Reference to standalone enum name
-};
-
-// ─── Children Types ───────────────────────
-
-export type ChildrenRelationConfig = {
-  name: string;
-  schema: SchemaDefinition | ChildrenSchemaCallback;
-};
-
-export type ChildrenDef = {
-  __type: "children";
-  __name: string;
-  __schema: SchemaDefinition | ChildrenSchemaCallback;
-};
-
-// ─── Model Types ──────────────────────────
-
-/** Schema can contain columns and children (no inline relations in v3) */
-export type SchemaDefinition = Record<string, ColumnDef | ChildrenDef>;
-export type ChildrenSchemaCallback = (s: ChildrenBuilder) => SchemaDefinition;
-
-/** Children builder - only has children() method */
-export type ChildrenBuilder = {
-  children(config: ChildrenRelationConfig): ChildrenDef;
-};
-
-export type IndexDef = {
-  __type: "index" | "unique";
-  __columns: string[];
-  __indexType?: IndexType; // PostgreSQL index type (Gin, Gist, Hash, etc.)
-};
-
-// ─── Type-Safe Index Builder ──────────────
-
-/** Index options for specifying type */
-export type IndexOptions = {
-  type?: IndexType;
-};
-
-/** Generic index builder that only allows valid column names */
-export type IndexBuilder<TColumns extends string = string> = {
-  on<T extends TColumns>(...columns: T[]): IndexDef;
-  on<T extends TColumns>(columns: T[], options: IndexOptions): IndexDef;
-  unique<T extends TColumns>(...columns: T[]): IndexDef;
-  // Convenience methods for typed indexes (PostgreSQL)
-  gin<T extends TColumns>(...columns: T[]): IndexDef;
-  gist<T extends TColumns>(...columns: T[]): IndexDef;
-  hash<T extends TColumns>(...columns: T[]): IndexDef;
-  brin<T extends TColumns>(...columns: T[]): IndexDef;
-};
-
-/** Index callback type - generic over column names */
-export type IndexCallback<TColumns extends string = string> = (
-  i: IndexBuilder<TColumns>
-) => IndexDef[];
-
-// ─── Model Definition ─────────────────────
-
-/** Generic ModelDef that preserves schema type for type-safe relations */
-export type ModelDef<TSchema extends SchemaDefinition = SchemaDefinition> = {
-  __type: "model";
-  __name: string;
-  __schema: TSchema | ChildrenSchemaCallback;
-  __indexes?: IndexCallback;
-  __columns: Map<string, ColumnDef>;
-  __children: Map<string, ModelDef>;
-  __map?: string; // @@map("table_name") - map to different database table name
-  __primaryKey?: string[]; // @@id([col1, col2]) - compound primary key
-  // Note: __relations removed - now defined separately via defineRelations()
-};
-
-// ─── Relations Types (v3 - Drizzle-style) ─
-
-/**
- * Column reference - points to Model.column
- * Used in defineRelations() for type-safe from/to references
- */
-export type ColumnRef<
-  TModel extends string = string,
-  TColumn extends string = string,
-> = {
-  __type: "columnRef";
-  __model: TModel;
-  __column: TColumn;
-  through<TJunction extends string, TJunctionCol extends string>(
-    junction: ColumnRef<TJunction, TJunctionCol>
-  ): ThroughRef<TModel, TColumn, TJunction, TJunctionCol>;
-};
-
-/**
- * Through reference for many-to-many relations via junction table
- */
-export type ThroughRef<
-  TModel extends string = string,
-  TColumn extends string = string,
-  TJunction extends string = string,
-  TJunctionCol extends string = string,
-> = {
-  __type: "throughRef";
-  __model: TModel;
-  __column: TColumn;
-  __junction: TJunction;
-  __junctionColumn: TJunctionCol;
-};
-
-/**
- * Config for r.one.ModelName({ from, to })
- */
-export type OneRelationDefConfig<
-  TFrom extends ColumnRef | ThroughRef = ColumnRef,
-  TTo extends ColumnRef | ThroughRef = ColumnRef,
-> = {
-  from: TFrom;
-  to: TTo;
-  optional?: boolean;
-  alias?: string;
-  onDelete?: CascadeAction; // Referential action on delete
-  onUpdate?: CascadeAction; // Referential action on update
-};
-
-/**
- * Config for r.many.ModelName({ from, to })
- */
-export type ManyRelationDefConfig<
-  TFrom extends ColumnRef | ThroughRef = ColumnRef | ThroughRef,
-  TTo extends ColumnRef | ThroughRef = ColumnRef | ThroughRef,
-> = {
-  from: TFrom;
-  to: TTo;
-  optional?: boolean;
-  alias?: string;
-  onDelete?: CascadeAction; // Referential action on delete
-  onUpdate?: CascadeAction; // Referential action on update
-};
-
-/**
- * Stored relation definition (output of defineRelations)
- */
-export type StoredRelationDef = {
-  __type: "storedRelation";
-  __relationType: "one" | "many";
-  __targetModel: string;
-  __fromModel: string;
-  __fromColumn: string;
-  __toModel: string;
-  __toColumn: string;
-  __throughJunction?: string;
-  __throughFromCol?: string;
-  __throughToCol?: string;
-  __optional: boolean;
-  __alias?: string;
-  __onDelete?: CascadeAction; // Referential action on delete
-  __onUpdate?: CascadeAction; // Referential action on update
-};
-
-/**
- * Relations map: { ModelName: { relationName: StoredRelationDef } }
- */
-export type RelationsMap = Record<string, Record<string, StoredRelationDef>>;
-
-// ─── Relations Builder Types ──────────────
-
-/**
- * Extract column names from a ModelDef's __columns Map
- * This is done at runtime, so we need to encode it in the type system
- */
-export type ExtractModelColumns<T> = T extends ModelDef<infer TSchema>
-  ? Extract<keyof TSchema, string>
-  : never;
-
-/**
- * Relations builder passed to defineRelations callback
- * Provides r.one, r.many, and r.ModelName.columnName access
- */
-export type RelationsBuilder<TSchema extends Record<string, ModelDef>> = {
-  // r.one.ModelName({ from, to }) - creates one-to-one or many-to-one
-  one: {
-    [K in keyof TSchema & string]: <
-      TFrom extends ColumnRef | ThroughRef,
-      TTo extends ColumnRef | ThroughRef,
-    >(
-      config: OneRelationDefConfig<TFrom, TTo>
-    ) => StoredRelationDef;
-  };
-
-  // r.many.ModelName({ from, to }) - creates one-to-many or many-to-many
-  many: {
-    [K in keyof TSchema & string]: <
-      TFrom extends ColumnRef | ThroughRef,
-      TTo extends ColumnRef | ThroughRef,
-    >(
-      config: ManyRelationDefConfig<TFrom, TTo>
-    ) => StoredRelationDef;
-  };
-} & {
-  // r.ModelName.columnName - column references for from/to
-  [K in keyof TSchema & string]: ModelColumnRefs<K, TSchema[K]>;
-};
-
-/**
- * Column references for a specific model
- * r.User.id, r.User.email, etc.
- */
-export type ModelColumnRefs<
-  TModelName extends string,
-  TModel extends ModelDef,
-> = {
-  [C in ExtractModelColumns<TModel>]: ColumnRef<TModelName, C>;
-};
-
-/**
- * Output type of defineRelations callback
- */
-export type RelationsOutput<TSchema extends Record<string, ModelDef>> = {
-  [K in keyof TSchema]?: Record<string, StoredRelationDef>;
-};
-
-// ─── Schema Types ─────────────────────────
-
-export type SchemaInput = Record<string, ModelDef | EnumDef | Record<string, ModelDef | EnumDef>>;
-
-export type SchemaDef = {
-  __type: "schema";
-  __models: Map<string, ModelDef>;
-  __enums: Map<string, readonly string[]>;
-  __relations: RelationsMap;
-};
-
-// ─── Generator Types ──────────────────────
-
-export type PrismaGeneratorConfig = {
-  output?: string;
-};
-
-export type GeneratorConfig = {
-  prisma?: PrismaGeneratorConfig;
-};
-
-export type GeneratorOutput = {
-  prisma?: string;
-};

package/src/validate.ts

@@ -1,141 +0,0 @@
-/**
- * Schema validation for @vibeorm/dsl
- *
- * Validates a SchemaDef for common issues before generation:
- * - Duplicate model/enum names
- * - Missing FK columns referenced in relations
- * - Relation alias consistency (matching aliases on both sides)
- * - Self-referential relations without aliases
- *
- * @example
- * const schema = dsl.schema({ User, Post }, { relations });
- * const errors = validateSchema(schema);
- * if (errors.length > 0) {
- *   console.error("Schema validation failed:", errors);
- * }
- */
-
-import type { SchemaDef, StoredRelationDef } from "./types.ts";
-
-// ─── Types ─────────────────────────────────
-
-export type ValidationError = {
-  type: "error" | "warning";
-  message: string;
-  model?: string;
-  relation?: string;
-};
-
-// ─── Validation ─────────────────────────────
-
-/**
- * Validates a SchemaDef and returns any issues found.
- * Returns an empty array if the schema is valid.
- */
-export function validateSchema(schema: SchemaDef): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  // 1. Check for model/enum name collisions
-  const allNames = new Set<string>();
-  for (const [name] of schema.__models) {
-    if (allNames.has(name)) {
-      errors.push({
-        type: "error",
-        message: `Duplicate name "${name}" - used by both a model and enum/model`,
-        model: name,
-      });
-    }
-    allNames.add(name);
-  }
-  for (const [name] of schema.__enums) {
-    if (allNames.has(name)) {
-      errors.push({
-        type: "error",
-        message: `Duplicate name "${name}" - used by both a model and enum`,
-      });
-    }
-    allNames.add(name);
-  }
-
-  // 2. Validate relations
-  for (const [modelName, modelRelations] of Object.entries(schema.__relations)) {
-    // Check model exists
-    if (!schema.__models.has(modelName)) {
-      errors.push({
-        type: "error",
-        message: `Relations defined for unknown model "${modelName}"`,
-        model: modelName,
-      });
-      continue;
-    }
-
-    const model = schema.__models.get(modelName)!;
-
-    for (const [relName, rel] of Object.entries(modelRelations)) {
-      // Check target model exists
-      if (!schema.__models.has(rel.__targetModel)) {
-        errors.push({
-          type: "error",
-          message: `Relation "${relName}" references unknown model "${rel.__targetModel}"`,
-          model: modelName,
-          relation: relName,
-        });
-        continue;
-      }
-
-      // For "one" relations that own the FK, check FK column exists
-      if (rel.__relationType === "one" && rel.__fromModel === modelName) {
-        if (!model.__columns.has(rel.__fromColumn)) {
-          errors.push({
-            type: "error",
-            message: `Relation "${relName}" references FK column "${rel.__fromColumn}" which doesn't exist on model "${modelName}"`,
-            model: modelName,
-            relation: relName,
-          });
-        }
-
-        // Check target column exists
-        const targetModel = schema.__models.get(rel.__targetModel);
-        if (targetModel && !targetModel.__columns.has(rel.__toColumn)) {
-          errors.push({
-            type: "error",
-            message: `Relation "${relName}" references column "${rel.__toColumn}" which doesn't exist on target model "${rel.__targetModel}"`,
-            model: modelName,
-            relation: relName,
-          });
-        }
-      }
-
-      // Warn about self-referential relations without aliases
-      if (rel.__targetModel === modelName && !rel.__alias) {
-        const otherSelfRels = Object.values(modelRelations).filter(
-          (r): r is StoredRelationDef =>
-            r.__targetModel === modelName && r !== rel
-        );
-        if (otherSelfRels.length > 0) {
-          errors.push({
-            type: "warning",
-            message: `Self-referential relation "${relName}" on "${modelName}" has no alias - this may cause Prisma ambiguity`,
-            model: modelName,
-            relation: relName,
-          });
-        }
-      }
-    }
-  }
-
-  // 3. Check for models with no id column and no primaryKey override
-  for (const [modelName, model] of schema.__models) {
-    const hasIdCol = Array.from(model.__columns.values()).some(col => col.__columnType === "id");
-    const hasPrimaryKey = model.__primaryKey && model.__primaryKey.length > 0;
-    if (!hasIdCol && !hasPrimaryKey) {
-      errors.push({
-        type: "warning",
-        message: `Model "${modelName}" has no id column and no compound primaryKey defined`,
-        model: modelName,
-      });
-    }
-  }
-
-  return errors;
-}