@prisma-next/sql-builder 0.0.1

package/src/runtime/mutation-impl.ts

@@ -0,0 +1,317 @@
+import type { StorageTable } from '@prisma-next/sql-contract/types';
+import {
+  type AnyExpression as AstExpression,
+  ColumnRef,
+  DeleteAst,
+  InsertAst,
+  ParamRef,
+  TableSource,
+  UpdateAst,
+} from '@prisma-next/sql-relational-core/ast';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import type { MutationDefaultsOp } from '@prisma-next/sql-relational-core/query-lane-context';
+import type { ExpressionBuilder } from '../expression';
+import type { ResolveRow } from '../resolve';
+import type { QueryContext, Scope, ScopeField } from '../scope';
+import type {
+  DeleteQuery,
+  InsertQuery,
+  ReturningCapability,
+  UpdateQuery,
+} from '../types/mutation-query';
+import {
+  BuilderBase,
+  type BuilderContext,
+  buildQueryPlan,
+  combineWhereExprs,
+} from './builder-base';
+import { createFieldProxy } from './field-proxy';
+import { createFunctions } from './functions';
+
+type WhereCallback = ExpressionBuilder<Scope, QueryContext>;
+
+function buildParamValues(
+  values: Record<string, unknown>,
+  table: StorageTable,
+  tableName: string,
+  op: MutationDefaultsOp,
+  ctx: BuilderContext,
+): Record<string, ParamRef> {
+  const params: Record<string, ParamRef> = {};
+  for (const [col, value] of Object.entries(values)) {
+    const column = table.columns[col];
+    params[col] = ParamRef.of(value, column ? { codecId: column.codecId } : undefined);
+  }
+  for (const def of ctx.applyMutationDefaults({ op, table: tableName, values })) {
+    const column = table.columns[def.column];
+    params[def.column] = ParamRef.of(def.value, column ? { codecId: column.codecId } : undefined);
+  }
+  return params;
+}
+
+function buildReturningColumnRefs(tableName: string, columns: string[]): ColumnRef[] {
+  return columns.map((col) => ColumnRef.of(tableName, col));
+}
+
+function evaluateWhere(
+  whereCallback: WhereCallback,
+  scope: Scope,
+  queryOperationTypes: BuilderContext['queryOperationTypes'],
+): AstExpression {
+  const fieldProxy = createFieldProxy(scope);
+  const fns = createFunctions(queryOperationTypes);
+  const result = whereCallback(fieldProxy, fns as never);
+  return result.buildAst();
+}
+
+export class InsertQueryImpl<
+    QC extends QueryContext = QueryContext,
+    AvailableScope extends Scope = Scope,
+    RowType extends Record<string, ScopeField> = Record<string, ScopeField>,
+  >
+  extends BuilderBase<QC['capabilities']>
+  implements InsertQuery<QC, AvailableScope, RowType>
+{
+  readonly #tableName: string;
+  readonly #table: StorageTable;
+  readonly #scope: Scope;
+  readonly #values: Record<string, unknown>;
+  readonly #returningColumns: string[];
+  readonly #rowFields: Record<string, ScopeField>;
+
+  constructor(
+    tableName: string,
+    table: StorageTable,
+    scope: Scope,
+    values: Record<string, unknown>,
+    ctx: BuilderContext,
+    returningColumns: string[] = [],
+    rowFields: Record<string, ScopeField> = {},
+  ) {
+    super(ctx);
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#scope = scope;
+    this.#values = values;
+    this.#returningColumns = returningColumns;
+    this.#rowFields = rowFields;
+  }
+
+  returning = this._gate<ReturningCapability, string[], InsertQuery<QC, AvailableScope, never>>(
+    { sql: { returning: true } },
+    'returning',
+    (...columns: string[]) => {
+      const newRowFields: Record<string, ScopeField> = {};
+      for (const col of columns) {
+        const field = this.#scope.topLevel[col];
+        if (!field) throw new Error(`Column "${col}" not found in scope`);
+        newRowFields[col] = field;
+      }
+      return new InsertQueryImpl(
+        this.#tableName,
+        this.#table,
+        this.#scope,
+        this.#values,
+        this.ctx,
+        columns,
+        newRowFields,
+      ) as unknown as InsertQuery<QC, AvailableScope, never>;
+    },
+  );
+
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>> {
+    const paramValues = buildParamValues(
+      this.#values,
+      this.#table,
+      this.#tableName,
+      'create',
+      this.ctx,
+    );
+
+    let ast = InsertAst.into(TableSource.named(this.#tableName)).withValues(paramValues);
+
+    if (this.#returningColumns.length > 0) {
+      ast = ast.withReturning(buildReturningColumnRefs(this.#tableName, this.#returningColumns));
+    }
+
+    return buildQueryPlan<ResolveRow<RowType, QC['codecTypes']>>(ast, this.#rowFields, this.ctx);
+  }
+}
+
+export class UpdateQueryImpl<
+    QC extends QueryContext = QueryContext,
+    AvailableScope extends Scope = Scope,
+    RowType extends Record<string, ScopeField> = Record<string, ScopeField>,
+  >
+  extends BuilderBase<QC['capabilities']>
+  implements UpdateQuery<QC, AvailableScope, RowType>
+{
+  readonly #tableName: string;
+  readonly #table: StorageTable;
+  readonly #scope: Scope;
+  readonly #setValues: Record<string, unknown>;
+  readonly #whereCallbacks: readonly WhereCallback[];
+  readonly #returningColumns: string[];
+  readonly #rowFields: Record<string, ScopeField>;
+
+  constructor(
+    tableName: string,
+    table: StorageTable,
+    scope: Scope,
+    setValues: Record<string, unknown>,
+    ctx: BuilderContext,
+    whereCallbacks: readonly WhereCallback[] = [],
+    returningColumns: string[] = [],
+    rowFields: Record<string, ScopeField> = {},
+  ) {
+    super(ctx);
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#scope = scope;
+    this.#setValues = setValues;
+    this.#whereCallbacks = whereCallbacks;
+    this.#returningColumns = returningColumns;
+    this.#rowFields = rowFields;
+  }
+
+  where(expr: ExpressionBuilder<AvailableScope, QC>): UpdateQuery<QC, AvailableScope, RowType> {
+    return new UpdateQueryImpl(
+      this.#tableName,
+      this.#table,
+      this.#scope,
+      this.#setValues,
+      this.ctx,
+      [...this.#whereCallbacks, expr as unknown as WhereCallback],
+      this.#returningColumns,
+      this.#rowFields,
+    );
+  }
+
+  returning = this._gate<ReturningCapability, string[], UpdateQuery<QC, AvailableScope, never>>(
+    { sql: { returning: true } },
+    'returning',
+    (...columns: string[]) => {
+      const newRowFields: Record<string, ScopeField> = {};
+      for (const col of columns) {
+        const field = this.#scope.topLevel[col];
+        if (!field) throw new Error(`Column "${col}" not found in scope`);
+        newRowFields[col] = field;
+      }
+      return new UpdateQueryImpl(
+        this.#tableName,
+        this.#table,
+        this.#scope,
+        this.#setValues,
+        this.ctx,
+        this.#whereCallbacks,
+        columns,
+        newRowFields,
+      ) as unknown as UpdateQuery<QC, AvailableScope, never>;
+    },
+  );
+
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>> {
+    const setParams = buildParamValues(
+      this.#setValues,
+      this.#table,
+      this.#tableName,
+      'update',
+      this.ctx,
+    );
+
+    const whereExpr = combineWhereExprs(
+      this.#whereCallbacks.map((cb) =>
+        evaluateWhere(cb, this.#scope, this.ctx.queryOperationTypes),
+      ),
+    );
+
+    let ast = UpdateAst.table(TableSource.named(this.#tableName))
+      .withSet(setParams)
+      .withWhere(whereExpr);
+
+    if (this.#returningColumns.length > 0) {
+      ast = ast.withReturning(buildReturningColumnRefs(this.#tableName, this.#returningColumns));
+    }
+
+    return buildQueryPlan<ResolveRow<RowType, QC['codecTypes']>>(ast, this.#rowFields, this.ctx);
+  }
+}
+
+export class DeleteQueryImpl<
+    QC extends QueryContext = QueryContext,
+    AvailableScope extends Scope = Scope,
+    RowType extends Record<string, ScopeField> = Record<string, ScopeField>,
+  >
+  extends BuilderBase<QC['capabilities']>
+  implements DeleteQuery<QC, AvailableScope, RowType>
+{
+  readonly #tableName: string;
+  readonly #scope: Scope;
+  readonly #whereCallbacks: readonly WhereCallback[];
+  readonly #returningColumns: string[];
+  readonly #rowFields: Record<string, ScopeField>;
+
+  constructor(
+    tableName: string,
+    scope: Scope,
+    ctx: BuilderContext,
+    whereCallbacks: readonly WhereCallback[] = [],
+    returningColumns: string[] = [],
+    rowFields: Record<string, ScopeField> = {},
+  ) {
+    super(ctx);
+    this.#tableName = tableName;
+    this.#scope = scope;
+    this.#whereCallbacks = whereCallbacks;
+    this.#returningColumns = returningColumns;
+    this.#rowFields = rowFields;
+  }
+
+  where(expr: ExpressionBuilder<AvailableScope, QC>): DeleteQuery<QC, AvailableScope, RowType> {
+    return new DeleteQueryImpl(
+      this.#tableName,
+      this.#scope,
+      this.ctx,
+      [...this.#whereCallbacks, expr as unknown as WhereCallback],
+      this.#returningColumns,
+      this.#rowFields,
+    );
+  }
+
+  returning = this._gate<ReturningCapability, string[], DeleteQuery<QC, AvailableScope, never>>(
+    { sql: { returning: true } },
+    'returning',
+    (...columns: string[]) => {
+      const newRowFields: Record<string, ScopeField> = {};
+      for (const col of columns) {
+        const field = this.#scope.topLevel[col];
+        if (!field) throw new Error(`Column "${col}" not found in scope`);
+        newRowFields[col] = field;
+      }
+      return new DeleteQueryImpl(
+        this.#tableName,
+        this.#scope,
+        this.ctx,
+        this.#whereCallbacks,
+        columns,
+        newRowFields,
+      ) as unknown as DeleteQuery<QC, AvailableScope, never>;
+    },
+  );
+
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>> {
+    const whereExpr = combineWhereExprs(
+      this.#whereCallbacks.map((cb) =>
+        evaluateWhere(cb, this.#scope, this.ctx.queryOperationTypes),
+      ),
+    );
+
+    let ast = DeleteAst.from(TableSource.named(this.#tableName)).withWhere(whereExpr);
+
+    if (this.#returningColumns.length > 0) {
+      ast = ast.withReturning(buildReturningColumnRefs(this.#tableName, this.#returningColumns));
+    }
+
+    return buildQueryPlan<ResolveRow<RowType, QC['codecTypes']>>(ast, this.#rowFields, this.ctx);
+  }
+}

package/src/runtime/query-impl.ts

@@ -0,0 +1,254 @@
+import { DerivedTableSource, type SelectAst } from '@prisma-next/sql-relational-core/ast';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import type {
+  AggregateFunctions,
+  BooleanCodecType,
+  Expression,
+  ExpressionBuilder,
+  ExtractScopeFields,
+  FieldProxy,
+  Functions,
+  OrderByOptions,
+  OrderByScope,
+  WithField,
+  WithFields,
+} from '../expression';
+import type { ResolveRow } from '../resolve';
+import type {
+  Expand,
+  JoinOuterScope,
+  JoinSource,
+  QueryContext,
+  Scope,
+  ScopeField,
+  // biome-ignore lint/correctness/noUnusedImports: used in `declare` property
+  SubqueryMarker,
+} from '../scope';
+import type { GroupedQuery } from '../types/grouped-query';
+import type { SelectQuery } from '../types/select-query';
+import {
+  BuilderBase,
+  type BuilderContext,
+  type BuilderState,
+  buildPlan,
+  buildSelectAst,
+  cloneState,
+  orderByScopeOf,
+  resolveDistinctOn,
+  resolveGroupBy,
+  resolveOrderBy,
+  resolveSelectArgs,
+} from './builder-base';
+import { createFieldProxy } from './field-proxy';
+import { createAggregateFunctions, createFunctions } from './functions';
+
+abstract class QueryBase<
+  QC extends QueryContext = QueryContext,
+  AvailableScope extends Scope = Scope,
+  RowType extends Record<string, ScopeField> = Record<string, ScopeField>,
+> extends BuilderBase<QC['capabilities']> {
+  protected readonly state: BuilderState;
+
+  constructor(state: BuilderState, ctx: BuilderContext) {
+    super(ctx);
+    this.state = state;
+  }
+
+  protected abstract clone(state: BuilderState): this;
+
+  distinctOn = this._gate(
+    { postgres: { distinctOn: true } },
+    'distinctOn',
+    (...args: unknown[]) => {
+      const exprs = resolveDistinctOn(args, this.state.scope, this.state.rowFields, this.ctx);
+      return this.clone(
+        cloneState(this.state, {
+          distinctOn: [...(this.state.distinctOn ?? []), ...exprs],
+        }),
+      );
+    },
+  );
+
+  limit(count: number): this {
+    return this.clone(cloneState(this.state, { limit: count }));
+  }
+
+  offset(count: number): this {
+    return this.clone(cloneState(this.state, { offset: count }));
+  }
+
+  distinct(): this {
+    return this.clone(cloneState(this.state, { distinct: true }));
+  }
+
+  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>;
+  groupBy(...args: unknown[]): unknown {
+    const exprs = resolveGroupBy(args, this.state.scope, this.state.rowFields, this.ctx);
+    return new GroupedQueryImpl<QC, AvailableScope, RowType>(
+      cloneState(this.state, { groupBy: [...this.state.groupBy, ...exprs] }),
+      this.ctx,
+    );
+  }
+
+  as<Alias extends string>(alias: Alias): JoinSource<RowType, Alias> {
+    const ast = buildSelectAst(this.state);
+    const derivedSource = DerivedTableSource.as(alias, ast);
+    const scope = {
+      topLevel: this.state.rowFields as RowType,
+      namespaces: { [alias]: this.state.rowFields } as Record<Alias, RowType>,
+    };
+    return {
+      getJoinOuterScope: () => scope,
+      buildAst: () => derivedSource,
+
+      // `as unknown` is necessary, because JoinOuterScope is a phantom type-only property that does not exist at runtime
+    } satisfies Omit<JoinSource<RowType, Alias>, typeof JoinOuterScope> as unknown as JoinSource<
+      RowType,
+      Alias
+    >;
+  }
+
+  getRowFields(): Record<string, ScopeField> {
+    return this.state.rowFields;
+  }
+
+  buildAst(): SelectAst {
+    return buildSelectAst(this.state);
+  }
+
+  build(): SqlQueryPlan<ResolveRow<RowType, QC['codecTypes']>> {
+    return buildPlan<ResolveRow<RowType, QC['codecTypes']>>(this.state, this.ctx);
+  }
+}
+
+export class SelectQueryImpl<
+    QC extends QueryContext = QueryContext,
+    AvailableScope extends Scope = Scope,
+    RowType extends Record<string, ScopeField> = Record<string, ScopeField>,
+  >
+  extends QueryBase<QC, AvailableScope, RowType>
+  implements SelectQuery<QC, AvailableScope, RowType>
+{
+  declare readonly [SubqueryMarker]: RowType;
+
+  protected clone(state: BuilderState): this {
+    return new SelectQueryImpl<QC, AvailableScope, RowType>(state, this.ctx) as this;
+  }
+
+  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>>>;
+  select(...args: unknown[]): unknown {
+    const { projections, newRowFields } = resolveSelectArgs(args, this.state.scope, this.ctx);
+    return new SelectQueryImpl(
+      cloneState(this.state, {
+        projections: [...this.state.projections, ...projections],
+        rowFields: { ...this.state.rowFields, ...newRowFields },
+      }),
+      this.ctx,
+    );
+  }
+
+  where(expr: ExpressionBuilder<AvailableScope, QC>): SelectQuery<QC, AvailableScope, RowType> {
+    const fieldProxy = createFieldProxy(this.state.scope);
+    const fns = createFunctions<QC>(this.ctx.queryOperationTypes);
+    const result = (expr as ExpressionBuilder<Scope, QueryContext>)(fieldProxy, fns as never);
+    return new SelectQueryImpl(
+      cloneState(this.state, {
+        where: [...this.state.where, result.buildAst()],
+      }),
+      this.ctx,
+    );
+  }
+
+  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>;
+  orderBy(arg: unknown, options?: OrderByOptions): unknown {
+    const item = resolveOrderBy(
+      arg,
+      options,
+      this.state.scope,
+      this.state.rowFields,
+      this.ctx,
+      false,
+    );
+    return this.clone(cloneState(this.state, { orderBy: [...this.state.orderBy, item] }));
+  }
+}
+
+export class GroupedQueryImpl<
+    QC extends QueryContext = QueryContext,
+    AvailableScope extends Scope = Scope,
+    RowType extends Record<string, ScopeField> = Record<string, ScopeField>,
+  >
+  extends QueryBase<QC, AvailableScope, RowType>
+  implements GroupedQuery<QC, AvailableScope, RowType>
+{
+  declare readonly [SubqueryMarker]: RowType;
+
+  protected clone(state: BuilderState): this {
+    return new GroupedQueryImpl<QC, AvailableScope, RowType>(state, this.ctx) as this;
+  }
+
+  having(
+    expr: (
+      fields: FieldProxy<OrderByScope<AvailableScope, RowType>>,
+      fns: AggregateFunctions<QC>,
+    ) => Expression<BooleanCodecType>,
+  ): GroupedQuery<QC, AvailableScope, RowType> {
+    const combined = orderByScopeOf(
+      this.state.scope as AvailableScope,
+      this.state.rowFields as RowType,
+    );
+    const fns = createAggregateFunctions(this.ctx.queryOperationTypes);
+    const result = expr(createFieldProxy(combined), fns);
+    return new GroupedQueryImpl(cloneState(this.state, { having: result.buildAst() }), this.ctx);
+  }
+
+  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>;
+  orderBy(arg: unknown, options?: OrderByOptions): unknown {
+    const item = resolveOrderBy(
+      arg,
+      options,
+      this.state.scope,
+      this.state.rowFields,
+      this.ctx,
+      true,
+    );
+    return this.clone(cloneState(this.state, { orderBy: [...this.state.orderBy, item] }));
+  }
+}

package/src/runtime/sql.ts

@@ -0,0 +1,31 @@
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import type { Db } from '../types/db';
+import type { BuilderContext } from './builder-base';
+import { TableProxyImpl } from './table-proxy-impl';
+
+export interface SqlOptions<C extends SqlContract<SqlStorage>> {
+  readonly context: ExecutionContext<C>;
+}
+
+export function sql<C extends SqlContract<SqlStorage>>(options: SqlOptions<C>): Db<C> {
+  const { context } = options;
+  const ctx: BuilderContext = {
+    capabilities: context.contract.capabilities,
+    queryOperationTypes: context.queryOperations.entries(),
+    target: context.contract.target ?? 'unknown',
+    storageHash: context.contract.storageHash ?? 'unknown',
+    applyMutationDefaults: (options) => context.applyMutationDefaults(options),
+  };
+
+  return new Proxy({} as Db<C>, {
+    get(_target, prop: string) {
+      const tables = context.contract.storage.tables;
+      const table = Object.hasOwn(tables, prop) ? tables[prop] : undefined;
+      if (table) {
+        return new TableProxyImpl(prop, table, prop, ctx);
+      }
+      return undefined;
+    },
+  });
+}