@prisma-next/mongo-orm 0.3.0-dev.135 → 0.3.0-dev.162

package/src/compile.ts

@@ -0,0 +1,86 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
+import type { MongoPipelineStage, MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
+import {
+  AggregateCommand,
+  MongoAndExpr,
+  MongoLimitStage,
+  MongoLookupStage,
+  MongoMatchStage,
+  MongoProjectStage,
+  MongoSkipStage,
+  MongoSortStage,
+  MongoUnwindStage,
+} from '@prisma-next/mongo-query-ast/execution';
+import type { MongoCollectionState, MongoIncludeExpr } from './collection-state';
+
+function compileIncludes(includes: readonly MongoIncludeExpr[]): MongoPipelineStage[] {
+  const stages: MongoPipelineStage[] = [];
+
+  for (const inc of includes) {
+    stages.push(
+      new MongoLookupStage({
+        from: inc.from,
+        localField: inc.localField,
+        foreignField: inc.foreignField,
+        as: inc.relationName,
+      }),
+    );
+
+    if (inc.cardinality === 'N:1' || inc.cardinality === '1:1') {
+      stages.push(new MongoUnwindStage(`$${inc.relationName}`, true));
+    }
+  }
+
+  return stages;
+}
+
+export function compileMongoQuery<Row = unknown>(
+  collection: string,
+  state: MongoCollectionState,
+  storageHash: string,
+): MongoQueryPlan<Row> {
+  const stages: MongoPipelineStage[] = [];
+
+  const singleFilter = state.filters.length === 1 ? state.filters[0] : undefined;
+  if (singleFilter) {
+    stages.push(new MongoMatchStage(singleFilter));
+  } else if (state.filters.length > 1) {
+    stages.push(new MongoMatchStage(MongoAndExpr.of([...state.filters])));
+  }
+
+  if (state.includes.length > 0) {
+    stages.push(...compileIncludes(state.includes));
+  }
+
+  if (state.orderBy) {
+    stages.push(new MongoSortStage(state.orderBy));
+  }
+
+  if (state.offset !== undefined) {
+    stages.push(new MongoSkipStage(state.offset));
+  }
+
+  if (state.limit !== undefined) {
+    stages.push(new MongoLimitStage(state.limit));
+  }
+
+  if (state.selectedFields && state.selectedFields.length > 0) {
+    const projection: Record<string, 0 | 1> = {};
+    for (const field of state.selectedFields) {
+      projection[field] = 1;
+    }
+    if (!Object.hasOwn(projection, '_id')) {
+      projection['_id'] = 0;
+    }
+    stages.push(new MongoProjectStage(projection));
+  }
+
+  const meta: PlanMeta = {
+    target: 'mongo',
+    storageHash,
+    lane: 'mongo-orm',
+    paramDescriptors: [],
+  };
+  const command = new AggregateCommand(collection, stages);
+  return { collection, command, meta };
+}

package/src/executor.ts

@@ -0,0 +1,6 @@
+import type { AsyncIterableResult } from '@prisma-next/framework-components/runtime';
+import type { MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
+
+export interface MongoQueryExecutor {
+  execute<Row>(plan: MongoQueryPlan<Row>): AsyncIterableResult<Row>;
+}

package/src/exports/index.ts

@@ -1,13 +1,34 @@
+export type { MongoCollection } from '../collection';
+export { createMongoCollection } from '../collection';
+export { compileMongoQuery } from '../compile';
+export type { MongoQueryExecutor } from '../executor';
+export type {
+  DotPath,
+  FieldAccessor,
+  FieldExpression,
+  FieldOperation,
+  ResolveDotPathType,
+  UpdateOperator,
+} from '../field-accessor';
+export { createFieldAccessor } from '../field-accessor';
+export type { MongoOrmClient, MongoOrmOptions } from '../mongo-orm';
 export { mongoOrm } from '../mongo-orm';
+export type { MongoRawClient } from '../mongo-raw';
+export { mongoRaw } from '../mongo-raw';
+export type { RawMongoCollection } from '../raw-collection';
 export type {
+  CreateInput,
+  DefaultModelRow,
+  IncludedRow,
   IncludeResultFields,
   InferFullRow,
   InferRootRow,
-  MongoCollection,
-  MongoFindManyOptions,
   MongoIncludeSpec,
-  MongoOrmClient,
-  MongoOrmOptions,
-  MongoQueryExecutor,
   MongoWhereFilter,
+  NoIncludes,
+  ResolvedCreateInput,
+  SimplifyDeep,
+  VariantCreateInput,
+  VariantModelRow,
+  VariantNames,
 } from '../types';

package/src/field-accessor.ts

@@ -0,0 +1,265 @@
+import type { ContractField, ContractValueObject } from '@prisma-next/contract/types';
+import type {
+  ExtractMongoCodecTypes,
+  ExtractMongoFieldOutputTypes,
+  InferModelRow,
+  MongoContract,
+  MongoContractWithTypeMaps,
+  MongoTypeMaps,
+} from '@prisma-next/mongo-contract';
+import type { MongoValue } from '@prisma-next/mongo-value';
+import { MongoParamRef } from '@prisma-next/mongo-value';
+
+// ── Runtime types ────────────────────────────────────────────────────────────
+
+export type UpdateOperator =
+  | '$set'
+  | '$unset'
+  | '$inc'
+  | '$mul'
+  | '$push'
+  | '$pull'
+  | '$addToSet'
+  | '$pop';
+
+export interface FieldOperation {
+  readonly operator: UpdateOperator;
+  readonly field: string;
+  readonly value: MongoValue;
+}
+
+// ── Compile-time types ───────────────────────────────────────────────────────
+
+type ScalarFieldKeys<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in keyof TContract['models'][ModelName]['fields'] &
+    string]: TContract['models'][ModelName]['fields'][K] extends {
+    readonly type: { readonly kind: 'scalar' };
+  }
+    ? K
+    : never;
+}[keyof TContract['models'][ModelName]['fields'] & string];
+
+type ValueObjectFieldKeys<
+  TContract extends MongoContract,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in keyof TContract['models'][ModelName]['fields'] &
+    string]: TContract['models'][ModelName]['fields'][K] extends {
+    readonly type: { readonly kind: 'valueObject'; readonly name: string };
+  }
+    ? K
+    : never;
+}[keyof TContract['models'][ModelName]['fields'] & string];
+
+type ResolvedModelRow<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = string extends keyof ExtractMongoFieldOutputTypes<TContract>
+  ? InferModelRow<TContract, ModelName>
+  : ModelName extends keyof ExtractMongoFieldOutputTypes<TContract>
+    ? {
+        -readonly [K in keyof ExtractMongoFieldOutputTypes<TContract>[ModelName]]: ExtractMongoFieldOutputTypes<TContract>[ModelName][K];
+      }
+    : InferModelRow<TContract, ModelName>;
+
+type ResolveFieldType<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  K extends keyof TContract['models'][ModelName]['fields'] & string,
+> = K extends keyof ResolvedModelRow<TContract, ModelName>
+  ? ResolvedModelRow<TContract, ModelName>[K]
+  : unknown;
+
+type NumericOps = {
+  inc(value: number): FieldOperation;
+  mul(value: number): FieldOperation;
+};
+
+export type FieldExpression<T = unknown> = {
+  set(value: T): FieldOperation;
+  unset(): FieldOperation;
+  push(value: T extends readonly (infer E)[] ? E : unknown): FieldOperation;
+  pull(match: T extends readonly (infer E)[] ? E | Partial<E> : unknown): FieldOperation;
+  addToSet(value: T extends readonly (infer E)[] ? E : unknown): FieldOperation;
+  pop(end: 1 | -1): FieldOperation;
+} & (T extends number ? NumericOps : unknown);
+
+type HasValueObjects = { readonly valueObjects?: Record<string, ContractValueObject> };
+
+type VOFields<TContract extends HasValueObjects, VOName extends string> = TContract extends {
+  readonly valueObjects: infer VOs extends Record<string, ContractValueObject>;
+}
+  ? VOName extends keyof VOs
+    ? VOs[VOName]['fields']
+    : never
+  : never;
+
+type VOScalarFieldKeys<Fields extends Record<string, ContractField>> = {
+  [K in keyof Fields & string]: Fields[K] extends { readonly type: { readonly kind: 'scalar' } }
+    ? K
+    : never;
+}[keyof Fields & string];
+
+type VOValueObjectFieldKeys<Fields extends Record<string, ContractField>> = {
+  [K in keyof Fields & string]: Fields[K] extends {
+    readonly type: { readonly kind: 'valueObject'; readonly name: string };
+  }
+    ? K
+    : never;
+}[keyof Fields & string];
+
+type VODotPaths<
+  TContract extends HasValueObjects,
+  Fields extends Record<string, ContractField>,
+  Prefix extends string,
+> =
+  | { [K in VOScalarFieldKeys<Fields>]: `${Prefix}${K}` }[VOScalarFieldKeys<Fields>]
+  | {
+      [K in VOValueObjectFieldKeys<Fields>]: Fields[K] extends {
+        readonly type: { readonly kind: 'valueObject'; readonly name: infer N extends string };
+      }
+        ? VODotPaths<TContract, VOFields<TContract, N>, `${Prefix}${K}.`>
+        : never;
+    }[VOValueObjectFieldKeys<Fields>];
+
+export type DotPath<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  [K in ValueObjectFieldKeys<
+    TContract,
+    ModelName
+  >]: TContract['models'][ModelName]['fields'][K] extends {
+    readonly type: { readonly kind: 'valueObject'; readonly name: infer N extends string };
+  }
+    ? VODotPaths<TContract, VOFields<TContract, N>, `${K}.`>
+    : never;
+}[ValueObjectFieldKeys<TContract, ModelName>];
+
+type ResolveDotPathInFields<
+  TContract extends HasValueObjects,
+  Fields extends Record<string, ContractField>,
+  Path extends string,
+  TCodecTypes extends Record<string, { output: unknown }>,
+> = Path extends `${infer Head}.${infer Rest}`
+  ? Head extends keyof Fields & string
+    ? Fields[Head] extends {
+        readonly type: { readonly kind: 'valueObject'; readonly name: infer N extends string };
+      }
+      ? ResolveDotPathInFields<TContract, VOFields<TContract, N>, Rest, TCodecTypes>
+      : never
+    : never
+  : Path extends keyof Fields & string
+    ? Fields[Path] extends {
+        readonly type: {
+          readonly kind: 'scalar';
+          readonly codecId: infer CId extends string & keyof TCodecTypes;
+        };
+      }
+      ? TCodecTypes[CId]['output']
+      : unknown
+    : never;
+
+export type ResolveDotPathType<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+  Path extends string,
+  TCodecTypes extends Record<string, { output: unknown }> = ExtractMongoCodecTypes<TContract>,
+> = Path extends `${infer Head}.${infer Rest}`
+  ? Head extends keyof TContract['models'][ModelName]['fields'] & string
+    ? TContract['models'][ModelName]['fields'][Head] extends {
+        readonly type: { readonly kind: 'valueObject'; readonly name: infer N extends string };
+      }
+      ? ResolveDotPathInFields<TContract, VOFields<TContract, N>, Rest, TCodecTypes>
+      : never
+    : never
+  : never;
+
+export type FieldAccessor<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+> = {
+  readonly [K in ScalarFieldKeys<TContract, ModelName>]: FieldExpression<
+    ResolveFieldType<TContract, ModelName, K>
+  >;
+} & {
+  readonly [K in ValueObjectFieldKeys<TContract, ModelName>]: FieldExpression<
+    ResolveFieldType<TContract, ModelName, K>
+  >;
+} & (<P extends DotPath<TContract, ModelName>>(
+    path: P,
+  ) => FieldExpression<ResolveDotPathType<TContract, ModelName, P>>);
+
+// ── Runtime implementation ───────────────────────────────────────────────────
+
+// Runtime expression has all methods; type-level gating happens via FieldExpression<T>
+interface RuntimeFieldExpression extends NumericOps {
+  set(value: unknown): FieldOperation;
+  unset(): FieldOperation;
+  push(value: unknown): FieldOperation;
+  pull(match: unknown): FieldOperation;
+  addToSet(value: unknown): FieldOperation;
+  pop(end: 1 | -1): FieldOperation;
+}
+
+function createFieldExpression(fieldPath: string): RuntimeFieldExpression {
+  return {
+    set(value: unknown): FieldOperation {
+      return { operator: '$set', field: fieldPath, value: new MongoParamRef(value) };
+    },
+    unset(): FieldOperation {
+      return { operator: '$unset', field: fieldPath, value: new MongoParamRef('') };
+    },
+    inc(value: number): FieldOperation {
+      return { operator: '$inc', field: fieldPath, value: new MongoParamRef(value) };
+    },
+    mul(value: number): FieldOperation {
+      return { operator: '$mul', field: fieldPath, value: new MongoParamRef(value) };
+    },
+    push(value: unknown): FieldOperation {
+      return { operator: '$push', field: fieldPath, value: new MongoParamRef(value) };
+    },
+    pull(match: unknown): FieldOperation {
+      return { operator: '$pull', field: fieldPath, value: new MongoParamRef(match) };
+    },
+    addToSet(value: unknown): FieldOperation {
+      return { operator: '$addToSet', field: fieldPath, value: new MongoParamRef(value) };
+    },
+    pop(end: 1 | -1): FieldOperation {
+      return { operator: '$pop', field: fieldPath, value: new MongoParamRef(end) };
+    },
+  };
+}
+
+export function createFieldAccessor<
+  TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
+  ModelName extends string & keyof TContract['models'],
+>(): FieldAccessor<TContract, ModelName> {
+  return new Proxy((() => {}) as unknown as FieldAccessor<TContract, ModelName>, {
+    get(_target, prop: string): RuntimeFieldExpression {
+      return createFieldExpression(prop);
+    },
+    apply(_target, _thisArg, args: [string]): RuntimeFieldExpression {
+      return createFieldExpression(args[0]);
+    },
+  });
+}
+
+export function compileFieldOperations(
+  ops: readonly FieldOperation[],
+  wrapValue: (field: string, value: MongoValue, operator: UpdateOperator) => MongoValue,
+): Record<string, Record<string, MongoValue>> {
+  const grouped: Record<string, Record<string, MongoValue>> = {};
+  for (const op of ops) {
+    let group = grouped[op.operator];
+    if (!group) {
+      group = {};
+      grouped[op.operator] = group;
+    }
+    group[op.field] = wrapValue(op.field, op.value, op.operator);
+  }
+  return grouped;
+}

package/src/mongo-orm.ts

@@ -1,130 +1,25 @@
-import type { DomainReferenceRelation, PlanMeta } from '@prisma-next/contract/types';
-import {
-  AggregateCommand,
-  FindCommand,
-  type MongoContract,
-  type MongoContractWithTypeMaps,
-  type MongoExpr,
-  type MongoModelDefinition,
-  type MongoQueryPlan,
-  type MongoTypeMaps,
-} from '@prisma-next/mongo-core';
-import type { AsyncIterableResult } from '@prisma-next/runtime-executor';
 import type {
-  MongoFindManyOptions,
-  MongoIncludeSpec,
-  MongoOrmClient,
-  MongoOrmOptions,
-  MongoQueryExecutor,
-} from './types';
-
-const stubMeta: PlanMeta = {
-  target: 'mongo',
-  storageHash: 'orm',
-  lane: 'mongo-orm',
-  paramDescriptors: [],
-};
-
-function resolveCollection(model: MongoModelDefinition, modelName: string): string {
-  return model.storage.collection ?? modelName;
+  MongoContract,
+  MongoContractWithTypeMaps,
+  MongoTypeMaps,
+} from '@prisma-next/mongo-contract';
+import type { MongoCollection } from './collection';
+import { createMongoCollection } from './collection';
+import type { MongoQueryExecutor } from './executor';
+
+export interface MongoOrmOptions<TContract extends MongoContract> {
+  readonly contract: TContract;
+  readonly executor: MongoQueryExecutor;
 }
 
-function buildLookupStages(
-  contract: MongoContract,
-  model: MongoModelDefinition,
-  include: Record<string, true>,
-): Record<string, unknown>[] {
-  const stages: Record<string, unknown>[] = [];
-
-  for (const [relName, shouldInclude] of Object.entries(include)) {
-    if (!shouldInclude) continue;
-
-    const relation = model.relations?.[relName];
-    if (!relation) continue;
-
-    const targetModel = contract.models[relation.to];
-    if (!targetModel || targetModel.owner) continue;
-
-    const ref = relation as DomainReferenceRelation;
-
-    if (ref.on.localFields.length !== 1 || ref.on.targetFields.length !== 1) {
-      throw new Error(
-        `Compound references are not yet supported: relation "${relName}" has ${ref.on.localFields.length} local field(s) and ${ref.on.targetFields.length} target field(s)`,
-      );
-    }
-
-    const targetCollection = resolveCollection(targetModel, ref.to);
-
-    stages.push({
-      $lookup: {
-        from: targetCollection,
-        localField: ref.on.localFields[0],
-        foreignField: ref.on.targetFields[0],
-        as: relName,
-      },
-    });
-
-    if (ref.cardinality === 'N:1' || ref.cardinality === '1:1') {
-      stages.push({
-        $unwind: {
-          path: `$${relName}`,
-          preserveNullAndEmptyArrays: true,
-        },
-      });
-    }
-  }
-
-  return stages;
-}
-
-class MongoCollectionImpl<
+export type MongoOrmClient<
   TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>,
-  ModelName extends string & keyof TContract['models'],
-> {
-  readonly #contract: TContract;
-  readonly #modelName: ModelName;
-  readonly #executor: MongoQueryExecutor;
-
-  constructor(contract: TContract, modelName: ModelName, executor: MongoQueryExecutor) {
-    this.#contract = contract;
-    this.#modelName = modelName;
-    this.#executor = executor;
-  }
-
-  findMany<TInclude extends MongoIncludeSpec<TContract, ModelName> = Record<string, never>>(
-    options?: MongoFindManyOptions<TContract, ModelName, TInclude>,
-  ): AsyncIterableResult<unknown> {
-    const model = this.#contract.models[this.#modelName] as MongoModelDefinition;
-    const collection = resolveCollection(model, this.#modelName as string);
-    const filter = options?.where ? (options.where as unknown as MongoExpr) : undefined;
-    const include = options?.include as Record<string, true> | undefined;
-
-    const hasIncludes = include && Object.keys(include).length > 0;
-
-    let plan: MongoQueryPlan;
-    if (hasIncludes) {
-      const pipeline: Record<string, unknown>[] = [];
-
-      if (filter && Object.keys(filter as Record<string, unknown>).length > 0) {
-        pipeline.push({ $match: filter });
-      }
-
-      pipeline.push(...buildLookupStages(this.#contract, model, include));
-
-      plan = {
-        command: new AggregateCommand(collection, pipeline),
-        meta: stubMeta,
-      };
-    } else {
-      plan = {
-        command: new FindCommand(collection, filter),
-        meta: stubMeta,
-      };
-    }
-
-    return this.#executor.execute(plan);
-  }
-}
+> = {
+  readonly [K in keyof TContract['roots']]: TContract['roots'][K] extends string &
+    keyof TContract['models']
+    ? MongoCollection<TContract, TContract['roots'][K]>
+    : never;
+};
 
 export function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>>(
   options: MongoOrmOptions<TContract>,
@@ -133,7 +28,7 @@ export function mongoOrm<TContract extends MongoContractWithTypeMaps<MongoContra
   const client: Record<string, unknown> = {};
 
   for (const [rootName, modelName] of Object.entries(contract.roots)) {
-    client[rootName] = new MongoCollectionImpl(
+    client[rootName] = createMongoCollection(
       contract,
       modelName as string & keyof TContract['models'],
       executor,

package/src/mongo-raw.ts

@@ -0,0 +1,33 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
+import type { MongoContract, MongoModelDefinition } from '@prisma-next/mongo-contract';
+import { createRawMongoCollection, type RawMongoCollection } from './raw-collection';
+
+export interface MongoRawClient<TContract extends MongoContract> {
+  collection<K extends keyof TContract['roots'] & string>(rootName: K): RawMongoCollection;
+}
+
+export function mongoRaw<TContract extends MongoContract>(options: {
+  contract: TContract;
+}): MongoRawClient<TContract> {
+  const { contract } = options;
+
+  return {
+    collection<K extends keyof TContract['roots'] & string>(rootName: K): RawMongoCollection {
+      const modelName = contract.roots[rootName] as string;
+      if (!Object.hasOwn(contract.models, modelName)) {
+        throw new Error(`Unknown model "${modelName}" for root "${rootName}"`);
+      }
+      const model = contract.models[modelName] as MongoModelDefinition;
+      const collectionName = model.storage.collection ?? modelName;
+
+      const meta: PlanMeta = {
+        target: 'mongo',
+        storageHash: contract.storage.storageHash,
+        lane: 'mongo-raw',
+        paramDescriptors: [],
+      };
+
+      return createRawMongoCollection(collectionName, meta);
+    },
+  };
+}

package/src/raw-collection.ts

@@ -0,0 +1,95 @@
+import type { PlanMeta } from '@prisma-next/contract/types';
+import type { MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
+import {
+  RawAggregateCommand,
+  RawDeleteManyCommand,
+  RawDeleteOneCommand,
+  RawFindOneAndDeleteCommand,
+  RawFindOneAndUpdateCommand,
+  RawInsertManyCommand,
+  RawInsertOneCommand,
+  RawUpdateManyCommand,
+  RawUpdateOneCommand,
+} from '@prisma-next/mongo-query-ast/execution';
+import type { Document } from '@prisma-next/mongo-value';
+
+interface Buildable<Row = unknown> {
+  build(): MongoQueryPlan<Row>;
+}
+
+export interface RawMongoCollection {
+  aggregate<Row = Record<string, unknown>>(pipeline: ReadonlyArray<Document>): Buildable<Row>;
+
+  insertOne(document: Document): Buildable;
+  insertMany(documents: ReadonlyArray<Document>): Buildable;
+
+  updateOne(filter: Document, update: Document | ReadonlyArray<Document>): Buildable;
+
+  updateMany(filter: Document, update: Document | ReadonlyArray<Document>): Buildable;
+
+  deleteOne(filter: Document): Buildable;
+  deleteMany(filter: Document): Buildable;
+
+  findOneAndUpdate(
+    filter: Document,
+    update: Document | ReadonlyArray<Document>,
+    options?: { upsert?: boolean },
+  ): Buildable;
+
+  findOneAndDelete(filter: Document): Buildable;
+}
+
+export function createRawMongoCollection(
+  collectionName: string,
+  meta: PlanMeta,
+): RawMongoCollection {
+  function buildable<Row>(command: MongoQueryPlan['command']): Buildable<Row> {
+    return {
+      build: () => ({ collection: collectionName, command, meta }),
+    };
+  }
+
+  return {
+    aggregate<Row = Record<string, unknown>>(pipeline: ReadonlyArray<Document>) {
+      return buildable<Row>(new RawAggregateCommand(collectionName, pipeline));
+    },
+
+    insertOne(document: Document) {
+      return buildable(new RawInsertOneCommand(collectionName, document));
+    },
+
+    insertMany(documents: ReadonlyArray<Document>) {
+      return buildable(new RawInsertManyCommand(collectionName, documents));
+    },
+
+    updateOne(filter: Document, update: Document | ReadonlyArray<Document>) {
+      return buildable(new RawUpdateOneCommand(collectionName, filter, update));
+    },
+
+    updateMany(filter: Document, update: Document | ReadonlyArray<Document>) {
+      return buildable(new RawUpdateManyCommand(collectionName, filter, update));
+    },
+
+    deleteOne(filter: Document) {
+      return buildable(new RawDeleteOneCommand(collectionName, filter));
+    },
+
+    deleteMany(filter: Document) {
+      return buildable(new RawDeleteManyCommand(collectionName, filter));
+    },
+
+    findOneAndUpdate(
+      filter: Document,
+      update: Document | ReadonlyArray<Document>,
+      options?: { upsert?: boolean },
+    ) {
+      return buildable(
+        new RawFindOneAndUpdateCommand(collectionName, filter, update, options?.upsert ?? false),
+      );
+    },
+
+    findOneAndDelete(filter: Document) {
+      return buildable(new RawFindOneAndDeleteCommand(collectionName, filter));
+    },
+  };
+}