@prisma-next/sql-relational-core 0.3.0-pr.99.6 → 0.3.0

package/src/ast/delete.ts

@@ -1,17 +0,0 @@
-import type { BinaryExpr, ColumnRef, DeleteAst, TableRef } from './types';
-import { compact } from './util';
-
-export interface CreateDeleteAstOptions {
-  readonly table: TableRef;
-  readonly where: BinaryExpr;
-  readonly returning?: ReadonlyArray<ColumnRef>;
-}
-
-export function createDeleteAst(options: CreateDeleteAstOptions): DeleteAst {
-  return compact({
-    kind: 'delete',
-    table: options.table,
-    where: options.where,
-    returning: options.returning,
-  }) as DeleteAst;
-}

package/src/ast/insert.ts

@@ -1,17 +0,0 @@
-import type { ColumnRef, InsertAst, ParamRef, TableRef } from './types';
-import { compact } from './util';
-
-export interface CreateInsertAstOptions {
-  readonly table: TableRef;
-  readonly values: Record<string, ColumnRef | ParamRef>;
-  readonly returning?: ReadonlyArray<ColumnRef>;
-}
-
-export function createInsertAst(options: CreateInsertAstOptions): InsertAst {
-  return compact({
-    kind: 'insert',
-    table: options.table,
-    values: options.values,
-    returning: options.returning,
-  }) as InsertAst;
-}

package/src/ast/join.ts

@@ -1,54 +0,0 @@
-import { planInvalid } from '@prisma-next/plan';
-import type { AnyColumnBuilder, JoinOnBuilder, JoinOnPredicate } from '../types';
-import { isColumnBuilder } from '../types';
-import type { ColumnRef, JoinAst, JoinOnExpr, TableRef } from './types';
-
-export function createJoin(
-  joinType: 'inner' | 'left' | 'right' | 'full',
-  table: TableRef,
-  on: JoinOnExpr,
-): JoinAst {
-  return {
-    kind: 'join',
-    joinType,
-    table,
-    on,
-  };
-}
-
-export function createJoinOnExpr(left: ColumnRef, right: ColumnRef): JoinOnExpr {
-  return {
-    kind: 'eqCol',
-    left,
-    right,
-  };
-}
-
-class JoinOnBuilderImpl implements JoinOnBuilder {
-  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate {
-    if (!left || !isColumnBuilder(left)) {
-      throw planInvalid('Join ON left operand must be a column');
-    }
-
-    if (!right || !isColumnBuilder(right)) {
-      throw planInvalid('Join ON right operand must be a column');
-    }
-
-    // TypeScript can't narrow ColumnBuilder properly, so we assert
-    const leftCol = left as unknown as { table: string; column: string };
-    const rightCol = right as unknown as { table: string; column: string };
-    if (leftCol.table === rightCol.table) {
-      throw planInvalid('Self-joins are not supported in MVP');
-    }
-
-    return {
-      kind: 'join-on',
-      left: left as AnyColumnBuilder,
-      right: right as AnyColumnBuilder,
-    };
-  }
-}
-
-export function createJoinOnBuilder(): JoinOnBuilder {
-  return new JoinOnBuilderImpl();
-}

package/src/ast/order.ts

@@ -1,11 +0,0 @@
-import type { ColumnRef, Direction, OperationExpr } from './types';
-
-export function createOrderByItem(
-  expr: ColumnRef | OperationExpr,
-  dir: 'asc' | 'desc',
-): { expr: ColumnRef | OperationExpr; dir: Direction } {
-  return {
-    expr,
-    dir,
-  };
-}

package/src/ast/predicate.ts

@@ -1,22 +0,0 @@
-import type { BinaryExpr, BinaryOp, ExistsExpr, Expression, ParamRef, SelectAst } from './types';
-
-export function createBinaryExpr(
-  op: BinaryOp,
-  left: Expression,
-  right: Expression | ParamRef,
-): BinaryExpr {
-  return {
-    kind: 'bin',
-    op,
-    left,
-    right,
-  };
-}
-
-export function createExistsExpr(not: boolean, subquery: SelectAst): ExistsExpr {
-  return {
-    kind: 'exists',
-    not,
-    subquery,
-  };
-}

package/src/ast/select.ts

@@ -1,39 +0,0 @@
-import type {
-  BinaryExpr,
-  ColumnRef,
-  Direction,
-  ExistsExpr,
-  IncludeAst,
-  IncludeRef,
-  JoinAst,
-  OperationExpr,
-  SelectAst,
-  TableRef,
-} from './types';
-import { compact } from './util';
-
-export interface CreateSelectAstOptions {
-  readonly from: TableRef;
-  readonly joins?: ReadonlyArray<JoinAst>;
-  readonly includes?: ReadonlyArray<IncludeAst>;
-  readonly project: ReadonlyArray<{
-    alias: string;
-    expr: ColumnRef | IncludeRef | OperationExpr;
-  }>;
-  readonly where?: BinaryExpr | ExistsExpr;
-  readonly orderBy?: ReadonlyArray<{ expr: ColumnRef | OperationExpr; dir: Direction }>;
-  readonly limit?: number;
-}
-
-export function createSelectAst(options: CreateSelectAstOptions): SelectAst {
-  return compact({
-    kind: 'select',
-    from: options.from,
-    joins: options.joins,
-    includes: options.includes,
-    project: options.project,
-    where: options.where,
-    orderBy: options.orderBy,
-    limit: options.limit,
-  }) as SelectAst;
-}

package/src/ast/update.ts

@@ -1,19 +0,0 @@
-import type { BinaryExpr, ColumnRef, ParamRef, TableRef, UpdateAst } from './types';
-import { compact } from './util';
-
-export interface CreateUpdateAstOptions {
-  readonly table: TableRef;
-  readonly set: Record<string, ColumnRef | ParamRef>;
-  readonly where: BinaryExpr;
-  readonly returning?: ReadonlyArray<ColumnRef>;
-}
-
-export function createUpdateAst(options: CreateUpdateAstOptions): UpdateAst {
-  return compact({
-    kind: 'update',
-    table: options.table,
-    set: options.set,
-    where: options.where,
-    returning: options.returning,
-  }) as UpdateAst;
-}

package/src/exports/guards.ts

@@ -1,15 +0,0 @@
-export {
-  collectColumnRefs,
-  expressionFromSource,
-  extractBaseColumnRef,
-  getColumnInfo,
-  getColumnMeta,
-  getOperationExpr,
-  isColumnBuilder,
-  isExpressionBuilder,
-  isExpressionSource,
-  isOperationExpr,
-  isParamPlaceholder,
-  isValueSource,
-  toExpression,
-} from '../utils/guards';

package/src/exports/operations-registry.ts

@@ -1 +0,0 @@
-export { attachOperationsToColumnBuilder } from '../operations-registry';

package/src/exports/param.ts

@@ -1,2 +0,0 @@
-export type { Parameter } from '../param';
-export { param } from '../param';

package/src/exports/schema.ts

@@ -1,6 +0,0 @@
-export type {
-  ColumnBuilderImpl as Column,
-  SchemaHandle,
-  TableBuilderImpl as Table,
-} from '../schema';
-export { ColumnBuilderImpl, schema, TableBuilderImpl } from '../schema';

package/src/operations-registry.ts

@@ -1,276 +0,0 @@
-import type { OperationRegistry } from '@prisma-next/operations';
-import { hasAllCapabilities } from '@prisma-next/operations';
-import { planInvalid } from '@prisma-next/plan';
-import type { StorageColumn } from '@prisma-next/sql-contract/types';
-import type { SqlOperationSignature } from '@prisma-next/sql-operations';
-import type {
-  BinaryOp,
-  Expression,
-  ExpressionSource,
-  LiteralExpr,
-  OperationExpr,
-  ParamRef,
-} from './ast/types';
-import type {
-  AnyBinaryBuilder,
-  AnyOrderBuilder,
-  ColumnBuilder,
-  ExpressionBuilder,
-  OperationTypes,
-  ParamPlaceholder,
-} from './types';
-import { isParamPlaceholder } from './utils/guards';
-
-/**
- * Type guard to check if a value is an ExpressionSource (has toExpr method).
- */
-function isExpressionSource(value: unknown): value is ExpressionSource {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'toExpr' in value &&
-    typeof (value as ExpressionSource).toExpr === 'function'
-  );
-}
-
-/**
- * Executes an operation and returns an ExpressionBuilder.
- * This is the canonical entrypoint for operation invocation, enabling
- * future enhancements like telemetry, caching, or tracing.
- *
- * The returned ExpressionBuilder:
- * - Has `kind: 'expression'` to distinguish it from ColumnBuilder
- * - Contains the operation expression in `expr`
- * - Provides `toExpr()` method to get the Expression
- * - Provides comparison and ordering methods for chaining
- *
- * @param signature - The operation signature from the registry
- * @param selfBuilder - The expression source that the operation is called on
- * @param args - The arguments passed to the operation
- * @param columnMeta - The metadata of the column the operation is called on
- * @returns An ExpressionBuilder containing the operation expression
- */
-function executeOperation(
-  signature: SqlOperationSignature,
-  selfBuilder: ExpressionSource,
-  args: unknown[],
-  columnMeta: StorageColumn,
-  operationRegistry?: OperationRegistry,
-  contractCapabilities?: Record<string, Record<string, boolean>>,
-): ExpressionBuilder {
-  if (args.length !== signature.args.length) {
-    throw planInvalid(
-      `Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`,
-    );
-  }
-
-  // Get the Expression from the self builder using toExpr()
-  const selfExpr: Expression = selfBuilder.toExpr();
-
-  const operationArgs: Array<Expression | ParamRef | LiteralExpr> = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const argSpec = signature.args[i];
-    if (!argSpec) {
-      throw planInvalid(`Missing argument spec for argument ${i}`);
-    }
-
-    if (argSpec.kind === 'param') {
-      if (!isParamPlaceholder(arg)) {
-        throw planInvalid(`Argument ${i} must be a parameter placeholder`);
-      }
-      operationArgs.push({
-        kind: 'param',
-        index: 0,
-        name: arg.name,
-      });
-    } else if (argSpec.kind === 'typeId') {
-      // Accept ExpressionSource (ColumnBuilder or ExpressionBuilder)
-      if (!isExpressionSource(arg)) {
-        throw planInvalid(
-          `Argument ${i} must be an ExpressionSource (ColumnBuilder or ExpressionBuilder)`,
-        );
-      }
-      // Use toExpr() to get the Expression
-      operationArgs.push(arg.toExpr());
-    } else if (argSpec.kind === 'literal') {
-      operationArgs.push({
-        kind: 'literal',
-        value: arg,
-      });
-    }
-  }
-
-  const operationExpr: OperationExpr = {
-    kind: 'operation',
-    method: signature.method,
-    forTypeId: signature.forTypeId,
-    self: selfExpr,
-    args: operationArgs,
-    returns: signature.returns,
-    lowering: signature.lowering,
-  };
-
-  const returnTypeId = signature.returns.kind === 'typeId' ? signature.returns.type : undefined;
-  const returnColumnMeta: StorageColumn = returnTypeId
-    ? {
-        ...columnMeta,
-        codecId: returnTypeId,
-      }
-    : columnMeta;
-
-  const createComparisonMethod =
-    (op: BinaryOp) =>
-    (value: ParamPlaceholder | ExpressionSource): AnyBinaryBuilder =>
-      Object.freeze({
-        kind: 'binary' as const,
-        op,
-        left: operationExpr,
-        right: value,
-      }) as AnyBinaryBuilder;
-
-  const baseResult: ExpressionBuilder = {
-    kind: 'expression' as const,
-    expr: operationExpr,
-    get columnMeta() {
-      return returnColumnMeta;
-    },
-    eq: createComparisonMethod('eq'),
-    neq: createComparisonMethod('neq'),
-    gt: createComparisonMethod('gt'),
-    lt: createComparisonMethod('lt'),
-    gte: createComparisonMethod('gte'),
-    lte: createComparisonMethod('lte'),
-    asc(): AnyOrderBuilder {
-      return Object.freeze({
-        kind: 'order' as const,
-        expr: operationExpr,
-        dir: 'asc' as const,
-      });
-    },
-    desc(): AnyOrderBuilder {
-      return Object.freeze({
-        kind: 'order' as const,
-        expr: operationExpr,
-        dir: 'desc' as const,
-      });
-    },
-    toExpr(): OperationExpr {
-      return operationExpr;
-    },
-    get __jsType(): unknown {
-      return undefined;
-    },
-  };
-
-  // If the return type is a typeId, attach operations for that type
-  if (returnTypeId && operationRegistry) {
-    const resultWithOps = attachOperationsToExpressionBuilder(
-      baseResult,
-      returnColumnMeta,
-      operationRegistry,
-      contractCapabilities,
-    );
-    return Object.freeze(resultWithOps);
-  }
-
-  return Object.freeze(baseResult);
-}
-
-/**
- * Attaches operation methods to an ExpressionBuilder for chained operations.
- * When an operation returns a typeId, the result ExpressionBuilder needs
- * operation methods for that type.
- */
-function attachOperationsToExpressionBuilder(
-  expressionBuilder: ExpressionBuilder,
-  columnMeta: StorageColumn,
-  registry: OperationRegistry,
-  contractCapabilities?: Record<string, Record<string, boolean>>,
-): ExpressionBuilder {
-  const codecId = columnMeta.codecId;
-  if (!codecId) {
-    return expressionBuilder;
-  }
-
-  const operations = registry.byType(codecId) as SqlOperationSignature[];
-  if (operations.length === 0) {
-    return expressionBuilder;
-  }
-
-  const builderWithOps = expressionBuilder as ExpressionBuilder & Record<string, unknown>;
-
-  for (const operation of operations) {
-    if (operation.capabilities && operation.capabilities.length > 0) {
-      if (!contractCapabilities) {
-        continue;
-      }
-
-      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {
-        continue;
-      }
-    }
-    // Method sugar: attach operation as a method on the expression builder
-    builderWithOps[operation.method] = function (this: ExpressionBuilder, ...args: unknown[]) {
-      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);
-    };
-  }
-
-  return builderWithOps;
-}
-
-export function attachOperationsToColumnBuilder<
-  ColumnName extends string,
-  ColumnMeta extends StorageColumn,
-  JsType = unknown,
-  Operations extends OperationTypes = Record<string, never>,
->(
-  columnBuilder: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,
-  columnMeta: ColumnMeta,
-  registry: OperationRegistry | undefined,
-  contractCapabilities?: Record<string, Record<string, boolean>>,
-): ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations> {
-  if (!registry) {
-    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
-  }
-
-  // Use codecId to look up operations registered for this column's type
-  const codecId = columnMeta.codecId;
-  if (!codecId) {
-    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
-  }
-
-  const operations = registry.byType(codecId) as SqlOperationSignature[];
-  if (operations.length === 0) {
-    return columnBuilder as ColumnBuilder<ColumnName, ColumnMeta, JsType, Operations>;
-  }
-
-  const builderWithOps = columnBuilder as unknown as ColumnBuilder<
-    ColumnName,
-    ColumnMeta,
-    JsType,
-    Operations
-  >;
-
-  for (const operation of operations) {
-    if (operation.capabilities && operation.capabilities.length > 0) {
-      if (!contractCapabilities) {
-        continue;
-      }
-
-      if (!hasAllCapabilities(operation.capabilities, contractCapabilities)) {
-        continue;
-      }
-    }
-    // Method sugar: attach operation as a method on the column builder
-    // Operations return ExpressionBuilder, not ColumnBuilder
-    (builderWithOps as Record<string, unknown>)[operation.method] = function (
-      this: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,
-      ...args: unknown[]
-    ) {
-      return executeOperation(operation, this, args, columnMeta, registry, contractCapabilities);
-    };
-  }
-
-  return builderWithOps;
-}

package/src/param.ts

@@ -1,15 +0,0 @@
-import { planInvalid } from '@prisma-next/plan';
-import type { ParamPlaceholder } from './types';
-
-export type Parameter = ParamPlaceholder;
-
-export function param(name: string): Parameter {
-  if (typeof name !== 'string' || name.length === 0) {
-    throw planInvalid('Parameter name must be a non-empty string');
-  }
-
-  return Object.freeze({
-    kind: 'param-placeholder' as const,
-    name,
-  }) satisfies Parameter;
-}