@prisma-next/contract-authoring 0.3.0-dev.2 → 0.3.0-dev.21

package/src/table-builder.ts

@@ -0,0 +1,195 @@
+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

@@ -0,0 +1,129 @@
+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]>;
+};