@classytic/mongokit 3.18.0 → 3.19.0

package/dist/query/primitives/coercion.d.mts

@@ -1,2 +1,2 @@
-import { a as coerceHeuristic, i as coerceFieldValue, n as SchemaPathsLike, o as coerceToType, r as buildFieldTypeMap, s as normalizeMongooseType, t as FieldType } from "../../coercion-TRMmR49h.mjs";
+import { a as coerceHeuristic, i as coerceFieldValue, n as SchemaPathsLike, o as coerceToType, r as buildFieldTypeMap, s as normalizeMongooseType, t as FieldType } from "../../coercion-BxxHyLjP.mjs";
 export { FieldType, SchemaPathsLike, buildFieldTypeMap, coerceFieldValue, coerceHeuristic, coerceToType, normalizeMongooseType };

package/dist/query/primitives/indexes.d.mts

@@ -1,2 +1,2 @@
-import { n as SchemaIndexes, r as extractSchemaIndexes, t as IndexableSchema } from "../../indexes-CgOF7Wjd.mjs";
+import { n as SchemaIndexes, r as extractSchemaIndexes, t as IndexableSchema } from "../../indexes-3eHBWNZ2.mjs";
 export { IndexableSchema, SchemaIndexes, extractSchemaIndexes };

package/dist/testkit/index.d.mts

@@ -0,0 +1,129 @@
+import { a as Repository, n as CreateRepositoryConfig } from "../create-repository-K0yft2ht.mjs";
+import { Connection, Model, Schema } from "mongoose";
+import { MongoMemoryReplSet, MongoMemoryServer } from "mongodb-memory-server";
+
+//#region src/testkit/index.d.ts
+interface MongoMemoryOptions {
+  /**
+   * Boot a single-node replica set instead of a standalone mongod. Required for
+   * any code that opens a `session.startTransaction()` — a standalone server
+   * rejects it with error 263. Slightly slower to start (~2-3s). Default false.
+   */
+  replset?: boolean;
+  /** Database name baked into the generated URI. Default `"mongokit-test"`. */
+  dbName?: string;
+  /**
+   * Use this URI instead of spinning an in-memory server (real MongoDB, CI
+   * replica set). Falls back to `process.env.MONGODB_URI`. When either is set,
+   * `stop()` is a no-op — the caller owns the server's lifecycle.
+   */
+  uri?: string;
+}
+interface MongoMemoryHandle {
+  /** Connection string for the running (or external) server. */
+  uri: string;
+  /** The in-memory server; `undefined` when an external `uri` is used. */
+  server?: MongoMemoryServer | MongoMemoryReplSet;
+  /** Stop the in-memory server. No-op for an external URI. Idempotent. */
+  stop(): Promise<void>;
+}
+/**
+ * Start an ephemeral MongoDB (or resolve an external one) and return its URI +
+ * a `stop()` teardown. Prefer `createTestConnection` / `createTestRepository`
+ * unless you need the server without a mongoose connection.
+ */
+declare function createMongoMemory(options?: MongoMemoryOptions): Promise<MongoMemoryHandle>;
+interface TestConnection {
+  /** An isolated mongoose connection (never the global `mongoose.connection`). */
+  connection: Connection;
+  uri: string;
+  /** Empty every collection on this connection — call in `beforeEach`. */
+  clear(): Promise<void>;
+  /** Close the connection and stop the server. Idempotent. */
+  close(): Promise<void>;
+}
+/** Drop every document in every collection on a connection (models preserved). */
+declare function clearCollections(connection: Connection): Promise<void>;
+/**
+ * Start (or resolve) a server AND open an isolated mongoose connection over it.
+ * Each call gets its own connection — model registries are per-connection, so
+ * repeated boots in one process never collide.
+ */
+declare function createTestConnection(options?: MongoMemoryOptions): Promise<TestConnection>;
+/**
+ * Scoped harness: start a connection, run `fn`, and tear down in a `finally`
+ * even if `fn` throws.
+ *
+ * ```ts
+ * await withMongoMemory(async ({ connection }) => {
+ *   const repo = createRepository(connection.model("User", userSchema));
+ *   // ... assertions ...
+ * });
+ * ```
+ */
+declare function withMongoMemory<T>(fn: (ctx: TestConnection) => Promise<T> | T, options?: MongoMemoryOptions): Promise<T>;
+interface CreateTestRepositoryOptions<TDoc> extends MongoMemoryOptions {
+  /** Model / collection name (unique per test to avoid cross-file collisions). */
+  name: string;
+  /** Mongoose schema for the model. */
+  schema: Schema<TDoc>;
+  /** mongokit `createRepository` config — tenant, softDelete, plugins, cache… */
+  config?: CreateRepositoryConfig;
+}
+interface TestRepository<TDoc> {
+  /** A live mongokit repository over an in-memory collection. */
+  repository: Repository<TDoc>;
+  /** The underlying mongoose model (bound to the isolated connection). */
+  model: Model<TDoc>;
+  connection: Connection;
+  uri: string;
+  /** Empty this repository's collection. */
+  clear(): Promise<void>;
+  /** Close the connection and stop the server. Idempotent. */
+  close(): Promise<void>;
+}
+/**
+ * The fast path for testing a mongokit repository: spins an in-memory server,
+ * opens an isolated connection, registers the model on it, builds indexes, and
+ * returns a ready `Repository` (plus `clear()` / `close()`).
+ *
+ * ```ts
+ * const t = await createTestRepository({ name: "Order", schema: orderSchema,
+ *   config: { softDelete: true } });
+ * await t.repository.create({ total: 10 });
+ * await t.close();
+ * ```
+ */
+declare function createTestRepository<TDoc>(options: CreateTestRepositoryOptions<TDoc>): Promise<TestRepository<TDoc>>;
+/** The context a module receives from the Mongo backend (live connection + URI). */
+interface MongoTestContext {
+  connection: Connection;
+  uri: string;
+}
+/**
+ * A backend usable by `@classytic/arc-testkit`'s `bootModuleApp`. Structurally
+ * a `TestBackend<MongoTestContext>` — no import of arc-testkit, so mongokit
+ * never depends on it (one-way: arc-testkit consumes this by shape).
+ */
+interface MongoMemoryBackend {
+  setup(): Promise<{
+    ctx: MongoTestContext;
+    teardown: () => Promise<void>;
+  }>;
+}
+/**
+ * A real in-memory Mongo backend for arc-testkit:
+ *
+ * ```ts
+ * import { bootModuleApp } from "@classytic/arc-testkit";
+ * import { mongoMemoryBackend } from "@classytic/mongokit/testkit";
+ *
+ * const t = await bootModuleApp(
+ *   ({ connection }) => [createAccountingModule({ connection, permissions })],
+ *   { backend: mongoMemoryBackend() },
+ * );
+ * ```
+ */
+declare function mongoMemoryBackend(options?: MongoMemoryOptions): MongoMemoryBackend;
+//#endregion
+export { CreateTestRepositoryOptions, MongoMemoryBackend, MongoMemoryHandle, MongoMemoryOptions, MongoTestContext, TestConnection, TestRepository, clearCollections, createMongoMemory, createTestConnection, createTestRepository, mongoMemoryBackend, withMongoMemory };

package/dist/testkit/index.mjs

@@ -0,0 +1,139 @@
+import { t as createRepository } from "../create-repository-D5YX0wGs.mjs";
+import { createConnection } from "mongoose";
+//#region src/testkit/index.ts
+function idempotentStop(server) {
+	let stopped = false;
+	return async () => {
+		if (stopped) return;
+		stopped = true;
+		await server.stop().catch(() => void 0);
+	};
+}
+/**
+* Start an ephemeral MongoDB (or resolve an external one) and return its URI +
+* a `stop()` teardown. Prefer `createTestConnection` / `createTestRepository`
+* unless you need the server without a mongoose connection.
+*/
+async function createMongoMemory(options = {}) {
+	const externalUri = options.uri ?? process.env.MONGODB_URI;
+	if (externalUri) return {
+		uri: externalUri,
+		stop: async () => void 0
+	};
+	const { MongoMemoryServer, MongoMemoryReplSet } = await import("mongodb-memory-server");
+	const dbName = options.dbName ?? "mongokit-test";
+	if (options.replset) {
+		const rs = await MongoMemoryReplSet.create({ replSet: { count: 1 } });
+		return {
+			uri: rs.getUri(dbName),
+			server: rs,
+			stop: idempotentStop(rs)
+		};
+	}
+	const server = await MongoMemoryServer.create();
+	return {
+		uri: server.getUri(dbName),
+		server,
+		stop: idempotentStop(server)
+	};
+}
+/** Drop every document in every collection on a connection (models preserved). */
+async function clearCollections(connection) {
+	const collections = await connection.db?.collections();
+	if (!collections) return;
+	await Promise.all(collections.map((c) => c.deleteMany({})));
+}
+/**
+* Start (or resolve) a server AND open an isolated mongoose connection over it.
+* Each call gets its own connection — model registries are per-connection, so
+* repeated boots in one process never collide.
+*/
+async function createTestConnection(options = {}) {
+	const handle = await createMongoMemory(options);
+	const connection = await createConnection(handle.uri).asPromise();
+	let closed = false;
+	return {
+		connection,
+		uri: handle.uri,
+		clear: () => clearCollections(connection),
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			await connection.close().catch(() => void 0);
+			await handle.stop();
+		}
+	};
+}
+/**
+* Scoped harness: start a connection, run `fn`, and tear down in a `finally`
+* even if `fn` throws.
+*
+* ```ts
+* await withMongoMemory(async ({ connection }) => {
+*   const repo = createRepository(connection.model("User", userSchema));
+*   // ... assertions ...
+* });
+* ```
+*/
+async function withMongoMemory(fn, options = {}) {
+	const ctx = await createTestConnection(options);
+	try {
+		return await fn(ctx);
+	} finally {
+		await ctx.close();
+	}
+}
+/**
+* The fast path for testing a mongokit repository: spins an in-memory server,
+* opens an isolated connection, registers the model on it, builds indexes, and
+* returns a ready `Repository` (plus `clear()` / `close()`).
+*
+* ```ts
+* const t = await createTestRepository({ name: "Order", schema: orderSchema,
+*   config: { softDelete: true } });
+* await t.repository.create({ total: 10 });
+* await t.close();
+* ```
+*/
+async function createTestRepository(options) {
+	const tc = await createTestConnection(options);
+	const model = tc.connection.model(options.name, options.schema);
+	await model.init();
+	return {
+		repository: createRepository(model, options.config),
+		model,
+		connection: tc.connection,
+		uri: tc.uri,
+		clear: async () => {
+			await model.deleteMany({});
+		},
+		close: tc.close
+	};
+}
+/**
+* A real in-memory Mongo backend for arc-testkit:
+*
+* ```ts
+* import { bootModuleApp } from "@classytic/arc-testkit";
+* import { mongoMemoryBackend } from "@classytic/mongokit/testkit";
+*
+* const t = await bootModuleApp(
+*   ({ connection }) => [createAccountingModule({ connection, permissions })],
+*   { backend: mongoMemoryBackend() },
+* );
+* ```
+*/
+function mongoMemoryBackend(options = {}) {
+	return { async setup() {
+		const tc = await createTestConnection(options);
+		return {
+			ctx: {
+				connection: tc.connection,
+				uri: tc.uri
+			},
+			teardown: tc.close
+		};
+	} };
+}
+//#endregion
+export { clearCollections, createMongoMemory, createTestConnection, createTestRepository, mongoMemoryBackend, withMongoMemory };