mondel 0.1.0

package/dist/index.js

@@ -0,0 +1,947 @@
+'use strict';
+
+var mongodb = require('mongodb');
+var zod = require('zod');
+
+// src/schema/field-builder.ts
+var FieldBuilder = class {
+  definition;
+  constructor(type) {
+    this.definition = {
+      type,
+      required: false,
+      unique: false
+    };
+  }
+  required() {
+    this.definition.required = true;
+    return this;
+  }
+  unique() {
+    this.definition.unique = true;
+    return this;
+  }
+  default(value) {
+    this.definition.default = value;
+    return this;
+  }
+  index(options) {
+    this.definition.index = options ?? { type: 1 };
+    return this;
+  }
+  build() {
+    return { ...this.definition };
+  }
+};
+var StringFieldBuilder = class extends FieldBuilder {
+  constructor() {
+    super("string");
+  }
+  min(length) {
+    this.definition.minLength = length;
+    return this;
+  }
+  max(length) {
+    this.definition.maxLength = length;
+    return this;
+  }
+  pattern(regex) {
+    this.definition.pattern = regex;
+    return this;
+  }
+  email() {
+    this.definition.email = true;
+    return this;
+  }
+  url() {
+    this.definition.url = true;
+    return this;
+  }
+  text() {
+    return this.index({ type: "text" });
+  }
+  enum(values) {
+    const builder = new EnumFieldBuilder(values);
+    const def = this.build();
+    if (def.required) builder.required();
+    if (def.unique) builder.unique();
+    if (def.index) builder.index(def.index);
+    return builder;
+  }
+};
+var EnumFieldBuilder = class extends FieldBuilder {
+  constructor(values) {
+    super("string");
+    this.definition.enum = values;
+  }
+};
+var NumberFieldBuilder = class extends FieldBuilder {
+  constructor() {
+    super("number");
+  }
+  min(value) {
+    this.definition.min = value;
+    return this;
+  }
+  max(value) {
+    this.definition.max = value;
+    return this;
+  }
+};
+var BooleanFieldBuilder = class extends FieldBuilder {
+  constructor() {
+    super("boolean");
+  }
+};
+var DateFieldBuilder = class extends FieldBuilder {
+  constructor() {
+    super("date");
+  }
+};
+var ObjectIdFieldBuilder = class extends FieldBuilder {
+  constructor() {
+    super("objectId");
+  }
+};
+var ArrayFieldBuilder = class extends FieldBuilder {
+  constructor(items) {
+    super("array");
+    this.definition.items = items;
+  }
+};
+var ObjectFieldBuilder = class extends FieldBuilder {
+  constructor(properties) {
+    super("object");
+    this.definition.properties = properties;
+  }
+};
+var JsonFieldBuilder = class extends FieldBuilder {
+  constructor() {
+    super("json");
+  }
+};
+var LiteralFieldBuilder = class extends FieldBuilder {
+  constructor(value) {
+    super("literal");
+    this.definition.literal = value;
+  }
+};
+
+// src/schema/schema-builder.ts
+function resolveFields(fields) {
+  const resolved = {};
+  for (const [key, builder] of Object.entries(fields)) {
+    resolved[key] = builder.build();
+  }
+  return resolved;
+}
+var s = {
+  string() {
+    return new StringFieldBuilder();
+  },
+  number() {
+    return new NumberFieldBuilder();
+  },
+  boolean() {
+    return new BooleanFieldBuilder();
+  },
+  date() {
+    return new DateFieldBuilder();
+  },
+  objectId() {
+    return new ObjectIdFieldBuilder();
+  },
+  array(items) {
+    return new ArrayFieldBuilder(items.build());
+  },
+  object(properties) {
+    const resolvedProps = {};
+    for (const [key, builder] of Object.entries(properties)) {
+      resolvedProps[key] = builder.build();
+    }
+    return new ObjectFieldBuilder(resolvedProps);
+  },
+  json() {
+    return new JsonFieldBuilder();
+  },
+  literal(value) {
+    return new LiteralFieldBuilder(value);
+  },
+  enum(values) {
+    return new EnumFieldBuilder(values);
+  }
+};
+
+// src/schema/define-schema.ts
+function schema(name, definition) {
+  const resolvedFields = resolveFields(definition.fields);
+  const timestamps = definition.timestamps === true ? { createdAt: "createdAt", updatedAt: "updatedAt" } : definition.timestamps === false || definition.timestamps === void 0 ? false : definition.timestamps;
+  return {
+    name,
+    collection: definition.collection ?? name,
+    timestamps,
+    validation: definition.validation ?? { enabled: false, mode: "off" },
+    connection: definition.connection,
+    fields: resolvedFields,
+    indexes: definition.indexes ?? []
+  };
+}
+var defineSchema = schema;
+function getFieldIndexes(schema2) {
+  const indexes = [];
+  for (const [fieldName, fieldDef] of Object.entries(schema2.fields)) {
+    if (fieldDef.index) {
+      indexes.push({ field: fieldName, options: fieldDef.index });
+    }
+    if (fieldDef.unique && !fieldDef.index) {
+      indexes.push({ field: fieldName, options: { unique: true } });
+    }
+  }
+  return indexes;
+}
+function isObjectId(value) {
+  if (typeof value === "object" && value !== null) {
+    return "toHexString" in value && typeof value.toHexString === "function";
+  }
+  if (typeof value === "string") {
+    return /^[a-fA-F0-9]{24}$/.test(value);
+  }
+  return false;
+}
+function buildStringSchema(field) {
+  if (field.enum) {
+    return zod.z.enum(field.enum);
+  }
+  let schema2 = zod.z.string();
+  if (field.minLength !== void 0) schema2 = schema2.min(field.minLength);
+  if (field.maxLength !== void 0) schema2 = schema2.max(field.maxLength);
+  if (field.pattern) schema2 = schema2.regex(field.pattern);
+  if (field.email) schema2 = schema2.email();
+  if (field.url) schema2 = schema2.url();
+  return schema2;
+}
+function buildNumberSchema(field) {
+  let schema2 = zod.z.number();
+  if (field.min !== void 0) schema2 = schema2.min(field.min);
+  if (field.max !== void 0) schema2 = schema2.max(field.max);
+  return schema2;
+}
+function buildArraySchema(field) {
+  return field.items ? zod.z.array(fieldToZod(field.items)) : zod.z.array(zod.z.unknown());
+}
+function buildObjectSchema(field) {
+  if (!field.properties) {
+    return zod.z.record(zod.z.unknown());
+  }
+  const shape = {};
+  for (const [key, prop] of Object.entries(field.properties)) {
+    shape[key] = fieldToZod(prop);
+  }
+  return zod.z.object(shape);
+}
+var typeBuilders = {
+  string: buildStringSchema,
+  number: buildNumberSchema,
+  boolean: () => zod.z.boolean(),
+  date: () => zod.z.date(),
+  objectId: () => zod.z.union([zod.z.string(), zod.z.custom((val) => isObjectId(val))]),
+  array: buildArraySchema,
+  object: buildObjectSchema,
+  json: () => zod.z.unknown(),
+  literal: (field) => zod.z.literal(field.literal)
+};
+function fieldToZod(field) {
+  const builder = typeBuilders[field.type];
+  let schema2 = builder ? builder(field) : zod.z.unknown();
+  if (!field.required) {
+    schema2 = schema2.optional().nullable();
+  }
+  if (field.default !== void 0 && field.default !== "auto") {
+    schema2 = schema2.default(field.default);
+  }
+  return schema2;
+}
+function zodSchema(schema2) {
+  const shape = {};
+  for (const [fieldName, fieldDef] of Object.entries(schema2.fields)) {
+    shape[fieldName] = fieldToZod(fieldDef);
+  }
+  if (schema2.timestamps) {
+    const ts = schema2.timestamps;
+    if (ts.createdAt) {
+      shape[ts.createdAt] = zod.z.date().optional();
+    }
+    if (ts.updatedAt) {
+      shape[ts.updatedAt] = zod.z.date().optional();
+    }
+  }
+  return zod.z.object(shape);
+}
+function zodCreateSchema(schema2) {
+  const fullSchema = zodSchema(schema2);
+  const shape = { ...fullSchema.shape };
+  delete shape["_id"];
+  if (schema2.timestamps) {
+    const ts = schema2.timestamps;
+    if (ts.createdAt) delete shape[ts.createdAt];
+    if (ts.updatedAt) delete shape[ts.updatedAt];
+  }
+  return zod.z.object(shape);
+}
+function zodUpdateSchema(schema2) {
+  const createSchema = zodCreateSchema(schema2);
+  return createSchema.partial();
+}
+function validate(schema2, data) {
+  const result = schema2.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+
+// src/manager/collection-proxy.ts
+var CollectionProxy = class {
+  collection;
+  schema;
+  validationMode;
+  constructor(db, schema2, validationMode = "strict") {
+    this.collection = db.collection(schema2.collection);
+    this.schema = schema2;
+    this.validationMode = validationMode;
+  }
+  validateCreate(data) {
+    if (this.validationMode === "off") return;
+    const zodSchema2 = zodCreateSchema(this.schema);
+    const result = zodSchema2.safeParse(data);
+    if (!result.success) {
+      if (this.validationMode === "strict") {
+        throw new Error(`Validation failed: ${result.error.message}`);
+      }
+      console.warn(`Validation warning: ${result.error.message}`);
+    }
+  }
+  validateUpdate(data) {
+    if (this.validationMode === "off") return;
+    const zodSchema2 = zodUpdateSchema(this.schema);
+    const result = zodSchema2.safeParse(data);
+    if (!result.success) {
+      if (this.validationMode === "strict") {
+        throw new Error(`Validation failed: ${result.error.message}`);
+      }
+      console.warn(`Validation warning: ${result.error.message}`);
+    }
+  }
+  /**
+   * Find a single document matching the filter.
+   *
+   * @param where - MongoDB filter query
+   * @param options - Find options (select, sort, skip, limit, session)
+   * @returns The matching document or null
+   *
+   * @example
+   * ```typescript
+   * // Find by email
+   * const user = await db.users.findOne({ email: "john@example.com" });
+   *
+   * // With field selection
+   * const user = await db.users.findOne(
+   *   { email: "john@example.com" },
+   *   { select: { _id: true, email: true, name: true } }
+   * );
+   *
+   * // With session (for transactions)
+   * const user = await db.users.findOne(
+   *   { email: "john@example.com" },
+   *   { session }
+   * );
+   * ```
+   */
+  async findOne(where, options) {
+    const mongoOptions = {};
+    if (options?.select) {
+      mongoOptions.projection = options.select;
+    }
+    if (options?.sort) {
+      mongoOptions.sort = options.sort;
+    }
+    return this.collection.findOne(where, mongoOptions);
+  }
+  /**
+   * Find multiple documents matching the filter.
+   *
+   * @param where - MongoDB filter query (optional, defaults to {})
+   * @param options - Find options (select, sort, skip, limit, session)
+   * @returns Array of matching documents
+   *
+   * @example
+   * ```typescript
+   * // Find all active users
+   * const users = await db.users.findMany({ isActive: true });
+   *
+   * // With pagination and sorting
+   * const users = await db.users.findMany(
+   *   { role: "ADMIN" },
+   *   {
+   *     select: { _id: true, email: true, name: true },
+   *     sort: { createdAt: -1 },
+   *     skip: 0,
+   *     limit: 10
+   *   }
+   * );
+   *
+   * // Using MongoDB operators
+   * const users = await db.users.findMany({
+   *   age: { $gte: 18, $lte: 65 },
+   *   role: { $in: ["ADMIN", "MODERATOR"] }
+   * });
+   * ```
+   */
+  async findMany(where = {}, options) {
+    let cursor = this.collection.find(where);
+    if (options?.select) {
+      cursor = cursor.project(options.select);
+    }
+    if (options?.sort) {
+      cursor = cursor.sort(options.sort);
+    }
+    if (options?.skip !== void 0) {
+      cursor = cursor.skip(options.skip);
+    }
+    if (options?.limit !== void 0) {
+      cursor = cursor.limit(options.limit);
+    }
+    return cursor.toArray();
+  }
+  /**
+   * Find a document by its _id.
+   *
+   * @param id - ObjectId or string representation
+   * @param options - Find options (select, session)
+   * @returns The matching document or null
+   *
+   * @example
+   * ```typescript
+   * // Find by string ID
+   * const user = await db.users.findById("507f1f77bcf86cd799439011");
+   *
+   * // Find by ObjectId
+   * const user = await db.users.findById(new ObjectId("507f1f77bcf86cd799439011"));
+   *
+   * // With field selection
+   * const user = await db.users.findById(userId, {
+   *   select: { email: true, name: true }
+   * });
+   * ```
+   */
+  async findById(id, options) {
+    const objectId = this.parseObjectId(id);
+    const mongoOptions = { ...options };
+    if (options?.select) {
+      mongoOptions.projection = options.select;
+      delete mongoOptions.select;
+    }
+    return this.collection.findOne({ _id: objectId }, mongoOptions);
+  }
+  /**
+   * Create a new document.
+   * Automatically adds timestamps if enabled in schema.
+   *
+   * @param data - Document data (validated against schema)
+   * @param options - Create options (timestamps, session)
+   * @returns Insert result with insertedId
+   *
+   * @example
+   * ```typescript
+   * // Create a user
+   * const result = await db.users.create({
+   *   email: "john@example.com",
+   *   name: "John Doe",
+   *   role: "USER"
+   * });
+   * console.log(result.insertedId); // ObjectId
+   *
+   * // Disable automatic timestamps
+   * await db.users.create(userData, { timestamps: false });
+   *
+   * // With session (for transactions)
+   * await db.users.create(userData, { session });
+   * ```
+   */
+  async create(data, options) {
+    this.validateCreate(data);
+    const doc = this.applyTimestamps(data, "create", options?.timestamps);
+    return this.collection.insertOne(doc);
+  }
+  /**
+   * Create multiple documents in a single operation.
+   * Automatically adds timestamps if enabled in schema.
+   *
+   * @param data - Array of document data
+   * @param options - Create options (timestamps, ordered, session)
+   * @returns Insert result with insertedIds
+   *
+   * @example
+   * ```typescript
+   * // Create multiple users
+   * const result = await db.users.createMany([
+   *   { email: "user1@example.com", name: "User 1" },
+   *   { email: "user2@example.com", name: "User 2" },
+   *   { email: "user3@example.com", name: "User 3" }
+   * ]);
+   * console.log(result.insertedIds); // { 0: ObjectId, 1: ObjectId, 2: ObjectId }
+   *
+   * // With session (for transactions)
+   * await db.users.createMany(usersData, { session });
+   * ```
+   */
+  async createMany(data, options) {
+    for (const item of data) {
+      this.validateCreate(item);
+    }
+    const docs = data.map((d) => this.applyTimestamps(d, "create", options?.timestamps));
+    const { timestamps: _timestamps, ...mongoOptions } = options || {};
+    return this.collection.insertMany(docs, mongoOptions);
+  }
+  /**
+   * Update a single document matching the filter.
+   * Supports both simple updates and MongoDB update operators.
+   *
+   * @param where - MongoDB filter query
+   * @param data - Update data or MongoDB update operators ($set, $inc, etc.)
+   * @param options - Update options (upsert, timestamps, session)
+   * @returns Update result with matchedCount, modifiedCount, upsertedId
+   *
+   * @example
+   * ```typescript
+   * // Simple update (automatically wrapped in $set)
+   * await db.users.updateOne(
+   *   { email: "john@example.com" },
+   *   { name: "John Smith" }
+   * );
+   *
+   * // Using MongoDB operators
+   * await db.users.updateOne(
+   *   { _id: userId },
+   *   { $set: { name: "John" }, $inc: { loginCount: 1 } }
+   * );
+   *
+   * // Upsert - create if not exists
+   * await db.users.updateOne(
+   *   { email: "john@example.com" },
+   *   { $set: { name: "John", isActive: true } },
+   *   { upsert: true }
+   * );
+   *
+   * // With session (for transactions)
+   * await db.users.updateOne(filter, update, { session });
+   * ```
+   */
+  async updateOne(where, data, options) {
+    const hasOperators = Object.keys(data).some((k) => k.startsWith("$"));
+    if (!hasOperators) {
+      this.validateUpdate(data);
+    }
+    const update = this.applyUpdateTimestamps(data, hasOperators, options);
+    const { timestamps: _timestamps, ...mongoOptions } = options || {};
+    return this.collection.updateOne(where, update, mongoOptions);
+  }
+  /**
+   * Update multiple documents matching the filter.
+   * Supports both simple updates and MongoDB update operators.
+   *
+   * @param where - MongoDB filter query
+   * @param data - Update data or MongoDB update operators
+   * @param options - Update options (upsert, timestamps, session)
+   * @returns Update result with matchedCount, modifiedCount
+   *
+   * @example
+   * ```typescript
+   * // Deactivate all users with expired subscriptions
+   * await db.users.updateMany(
+   *   { subscriptionExpiry: { $lt: new Date() } },
+   *   { $set: { isActive: false } }
+   * );
+   *
+   * // Increment login count for all admins
+   * await db.users.updateMany(
+   *   { role: "ADMIN" },
+   *   { $inc: { loginCount: 1 } }
+   * );
+   * ```
+   */
+  async updateMany(where, data, options) {
+    const hasOperators = Object.keys(data).some((k) => k.startsWith("$"));
+    if (!hasOperators) {
+      this.validateUpdate(data);
+    }
+    const update = this.applyUpdateTimestamps(data, hasOperators, options);
+    const { timestamps: _timestamps, ...mongoOptions } = options || {};
+    return this.collection.updateMany(where, update, mongoOptions);
+  }
+  /**
+   * Update a document by its _id.
+   * Convenience method that wraps updateOne with _id filter.
+   *
+   * @param id - ObjectId or string representation
+   * @param data - Update data or MongoDB update operators
+   * @param options - Update options (upsert, timestamps, session)
+   * @returns Update result with matchedCount, modifiedCount
+   *
+   * @example
+   * ```typescript
+   * // Update by ID
+   * await db.users.updateById(userId, { name: "New Name" });
+   *
+   * // Using operators
+   * await db.users.updateById(userId, {
+   *   $set: { name: "New Name" },
+   *   $push: { tags: "premium" }
+   * });
+   * ```
+   */
+  async updateById(id, data, options) {
+    const objectId = this.parseObjectId(id);
+    return this.updateOne({ _id: objectId }, data, options);
+  }
+  /**
+   * Delete a single document matching the filter.
+   *
+   * @param where - MongoDB filter query
+   * @param options - Delete options (session)
+   * @returns Delete result with deletedCount
+   *
+   * @example
+   * ```typescript
+   * // Delete by email
+   * await db.users.deleteOne({ email: "john@example.com" });
+   *
+   * // With session (for transactions)
+   * await db.users.deleteOne({ _id: userId }, { session });
+   * ```
+   */
+  async deleteOne(where, options) {
+    const { soft: _soft, ...mongoOptions } = options || {};
+    return this.collection.deleteOne(where, mongoOptions);
+  }
+  /**
+   * Delete multiple documents matching the filter.
+   *
+   * @param where - MongoDB filter query
+   * @param options - Delete options (session)
+   * @returns Delete result with deletedCount
+   *
+   * @example
+   * ```typescript
+   * // Delete all inactive users
+   * const result = await db.users.deleteMany({ isActive: false });
+   * console.log(`Deleted ${result.deletedCount} users`);
+   *
+   * // Delete users created before a date
+   * await db.users.deleteMany({
+   *   createdAt: { $lt: new Date("2023-01-01") }
+   * });
+   * ```
+   */
+  async deleteMany(where, options) {
+    const { soft: _soft, ...mongoOptions } = options || {};
+    return this.collection.deleteMany(where, mongoOptions);
+  }
+  /**
+   * Delete a document by its _id.
+   *
+   * @param id - ObjectId or string representation
+   * @param options - Delete options (session)
+   * @returns Delete result with deletedCount
+   *
+   * @example
+   * ```typescript
+   * await db.users.deleteById("507f1f77bcf86cd799439011");
+   * await db.users.deleteById(userId, { session });
+   * ```
+   */
+  async deleteById(id, options) {
+    const objectId = this.parseObjectId(id);
+    return this.deleteOne({ _id: objectId }, options);
+  }
+  /**
+   * Count documents matching the filter.
+   *
+   * @param where - MongoDB filter query (optional)
+   * @param options - Count options (limit, skip, session)
+   * @returns Number of matching documents
+   *
+   * @example
+   * ```typescript
+   * // Count all users
+   * const total = await db.users.count();
+   *
+   * // Count active users
+   * const activeCount = await db.users.count({ isActive: true });
+   *
+   * // Count with limit (for existence check optimization)
+   * const hasAdmins = await db.users.count({ role: "ADMIN" }, { limit: 1 }) > 0;
+   * ```
+   */
+  async count(where = {}, options) {
+    return this.collection.countDocuments(where, options);
+  }
+  /**
+   * Check if any document matches the filter.
+   * Optimized to stop after finding first match.
+   *
+   * @param where - MongoDB filter query
+   * @param options - Count options (session)
+   * @returns true if at least one document matches
+   *
+   * @example
+   * ```typescript
+   * // Check if email is taken
+   * const emailTaken = await db.users.exists({ email: "john@example.com" });
+   *
+   * // Check if user has admin role
+   * const isAdmin = await db.users.exists({ _id: userId, role: "ADMIN" });
+   * ```
+   */
+  async exists(where, options) {
+    const count = await this.collection.countDocuments(where, { ...options, limit: 1 });
+    return count > 0;
+  }
+  /**
+   * Run an aggregation pipeline.
+   * Provides full access to MongoDB aggregation framework.
+   *
+   * @param pipeline - Array of aggregation stages
+   * @param options - Aggregation options (allowDiskUse, session)
+   * @returns Array of aggregation results
+   *
+   * @example
+   * ```typescript
+   * // Group users by role and count
+   * const stats = await db.users.aggregate([
+   *   { $match: { isActive: true } },
+   *   { $group: { _id: "$role", count: { $sum: 1 } } },
+   *   { $sort: { count: -1 } }
+   * ]);
+   *
+   * // Lookup related documents
+   * const usersWithPosts = await db.users.aggregate([
+   *   { $lookup: {
+   *       from: "posts",
+   *       localField: "_id",
+   *       foreignField: "authorId",
+   *       as: "posts"
+   *   }}
+   * ]);
+   *
+   * // With options
+   * const bigResult = await db.users.aggregate(pipeline, {
+   *   allowDiskUse: true
+   * });
+   * ```
+   */
+  async aggregate(pipeline, options) {
+    return this.collection.aggregate(pipeline, options).toArray();
+  }
+  /**
+   * Get the underlying MongoDB Collection instance.
+   * Use for advanced operations not covered by the proxy.
+   *
+   * @returns MongoDB Collection instance
+   *
+   * @example
+   * ```typescript
+   * const collection = db.users.getCollection();
+   *
+   * // Use for watch, bulkWrite, or other advanced operations
+   * const changeStream = collection.watch();
+   * ```
+   */
+  getCollection() {
+    return this.collection;
+  }
+  applyTimestamps(data, operation, enabled) {
+    if (enabled === false || !this.schema.timestamps) {
+      return data;
+    }
+    const timestamps = this.schema.timestamps;
+    const now = /* @__PURE__ */ new Date();
+    const result = { ...data };
+    if (operation === "create" && timestamps.createdAt) {
+      result[timestamps.createdAt] = now;
+    }
+    if (timestamps.updatedAt) {
+      result[timestamps.updatedAt] = now;
+    }
+    return result;
+  }
+  parseObjectId(id) {
+    return typeof id === "string" ? new mongodb.ObjectId(id) : id;
+  }
+  applyUpdateTimestamps(data, hasOperators, options) {
+    const schemaTimestamps = this.schema.timestamps;
+    if (!schemaTimestamps) {
+      return hasOperators ? data : { $set: data };
+    }
+    const timestamps = schemaTimestamps;
+    const now = /* @__PURE__ */ new Date();
+    const update = hasOperators ? { ...data } : { $set: { ...data } };
+    if (timestamps.updatedAt) {
+      update.$set = update.$set || {};
+      if (!(timestamps.updatedAt in update.$set)) {
+        update.$set[timestamps.updatedAt] = now;
+      }
+    }
+    if (options?.upsert && timestamps.createdAt) {
+      update.$setOnInsert = update.$setOnInsert || {};
+      if (!(timestamps.createdAt in update.$setOnInsert)) {
+        update.$setOnInsert[timestamps.createdAt] = now;
+      }
+    }
+    return update;
+  }
+};
+
+// src/client/client.ts
+async function syncIndexes(db, schemas) {
+  for (const schema2 of schemas) {
+    const collection = db.collection(schema2.collection);
+    const fieldIndexes = getFieldIndexes(schema2);
+    for (const { field, options } of fieldIndexes) {
+      const indexSpec = {
+        [field]: options.type ?? 1
+      };
+      const indexOptions = {};
+      if (options.name) indexOptions.name = options.name;
+      if (options.unique) indexOptions.unique = options.unique;
+      if (options.sparse) indexOptions.sparse = options.sparse;
+      if (options.expireAfterSeconds !== void 0) {
+        indexOptions.expireAfterSeconds = options.expireAfterSeconds;
+      }
+      if (options.partialFilterExpression) {
+        indexOptions.partialFilterExpression = options.partialFilterExpression;
+      }
+      await collection.createIndex(indexSpec, indexOptions);
+    }
+    for (const index of schema2.indexes) {
+      const indexSpec = index.fields;
+      const indexOptions = {};
+      if (index.options?.name) indexOptions.name = index.options.name;
+      if (index.options?.unique) indexOptions.unique = index.options.unique;
+      if (index.options?.sparse) indexOptions.sparse = index.options.sparse;
+      if (index.options?.partialFilterExpression) {
+        indexOptions.partialFilterExpression = index.options.partialFilterExpression;
+      }
+      if (index.options?.weights) {
+        indexOptions.weights = index.options.weights;
+      }
+      await collection.createIndex(indexSpec, indexOptions);
+    }
+  }
+}
+function createClientProxy(client, db, schemas, validationMode) {
+  const schemaMap = /* @__PURE__ */ new Map();
+  const proxyCache = /* @__PURE__ */ new Map();
+  for (const schema2 of schemas) {
+    schemaMap.set(schema2.name, schema2);
+  }
+  const baseClient = {
+    async close() {
+      await client.close();
+    },
+    getDb() {
+      return db;
+    },
+    startSession(options) {
+      return client.startSession(options);
+    }
+  };
+  const IGNORED_PROPERTIES = /* @__PURE__ */ new Set([
+    "then",
+    "catch",
+    "finally",
+    "inspect",
+    "nodeType",
+    "toJSON",
+    "constructor",
+    "prototype",
+    "__proto__"
+  ]);
+  return new Proxy(baseClient, {
+    get(target, prop) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop);
+      }
+      if (IGNORED_PROPERTIES.has(prop)) {
+        return void 0;
+      }
+      if (prop in target) {
+        const value = target[prop];
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      const schema2 = schemaMap.get(prop);
+      if (schema2) {
+        let proxy = proxyCache.get(prop);
+        if (!proxy) {
+          proxy = new CollectionProxy(db, schema2, validationMode);
+          proxyCache.set(prop, proxy);
+        }
+        return proxy;
+      }
+      return void 0;
+    },
+    has(target, prop) {
+      if (typeof prop === "symbol") return false;
+      if (IGNORED_PROPERTIES.has(prop)) return false;
+      return prop in target || schemaMap.has(prop);
+    },
+    ownKeys(target) {
+      const baseKeys = Reflect.ownKeys(target);
+      const schemaNames = Array.from(schemaMap.keys());
+      return [.../* @__PURE__ */ new Set([...baseKeys, ...schemaNames])];
+    }
+  });
+}
+function createClient(config) {
+  const { schemas, syncIndexes: shouldSyncIndexes = false, validation = "strict" } = config;
+  if (config.serverless === true) {
+    return async (uri, options) => {
+      const client = new mongodb.MongoClient(uri, options);
+      await client.connect();
+      const db = client.db();
+      if (shouldSyncIndexes) {
+        await syncIndexes(db, schemas);
+      }
+      return createClientProxy(client, db, schemas, validation);
+    };
+  } else {
+    return (async () => {
+      const client = new mongodb.MongoClient(config.uri, config.options);
+      await client.connect();
+      const db = client.db();
+      if (shouldSyncIndexes) {
+        await syncIndexes(db, schemas);
+      }
+      return createClientProxy(client, db, schemas, validation);
+    })();
+  }
+}
+
+Object.defineProperty(exports, "ObjectId", {
+  enumerable: true,
+  get: function () { return mongodb.ObjectId; }
+});
+exports.CollectionProxy = CollectionProxy;
+exports.createClient = createClient;
+exports.defineSchema = defineSchema;
+exports.s = s;
+exports.schema = schema;
+exports.validate = validate;
+exports.zodCreateSchema = zodCreateSchema;
+exports.zodSchema = zodSchema;
+exports.zodUpdateSchema = zodUpdateSchema;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map