@mauroandre/zodmongo 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mauro André
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,339 @@
+# ZodMongo
+
+Lightweight MongoDB ODM powered by [Zod](https://zod.dev) schemas. TypeScript-first, built on the native MongoDB driver — no Mongoose.
+
+## Why ZodMongo?
+
+- **No Mongoose** — uses the native MongoDB driver, zero overhead
+- **Zod-native** — define schemas with Zod, not a proprietary format
+- **TypeScript-first** — types inferred directly from your Zod schemas
+- **Tiny** — ~300 lines of code, only `mongodb` and `zod` as dependencies
+- **Transparent id/ObjectId** — work with `id` (string) in your app, `_id` (ObjectId) in MongoDB
+- **Automatic timestamps** — `createdAt` and `updatedAt` managed by the ODM
+- **Built-in pagination** — via aggregation pipeline with `$facet`
+- **Full aggregation pipeline** — `findMany` accepts a complete pipeline, not just match filters
+- **Relations & Snapshots** — declare references to other collections with automatic `$lookup` generation
+
+## Install
+
+```bash
+npm install zodmongo
+```
+
+## Quick Start
+
+```typescript
+import { connect, close, save, findMany, deleteMany } from "zodmongo";
+import { dbSchema } from "zodmongo";
+import { z } from "zod/v4";
+
+// Connect
+await connect("mongodb://localhost:27017", "mydb");
+
+// Define a schema
+const userSchema = dbSchema({
+    name: z.string(),
+    email: z.string().email(),
+});
+type User = z.infer<typeof userSchema>;
+
+// Insert
+const user = userSchema.parse({ name: "Mauro", email: "mauro@example.com" });
+await save("users", user);
+console.log(user.id); // ObjectId string, auto-assigned
+
+// Update
+user.name = "Mauro André";
+await save("users", user);
+
+// Find
+const users = await findMany<User>("users", { name: "Mauro André" });
+const all = await findMany<User>("users");
+
+// Delete
+await deleteMany("users", { email: "mauro@example.com" });
+
+// Close
+await close();
+```
+
+## Schemas
+
+### `dbSchema(shape)`
+
+Creates a schema that extends the base model with `id`, `createdAt`, and `updatedAt`. This is the primary way to define your models.
+
+```typescript
+import { dbSchema } from "zodmongo";
+import { z } from "zod/v4";
+
+const postSchema = dbSchema({
+    title: z.string(),
+    body: z.string(),
+    published: z.boolean().default(false),
+});
+type Post = z.infer<typeof postSchema>;
+// { id: string | null, createdAt: Date | null, updatedAt: Date | null, title: string, body: string, published: boolean }
+```
+
+### `embeddedSchema(shape)`
+
+Creates a schema **without** the base model fields (`id`, `createdAt`, `updatedAt`). Use for nested objects that don't need their own identity.
+
+```typescript
+import { embeddedSchema } from "zodmongo";
+import { z } from "zod/v4";
+
+const addressSchema = embeddedSchema({
+    street: z.string(),
+    city: z.string(),
+    zip: z.string(),
+});
+
+const userSchema = dbSchema({
+    name: z.string(),
+    address: addressSchema,
+});
+```
+
+### `dbModelSchema` and `idSchema`
+
+Low-level schemas if you need to extend manually:
+
+```typescript
+import { dbModelSchema, idSchema } from "zodmongo/schema";
+
+const customSchema = dbModelSchema.extend({
+    name: z.string(),
+});
+
+// idSchema validates a string as a valid ObjectId
+idSchema.parse("507f1f77bcf86cd799439011"); // ok
+idSchema.parse("invalid"); // throws
+```
+
+## API
+
+### `connect(uri, dbName)`
+
+Connects to MongoDB. Returns the `Db` instance.
+
+```typescript
+const db = await connect("mongodb://localhost:27017", "mydb");
+```
+
+### `close()`
+
+Waits for pending promises and closes the connection.
+
+```typescript
+await close();
+```
+
+### `getDb()`
+
+Returns the current `Db` instance. Throws if not connected.
+
+```typescript
+const db = getDb();
+const collection = db.collection("users");
+```
+
+### `save(collection, doc, filter?, options?)`
+
+Smart upsert — inserts if no `id`, updates if `id` exists. Automatically manages `createdAt` and `updatedAt`.
+
+```typescript
+// Insert (no id)
+const user = userSchema.parse({ name: "Mauro", email: "m@b.com" });
+await save("users", user);
+// user.id is now set to the generated ObjectId string
+
+// Update (has id)
+user.name = "Updated";
+await save("users", user);
+
+// Upsert with custom filter
+await save("users", user, { email: "m@b.com" });
+
+// Disable upsert (update only, no insert)
+await save("users", user, { email: "m@b.com" }, { upsert: false });
+```
+
+### `findMany<T>(collection, matchOrPipeline?, options?)`
+
+Finds documents using a simple match object or a full aggregation pipeline. Automatically converts `_id` to `id` and ObjectIds to strings in the results.
+
+```typescript
+// All documents
+const all = await findMany<User>("users");
+
+// Simple match
+const admins = await findMany<User>("users", { role: "admin" });
+
+// Find by id
+const found = await findMany<User>("users", { id: "507f1f77bcf86cd799439011" });
+
+// Full aggregation pipeline
+const topAdmins = await findMany<User>("users", [
+    { $match: { role: "admin" } },
+    { $sort: { createdAt: -1 } },
+    { $limit: 10 },
+]);
+```
+
+#### Pagination
+
+Pass `{ paginate: true }` to get paginated results via `$facet`:
+
+```typescript
+const page = await findMany<User>("users", {}, {
+    paginate: true,
+    currentPage: 1,
+    docsPerPage: 20,
+});
+
+page.docs;          // User[]
+page.currentPage;   // 1
+page.pageQuantity;  // total pages
+page.docsQuantity;  // total documents
+```
+
+### `deleteMany(collection, filter)`
+
+Deletes documents matching the filter. Automatically converts `id` to `_id`.
+
+```typescript
+await deleteMany("users", { email: "m@b.com" });
+await deleteMany("users", { id: "507f1f77bcf86cd799439011" });
+```
+
+## Relations
+
+Declare references between collections. The ODM generates `$lookup` pipelines automatically.
+
+### `relation(schema, config)`
+
+Marks a field as a reference to another collection.
+
+```typescript
+const companySchema = dbSchema({ name: z.string() });
+
+const userSchema = dbSchema({
+    name: z.string(),
+    company: relation(companySchema, { collection: "companies" }),
+});
+
+// When fetching, use getPipeline() to auto-generate $lookup stages
+const pipeline = getPipeline(userSchema);
+const users = await findMany<User>("users", pipeline);
+// users[0].company is now the full company document, not just an ObjectId
+```
+
+When saving, use `toSave()` to convert relations back to ObjectIds:
+
+```typescript
+const dataToSave = toSave(userSchema, userData);
+// dataToSave.company is now an ObjectId
+await save("users", dataToSave);
+```
+
+#### Array relations
+
+```typescript
+const tagSchema = dbSchema({ label: z.string() });
+
+const postSchema = dbSchema({
+    title: z.string(),
+    tags: z.array(relation(tagSchema, { collection: "tags" })),
+});
+```
+
+#### Custom foreign field
+
+```typescript
+const categorySchema = dbSchema({ slug: z.string(), name: z.string() });
+
+const postSchema = dbSchema({
+    title: z.string(),
+    category: relation(categorySchema, { collection: "categories", foreignField: "slug" }),
+});
+```
+
+### `snapshot(schema)`
+
+Marks a field as a persisted copy. The ODM will **not** generate `$lookup` for it and will **not** convert it to ObjectId when saving. Useful for denormalized data you want to store as-is.
+
+```typescript
+const userSchema = dbSchema({
+    name: z.string(),
+    company: snapshot(companySchema), // stored as a full copy, no lookup
+});
+```
+
+### `getPipeline(schema)`
+
+Generates the aggregation pipeline (with `$lookup`, `$set`, `$project`) from a schema.
+
+```typescript
+const pipeline = getPipeline(userSchema);
+// Use it with findMany
+const users = await findMany<User>("users", [...pipeline, { $match: { active: true } }]);
+```
+
+### `toSave(schema, data)`
+
+Parses data through the schema and converts relations to ObjectIds for saving.
+
+```typescript
+const prepared = toSave(userSchema, rawData);
+await save("users", prepared);
+```
+
+## id ↔ _id ↔ ObjectId
+
+ZodMongo automatically handles conversions between your app's `id` (string) and MongoDB's `_id` (ObjectId):
+
+| Direction | What happens |
+|---|---|
+| **Reading** (MongoDB → App) | `_id` (ObjectId) becomes `id` (string), recursively |
+| **Saving** (App → MongoDB) | `id` (string) becomes `_id` (ObjectId), valid ObjectId strings are converted |
+| **Querying** | `{ id: "..." }` becomes `{ _id: ObjectId("...") }`, supports dot-notation (`company.id` → `company._id`) |
+
+## Automatic Timestamps
+
+- `createdAt` — set automatically on insert (`$setOnInsert`), never modified on update
+- `updatedAt` — set on every save (`$set`)
+
+## Promise Tracking
+
+Use `trackPromise()` to register fire-and-forget operations. `close()` waits for all tracked promises before disconnecting.
+
+```typescript
+import { trackPromise, close } from "zodmongo";
+
+trackPromise(save("logs", logEntry));
+trackPromise(save("logs", anotherEntry));
+
+await close(); // waits for both saves to complete
+```
+
+## Development
+
+```bash
+# Start MongoDB
+docker compose up -d
+
+# Run tests
+npm test
+
+# Type check
+npm run typecheck
+
+# Build
+npm run build
+```
+
+## License
+
+MIT

package/dist/engine.d.ts

@@ -0,0 +1,28 @@
+import { Db, Document, UpdateResult } from 'mongodb';
+import { DbModel } from './schema.js';
+declare const trackPromise: <T>(promise: Promise<T>) => Promise<T>;
+declare const connect: (uri: string, dbName: string) => Promise<Db>;
+declare const getDb: () => Db;
+declare const close: () => Promise<void>;
+interface PaginateResponse<T> {
+    currentPage: number;
+    pageQuantity: number;
+    docsQuantity: number;
+    docs: T[];
+}
+interface FindOptions {
+    paginate?: boolean;
+    currentPage?: number;
+    docsPerPage?: number;
+}
+interface SaveOptions {
+    upsert?: boolean;
+}
+declare const save: <T extends DbModel>(collectionName: string, doc: T, find?: any, options?: SaveOptions) => Promise<UpdateResult>;
+declare function findMany<T>(collectionName: string, matchOrPipeline: Document[] | any, options: FindOptions & {
+    paginate: true;
+}): Promise<PaginateResponse<T>>;
+declare function findMany<T>(collectionName: string, matchOrPipeline?: Document[] | any, options?: FindOptions): Promise<T[]>;
+declare const deleteMany: (collectionName: string, filter: any) => Promise<import('mongodb').DeleteResult>;
+export { connect, getDb, close, save, findMany, deleteMany, trackPromise };
+export type { PaginateResponse, FindOptions, SaveOptions };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { connect, getDb, close, save, findMany, deleteMany, trackPromise, } from './engine.js';
+export { dbModelSchema, idSchema } from './schema.js';
+export { dbSchema, embeddedSchema, relation, snapshot, getPipeline, toSave, } from './odm.js';
+export type { PaginateResponse, FindOptions, SaveOptions } from './engine.js';
+export type { DbModel, Id } from './schema.js';
+export type { RelationConfig, SchemaWithPipeline } from './odm.js';

package/dist/index.js

@@ -0,0 +1,190 @@
+import { dbModelSchema as e, idSchema as t } from "./schema.js";
+import { MongoClient as n, ObjectId as r } from "mongodb";
+import { z as i } from "zod/v4";
+//#region src/transforms.ts
+var a = (e) => {
+	if (!e || typeof e != "object") return e;
+	if (e instanceof r) return e.toString();
+	if (Array.isArray(e)) return e.map(a);
+	e._id && (e._id instanceof r ? e.id = e._id.toString() : e.id = e._id, delete e._id);
+	for (let t in e) e[t] && (e[t] instanceof r ? e[t] = e[t].toString() : typeof e[t] == "object" && (e[t] = a(e[t])));
+	return e;
+}, o = (e) => {
+	if (typeof e == "string" && r.isValid(e)) return new r(e);
+	if (!e || typeof e != "object" || e instanceof r) return e;
+	if (Array.isArray(e)) return e.map(o);
+	e.id && typeof e.id == "string" && (e._id = new r(e.id), delete e.id);
+	for (let t in e) if (e[t]) {
+		if (e[t] instanceof r) continue;
+		(typeof e[t] == "string" || typeof e[t] == "object") && (e[t] = o(e[t]));
+	}
+	return e;
+}, s = (e) => {
+	if (!e || typeof e != "object") return typeof e == "string" && r.isValid(e) ? new r(e) : e;
+	if (e instanceof r || e instanceof Date) return e;
+	if (Array.isArray(e)) return e.map(s);
+	let t = {};
+	for (let n in e) {
+		let r = n === "id" ? "_id" : n.endsWith(".id") ? n.slice(0, -3) + "._id" : n;
+		t[r] = s(e[n]);
+	}
+	return t;
+}, c, l, u = /* @__PURE__ */ new Set(), d = (e) => (u.add(e), e.finally(() => u.delete(e)), e), f = async () => {
+	u.size > 0 && await Promise.all(u);
+}, p = async (e, t) => c || (l = new n(e), await l.connect(), c = l.db(t), c), m = () => {
+	if (!c) throw Error("Database not initialized. Call connect() first.");
+	return c;
+}, h = async () => {
+	l &&= (await f(), await l.close(), c = void 0, void 0);
+}, g = async (e, t, n, i = { upsert: !0 }) => {
+	let a = m(), s = /* @__PURE__ */ new Date(), { id: c, createdAt: l, updatedAt: u, ...d } = t, f = o({ ...d }), p = n || (c ? { _id: new r(c) } : { _id: new r() });
+	p.id && (p = {
+		...p,
+		_id: new r(p.id)
+	}, delete p.id), p._id && typeof p._id == "string" && (p = {
+		...p,
+		_id: new r(p._id)
+	});
+	let h = await a.collection(e).updateMany(p, {
+		$set: {
+			...f,
+			updatedAt: s
+		},
+		$setOnInsert: { createdAt: s }
+	}, { upsert: i.upsert ?? !0 });
+	return h.upsertedId && (t.id = h.upsertedId.toString()), h;
+};
+async function _(e, t, n = {}) {
+	let r = m().collection(e), i;
+	i = Array.isArray(t) ? t : t ? [{ $match: t }] : [];
+	for (let e of i) e.$match &&= s(e.$match);
+	if (n.paginate) {
+		let e = n.currentPage && n.currentPage > 0 ? n.currentPage : 1, t = n.docsPerPage && n.docsPerPage > 0 ? n.docsPerPage : 100, o = (e - 1) * t, s = [...i, { $facet: {
+			docs: [{ $skip: o }, { $limit: t }],
+			docsQuantity: [{ $count: "count" }]
+		} }], c = await r.aggregate(s).toArray(), l = (c[0]?.docs || []).map(a), u = c[0]?.docsQuantity[0]?.count || 0;
+		return {
+			docs: l,
+			docsQuantity: u,
+			pageQuantity: Math.ceil(u / t),
+			currentPage: e
+		};
+	}
+	return (await r.aggregate(i).toArray()).map(a);
+}
+var v = async (e, t) => {
+	let n = s(t);
+	return await m().collection(e).deleteMany(n);
+}, y = (e) => e._zod?.def ?? e._def ?? {}, b = (e) => {
+	let t = y(e);
+	return t.type ?? t.typeName ?? "";
+}, x = (e) => {
+	let t = e, n = b(t);
+	for (; n === "optional" || n === "nullable" || n === "default" || n === "pipe";) {
+		let e = y(t);
+		t = n === "pipe" ? e.in ?? t : e.innerType ?? t, n = b(t);
+	}
+	return t;
+}, S = (e) => e._relation, C = (e) => e._snapshot === !0, w = (e) => typeof e.pipeline == "function", T = (e) => b(e) === "object", E = (e) => b(e) === "array", D = (e) => y(e).element, O = (e) => y(e).shape, k = (e) => {
+	let t = [], n = {}, r = (e, i) => {
+		let a = x(e);
+		if (E(a)) {
+			let e = D(a);
+			if (!e) return;
+			let o = x(e);
+			if (C(e) || C(o)) {
+				n[i] = 1;
+				return;
+			}
+			let s = S(e) ?? S(o);
+			if (s) {
+				let r = w(e) ? e.pipeline() : w(o) ? o.pipeline() : [];
+				t.push({ $lookup: {
+					from: s.collection,
+					localField: i,
+					foreignField: s.foreignField ?? "_id",
+					as: i,
+					...r.length > 0 && { pipeline: r }
+				} }), n[i] = 1;
+			} else T(o) ? r(e, i) : n[i] = 1;
+			return;
+		}
+		if (T(a)) {
+			let e = O(a);
+			if (!e) return;
+			for (let [a, o] of Object.entries(e)) {
+				let e = a === "id" ? "_id" : a, s = i ? `${i}.${e}` : e, c = x(o);
+				if (C(o) || C(c)) {
+					n[s] = 1;
+					continue;
+				}
+				let l = S(o) ?? S(c);
+				if (l) {
+					let e = w(o) ? o.pipeline() : w(c) ? c.pipeline() : [];
+					t.push({ $lookup: {
+						from: l.collection,
+						localField: s,
+						foreignField: l.foreignField ?? "_id",
+						as: s,
+						...e.length > 0 && { pipeline: e }
+					} }), t.push({ $set: { [s]: { $arrayElemAt: [`$${s}`, 0] } } }), n[s] = 1;
+				} else T(c) || E(c) ? r(o, s) : n[s] = 1;
+			}
+		}
+	};
+	return r(e, ""), Object.keys(n).length > 0 && t.push({ $project: n }), t;
+}, A = (e, t) => {
+	if (t == null) return t;
+	let n = x(e);
+	if (C(e) || C(n)) return t;
+	if (S(e) ?? S(n)) return new r(t.id);
+	if (E(n) && Array.isArray(t)) {
+		let e = D(n);
+		return e ? t.map((t) => A(e, t)) : t;
+	}
+	if (T(n) && typeof t == "object") {
+		let e = O(n);
+		if (!e) return t;
+		let r = { ...t };
+		for (let [n, i] of Object.entries(e)) n in t && (r[n] = A(i, t[n]));
+		return r;
+	}
+	return t;
+}, j = (e) => {
+	if (w(e)) return e.pipeline();
+	let t = x(e);
+	return w(t) ? t.pipeline() : k(t);
+}, M = (e) => typeof e.toSave == "function", N = (e, t) => {
+	if (M(e)) return e.toSave(t);
+	let n = e.parse(t);
+	return A(x(e), n);
+}, P = (e, t) => Object.assign(e, { _relation: t }), F = (e) => {
+	let t = Object.create(e);
+	return t._snapshot = !0, t._relation = void 0, t;
+}, I = (t) => {
+	let n = e.extend(t), r = () => k(n), i = (e) => A(n, n.parse(e)), a = n.transform.bind(n);
+	return n.transform = (e) => {
+		let t = a(e);
+		return Object.assign(t, {
+			pipeline: r,
+			toSave: (e) => A(n, t.parse(e))
+		});
+	}, Object.assign(n, {
+		pipeline: r,
+		toSave: i
+	});
+}, L = (e) => {
+	let t = i.object(e), n = () => k(t), r = (e) => A(t, t.parse(e)), a = t.transform.bind(t);
+	return t.transform = (e) => {
+		let r = a(e);
+		return Object.assign(r, {
+			pipeline: n,
+			toSave: (e) => A(t, r.parse(e))
+		});
+	}, Object.assign(t, {
+		pipeline: n,
+		toSave: r
+	});
+};
+//#endregion
+export { h as close, p as connect, e as dbModelSchema, I as dbSchema, v as deleteMany, L as embeddedSchema, _ as findMany, m as getDb, j as getPipeline, t as idSchema, P as relation, g as save, F as snapshot, N as toSave, d as trackPromise };

package/dist/odm.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod/v4';
+import { Document } from 'mongodb';
+import { dbModelSchema } from './schema.js';
+interface RelationConfig {
+    collection: string;
+    foreignField?: string;
+}
+interface RelationMeta {
+    _relation?: RelationConfig;
+}
+type SchemaWithPipeline<T extends z.ZodTypeAny> = T & {
+    pipeline: () => Document[];
+    toSave: (data: z.input<T>) => z.output<T>;
+};
+export declare const getPipeline: (schema: z.ZodTypeAny) => Document[];
+export declare const toSave: <T extends z.ZodTypeAny>(schema: T, data: z.input<T>) => z.output<T>;
+export declare const relation: <T extends z.ZodTypeAny>(schema: T, config: RelationConfig) => T & RelationMeta;
+export declare const snapshot: <T extends z.ZodTypeAny>(schema: T) => T;
+export declare const dbSchema: <T extends z.ZodRawShape>(shape: T) => SchemaWithPipeline<ReturnType<typeof dbModelSchema.extend<T>>>;
+export declare const embeddedSchema: <T extends z.ZodRawShape>(shape: T) => SchemaWithPipeline<z.ZodObject<T>>;
+export type { RelationConfig, SchemaWithPipeline };

package/dist/schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod/v4';
+export declare const idSchema: z.ZodString;
+export declare const dbModelSchema: z.ZodObject<{
+    id: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    createdAt: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>>;
+    updatedAt: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>>;
+}, z.core.$strip>;
+export type DbModel = z.infer<typeof dbModelSchema>;
+export type Id = z.infer<typeof idSchema>;

package/dist/schema.js

@@ -0,0 +1,10 @@
+import { ObjectId as e } from "mongodb";
+import { z as t } from "zod/v4";
+//#region src/schema.ts
+var n = t.string().refine((t) => e.isValid(t), { message: "Invalid ObjectId format" }), r = t.object({
+	id: n.nullable().optional().default(null),
+	createdAt: t.coerce.date().nullable().optional().default(null),
+	updatedAt: t.coerce.date().nullable().optional().default(null)
+});
+//#endregion
+export { r as dbModelSchema, n as idSchema };

package/dist/transforms.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Recursively converts _id (ObjectId) to id (string).
+ * Used to transform documents coming from MongoDB into the application format.
+ */
+export declare const transformDoc: <T>(doc: any) => T;
+/**
+ * Recursively converts id (string) to _id (ObjectId).
+ * Automatically converts valid ObjectId strings.
+ * Used before saving documents to MongoDB.
+ */
+export declare const transformDocForSave: (doc: any) => any;
+/**
+ * Converts valid strings to ObjectIds and id to _id in search queries.
+ * Supports dot-notation (e.g. "company.id" → "company._id").
+ */
+export declare const transformMatchQuery: (query: any) => any;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@mauroandre/zodmongo",
+  "version": "0.0.1",
+  "description": "Lightweight MongoDB ODM with Zod validation. TypeScript-first, no Mongoose.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Mauro André",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mauro-andre/zodmongo.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./schema": {
+      "import": "./dist/schema.js",
+      "types": "./dist/schema.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --reporter verbose",
+    "test:watch": "vitest --reporter verbose",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mongodb",
+    "zod",
+    "odm",
+    "typescript",
+    "validation",
+    "schema"
+  ],
+  "dependencies": {
+    "mongodb": "^7.1.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.2",
+    "vite": "^8.0.8",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.4"
+  }
+}