@classytic/mongokit 3.35.0 → 3.36.0

package/dist/adapter/index.d.mts

@@ -3,15 +3,25 @@ import { Document, Model } from "mongoose";
 import { SchemaBuilderOptions, SchemaGenerator } from "@classytic/repo-core/schema";
 import { AdapterRepositoryInput, AdapterSchemaContext, AdapterValidationResult, DataAdapter, OpenApiSchemas, RepositoryLike, SchemaMetadata } from "@classytic/repo-core/adapter";
 //#region src/adapter/mongoose-adapter.d.ts
-/**
- * Options for creating a Mongoose adapter.
- *
- * `TDoc` is auto-inferred from the Mongoose model — no explicit type
- * needed in most call sites.
- */
-interface MongooseAdapterOptions<TDoc = unknown> {
-  /** Mongoose model instance — preserves document type for type safety. */
-  model: Model<TDoc>;
+interface MongooseAdapterOptions<TDoc = unknown, TModelDoc = unknown> {
+  /**
+   * The Mongoose model. Still a real `Model`, so a Schema or a hand-built
+   * object literal is a COMPILE error — but its document type is INDEPENDENT of
+   * `TDoc`.
+   *
+   * `Model<T>` is invariant in `T`, so `Model<TDoc>` here forced every caller
+   * whose repository speaks a lean entity (string ids) while its schema-inferred
+   * model carries hydrated documents to cast: the two describe one collection
+   * and can never unify. The adapter reads the model for `modelName` and
+   * `.schema.paths` metadata only, never for document typing.
+   *
+   * Decoupling the two parameters removes a static check, so the constructor
+   * restores it at RUNTIME by comparing this model against the one the
+   * repository owns — see `assertModelMatchesRepository`. That check is
+   * strictly stronger: it also rejects two DIFFERENT collections that happen to
+   * share a document shape, which no type could distinguish.
+   */
+  model: Model<TModelDoc>;
   /**
    * Repository implementing CRUD operations.
    *
@@ -58,13 +68,19 @@ interface MongooseAdapterOptions<TDoc = unknown> {
  * Mongoose data adapter — implements the `DataAdapter<TDoc>` contract from
  * `@classytic/repo-core/adapter`.
  */
-declare class MongooseAdapter<TDoc = unknown> implements DataAdapter<TDoc> {
+declare class MongooseAdapter<TDoc = unknown, TModelDoc = unknown> implements DataAdapter<TDoc> {
   readonly type: "mongoose";
   readonly name: string;
-  readonly model: Model<TDoc>;
+  /**
+   * The model as given. Its document type is NOT `TDoc` — a lean repository
+   * legitimately pairs with a hydrated schema-inferred model, so claiming
+   * `Model<TDoc>` here was an assertion the code could not honour. Read it for
+   * `modelName` and `.schema`; narrow it yourself if you need document typing.
+   */
+  readonly model: Model<unknown>;
   readonly repository: RepositoryLike<TDoc>;
   private readonly schemaGenerator?;
-  constructor(options: MongooseAdapterOptions<TDoc>);
+  constructor(options: MongooseAdapterOptions<TDoc, TModelDoc>);
   /**
    * Lightweight path-existence check for hosts that infer absent fields
    * (e.g. arc's `defineResource()` infers `tenantField: false` when the
@@ -159,8 +175,8 @@ declare class MongooseAdapter<TDoc = unknown> implements DataAdapter<TDoc> {
  * const adapter = createMongooseAdapter(ProductModel, productRepository);
  * ```
  */
-declare function createMongooseAdapter<TDoc = unknown>(model: Model<TDoc>, repository: AdapterRepositoryInput<TDoc>): DataAdapter<TDoc>;
-declare function createMongooseAdapter<TDoc = unknown>(options: MongooseAdapterOptions<TDoc>): DataAdapter<TDoc>;
+declare function createMongooseAdapter<TDoc = unknown, TModelDoc = unknown>(model: Model<TModelDoc>, repository: AdapterRepositoryInput<TDoc>): DataAdapter<TDoc>;
+declare function createMongooseAdapter<TDoc = unknown, TModelDoc = unknown>(options: MongooseAdapterOptions<TDoc, TModelDoc>): DataAdapter<TDoc>;
 //#endregion
 //#region src/adapter/types.d.ts
 /**

package/dist/adapter/index.mjs

@@ -1,2 +1,2 @@
-import { n as createMongooseAdapter, r as isMongooseModel, t as MongooseAdapter } from "../adapter-DlaOGcQN.mjs";
+import { n as createMongooseAdapter, r as isMongooseModel, t as MongooseAdapter } from "../adapter-Bfqz8yHE.mjs";
 export { MongooseAdapter, createMongooseAdapter, isMongooseModel };

package/dist/{adapter-DlaOGcQN.mjs → adapter-Bfqz8yHE.mjs}

@@ -65,18 +65,60 @@ function formatInvalidRepositoryError(repository, model) {
 	].join("\n");
 }
 /**
+* Options for creating a Mongoose adapter.
+*
+* `TDoc` is auto-inferred from the Mongoose model — no explicit type
+* needed in most call sites.
+*/
+/**
+* The model and the repository must name the SAME collection.
+*
+* Decoupling their document types (so a lean repository pairs with a hydrated
+* schema-inferred model) removes the static cross-check that `Model<TDoc>` +
+* `AdapterRepositoryInput<TDoc>` gave. This restores it where it can actually be
+* decided — at construction, against `Repository.Model`, which every kit-native
+* repository carries. It is strictly stronger than the type was: two different
+* collections sharing a document shape were always statically indistinguishable.
+*
+* Silent when the repository does not expose a model (a BYO/mock repository) —
+* absence of an answer is not a negative answer, and refusing there would break
+* every legitimate custom repository.
+*/
+function assertModelMatchesRepository(model, repository) {
+	const repoModel = repository?.Model;
+	const repoModelName = typeof repoModel?.modelName === "string" ? repoModel.modelName : void 0;
+	if (repoModelName === void 0 || repoModelName === model.modelName) return;
+	throw new TypeError([
+		`MongooseAdapter: model/repository mismatch — model is '${model.modelName}' but the repository is bound to '${repoModelName}'.`,
+		"",
+		"The adapter reads schema metadata from the MODEL (arc infers a missing",
+		"`tenantField` from it) and reads/writes through the REPOSITORY. Mismatched,",
+		"the tenant probe answers about the wrong collection and queries are either",
+		"filtered to zero rows or left unscoped — neither of which errors.",
+		"",
+		"Fix: pass the model that repository was constructed with."
+	].join("\n"));
+}
+/**
 * Mongoose data adapter — implements the `DataAdapter<TDoc>` contract from
 * `@classytic/repo-core/adapter`.
 */
 var MongooseAdapter = class {
 	type = "mongoose";
 	name;
+	/**
+	* The model as given. Its document type is NOT `TDoc` — a lean repository
+	* legitimately pairs with a hydrated schema-inferred model, so claiming
+	* `Model<TDoc>` here was an assertion the code could not honour. Read it for
+	* `modelName` and `.schema`; narrow it yourself if you need document typing.
+	*/
 	model;
 	repository;
 	schemaGenerator;
 	constructor(options) {
 		if (!isMongooseModel(options.model)) throw new TypeError(formatInvalidModelError(options.model));
 		if (!isRepository(options.repository)) throw new TypeError(formatInvalidRepositoryError(options.repository, options.model));
+		assertModelMatchesRepository(options.model, options.repository);
 		this.model = options.model;
 		this.repository = asRepositoryLike(options.repository);
 		this.schemaGenerator = options.schemaGenerator === false ? void 0 : options.schemaGenerator ?? buildCrudSchemasFromModel;

package/dist/better-auth/index.mjs

@@ -1,5 +1,5 @@
 import { n as Repository } from "../Repository-BArvU32x.mjs";
-import { n as createMongooseAdapter } from "../adapter-DlaOGcQN.mjs";
+import { n as createMongooseAdapter } from "../adapter-Bfqz8yHE.mjs";
 import { asReadOnlyRepo } from "@classytic/repo-core/repository";
 import { pluralizeBetterAuthCollection, resolveBetterAuthCollections } from "@classytic/repo-core/better-auth";
 //#region src/better-auth/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.35.0",
+  "version": "3.36.0",
   "description": "Production-grade MongoDB repositories - smart pagination, events, and plugins. Built on @classytic/repo-core.",
   "type": "module",
   "sideEffects": false,