@prisma-next/sql-orm-lane 0.3.0-dev.3 → 0.3.0-dev.31

package/src/orm/capabilities.ts

@@ -0,0 +1,14 @@
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import { errorIncludeCapabilitiesNotTrue, errorIncludeRequiresCapabilities } from '../utils/errors';
+
+export function checkIncludeCapabilities(contract: SqlContract<SqlStorage>): void {
+  const target = contract.target;
+  const capabilities = contract.capabilities;
+  if (!capabilities || !capabilities[target]) {
+    errorIncludeRequiresCapabilities();
+  }
+  const targetCapabilities = capabilities[target];
+  if (capabilities[target]['lateral'] !== true || targetCapabilities['jsonAgg'] !== true) {
+    errorIncludeCapabilitiesNotTrue();
+  }
+}

package/src/orm/context.ts

@@ -0,0 +1,10 @@
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+
+export type OrmContext<TContract extends SqlContract<SqlStorage>> = QueryLaneContext<TContract>;
+
+export function createOrmContext<TContract extends SqlContract<SqlStorage>>(
+  context: QueryLaneContext<TContract>,
+): OrmContext<TContract> {
+  return context;
+}

package/src/orm/state.ts

@@ -0,0 +1,52 @@
+import type { TableRef } from '@prisma-next/sql-relational-core/ast';
+import type {
+  AnyBinaryBuilder,
+  AnyExpressionSource,
+  AnyOrderBuilder,
+  NestedProjection,
+} from '@prisma-next/sql-relational-core/types';
+
+export interface RelationFilter {
+  relationName: string;
+  childModelName: string;
+  filterType: 'some' | 'none' | 'every';
+  childWhere: AnyBinaryBuilder | undefined;
+  relation: {
+    to: string;
+    cardinality: string;
+    on: {
+      parentCols: readonly string[];
+      childCols: readonly string[];
+    };
+  };
+}
+
+export interface OrmIncludeState {
+  relationName: string;
+  childModelName: string;
+  childTable: TableRef;
+  childWhere: AnyBinaryBuilder | undefined;
+  childOrderBy: AnyOrderBuilder | undefined;
+  childLimit: number | undefined;
+  childProjection: Record<string, AnyExpressionSource | boolean | NestedProjection> | undefined;
+  alias: string;
+  relation: {
+    to: string;
+    cardinality: string;
+    on: {
+      parentCols: readonly string[];
+      childCols: readonly string[];
+    };
+  };
+}
+
+export interface OrmBuilderState {
+  table: TableRef;
+  wherePredicate: AnyBinaryBuilder | undefined;
+  relationFilters: RelationFilter[];
+  includes: OrmIncludeState[];
+  orderByExpr: AnyOrderBuilder | undefined;
+  limitValue: number | undefined;
+  offsetValue: number | undefined;
+  projection: Record<string, AnyExpressionSource | boolean | NestedProjection> | undefined;
+}

package/src/orm-include-child.ts

@@ -0,0 +1,169 @@
+import { planInvalid } from '@prisma-next/plan';
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import { schema } from '@prisma-next/sql-relational-core/schema';
+import type {
+  AnyBinaryBuilder,
+  AnyColumnBuilder,
+  AnyOrderBuilder,
+  InferNestedProjectionRow,
+  NestedProjection,
+} from '@prisma-next/sql-relational-core/types';
+import type { ModelColumnAccessor, OrmBuilderOptions } from './orm-types';
+
+export interface OrmIncludeChildBuilder<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ChildModelName extends string,
+  ChildRow = unknown,
+> {
+  where(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => AnyBinaryBuilder,
+  ): OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow>;
+  orderBy(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => AnyOrderBuilder,
+  ): OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow>;
+  take(n: number): OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow>;
+  select<Projection extends Record<string, AnyColumnBuilder | boolean | NestedProjection>>(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => Projection,
+  ): OrmIncludeChildBuilder<
+    TContract,
+    CodecTypes,
+    ChildModelName,
+    InferNestedProjectionRow<Projection, CodecTypes>
+  >;
+}
+
+export class OrmIncludeChildBuilderImpl<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ChildModelName extends string,
+  ChildRow = unknown,
+> implements OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow>
+{
+  private readonly context: QueryLaneContext<TContract>;
+  private readonly contract: TContract;
+  private readonly childModelName: ChildModelName;
+  private childWhere: AnyBinaryBuilder | undefined;
+  private childOrderBy: AnyOrderBuilder | undefined;
+  private childLimit: number | undefined;
+  private childProjection:
+    | Record<string, AnyColumnBuilder | boolean | NestedProjection>
+    | undefined = undefined;
+
+  constructor(options: OrmBuilderOptions<TContract>, childModelName: ChildModelName) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.childModelName = childModelName;
+  }
+
+  where(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => AnyBinaryBuilder,
+  ): OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow> {
+    const builder = new OrmIncludeChildBuilderImpl<TContract, CodecTypes, ChildModelName, ChildRow>(
+      { context: this.context },
+      this.childModelName,
+    );
+    builder.childWhere = fn(this._getModelAccessor());
+    builder.childOrderBy = this.childOrderBy;
+    builder.childLimit = this.childLimit;
+    builder.childProjection = this.childProjection;
+    return builder;
+  }
+
+  orderBy(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => AnyOrderBuilder,
+  ): OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow> {
+    const builder = new OrmIncludeChildBuilderImpl<TContract, CodecTypes, ChildModelName, ChildRow>(
+      { context: this.context },
+      this.childModelName,
+    );
+    builder.childWhere = this.childWhere;
+    builder.childOrderBy = fn(this._getModelAccessor());
+    builder.childLimit = this.childLimit;
+    builder.childProjection = this.childProjection;
+    return builder;
+  }
+
+  take(n: number): OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow> {
+    const builder = new OrmIncludeChildBuilderImpl<TContract, CodecTypes, ChildModelName, ChildRow>(
+      { context: this.context },
+      this.childModelName,
+    );
+    builder.childWhere = this.childWhere;
+    builder.childOrderBy = this.childOrderBy;
+    builder.childLimit = n;
+    builder.childProjection = this.childProjection;
+    return builder;
+  }
+
+  select<Projection extends Record<string, AnyColumnBuilder | boolean | NestedProjection>>(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => Projection,
+  ): OrmIncludeChildBuilder<
+    TContract,
+    CodecTypes,
+    ChildModelName,
+    InferNestedProjectionRow<Projection, CodecTypes>
+  > {
+    const builder = new OrmIncludeChildBuilderImpl<
+      TContract,
+      CodecTypes,
+      ChildModelName,
+      InferNestedProjectionRow<Projection, CodecTypes>
+    >({ context: this.context }, this.childModelName);
+    builder.childWhere = this.childWhere;
+    builder.childOrderBy = this.childOrderBy;
+    builder.childLimit = this.childLimit;
+    builder.childProjection = fn(this._getModelAccessor());
+    return builder;
+  }
+
+  getState(): {
+    childWhere?: AnyBinaryBuilder;
+    childOrderBy?: AnyOrderBuilder;
+    childLimit?: number;
+    childProjection?: Record<string, AnyColumnBuilder | boolean | NestedProjection>;
+  } {
+    return {
+      ...(this.childWhere !== undefined ? { childWhere: this.childWhere } : {}),
+      ...(this.childOrderBy !== undefined ? { childOrderBy: this.childOrderBy } : {}),
+      ...(this.childLimit !== undefined ? { childLimit: this.childLimit } : {}),
+      ...(this.childProjection !== undefined ? { childProjection: this.childProjection } : {}),
+    };
+  }
+
+  private _getModelAccessor(): ModelColumnAccessor<TContract, CodecTypes, ChildModelName> {
+    const tableName = this.contract.mappings.modelToTable?.[this.childModelName];
+    if (!tableName) {
+      throw planInvalid(`Model ${this.childModelName} not found in mappings`);
+    }
+    const schemaHandle = schema(this.context);
+    const table = schemaHandle.tables[tableName];
+    if (!table) {
+      throw planInvalid(`Table ${tableName} not found in schema`);
+    }
+
+    const accessor = {} as ModelColumnAccessor<TContract, CodecTypes, ChildModelName>;
+    const model = this.contract.models[this.childModelName];
+    if (!model || typeof model !== 'object' || !('fields' in model)) {
+      throw planInvalid(`Model ${this.childModelName} does not have fields`);
+    }
+    const modelFields = model.fields as Record<string, { column?: string }>;
+
+    for (const fieldName in modelFields) {
+      const field = modelFields[fieldName];
+      if (!field) continue;
+      const columnName =
+        this.contract.mappings.fieldToColumn?.[this.childModelName]?.[fieldName] ??
+        field.column ??
+        fieldName;
+      const column = table.columns[columnName];
+      if (column) {
+        // ModelColumnAccessor alignment is ensured by contract validation; cast for compatibility
+        (accessor as Record<string, AnyColumnBuilder>)[fieldName] = column;
+      }
+    }
+
+    return accessor;
+  }
+}

package/src/orm-relation-filter.ts

@@ -0,0 +1,93 @@
+import { planInvalid } from '@prisma-next/plan';
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import { schema } from '@prisma-next/sql-relational-core/schema';
+import type { AnyBinaryBuilder, AnyColumnBuilder } from '@prisma-next/sql-relational-core/types';
+import type { ModelColumnAccessor, OrmBuilderOptions, OrmRelationFilterBuilder } from './orm-types';
+
+export class OrmRelationFilterBuilderImpl<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ChildModelName extends string,
+> implements OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>
+{
+  private readonly context: QueryLaneContext<TContract>;
+  private readonly contract: TContract;
+  private readonly childModelName: ChildModelName;
+  private wherePredicate: AnyBinaryBuilder | undefined = undefined;
+  private modelAccessor: ModelColumnAccessor<TContract, CodecTypes, ChildModelName> | undefined =
+    undefined;
+
+  constructor(options: OrmBuilderOptions<TContract>, childModelName: ChildModelName) {
+    this.context = options.context;
+    this.contract = options.context.contract;
+    this.childModelName = childModelName;
+    this.modelAccessor = this._getModelAccessor();
+  }
+
+  where(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => AnyBinaryBuilder,
+  ): OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName> {
+    const builder = new OrmRelationFilterBuilderImpl<TContract, CodecTypes, ChildModelName>(
+      { context: this.context },
+      this.childModelName,
+    );
+    builder.modelAccessor = this.modelAccessor;
+    if (this.modelAccessor) {
+      builder.wherePredicate = fn(this.modelAccessor);
+    }
+    return builder;
+  }
+
+  getWherePredicate(): AnyBinaryBuilder | undefined {
+    return this.wherePredicate;
+  }
+
+  getChildModelName(): ChildModelName {
+    return this.childModelName;
+  }
+
+  getModelAccessor(): ModelColumnAccessor<TContract, CodecTypes, ChildModelName> {
+    if (!this.modelAccessor) {
+      this.modelAccessor = this._getModelAccessor();
+    }
+    if (!this.modelAccessor) {
+      throw planInvalid(`Failed to get model accessor for ${this.childModelName}`);
+    }
+    return this.modelAccessor;
+  }
+
+  private _getModelAccessor(): ModelColumnAccessor<TContract, CodecTypes, ChildModelName> {
+    const tableName = this.contract.mappings.modelToTable?.[this.childModelName];
+    if (!tableName) {
+      throw planInvalid(`Model ${this.childModelName} not found in mappings`);
+    }
+    const schemaHandle = schema(this.context);
+    const table = schemaHandle.tables[tableName];
+    if (!table) {
+      throw planInvalid(`Table ${tableName} not found in schema`);
+    }
+
+    const accessor: Record<string, AnyColumnBuilder> = {};
+    const model = this.contract.models[this.childModelName];
+    if (!model || typeof model !== 'object' || !('fields' in model)) {
+      throw planInvalid(`Model ${this.childModelName} does not have fields`);
+    }
+    const modelFields = model.fields as Record<string, { column?: string }>;
+
+    for (const fieldName in modelFields) {
+      const field = modelFields[fieldName];
+      if (!field) continue;
+      const columnName =
+        this.contract.mappings.fieldToColumn?.[this.childModelName]?.[fieldName] ??
+        field.column ??
+        fieldName;
+      const column = table.columns[columnName];
+      if (column) {
+        accessor[fieldName] = column as AnyColumnBuilder;
+      }
+    }
+
+    return accessor as ModelColumnAccessor<TContract, CodecTypes, ChildModelName>;
+  }
+}

package/src/orm-types.ts

@@ -0,0 +1,271 @@
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import type {
+  AnyBinaryBuilder,
+  AnyColumnBuilder,
+  AnyOrderBuilder,
+  BuildOptions,
+  ColumnBuilder,
+  ComputeColumnJsType,
+  InferNestedProjectionRow,
+  NestedProjection,
+} from '@prisma-next/sql-relational-core/types';
+import type { OrmIncludeChildBuilder } from './orm-include-child';
+
+export interface OrmBuilderOptions<TContract extends SqlContract<SqlStorage>> {
+  readonly context: QueryLaneContext<TContract>;
+}
+
+type ModelName<TContract extends SqlContract<SqlStorage>> = keyof TContract['models'] & string;
+
+type LowercaseModelName<M extends string> = M extends `${infer First}${infer Rest}`
+  ? `${Lowercase<First>}${Rest}`
+  : M;
+
+// Helper to get table name from model name
+type ModelToTableName<
+  TContract extends SqlContract<SqlStorage>,
+  ModelName extends string,
+> = TContract['mappings']['modelToTable'] extends Record<string, string>
+  ? TContract['mappings']['modelToTable'][ModelName] extends string
+    ? TContract['mappings']['modelToTable'][ModelName]
+    : never
+  : never;
+
+// Helper to get relations for a model (via table name)
+type ModelRelations<
+  TContract extends SqlContract<SqlStorage>,
+  ModelName extends string,
+> = ModelToTableName<TContract, ModelName> extends string
+  ? TContract['relations'][ModelToTableName<TContract, ModelName>] extends Record<
+      string,
+      { to: string }
+    >
+    ? TContract['relations'][ModelToTableName<TContract, ModelName>]
+    : Record<string, never>
+  : Record<string, never>;
+
+type ModelFieldToColumnMap<
+  TContract extends SqlContract<SqlStorage>,
+  ModelName extends string,
+> = TContract['mappings']['fieldToColumn'] extends Record<string, Record<string, string>>
+  ? ModelName extends keyof TContract['mappings']['fieldToColumn']
+    ? TContract['mappings']['fieldToColumn'][ModelName]
+    : never
+  : never;
+
+type FieldToColumnMapSafe<
+  TContract extends SqlContract<SqlStorage>,
+  ModelName extends string,
+> = ModelFieldToColumnMap<TContract, ModelName> extends Record<string, string>
+  ? ModelFieldToColumnMap<TContract, ModelName>
+  : never;
+
+type FieldColumnName<
+  TContract extends SqlContract<SqlStorage>,
+  ModelName extends string,
+  FieldName extends string,
+> = (FieldToColumnMapSafe<TContract, ModelName> extends never
+  ? FieldName
+  : FieldName extends keyof FieldToColumnMapSafe<TContract, ModelName>
+    ? FieldToColumnMapSafe<TContract, ModelName>[FieldName]
+    : FieldName) &
+  string;
+
+type ModelColumnMeta<
+  TContract extends SqlContract<SqlStorage>,
+  ModelName extends string,
+  ColumnName extends string,
+> = ModelToTableName<TContract, ModelName> extends infer TableName extends string
+  ? TableName extends keyof TContract['storage']['tables']
+    ? ColumnName extends keyof TContract['storage']['tables'][TableName]['columns']
+      ? TContract['storage']['tables'][TableName]['columns'][ColumnName]
+      : never
+    : never
+  : never;
+
+type _IndexKeys = string | number | symbol;
+
+export type IncludeAccumulator<
+  Includes extends Record<string, unknown>,
+  Key extends string,
+  Value,
+> = {
+  readonly [K in Exclude<keyof Includes, _IndexKeys> | Key]: K extends Key ? Value : Includes[K];
+};
+
+export type OrmRegistry<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }> = Record<string, never>,
+> = {
+  readonly [K in ModelName<TContract>]: () => OrmModelBuilder<TContract, CodecTypes, K>;
+} & {
+  readonly [K in ModelName<TContract> as LowercaseModelName<K>]: () => OrmModelBuilder<
+    TContract,
+    CodecTypes,
+    K
+  >;
+};
+
+// Relation filter builder - filter-only scope (no ordering/limit/select)
+export interface OrmRelationFilterBuilder<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ChildModelName extends string,
+> {
+  where(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ChildModelName>) => AnyBinaryBuilder,
+  ): OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>;
+}
+
+// Relation accessor - exposes relations with some/none/every methods
+export type OrmRelationAccessor<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ModelName extends string,
+  ChildModelName extends string,
+  Includes extends Record<string, unknown>,
+  Row,
+> = {
+  some(
+    fn: (
+      child: OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>,
+    ) => OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>,
+  ): OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>;
+  none(
+    fn: (
+      child: OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>,
+    ) => OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>,
+  ): OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>;
+  every(
+    fn: (
+      child: OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>,
+    ) => OrmRelationFilterBuilder<TContract, CodecTypes, ChildModelName>,
+  ): OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>;
+};
+
+// Where property - both a function and an object with related
+export type OrmWhereProperty<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ModelName extends string,
+  Includes extends Record<string, unknown>,
+  Row,
+> = ((
+  fn: (model: ModelColumnAccessor<TContract, CodecTypes, ModelName>) => AnyBinaryBuilder,
+) => OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>) & {
+  related: ModelRelations<TContract, ModelName> extends Record<string, { to: infer To }>
+    ? To extends string
+      ? {
+          readonly [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<
+            TContract,
+            ModelName
+          >[K] extends {
+            to: infer ChildModelName;
+          }
+            ? ChildModelName extends string
+              ? OrmRelationAccessor<TContract, CodecTypes, ModelName, ChildModelName, Includes, Row>
+              : never
+            : never;
+        }
+      : Record<string, never>
+    : Record<string, never>;
+};
+
+// Include accessor - exposes relations with include methods
+export type OrmIncludeAccessor<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ModelName extends string,
+  Includes extends Record<string, unknown>,
+  Row,
+> = ModelRelations<TContract, ModelName> extends Record<string, { to: infer To }>
+  ? To extends string
+    ? {
+        readonly [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<
+          TContract,
+          ModelName
+        >[K] extends {
+          to: infer ChildModelName;
+        }
+          ? ChildModelName extends string
+            ? <ChildRow>(
+                child: (
+                  child: OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName>,
+                ) => OrmIncludeChildBuilder<TContract, CodecTypes, ChildModelName, ChildRow>,
+              ) => OrmModelBuilder<
+                TContract,
+                CodecTypes,
+                ModelName,
+                IncludeAccumulator<Includes, K & string, ChildRow>,
+                Row
+              >
+            : never
+          : never;
+      }
+    : Record<string, never>
+  : Record<string, never>;
+
+export interface OrmModelBuilder<
+  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }> = Record<string, never>,
+  ModelName extends string = string,
+  Includes extends Record<string, unknown> = Record<string, never>,
+  Row = unknown,
+> {
+  where: OrmWhereProperty<TContract, CodecTypes, ModelName, Includes, Row>;
+  include: OrmIncludeAccessor<TContract, CodecTypes, ModelName, Includes, Row>;
+  orderBy(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ModelName>) => AnyOrderBuilder,
+  ): OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>;
+  take(n: number): OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>;
+  skip(n: number): OrmModelBuilder<TContract, CodecTypes, ModelName, Includes, Row>;
+  select<Projection extends Record<string, AnyColumnBuilder | boolean | NestedProjection>>(
+    fn: (model: ModelColumnAccessor<TContract, CodecTypes, ModelName>) => Projection,
+  ): OrmModelBuilder<
+    TContract,
+    CodecTypes,
+    ModelName,
+    Includes,
+    InferNestedProjectionRow<Projection, CodecTypes, Includes>
+  >;
+  findMany(options?: BuildOptions): SqlQueryPlan<Row>;
+  findFirst(options?: BuildOptions): SqlQueryPlan<Row>;
+  findUnique(
+    where: (model: ModelColumnAccessor<TContract, CodecTypes, ModelName>) => AnyBinaryBuilder,
+    options?: BuildOptions,
+  ): SqlQueryPlan<Row>;
+  create(data: Record<string, unknown>, options?: BuildOptions): SqlQueryPlan<number>;
+  update(
+    where: (model: ModelColumnAccessor<TContract, CodecTypes, ModelName>) => AnyBinaryBuilder,
+    data: Record<string, unknown>,
+    options?: BuildOptions,
+  ): SqlQueryPlan<number>;
+  delete(
+    where: (model: ModelColumnAccessor<TContract, CodecTypes, ModelName>) => AnyBinaryBuilder,
+    options?: BuildOptions,
+  ): SqlQueryPlan<number>;
+}
+
+export type ModelColumnAccessor<
+  TContract extends SqlContract<SqlStorage>,
+  CodecTypes extends Record<string, { output: unknown }>,
+  ModelName extends string,
+> = TContract['models'][ModelName] extends { fields: infer Fields }
+  ? Fields extends Record<string, unknown>
+    ? {
+        readonly [K in keyof Fields & string]: ColumnBuilder<
+          K,
+          ModelColumnMeta<TContract, ModelName, FieldColumnName<TContract, ModelName, K>>,
+          ComputeColumnJsType<
+            TContract,
+            ModelToTableName<TContract, ModelName>,
+            FieldColumnName<TContract, ModelName, K>,
+            ModelColumnMeta<TContract, ModelName, FieldColumnName<TContract, ModelName, K>>,
+            CodecTypes
+          >
+        >;
+      }
+    : never
+  : never;

package/src/orm.ts

@@ -0,0 +1,51 @@
+import { planInvalid } from '@prisma-next/plan';
+import type { ExtractCodecTypes, SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import { OrmModelBuilderImpl } from './orm/builder';
+import type { OrmBuilderOptions, OrmRegistry } from './orm-types';
+
+type ModelName<TContract extends SqlContract<SqlStorage>> = keyof TContract['models'] & string;
+
+export function orm<TContract extends SqlContract<SqlStorage>>(
+  options: OrmBuilderOptions<TContract>,
+): OrmRegistry<TContract, ExtractCodecTypes<TContract>> {
+  const contract = options.context.contract;
+  type CodecTypes = ExtractCodecTypes<TContract>;
+
+  return new Proxy({} as OrmRegistry<TContract, CodecTypes>, {
+    get(_target, prop) {
+      if (typeof prop !== 'string') {
+        return undefined;
+      }
+
+      const modelName = (prop.charAt(0).toUpperCase() + prop.slice(1)) as ModelName<TContract>;
+      if (
+        !contract.models ||
+        typeof contract.models !== 'object' ||
+        !(modelName in contract.models)
+      ) {
+        throw planInvalid(`Model ${prop} (resolved to ${modelName}) not found in contract`);
+      }
+
+      return () =>
+        new OrmModelBuilderImpl<TContract, CodecTypes, typeof modelName>(options, modelName);
+    },
+    has(_target, prop) {
+      if (typeof prop !== 'string') {
+        return false;
+      }
+      const modelName = (prop.charAt(0).toUpperCase() + prop.slice(1)) as ModelName<TContract>;
+      return contract.models && typeof contract.models === 'object' && modelName in contract.models;
+    },
+  });
+}
+
+// Re-export types for convenience
+export type {
+  ModelColumnAccessor,
+  OrmBuilderOptions,
+  OrmModelBuilder,
+  OrmRegistry,
+  OrmRelationAccessor,
+  OrmRelationFilterBuilder,
+  OrmWhereProperty,
+} from './orm-types';

package/src/plan/lowering.ts

@@ -0,0 +1 @@
+export type {};