@prisma-next/sql-relational-core 0.3.0-dev.16 → 0.3.0-dev.162

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,10 +0,0 @@
-export {
-  collectColumnRefs,
-  extractBaseColumnRef,
-  getColumnInfo,
-  getColumnMeta,
-  getOperationExpr,
-  isColumnBuilder,
-  isOperationExpr,
-  isParamPlaceholder,
-} 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,237 +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, ColumnRef, LiteralExpr, OperationExpr, ParamRef } from './ast/types';
-import type { AnyColumnBuilder, ColumnBuilder, OperationTypes, ParamPlaceholder } from './types';
-import { isParamPlaceholder } from './utils/guards';
-
-function isColumnBuilder(value: unknown): value is AnyColumnBuilder {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'kind' in value &&
-    (value as { kind: unknown }).kind === 'column'
-  );
-}
-
-/**
- * Executes an operation and returns a column-shaped result object.
- * This is the canonical entrypoint for operation invocation, enabling
- * future enhancements like telemetry, caching, or tracing.
- *
- * @param signature - The operation signature from the registry
- * @param selfBuilder - The column builder 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 A column-shaped builder with the operation expression attached
- */
-function executeOperation(
-  signature: SqlOperationSignature,
-  selfBuilder: AnyColumnBuilder,
-  args: unknown[],
-  columnMeta: StorageColumn,
-  operationRegistry?: OperationRegistry,
-  contractCapabilities?: Record<string, Record<string, boolean>>,
-): AnyColumnBuilder & { _operationExpr?: OperationExpr } {
-  if (args.length !== signature.args.length) {
-    throw planInvalid(
-      `Operation ${signature.method} expects ${signature.args.length} arguments, got ${args.length}`,
-    );
-  }
-
-  // Check if this column builder has an existing operation expression
-  const selfBuilderWithExpr = selfBuilder as unknown as {
-    _operationExpr?: OperationExpr;
-    table: string;
-    column: string;
-  };
-  const selfExpr: ColumnRef | OperationExpr = selfBuilderWithExpr._operationExpr
-    ? selfBuilderWithExpr._operationExpr
-    : {
-        kind: 'col',
-        table: selfBuilderWithExpr.table,
-        column: selfBuilderWithExpr.column,
-      };
-
-  const operationArgs: Array<ColumnRef | ParamRef | LiteralExpr | OperationExpr> = [];
-  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') {
-      if (!isColumnBuilder(arg)) {
-        throw planInvalid(`Argument ${i} must be a ColumnBuilder`);
-      }
-      const colBuilderWithExpr = arg as unknown as {
-        _operationExpr?: OperationExpr;
-        table: string;
-        column: string;
-      };
-      // Check if the column builder has an operation expression
-      if (colBuilderWithExpr._operationExpr) {
-        operationArgs.push(colBuilderWithExpr._operationExpr);
-      } else {
-        // Fall back to raw ColumnRef
-        operationArgs.push({
-          kind: 'col',
-          table: colBuilderWithExpr.table,
-          column: colBuilderWithExpr.column,
-        });
-      }
-    } 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) =>
-    Object.freeze({
-      kind: 'binary' as const,
-      op,
-      left: operationExpr,
-      right: value,
-    });
-
-  const baseResult = {
-    kind: 'column' as const,
-    table: selfBuilderWithExpr.table,
-    column: selfBuilderWithExpr.column,
-    get columnMeta() {
-      return returnColumnMeta;
-    },
-    eq: createComparisonMethod('eq'),
-    neq: createComparisonMethod('neq'),
-    gt: createComparisonMethod('gt'),
-    lt: createComparisonMethod('lt'),
-    gte: createComparisonMethod('gte'),
-    lte: createComparisonMethod('lte'),
-    asc() {
-      return Object.freeze({
-        kind: 'order' as const,
-        expr: operationExpr,
-        dir: 'asc' as const,
-      });
-    },
-    desc() {
-      return Object.freeze({
-        kind: 'order' as const,
-        expr: operationExpr,
-        dir: 'desc' as const,
-      });
-    },
-    _operationExpr: operationExpr,
-  } as unknown as AnyColumnBuilder & {
-    _operationExpr?: OperationExpr;
-  };
-
-  // If the return type is a typeId, attach operations for that type
-  if (returnTypeId && operationRegistry) {
-    const resultWithOps = attachOperationsToColumnBuilder(
-      baseResult as ColumnBuilder<string, StorageColumn, unknown, Record<string, never>>,
-      returnColumnMeta,
-      operationRegistry,
-      contractCapabilities,
-    ) as AnyColumnBuilder & {
-      _operationExpr?: OperationExpr;
-    };
-    return Object.freeze(resultWithOps);
-  }
-
-  return Object.freeze(baseResult);
-}
-
-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
-    (builderWithOps as Record<string, unknown>)[operation.method] = function (
-      this: ColumnBuilder<ColumnName, ColumnMeta, JsType, Record<string, never>>,
-      ...args: unknown[]
-    ) {
-      return executeOperation(
-        operation,
-        this as unknown as ColumnBuilder<string, StorageColumn, unknown>,
-        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;
-}