@prisma-next/contract-authoring 0.3.0-pr.99.6 → 0.3.0

package/src/contract-builder.ts

@@ -1,159 +0,0 @@
-import type { TargetPackRef } from '@prisma-next/contract/framework-components';
-import type {
-  ColumnBuilderState,
-  ContractBuilderState,
-  ModelBuilderState,
-  RelationDefinition,
-  TableBuilderState,
-} from './builder-state';
-import { ModelBuilder } from './model-builder';
-import { createTable, TableBuilder } from './table-builder';
-
-export class ContractBuilder<
-  Target extends string | undefined = undefined,
-  Tables extends Record<
-    string,
-    TableBuilderState<
-      string,
-      Record<string, ColumnBuilderState<string, boolean, string>>,
-      readonly string[] | undefined
-    >
-  > = Record<never, never>,
-  Models extends Record<
-    string,
-    ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>
-  > = Record<never, never>,
-  CoreHash extends string | undefined = undefined,
-  ExtensionPacks extends Record<string, unknown> | undefined = undefined,
-  Capabilities extends Record<string, Record<string, boolean>> | undefined = undefined,
-> {
-  protected readonly state: ContractBuilderState<
-    Target,
-    Tables,
-    Models,
-    CoreHash,
-    ExtensionPacks,
-    Capabilities
-  >;
-
-  constructor(
-    state?: ContractBuilderState<Target, Tables, Models, CoreHash, ExtensionPacks, Capabilities>,
-  ) {
-    this.state =
-      state ??
-      ({
-        tables: {},
-        models: {},
-      } as ContractBuilderState<Target, Tables, Models, CoreHash, ExtensionPacks, Capabilities>);
-  }
-
-  target<T extends string>(
-    packRef: TargetPackRef<string, T>,
-  ): ContractBuilder<T, Tables, Models, CoreHash, ExtensionPacks, Capabilities> {
-    return new ContractBuilder<T, Tables, Models, CoreHash, ExtensionPacks, Capabilities>({
-      ...this.state,
-      target: packRef.targetId,
-    });
-  }
-
-  capabilities<C extends Record<string, Record<string, boolean>>>(
-    capabilities: C,
-  ): ContractBuilder<Target, Tables, Models, CoreHash, ExtensionPacks, C> {
-    return new ContractBuilder<Target, Tables, Models, CoreHash, ExtensionPacks, C>({
-      ...this.state,
-      capabilities,
-    });
-  }
-
-  table<
-    TableName extends string,
-    T extends TableBuilder<
-      TableName,
-      Record<string, ColumnBuilderState<string, boolean, string>>,
-      readonly string[] | undefined
-    >,
-  >(
-    name: TableName,
-    callback: (t: TableBuilder<TableName>) => T | undefined,
-  ): ContractBuilder<
-    Target,
-    Tables & Record<TableName, ReturnType<T['build']>>,
-    Models,
-    CoreHash,
-    ExtensionPacks,
-    Capabilities
-  > {
-    const tableBuilder = createTable(name);
-    const result = callback(tableBuilder);
-    const finalBuilder = result instanceof TableBuilder ? result : tableBuilder;
-    const tableState = finalBuilder.build();
-
-    return new ContractBuilder<
-      Target,
-      Tables & Record<TableName, ReturnType<T['build']>>,
-      Models,
-      CoreHash,
-      ExtensionPacks,
-      Capabilities
-    >({
-      ...this.state,
-      tables: { ...this.state.tables, [name]: tableState } as Tables &
-        Record<TableName, ReturnType<T['build']>>,
-    });
-  }
-
-  model<
-    ModelName extends string,
-    TableName extends string,
-    M extends ModelBuilder<
-      ModelName,
-      TableName,
-      Record<string, string>,
-      Record<string, RelationDefinition>
-    >,
-  >(
-    name: ModelName,
-    table: TableName,
-    callback: (
-      m: ModelBuilder<ModelName, TableName, Record<string, string>, Record<never, never>>,
-    ) => M | undefined,
-  ): ContractBuilder<
-    Target,
-    Tables,
-    Models & Record<ModelName, ReturnType<M['build']>>,
-    CoreHash,
-    ExtensionPacks,
-    Capabilities
-  > {
-    const modelBuilder = new ModelBuilder<ModelName, TableName>(name, table);
-    const result = callback(modelBuilder);
-    const finalBuilder = result instanceof ModelBuilder ? result : modelBuilder;
-    const modelState = finalBuilder.build();
-
-    return new ContractBuilder<
-      Target,
-      Tables,
-      Models & Record<ModelName, ReturnType<M['build']>>,
-      CoreHash,
-      ExtensionPacks,
-      Capabilities
-    >({
-      ...this.state,
-      models: { ...this.state.models, [name]: modelState } as Models &
-        Record<ModelName, ReturnType<M['build']>>,
-    });
-  }
-
-  coreHash<H extends string>(
-    hash: H,
-  ): ContractBuilder<Target, Tables, Models, H, ExtensionPacks, Capabilities> {
-    return new ContractBuilder<Target, Tables, Models, H, ExtensionPacks, Capabilities>({
-      ...this.state,
-      coreHash: hash,
-    });
-  }
-}
-
-export function defineContract(): ContractBuilder {
-  return new ContractBuilder();
-}

package/src/model-builder.ts

@@ -1,160 +0,0 @@
-import type { ModelBuilderState, RelationDefinition } from './builder-state';
-
-export class ModelBuilder<
-  Name extends string,
-  Table extends string,
-  Fields extends Record<string, string> = Record<never, never>,
-  Relations extends Record<string, RelationDefinition> = Record<never, never>,
-> {
-  private readonly _name: Name;
-  private readonly _table: Table;
-  private readonly _fields: Fields;
-  private readonly _relations: Relations;
-
-  constructor(
-    name: Name,
-    table: Table,
-    fields: Fields = {} as Fields,
-    relations: Relations = {} as Relations,
-  ) {
-    this._name = name;
-    this._table = table;
-    this._fields = fields;
-    this._relations = relations;
-  }
-
-  field<FieldName extends string, ColumnName extends string>(
-    fieldName: FieldName,
-    columnName: ColumnName,
-  ): ModelBuilder<Name, Table, Fields & Record<FieldName, ColumnName>, Relations> {
-    return new ModelBuilder(
-      this._name,
-      this._table,
-      {
-        ...this._fields,
-        [fieldName]: columnName,
-      } as Fields & Record<FieldName, ColumnName>,
-      this._relations,
-    );
-  }
-
-  relation<RelationName extends string, ToModel extends string, ToTable extends string>(
-    name: RelationName,
-    options: {
-      toModel: ToModel;
-      toTable: ToTable;
-      cardinality: '1:1' | '1:N' | 'N:1';
-      on: {
-        parentTable: Table;
-        parentColumns: readonly string[];
-        childTable: ToTable;
-        childColumns: readonly string[];
-      };
-    },
-  ): ModelBuilder<Name, Table, Fields, Relations & Record<RelationName, RelationDefinition>>;
-  relation<
-    RelationName extends string,
-    ToModel extends string,
-    ToTable extends string,
-    JunctionTable extends string,
-  >(
-    name: RelationName,
-    options: {
-      toModel: ToModel;
-      toTable: ToTable;
-      cardinality: 'N:M';
-      through: {
-        table: JunctionTable;
-        parentColumns: readonly string[];
-        childColumns: readonly string[];
-      };
-      on: {
-        parentTable: Table;
-        parentColumns: readonly string[];
-        childTable: JunctionTable;
-        childColumns: readonly string[];
-      };
-    },
-  ): ModelBuilder<Name, Table, Fields, Relations & Record<RelationName, RelationDefinition>>;
-  relation<
-    RelationName extends string,
-    ToModel extends string,
-    ToTable extends string,
-    JunctionTable extends string = never,
-  >(
-    name: RelationName,
-    options: {
-      toModel: ToModel;
-      toTable: ToTable;
-      cardinality: '1:1' | '1:N' | 'N:1' | 'N:M';
-      through?: {
-        table: JunctionTable;
-        parentColumns: readonly string[];
-        childColumns: readonly string[];
-      };
-      on: {
-        parentTable: Table;
-        parentColumns: readonly string[];
-        childTable: ToTable | JunctionTable;
-        childColumns: readonly string[];
-      };
-    },
-  ): ModelBuilder<Name, Table, Fields, Relations & Record<RelationName, RelationDefinition>> {
-    // Validate parentTable matches model's table
-    if (options.on.parentTable !== this._table) {
-      throw new Error(
-        `Relation "${name}" parentTable "${options.on.parentTable}" does not match model table "${this._table}"`,
-      );
-    }
-
-    // Validate childTable matches toTable (for non-N:M) or through.table (for N:M)
-    if (options.cardinality === 'N:M') {
-      if (!options.through) {
-        throw new Error(`Relation "${name}" with cardinality "N:M" requires through field`);
-      }
-      if (options.on.childTable !== options.through.table) {
-        throw new Error(
-          `Relation "${name}" childTable "${options.on.childTable}" does not match through.table "${options.through.table}"`,
-        );
-      }
-    } else {
-      if (options.on.childTable !== options.toTable) {
-        throw new Error(
-          `Relation "${name}" childTable "${options.on.childTable}" does not match toTable "${options.toTable}"`,
-        );
-      }
-    }
-
-    const relationDef: RelationDefinition = {
-      to: options.toModel,
-      cardinality: options.cardinality,
-      on: {
-        parentCols: options.on.parentColumns,
-        childCols: options.on.childColumns,
-      },
-      ...(options.through
-        ? {
-            through: {
-              table: options.through.table,
-              parentCols: options.through.parentColumns,
-              childCols: options.through.childColumns,
-            },
-          }
-        : undefined),
-    };
-
-    return new ModelBuilder(this._name, this._table, this._fields, {
-      ...this._relations,
-      [name]: relationDef,
-    } as Relations & Record<RelationName, RelationDefinition>);
-  }
-
-  build(): ModelBuilderState<Name, Table, Fields, Relations> {
-    return {
-      name: this._name,
-      table: this._table,
-      fields: this._fields,
-      relations: this._relations,
-    };
-  }
-}

package/src/table-builder.ts

@@ -1,195 +0,0 @@
-import type {
-  ColumnBuilderState,
-  ColumnTypeDescriptor,
-  ForeignKeyDef,
-  IndexDef,
-  TableBuilderState,
-  UniqueConstraintDef,
-} from './builder-state';
-
-interface TableBuilderInternalState<
-  Name extends string,
-  Columns extends Record<string, ColumnBuilderState<string, boolean, string>>,
-  PrimaryKey extends readonly string[] | undefined,
-> {
-  readonly name: Name;
-  readonly columns: Columns;
-  readonly primaryKey: PrimaryKey;
-  readonly primaryKeyName: string | undefined;
-  readonly uniques: readonly UniqueConstraintDef[];
-  readonly indexes: readonly IndexDef[];
-  readonly foreignKeys: readonly ForeignKeyDef[];
-}
-
-/**
- * Creates a new table builder with the given name.
- * This is the preferred way to create a TableBuilder - it ensures
- * type parameters are inferred correctly without unsafe casts.
- */
-export function createTable<Name extends string>(name: Name): TableBuilder<Name> {
-  return new TableBuilder(name, {}, undefined, undefined, [], [], []);
-}
-
-/**
- * Builder for defining table structure with type-safe chaining.
- * Use `createTable(name)` to create instances.
- */
-export class TableBuilder<
-  Name extends string,
-  Columns extends Record<string, ColumnBuilderState<string, boolean, string>> = Record<
-    never,
-    ColumnBuilderState<string, boolean, string>
-  >,
-  PrimaryKey extends readonly string[] | undefined = undefined,
-> {
-  private readonly _state: TableBuilderInternalState<Name, Columns, PrimaryKey>;
-
-  /** @internal Use createTable() instead */
-  constructor(
-    name: Name,
-    columns: Columns,
-    primaryKey: PrimaryKey,
-    primaryKeyName: string | undefined,
-    uniques: readonly UniqueConstraintDef[],
-    indexes: readonly IndexDef[],
-    foreignKeys: readonly ForeignKeyDef[],
-  ) {
-    this._state = {
-      name,
-      columns,
-      primaryKey,
-      primaryKeyName,
-      uniques,
-      indexes,
-      foreignKeys,
-    };
-  }
-
-  private get _name(): Name {
-    return this._state.name;
-  }
-
-  private get _columns(): Columns {
-    return this._state.columns;
-  }
-
-  private get _primaryKey(): PrimaryKey {
-    return this._state.primaryKey;
-  }
-
-  column<
-    ColName extends string,
-    Descriptor extends ColumnTypeDescriptor,
-    Nullable extends boolean | undefined = undefined,
-  >(
-    name: ColName,
-    options: {
-      type: Descriptor;
-      nullable?: Nullable;
-    },
-  ): TableBuilder<
-    Name,
-    Columns &
-      Record<
-        ColName,
-        ColumnBuilderState<ColName, Nullable extends true ? true : false, Descriptor['codecId']>
-      >,
-    PrimaryKey
-  > {
-    const nullable = (options.nullable ?? false) as Nullable extends true ? true : false;
-    const { codecId, nativeType } = options.type;
-
-    const columnState = {
-      name,
-      nullable,
-      type: codecId,
-      nativeType,
-    } as ColumnBuilderState<ColName, Nullable extends true ? true : false, Descriptor['codecId']>;
-    const newColumns = { ...this._columns, [name]: columnState } as Columns &
-      Record<
-        ColName,
-        ColumnBuilderState<ColName, Nullable extends true ? true : false, Descriptor['codecId']>
-      >;
-    return new TableBuilder(
-      this._state.name,
-      newColumns,
-      this._state.primaryKey,
-      this._state.primaryKeyName,
-      this._state.uniques,
-      this._state.indexes,
-      this._state.foreignKeys,
-    );
-  }
-
-  primaryKey<PK extends readonly string[]>(
-    columns: PK,
-    name?: string,
-  ): TableBuilder<Name, Columns, PK> {
-    return new TableBuilder(
-      this._state.name,
-      this._state.columns,
-      columns,
-      name,
-      this._state.uniques,
-      this._state.indexes,
-      this._state.foreignKeys,
-    );
-  }
-
-  unique(columns: readonly string[], name?: string): TableBuilder<Name, Columns, PrimaryKey> {
-    const constraint: UniqueConstraintDef = name ? { columns, name } : { columns };
-    return new TableBuilder(
-      this._state.name,
-      this._state.columns,
-      this._state.primaryKey,
-      this._state.primaryKeyName,
-      [...this._state.uniques, constraint],
-      this._state.indexes,
-      this._state.foreignKeys,
-    );
-  }
-
-  index(columns: readonly string[], name?: string): TableBuilder<Name, Columns, PrimaryKey> {
-    const indexDef: IndexDef = name ? { columns, name } : { columns };
-    return new TableBuilder(
-      this._state.name,
-      this._state.columns,
-      this._state.primaryKey,
-      this._state.primaryKeyName,
-      this._state.uniques,
-      [...this._state.indexes, indexDef],
-      this._state.foreignKeys,
-    );
-  }
-
-  foreignKey(
-    columns: readonly string[],
-    references: { table: string; columns: readonly string[] },
-    name?: string,
-  ): TableBuilder<Name, Columns, PrimaryKey> {
-    const fkDef: ForeignKeyDef = name ? { columns, references, name } : { columns, references };
-    return new TableBuilder(
-      this._state.name,
-      this._state.columns,
-      this._state.primaryKey,
-      this._state.primaryKeyName,
-      this._state.uniques,
-      this._state.indexes,
-      [...this._state.foreignKeys, fkDef],
-    );
-  }
-
-  build(): TableBuilderState<Name, Columns, PrimaryKey> {
-    return {
-      name: this._name,
-      columns: this._columns,
-      ...(this._primaryKey !== undefined ? { primaryKey: this._primaryKey } : {}),
-      ...(this._state.primaryKeyName !== undefined
-        ? { primaryKeyName: this._state.primaryKeyName }
-        : {}),
-      uniques: this._state.uniques,
-      indexes: this._state.indexes,
-      foreignKeys: this._state.foreignKeys,
-    } as TableBuilderState<Name, Columns, PrimaryKey>;
-  }
-}

package/src/types.ts

@@ -1,129 +0,0 @@
-import type {
-  ColumnBuilderState,
-  ModelBuilderState,
-  RelationDefinition,
-  TableBuilderState,
-} from './builder-state';
-
-export type BuildStorageColumn<Nullable extends boolean, Type extends string> = {
-  readonly nativeType: string;
-  readonly codecId: Type;
-  readonly nullable: Nullable;
-};
-
-export type ExtractColumns<
-  T extends TableBuilderState<
-    string,
-    Record<string, ColumnBuilderState<string, boolean, string>>,
-    readonly string[] | undefined
-  >,
-> = T extends TableBuilderState<string, infer C, readonly string[] | undefined> ? C : never;
-
-export type ExtractPrimaryKey<
-  T extends TableBuilderState<
-    string,
-    Record<string, ColumnBuilderState<string, boolean, string>>,
-    readonly string[] | undefined
-  >,
-> =
-  T extends TableBuilderState<
-    string,
-    Record<string, ColumnBuilderState<string, boolean, string>>,
-    infer PK
-  >
-    ? PK
-    : never;
-
-export type BuildStorage<
-  Tables extends Record<
-    string,
-    TableBuilderState<
-      string,
-      Record<string, ColumnBuilderState<string, boolean, string>>,
-      readonly string[] | undefined
-    >
-  >,
-> = {
-  readonly tables: {
-    readonly [K in keyof Tables]: {
-      readonly columns: {
-        readonly [ColK in keyof ExtractColumns<Tables[K]>]: ExtractColumns<
-          Tables[K]
-        >[ColK] extends ColumnBuilderState<string, infer Null, infer TType>
-          ? BuildStorageColumn<Null & boolean, TType>
-          : never;
-      };
-    };
-  };
-};
-
-export type BuildStorageTables<
-  Tables extends Record<
-    string,
-    TableBuilderState<
-      string,
-      Record<string, ColumnBuilderState<string, boolean, string>>,
-      readonly string[] | undefined
-    >
-  >,
-> = {
-  readonly [K in keyof Tables]: {
-    readonly columns: {
-      readonly [ColK in keyof ExtractColumns<Tables[K]>]: ExtractColumns<
-        Tables[K]
-      >[ColK] extends ColumnBuilderState<string, infer Null, infer TType>
-        ? BuildStorageColumn<Null & boolean, TType>
-        : never;
-    };
-  };
-};
-
-export type Mutable<T> = {
-  -readonly [K in keyof T]-?: T[K];
-};
-
-export type BuildModelFields<Fields extends Record<string, string>> = {
-  readonly [K in keyof Fields]: { readonly column: Fields[K] };
-};
-
-export type ExtractModelFields<
-  T extends ModelBuilderState<
-    string,
-    string,
-    Record<string, string>,
-    Record<string, RelationDefinition>
-  >,
-> =
-  T extends ModelBuilderState<string, string, infer F, Record<string, RelationDefinition>>
-    ? F
-    : never;
-
-export type ExtractModelRelations<
-  T extends ModelBuilderState<
-    string,
-    string,
-    Record<string, string>,
-    Record<string, RelationDefinition>
-  >,
-> = T extends ModelBuilderState<string, string, Record<string, string>, infer R> ? R : never;
-
-export type BuildModels<
-  Models extends Record<
-    string,
-    ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>
-  >,
-> = {
-  readonly [K in keyof Models]: {
-    readonly storage: { readonly table: Models[K]['table'] };
-    readonly fields: BuildModelFields<ExtractModelFields<Models[K]>>;
-  };
-};
-
-export type BuildRelations<
-  Models extends Record<
-    string,
-    ModelBuilderState<string, string, Record<string, string>, Record<string, RelationDefinition>>
-  >,
-> = {
-  readonly [K in keyof Models as Models[K]['table']]: ExtractModelRelations<Models[K]>;
-};