@zodyac/zod-mongoose 1.1.3 → 1.3.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## 1.3.0 - 2024-08-30
+### Added
+- Changelog

package/README.md

@@ -1,8 +1,9 @@
-# Zod to mongoose schema converter
+# Zod to Mongoose schema converter
 
-[![npm version](https://badge.fury.io/js/%40zodyac%2Fmongoose.svg)](https://badge.fury.io/js/%40zodyac%2Fmongoose)
-
-> A part of [Zodyac toolbox](https://npmjs.com/org/zodyac).
+![NPM Version](https://img.shields.io/npm/v/%40zodyac%2Fzod-mongoose)
+![NPM Downloads](https://img.shields.io/npm/dw/%40zodyac%2Fzod-mongoose)
+![npm bundle size](https://img.shields.io/bundlephobia/min/%40zodyac%2Fzod-mongoose)
+![Test coverage](./badges/coverage.svg)
 
 This package provides a function to convert [zod](https://www.npmjs.com/package/zod) object to [mongoose](https://www.npmjs.com/package/mongoose) schema.
 
@@ -10,51 +11,68 @@ This package provides a function to convert [zod](https://www.npmjs.com/package/
 
 ```bash
 npm i @zodyac/zod-mongoose
+
+pnpm add @zodyac/zod-mongoose
+
+yarn add @zodyac/zod-mongoose
+
+bun add @zodyac/zod-mongoose
 ```
 
+## Breaking changes
+> [!WARNING]
+> If you were using ```zId``` or ```zUUID``` before, please replace those with ```z.objectId()``` and ```z.mongoUUID()```.
+
+- ```zId``` is now ```z.objectId()```
+- ```zUUID``` is now ```z.mongoUUID()```
+
 ## Usage
 
-First, create your zod schema:
+First, extend Zod with ```extendZod```, then create your zod schema:
 
 ```typescript
-import { z } from 'zod';
-import { zId, zUUID } from '@zodyac/zod-mongoose';
+import { z } from "zod";
+import { extendZod } from "@zodyac/zod-mongoose";
+
+extend(z);
 
 const zUser = z.object({
   name: z.string().min(3).max(255),
   age: z.number().min(18).max(100),
   active: z.boolean().default(false),
-  access: z.enum(['admin', 'user']).default('user'),
-  companyId: zId.describe('ObjectId:Company'),
-  wearable: zUUID.describe('UUID:Wearable'),
+  access: z.enum(["admin", "user"]).default("user"),
+  companyId: z.objectId("Company"),
+  wearable: z.mongoUUID(),
   address: z.object({
     street: z.string(),
     city: z.string(),
-    state: z.enum(['CA', 'NY', 'TX']),
+    state: z.enum(["CA", "NY", "TX"]),
   }),
   tags: z.array(z.string()),
   createdAt: z.date(),
   updatedAt: z.date(),
 });
-
 ```
 
 Then, convert it to mongoose schema and connect model:
 
 ```typescript
-import { zodSchema } from '@zodyac/zod-mongoose';
-import { model } from 'mongoose';
+import { zodSchema } from "@zodyac/zod-mongoose";
+import { model } from "mongoose";
 
 const schema = zodSchema(zDoc);
-const userModel = model('User', schema);
+const userModel = model("User", schema);
 ```
 
 That's it! Now you can use your mongoose model as usual:
 
 ```typescript
-userModel.find({ name: 'John' });
+userModel.find({ name: "John" });
 ```
 
+> [Note]
+```extendZod``` should be called once for the whole application.
+
 ## Features
 
 - ✅ Basic types
@@ -62,25 +80,27 @@ userModel.find({ name: 'John' });
 - ✅ Arrays
 - ✅ Enums (strings only)
 - ✅ Default values
+- ✅ Maps
 - ✅ Dates
 - ✅ ObjectId
 - ✅ ObjectId references
 - ✅ ZodAny as SchemaTypes.Mixed
-- 🔧 UUID (experimental)
-- 🔧 UUID references (experimental)
-- ❗️ Unions (not supported by mongoose)
+- ✅ Validation using refinement for String, Number, Date
+- ✅ Unique for String, Number, Date, ObjectId and UUID
+
+- ⚠️ Record (Being converted to Map)
+- ⚠️ Unions (not supported by mongoose, will pick first inner type)
+
 - ❗️ Intersection (not supported by mongoose)
+- ❗️ Set (not supported by mongoose)
 - ❗️ Indexes (not supported by zod)
-- ❗️ Number enums (comming soon)
-- ⏳ Regex validation (comming soon)
-- ⏳ Custom validators (comming soon)
-- ⏳ instanceOf (comming soon)
-- ⏳ Transform (comming soon)
-- ⏳ Refine (comming soon)
+
+- ⏳ Regex validation (coming soon)
+- ⏳ instanceOf (coming soon)
 
 ## Checking schemas
 
-To make sure nothing is missing, you can use ```Schema.obj```:
+To make sure nothing is missing, you can use `Schema.obj`:
 
 ```typescript
 // schema is mongoose schema
@@ -89,17 +109,105 @@ console.log(schema.obj);
 
 ## Raw object
 
-If you want to get raw object from zod schema to modify it, you can use ```zodSchemaRaw``` function:
+If you want to get raw object from zod schema to modify it, you can use `zodSchemaRaw` function:
 
 ```typescript
-import { zodSchemaRaw } from '@zodyac/zod-mongoose';
-import { model, Schema } from 'mongoose';
+import { extendZod, zodSchemaRaw } from "@zodyac/zod-mongoose";
+import { model, Schema } from "mongoose";
+
+extendZod(z);
 
 const schema = zodSchemaRaw(zDoc);
-schema.age.validate = (v: number) => v > 18;
+schema.age.index = true
 
-const model = model('User', new Schema(schema));
+const model = model("User", new Schema(schema, {
+  timestamps: true,
+}));
 ```
 
+## ObjectID and UUID
+You can use ```z.objectId(ref?: string)``` and ```z.mongoUUID()``` to describe fields as ObjectID and UUID and add reference to another collection:
+
+```typescript
+import { extendZod } from "@zodyac/zod-mongoose";
+import { z } from "zod"
+
+extendZod(z);
+
+const zUser = z.object({
+  someId: z.objectId(),
+  companyId: z.objectId("Company"),
+  facilityId: z.objectId().ref("Facility"),
+  wearable: z.mongoUUID(),
+});
+```
+
+## Validation
+You can use zod refinement to validate your mongoose models:
+
+```typescript
+import { z } from "zod";
+import { extendZod, zodSchema } from "@zodyac/zod-mongoose";
+
+extendZod(z);
+
+const zUser = z.object({
+  phone: z.string().refine((v) => v.match(/^\d{3}-\d{3}-\d{4}$/), "Invalid phone number"),
+});
+```
+
+## Unique fields
+To make a String, Number or Date unique, call ```.unique()```:
+```typescript
+import { z } from "zod";
+import { extendZod, zodSchema } from "@zodyac/zod-mongoose";
+
+extendZod(z);
+
+const zUser = z.object({
+  phone: z.string().unique(),
+});
+
+//
+```
+
+## Warnings
+
+### ZodUnion types
+
+Union types are not supported by mongoose. If you have a union type in your zod schema, it will be converted to it's inner type by default.
+
+```typescript
+const zUser = z.object({
+  access: z.union([z.string(), z.number()]),
+});
+
+// Will become
+// {
+//   access: {
+//     type: String,
+//   },
+// }
+```
+
+### ZodAny
+`ZodAny` is converted to `SchemaTypes.Mixed`. It's not recommended to use it, but it's there if you need it.
+
+### ZodRecord
+`ZodRecord` is converted to `Map` type. It's not recommended to use it, but it's there if you need it.
+
+## Contributing
+
+Feel free to open issues and pull requests! Here's a quick guide to get you started:
+- Fork the repository
+- Install linter and formatter for VSCode: Biome
+- Install dependencies: ```npm i```
+- Make changes
+- Run tests: ```npm test```
+- Run linter: ```npm run lint``` (fix with ```npm run lint:fix```)
+- Commit and push your changes
+- Open a pull request
+
 ## License
+
 MIT

package/dist/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -21,132 +22,164 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   default: () => src_default,
-  zId: () => zId,
-  zUUID: () => zUUID,
+  extendZod: () => extendZod,
   zodSchema: () => zodSchema,
   zodSchemaRaw: () => zodSchemaRaw
 });
 module.exports = __toCommonJS(src_exports);
+var import_mongoose2 = require("mongoose");
+var import_zod2 = require("zod");
+
+// src/extension.ts
 var import_mongoose = require("mongoose");
 var import_zod = require("zod");
-function zodSchema(schema) {
+var zod_extended = false;
+function extendZod(z_0) {
+  if (zod_extended) return;
+  zod_extended = true;
+  const _refine = z_0.ZodType.prototype.refine;
+  z_0.ZodType.prototype.refine = function(check, opts) {
+    const zEffect = _refine.bind(this)(check, opts);
+    let message = void 0;
+    if (typeof opts === "string") message = opts;
+    else if ("message" in opts) message = opts.message;
+    zEffect._def.effect.__zm_validation = {
+      validator: check,
+      message
+    };
+    return zEffect;
+  };
+  z_0.ZodString.prototype.unique = function(arg = true) {
+    this.__zm_unique = arg;
+    return this;
+  };
+  z_0.ZodNumber.prototype.unique = function(arg = true) {
+    this.__zm_unique = arg;
+    return this;
+  };
+  z_0.ZodDate.prototype.unique = function(arg = true) {
+    this.__zm_unique = arg;
+    return this;
+  };
+  z_0.objectId = (ref) => {
+    const output = import_zod.z.string().refine((v) => (0, import_mongoose.isValidObjectId)(v), {
+      message: "Invalid ObjectId"
+    }).or(import_zod.z.instanceof(import_mongoose.Types.ObjectId));
+    output.__zm_type = "ObjectId";
+    output.__zm_ref = ref;
+    output.ref = function(ref2) {
+      this.__zm_ref = ref2;
+      return this;
+    };
+    output.unique = function(val = true) {
+      this.__zm_unique = val;
+      return this;
+    };
+    return output;
+  };
+  z_0.mongoUUID = () => {
+    const output = import_zod.z.string().uuid({
+      message: "Invalid UUID"
+    }).or(import_zod.z.instanceof(import_mongoose.Types.UUID).describe("UUID"));
+    output.__zm_type = "UUID";
+    output.unique = function(val = true) {
+      this.__zm_unique = val;
+      return this;
+    };
+    return output;
+  };
+}
+__name(extendZod, "extendZod");
+
+// src/index.ts
+function zodSchema(schema, options) {
   const definition = parseObject(schema);
-  return new import_mongoose.Schema(definition);
+  return new import_mongoose2.Schema(definition, options);
 }
+__name(zodSchema, "zodSchema");
 function zodSchemaRaw(schema) {
   return parseObject(schema);
 }
-var zId = import_zod.z.string().refine((v) => (0, import_mongoose.isValidObjectId)(v), { message: "Invalid ObjectId" }).or(import_zod.z.instanceof(import_mongoose.Types.ObjectId).describe("ObjectId"));
-var zUUID = import_zod.z.string().uuid({ message: "Invalid UUID" }).or(import_zod.z.instanceof(import_mongoose.Types.UUID).describe("UUID"));
+__name(zodSchemaRaw, "zodSchemaRaw");
 function parseObject(obj) {
   const object = {};
   for (const [key, field] of Object.entries(obj.shape)) {
-    if (field instanceof import_zod.ZodObject) {
+    if (field instanceof import_zod2.ZodObject) {
       object[key] = parseObject(field);
     } else {
       const f = parseField(field);
-      if (f)
-        object[key] = f;
-      else
-        console.error(
-          `Key ${key}: Unsupported field type: ${field.constructor}`
-        );
+      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);
+      object[key] = f;
     }
   }
   return object;
 }
-function parseField(field, required, def) {
-  if (field instanceof import_zod.ZodObject) {
+__name(parseObject, "parseObject");
+function parseField(field, required = true, def, refinement) {
+  const field_type = field.constructor.name;
+  if ("__zm_type" in field && field.__zm_type === "ObjectId") {
+    const ref = field.__zm_ref;
+    const unique = field.__zm_unique;
+    return parseObjectId(required, ref, unique);
+  }
+  if ("__zm_type" in field && field.__zm_type === "UUID") {
+    const unique = field.__zm_unique;
+    return parseUUID(required, unique);
+  }
+  if (field instanceof import_zod2.ZodObject) {
     return parseObject(field);
   }
-  if (field instanceof import_zod.ZodNumber) {
-    return parseNumber(
-      field,
-      required,
-      def,
-      field.description?.toLocaleLowerCase() === "unique"
-      // validate as (v: number) => boolean,
-    );
-  }
-  if (field instanceof import_zod.ZodString) {
-    return parseString(
-      field,
-      required,
-      def,
-      field.description?.toLocaleLowerCase() === "unique"
-      // validate as (v: string) => boolean,
-    );
-  }
-  if (field instanceof import_zod.ZodEnum) {
+  if (field instanceof import_zod2.ZodNumber) {
+    const isUnique = field.__zm_unique ?? false;
+    return parseNumber(field, required, def, isUnique, refinement);
+  }
+  if (field instanceof import_zod2.ZodString) {
+    const isUnique = field.__zm_unique ?? false;
+    return parseString(field, required, def, isUnique, refinement);
+  }
+  if (field instanceof import_zod2.ZodEnum) {
     return parseEnum(Object.keys(field.Values), required, def);
   }
-  if (field instanceof import_zod.ZodBoolean) {
+  if (field_type === "ZodBoolean") {
     return parseBoolean(required, def);
   }
-  if (field instanceof import_zod.ZodDate) {
-    return parseDate(required, def);
+  if (field instanceof import_zod2.ZodDate) {
+    const isUnique = field.__zm_unique ?? false;
+    return parseDate(required, def, refinement, isUnique);
   }
-  if (field instanceof import_zod.ZodArray) {
-    return [parseField(field.element)];
+  if (field instanceof import_zod2.ZodArray) {
+    return parseArray(required, field.element, def);
   }
-  if (field instanceof import_zod.ZodDefault) {
-    return parseField(
-      field._def.innerType,
-      required,
-      field._def.defaultValue()
-    );
+  if (field instanceof import_zod2.ZodDefault) {
+    return parseField(field._def.innerType, required, field._def.defaultValue());
   }
-  if (field instanceof import_zod.ZodOptional) {
+  if (field instanceof import_zod2.ZodOptional) {
     return parseField(field._def.innerType, false, void 0);
   }
-  if (field instanceof import_zod.ZodNullable) {
+  if (field instanceof import_zod2.ZodNullable) {
     return parseField(field._def.innerType, false, def || null);
   }
-  if (field.description?.startsWith("ObjectId")) {
-    const ref = field.description.split(":")[1];
-    if (ref)
-      return parseObjectIdRef(required, ref);
-    return parseObjectId(required);
-  }
-  if (field.description?.startsWith("UUID")) {
-    const ref = field.description.split(":")[1];
-    if (ref)
-      return parseUUIDRef(required, ref);
-    return parseUUID(required);
-  }
-  if (field instanceof import_zod.ZodUnion) {
+  if (field instanceof import_zod2.ZodUnion) {
     return parseField(field._def.options[0]);
   }
-  if (field instanceof import_zod.ZodAny) {
+  if (field_type === "ZodAny") {
     return parseMixed(required, def);
   }
-  if (field instanceof import_zod.ZodEffects) {
-    if (field._def.effect.type === "refinement") {
-      return parseField(
-        field._def.schema,
-        required,
-        def
-        // field._def.effect.refinement as (v: T) => boolean,
-      );
+  if (field instanceof import_zod2.ZodMap || field instanceof import_zod2.ZodRecord) {
+    return parseMap(required, field.keySchema, def);
+  }
+  if (field instanceof import_zod2.ZodEffects) {
+    const effect = field._def.effect;
+    if (effect.type === "refinement") {
+      const validation = effect.__zm_validation;
+      return parseField(field._def.schema, required, def, validation);
     }
   }
   return null;
 }
+__name(parseField, "parseField");
 function parseNumber(field, required = true, def, unique = false, validate) {
-  if (validate) {
-    return {
-      type: Number,
-      default: def,
-      min: field.minValue ?? void 0,
-      max: field.maxValue ?? void 0,
-      validation: {
-        validate
-      },
-      required,
-      unique
-    };
-  }
-  return {
+  const output = {
     type: Number,
     default: def,
     min: field.minValue ?? void 0,
@@ -154,40 +187,33 @@ function parseNumber(field, required = true, def, unique = false, validate) {
     required,
     unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
+__name(parseNumber, "parseNumber");
 function parseString(field, required = true, def, unique = false, validate) {
-  if (validate) {
-    return {
-      type: String,
-      default: def,
-      required,
-      minLength: field.minLength ?? void 0,
-      maxLength: field.maxLength ?? void 0,
-      validation: {
-        validate
-      },
-      unique
-    };
-  }
-  return {
+  const output = {
     type: String,
     default: def,
-    // TODO: match: field.regex(),
     required,
     minLength: field.minLength ?? void 0,
     maxLength: field.maxLength ?? void 0,
     unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
+__name(parseString, "parseString");
 function parseEnum(values, required = true, def) {
   return {
     type: String,
+    unique: false,
     default: def,
     enum: values,
-    required,
-    unique: false
+    required
   };
 }
+__name(parseEnum, "parseEnum");
 function parseBoolean(required = true, def) {
   return {
     type: Boolean,
@@ -195,51 +221,85 @@ function parseBoolean(required = true, def) {
     required
   };
 }
-function parseDate(required = true, def) {
-  return {
+__name(parseBoolean, "parseBoolean");
+function parseDate(required = true, def, validate, unique = false) {
+  const output = {
     type: Date,
     default: def,
-    required
+    required,
+    unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
-function parseObjectId(required = true) {
-  return {
-    type: import_mongoose.SchemaTypes.ObjectId,
-    required
+__name(parseDate, "parseDate");
+function parseObjectId(required = true, ref, unique = false) {
+  const output = {
+    type: import_mongoose2.SchemaTypes.ObjectId,
+    required,
+    unique
   };
+  if (ref) output.ref = ref;
+  return output;
 }
-function parseObjectIdRef(required = true, ref) {
+__name(parseObjectId, "parseObjectId");
+function parseArray(required = true, element, def) {
+  const innerType = parseField(element);
+  if (!innerType) throw new Error("Unsupported array type");
   return {
-    type: import_mongoose.SchemaTypes.ObjectId,
-    ref,
+    type: [
+      innerType
+    ],
+    default: def,
     required
   };
 }
-function parseUUID(required = true) {
+__name(parseArray, "parseArray");
+function parseMap(required = true, key, def) {
+  const pointer = typeConstructor(key);
   return {
-    type: import_mongoose.SchemaTypes.UUID,
+    type: Map,
+    of: pointer,
+    default: def,
     required
   };
 }
-function parseUUIDRef(required = true, ref) {
+__name(parseMap, "parseMap");
+function typeConstructor(t) {
+  switch (true) {
+    case t instanceof import_zod2.ZodString:
+      return String;
+    case t instanceof import_zod2.ZodEnum:
+      return String;
+    case t instanceof import_zod2.ZodNumber:
+      return Number;
+    case t instanceof import_zod2.ZodDate:
+      return Date;
+    default:
+      return void 0;
+  }
+}
+__name(typeConstructor, "typeConstructor");
+function parseUUID(required = true, unique = false) {
   return {
-    type: import_mongoose.SchemaTypes.UUID,
-    ref,
-    required
+    type: import_mongoose2.SchemaTypes.UUID,
+    required,
+    unique
   };
 }
+__name(parseUUID, "parseUUID");
 function parseMixed(required = true, def) {
   return {
-    type: import_mongoose.SchemaTypes.Mixed,
+    type: import_mongoose2.SchemaTypes.Mixed,
     default: def,
     required
   };
 }
+__name(parseMixed, "parseMixed");
 var src_default = zodSchema;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  zId,
-  zUUID,
+  extendZod,
   zodSchema,
   zodSchemaRaw
 });