@prisma-next/sql-builder 0.0.1

package/src/runtime/table-proxy-impl.ts

@@ -0,0 +1,173 @@
+import type { StorageTable } from '@prisma-next/sql-contract/types';
+import { type AnyFromSource, TableSource } from '@prisma-next/sql-relational-core/ast';
+import type {
+  AggregateFunctions,
+  Expression,
+  ExpressionBuilder,
+  ExtractScopeFields,
+  FieldProxy,
+  WithField,
+  WithFields,
+} from '../expression';
+import type {
+  EmptyRow,
+  Expand,
+  JoinOuterScope,
+  JoinSource,
+  MergeScopes,
+  NullableScope,
+  QueryContext,
+  RebindScope,
+  Scope,
+  ScopeField,
+  ScopeTable,
+  StorageTableToScopeTable,
+  Subquery,
+} from '../scope';
+import type { TableProxyContract } from '../types/db';
+import type { JoinedTables } from '../types/joined-tables';
+import type { DeleteQuery, InsertQuery, UpdateQuery } from '../types/mutation-query';
+import type { SelectQuery } from '../types/select-query';
+import type { LateralBuilder } from '../types/shared';
+import type { TableProxy } from '../types/table-proxy';
+import { BuilderBase, type BuilderContext, emptyState, tableToScope } from './builder-base';
+import { JoinedTablesImpl } from './joined-tables-impl';
+import { DeleteQueryImpl, InsertQueryImpl, UpdateQueryImpl } from './mutation-impl';
+import { SelectQueryImpl } from './query-impl';
+
+export class TableProxyImpl<
+    C extends TableProxyContract,
+    Name extends string & keyof C['storage']['tables'],
+    Alias extends string,
+    AvailableScope extends Scope,
+    QC extends QueryContext,
+  >
+  extends BuilderBase<C['capabilities']>
+  implements TableProxy<C, Name, Alias, AvailableScope, QC>
+{
+  declare readonly [JoinOuterScope]: JoinSource<
+    StorageTableToScopeTable<C['storage']['tables'][Name]>,
+    Alias
+  >[typeof JoinOuterScope];
+
+  readonly #tableName: string;
+  readonly #table: StorageTable;
+  readonly #fromSource: TableSource;
+  readonly #scope: Scope;
+
+  constructor(tableName: string, table: StorageTable, alias: string, ctx: BuilderContext) {
+    super(ctx);
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#scope = tableToScope(alias, table);
+    this.#fromSource = TableSource.named(tableName, alias !== tableName ? alias : undefined);
+  }
+
+  lateralJoin = this._gate(
+    { sql: { lateral: true } },
+    'lateralJoin',
+    <LAlias extends string, LateralRow extends Record<string, ScopeField>>(
+      alias: LAlias,
+      builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>,
+    ): JoinedTables<
+      QC,
+      MergeScopes<AvailableScope, { topLevel: LateralRow; namespaces: Record<LAlias, LateralRow> }>
+    > => {
+      return this.#toJoined().lateralJoin(alias, builder);
+    },
+  ) as TableProxy<C, Name, Alias, AvailableScope, QC>['lateralJoin'];
+
+  outerLateralJoin = this._gate(
+    { sql: { lateral: true } },
+    'outerLateralJoin',
+    <LAlias extends string, LateralRow extends Record<string, ScopeField>>(
+      alias: LAlias,
+      builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>,
+    ): JoinedTables<
+      QC,
+      MergeScopes<
+        AvailableScope,
+        NullableScope<{ topLevel: LateralRow; namespaces: Record<LAlias, LateralRow> }>
+      >
+    > => {
+      return this.#toJoined().outerLateralJoin(alias, builder);
+    },
+  ) as TableProxy<C, Name, Alias, AvailableScope, QC>['outerLateralJoin'];
+
+  getJoinOuterScope(): Scope {
+    return this.#scope;
+  }
+
+  buildAst(): AnyFromSource {
+    return this.#fromSource;
+  }
+
+  as<NewAlias extends string>(
+    newAlias: NewAlias,
+  ): TableProxy<C, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>> {
+    return new TableProxyImpl(this.#tableName, this.#table, newAlias, this.ctx);
+  }
+
+  select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
+    ...columns: Columns
+  ): SelectQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>;
+  select<LAlias extends string, Field extends ScopeField>(
+    alias: LAlias,
+    expr: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Expression<Field>,
+  ): SelectQuery<QC, AvailableScope, WithField<EmptyRow, Field, LAlias>>;
+  select<Result extends Record<string, Expression<ScopeField>>>(
+    callback: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Result,
+  ): SelectQuery<QC, AvailableScope, Expand<ExtractScopeFields<Result>>>;
+  select(...args: unknown[]): unknown {
+    return new SelectQueryImpl(emptyState(this.#fromSource, this.#scope), this.ctx).select(
+      ...(args as string[]),
+    );
+  }
+
+  innerJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>> {
+    return this.#toJoined().innerJoin(other, on);
+  }
+
+  outerLeftJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<Other[typeof JoinOuterScope]>>> {
+    return this.#toJoined().outerLeftJoin(other, on);
+  }
+
+  outerRightJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, Other[typeof JoinOuterScope]>> {
+    return this.#toJoined().outerRightJoin(other, on);
+  }
+
+  outerFullJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<
+    QC,
+    MergeScopes<NullableScope<AvailableScope>, NullableScope<Other[typeof JoinOuterScope]>>
+  > {
+    return this.#toJoined().outerFullJoin(other, on);
+  }
+
+  insert(values: Record<string, unknown>): InsertQuery<QC, AvailableScope, EmptyRow> {
+    return new InsertQueryImpl(this.#tableName, this.#table, this.#scope, values, this.ctx);
+  }
+
+  update(set: Record<string, unknown>): UpdateQuery<QC, AvailableScope, EmptyRow> {
+    return new UpdateQueryImpl(this.#tableName, this.#table, this.#scope, set, this.ctx);
+  }
+
+  delete(): DeleteQuery<QC, AvailableScope, EmptyRow> {
+    return new DeleteQueryImpl(this.#tableName, this.#scope, this.ctx);
+  }
+
+  #toJoined(): JoinedTables<QC, AvailableScope> {
+    return new JoinedTablesImpl(emptyState(this.#fromSource, this.#scope), this.ctx);
+  }
+}

package/src/scope.ts

@@ -0,0 +1,83 @@
+import type { QueryOperationTypesBase, StorageTable } from '@prisma-next/sql-contract/types';
+import type { AnyFromSource, SelectAst } from '@prisma-next/sql-relational-core/ast';
+
+export type GatedMethod<Capabilities, Required, Method> = Capabilities extends Required
+  ? Method
+  : never;
+
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+export declare const ExpressionType: unique symbol;
+export declare const JoinOuterScope: unique symbol;
+export declare const SubqueryMarker: unique symbol;
+
+export type Expand<T> = { [K in keyof T]: T[K] } & unknown;
+export type EmptyRow = Record<never, ScopeField>;
+
+export type ScopeField = { codecId: string; nullable: boolean };
+export type ScopeTable = Record<string, ScopeField>;
+
+export type Scope = {
+  topLevel: ScopeTable;
+  namespaces: Record<string, ScopeTable>;
+};
+
+export type JoinSource<Row extends ScopeTable, Alias extends string> = {
+  readonly [JoinOuterScope]: {
+    topLevel: Row;
+    namespaces: Record<Alias, Row>;
+  };
+
+  getJoinOuterScope(): Scope;
+  buildAst(): AnyFromSource;
+};
+
+export type DefaultScope<Name extends string, Table extends StorageTable> = {
+  topLevel: StorageTableToScopeTable<Table>;
+  namespaces: {
+    [K in Name]: StorageTableToScopeTable<Table>;
+  };
+};
+
+export type StorageTableToScopeTable<T extends StorageTable> = {
+  [K in keyof T['columns']]: {
+    codecId: T['columns'][K]['codecId'];
+    nullable: T['columns'][K]['nullable'];
+  };
+};
+
+export type MergeScopes<A extends Scope, B extends Scope> = {
+  topLevel: Expand<
+    Omit<A['topLevel'], keyof B['topLevel']> & Omit<B['topLevel'], keyof A['topLevel']>
+  >;
+  namespaces: Expand<A['namespaces'] & B['namespaces']>;
+};
+
+export type RebindScope<S extends Scope, OldKey extends string, NewKey extends string> = {
+  topLevel: S['topLevel'];
+  namespaces: Expand<Omit<S['namespaces'], OldKey> & Record<NewKey, S['namespaces'][OldKey]>>;
+};
+
+export type NullableScopeTable<S extends ScopeTable> = {
+  [K in keyof S]: { codecId: S[K]['codecId']; nullable: true };
+};
+
+export type NullableScope<S extends Scope> = {
+  topLevel: NullableScopeTable<S['topLevel']>;
+  namespaces: {
+    [TableName in keyof S['namespaces']]: NullableScopeTable<S['namespaces'][TableName]>;
+  };
+};
+
+export type Subquery<RowType extends Record<string, ScopeField>> = {
+  [SubqueryMarker]: RowType;
+  buildAst(): SelectAst;
+  getRowFields(): Record<string, ScopeField>;
+};
+
+export type QueryContext = {
+  readonly codecTypes: CodecTypesBase;
+  readonly capabilities: Record<string, Record<string, boolean>>;
+  readonly queryOperationTypes: QueryOperationTypesBase;
+};
+
+export type { CodecTypesBase, StorageTable };

package/src/types/db.ts

@@ -0,0 +1,13 @@
+import type { StorageTable } from '@prisma-next/sql-contract/types';
+import type { TableProxy } from './table-proxy';
+
+export type CapabilitiesBase = Record<string, Record<string, boolean>>;
+
+export type TableProxyContract = {
+  readonly storage: { readonly tables: Record<string, StorageTable> };
+  readonly capabilities: CapabilitiesBase;
+};
+
+export type Db<C extends TableProxyContract> = {
+  [Name in string & keyof C['storage']['tables']]: TableProxy<C, Name>;
+};

package/src/types/grouped-query.ts

@@ -0,0 +1,68 @@
+import type {
+  AggregateFunctions,
+  BooleanCodecType,
+  Expression,
+  FieldProxy,
+  Functions,
+  OrderByOptions,
+  OrderByScope,
+} from '../expression';
+import type { GatedMethod, QueryContext, Scope, ScopeField, Subquery } from '../scope';
+import type { WithAlias, WithBuild, WithDistinct, WithPagination } from './shared';
+
+export interface GroupedQuery<
+  QC extends QueryContext,
+  AvailableScope extends Scope,
+  RowType extends Record<string, ScopeField>,
+> extends Subquery<RowType>,
+    WithPagination,
+    WithDistinct,
+    WithAlias<RowType>,
+    WithBuild<QC, RowType> {
+  groupBy(
+    ...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  groupBy(
+    expr: (
+      fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+      fns: Functions<QC>,
+    ) => Expression<ScopeField>,
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  having(
+    expr: (
+      fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+      fns: AggregateFunctions<QC>,
+    ) => Expression<BooleanCodecType>,
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  orderBy(
+    field: (keyof RowType | keyof AvailableScope['topLevel']) & string,
+    options?: OrderByOptions,
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  orderBy(
+    expr: (
+      fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+      fns: AggregateFunctions<QC>,
+    ) => Expression<ScopeField>,
+    options?: OrderByOptions,
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  distinctOn: GatedMethod<
+    QC['capabilities'],
+    { postgres: { distinctOn: true } },
+    {
+      (
+        ...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]
+      ): GroupedQuery<QC, AvailableScope, RowType>;
+      (
+        expr: (
+          fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+          fns: Functions<QC>,
+        ) => Expression<ScopeField>,
+      ): GroupedQuery<QC, AvailableScope, RowType>;
+    }
+  >;
+}

package/src/types/joined-tables.ts

@@ -0,0 +1,6 @@
+import type { EmptyRow, QueryContext, Scope } from '../scope';
+import type { WithJoin, WithSelect } from './shared';
+
+export interface JoinedTables<QC extends QueryContext, AvailableScope extends Scope>
+  extends WithSelect<QC, AvailableScope, EmptyRow>,
+    WithJoin<QC, AvailableScope, QC['capabilities']> {}

package/src/types/mutation-query.ts

@@ -0,0 +1,73 @@
+import type { StorageTable } from '@prisma-next/sql-contract/types';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import type { ExpressionBuilder, WithFields } from '../expression';
+import type { ResolveRow } from '../resolve';
+import type { EmptyRow, GatedMethod, QueryContext, Scope, ScopeField } from '../scope';
+
+export type ReturningCapability = { sql: { returning: true } };
+
+// Map table columns to their codec input types
+export type InsertValues<
+  Table extends StorageTable,
+  CT extends Record<string, { readonly input: unknown }>,
+> = {
+  [K in keyof Table['columns']]?: Table['columns'][K]['codecId'] extends keyof CT
+    ? CT[Table['columns'][K]['codecId']]['input']
+    : unknown;
+};
+
+export type UpdateValues<
+  Table extends StorageTable,
+  CT extends Record<string, { readonly input: unknown }>,
+> = {
+  [K in keyof Table['columns']]?: Table['columns'][K]['codecId'] extends keyof CT
+    ? CT[Table['columns'][K]['codecId']]['input']
+    : unknown;
+};
+
+export interface InsertQuery<
+  QC extends QueryContext,
+  AvailableScope extends Scope,
+  RowType extends Record<string, ScopeField>,
+> {
+  returning: GatedMethod<
+    QC['capabilities'],
+    ReturningCapability,
+    <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
+      ...columns: Columns
+    ) => InsertQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>
+  >;
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>>;
+}
+
+export interface UpdateQuery<
+  QC extends QueryContext,
+  AvailableScope extends Scope,
+  RowType extends Record<string, ScopeField>,
+> {
+  where(expr: ExpressionBuilder<AvailableScope, QC>): UpdateQuery<QC, AvailableScope, RowType>;
+  returning: GatedMethod<
+    QC['capabilities'],
+    ReturningCapability,
+    <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
+      ...columns: Columns
+    ) => UpdateQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>
+  >;
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>>;
+}
+
+export interface DeleteQuery<
+  QC extends QueryContext,
+  AvailableScope extends Scope,
+  RowType extends Record<string, ScopeField>,
+> {
+  where(expr: ExpressionBuilder<AvailableScope, QC>): DeleteQuery<QC, AvailableScope, RowType>;
+  returning: GatedMethod<
+    QC['capabilities'],
+    ReturningCapability,
+    <Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
+      ...columns: Columns
+    ) => DeleteQuery<QC, AvailableScope, WithFields<EmptyRow, AvailableScope['topLevel'], Columns>>
+  >;
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>>;
+}

package/src/types/select-query.ts

@@ -0,0 +1,64 @@
+import type {
+  Expression,
+  ExpressionBuilder,
+  FieldProxy,
+  Functions,
+  OrderByOptions,
+  OrderByScope,
+} from '../expression';
+import type { GatedMethod, QueryContext, Scope, ScopeField, Subquery } from '../scope';
+import type { GroupedQuery } from './grouped-query';
+import type { WithAlias, WithBuild, WithDistinct, WithPagination, WithSelect } from './shared';
+
+export interface SelectQuery<
+  QC extends QueryContext,
+  AvailableScope extends Scope,
+  RowType extends Record<string, ScopeField>,
+> extends Subquery<RowType>,
+    WithSelect<QC, AvailableScope, RowType>,
+    WithPagination,
+    WithDistinct,
+    WithAlias<RowType>,
+    WithBuild<QC, RowType> {
+  where(expr: ExpressionBuilder<AvailableScope, QC>): SelectQuery<QC, AvailableScope, RowType>;
+
+  orderBy(
+    field: (keyof RowType | keyof AvailableScope['topLevel']) & string,
+    options?: OrderByOptions,
+  ): SelectQuery<QC, AvailableScope, RowType>;
+
+  orderBy(
+    expr: (
+      fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+      fns: Functions<QC>,
+    ) => Expression<ScopeField>,
+    options?: OrderByOptions,
+  ): SelectQuery<QC, AvailableScope, RowType>;
+
+  groupBy(
+    ...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  groupBy(
+    expr: (
+      fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+      fns: Functions<QC>,
+    ) => Expression<ScopeField>,
+  ): GroupedQuery<QC, AvailableScope, RowType>;
+
+  distinctOn: GatedMethod<
+    QC['capabilities'],
+    { postgres: { distinctOn: true } },
+    {
+      (
+        ...fields: ((keyof RowType | keyof AvailableScope['topLevel']) & string)[]
+      ): SelectQuery<QC, AvailableScope, RowType>;
+      (
+        expr: (
+          fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+          fns: Functions<QC>,
+        ) => Expression<ScopeField>,
+      ): SelectQuery<QC, AvailableScope, RowType>;
+    }
+  >;
+}

package/src/types/shared.ts

@@ -0,0 +1,121 @@
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import type {
+  AggregateFunctions,
+  Expression,
+  ExpressionBuilder,
+  ExtractScopeFields,
+  FieldProxy,
+  WithField,
+  WithFields,
+} from '../expression';
+import type { ResolveRow } from '../resolve';
+import type {
+  EmptyRow,
+  Expand,
+  GatedMethod,
+  JoinOuterScope,
+  JoinSource,
+  MergeScopes,
+  NullableScope,
+  QueryContext,
+  Scope,
+  ScopeField,
+  ScopeTable,
+  Subquery,
+} from '../scope';
+import type { JoinedTables } from './joined-tables';
+import type { SelectQuery } from './select-query';
+
+export interface LateralBuilder<QC extends QueryContext, ParentScope extends Scope> {
+  from<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+  ): SelectQuery<QC, MergeScopes<ParentScope, Other[typeof JoinOuterScope]>, EmptyRow>;
+}
+
+export interface WithSelect<
+  QC extends QueryContext,
+  AvailableScope extends Scope,
+  RowType extends Record<string, ScopeField> = EmptyRow,
+> {
+  select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
+    ...columns: Columns
+  ): SelectQuery<QC, AvailableScope, WithFields<RowType, AvailableScope['topLevel'], Columns>>;
+
+  select<Alias extends string, Field extends ScopeField>(
+    alias: Alias,
+    expr: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Expression<Field>,
+  ): SelectQuery<QC, AvailableScope, WithField<RowType, Field, Alias>>;
+
+  select<Result extends Record<string, Expression<ScopeField>>>(
+    callback: (fields: FieldProxy<AvailableScope>, fns: AggregateFunctions<QC>) => Result,
+  ): SelectQuery<QC, AvailableScope, Expand<RowType & ExtractScopeFields<Result>>>;
+}
+
+export interface WithJoin<QC extends QueryContext, AvailableScope extends Scope, Capabilities> {
+  innerJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>>;
+
+  outerLeftJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<AvailableScope, NullableScope<Other[typeof JoinOuterScope]>>>;
+
+  outerRightJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<NullableScope<AvailableScope>, Other[typeof JoinOuterScope]>>;
+
+  outerFullJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<
+    QC,
+    MergeScopes<NullableScope<AvailableScope>, NullableScope<Other[typeof JoinOuterScope]>>
+  >;
+
+  lateralJoin: GatedMethod<
+    Capabilities,
+    { sql: { lateral: true } },
+    <Alias extends string, LateralRow extends Record<string, ScopeField>>(
+      alias: Alias,
+      builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>,
+    ) => JoinedTables<
+      QC,
+      MergeScopes<AvailableScope, { topLevel: LateralRow; namespaces: Record<Alias, LateralRow> }>
+    >
+  >;
+
+  outerLateralJoin: GatedMethod<
+    Capabilities,
+    { sql: { lateral: true } },
+    <Alias extends string, LateralRow extends Record<string, ScopeField>>(
+      alias: Alias,
+      builder: (lateral: LateralBuilder<QC, AvailableScope>) => Subquery<LateralRow>,
+    ) => JoinedTables<
+      QC,
+      MergeScopes<
+        AvailableScope,
+        NullableScope<{ topLevel: LateralRow; namespaces: Record<Alias, LateralRow> }>
+      >
+    >
+  >;
+}
+
+export interface WithPagination {
+  limit(count: number): this;
+  offset(count: number): this;
+}
+
+export interface WithDistinct {
+  distinct(): this;
+}
+
+export interface WithAlias<RowType extends Record<string, ScopeField>> {
+  as<Alias extends string>(newAlias: Alias): JoinSource<RowType, Alias>;
+}
+
+export interface WithBuild<QC extends QueryContext, RowType extends Record<string, ScopeField>> {
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>>;
+}

package/src/types/table-proxy.ts

@@ -0,0 +1,52 @@
+import type {
+  ExtractCodecTypes,
+  ExtractQueryOperationTypes,
+} from '@prisma-next/sql-contract/types';
+import type {
+  DefaultScope,
+  EmptyRow,
+  JoinSource,
+  QueryContext,
+  RebindScope,
+  Scope,
+  StorageTableToScopeTable,
+} from '../scope';
+import type { TableProxyContract } from './db';
+import type {
+  DeleteQuery,
+  InsertQuery,
+  InsertValues,
+  UpdateQuery,
+  UpdateValues,
+} from './mutation-query';
+import type { WithJoin, WithSelect } from './shared';
+
+type ContractToQC<C extends TableProxyContract> = {
+  readonly codecTypes: ExtractCodecTypes<C>;
+  readonly capabilities: C['capabilities'];
+  readonly queryOperationTypes: ExtractQueryOperationTypes<C>;
+};
+
+export interface TableProxy<
+  C extends TableProxyContract,
+  Name extends string & keyof C['storage']['tables'],
+  Alias extends string = Name,
+  AvailableScope extends Scope = DefaultScope<Name, C['storage']['tables'][Name]>,
+  QC extends QueryContext = ContractToQC<C>,
+> extends JoinSource<StorageTableToScopeTable<C['storage']['tables'][Name]>, Alias>,
+    WithSelect<QC, AvailableScope, EmptyRow>,
+    WithJoin<QC, AvailableScope, C['capabilities']> {
+  as<NewAlias extends string>(
+    newAlias: NewAlias,
+  ): TableProxy<C, Name, NewAlias, RebindScope<AvailableScope, Alias, NewAlias>>;
+
+  insert(
+    values: InsertValues<C['storage']['tables'][Name], QC['codecTypes']>,
+  ): InsertQuery<QC, AvailableScope, EmptyRow>;
+
+  update(
+    set: UpdateValues<C['storage']['tables'][Name], QC['codecTypes']>,
+  ): UpdateQuery<QC, AvailableScope, EmptyRow>;
+
+  delete(): DeleteQuery<QC, AvailableScope, EmptyRow>;
+}