@prisma-next/sql-builder 0.0.1

package/src/runtime/expression-impl.ts

@@ -0,0 +1,23 @@
+import type { AnyExpression as AstExpression } from '@prisma-next/sql-relational-core/ast';
+import type { Expression } from '../expression';
+// biome-ignore lint/correctness/noUnusedImports: used in `declare` property
+import type { ExpressionType, ScopeField } from '../scope';
+
+/**
+ * Runtime wrapper around a relational-core AST expression node.
+ * Carries ScopeField metadata (codecId, nullable) for plan generation.
+ */
+export class ExpressionImpl<T extends ScopeField = ScopeField> implements Expression<T> {
+  declare readonly [ExpressionType]: T;
+  private readonly ast: AstExpression;
+  readonly field: T;
+
+  constructor(ast: AstExpression, field: T) {
+    this.ast = ast;
+    this.field = field;
+  }
+
+  buildAst(): AstExpression {
+    return this.ast;
+  }
+}

package/src/runtime/field-proxy.ts

@@ -0,0 +1,37 @@
+import { ColumnRef, IdentifierRef } from '@prisma-next/sql-relational-core/ast';
+import type { FieldProxy } from '../expression';
+import type { Scope, ScopeTable } from '../scope';
+import { ExpressionImpl } from './expression-impl';
+
+export function createFieldProxy<S extends Scope>(scope: S): FieldProxy<S> {
+  return new Proxy({} as FieldProxy<S>, {
+    get(_target, prop: string) {
+      if (Object.hasOwn(scope.topLevel, prop)) {
+        const topField = scope.topLevel[prop];
+        if (topField) return new ExpressionImpl(IdentifierRef.of(prop), topField);
+      }
+
+      if (Object.hasOwn(scope.namespaces, prop)) {
+        const nsFields = scope.namespaces[prop];
+        if (nsFields) return createNamespaceProxy(prop, nsFields);
+      }
+
+      return undefined;
+    },
+  });
+}
+
+function createNamespaceProxy(
+  namespaceName: string,
+  fields: ScopeTable,
+): Record<string, ExpressionImpl> {
+  return new Proxy({} as Record<string, ExpressionImpl>, {
+    get(_target, prop: string) {
+      if (Object.hasOwn(fields, prop)) {
+        const field = fields[prop];
+        if (field) return new ExpressionImpl(ColumnRef.of(namespaceName, prop), field);
+      }
+      return undefined;
+    },
+  });
+}

package/src/runtime/functions.ts

@@ -0,0 +1,190 @@
+import {
+  AggregateExpr,
+  AndExpr,
+  type AnyExpression as AstExpression,
+  BinaryExpr,
+  type BinaryOp,
+  ExistsExpr,
+  ListExpression,
+  LiteralExpr,
+  NullCheckExpr,
+  OperationExpr,
+  OrExpr,
+  ParamRef,
+  SubqueryExpr,
+} from '@prisma-next/sql-relational-core/ast';
+import type { QueryOperationEntry } from '@prisma-next/sql-relational-core/query-operations';
+import type {
+  AggregateFunctions,
+  AggregateOnlyFunctions,
+  BooleanCodecType,
+  BuiltinFunctions,
+  Expression,
+  ExpressionOrValue,
+  Functions,
+} from '../expression';
+import type { QueryContext, ScopeField, Subquery } from '../scope';
+import { ExpressionImpl } from './expression-impl';
+
+type CodecTypes = Record<string, { readonly input: unknown }>;
+type ExprOrVal<T extends ScopeField = ScopeField> = ExpressionOrValue<T, CodecTypes>;
+
+const BOOL_FIELD: BooleanCodecType = { codecId: 'pg/bool@1', nullable: false };
+
+function resolve(value: ExprOrVal): AstExpression {
+  if (value instanceof ExpressionImpl) return value.buildAst();
+  return ParamRef.of(value);
+}
+
+function resolveToAst(value: ExprOrVal): AstExpression {
+  if (value instanceof ExpressionImpl) return value.buildAst();
+  return new LiteralExpr(value);
+}
+
+function boolExpr(astNode: AstExpression): ExpressionImpl<BooleanCodecType> {
+  return new ExpressionImpl(astNode, BOOL_FIELD);
+}
+
+function eq(a: ExprOrVal, b: ExprOrVal): ExpressionImpl<BooleanCodecType> {
+  if (b === null) return boolExpr(NullCheckExpr.isNull(resolve(a)));
+  if (a === null) return boolExpr(NullCheckExpr.isNull(resolve(b)));
+  return boolExpr(new BinaryExpr('eq', resolve(a), resolve(b)));
+}
+
+function ne(a: ExprOrVal, b: ExprOrVal): ExpressionImpl<BooleanCodecType> {
+  if (b === null) return boolExpr(NullCheckExpr.isNotNull(resolve(a)));
+  if (a === null) return boolExpr(NullCheckExpr.isNotNull(resolve(b)));
+  return boolExpr(new BinaryExpr('neq', resolve(a), resolve(b)));
+}
+
+function comparison(a: ExprOrVal, b: ExprOrVal, op: BinaryOp): ExpressionImpl<BooleanCodecType> {
+  return boolExpr(new BinaryExpr(op, resolve(a), resolve(b)));
+}
+
+function inOrNotIn(
+  expr: Expression<ScopeField>,
+  valuesOrSubquery: Subquery<Record<string, ScopeField>> | ExprOrVal[],
+  op: 'in' | 'notIn',
+): ExpressionImpl<BooleanCodecType> {
+  const left = expr.buildAst();
+  const binaryFn = op === 'in' ? BinaryExpr.in : BinaryExpr.notIn;
+
+  if (Array.isArray(valuesOrSubquery)) {
+    const refs = valuesOrSubquery.map((v) => resolve(v));
+    return boolExpr(binaryFn(left, ListExpression.of(refs)));
+  }
+  return boolExpr(binaryFn(left, SubqueryExpr.of(valuesOrSubquery.buildAst())));
+}
+
+function numericAgg(
+  fn: 'sum' | 'avg' | 'min' | 'max',
+  expr: Expression<ScopeField>,
+): ExpressionImpl<{ codecId: string; nullable: true }> {
+  return new ExpressionImpl(AggregateExpr[fn](expr.buildAst()), {
+    codecId: (expr as ExpressionImpl).field.codecId,
+    nullable: true as const,
+  });
+}
+
+function createBuiltinFunctions() {
+  return {
+    eq: (a: ExprOrVal, b: ExprOrVal) => eq(a, b),
+    ne: (a: ExprOrVal, b: ExprOrVal) => ne(a, b),
+    gt: (a: ExprOrVal, b: ExprOrVal) => comparison(a, b, 'gt'),
+    gte: (a: ExprOrVal, b: ExprOrVal) => comparison(a, b, 'gte'),
+    lt: (a: ExprOrVal, b: ExprOrVal) => comparison(a, b, 'lt'),
+    lte: (a: ExprOrVal, b: ExprOrVal) => comparison(a, b, 'lte'),
+    and: (...exprs: ExprOrVal<BooleanCodecType>[]) => boolExpr(AndExpr.of(exprs.map(resolveToAst))),
+    or: (...exprs: ExprOrVal<BooleanCodecType>[]) => boolExpr(OrExpr.of(exprs.map(resolveToAst))),
+    exists: (subquery: Subquery<Record<string, ScopeField>>) =>
+      boolExpr(ExistsExpr.exists(subquery.buildAst())),
+    notExists: (subquery: Subquery<Record<string, ScopeField>>) =>
+      boolExpr(ExistsExpr.notExists(subquery.buildAst())),
+    in: (
+      expr: Expression<ScopeField>,
+      valuesOrSubquery: Subquery<Record<string, ScopeField>> | ExprOrVal[],
+    ) => inOrNotIn(expr, valuesOrSubquery, 'in'),
+    notIn: (
+      expr: Expression<ScopeField>,
+      valuesOrSubquery: Subquery<Record<string, ScopeField>> | ExprOrVal[],
+    ) => inOrNotIn(expr, valuesOrSubquery, 'notIn'),
+  } satisfies BuiltinFunctions<CodecTypes>;
+}
+
+function createAggregateOnlyFunctions() {
+  return {
+    count: (expr?: Expression<ScopeField>) => {
+      const astExpr = expr ? expr.buildAst() : undefined;
+      return new ExpressionImpl(AggregateExpr.count(astExpr), {
+        codecId: 'pg/int8@1',
+        nullable: false,
+      });
+    },
+    sum: (expr: Expression<ScopeField>) => numericAgg('sum', expr),
+    avg: (expr: Expression<ScopeField>) => numericAgg('avg', expr),
+    min: (expr: Expression<ScopeField>) => numericAgg('min', expr),
+    max: (expr: Expression<ScopeField>) => numericAgg('max', expr),
+  } satisfies AggregateOnlyFunctions;
+}
+
+function createExtensionFunction(
+  name: string,
+  entry: QueryOperationEntry,
+): (...args: ExprOrVal[]) => ExpressionImpl {
+  return (...args: ExprOrVal[]) => {
+    const resolvedArgs = args.map((arg, i) => {
+      if (arg instanceof ExpressionImpl) return arg.buildAst();
+      const codecId = entry.args[i]?.codecId;
+      return ParamRef.of(arg, codecId ? { codecId } : undefined);
+    });
+    const self = resolvedArgs[0] as AstExpression;
+    const restArgs = resolvedArgs.slice(1);
+
+    return new ExpressionImpl(
+      new OperationExpr({
+        method: name,
+        forTypeId: entry.args[0]?.codecId ?? 'unknown',
+        self,
+        args: restArgs.length > 0 ? restArgs : undefined,
+        returns: { kind: 'typeId', type: entry.returns.codecId },
+        lowering: entry.lowering,
+      }),
+      entry.returns,
+    );
+  };
+}
+
+export function createFunctions<QC extends QueryContext>(
+  queryOperationTypes: Readonly<Record<string, QueryOperationEntry>>,
+): Functions<QC> {
+  const builtins = createBuiltinFunctions();
+
+  return new Proxy({} as Functions<QC>, {
+    get(_target, prop: string) {
+      const builtin = (builtins as Record<string, unknown>)[prop];
+      if (builtin) return builtin;
+
+      const extOp = queryOperationTypes[prop];
+      if (extOp) {
+        return createExtensionFunction(prop, extOp);
+      }
+      return undefined;
+    },
+  });
+}
+
+export function createAggregateFunctions<QC extends QueryContext>(
+  queryOperationTypes: Readonly<Record<string, QueryOperationEntry>>,
+): AggregateFunctions<QC> {
+  const baseFns = createFunctions<QC>(queryOperationTypes);
+  const aggregates = createAggregateOnlyFunctions();
+
+  return new Proxy({} as AggregateFunctions<QC>, {
+    get(_target, prop: string) {
+      const agg = (aggregates as Record<string, unknown>)[prop];
+      if (agg) return agg;
+
+      return (baseFns as Record<string, unknown>)[prop];
+    },
+  });
+}

package/src/runtime/index.ts

@@ -0,0 +1,4 @@
+export { ExpressionImpl } from './expression-impl';
+export { createFieldProxy } from './field-proxy';
+export { createAggregateFunctions, createFunctions } from './functions';
+export { type SqlOptions, sql } from './sql';

package/src/runtime/joined-tables-impl.ts

@@ -0,0 +1,238 @@
+import {
+  AndExpr,
+  DerivedTableSource,
+  JoinAst,
+  type 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,
+  Scope,
+  ScopeField,
+  ScopeTable,
+  Subquery,
+} from '../scope';
+import type { JoinedTables } from '../types/joined-tables';
+import type { SelectQuery } from '../types/select-query';
+import type { LateralBuilder } from '../types/shared';
+import {
+  BuilderBase,
+  type BuilderContext,
+  type BuilderState,
+  cloneState,
+  emptyState,
+  mergeScopes,
+  nullableScope,
+  resolveSelectArgs,
+} from './builder-base';
+import { createFieldProxy } from './field-proxy';
+import { createFunctions } from './functions';
+import { SelectQueryImpl } from './query-impl';
+
+export class JoinedTablesImpl<QC extends QueryContext, AvailableScope extends Scope>
+  extends BuilderBase<QC['capabilities']>
+  implements JoinedTables<QC, AvailableScope>
+{
+  readonly #state: BuilderState;
+
+  constructor(state: BuilderState, ctx: BuilderContext) {
+    super(ctx);
+    this.#state = state;
+  }
+
+  lateralJoin = this._gate(
+    { sql: { lateral: true } },
+    'lateralJoin',
+    <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> }>
+    > => {
+      const { derivedSource, lateralScope } = this.#buildLateral(alias, builder);
+      const resultScope = mergeScopes(
+        this.#state.scope as AvailableScope,
+        lateralScope as { topLevel: LateralRow; namespaces: Record<Alias, LateralRow> },
+      );
+      return this.#addLateralJoin('inner', resultScope, derivedSource);
+    },
+  ) as JoinedTables<QC, AvailableScope>['lateralJoin'];
+
+  outerLateralJoin = this._gate(
+    { sql: { lateral: true } },
+    'outerLateralJoin',
+    <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> }>
+      >
+    > => {
+      const { derivedSource, lateralScope } = this.#buildLateral(alias, builder);
+      const resultScope = mergeScopes(
+        this.#state.scope as AvailableScope,
+        nullableScope(
+          lateralScope as { topLevel: LateralRow; namespaces: Record<Alias, LateralRow> },
+        ),
+      );
+      return this.#addLateralJoin('left', resultScope, derivedSource);
+    },
+  ) as JoinedTables<QC, AvailableScope>['outerLateralJoin'];
+
+  select<Columns extends (keyof AvailableScope['topLevel'] & string)[]>(
+    ...columns: Columns
+  ): SelectQuery<QC, AvailableScope, WithFields<EmptyRow, 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<EmptyRow, Field, Alias>>;
+  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 {
+    const { projections, newRowFields } = resolveSelectArgs(args, this.#state.scope, this.ctx);
+    return new SelectQueryImpl<QC, AvailableScope>(
+      cloneState(this.#state, {
+        projections: [...this.#state.projections, ...projections],
+        rowFields: { ...this.#state.rowFields, ...newRowFields },
+      }),
+      this.ctx,
+    );
+  }
+
+  innerJoin<Other extends JoinSource<ScopeTable, string | never>>(
+    other: Other,
+    on: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>> {
+    const targetScope = mergeScopes(
+      this.#state.scope as AvailableScope,
+      other.getJoinOuterScope() as Other[typeof JoinOuterScope],
+    );
+    return this.#addJoin(other, 'inner', targetScope, 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]>>> {
+    const targetScope = mergeScopes(
+      this.#state.scope as AvailableScope,
+      nullableScope(other.getJoinOuterScope() as Other[typeof JoinOuterScope]),
+    );
+    return this.#addJoin(other, 'left', targetScope, 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]>> {
+    const targetScope = mergeScopes(
+      nullableScope(this.#state.scope as AvailableScope),
+      other.getJoinOuterScope() as Other[typeof JoinOuterScope],
+    );
+    return this.#addJoin(other, 'right', targetScope, 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]>>
+  > {
+    const targetScope = mergeScopes(
+      nullableScope(this.#state.scope as AvailableScope),
+      nullableScope(other.getJoinOuterScope() as Other[typeof JoinOuterScope]),
+    );
+    return this.#addJoin(other, 'full', targetScope, on);
+  }
+
+  #addJoin<Other extends JoinSource<ScopeTable, string | never>, ResultScope extends Scope>(
+    other: Other,
+    joinType: 'inner' | 'left' | 'right' | 'full',
+    resultScope: ResultScope,
+    onExpr: ExpressionBuilder<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>, QC>,
+  ): JoinedTables<QC, ResultScope> {
+    const fieldProxy = createFieldProxy(
+      mergeScopes(
+        this.#state.scope as AvailableScope,
+        other.getJoinOuterScope() as Other[typeof JoinOuterScope],
+      ),
+    ) as FieldProxy<MergeScopes<AvailableScope, Other[typeof JoinOuterScope]>>;
+    const fns = createFunctions<QC>(this.ctx.queryOperationTypes);
+    const onResult = onExpr(fieldProxy, fns);
+    const joinAst = new JoinAst(joinType, other.buildAst(), onResult.buildAst());
+
+    return new JoinedTablesImpl(
+      cloneState(this.#state, {
+        joins: [...this.#state.joins, joinAst],
+        scope: resultScope,
+      }),
+      this.ctx,
+    );
+  }
+
+  #buildLateral(
+    alias: string,
+    builderFn: (
+      lateral: LateralBuilder<QC, AvailableScope>,
+    ) => Subquery<Record<string, ScopeField>>,
+  ) {
+    const lateralBuilder: LateralBuilder<QC, AvailableScope> = {
+      from: (other) => {
+        const otherScope = other.getJoinOuterScope();
+        const parentMerged = mergeScopes(this.#state.scope, otherScope);
+        return new SelectQueryImpl(
+          emptyState(other.buildAst() as TableSource, parentMerged),
+          this.ctx,
+        ) as unknown as SelectQuery<QC, AvailableScope, EmptyRow>;
+      },
+    };
+
+    const subquery = builderFn(lateralBuilder);
+    const subqueryAst = subquery.buildAst();
+    const derivedSource = DerivedTableSource.as(alias, subqueryAst);
+    const subqueryRowFields: ScopeTable = subquery.getRowFields();
+    const lateralScope: Scope = {
+      topLevel: subqueryRowFields,
+      namespaces: { [alias]: subqueryRowFields },
+    };
+
+    return { derivedSource, lateralScope };
+  }
+
+  #addLateralJoin<ResultScope extends Scope>(
+    joinType: 'inner' | 'left',
+    resultScope: ResultScope,
+    derivedSource: DerivedTableSource,
+  ): JoinedTables<QC, ResultScope> {
+    const onExpr = AndExpr.of([]);
+    const joinAst = new JoinAst(joinType, derivedSource, onExpr, true);
+
+    return new JoinedTablesImpl(
+      cloneState(this.#state, {
+        joins: [...this.#state.joins, joinAst],
+        scope: resultScope,
+      }),
+      this.ctx,
+    );
+  }
+}