use-zod-default 1.0.1

package/README.md

@@ -0,0 +1,126 @@
+# use-zod-default
+
+Effortlessly create default instances from Zod schemas with intelligent type inference and flexible customization.
+
+## 🚀 Features
+
+- 📦 Create default instances from Zod schemas
+- 🧠 Intelligent type inference
+- 🛠 Support for nested objects, arrays, and complex types
+- 🎛 Customizable with partial source objects
+- 🔄 Handles discriminated unions and regular unions
+- 🏷 Full TypeScript support
+
+## 📦 Installation
+
+```bash
+npm install use-zod-default
+```
+
+or
+
+```bash
+yarn add use-zod-default
+```
+
+## 🛠 Usage
+
+```typescript
+import { z } from 'zod';
+import defaultInstance from 'use-zod-default';
+
+// Define your Zod schema
+const userSchema = z.object({
+	name: z.string(),
+	age: z.number(),
+	isActive: z.boolean(),
+	roles: z.array(z.string()),
+	settings: z.object({
+		theme: z.enum(['light', 'dark']),
+		notifications: z.boolean()
+	})
+});
+
+// Create a default instance
+const defaultUser = defaultInstance(userSchema);
+
+console.log(defaultUser);
+// Output:
+// {
+//   name: '',
+//   age: 0,
+//   isActive: false,
+//   roles: [],
+//   settings: {
+//     theme: 'light',
+//     notifications: false
+//   }
+// }
+```
+
+### With Partial Source
+
+You can provide a partial source object to override default values:
+
+```typescript
+const partialUser = {
+	name: 'John Doe',
+	settings: {
+		theme: 'dark'
+	}
+};
+
+const userWithCustomValues = defaultInstance(userSchema, partialUser);
+
+console.log(userWithCustomValues);
+// Output:
+// {
+//   name: 'John Doe',
+//   age: 0,
+//   isActive: false,
+//   roles: [],
+//   settings: {
+//     theme: 'dark',
+//     notifications: false
+//   }
+// }
+```
+
+## 🧩 Advanced Usage
+
+### Discriminated Unions
+
+```typescript
+const resultSchema = z.discriminatedUnion('status', [
+	z.object({ status: z.literal('success'), data: z.string() }),
+	z.object({ status: z.literal('error'), message: z.string() })
+]);
+
+const defaultResult = defaultInstance(resultSchema);
+console.log(defaultResult); // { status: 'success', data: '' }
+```
+
+### Regular Unions
+
+```typescript
+const dataSchema = z.union([
+	z.object({ type: z.literal('string'), value: z.string() }),
+	z.object({ type: z.literal('number'), value: z.number() }),
+	z.string()
+]);
+
+const defaultData = defaultInstance(dataSchema);
+console.log(defaultData); // { type: 'string', value: '' }
+```
+
+## 📝 License
+
+MIT © [Felipe Rohde](mailto:feliperohdee@gmail.com)
+
+## 👨‍💻 Author
+
+**Felipe Rohde**
+
+- Twitter: [@felipe_rohde](https://twitter.com/felipe_rohde)
+- Github: [@feliperohdee](https://github.com/feliperohdee)
+- Email: feliperohdee@gmail.com

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+declare const defaultInstance: <T extends z.ZodSchema>(schema: T, source?: any) => z.output<T>;
+export default defaultInstance;

package/dist/index.js

@@ -0,0 +1,234 @@
+import { z } from 'zod';
+const defaultInstance = (schema, source = {}) => {
+    const getDefaultValue = (schema) => {
+        if (schema instanceof z.ZodDefault) {
+            return schema._def.defaultValue();
+        }
+        if (schema instanceof z.ZodAny) {
+            return undefined;
+        }
+        if (schema instanceof z.ZodArray) {
+            return [];
+        }
+        if (schema instanceof z.ZodBoolean) {
+            return false;
+        }
+        if (schema instanceof z.ZodDate) {
+            return null;
+        }
+        if (schema instanceof z.ZodDiscriminatedUnion) {
+            return defaultInstance(schema.options[0]);
+        }
+        if (schema instanceof z.ZodEffects) {
+            return getDefaultValue(schema.innerType());
+        }
+        if (schema instanceof z.ZodEnum) {
+            return schema.options[0];
+        }
+        if (schema instanceof z.ZodFunction) {
+            return () => null;
+        }
+        if (schema instanceof z.ZodIntersection) {
+            return defaultInstance(schema._def.left, source);
+        }
+        if (schema instanceof z.ZodLiteral) {
+            return schema.value;
+        }
+        if (schema instanceof z.ZodMap) {
+            return new Map();
+        }
+        if (schema instanceof z.ZodNativeEnum) {
+            const keys = Object.keys(schema._def.values);
+            return schema._def.values[keys[0]];
+        }
+        if (schema instanceof z.ZodNaN) {
+            return NaN;
+        }
+        if (schema instanceof z.ZodNever) {
+            return undefined;
+        }
+        if (schema instanceof z.ZodNull) {
+            return null;
+        }
+        if (schema instanceof z.ZodNullable) {
+            return null;
+        }
+        if (schema instanceof z.ZodNumber || schema instanceof z.ZodBigInt) {
+            return schema.minValue ?? 0;
+        }
+        if (schema instanceof z.ZodObject) {
+            return defaultInstance(schema, {});
+        }
+        if (schema instanceof z.ZodPipeline) {
+            if (!('out' in schema._def)) {
+                return undefined;
+            }
+            return getDefaultValue(schema._def.out);
+        }
+        if (schema instanceof z.ZodPromise) {
+            return Promise.resolve(getDefaultValue(schema.unwrap()));
+        }
+        if (schema instanceof z.ZodRecord) {
+            return {};
+        }
+        if (schema instanceof z.ZodSet) {
+            return new Set();
+        }
+        if (schema instanceof z.ZodString) {
+            return '';
+        }
+        if (schema instanceof z.ZodSymbol) {
+            return '';
+        }
+        if (schema instanceof z.ZodTuple) {
+            return [];
+        }
+        if (schema instanceof z.ZodUnion) {
+            return getDefaultValue(schema.options[0]);
+        }
+        if (schema instanceof z.ZodUnknown) {
+            return undefined;
+        }
+        if (schema instanceof z.ZodUndefined) {
+            return undefined;
+        }
+        if (schema instanceof z.ZodVoid) {
+            return undefined;
+        }
+        if (schema._def && schema._def.innerType) {
+            return getDefaultValue(schema._def.innerType);
+        }
+        return undefined;
+    };
+    const processArray = (schema, source) => {
+        if (!Array.isArray(source)) {
+            return [];
+        }
+        const elementSchema = schema.element;
+        return source.map(item => {
+            return processValue(elementSchema, item);
+        });
+    };
+    const processDiscriminatedUnion = (schema, source) => {
+        if (typeof source !== 'object' || source === null) {
+            return getDefaultValue(schema);
+        }
+        const discriminator = schema.discriminator;
+        const discriminatorValue = source[discriminator];
+        const matchingSchema = schema.options.find(option => {
+            return option.shape[discriminator] instanceof z.ZodLiteral && option.shape[discriminator].value === discriminatorValue;
+        });
+        if (!matchingSchema) {
+            // If no matching schema is found, use the first option as default
+            return processObject(schema.options[0], source);
+        }
+        return processObject(matchingSchema, source);
+    };
+    const processValue = (schema, value) => {
+        if (schema instanceof z.ZodObject) {
+            return processObject(schema, value);
+        }
+        else if (schema instanceof z.ZodArray) {
+            return processArray(schema, value);
+        }
+        else if (schema instanceof z.ZodDiscriminatedUnion) {
+            return processDiscriminatedUnion(schema, value);
+        }
+        else if (schema instanceof z.ZodUnion) {
+            return processUnion(schema, value);
+        }
+        else if (schema instanceof z.ZodBoolean) {
+            return typeof value === 'boolean' ? value : false;
+        }
+        else if (schema instanceof z.ZodMap) {
+            return processMap(schema, value);
+        }
+        else if (schema instanceof z.ZodNumber) {
+            return typeof value === 'number' ? value : (schema.minValue ?? 0);
+        }
+        else if (schema instanceof z.ZodRecord) {
+            return processRecord(schema, value);
+        }
+        else if (schema instanceof z.ZodSet) {
+            return processSet(schema, value);
+        }
+        else if (schema instanceof z.ZodString) {
+            return typeof value === 'string' ? value : '';
+        }
+        else if (schema instanceof z.ZodNullable) {
+            return value === null ? null : processValue(schema.unwrap(), value);
+        }
+        else {
+            return value;
+        }
+    };
+    const processMap = (schema, source) => {
+        if (!(source instanceof Map)) {
+            return new Map();
+        }
+        const valueSchema = schema._def.valueType;
+        const result = new Map();
+        source.forEach((value, key) => {
+            result.set(key, processValue(valueSchema, value));
+        });
+        return result;
+    };
+    const processObject = (schema, source) => {
+        const result = {};
+        const shape = schema.shape;
+        for (const [key, fieldSchema] of Object.entries(shape)) {
+            if (key in source) {
+                result[key] = processValue(fieldSchema, source[key]);
+            }
+            else {
+                result[key] = getDefaultValue(fieldSchema);
+            }
+        }
+        return result;
+    };
+    const processRecord = (schema, source) => {
+        if (typeof source !== 'object' || source === null) {
+            return {};
+        }
+        const valueSchema = schema._def.valueType;
+        const result = {};
+        for (const key in source) {
+            result[key] = processValue(valueSchema, source[key]);
+        }
+        return result;
+    };
+    const processSet = (schema, source) => {
+        if (!(source instanceof Set)) {
+            return new Set();
+        }
+        const valueSchema = schema._def.valueType;
+        const result = new Set();
+        for (const value of source) {
+            result.add(processValue(valueSchema, value));
+        }
+        return result;
+    };
+    const processUnion = (schema, source) => {
+        for (const optionSchema of schema._def.options) {
+            try {
+                const parsed = optionSchema.safeParse(source);
+                if (parsed.success) {
+                    return processValue(optionSchema, source);
+                }
+            }
+            catch {
+                // If parsing fails, try the next option
+            }
+        }
+        // If no option matches, return the default value of the first option
+        return getDefaultValue(schema._def.options[0]);
+    };
+    if (schema instanceof z.ZodDiscriminatedUnion) {
+        return processDiscriminatedUnion(schema, source);
+    }
+    if (schema instanceof z.ZodEffects) {
+        schema = schema.innerType();
+    }
+    return processValue(schema, source);
+};
+export default defaultInstance;

package/package.json

@@ -0,0 +1,29 @@
+{
+	"dependencies": {
+		"zod": "^3.23.8"
+	},
+	"devDependencies": {
+		"@types/lodash": "^4.17.12",
+		"@types/node": "^22.7.7",
+		"prettier": "^3.3.3",
+		"typescript": "^5.6.3",
+		"vitest": "^2.1.3"
+	},
+	"files": [
+		"dist"
+	],
+	"license": "MIT",
+	"main": "dist/index.js",
+	"name": "use-zod-default",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/feliperohdee/use-zod-default"
+	},
+	"scripts": {
+		"build": "rm -rf dist && tsc -p tsconfig.json",
+		"lint": "prettier --write . && yarn tsc",
+		"npm-publish": "yarn test --run && yarn build && yarn version --patch --no-git-tag-version && yarn publish --non-interactive",
+		"test": "vitest"
+	},
+	"version": "1.0.1"
+}