@prisma-next/contract-authoring 0.3.0-dev.16 → 0.3.0-dev.160

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,90 +0,0 @@
-import type { ColumnBuilderState, ColumnTypeDescriptor, TableBuilderState } from './builder-state';
-
-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 _name: Name;
-  private readonly _columns: Columns;
-  private readonly _primaryKey: PrimaryKey;
-
-  constructor(name: Name, columns: Columns = {} as Columns, primaryKey?: PrimaryKey) {
-    this._name = name;
-    this._columns = columns;
-    this._primaryKey = primaryKey as 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']>;
-    return new TableBuilder(
-      this._name,
-      { ...this._columns, [name]: columnState } as Columns &
-        Record<
-          ColName,
-          ColumnBuilderState<ColName, Nullable extends true ? true : false, Descriptor['codecId']>
-        >,
-      this._primaryKey,
-    );
-  }
-
-  primaryKey<PK extends readonly string[]>(
-    columns: PK,
-    _name?: string,
-  ): TableBuilder<Name, Columns, PK> {
-    return new TableBuilder(this._name, this._columns, columns);
-  }
-
-  unique(_columns: readonly string[], _name?: string): TableBuilder<Name, Columns, PrimaryKey> {
-    return this;
-  }
-
-  index(_columns: readonly string[], _name?: string): TableBuilder<Name, Columns, PrimaryKey> {
-    return this;
-  }
-
-  foreignKey(
-    _columns: readonly string[],
-    _references: { table: string; columns: readonly string[] },
-    _name?: string,
-  ): TableBuilder<Name, Columns, PrimaryKey> {
-    return this;
-  }
-
-  build(): TableBuilderState<Name, Columns, PrimaryKey> {
-    return {
-      name: this._name,
-      columns: this._columns,
-      ...(this._primaryKey !== undefined ? { primaryKey: this._primaryKey } : {}),
-    } 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]>;
-};