@wenu/mongo 0.2.4

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## [0.2.4](https://github.com/johnnyhuirilef/toolkit/compare/mongo-v0.2.3...mongo-v0.2.4) (2026-06-25)
+
+
+### Bug Fixes
+
+* **zod-mongo:** declare zod peer dep as required in peerDependenciesMeta ([2ed070b](https://github.com/johnnyhuirilef/toolkit/commit/2ed070b14ed8a984ca1c58ee0b6ce4dd4ebed2d4))
+
+## [0.2.3](https://github.com/johnnyhuirilef/toolkit/compare/mongo-v0.2.2...mongo-v0.2.3) (2026-06-25)
+
+
+### Bug Fixes
+
+* **zod-mongo:** broaden zod peer dependency to support zod v5 ([6b6a3c6](https://github.com/johnnyhuirilef/toolkit/commit/6b6a3c6e4596d71331b9f7440d25167d21d3e53f))
+
+## [0.2.2](https://github.com/johnnyhuirilef/toolkit/compare/mongo-v0.2.1...mongo-v0.2.2) (2026-06-25)
+
+
+### Bug Fixes
+
+* **zod-mongo:** add funding field to package metadata ([ff4e95f](https://github.com/johnnyhuirilef/toolkit/commit/ff4e95fd1dea3bd0b48a523fe2d8185fb56af092))
+
+## [0.2.1](https://github.com/johnnyhuirilef/toolkit/compare/mongo-v0.2.0...mongo-v0.2.1) (2026-06-25)
+
+
+### Bug Fixes
+
+* **zod-mongo:** add missing npm keywords for discoverability ([f52dc3d](https://github.com/johnnyhuirilef/toolkit/commit/f52dc3da7243ce4077347348d076f6477084220c))
+
+## [0.2.0](https://github.com/johnnyhuirilef/toolkit/compare/mongo-v0.1.0...mongo-v0.2.0) (2026-06-25)
+
+
+### Features
+
+* add @wenu/mongo and @wenu/nest-mongo packages ([#17](https://github.com/johnnyhuirilef/toolkit/issues/17)) ([8635018](https://github.com/johnnyhuirilef/toolkit/commit/8635018605ab53468feb0257173e39126cecdcb2))

package/README.md

@@ -0,0 +1,535 @@
+# @wenu/mongo
+
+Declarative, immutable, type-safe MongoDB repository layer with Zod validation. Zero throws. Dual
+ESM/CJS. MongoDB 5/6/7 compatible. Zod 3 and 4 compatible.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Core Concepts](#core-concepts)
+  - [Defining a Collection](#defining-a-collection)
+  - [Creating a Repository](#creating-a-repository)
+  - [Result Type](#result-type)
+- [CRUD Operations](#crud-operations)
+- [Error Handling](#error-handling)
+- [ID Strategies](#id-strategies)
+- [Index Management](#index-management)
+- [Aggregation](#aggregation)
+- [Compatibility](#compatibility)
+- [API Reference](#api-reference)
+
+---
+
+## Features
+
+- **Zero throws** — every method returns `Result<T, DbError>`, never throws
+- **Full type inference** — document shape, `_id` type, and filter types flow from a single
+  `defineCollection()` call
+- **Pluggable ID strategies** — `objectid` (default), `uuid`, `string`, or any Zod schema for custom
+  types
+- **Zod validation on write** — inserts and updates are validated before touching the database
+- **Immutable collection definitions** — `defineCollection()` returns a frozen, reusable descriptor
+- **Index management** — declare indexes alongside the schema, sync or generate migrate-mongo
+  scripts
+- **Typed aggregation** — `aggregate()` accepts an output schema and returns `Result<Infer<Out>[]>`
+- **Dual ESM/CJS** — works in Node ESM projects and CommonJS consumers alike
+
+---
+
+## Installation
+
+```bash
+# npm
+npm install @wenu/mongo
+
+# pnpm
+pnpm add @wenu/mongo
+
+# yarn
+yarn add @wenu/mongo
+```
+
+### Peer dependencies
+
+```bash
+# MongoDB driver (choose one range)
+npm install mongodb@^5   # or ^6 or ^7
+
+# Zod (v3 or v4)
+npm install zod@^3
+```
+
+**Requirements:** Node `>=18.0.0`
+
+---
+
+## Quick Start
+
+```typescript
+import * as z from 'zod';
+import { MongoClient } from 'mongodb';
+import { defineCollection, createRepository } from '@wenu/mongo';
+
+// 1. Define the schema and collection
+const UserCollection = defineCollection({
+  name: 'users',
+  schema: z.object({
+    name: z.string().min(1),
+    email: z.string().email(),
+    createdAt: z.date(),
+  }),
+});
+
+// 2. Connect and create the repository
+const client = await MongoClient.connect('mongodb://localhost:27017');
+const db = client.db('myapp');
+
+const users = createRepository(UserCollection, db);
+
+// 3. Use it — no throws, ever
+const result = await users.insert({
+  name: 'Alice',
+  email: 'alice@example.com',
+  createdAt: new Date(),
+});
+
+if (result.ok) {
+  console.log(result.value._id); // ObjectId (inferred from id: 'objectid')
+} else {
+  console.error(result.error.kind, result.error.message);
+}
+```
+
+---
+
+## Core Concepts
+
+### Defining a Collection
+
+`defineCollection()` is the single source of truth for a collection's shape, ID strategy, and
+indexes. It returns a frozen `CollectionDef` object you pass to `createRepository()` and index
+utilities.
+
+```typescript
+import * as z from 'zod';
+import { defineCollection, index } from '@wenu/mongo';
+
+const ProductCollection = defineCollection({
+  name: 'products',
+  schema: z.object({
+    sku: z.string(),
+    name: z.string(),
+    price: z.number().positive(),
+    tags: z.array(z.string()).default([]),
+  }),
+  id: 'uuid', // optional — defaults to 'objectid'
+  indexes: [index({ sku: 1 }, { unique: true }), index({ tags: 1 })],
+});
+```
+
+The `Doc<Schema, Id>` type resolves to the schema output merged with the inferred `_id` type:
+
+```typescript
+import type { Doc } from '@wenu/mongo';
+
+type Product = Doc<(typeof ProductCollection)['schema'], (typeof ProductCollection)['id']>;
+// { _id: string; sku: string; name: string; price: number; tags: string[] }
+```
+
+### Creating a Repository
+
+Pass the collection definition and a `Db` instance. The repository is a plain object — no classes,
+no state beyond the driver handle.
+
+```typescript
+import { createRepository } from '@wenu/mongo';
+
+const products = createRepository(ProductCollection, db);
+```
+
+All 12 methods return `Promise<Result<T, DbError>>`.
+
+### Result Type
+
+The `Result` type is a discriminated union — it never throws and forces you to handle both paths:
+
+```typescript
+type Ok<T> = { readonly ok: true; readonly value: T };
+type Err<E> = { readonly ok: false; readonly error: E };
+type Result<T, E = DbError> = Ok<T> | Err<E>;
+```
+
+Use the `ok` discriminant or the `isOk` / `isErr` type guards:
+
+```typescript
+import { isOk, isErr } from '@wenu/mongo';
+
+const result = await users.findById(id);
+
+// Discriminant
+if (result.ok) {
+  // result.value is Doc<...> | null
+}
+
+// Type guards
+if (isOk(result)) {
+  console.log(result.value);
+}
+if (isErr(result)) {
+  console.error(result.error);
+}
+```
+
+---
+
+## CRUD Operations
+
+All examples use the `users` repository from the Quick Start.
+
+### Find
+
+```typescript
+// By ID
+const byId = await users.findById(someObjectId);
+
+// By filter — returns first match or null
+const byEmail = await users.findOne({ email: 'alice@example.com' });
+
+// All matching documents
+const all = await users.find({ name: /alice/i });
+
+// All documents (no filter)
+const everyone = await users.find();
+```
+
+### Insert
+
+```typescript
+// Single document — validated before insert
+const inserted = await users.insert({
+  name: 'Bob',
+  email: 'bob@example.com',
+  createdAt: new Date(),
+});
+
+// Multiple documents — validates all first; any failure returns an error before any DB write
+const many = await users.insertMany([
+  { name: 'Carol', email: 'carol@example.com', createdAt: new Date() },
+  { name: 'Dave', email: 'dave@example.com', createdAt: new Date() },
+]);
+```
+
+### Update
+
+```typescript
+// By ID — returns updated document or null if not found
+const updated = await users.updateById(someObjectId, { name: 'Alice Smith' });
+
+// By filter — returns updated document or null
+const updatedOne = await users.updateOne({ email: 'alice@example.com' }, { name: 'Alice Smith' });
+
+// Bulk update — returns { modifiedCount }
+const bulk = await users.updateMany(
+  { createdAt: { $lt: new Date('2024-01-01') } },
+  { name: 'archived' },
+);
+if (bulk.ok) {
+  console.log(`Updated ${bulk.value.modifiedCount} documents`);
+}
+```
+
+### Delete
+
+```typescript
+// By ID — returns deleted document or null
+const deleted = await users.deleteById(someObjectId);
+
+// By filter — returns deleted document or null
+const deletedOne = await users.deleteOne({ email: 'bob@example.com' });
+
+// Bulk delete — returns { deletedCount }
+const bulk = await users.deleteMany({ createdAt: { $lt: cutoff } });
+if (bulk.ok) {
+  console.log(`Deleted ${bulk.value.deletedCount} documents`);
+}
+```
+
+---
+
+## Error Handling
+
+`DbError` carries a discriminated `kind` field so you can branch on error type without inspecting
+message strings:
+
+```typescript
+import type { DbError, DbErrorKind } from '@wenu/mongo';
+
+type DbErrorKind =
+  | 'validation' // Zod parse failed (insert/update input) — no DB call was made
+  | 'duplicate-key' // MongoDB error code 11000 (unique index violation)
+  | 'not-found' // reserved for future use
+  | 'connection' // reserved for future use
+  | 'unknown'; // any other driver error
+```
+
+```typescript
+const result = await products.insert({ sku: 'existing-sku', name: 'X', price: 10, tags: [] });
+
+if (!result.ok) {
+  switch (result.error.kind) {
+    case 'duplicate-key':
+      throw new ConflictError('SKU already exists');
+    case 'validation':
+      throw new BadRequestError(result.error.message);
+    default:
+      throw new InternalError(result.error.message);
+  }
+}
+```
+
+You can also convert any caught value into a `DbError` using `toDbError`:
+
+```typescript
+import { toDbError } from '@wenu/mongo';
+
+const dbError = toDbError(caughtError);
+```
+
+---
+
+## ID Strategies
+
+Set `id` in `defineCollection()`. The `_id` type on every document is inferred automatically.
+
+### `objectid` (default)
+
+Generated by the library using `new ObjectId()`. No `_id` required in input data.
+
+```typescript
+const Collection = defineCollection({ name: 'items', schema, id: 'objectid' });
+// Doc._id: ObjectId
+```
+
+### `uuid`
+
+Generated using `crypto.randomUUID()`. No `_id` required in input data.
+
+```typescript
+const Collection = defineCollection({ name: 'items', schema, id: 'uuid' });
+// Doc._id: string (UUID v4)
+```
+
+### `string`
+
+Caller-supplied string. The schema must include `_id: z.string()`.
+
+```typescript
+const Collection = defineCollection({
+  name: 'items',
+  schema: z.object({ _id: z.string(), name: z.string() }),
+  id: 'string',
+});
+// Doc._id: string (from data)
+```
+
+### Custom Zod schema
+
+Pass any Zod schema as the `id` value. The `_id` type is inferred from the schema's output. The
+caller is responsible for including `_id` in the input data.
+
+```typescript
+import * as z from 'zod';
+
+const OrderId = z.string().brand<'OrderId'>();
+
+const OrderCollection = defineCollection({
+  name: 'orders',
+  schema: z.object({ _id: OrderId, total: z.number() }),
+  id: OrderId,
+});
+// Doc._id: string & Brand<'OrderId'>
+```
+
+---
+
+## Index Management
+
+Declare indexes inside `defineCollection()` using the `index()` helper, then either sync them at
+startup or generate a migrate-mongo migration file.
+
+### Declaring indexes
+
+```typescript
+import { defineCollection, index } from '@wenu/mongo';
+
+const ArticleCollection = defineCollection({
+  name: 'articles',
+  schema: z.object({
+    slug: z.string(),
+    authorId: z.string(),
+    publishedAt: z.date().optional(),
+    tags: z.array(z.string()).default([]),
+  }),
+  indexes: [
+    index({ slug: 1 }, { unique: true }),
+    index({ authorId: 1, publishedAt: -1 }),
+    index({ tags: 1 }),
+  ],
+});
+```
+
+### Syncing at startup
+
+`syncIndexes()` calls `createIndexes()` on the underlying collection and returns `Result<void>`.
+Safe to call on every startup — MongoDB skips indexes that already exist.
+
+```typescript
+import { syncIndexes } from '@wenu/mongo';
+
+const result = await syncIndexes(ArticleCollection, db);
+if (!result.ok) {
+  console.error('Index sync failed:', result.error.message);
+}
+```
+
+### Generating a migrate-mongo script
+
+```typescript
+import { generateIndexMigration } from '@wenu/mongo';
+import fs from 'node:fs';
+
+const migration = generateIndexMigration(ArticleCollection);
+fs.writeFileSync('migrations/20240101-articles-indexes.js', migration);
+```
+
+The generated file exports `up(db)` / `down(db)` compatible with
+[migrate-mongo](https://github.com/seppevs/migrate-mongo).
+
+---
+
+## Aggregation
+
+Pass the pipeline and an output schema. Results are parsed with the provided schema and returned as
+`Result<Infer<Out>[]>`.
+
+```typescript
+import * as z from 'zod';
+
+const SummarySchema = z.object({
+  authorId: z.string(),
+  articleCount: z.number(),
+  latestPublishedAt: z.date().nullable(),
+});
+
+const result = await articles.aggregate(
+  [
+    { $match: { publishedAt: { $exists: true } } },
+    {
+      $group: {
+        _id: '$authorId',
+        articleCount: { $sum: 1 },
+        latestPublishedAt: { $max: '$publishedAt' },
+      },
+    },
+    { $project: { authorId: '$_id', articleCount: 1, latestPublishedAt: 1, _id: 0 } },
+  ],
+  SummarySchema,
+);
+
+if (result.ok) {
+  for (const summary of result.value) {
+    console.log(summary.authorId, summary.articleCount);
+  }
+}
+```
+
+---
+
+## Compatibility
+
+| Feature          | Supported                                   |
+| ---------------- | ------------------------------------------- |
+| Zod 3            | Yes                                         |
+| Zod 4            | Yes (same `ZodCompat` API surface)          |
+| MongoDB driver 5 | Yes (shim normalizes `ModifyResult.value`)  |
+| MongoDB driver 6 | Yes (direct return from `findOneAndUpdate`) |
+| MongoDB driver 7 | Yes                                         |
+| Node.js          | `>=18.0.0`                                  |
+| ESM              | Yes                                         |
+| CJS              | Yes                                         |
+
+---
+
+## API Reference
+
+### `defineCollection(config)`
+
+Creates an immutable `CollectionDef` descriptor.
+
+| Parameter        | Type         | Default      | Description                         |
+| ---------------- | ------------ | ------------ | ----------------------------------- |
+| `config.name`    | `string`     | —            | MongoDB collection name             |
+| `config.schema`  | `ZodCompat`  | —            | Zod schema for the document body    |
+| `config.id`      | `IdStrategy` | `'objectid'` | ID generation or inference strategy |
+| `config.indexes` | `IndexDef[]` | `[]`         | Index definitions                   |
+
+### `createRepository(collection, db)`
+
+Returns a `Repository<Schema, Id>` bound to the collection definition and database.
+
+### `Repository<Schema, Id>` methods
+
+| Method                              | Returns                                      |
+| ----------------------------------- | -------------------------------------------- |
+| `findById(id)`                      | `Promise<Result<Doc \| null>>`               |
+| `findOne(filter)`                   | `Promise<Result<Doc \| null>>`               |
+| `find(filter?)`                     | `Promise<Result<Doc[]>>`                     |
+| `insert(data)`                      | `Promise<Result<Doc>>`                       |
+| `insertMany(data)`                  | `Promise<Result<Doc[]>>`                     |
+| `updateById(id, patch)`             | `Promise<Result<Doc \| null>>`               |
+| `updateOne(filter, patch)`          | `Promise<Result<Doc \| null>>`               |
+| `updateMany(filter, patch)`         | `Promise<Result<{ modifiedCount: number }>>` |
+| `deleteById(id)`                    | `Promise<Result<Doc \| null>>`               |
+| `deleteOne(filter)`                 | `Promise<Result<Doc \| null>>`               |
+| `deleteMany(filter?)`               | `Promise<Result<{ deletedCount: number }>>`  |
+| `aggregate(pipeline, outputSchema)` | `Promise<Result<Infer<Out>[]>>`              |
+
+### `index(spec, options?)`
+
+Creates an `IndexDef`. `spec` follows the MongoDB index key format (`{ field: 1 }`, `{ field: -1 }`,
+etc.).
+
+### `syncIndexes(collection, db)`
+
+Syncs all declared indexes to MongoDB. Returns `Promise<Result<void>>`. Idempotent.
+
+### `generateIndexMigration(collection)`
+
+Returns a migrate-mongo compatible JS migration string (`up` / `down`) for the collection's indexes.
+
+### Result helpers
+
+| Export      | Signature                                | Description                       |
+| ----------- | ---------------------------------------- | --------------------------------- |
+| `ok`        | `<T>(value: T) => Ok<T>`                 | Construct a success result        |
+| `err`       | `<E>(error: E) => Err<E>`                | Construct an error result         |
+| `isOk`      | `<T, E>(r: Result<T, E>) => r is Ok<T>`  | Type guard for success            |
+| `isErr`     | `<T, E>(r: Result<T, E>) => r is Err<E>` | Type guard for error              |
+| `toDbError` | `(e: unknown) => DbError`                | Map any thrown value to `DbError` |
+
+### ID Strategies at a glance
+
+| Strategy               | `_id` type      | Auto-generated              |
+| ---------------------- | --------------- | --------------------------- |
+| `'objectid'` (default) | `ObjectId`      | Yes — `new ObjectId()`      |
+| `'uuid'`               | `string`        | Yes — `crypto.randomUUID()` |
+| `'string'`             | `string`        | No — embed `_id` in data    |
+| Any Zod schema         | `Infer<Schema>` | No — embed `_id` in data    |
+
+---
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,219 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let radashi = require("radashi");
+let zod = require("zod");
+let node_crypto = require("node:crypto");
+let mongodb = require("mongodb");
+//#region src/errors.ts
+const MONGO_DUPLICATE_KEY_CODE = 11e3;
+const toDbError = (error) => {
+	if (error instanceof zod.ZodError) return {
+		kind: "validation",
+		message: (0, radashi.getErrorMessage)(error),
+		cause: error
+	};
+	if ((0, radashi.isError)(error) && "code" in error && error.code === MONGO_DUPLICATE_KEY_CODE) return {
+		kind: "duplicate-key",
+		message: (0, radashi.getErrorMessage)(error),
+		cause: error
+	};
+	if ((0, radashi.isError)(error)) return {
+		kind: "unknown",
+		message: (0, radashi.getErrorMessage)(error),
+		cause: error
+	};
+	return {
+		kind: "unknown",
+		message: String(error)
+	};
+};
+//#endregion
+//#region src/result.ts
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const err = (error) => ({
+	ok: false,
+	error
+});
+const isOk = (r) => r.ok;
+const isErr = (r) => !r.ok;
+//#endregion
+//#region src/indexes.ts
+const index = (spec, options) => ({
+	spec,
+	options
+});
+const syncIndexes = async (collection, database) => {
+	if ((0, radashi.isEmpty)(collection.indexes)) return ok(void 0);
+	const [error] = await (0, radashi.tryit)(() => database.collection(collection.name).createIndexes(collection.indexes.map((indexEntry) => ({
+		key: indexEntry.spec,
+		...indexEntry.options
+	}))))();
+	return (0, radashi.isNullish)(error) ? ok(void 0) : err(toDbError(error));
+};
+const emptyMigration = () => radashi.dedent`
+  'use strict'
+
+  module.exports = {
+    async up(_db) {},
+    async down(_db) {},
+  }
+`;
+const indexMigration = (name, specs, names) => radashi.dedent`
+  'use strict'
+
+  module.exports = {
+    async up(db) {
+      await db.collection('${name}').createIndexes(${specs})
+    },
+    async down(db) {
+      await db.collection('${name}').dropIndexes(${names})
+    },
+  }
+`;
+const generateIndexMigration = (collection) => {
+	if ((0, radashi.isEmpty)(collection.indexes)) return emptyMigration();
+	const specs = JSON.stringify(collection.indexes.map((indexEntry) => ({
+		key: indexEntry.spec,
+		...indexEntry.options
+	})), null, 2);
+	const names = JSON.stringify(collection.indexes.map((indexEntry) => {
+		if (indexEntry.options?.name) return indexEntry.options.name;
+		return Object.keys(indexEntry.spec).map((key) => `${key}_${String(indexEntry.spec[key])}`).join("_");
+	}));
+	return indexMigration(collection.name, specs, names);
+};
+//#endregion
+//#region src/collection.ts
+const defineCollection = (config) => Object.freeze({
+	name: config.name,
+	schema: config.schema,
+	id: config.id ?? "objectid",
+	indexes: Object.freeze(config.indexes ?? [])
+});
+//#endregion
+//#region src/compat/driver.ts
+const MONGO_MAJOR = (() => {
+	const version = require("mongodb/package.json").version;
+	const match = /^(\d+)/.exec(version);
+	return match ? Number(match[1]) : 6;
+})();
+const extractResult = (raw, isV5) => {
+	if (isV5) return raw?.value ?? null;
+	return raw ?? null;
+};
+const findOneAndModify = async (collection, filter, op) => {
+	const isV5 = MONGO_MAJOR <= 5;
+	if (op.kind === "delete") return extractResult(await collection.findOneAndDelete(filter, op.options ?? {}), isV5);
+	return extractResult(await collection.findOneAndUpdate(filter, op.update, {
+		returnDocument: "after",
+		...op.options
+	}), isV5);
+};
+//#endregion
+//#region src/id.ts
+const generateId = (strategy) => {
+	if (strategy === "objectid") return new mongodb.ObjectId();
+	return (0, node_crypto.randomUUID)();
+};
+//#endregion
+//#region src/repository.ts
+const runSafe = async (operation) => {
+	const [error, value] = await (0, radashi.tryit)(operation)();
+	return (0, radashi.isNullish)(error) ? ok(value) : err(toDbError(error));
+};
+const createRepository = (collection, database) => {
+	const coll = database.collection(collection.name);
+	const schema = collection.schema;
+	const idStrategy = collection.id;
+	const parseSchema = (data) => {
+		try {
+			return ok(schema.parse(data));
+		} catch (error) {
+			return err(toDbError(error));
+		}
+	};
+	const parsePartialSchema = (data) => {
+		try {
+			return ok(("partial" in schema && typeof schema.partial === "function" ? schema.partial() : schema).parse(data));
+		} catch (error) {
+			return err(toDbError(error));
+		}
+	};
+	const buildDoc = (validated) => {
+		if (idStrategy === "objectid" || idStrategy === "uuid") {
+			const id = generateId(idStrategy);
+			return {
+				...validated,
+				_id: id
+			};
+		}
+		return { ...validated };
+	};
+	return {
+		findById: (id) => runSafe(() => coll.findOne({ _id: id }).then((found) => (0, radashi.isNullish)(found) ? null : found)),
+		findOne: (filter) => runSafe(() => coll.findOne(filter).then((found) => (0, radashi.isNullish)(found) ? null : found)),
+		find: (filter) => runSafe(() => {
+			return coll.find(filter ?? {}).toArray().then((records) => records);
+		}),
+		insert: async (data) => {
+			const parsed = parseSchema(data);
+			if (!parsed.ok) return parsed;
+			return runSafe(async () => {
+				const record = buildDoc(parsed.value);
+				await coll.insertOne(record);
+				return record;
+			});
+		},
+		insertMany: async (data) => {
+			const parsedItems = [];
+			for (const item of data) {
+				const result = parseSchema(item);
+				if (!result.ok) return result;
+				parsedItems.push(result.value);
+			}
+			return runSafe(async () => {
+				const records = parsedItems.map((item) => buildDoc(item));
+				await coll.insertMany(records);
+				return records;
+			});
+		},
+		updateById: async (id, patch) => {
+			const parsed = parsePartialSchema(patch);
+			if (!parsed.ok) return parsed;
+			return runSafe(() => findOneAndModify(coll, { _id: id }, {
+				kind: "update",
+				update: { $set: (0, radashi.shake)(parsed.value) }
+			}).then((found) => (0, radashi.isNullish)(found) ? null : found));
+		},
+		updateOne: async (filter, patch) => {
+			const parsed = parsePartialSchema(patch);
+			if (!parsed.ok) return parsed;
+			return runSafe(() => findOneAndModify(coll, filter, {
+				kind: "update",
+				update: { $set: (0, radashi.shake)(parsed.value) }
+			}).then((found) => (0, radashi.isNullish)(found) ? null : found));
+		},
+		updateMany: async (filter, patch) => {
+			const parsed = parsePartialSchema(patch);
+			if (!parsed.ok) return parsed;
+			return runSafe(() => coll.updateMany(filter, { $set: (0, radashi.shake)(parsed.value) }).then((result) => ({ modifiedCount: result.modifiedCount })));
+		},
+		deleteById: (id) => runSafe(() => findOneAndModify(coll, { _id: id }, { kind: "delete" }).then((found) => (0, radashi.isNullish)(found) ? null : found)),
+		deleteOne: (filter) => runSafe(() => findOneAndModify(coll, filter, { kind: "delete" }).then((found) => (0, radashi.isNullish)(found) ? null : found)),
+		deleteMany: (filter) => runSafe(() => coll.deleteMany(filter).then((result) => ({ deletedCount: result.deletedCount }))),
+		aggregate: (pipeline, outputSchema) => runSafe(() => coll.aggregate(pipeline).toArray().then((records) => records.map((r) => outputSchema.parse(r))))
+	};
+};
+//#endregion
+exports.createRepository = createRepository;
+exports.defineCollection = defineCollection;
+exports.err = err;
+exports.generateIndexMigration = generateIndexMigration;
+exports.index = index;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.ok = ok;
+exports.syncIndexes = syncIndexes;
+exports.toDbError = toDbError;

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+import { CreateIndexesOptions, Db, Document, Filter, IndexDescription, ObjectId } from "mongodb";
+
+//#region src/errors.d.ts
+type DbErrorKind = 'validation' | 'not-found' | 'duplicate-key' | 'connection' | 'unknown';
+type DbError = {
+  readonly kind: DbErrorKind;
+  readonly message: string;
+  readonly cause?: unknown;
+};
+declare const toDbError: (error: unknown) => DbError;
+//#endregion
+//#region src/result.d.ts
+type Ok<T> = {
+  readonly ok: true;
+  readonly value: T;
+};
+type Err<E> = {
+  readonly ok: false;
+  readonly error: E;
+};
+type Result<T, E = DbError> = Ok<T> | Err<E>;
+declare const ok: <T>(value: T) => Ok<T>;
+declare const err: <E>(error: E) => Err<E>;
+declare const isOk: <T, E>(r: Result<T, E>) => r is Ok<T>;
+declare const isErr: <T, E>(r: Result<T, E>) => r is Err<E>;
+//#endregion
+//#region src/compat/zod.d.ts
+type ZodCompat = {
+  readonly _output: unknown;
+  parse(data: unknown): unknown;
+};
+type Infer<T extends ZodCompat> = T['_output'];
+//#endregion
+//#region src/id.d.ts
+type IdStrategy = 'objectid' | 'uuid' | 'string' | ZodCompat;
+type InferIdType<T extends IdStrategy> = T extends 'objectid' ? ObjectId : T extends 'uuid' ? string : T extends 'string' ? string : T extends ZodCompat ? Infer<T> : never;
+//#endregion
+//#region src/collection.d.ts
+type Doc<Schema extends ZodCompat, Id extends IdStrategy> = Infer<Schema> & {
+  readonly _id: InferIdType<Id>;
+};
+type CollectionDef<Schema extends ZodCompat, Id extends IdStrategy> = {
+  readonly name: string;
+  readonly schema: Schema;
+  readonly id: Id;
+  readonly indexes: readonly IndexDef[];
+  readonly __doc?: Doc<Schema, Id>;
+};
+declare const defineCollection: <Schema extends ZodCompat, Id extends IdStrategy = "objectid">(config: {
+  name: string;
+  schema: Schema;
+  id?: Id;
+  indexes?: IndexDef[];
+}) => CollectionDef<Schema, Id>;
+//#endregion
+//#region src/indexes.d.ts
+type IndexSpec = IndexDescription['key'];
+type IndexDef = {
+  readonly spec: IndexSpec;
+  readonly options?: CreateIndexesOptions;
+};
+declare const index: (spec: IndexSpec, options?: CreateIndexesOptions) => IndexDef;
+declare const syncIndexes: (collection: CollectionDef<ZodCompat, IdStrategy>, database: Db) => Promise<Result<void>>;
+declare const generateIndexMigration: (collection: CollectionDef<ZodCompat, IdStrategy>) => string;
+//#endregion
+//#region src/repository.d.ts
+type Repository<Schema extends ZodCompat, Id extends IdStrategy> = {
+  findById(id: InferIdType<Id>): Promise<Result<Doc<Schema, Id> | null>>;
+  findOne(filter: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id> | null>>;
+  find(filter?: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id>[]>>;
+  insert(data: Infer<Schema>): Promise<Result<Doc<Schema, Id>>>;
+  insertMany(data: Infer<Schema>[]): Promise<Result<Doc<Schema, Id>[]>>;
+  updateById(id: InferIdType<Id>, patch: Partial<Infer<Schema>>): Promise<Result<Doc<Schema, Id> | null>>;
+  updateOne(filter: Filter<Doc<Schema, Id>>, patch: Partial<Infer<Schema>>): Promise<Result<Doc<Schema, Id> | null>>;
+  updateMany(filter: Filter<Doc<Schema, Id>>, patch: Partial<Infer<Schema>>): Promise<Result<{
+    modifiedCount: number;
+  }>>;
+  deleteById(id: InferIdType<Id>): Promise<Result<Doc<Schema, Id> | null>>;
+  deleteOne(filter: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id> | null>>;
+  deleteMany(filter: Filter<Doc<Schema, Id>>): Promise<Result<{
+    deletedCount: number;
+  }>>;
+  aggregate<Out extends ZodCompat>(pipeline: Document[], outputSchema: Out): Promise<Result<Infer<Out>[]>>;
+};
+declare const createRepository: <Schema extends ZodCompat, Id extends IdStrategy>(collection: CollectionDef<Schema, Id>, database: Db) => Repository<Schema, Id>;
+//#endregion
+export { type CollectionDef, type DbError, type DbErrorKind, type Doc, type Err, type IdStrategy, type IndexDef, type Infer, type InferIdType, type Ok, type Repository, type Result, type ZodCompat, createRepository, defineCollection, err, generateIndexMigration, index, isErr, isOk, ok, syncIndexes, toDbError };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/errors.ts","../src/result.ts","../src/compat/zod.ts","../src/id.ts","../src/collection.ts","../src/indexes.ts","../src/repository.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,88 @@
+import { CreateIndexesOptions, Db, Document, Filter, IndexDescription, ObjectId } from "mongodb";
+
+//#region src/errors.d.ts
+type DbErrorKind = 'validation' | 'not-found' | 'duplicate-key' | 'connection' | 'unknown';
+type DbError = {
+  readonly kind: DbErrorKind;
+  readonly message: string;
+  readonly cause?: unknown;
+};
+declare const toDbError: (error: unknown) => DbError;
+//#endregion
+//#region src/result.d.ts
+type Ok<T> = {
+  readonly ok: true;
+  readonly value: T;
+};
+type Err<E> = {
+  readonly ok: false;
+  readonly error: E;
+};
+type Result<T, E = DbError> = Ok<T> | Err<E>;
+declare const ok: <T>(value: T) => Ok<T>;
+declare const err: <E>(error: E) => Err<E>;
+declare const isOk: <T, E>(r: Result<T, E>) => r is Ok<T>;
+declare const isErr: <T, E>(r: Result<T, E>) => r is Err<E>;
+//#endregion
+//#region src/compat/zod.d.ts
+type ZodCompat = {
+  readonly _output: unknown;
+  parse(data: unknown): unknown;
+};
+type Infer<T extends ZodCompat> = T['_output'];
+//#endregion
+//#region src/id.d.ts
+type IdStrategy = 'objectid' | 'uuid' | 'string' | ZodCompat;
+type InferIdType<T extends IdStrategy> = T extends 'objectid' ? ObjectId : T extends 'uuid' ? string : T extends 'string' ? string : T extends ZodCompat ? Infer<T> : never;
+//#endregion
+//#region src/collection.d.ts
+type Doc<Schema extends ZodCompat, Id extends IdStrategy> = Infer<Schema> & {
+  readonly _id: InferIdType<Id>;
+};
+type CollectionDef<Schema extends ZodCompat, Id extends IdStrategy> = {
+  readonly name: string;
+  readonly schema: Schema;
+  readonly id: Id;
+  readonly indexes: readonly IndexDef[];
+  readonly __doc?: Doc<Schema, Id>;
+};
+declare const defineCollection: <Schema extends ZodCompat, Id extends IdStrategy = "objectid">(config: {
+  name: string;
+  schema: Schema;
+  id?: Id;
+  indexes?: IndexDef[];
+}) => CollectionDef<Schema, Id>;
+//#endregion
+//#region src/indexes.d.ts
+type IndexSpec = IndexDescription['key'];
+type IndexDef = {
+  readonly spec: IndexSpec;
+  readonly options?: CreateIndexesOptions;
+};
+declare const index: (spec: IndexSpec, options?: CreateIndexesOptions) => IndexDef;
+declare const syncIndexes: (collection: CollectionDef<ZodCompat, IdStrategy>, database: Db) => Promise<Result<void>>;
+declare const generateIndexMigration: (collection: CollectionDef<ZodCompat, IdStrategy>) => string;
+//#endregion
+//#region src/repository.d.ts
+type Repository<Schema extends ZodCompat, Id extends IdStrategy> = {
+  findById(id: InferIdType<Id>): Promise<Result<Doc<Schema, Id> | null>>;
+  findOne(filter: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id> | null>>;
+  find(filter?: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id>[]>>;
+  insert(data: Infer<Schema>): Promise<Result<Doc<Schema, Id>>>;
+  insertMany(data: Infer<Schema>[]): Promise<Result<Doc<Schema, Id>[]>>;
+  updateById(id: InferIdType<Id>, patch: Partial<Infer<Schema>>): Promise<Result<Doc<Schema, Id> | null>>;
+  updateOne(filter: Filter<Doc<Schema, Id>>, patch: Partial<Infer<Schema>>): Promise<Result<Doc<Schema, Id> | null>>;
+  updateMany(filter: Filter<Doc<Schema, Id>>, patch: Partial<Infer<Schema>>): Promise<Result<{
+    modifiedCount: number;
+  }>>;
+  deleteById(id: InferIdType<Id>): Promise<Result<Doc<Schema, Id> | null>>;
+  deleteOne(filter: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id> | null>>;
+  deleteMany(filter: Filter<Doc<Schema, Id>>): Promise<Result<{
+    deletedCount: number;
+  }>>;
+  aggregate<Out extends ZodCompat>(pipeline: Document[], outputSchema: Out): Promise<Result<Infer<Out>[]>>;
+};
+declare const createRepository: <Schema extends ZodCompat, Id extends IdStrategy>(collection: CollectionDef<Schema, Id>, database: Db) => Repository<Schema, Id>;
+//#endregion
+export { type CollectionDef, type DbError, type DbErrorKind, type Doc, type Err, type IdStrategy, type IndexDef, type Infer, type InferIdType, type Ok, type Repository, type Result, type ZodCompat, createRepository, defineCollection, err, generateIndexMigration, index, isErr, isOk, ok, syncIndexes, toDbError };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/result.ts","../src/compat/zod.ts","../src/id.ts","../src/collection.ts","../src/indexes.ts","../src/repository.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,215 @@
+import { createRequire } from "node:module";
+import { dedent, getErrorMessage, isEmpty, isError, isNullish, shake, tryit } from "radashi";
+import { ZodError } from "zod";
+import { randomUUID } from "node:crypto";
+import { ObjectId } from "mongodb";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/errors.ts
+const MONGO_DUPLICATE_KEY_CODE = 11e3;
+const toDbError = (error) => {
+	if (error instanceof ZodError) return {
+		kind: "validation",
+		message: getErrorMessage(error),
+		cause: error
+	};
+	if (isError(error) && "code" in error && error.code === MONGO_DUPLICATE_KEY_CODE) return {
+		kind: "duplicate-key",
+		message: getErrorMessage(error),
+		cause: error
+	};
+	if (isError(error)) return {
+		kind: "unknown",
+		message: getErrorMessage(error),
+		cause: error
+	};
+	return {
+		kind: "unknown",
+		message: String(error)
+	};
+};
+//#endregion
+//#region src/result.ts
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const err = (error) => ({
+	ok: false,
+	error
+});
+const isOk = (r) => r.ok;
+const isErr = (r) => !r.ok;
+//#endregion
+//#region src/indexes.ts
+const index = (spec, options) => ({
+	spec,
+	options
+});
+const syncIndexes = async (collection, database) => {
+	if (isEmpty(collection.indexes)) return ok(void 0);
+	const [error] = await tryit(() => database.collection(collection.name).createIndexes(collection.indexes.map((indexEntry) => ({
+		key: indexEntry.spec,
+		...indexEntry.options
+	}))))();
+	return isNullish(error) ? ok(void 0) : err(toDbError(error));
+};
+const emptyMigration = () => dedent`
+  'use strict'
+
+  module.exports = {
+    async up(_db) {},
+    async down(_db) {},
+  }
+`;
+const indexMigration = (name, specs, names) => dedent`
+  'use strict'
+
+  module.exports = {
+    async up(db) {
+      await db.collection('${name}').createIndexes(${specs})
+    },
+    async down(db) {
+      await db.collection('${name}').dropIndexes(${names})
+    },
+  }
+`;
+const generateIndexMigration = (collection) => {
+	if (isEmpty(collection.indexes)) return emptyMigration();
+	const specs = JSON.stringify(collection.indexes.map((indexEntry) => ({
+		key: indexEntry.spec,
+		...indexEntry.options
+	})), null, 2);
+	const names = JSON.stringify(collection.indexes.map((indexEntry) => {
+		if (indexEntry.options?.name) return indexEntry.options.name;
+		return Object.keys(indexEntry.spec).map((key) => `${key}_${String(indexEntry.spec[key])}`).join("_");
+	}));
+	return indexMigration(collection.name, specs, names);
+};
+//#endregion
+//#region src/collection.ts
+const defineCollection = (config) => Object.freeze({
+	name: config.name,
+	schema: config.schema,
+	id: config.id ?? "objectid",
+	indexes: Object.freeze(config.indexes ?? [])
+});
+//#endregion
+//#region src/compat/driver.ts
+const MONGO_MAJOR = (() => {
+	const version = __require("mongodb/package.json").version;
+	const match = /^(\d+)/.exec(version);
+	return match ? Number(match[1]) : 6;
+})();
+const extractResult = (raw, isV5) => {
+	if (isV5) return raw?.value ?? null;
+	return raw ?? null;
+};
+const findOneAndModify = async (collection, filter, op) => {
+	const isV5 = MONGO_MAJOR <= 5;
+	if (op.kind === "delete") return extractResult(await collection.findOneAndDelete(filter, op.options ?? {}), isV5);
+	return extractResult(await collection.findOneAndUpdate(filter, op.update, {
+		returnDocument: "after",
+		...op.options
+	}), isV5);
+};
+//#endregion
+//#region src/id.ts
+const generateId = (strategy) => {
+	if (strategy === "objectid") return new ObjectId();
+	return randomUUID();
+};
+//#endregion
+//#region src/repository.ts
+const runSafe = async (operation) => {
+	const [error, value] = await tryit(operation)();
+	return isNullish(error) ? ok(value) : err(toDbError(error));
+};
+const createRepository = (collection, database) => {
+	const coll = database.collection(collection.name);
+	const schema = collection.schema;
+	const idStrategy = collection.id;
+	const parseSchema = (data) => {
+		try {
+			return ok(schema.parse(data));
+		} catch (error) {
+			return err(toDbError(error));
+		}
+	};
+	const parsePartialSchema = (data) => {
+		try {
+			return ok(("partial" in schema && typeof schema.partial === "function" ? schema.partial() : schema).parse(data));
+		} catch (error) {
+			return err(toDbError(error));
+		}
+	};
+	const buildDoc = (validated) => {
+		if (idStrategy === "objectid" || idStrategy === "uuid") {
+			const id = generateId(idStrategy);
+			return {
+				...validated,
+				_id: id
+			};
+		}
+		return { ...validated };
+	};
+	return {
+		findById: (id) => runSafe(() => coll.findOne({ _id: id }).then((found) => isNullish(found) ? null : found)),
+		findOne: (filter) => runSafe(() => coll.findOne(filter).then((found) => isNullish(found) ? null : found)),
+		find: (filter) => runSafe(() => {
+			return coll.find(filter ?? {}).toArray().then((records) => records);
+		}),
+		insert: async (data) => {
+			const parsed = parseSchema(data);
+			if (!parsed.ok) return parsed;
+			return runSafe(async () => {
+				const record = buildDoc(parsed.value);
+				await coll.insertOne(record);
+				return record;
+			});
+		},
+		insertMany: async (data) => {
+			const parsedItems = [];
+			for (const item of data) {
+				const result = parseSchema(item);
+				if (!result.ok) return result;
+				parsedItems.push(result.value);
+			}
+			return runSafe(async () => {
+				const records = parsedItems.map((item) => buildDoc(item));
+				await coll.insertMany(records);
+				return records;
+			});
+		},
+		updateById: async (id, patch) => {
+			const parsed = parsePartialSchema(patch);
+			if (!parsed.ok) return parsed;
+			return runSafe(() => findOneAndModify(coll, { _id: id }, {
+				kind: "update",
+				update: { $set: shake(parsed.value) }
+			}).then((found) => isNullish(found) ? null : found));
+		},
+		updateOne: async (filter, patch) => {
+			const parsed = parsePartialSchema(patch);
+			if (!parsed.ok) return parsed;
+			return runSafe(() => findOneAndModify(coll, filter, {
+				kind: "update",
+				update: { $set: shake(parsed.value) }
+			}).then((found) => isNullish(found) ? null : found));
+		},
+		updateMany: async (filter, patch) => {
+			const parsed = parsePartialSchema(patch);
+			if (!parsed.ok) return parsed;
+			return runSafe(() => coll.updateMany(filter, { $set: shake(parsed.value) }).then((result) => ({ modifiedCount: result.modifiedCount })));
+		},
+		deleteById: (id) => runSafe(() => findOneAndModify(coll, { _id: id }, { kind: "delete" }).then((found) => isNullish(found) ? null : found)),
+		deleteOne: (filter) => runSafe(() => findOneAndModify(coll, filter, { kind: "delete" }).then((found) => isNullish(found) ? null : found)),
+		deleteMany: (filter) => runSafe(() => coll.deleteMany(filter).then((result) => ({ deletedCount: result.deletedCount }))),
+		aggregate: (pipeline, outputSchema) => runSafe(() => coll.aggregate(pipeline).toArray().then((records) => records.map((r) => outputSchema.parse(r))))
+	};
+};
+//#endregion
+export { createRepository, defineCollection, err, generateIndexMigration, index, isErr, isOk, ok, syncIndexes, toDbError };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["result"],"sources":["../src/errors.ts","../src/result.ts","../src/indexes.ts","../src/collection.ts","../src/compat/driver.ts","../src/id.ts","../src/repository.ts"],"sourcesContent":["import { isError, getErrorMessage } from 'radashi';\nimport { ZodError } from 'zod';\n\nexport type DbErrorKind = 'validation' | 'not-found' | 'duplicate-key' | 'connection' | 'unknown';\n\nexport type DbError = {\n  readonly kind: DbErrorKind;\n  readonly message: string;\n  readonly cause?: unknown;\n};\n\nconst MONGO_DUPLICATE_KEY_CODE = 11_000;\n\nexport const toDbError = (error: unknown): DbError => {\n  if (error instanceof ZodError)\n    return { kind: 'validation', message: getErrorMessage(error), cause: error };\n  if (isError(error) && 'code' in error && error.code === MONGO_DUPLICATE_KEY_CODE)\n    return { kind: 'duplicate-key', message: getErrorMessage(error), cause: error };\n  if (isError(error)) return { kind: 'unknown', message: getErrorMessage(error), cause: error };\n  return { kind: 'unknown', message: String(error) };\n};\n","import type { DbError } from './errors.js';\n\nexport type Ok<T> = { readonly ok: true; readonly value: T };\nexport type Err<E> = { readonly ok: false; readonly error: E };\nexport type Result<T, E = DbError> = Ok<T> | Err<E>;\n\nexport const ok = <T>(value: T): Ok<T> => ({ ok: true, value });\nexport const err = <E>(error: E): Err<E> => ({ ok: false, error });\nexport const isOk = <T, E>(r: Result<T, E>): r is Ok<T> => r.ok;\nexport const isErr = <T, E>(r: Result<T, E>): r is Err<E> => !r.ok;\n","import type { CreateIndexesOptions, Db, IndexDescription } from 'mongodb';\nimport { dedent, isEmpty, isNullish, tryit } from 'radashi';\n\nimport type { CollectionDef } from './collection.js';\nimport type { ZodCompat } from './compat/zod.js';\nimport { toDbError } from './errors.js';\nimport type { IdStrategy } from './id.js';\nimport { err, ok } from './result.js';\nimport type { Result } from './result.js';\n\n// ponytail: IndexDescription.key is { [key: string]: IndexDirection } | Map — not the broader IndexSpecification.\n// We alias it to IndexSpec so callers use the correct type that createIndexes() accepts.\nexport type IndexSpec = IndexDescription['key'];\nexport type IndexDef = { readonly spec: IndexSpec; readonly options?: CreateIndexesOptions };\n\nexport const index = (spec: IndexSpec, options?: CreateIndexesOptions): IndexDef => ({\n  spec,\n  options,\n});\n\nexport const syncIndexes = async (\n  collection: CollectionDef<ZodCompat, IdStrategy>,\n  database: Db,\n): Promise<Result<void>> => {\n  if (isEmpty(collection.indexes)) return ok(void 0);\n  const [error] = await tryit(() =>\n    database\n      .collection(collection.name)\n      .createIndexes(\n        collection.indexes.map((indexEntry) => ({ key: indexEntry.spec, ...indexEntry.options })),\n      ),\n  )();\n  return isNullish(error) ? ok(void 0) : err(toDbError(error));\n};\n\nconst emptyMigration = () => dedent`\n  'use strict'\n\n  module.exports = {\n    async up(_db) {},\n    async down(_db) {},\n  }\n`;\n\nconst indexMigration = (name: string, specs: string, names: string) => dedent`\n  'use strict'\n\n  module.exports = {\n    async up(db) {\n      await db.collection('${name}').createIndexes(${specs})\n    },\n    async down(db) {\n      await db.collection('${name}').dropIndexes(${names})\n    },\n  }\n`;\n\nexport const generateIndexMigration = (\n  collection: CollectionDef<ZodCompat, IdStrategy>,\n): string => {\n  if (isEmpty(collection.indexes)) return emptyMigration();\n\n  const specs = JSON.stringify(\n    collection.indexes.map((indexEntry) => ({ key: indexEntry.spec, ...indexEntry.options })),\n    null,\n    2,\n  );\n  // ponytail: respect options.name if provided — MongoDB stores the index under that name,\n  // so dropIndexes must use the same name or the rollback is a silent no-op\n  const names = JSON.stringify(\n    collection.indexes.map((indexEntry) => {\n      if (indexEntry.options?.name) return indexEntry.options.name;\n      const keys = Object.keys(indexEntry.spec as object);\n      return keys\n        .map((key) => `${key}_${String((indexEntry.spec as Record<string, number | string>)[key])}`)\n        .join('_');\n    }),\n  );\n\n  return indexMigration(collection.name, specs, names);\n};\n","import type { ZodCompat, Infer } from './compat/zod.js';\nimport type { IdStrategy, InferIdType } from './id.js';\nimport type { IndexDef } from './indexes.js';\n\nexport type Doc<Schema extends ZodCompat, Id extends IdStrategy> = Infer<Schema> & {\n  readonly _id: InferIdType<Id>;\n};\n\nexport type CollectionDef<Schema extends ZodCompat, Id extends IdStrategy> = {\n  readonly name: string;\n  readonly schema: Schema;\n  readonly id: Id;\n  readonly indexes: readonly IndexDef[];\n  readonly __doc?: Doc<Schema, Id>;\n};\n\nexport const defineCollection = <\n  Schema extends ZodCompat,\n  Id extends IdStrategy = 'objectid',\n>(config: {\n  name: string;\n  schema: Schema;\n  id?: Id;\n  indexes?: IndexDef[];\n}): CollectionDef<Schema, Id> =>\n  Object.freeze({\n    name: config.name,\n    schema: config.schema,\n    id: (config.id ?? 'objectid') as Id,\n    indexes: Object.freeze(config.indexes ?? []),\n  }) as CollectionDef<Schema, Id>;\n","import type {\n  Collection,\n  Filter,\n  UpdateFilter,\n  FindOneAndUpdateOptions,\n  FindOneAndDeleteOptions,\n  ModifyResult,\n  WithId,\n} from 'mongodb';\n\n// ponytail: version detection at load time — avoids per-call overhead\nconst MONGO_MAJOR = (() => {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports, unicorn/prefer-module\n  const version: string = (require('mongodb/package.json') as { version: string }).version;\n  const match = /^(\\d+)/.exec(version);\n  return match ? Number(match[1]) : 6;\n})();\n\ntype FindOneAndModifyOp<T> =\n  | { kind: 'update'; update: UpdateFilter<T>; options?: FindOneAndUpdateOptions }\n  | { kind: 'delete'; options?: FindOneAndDeleteOptions };\n\n// ponytail: v5 returns ModifyResult<T> ({ value: WithId<T> | null, ... }); v6/7 returns WithId<T> | null directly.\n// ModifyResult<T> and WithId<T> don't overlap, so we go through unknown for the v5 branch only.\nconst extractResult = <T>(raw: unknown, isV5: boolean): WithId<T> | null => {\n  if (isV5) {\n    const result = raw as ModifyResult<T> | null | undefined;\n    return result?.value ?? null;\n  }\n  return (raw as WithId<T> | null) ?? null;\n};\n\nexport const findOneAndModify = async <T extends object>(\n  collection: Collection<T>,\n  filter: Filter<T>,\n  op: FindOneAndModifyOp<T>,\n): Promise<WithId<T> | null> => {\n  const isV5 = MONGO_MAJOR <= 5;\n  if (op.kind === 'delete') {\n    const raw = await collection.findOneAndDelete(filter, op.options ?? {});\n    return extractResult<T>(raw, isV5);\n  }\n  const raw = await collection.findOneAndUpdate(filter, op.update, {\n    returnDocument: 'after',\n    ...op.options,\n  });\n  return extractResult<T>(raw, isV5);\n};\n","import { randomUUID } from 'node:crypto';\n\nimport { ObjectId } from 'mongodb';\n\nimport type { Infer, ZodCompat } from './compat/zod.js';\n\nexport type IdStrategy = 'objectid' | 'uuid' | 'string' | ZodCompat;\n\nexport type InferIdType<T extends IdStrategy> = T extends 'objectid'\n  ? ObjectId\n  : T extends 'uuid'\n    ? string\n    : T extends 'string'\n      ? string\n      : T extends ZodCompat\n        ? Infer<T>\n        : never;\n\n// generateId handles only auto-generated strategies.\n// 'string' and custom ZodCompat require caller-supplied values.\nexport const generateId = (strategy: 'objectid' | 'uuid'): ObjectId | string => {\n  if (strategy === 'objectid') return new ObjectId();\n  return randomUUID();\n};\n","import type { Db, Document, Filter, OptionalUnlessRequiredId, UpdateFilter } from 'mongodb';\nimport { isNullish, shake, tryit } from 'radashi';\n\nimport type { CollectionDef, Doc } from './collection.js';\nimport { findOneAndModify } from './compat/driver.js';\nimport type { Infer, ZodCompat } from './compat/zod.js';\nimport { toDbError } from './errors.js';\nimport { generateId } from './id.js';\nimport type { IdStrategy, InferIdType } from './id.js';\nimport { err, ok } from './result.js';\nimport type { Result } from './result.js';\n\nexport type Repository<Schema extends ZodCompat, Id extends IdStrategy> = {\n  findById(id: InferIdType<Id>): Promise<Result<Doc<Schema, Id> | null>>;\n  findOne(filter: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id> | null>>;\n  find(filter?: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id>[]>>;\n  insert(data: Infer<Schema>): Promise<Result<Doc<Schema, Id>>>;\n  insertMany(data: Infer<Schema>[]): Promise<Result<Doc<Schema, Id>[]>>;\n  updateById(\n    id: InferIdType<Id>,\n    patch: Partial<Infer<Schema>>,\n  ): Promise<Result<Doc<Schema, Id> | null>>;\n  updateOne(\n    filter: Filter<Doc<Schema, Id>>,\n    patch: Partial<Infer<Schema>>,\n  ): Promise<Result<Doc<Schema, Id> | null>>;\n  updateMany(\n    filter: Filter<Doc<Schema, Id>>,\n    patch: Partial<Infer<Schema>>,\n  ): Promise<Result<{ modifiedCount: number }>>;\n  deleteById(id: InferIdType<Id>): Promise<Result<Doc<Schema, Id> | null>>;\n  deleteOne(filter: Filter<Doc<Schema, Id>>): Promise<Result<Doc<Schema, Id> | null>>;\n  deleteMany(filter: Filter<Doc<Schema, Id>>): Promise<Result<{ deletedCount: number }>>;\n  aggregate<Out extends ZodCompat>(\n    pipeline: Document[],\n    outputSchema: Out,\n  ): Promise<Result<Infer<Out>[]>>;\n};\n\n// ponytail: wraps driver promises — tryit returns [error, value] tuple, we map to our Result type\nconst runSafe = async <T>(operation: () => Promise<T>): Promise<Result<T>> => {\n  const [error, value] = await tryit(operation)();\n  return isNullish(error) ? ok(value as T) : err(toDbError(error));\n};\n\nexport const createRepository = <Schema extends ZodCompat, Id extends IdStrategy>(\n  collection: CollectionDef<Schema, Id>,\n  database: Db,\n): Repository<Schema, Id> => {\n  type TDoc = Doc<Schema, Id>;\n  // ponytail: Doc<Schema, Id> has a typed _id: InferIdType<Id> which conflicts with MongoDB's\n  // internal WithId<T> wrapper. We narrow via explicit cast at each read site rather than widening\n  // the collection type. The cast is safe: the driver returns the shape we inserted.\n  const coll = database.collection<TDoc>(collection.name);\n  const schema = collection.schema;\n  const idStrategy = collection.id;\n\n  const parseSchema = (data: unknown): Result<Infer<Schema>> => {\n    try {\n      return ok(schema.parse(data) as Infer<Schema>);\n    } catch (error) {\n      return err(toDbError(error));\n    }\n  };\n\n  const parsePartialSchema = (data: unknown): Result<Partial<Infer<Schema>>> => {\n    try {\n      // ponytail: ZodCompat only guarantees parse() at the type level; partial() exists at runtime\n      // for all Zod schemas. The defensive check avoids a hard dependency on Zod internals.\n      const partial =\n        'partial' in schema && typeof (schema as { partial?: unknown }).partial === 'function'\n          ? (schema as { partial: () => ZodCompat }).partial()\n          : schema;\n      return ok(partial.parse(data) as Partial<Infer<Schema>>);\n    } catch (error) {\n      return err(toDbError(error));\n    }\n  };\n\n  const buildDoc = (validated: Infer<Schema>): TDoc => {\n    if (idStrategy === 'objectid' || idStrategy === 'uuid') {\n      const id = generateId(idStrategy);\n      // ponytail: Infer<Schema> is structurally unknown at this level; spreading requires a cast to object.\n      // The result is Doc<Schema, Id> by construction (_id + validated fields).\n      return { ...(validated as object), _id: id } as TDoc;\n    }\n    // ponytail: for 'string'/'custom' strategies the caller embeds _id in data —\n    // validated already satisfies TDoc structurally; single cast via object is sufficient.\n    return { ...(validated as object) } as TDoc;\n  };\n\n  return {\n    findById: (id) =>\n      runSafe(() =>\n        coll\n          .findOne({ _id: id } as Filter<TDoc>)\n          .then((found) => (isNullish(found) ? null : found) as TDoc | null),\n      ),\n\n    findOne: (filter) =>\n      runSafe(() =>\n        coll.findOne(filter).then((found) => (isNullish(found) ? null : found) as TDoc | null),\n      ),\n\n    find: (filter) =>\n      runSafe(() => {\n        // ponytail: Collection.find() is not Array.find() — unicorn cannot distinguish them.\n        // eslint-disable-next-line unicorn/no-array-callback-reference\n        const cursor = coll.find(filter ?? {});\n        return cursor.toArray().then((records) => records as TDoc[]);\n      }),\n\n    insert: async (data) => {\n      const parsed = parseSchema(data);\n      if (!parsed.ok) return parsed as Result<TDoc>;\n      return runSafe(async () => {\n        const record = buildDoc(parsed.value);\n        await coll.insertOne(record as OptionalUnlessRequiredId<TDoc>);\n        return record;\n      });\n    },\n\n    insertMany: async (data) => {\n      const parsedItems: Infer<Schema>[] = [];\n      for (const item of data) {\n        const result = parseSchema(item);\n        if (!result.ok) return result as Result<TDoc[]>;\n        parsedItems.push(result.value);\n      }\n      return runSafe(async () => {\n        const records = parsedItems.map((item) => buildDoc(item));\n        await coll.insertMany(records as OptionalUnlessRequiredId<TDoc>[]);\n        return records;\n      });\n    },\n\n    updateById: async (id, patch) => {\n      const parsed = parsePartialSchema(patch);\n      if (!parsed.ok) return parsed as Result<TDoc | null>;\n      return runSafe(() =>\n        findOneAndModify(coll, { _id: id } as Filter<TDoc>, {\n          kind: 'update',\n          update: { $set: shake(parsed.value) } as UpdateFilter<TDoc>,\n        }).then((found) => (isNullish(found) ? null : found) as TDoc | null),\n      );\n    },\n\n    updateOne: async (filter, patch) => {\n      const parsed = parsePartialSchema(patch);\n      if (!parsed.ok) return parsed as Result<TDoc | null>;\n      return runSafe(() =>\n        findOneAndModify(coll, filter, {\n          kind: 'update',\n          update: { $set: shake(parsed.value) } as UpdateFilter<TDoc>,\n        }).then((found) => (isNullish(found) ? null : found) as TDoc | null),\n      );\n    },\n\n    updateMany: async (filter, patch) => {\n      const parsed = parsePartialSchema(patch);\n      if (!parsed.ok) return parsed as Result<{ modifiedCount: number }>;\n      return runSafe(() =>\n        coll\n          .updateMany(filter, { $set: shake(parsed.value) } as UpdateFilter<TDoc>)\n          .then((result) => ({ modifiedCount: result.modifiedCount })),\n      );\n    },\n\n    deleteById: (id) =>\n      runSafe(() =>\n        findOneAndModify(coll, { _id: id } as Filter<TDoc>, { kind: 'delete' }).then(\n          (found) => (isNullish(found) ? null : found) as TDoc | null,\n        ),\n      ),\n\n    deleteOne: (filter) =>\n      runSafe(() =>\n        findOneAndModify(coll, filter, { kind: 'delete' }).then(\n          (found) => (isNullish(found) ? null : found) as TDoc | null,\n        ),\n      ),\n\n    deleteMany: (filter) =>\n      runSafe(() =>\n        coll.deleteMany(filter).then((result) => ({ deletedCount: result.deletedCount })),\n      ),\n\n    aggregate: <Out extends ZodCompat>(pipeline: Document[], outputSchema: Out) =>\n      runSafe(() =>\n        coll\n          .aggregate(pipeline)\n          .toArray()\n          .then((records) => records.map((r) => outputSchema.parse(r) as Infer<Out>)),\n      ),\n  };\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@wenu/mongo",
+  "version": "0.2.4",
+  "description": "Declarative, immutable, type-safe MongoDB repository layer with Zod validation. Zero throws, dual ESM/CJS, pluggable ID strategies.",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist/*.cjs",
+    "dist/*.mjs",
+    "dist/*.d.cts",
+    "dist/*.d.mts",
+    "dist/*.map",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "type": "commonjs",
+  "sideEffects": false,
+  "keywords": [
+    "mongodb",
+    "zod",
+    "validation",
+    "repository",
+    "typescript",
+    "schema",
+    "nosql",
+    "database",
+    "immutable",
+    "type-safe"
+  ],
+  "author": "Johnny J. Huirilef",
+  "license": "MIT",
+  "homepage": "https://github.com/johnnyhuirilef/toolkit/tree/main/packages/zod-mongo#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnnyhuirilef/toolkit.git",
+    "directory": "packages/zod-mongo"
+  },
+  "bugs": {
+    "url": "https://github.com/johnnyhuirilef/toolkit/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "mongodb": ">=6.0.0",
+    "zod": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": false
+    }
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/johnnyhuirilef"
+  },
+  "devDependencies": {
+    "@nx/vite": "^22.0.0",
+    "@testcontainers/mongodb": "^11.10.0",
+    "jsonc-eslint-parser": "^2.0.0",
+    "tsdown": "^0.22.3",
+    "tsx": "^4.0.0",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "radashi": "^12.1.0"
+  }
+}