@prisma-next/mongo-core 0.0.1

package/src/validate-storage.ts

@@ -0,0 +1,64 @@
+import type { MongoContract } from './contract-types';
+
+export function validateMongoStorage(contract: MongoContract): void {
+  const errors: string[] = [];
+
+  for (const [modelName, model] of Object.entries(contract.models)) {
+    if (model.storage.collection && !(model.storage.collection in contract.storage.collections)) {
+      errors.push(
+        `Model "${modelName}" references collection "${model.storage.collection}" which is not in storage.collections`,
+      );
+    }
+
+    // Mongo does not support multi-table inheritance (ADR 2): all variants of a base
+    // must share the same collection (single-table inheritance only).
+    if (model.base) {
+      const baseModel = contract.models[model.base];
+      if (baseModel) {
+        const variantCollection = model.storage.collection;
+        const baseCollection = baseModel.storage.collection;
+        if (variantCollection !== baseCollection) {
+          errors.push(
+            `Mongo does not support multi-table inheritance; variant "${modelName}" must share its base's collection ("${baseCollection ?? '(none)'}"), but has "${variantCollection ?? '(none)'}"`,
+          );
+        }
+      }
+    }
+
+    for (const [relName, relation] of Object.entries(model.relations)) {
+      if (relation.strategy === 'embed') {
+        const target = contract.models[relation.to];
+        if (target?.storage.collection) {
+          errors.push(
+            `Embed relation "${relName}" targets "${relation.to}" which must not have a collection`,
+          );
+        }
+      }
+
+      if (relation.strategy === 'reference') {
+        for (const localField of relation.on.localFields) {
+          if (!(localField in model.fields)) {
+            errors.push(
+              `Reference relation "${relName}": localField "${localField}" is not a field on model "${modelName}"`,
+            );
+          }
+        }
+
+        const targetModel = contract.models[relation.to];
+        if (targetModel) {
+          for (const targetField of relation.on.targetFields) {
+            if (!(targetField in targetModel.fields)) {
+              errors.push(
+                `Reference relation "${relName}": targetField "${targetField}" is not a field on model "${relation.to}"`,
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Contract storage validation failed:\n- ${errors.join('\n- ')}`);
+  }
+}

package/src/values.ts

@@ -0,0 +1,12 @@
+import type { MongoParamRef } from './param-ref';
+
+export type LiteralValue = string | number | boolean | null | Date;
+export type MongoValue = MongoParamRef | LiteralValue | MongoDocument | MongoArray;
+export interface MongoDocument {
+  readonly [key: string]: MongoValue;
+}
+export interface MongoArray extends ReadonlyArray<MongoValue> {}
+export type MongoExpr = MongoDocument;
+export type MongoUpdateDocument = Record<string, MongoValue>;
+export type RawPipeline = ReadonlyArray<Record<string, unknown>>;
+export type Document = Record<string, unknown>;

package/src/wire-commands.ts

@@ -0,0 +1,95 @@
+import type { Document, RawPipeline } from './values';
+
+abstract class MongoWireCommand {
+  abstract readonly kind: string;
+  readonly collection: string;
+
+  protected constructor(collection: string) {
+    this.collection = collection;
+  }
+
+  protected freeze(): void {
+    Object.freeze(this);
+  }
+}
+
+export class FindWireCommand extends MongoWireCommand {
+  readonly kind = 'find' as const;
+  readonly filter: Document | undefined;
+  readonly projection: Document | undefined;
+  readonly sort: Document | undefined;
+  readonly limit: number | undefined;
+  readonly skip: number | undefined;
+
+  constructor(
+    collection: string,
+    filter?: Document,
+    options?: {
+      projection?: Document;
+      sort?: Document;
+      limit?: number;
+      skip?: number;
+    },
+  ) {
+    super(collection);
+    this.filter = filter;
+    this.projection = options?.projection;
+    this.sort = options?.sort;
+    this.limit = options?.limit;
+    this.skip = options?.skip;
+    this.freeze();
+  }
+}
+
+export class InsertOneWireCommand extends MongoWireCommand {
+  readonly kind = 'insertOne' as const;
+  readonly document: Document;
+
+  constructor(collection: string, document: Document) {
+    super(collection);
+    this.document = document;
+    this.freeze();
+  }
+}
+
+export class UpdateOneWireCommand extends MongoWireCommand {
+  readonly kind = 'updateOne' as const;
+  readonly filter: Document;
+  readonly update: Document;
+
+  constructor(collection: string, filter: Document, update: Document) {
+    super(collection);
+    this.filter = filter;
+    this.update = update;
+    this.freeze();
+  }
+}
+
+export class DeleteOneWireCommand extends MongoWireCommand {
+  readonly kind = 'deleteOne' as const;
+  readonly filter: Document;
+
+  constructor(collection: string, filter: Document) {
+    super(collection);
+    this.filter = filter;
+    this.freeze();
+  }
+}
+
+export class AggregateWireCommand extends MongoWireCommand {
+  readonly kind = 'aggregate' as const;
+  readonly pipeline: RawPipeline;
+
+  constructor(collection: string, pipeline: RawPipeline) {
+    super(collection);
+    this.pipeline = pipeline;
+    this.freeze();
+  }
+}
+
+export type AnyMongoWireCommand =
+  | FindWireCommand
+  | InsertOneWireCommand
+  | UpdateOneWireCommand
+  | DeleteOneWireCommand
+  | AggregateWireCommand;