@prisma-next/sql-relational-core 0.3.0-dev.14 → 0.3.0-dev.146

package/src/schema.ts

@@ -1,373 +0,0 @@
-import type { OperationRegistry } from '@prisma-next/operations';
-import { planInvalid } from '@prisma-next/plan';
-import type {
-  ExtractCodecTypes,
-  ExtractOperationTypes,
-  SqlContract,
-  SqlStorage,
-  StorageColumn,
-} from '@prisma-next/sql-contract/types';
-import type { BinaryOp, TableRef } from './ast/types';
-import { attachOperationsToColumnBuilder } from './operations-registry';
-import type { QueryLaneContext } from './query-lane-context';
-import type {
-  AnyColumnBuilderBase,
-  BinaryBuilder,
-  CodecTypes as CodecTypesType,
-  ColumnBuilder,
-  ComputeColumnJsType,
-  OperationTypeSignature,
-  OperationTypes,
-  OrderBuilder,
-  ParamPlaceholder,
-} from './types';
-import { isColumnBuilder } from './types';
-
-type TableColumns<Table extends { columns: Record<string, StorageColumn> }> = Table['columns'];
-
-type ColumnBuilders<
-  Contract extends SqlContract<SqlStorage>,
-  TableName extends string,
-  Columns extends Record<string, StorageColumn>,
-  CodecTypes extends CodecTypesType,
-  Operations extends OperationTypes,
-> = {
-  readonly [K in keyof Columns]: ColumnBuilder<
-    K & string,
-    Columns[K],
-    ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,
-    Operations
-  >;
-};
-
-export class ColumnBuilderImpl<
-  ColumnName extends string,
-  ColumnMeta extends StorageColumn,
-  JsType = unknown,
-> {
-  readonly kind = 'column' as const;
-
-  constructor(
-    readonly table: string,
-    readonly column: ColumnName,
-    private readonly storageColumn: ColumnMeta,
-  ) {}
-
-  get columnMeta(): ColumnMeta {
-    return this.storageColumn;
-  }
-
-  // Type-level helper property (not used at runtime)
-  get __jsType(): JsType {
-    return undefined as unknown as JsType;
-  }
-
-  private createBinaryBuilder(
-    op: BinaryOp,
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    if (value == null) {
-      throw planInvalid('Parameter placeholder or column builder required for column comparison');
-    }
-    if (value.kind === 'param-placeholder' || isColumnBuilder(value)) {
-      return Object.freeze({
-        kind: 'binary' as const,
-        op,
-        left: this as unknown as ColumnBuilder<ColumnName, ColumnMeta, JsType>,
-        right: value,
-      }) as BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-    }
-    throw planInvalid('Parameter placeholder or column builder required for column comparison');
-  }
-
-  eq(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    return this.createBinaryBuilder('eq', value);
-  }
-
-  neq(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    return this.createBinaryBuilder('neq', value);
-  }
-
-  gt(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    return this.createBinaryBuilder('gt', value);
-  }
-
-  lt(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    return this.createBinaryBuilder('lt', value);
-  }
-
-  gte(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    return this.createBinaryBuilder('gte', value);
-  }
-
-  lte(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType> {
-    return this.createBinaryBuilder('lte', value);
-  }
-
-  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {
-    return Object.freeze({
-      kind: 'order' as const,
-      expr: this as unknown as ColumnBuilder<ColumnName, ColumnMeta, JsType>,
-      dir: 'asc' as const,
-    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;
-  }
-
-  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType> {
-    return Object.freeze({
-      kind: 'order' as const,
-      expr: this as unknown as ColumnBuilder<ColumnName, ColumnMeta, JsType>,
-      dir: 'desc' as const,
-    }) as OrderBuilder<ColumnName, ColumnMeta, JsType>;
-  }
-}
-
-export class TableBuilderImpl<
-  Contract extends SqlContract<SqlStorage>,
-  TableName extends string,
-  Columns extends Record<string, StorageColumn>,
-  CodecTypes extends CodecTypesType,
-  Operations extends OperationTypes,
-> implements TableRef
-{
-  readonly kind = 'table' as const;
-  readonly columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;
-  private readonly _name: TableName;
-
-  constructor(
-    name: TableName,
-    columns: ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>,
-  ) {
-    this._name = name;
-    this.columns = columns;
-  }
-
-  get name(): string {
-    return this._name;
-  }
-}
-
-function buildColumns<
-  Contract extends SqlContract<SqlStorage>,
-  TableName extends keyof Contract['storage']['tables'] & string,
-  CodecTypes extends CodecTypesType,
-  Operations extends OperationTypes,
->(
-  tableName: TableName,
-  storage: SqlStorage,
-  _contract: Contract,
-  operationRegistry?: OperationRegistry,
-  contractCapabilities?: Record<string, Record<string, boolean>>,
-): ColumnBuilders<
-  Contract,
-  TableName,
-  Contract['storage']['tables'][TableName]['columns'],
-  CodecTypes,
-  Operations
-> {
-  const table = storage.tables[tableName];
-
-  if (!table) {
-    throw planInvalid(`Unknown table ${tableName}`);
-  }
-
-  type Columns = Contract['storage']['tables'][TableName]['columns'];
-  const tableColumns = table.columns as Columns;
-
-  const result = {} as {
-    [K in keyof Columns]: ColumnBuilder<
-      K & string,
-      Columns[K],
-      ComputeColumnJsType<Contract, TableName, K & string, Columns[K], CodecTypes>,
-      Operations
-    >;
-  };
-
-  const assignColumn = <ColumnKey extends keyof Columns & string>(
-    columnName: ColumnKey,
-    columnDef: Columns[ColumnKey],
-  ) => {
-    type JsType = ComputeColumnJsType<
-      Contract,
-      TableName,
-      ColumnKey,
-      Columns[ColumnKey],
-      CodecTypes
-    >;
-
-    const columnBuilder = new ColumnBuilderImpl<ColumnKey, Columns[ColumnKey], JsType>(
-      tableName,
-      columnName,
-      columnDef,
-    );
-
-    const builderWithOps = attachOperationsToColumnBuilder<
-      ColumnKey,
-      Columns[ColumnKey],
-      JsType,
-      Operations
-    >(
-      columnBuilder as unknown as ColumnBuilder<
-        ColumnKey,
-        Columns[ColumnKey],
-        JsType,
-        Record<string, never>
-      >,
-      columnDef,
-      operationRegistry,
-      contractCapabilities,
-    );
-
-    (result as Record<string, unknown>)[columnName] = builderWithOps;
-  };
-
-  for (const columnName of Object.keys(tableColumns) as Array<keyof Columns & string>) {
-    const columnDef = tableColumns[columnName];
-    if (!columnDef) continue;
-    assignColumn(columnName, columnDef);
-  }
-
-  return result as ColumnBuilders<Contract, TableName, Columns, CodecTypes, Operations>;
-}
-
-/**
- * Creates a Proxy that enables accessing table columns directly on the table object,
- * in addition to the standard `table.columns.columnName` syntax.
- *
- * This allows both access patterns:
- * - `tables.user.columns.id` (standard access)
- * - `tables.user.id` (convenience access via proxy)
- *
- * The proxy intercepts property access and routes column name lookups to
- * `table.columns[prop]`, while preserving direct access to table properties
- * like `name`, `kind`, and `columns`.
- */
-function createTableProxy<
-  Contract extends SqlContract<SqlStorage>,
-  TableName extends string,
-  Columns extends Record<string, StorageColumn>,
-  CodecTypes extends CodecTypesType,
-  Operations extends OperationTypes,
->(
-  table: TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations>,
-): TableBuilderImpl<Contract, TableName, Columns, CodecTypes, Operations> {
-  return new Proxy(table, {
-    get(target, prop) {
-      if (prop === 'name' || prop === 'kind' || prop === 'columns') {
-        return Reflect.get(target, prop);
-      }
-      if (typeof prop === 'string' && prop in target.columns) {
-        return target.columns[prop as keyof typeof target.columns];
-      }
-      return undefined;
-    },
-  });
-}
-
-type ExtractSchemaTables<
-  Contract extends SqlContract<SqlStorage>,
-  CodecTypes extends CodecTypesType,
-  Operations extends OperationTypes,
-> = {
-  readonly [TableName in keyof Contract['storage']['tables']]: TableBuilderImpl<
-    Contract,
-    TableName & string,
-    TableColumns<Contract['storage']['tables'][TableName]>,
-    CodecTypes,
-    Operations
-  > &
-    TableRef;
-};
-
-export type SchemaHandle<
-  Contract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
-  CodecTypes extends CodecTypesType = CodecTypesType,
-  Operations extends OperationTypes = Record<string, never>,
-> = {
-  readonly tables: ExtractSchemaTables<Contract, CodecTypes, Operations>;
-};
-
-type SchemaReturnType<Contract extends SqlContract<SqlStorage>> = SchemaHandle<
-  Contract,
-  ExtractCodecTypes<Contract>,
-  ToOperationTypes<ExtractOperationTypes<Contract>>
->;
-
-type NormalizeOperationTypes<T> = {
-  [TypeId in keyof T]: {
-    [Method in keyof T[TypeId]]: T[TypeId][Method] extends OperationTypeSignature
-      ? T[TypeId][Method]
-      : OperationTypeSignature;
-  };
-};
-
-type ToOperationTypes<T> = T extends OperationTypes ? T : NormalizeOperationTypes<T>;
-
-/**
- * Creates a schema handle for building SQL queries.
- *
- * @param context - Query lane context containing contract, codec and operation registries
- * @returns A schema handle with typed table builders
- *
- * @example
- * ```typescript
- * const schemaHandle = schema<Contract>(context);
- * const userTable = schemaHandle.tables.user;
- * ```
- */
-export function schema<Contract extends SqlContract<SqlStorage>>(
-  context: QueryLaneContext<Contract>,
-): SchemaReturnType<Contract> {
-  const contract = context.contract;
-  const storage = contract.storage;
-  type CodecTypes = ExtractCodecTypes<Contract>;
-  type Operations = ToOperationTypes<ExtractOperationTypes<Contract>>;
-  const tables = {} as ExtractSchemaTables<Contract, CodecTypes, Operations>;
-  const contractCapabilities = contract.capabilities;
-
-  const operationRegistry = context.operations;
-
-  for (const tableName of Object.keys(storage.tables) as Array<
-    keyof Contract['storage']['tables'] & string
-  >) {
-    const columns = buildColumns<Contract, typeof tableName, CodecTypes, Operations>(
-      tableName,
-      storage,
-      contract,
-      operationRegistry,
-      contractCapabilities,
-    );
-    const table = new TableBuilderImpl<
-      Contract,
-      typeof tableName & string,
-      Contract['storage']['tables'][typeof tableName]['columns'],
-      CodecTypes,
-      Operations
-    >(tableName, columns);
-    const proxiedTable = createTableProxy<
-      Contract,
-      typeof tableName & string,
-      Contract['storage']['tables'][typeof tableName]['columns'],
-      CodecTypes,
-      Operations
-    >(table);
-    (tables as Record<string, unknown>)[tableName] = Object.freeze(
-      proxiedTable,
-    ) as ExtractSchemaTables<Contract, CodecTypes, Operations>[typeof tableName];
-  }
-
-  return Object.freeze({ tables }) as SchemaReturnType<Contract>;
-}
-
-export type { ColumnBuilderImpl as Column, TableBuilderImpl as Table };

package/src/utils/guards.ts

@@ -1,123 +0,0 @@
-import type { StorageColumn } from '@prisma-next/sql-contract/types';
-import type { ColumnRef, LiteralExpr, OperationExpr, ParamRef } from '../ast/types';
-import type { AnyColumnBuilder, ParamPlaceholder } from '../types';
-
-/**
- * Helper to extract columnMeta from a ColumnBuilder.
- * Returns StorageColumn if present, undefined otherwise.
- * AnyColumnBuilder is a union that includes types with columnMeta property,
- * so we can safely access it after checking for existence.
- */
-export function getColumnMeta(expr: AnyColumnBuilder): StorageColumn | undefined {
-  // AnyColumnBuilder includes AnyColumnBuilderBase which has columnMeta: StorageColumn
-  // and ColumnBuilder which has columnMeta: ColumnMeta extends StorageColumn
-  // TypeScript should narrow the type after the 'in' check
-  if ('columnMeta' in expr) {
-    return expr.columnMeta;
-  }
-  return undefined;
-}
-
-/**
- * Type predicate to check if a value is a ParamPlaceholder.
- */
-export function isParamPlaceholder(value: unknown): value is ParamPlaceholder {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'kind' in value &&
-    (value as { kind: unknown }).kind === 'param-placeholder' &&
-    'name' in value &&
-    typeof (value as { name: unknown }).name === 'string'
-  );
-}
-
-/**
- * Recursively extracts the base ColumnRef from an OperationExpr.
- * If the expression is already a ColumnRef, it is returned directly.
- */
-export function extractBaseColumnRef(expr: ColumnRef | OperationExpr): ColumnRef {
-  if (expr.kind === 'col') {
-    return expr;
-  }
-  return extractBaseColumnRef(expr.self);
-}
-
-/**
- * Recursively collects all ColumnRef nodes from an expression tree.
- * Handles nested OperationExpr structures by traversing both self and args.
- */
-export function collectColumnRefs(
-  expr: ColumnRef | ParamRef | LiteralExpr | OperationExpr,
-): ColumnRef[] {
-  if (expr.kind === 'col') {
-    return [expr];
-  }
-  if (expr.kind === 'operation') {
-    const refs: ColumnRef[] = collectColumnRefs(expr.self);
-    for (const arg of expr.args) {
-      refs.push(...collectColumnRefs(arg));
-    }
-    return refs;
-  }
-  return [];
-}
-
-/**
- * Type predicate to check if an expression is an OperationExpr.
- */
-export function isOperationExpr(expr: AnyColumnBuilder | OperationExpr): expr is OperationExpr {
-  return typeof expr === 'object' && expr !== null && 'kind' in expr && expr.kind === 'operation';
-}
-
-/**
- * Helper to extract table and column from a ColumnBuilder or OperationExpr.
- * For OperationExpr, recursively unwraps to find the base ColumnRef.
- */
-export function getColumnInfo(expr: AnyColumnBuilder | OperationExpr): {
-  table: string;
-  column: string;
-} {
-  if (isOperationExpr(expr)) {
-    const baseCol = extractBaseColumnRef(expr);
-    return { table: baseCol.table, column: baseCol.column };
-  }
-  // expr is ColumnBuilder - TypeScript can't narrow properly
-  const colBuilder = expr as unknown as { table: string; column: string };
-  return { table: colBuilder.table, column: colBuilder.column };
-}
-
-/**
- * Type predicate to check if a value is a ColumnBuilder.
- */
-export function isColumnBuilder(value: unknown): value is AnyColumnBuilder {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'kind' in value &&
-    (value as { kind: unknown }).kind === 'column'
-  );
-}
-
-/**
- * Extracts and returns an OperationExpr from a builder.
- * Returns the OperationExpr if the builder is an OperationExpr or has an _operationExpr property,
- * otherwise returns undefined.
- *
- * @design-note: This function accesses the hidden `_operationExpr` property, which is a code smell.
- * The issue is that `executeOperation()` in relational-core returns a ColumnBuilder-shaped object
- * with a hidden `_operationExpr` property, creating coupling between lanes and relational-core
- * implementation details. A cleaner design would be to have operation results be a separate
- * type (e.g., `OperationResultBuilder`) that properly represents expression nodes rather than
- * pretending to be a ColumnBuilder. This would require refactoring the operation execution
- * system in relational-core to return proper expression types.
- */
-export function getOperationExpr(
-  builder: AnyColumnBuilder | OperationExpr,
-): OperationExpr | undefined {
-  if (isOperationExpr(builder)) {
-    return builder;
-  }
-  const builderWithExpr = builder as unknown as { _operationExpr?: OperationExpr };
-  return builderWithExpr._operationExpr;
-}