@vibeorm/dsl 0.4.0 → 2.0.0-alpha.1

package/src/relations.ts

@@ -1,293 +0,0 @@
-/**
- * Drizzle-style centralized relations for @vibeorm/dsl
- *
- * @example
- * const relations = dsl.defineRelations({ User, Post }, (r) => ({
- *   User: {
- *     posts: r.many.Post({
- *       from: r.User.id,
- *       to: r.Post.authorId,
- *     }),
- *   },
- *   Post: {
- *     author: r.one.User({
- *       from: r.Post.authorId,
- *       to: r.User.id,
- *     }),
- *   },
- * }));
- */
-
-import type {
-  ColumnRef,
-  ManyRelationDefConfig,
-  ModelDef,
-  OneRelationDefConfig,
-  RelationsBuilder,
-  RelationsMap,
-  RelationsOutput,
-  StoredRelationDef,
-  ThroughRef,
-} from "./types.ts";
-
-// ─── Column Ref Factory ─────────────────────
-
-/**
- * Creates a ColumnRef with the through() method for many-to-many relations
- */
-function createColumnRef<TModel extends string, TColumn extends string>(
-  model: TModel,
-  column: TColumn
-): ColumnRef<TModel, TColumn> {
-  return {
-    __type: "columnRef",
-    __model: model,
-    __column: column,
-    through<TJunction extends string, TJunctionCol extends string>(
-      junction: ColumnRef<TJunction, TJunctionCol>
-    ): ThroughRef<TModel, TColumn, TJunction, TJunctionCol> {
-      return {
-        __type: "throughRef",
-        __model: model,
-        __column: column,
-        __junction: junction.__model,
-        __junctionColumn: junction.__column,
-      };
-    },
-  };
-}
-
-// ─── Ref Extraction ─────────────────────
-
-/**
- * Extracts info from a ColumnRef or ThroughRef
- */
-function extractRefInfo(ref: ColumnRef | ThroughRef): {
-  model: string;
-  column: string;
-  junction?: string;
-  junctionColumn?: string;
-} {
-  if (ref.__type === "throughRef") {
-    return {
-      model: ref.__model,
-      column: ref.__column,
-      junction: ref.__junction,
-      junctionColumn: ref.__junctionColumn,
-    };
-  }
-  return {
-    model: ref.__model,
-    column: ref.__column,
-  };
-}
-
-// ─── Relation Factory ─────────────────────
-
-/**
- * Creates a relation builder factory for one() or many()
- */
-function createRelationFactory(
-  relationType: "one" | "many",
-  targetModelName: string
-): (config: OneRelationDefConfig | ManyRelationDefConfig) => StoredRelationDef {
-  return (config) => {
-    const from = extractRefInfo(config.from);
-    const to = extractRefInfo(config.to);
-
-    // Determine through junction info (for many-to-many)
-    let throughJunction: string | undefined;
-    let throughFromCol: string | undefined;
-    let throughToCol: string | undefined;
-
-    if (config.from.__type === "throughRef") {
-      throughJunction = config.from.__junction;
-      throughFromCol = config.from.__junctionColumn;
-    }
-    if (config.to.__type === "throughRef") {
-      // If both have through, they should use the same junction
-      if (!throughJunction) {
-        throughJunction = config.to.__junction;
-      }
-      throughToCol = config.to.__junctionColumn;
-    }
-
-    return {
-      __type: "storedRelation",
-      __relationType: relationType,
-      __targetModel: targetModelName,
-      __fromModel: from.model,
-      __fromColumn: from.column,
-      __toModel: to.model,
-      __toColumn: to.column,
-      __throughJunction: throughJunction,
-      __throughFromCol: throughFromCol,
-      __throughToCol: throughToCol,
-      __optional: config.optional ?? (relationType === "one" ? false : true),
-      __alias: config.alias,
-      __onDelete: config.onDelete,
-      __onUpdate: config.onUpdate,
-    };
-  };
-}
-
-// ─── Relations Builder ─────────────────────
-
-/**
- * Creates the relations builder with r.one, r.many, and r.ModelName.columnName
- */
-function createRelationsBuilder<TSchema extends Record<string, ModelDef>>(
-  schema: TSchema
-): RelationsBuilder<TSchema> {
-  const builder = {} as RelationsBuilder<TSchema>;
-
-  // Create r.one and r.many objects
-  const oneObj: Record<string, (config: OneRelationDefConfig) => StoredRelationDef> = {};
-  const manyObj: Record<string, (config: ManyRelationDefConfig) => StoredRelationDef> = {};
-
-  for (const modelName of Object.keys(schema)) {
-    // r.one.ModelName
-    oneObj[modelName] = createRelationFactory("one", modelName);
-    // r.many.ModelName
-    manyObj[modelName] = createRelationFactory("many", modelName);
-
-    // r.ModelName.columnName - create column references
-    const model = schema[modelName];
-    if (!model) continue;
-
-    const columnRefs: Record<string, ColumnRef> = {};
-
-    // Get column names from the model's __columns Map
-    for (const [colName] of model.__columns) {
-      columnRefs[colName] = createColumnRef(modelName, colName);
-    }
-
-    // Also add column names from children if they have auto-generated FKs
-    for (const [, childModel] of model.__children) {
-      // Child models have parentId FK - we might want to expose this
-      // For now, children are separate models so we don't add them here
-    }
-
-    // Assign column refs to builder (r.ModelName)
-    (builder as Record<string, unknown>)[modelName] = columnRefs;
-  }
-
-  (builder as Record<string, unknown>).one = oneObj;
-  (builder as Record<string, unknown>).many = manyObj;
-
-  return builder;
-}
-
-// ─── Relations Processing ─────────────────────
-
-/**
- * Processes the callback output into a RelationsMap
- */
-function processRelationsOutput<TSchema extends Record<string, ModelDef>>(
-  output: RelationsOutput<TSchema>
-): RelationsMap {
-  const result: RelationsMap = {};
-
-  for (const [modelName, relations] of Object.entries(output)) {
-    if (relations) {
-      result[modelName] = relations;
-    }
-  }
-
-  return result;
-}
-
-// ─── Public API ─────────────────────
-
-/**
- * Define all relations for a schema in one place
- *
- * @example
- * const relations = dsl.defineRelations({ User, Post, Comment }, (r) => ({
- *   User: {
- *     posts: r.many.Post({
- *       from: r.User.id,
- *       to: r.Post.authorId,
- *     }),
- *   },
- *   Post: {
- *     author: r.one.User({
- *       from: r.Post.authorId,
- *       to: r.User.id,
- *     }),
- *     comments: r.many.Comment({
- *       from: r.Post.id,
- *       to: r.Comment.postId,
- *     }),
- *   },
- *   Comment: {
- *     post: r.one.Post({
- *       from: r.Comment.postId,
- *       to: r.Post.id,
- *     }),
- *   },
- * }));
- */
-export function defineRelations<TSchema extends Record<string, ModelDef>>(
-  schema: TSchema,
-  callback: (r: RelationsBuilder<TSchema>) => RelationsOutput<TSchema>
-): RelationsMap {
-  const builder = createRelationsBuilder(schema);
-  const output = callback(builder);
-  return processRelationsOutput(output);
-}
-
-/**
- * Define a partial set of relations (for splitting into multiple files)
- *
- * @example
- * // user-relations.ts
- * export const userRelations = dsl.defineRelationsPart({ User, Post }, (r) => ({
- *   User: {
- *     posts: r.many.Post({ from: r.User.id, to: r.Post.authorId }),
- *   },
- * }));
- *
- * // post-relations.ts
- * export const postRelations = dsl.defineRelationsPart({ User, Post }, (r) => ({
- *   Post: {
- *     author: r.one.User({ from: r.Post.authorId, to: r.User.id }),
- *   },
- * }));
- *
- * // Merge in main file
- * const allRelations = { ...userRelations, ...postRelations };
- */
-export function defineRelationsPart<TSchema extends Record<string, ModelDef>>(
-  schema: TSchema,
-  callback: (r: RelationsBuilder<TSchema>) => Partial<RelationsOutput<TSchema>>
-): RelationsMap {
-  const builder = createRelationsBuilder(schema);
-  const output = callback(builder);
-  return processRelationsOutput(output as RelationsOutput<TSchema>);
-}
-
-/**
- * Merge multiple relation parts into a single RelationsMap
- *
- * @example
- * const allRelations = dsl.mergeRelations(
- *   userRelations,
- *   postRelations,
- *   commentRelations,
- * );
- */
-export function mergeRelations(...parts: RelationsMap[]): RelationsMap {
-  const result: RelationsMap = {};
-
-  for (const part of parts) {
-    for (const [modelName, relations] of Object.entries(part)) {
-      if (!result[modelName]) {
-        result[modelName] = {};
-      }
-      Object.assign(result[modelName], relations);
-    }
-  }
-
-  return result;
-}

package/src/schema.ts

@@ -1,184 +0,0 @@
-/**
- * Schema composer for combining models and relations
- *
- * v3: Relations are now passed separately via options
- *
- * @example
- * // Define models
- * const models = { Workspace, User, Printer };
- *
- * // Define relations separately
- * const relations = dsl.defineRelations(models, (r) => ({
- *   User: {
- *     workspace: r.one.Workspace({ from: r.User.workspaceId, to: r.Workspace.id }),
- *   },
- * }));
- *
- * // Create schema with relations
- * const schema = dsl.schema(models, { relations });
- *
- * @example
- * // Grouped by domain
- * const schema = dsl.schema({
- *   Workspace,
- *   shipping: { Carrier, CarrierService },
- *   printing: { Account: PrintingAccount, Job: PrintJob },
- * }, { relations });
- *
- * @example
- * // With standalone enums
- * const Status = dsl.enum({ name: "Status", options: ["active", "inactive"] });
- * const schema = dsl.schema({
- *   Status,  // Standalone enums can be included
- *   User,
- * }, { relations });
- */
-
-import type { EnumDef, ModelDef, RelationsMap, SchemaDef, SchemaInput } from "./types.ts";
-
-// ─── Types ─────────────────────────────────
-
-/**
- * Options for schema creation
- */
-export type SchemaOptions = {
-  /** Relations defined via dsl.defineRelations() */
-  relations?: RelationsMap;
-};
-
-// ─── Type Guards ─────────────────────────────────
-
-/**
- * Checks if a value is a ModelDef
- */
-function isModelDef(value: unknown): value is ModelDef {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "__type" in value &&
-    value.__type === "model"
-  );
-}
-
-/**
- * Checks if a value is an EnumDef (standalone enum)
- */
-function isEnumDef(value: unknown): value is EnumDef {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "__type" in value &&
-    value.__type === "enum"
-  );
-}
-
-// ─── Extraction Helpers ─────────────────────────────────
-
-/**
- * Recursively extracts all models and standalone enums from schema input
- */
-function extractModelsAndEnums(params: {
-  input: SchemaInput;
-  models: Map<string, ModelDef>;
-  standaloneEnums: Map<string, readonly string[]>;
-}): void {
-  const { input, models, standaloneEnums } = params;
-
-  for (const [key, value] of Object.entries(input)) {
-    if (isModelDef(value)) {
-      models.set(value.__name, value);
-
-      // Also add any child models
-      for (const [childKey, childModel] of value.__children) {
-        models.set(childModel.__name, childModel);
-      }
-    } else if (isEnumDef(value)) {
-      // Standalone enum
-      standaloneEnums.set(value.__name, value.__options);
-    } else if (typeof value === "object" && value !== null) {
-      // Nested group
-      extractModelsAndEnums({
-        input: value as SchemaInput,
-        models,
-        standaloneEnums,
-      });
-    }
-  }
-}
-
-/**
- * Extracts all unique enum values from models (for inline enums)
- */
-function extractInlineEnums(params: {
-  models: Map<string, ModelDef>;
-  standaloneEnums: Map<string, readonly string[]>;
-}): Map<string, readonly string[]> {
-  const { models, standaloneEnums } = params;
-  const enums = new Map<string, readonly string[]>(standaloneEnums);
-
-  for (const [modelName, model] of models) {
-    for (const [colName, column] of model.__columns) {
-      if (column.__columnType === "enum" && column.__enumValues) {
-        // Check if this is a standalone enum reference
-        if (column.__enumName) {
-          // Already has a name (standalone enum) - ensure it's in the map
-          if (!enums.has(column.__enumName)) {
-            enums.set(column.__enumName, column.__enumValues);
-          }
-        } else {
-          // Inline enum - generate name: ModelNameColumnName
-          const enumName = `${modelName}${colName.charAt(0).toUpperCase()}${colName.slice(1)}`;
-          enums.set(enumName, column.__enumValues);
-
-          // Store enum name reference on column for generator
-          column.__enumName = enumName;
-        }
-      }
-    }
-  }
-
-  return enums;
-}
-
-// ─── Public API ─────────────────────────────────
-
-/**
- * Creates a schema from models and relations
- *
- * @param input - Models to include (can be nested/grouped)
- * @param options - Options including relations from defineRelations()
- */
-export function schema(input: SchemaInput, options?: SchemaOptions): SchemaDef {
-  const models = new Map<string, ModelDef>();
-  const standaloneEnums = new Map<string, readonly string[]>();
-
-  extractModelsAndEnums({ input, models, standaloneEnums });
-
-  const enums = extractInlineEnums({ models, standaloneEnums });
-
-  return {
-    __type: "schema",
-    __models: models,
-    __enums: enums,
-    __relations: options?.relations ?? {},
-  };
-}
-
-/**
- * Creates a domain group for organizing models
- *
- * @example
- * const shippingDomain = dsl.domain({
- *   name: "Shipping",
- *   models: { Carrier, CarrierService },
- * });
- */
-export function domain(params: {
-  name: string;
-  models: Record<string, ModelDef>;
-}): { name: string; models: Record<string, ModelDef> } {
-  return {
-    name: params.name,
-    models: params.models,
-  };
-}

package/src/templates.ts

@@ -1,134 +0,0 @@
-/**
- * Built-in templates for common schema patterns
- *
- * Templates use getters so that each spread produces fresh column instances,
- * preventing shared mutable state across models.
- *
- * @example
- * import { dsl } from "@vibeorm/dsl";
- *
- * const User = dsl.create({
- *   name: "User",
- *   schema: {
- *     ...dsl.templates.base,
- *     ...dsl.templates.withMetadata,
- *     email: dsl.string({ unique: true }),
- *   },
- * });
- */
-
-import { boolean, datetime, id, json, string } from "./column.ts";
-
-// ─── Base Templates ─────────────────────
-
-/**
- * Standard base fields for all models
- * - id: ULID primary key
- * - createdAt: Creation timestamp
- * - updatedAt: Last update timestamp
- * - deletedAt: Soft delete timestamp (optional)
- *
- * Uses getters to return fresh instances on each spread.
- */
-export const base = {
-  get id() { return id({ type: "ulid" }); },
-  get createdAt() { return datetime({ default: "now", tz: true, index: true }); },
-  get updatedAt() { return datetime({ default: "now", updatedAt: true, tz: true, index: true }); },
-  get deletedAt() { return datetime({ optional: true, index: true }); },
-};
-
-/**
- * Base fields with workspace association
- */
-export const baseWithWorkspace = {
-  get id() { return id({ type: "ulid" }); },
-  get createdAt() { return datetime({ default: "now", tz: true, index: true }); },
-  get updatedAt() { return datetime({ default: "now", updatedAt: true, tz: true, index: true }); },
-  get deletedAt() { return datetime({ optional: true, index: true }); },
-  get workspaceId() { return string({ index: true }); },
-};
-
-// ─── Mixin Templates ─────────────────────
-
-/**
- * Metadata fields for storing arbitrary JSON data
- */
-export const withMetadata = {
-  get metadata() { return json({ optional: true }); },
-  get settings() { return json({ optional: true }); },
-};
-
-/**
- * Active/inactive status field
- */
-export const withActive = {
-  get isActive() { return boolean({ default: true }); },
-};
-
-/**
- * Audit fields for tracking who created/updated
- */
-export const withAudit = {
-  get createdById() { return string({ optional: true, index: true }); },
-  get updatedById() { return string({ optional: true, index: true }); },
-};
-
-/**
- * External ID field for integrations
- */
-export const withExternalId = {
-  get externalId() { return string({ index: true }); },
-};
-
-/**
- * Name and description fields
- */
-export const withNameDescription = {
-  get name() { return string(); },
-  get description() { return string({ optional: true }); },
-};
-
-// ─── Common Field Definitions ─────────────────────
-
-/**
- * Pre-defined field definitions for common use cases.
- * Uses getters for fresh instances.
- */
-export const fields = {
-  /** Standard datetime with now default and timezone */
-  get datetime() { return datetime({ default: "now", updatedAt: true, tz: true, index: true }); },
-
-  /** ULID primary key */
-  get id() { return id({ type: "ulid" }); },
-
-  /** Standard title/name field */
-  get title() { return string(); },
-
-  /** Optional description field */
-  get description() { return string({ optional: true }); },
-
-  /** External ID with index */
-  get externalId() { return string({ index: true }); },
-
-  /** Optional metadata JSON */
-  get metadata() { return json({ optional: true }); },
-
-  /** Optional settings JSON */
-  get settings() { return json({ optional: true }); },
-
-  /** Active status with default true */
-  get isActive() { return boolean({ default: true }); },
-};
-
-// ─── Template Namespace Export ─────────────────────
-
-export const templates = {
-  base,
-  baseWithWorkspace,
-  withMetadata,
-  withActive,
-  withAudit,
-  withExternalId,
-  withNameDescription,
-  fields,
-};