@mirite/zod-to-mongoose 0.0.1

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,63 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+
+import * as Mongoose from 'mongoose';
+import { z } from 'zod';
+import { ZodBoolean } from 'zod';
+import { ZodDate } from 'zod';
+import { ZodDefault } from 'zod';
+import { ZodNumber } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodRawShape } from 'zod';
+import { ZodString } from 'zod';
+import { ZodTypeAny } from 'zod';
+import { ZodUnion } from 'zod';
+
+export declare type Check = "";
+
+export declare function createSchema<T extends ZodRawShape>(zodObject: ZodObject<T>, modelName: string, connection: Mongoose.Connection): {
+    schema: Mongoose.Schema;
+    model: Mongoose.Model<z.infer<typeof zodObject>>;
+};
+
+export declare function createSchema<T extends ZodRawShape>(zodObject: ZodObject<T>): Mongoose.Schema;
+
+export declare type Field = {
+    _def: FieldDefinition;
+    checks?: Array<Check>;
+    defaultValue?: () => unknown;
+};
+
+export declare type FieldDefinition = {
+    typeName: string;
+    innerType?: Field;
+    description: string | undefined;
+};
+
+declare type SupportedPrimitive = ZodString | ZodNumber | ZodBoolean | ZodDate;
+
+export declare type SupportedType = SupportedPrimitive | ZodDefault<ZodTypeAny> | ZodObject<ZodRawShape> | ZodUnion<readonly [ZodTypeAny, ...ZodTypeAny[]]>;
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+
+import * as Mongoose from 'mongoose';
+import { z } from 'zod';
+import { ZodBoolean } from 'zod';
+import { ZodDate } from 'zod';
+import { ZodDefault } from 'zod';
+import { ZodNumber } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodRawShape } from 'zod';
+import { ZodString } from 'zod';
+import { ZodTypeAny } from 'zod';
+import { ZodUnion } from 'zod';
+
+export declare type Check = "";
+
+export declare function createSchema<T extends ZodRawShape>(zodObject: ZodObject<T>, modelName: string, connection: Mongoose.Connection): {
+    schema: Mongoose.Schema;
+    model: Mongoose.Model<z.infer<typeof zodObject>>;
+};
+
+export declare function createSchema<T extends ZodRawShape>(zodObject: ZodObject<T>): Mongoose.Schema;
+
+export declare type Field = {
+    _def: FieldDefinition;
+    checks?: Array<Check>;
+    defaultValue?: () => unknown;
+};
+
+export declare type FieldDefinition = {
+    typeName: string;
+    innerType?: Field;
+    description: string | undefined;
+};
+
+declare type SupportedPrimitive = ZodString | ZodNumber | ZodBoolean | ZodDate;
+
+export declare type SupportedType = SupportedPrimitive | ZodDefault<ZodTypeAny> | ZodObject<ZodRawShape> | ZodUnion<readonly [ZodTypeAny, ...ZodTypeAny[]]>;
+
+export { }

package/dist/index.cjs

@@ -0,0 +1,2 @@
+"use strict";var s=Object.create;var d=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var m=Object.getPrototypeOf,h=Object.prototype.hasOwnProperty;var S=(e,o)=>{for(var n in o)d(e,n,{get:o[n],enumerable:!0})},r=(e,o,n,t)=>{if(o&&typeof o=="object"||typeof o=="function")for(let a of l(o))!h.call(e,a)&&a!==n&&d(e,a,{get:()=>o[a],enumerable:!(t=u(o,a))||t.enumerable});return e};var b=(e,o,n)=>(n=e!=null?s(m(e)):{},r(o||!e||!e.__esModule?d(n,"default",{value:e,enumerable:!0}):n,e)),Z=e=>r(d({},"__esModule",{value:!0}),e);var w={};S(w,{createSchema:()=>f});module.exports=Z(w);var c=b(require("mongoose"),1);function f(e,o,n){let t={};for(let i in e.shape){let p=e.shape[i];t[i]=T(i,p)}let a=new c.Schema(t);return!n||!o?a:{schema:a,model:n.model(o,a)}}function y(e){return e._def.typeName==="ZodObject"}function T(e,o){let n=g(o),t;switch(n.definition._def.typeName){case"ZodString":t=String;break;case"ZodNumber":t=Number;break;case"ZodBoolean":t=Boolean;break;case"ZodDate":t=Date;break;case"ZodObject":break;case"ZodUnion":t={};break;default:throw new Error(`Unsupported type: ${e}`)}return y(n.definition)&&(t=f(n.definition)),n.defaultValue?{type:t,default:n.defaultValue}:t}function g(e){let o=e,n=!1,t;for(;"innerType"in o._def;)"defaultValue"in o._def&&(t=o._def.defaultValue()),o=o._def.innerType;return{definition:o,optional:n,defaultValue:t}}0&&(module.exports={createSchema});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { z, ZodObject, ZodRawShape } from \"zod\";\nimport * as Mongoose from \"mongoose\";\nimport { SchemaDefinition } from \"mongoose\";\nimport { SupportedType } from \"./types\";\n\nexport function createSchema<T extends ZodRawShape>(\n    zodObject: ZodObject<T>,\n    modelName: string,\n    connection: Mongoose.Connection,\n): { schema: Mongoose.Schema; model: Mongoose.Model<z.infer<typeof zodObject>> };\nexport function createSchema<T extends ZodRawShape>(zodObject: ZodObject<T>): Mongoose.Schema;\n/**\n * Create a Mongoose schema from a Zod shape\n *\n * @param zodObject The Zod shape to create the schema from\n * @param modelName The unique name to assign to the model\n * @param connection The Mongoose connection to create the model from\n * @returns The Mongoose schema\n */\nexport function createSchema<T extends ZodRawShape>(\n    zodObject: ZodObject<T>,\n    modelName?: string,\n    connection?: Mongoose.Connection,\n): Mongoose.Schema | { schema: Mongoose.Schema; model: Mongoose.Model<z.infer<typeof zodObject>> } {\n    const convertedShape: Partial<SchemaDefinition> = {};\n    for (const key in zodObject.shape) {\n        const zodField = zodObject.shape[key];\n        convertedShape[key] = convertField(key, zodField);\n    }\n    const schema = new Mongoose.Schema(convertedShape);\n    if (!connection || !modelName) return schema;\n    return { schema, model: connection.model<z.infer<typeof zodObject>>(modelName, schema) };\n}\n\n/**\n * Check if a Zod definition is an object\n *\n * @param definition The Zod definition to check\n * @returns Whether the definition is an object\n */\nfunction isZodObject(definition: SupportedType): definition is ZodObject<ZodRawShape> {\n    return definition._def.typeName === \"ZodObject\";\n}\n\n/**\n * Convert a Zod field to a Mongoose type\n *\n * @param type The key of the field\n * @param zodField The Zod field to convert\n * @returns The Mongoose type\n */\nfunction convertField<T extends ZodRawShape>(type: string, zodField: T[Extract<keyof T, string>]) {\n    const unwrappedData = unwrapType(zodField);\n    let coreType;\n    switch (unwrappedData.definition._def.typeName) {\n        case \"ZodString\":\n            coreType = String;\n            break;\n        case \"ZodNumber\":\n            coreType = Number;\n            break;\n        case \"ZodBoolean\":\n            coreType = Boolean;\n            break;\n        case \"ZodDate\":\n            coreType = Date;\n            break;\n        case \"ZodObject\":\n            break;\n        case \"ZodUnion\":\n            coreType = {};\n            break;\n        default:\n            throw new Error(`Unsupported type: ${type}`);\n    }\n    if (isZodObject(unwrappedData.definition)) {\n        coreType = createSchema(unwrappedData.definition);\n    }\n\n    if (!unwrappedData.defaultValue) {\n        return coreType;\n    }\n    return {\n        type: coreType,\n        default: unwrappedData.defaultValue,\n    };\n}\n\n/**\n * Takes a complex type and returns the inner type definition along with the default if present.\n *\n * @param data The type data to unwrap.\n * @returns The inner type data along with the default if present.\n */\nfunction unwrapType(data: SupportedType): { definition: SupportedType; optional: boolean; defaultValue?: unknown } {\n    let definition = data;\n    const optional = false;\n    let defaultValue = undefined;\n    while (\"innerType\" in definition._def) {\n        if (\"defaultValue\" in definition._def) {\n            defaultValue = definition._def.defaultValue();\n        }\n        definition = definition._def.innerType;\n    }\n    return { definition, optional, defaultValue };\n}\n"],"mappings":"0jBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GACA,IAAAI,EAA0B,yBAkBnB,SAASF,EACZG,EACAC,EACAC,EAC+F,CAC/F,IAAMC,EAA4C,CAAC,EACnD,QAAWC,KAAOJ,EAAU,MAAO,CAC/B,IAAMK,EAAWL,EAAU,MAAMI,CAAG,EACpCD,EAAeC,CAAG,EAAIE,EAAaF,EAAKC,CAAQ,CACpD,CACA,IAAME,EAAS,IAAa,SAAOJ,CAAc,EACjD,MAAI,CAACD,GAAc,CAACD,EAAkBM,EAC/B,CAAE,OAAAA,EAAQ,MAAOL,EAAW,MAAiCD,EAAWM,CAAM,CAAE,CAC3F,CAQA,SAASC,EAAYC,EAAiE,CAClF,OAAOA,EAAW,KAAK,WAAa,WACxC,CASA,SAASH,EAAoCI,EAAcL,EAAuC,CAC9F,IAAMM,EAAgBC,EAAWP,CAAQ,EACrCQ,EACJ,OAAQF,EAAc,WAAW,KAAK,SAAU,CAC5C,IAAK,YACDE,EAAW,OACX,MACJ,IAAK,YACDA,EAAW,OACX,MACJ,IAAK,aACDA,EAAW,QACX,MACJ,IAAK,UACDA,EAAW,KACX,MACJ,IAAK,YACD,MACJ,IAAK,WACDA,EAAW,CAAC,EACZ,MACJ,QACI,MAAM,IAAI,MAAM,qBAAqBH,CAAI,EAAE,CACnD,CAKA,OAJIF,EAAYG,EAAc,UAAU,IACpCE,EAAWhB,EAAac,EAAc,UAAU,GAG/CA,EAAc,aAGZ,CACH,KAAME,EACN,QAASF,EAAc,YAC3B,EALWE,CAMf,CAQA,SAASD,EAAWE,EAA+F,CAC/G,IAAIL,EAAaK,EACXC,EAAW,GACbC,EACJ,KAAO,cAAeP,EAAW,MACzB,iBAAkBA,EAAW,OAC7BO,EAAeP,EAAW,KAAK,aAAa,GAEhDA,EAAaA,EAAW,KAAK,UAEjC,MAAO,CAAE,WAAAA,EAAY,SAAAM,EAAU,aAAAC,CAAa,CAChD","names":["src_exports","__export","createSchema","__toCommonJS","Mongoose","zodObject","modelName","connection","convertedShape","key","zodField","convertField","schema","isZodObject","definition","type","unwrappedData","unwrapType","coreType","data","optional","defaultValue"]}

package/dist/index.js

@@ -0,0 +1,2 @@
+import*as i from"mongoose";function c(t,o,n){let e={};for(let d in t.shape){let r=t.shape[d];e[d]=p(d,r)}let a=new i.Schema(e);return!n||!o?a:{schema:a,model:n.model(o,a)}}function f(t){return t._def.typeName==="ZodObject"}function p(t,o){let n=s(o),e;switch(n.definition._def.typeName){case"ZodString":e=String;break;case"ZodNumber":e=Number;break;case"ZodBoolean":e=Boolean;break;case"ZodDate":e=Date;break;case"ZodObject":break;case"ZodUnion":e={};break;default:throw new Error(`Unsupported type: ${t}`)}return f(n.definition)&&(e=c(n.definition)),n.defaultValue?{type:e,default:n.defaultValue}:e}function s(t){let o=t,n=!1,e;for(;"innerType"in o._def;)"defaultValue"in o._def&&(e=o._def.defaultValue()),o=o._def.innerType;return{definition:o,optional:n,defaultValue:e}}export{c as createSchema};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { z, ZodObject, ZodRawShape } from \"zod\";\nimport * as Mongoose from \"mongoose\";\nimport { SchemaDefinition } from \"mongoose\";\nimport { SupportedType } from \"./types\";\n\nexport function createSchema<T extends ZodRawShape>(\n    zodObject: ZodObject<T>,\n    modelName: string,\n    connection: Mongoose.Connection,\n): { schema: Mongoose.Schema; model: Mongoose.Model<z.infer<typeof zodObject>> };\nexport function createSchema<T extends ZodRawShape>(zodObject: ZodObject<T>): Mongoose.Schema;\n/**\n * Create a Mongoose schema from a Zod shape\n *\n * @param zodObject The Zod shape to create the schema from\n * @param modelName The unique name to assign to the model\n * @param connection The Mongoose connection to create the model from\n * @returns The Mongoose schema\n */\nexport function createSchema<T extends ZodRawShape>(\n    zodObject: ZodObject<T>,\n    modelName?: string,\n    connection?: Mongoose.Connection,\n): Mongoose.Schema | { schema: Mongoose.Schema; model: Mongoose.Model<z.infer<typeof zodObject>> } {\n    const convertedShape: Partial<SchemaDefinition> = {};\n    for (const key in zodObject.shape) {\n        const zodField = zodObject.shape[key];\n        convertedShape[key] = convertField(key, zodField);\n    }\n    const schema = new Mongoose.Schema(convertedShape);\n    if (!connection || !modelName) return schema;\n    return { schema, model: connection.model<z.infer<typeof zodObject>>(modelName, schema) };\n}\n\n/**\n * Check if a Zod definition is an object\n *\n * @param definition The Zod definition to check\n * @returns Whether the definition is an object\n */\nfunction isZodObject(definition: SupportedType): definition is ZodObject<ZodRawShape> {\n    return definition._def.typeName === \"ZodObject\";\n}\n\n/**\n * Convert a Zod field to a Mongoose type\n *\n * @param type The key of the field\n * @param zodField The Zod field to convert\n * @returns The Mongoose type\n */\nfunction convertField<T extends ZodRawShape>(type: string, zodField: T[Extract<keyof T, string>]) {\n    const unwrappedData = unwrapType(zodField);\n    let coreType;\n    switch (unwrappedData.definition._def.typeName) {\n        case \"ZodString\":\n            coreType = String;\n            break;\n        case \"ZodNumber\":\n            coreType = Number;\n            break;\n        case \"ZodBoolean\":\n            coreType = Boolean;\n            break;\n        case \"ZodDate\":\n            coreType = Date;\n            break;\n        case \"ZodObject\":\n            break;\n        case \"ZodUnion\":\n            coreType = {};\n            break;\n        default:\n            throw new Error(`Unsupported type: ${type}`);\n    }\n    if (isZodObject(unwrappedData.definition)) {\n        coreType = createSchema(unwrappedData.definition);\n    }\n\n    if (!unwrappedData.defaultValue) {\n        return coreType;\n    }\n    return {\n        type: coreType,\n        default: unwrappedData.defaultValue,\n    };\n}\n\n/**\n * Takes a complex type and returns the inner type definition along with the default if present.\n *\n * @param data The type data to unwrap.\n * @returns The inner type data along with the default if present.\n */\nfunction unwrapType(data: SupportedType): { definition: SupportedType; optional: boolean; defaultValue?: unknown } {\n    let definition = data;\n    const optional = false;\n    let defaultValue = undefined;\n    while (\"innerType\" in definition._def) {\n        if (\"defaultValue\" in definition._def) {\n            defaultValue = definition._def.defaultValue();\n        }\n        definition = definition._def.innerType;\n    }\n    return { definition, optional, defaultValue };\n}\n"],"mappings":"AACA,UAAYA,MAAc,WAkBnB,SAASC,EACZC,EACAC,EACAC,EAC+F,CAC/F,IAAMC,EAA4C,CAAC,EACnD,QAAWC,KAAOJ,EAAU,MAAO,CAC/B,IAAMK,EAAWL,EAAU,MAAMI,CAAG,EACpCD,EAAeC,CAAG,EAAIE,EAAaF,EAAKC,CAAQ,CACpD,CACA,IAAME,EAAS,IAAa,SAAOJ,CAAc,EACjD,MAAI,CAACD,GAAc,CAACD,EAAkBM,EAC/B,CAAE,OAAAA,EAAQ,MAAOL,EAAW,MAAiCD,EAAWM,CAAM,CAAE,CAC3F,CAQA,SAASC,EAAYC,EAAiE,CAClF,OAAOA,EAAW,KAAK,WAAa,WACxC,CASA,SAASH,EAAoCI,EAAcL,EAAuC,CAC9F,IAAMM,EAAgBC,EAAWP,CAAQ,EACrCQ,EACJ,OAAQF,EAAc,WAAW,KAAK,SAAU,CAC5C,IAAK,YACDE,EAAW,OACX,MACJ,IAAK,YACDA,EAAW,OACX,MACJ,IAAK,aACDA,EAAW,QACX,MACJ,IAAK,UACDA,EAAW,KACX,MACJ,IAAK,YACD,MACJ,IAAK,WACDA,EAAW,CAAC,EACZ,MACJ,QACI,MAAM,IAAI,MAAM,qBAAqBH,CAAI,EAAE,CACnD,CAKA,OAJIF,EAAYG,EAAc,UAAU,IACpCE,EAAWd,EAAaY,EAAc,UAAU,GAG/CA,EAAc,aAGZ,CACH,KAAME,EACN,QAASF,EAAc,YAC3B,EALWE,CAMf,CAQA,SAASD,EAAWE,EAA+F,CAC/G,IAAIL,EAAaK,EACXC,EAAW,GACbC,EACJ,KAAO,cAAeP,EAAW,MACzB,iBAAkBA,EAAW,OAC7BO,EAAeP,EAAW,KAAK,aAAa,GAEhDA,EAAaA,EAAW,KAAK,UAEjC,MAAO,CAAE,WAAAA,EAAY,SAAAM,EAAU,aAAAC,CAAa,CAChD","names":["Mongoose","createSchema","zodObject","modelName","connection","convertedShape","key","zodField","convertField","schema","isZodObject","definition","type","unwrappedData","unwrapType","coreType","data","optional","defaultValue"]}

package/dist/src/index.d.cts

@@ -0,0 +1 @@
+export { createSchema } from '../_tsup-dts-rollup';

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { createSchema } from '../_tsup-dts-rollup';

package/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "@mirite/zod-to-mongoose",
+    "version": "0.0.1",
+    "description": "Package for creating mongoose schemas out of Zod schemas for type safety, and removing duplicate effort.",
+    "types": "dist/_tsup-dts-rollup.d.ts",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mirite/zod-to-mongoose.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "author": {
+        "name": "Jesse Conner",
+        "email": "me@jesseconner.ca",
+        "url": "https://jesseconner.ca"
+    },
+    "keywords": [
+        "zod",
+        "mongoose",
+        "schema",
+        "type",
+        "type-safe"
+    ],
+    "issues": "https://github.com/mirite/zod-to-mongoose/issues",
+    "license": "MIT",
+    "scripts": {
+        "build": "tsup",
+        "test": "jest --coverage",
+        "lint": "eslint . --fix --ignore-path .gitignore",
+        "format": "prettier --write . --ignore-path .gitignore",
+        "release": "yarn build && npm publish"
+    },
+    "devDependencies": {
+        "@types/eslint": "^8.56.2",
+        "@types/jest": "^29.5.12",
+        "@typescript-eslint/eslint-plugin": "^7.0.1",
+        "@typescript-eslint/parser": "^7.0.1",
+        "eslint": "^8.56.0",
+        "eslint-plugin-jsdoc": "^48.0.6",
+        "jest": "^29.7.0",
+        "prettier": "^3.2.5",
+        "prettier-plugin-jsdoc": "^1.3.0",
+        "ts-jest": "^29.1.2",
+        "tsup": "^8.0.2",
+        "typescript": "^5.3.3"
+    },
+    "packageManager": "yarn@4.1.0",
+    "dependencies": {
+        "@microsoft/api-extractor": "^7.40.1",
+        "mongoose": "^8.1.2",
+        "zod": "^3.22.4"
+    }
+}

package/readme.md

@@ -0,0 +1,67 @@
+# Zod to Mongoose
+
+This is a package for generating Mongoose schemas from Zod schemas. The goal is to improve type safety and reduce the amount of code that needs to be written when working with Mongoose.
+
+## Installation
+
+```bash
+yarn add @mirite/zod-to-mongoose
+```
+
+## Usage
+
+### Basic
+
+Passing in a Zod schema will return a Mongoose schema.
+```typescript
+import { createSchema } from "@mirite/zod-to-mongoose";
+
+const schema = createSchema(
+    z.object({
+        name: z.string().optional().default("Bob"),
+        age: z.number().default(3).optional(),
+        isHappy: z.boolean().optional(),
+        birthday: z.date().default(new Date()),
+    }),
+);
+
+const model = mongoose.model("modelName", schema);
+const result = await model.create({
+    isHappy: true,
+    birthday: new Date("1980-01-01"),
+});
+````
+
+### Advanced
+If you pass a connection, the model will be created, 4registered with the connection, and returned for use.
+```typescript
+import { createSchema } from "@mirite/zod-to-mongoose";
+
+
+const model = createSchema(
+    z.object({
+        name: z.string().optional().default("Bob"),
+        age: z.number().default(3).optional(),
+        isHappy: z.boolean().optional(),
+        birthday: z.date().default(new Date()),
+    }),
+    "modelName", // The unique name to give the model
+    connection, // Mongoose connection
+);
+
+const result = await model.create({
+    isHappy: true,
+    birthday: new Date("1980-01-01"),
+});
+```
+
+### Caveats
+Only a subset of Zod types are supported. The following types are supported:
+- `z.string()`
+- `z.number()`
+- `z.boolean()`
+- `z.date()`
+- `z.object()` (Nested objects are supported)
+- `z.union()` (Type safety is not guaranteed)
+
+Additionally, no additional validation is performed on the Mongoose schema.