@geekmidas/schema 1.0.4 → 10.0.0-alpha.0

package/README.md

@@ -73,7 +73,7 @@ import { z } from 'zod';
 // Define a schema
 const userSchema = z.object({
   id: z.string(),
-  email: z.string().email(),
+  email: z.email(),
   age: z.number().min(18),
   role: z.enum(['admin', 'user'])
 });
@@ -130,7 +130,7 @@ import { z } from 'zod';
 const schemas = {
   user: z.object({
     id: z.string(),
-    email: z.string().email()
+    email: z.email()
   }),
   post: z.object({
     id: z.string(),
@@ -237,7 +237,7 @@ import { z } from 'zod';
 const createUserEndpoint = {
   body: z.object({
     name: z.string().min(1),
-    email: z.string().email(),
+    email: z.email(),
     age: z.number().int().min(18)
   }),
   response: z.object({
@@ -272,7 +272,7 @@ import { z } from 'zod';
 
 const userSchema = z.object({
   id: z.string(),
-  email: z.string().email()
+  email: z.email()
 });
 
 type User = InferStandardSchema<typeof userSchema>;
@@ -296,11 +296,11 @@ if (isUser(data)) {
 This package is used internally by `@geekmidas/constructs` for type-safe endpoint validation:
 
 ```typescript
-import { e } from '@geekmidas/constructs/endpoints';
+import { api } from '../constructs/api';
 import { z } from 'zod';
 
 // The constructs package uses InferStandardSchema internally
-const endpoint = e
+const endpoint = api
   .post('/users')
   .body(z.object({ name: z.string() }))
   .output(z.object({ id: z.string() }))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/schema",
-  "version": "1.0.4",
+  "version": "10.0.0-alpha.0",
   "type": "module",
   "exports": {
     ".": {
@@ -44,6 +44,9 @@
       }
     }
   },
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/geekmidas/toolbox"

package/CHANGELOG.md

@@ -1,45 +0,0 @@
-# @geekmidas/schema
-
-## 1.0.4
-
-### Patch Changes
-
-- 🐛 [#11](https://github.com/geekmidas/toolbox/pull/11) [`40f4dc0`](https://github.com/geekmidas/toolbox/commit/40f4dc095911b2223a255029d8f776caf7781309) Thanks [@geekmidas](https://github.com/geekmidas)! - Patch release across all packages to realign published versions with the
-  registry. The previous release only published the four packages that had
-  version bumps; the remaining packages failed with "cannot publish over the
-  previously published versions" because their versions were unchanged.
-
-## 1.0.3
-
-### Patch Changes
-
-- [#7](https://github.com/geekmidas/toolbox/pull/7) [`e0d06b3`](https://github.com/geekmidas/toolbox/commit/e0d06b38dfd275758f7955f5754900ab78779302) Thanks [@geekmidas](https://github.com/geekmidas)! - feat(constructs): allow endpoint handlers to return the output schema's input type
-
-  Endpoint handlers previously had to return the output schema's _parsed_ type
-  (`InferStandardSchema`). When an output schema coerces its value (e.g. a `Date`
-  serialized to an ISO `string`, or an applied default), that forced handlers to
-  pre-coerce values themselves even though the schema would do it on the way out.
-
-  A new `InferStandardSchemaInput` type is added to `@geekmidas/schema`, exposing a
-  Standard Schema's _input_ type (`StandardSchemaV1.InferInput`). `Endpoint`'s
-  handler return type now uses it, so handlers may return the looser pre-coercion
-  input while consumers (`EndpointOutput` and the generated client) still see the
-  narrower parsed output type.
-
-## 1.0.2
-
-### Patch Changes
-
-- 🐛 [`d70c6c0`](https://github.com/geekmidas/toolbox/commit/d70c6c0aeb8a79da2473ac77dbd8255a4a2f5651) Thanks [@geekmidas](https://github.com/geekmidas)! - Fix `package.json` exports so TypeScript declarations resolve correctly under NodeNext/Bundler module resolution. Each subpath export now nests `types` inside its `import`/`require` condition, pointing at the `.d.mts` and `.d.cts` files that `tsdown` actually emits (previously the exports referenced non-existent `.d.ts` files, causing type-resolution failures for consumers). Both ESM (`.mjs`) and CJS (`.cjs`) runtime entry points are preserved. Additionally, `@geekmidas/ui` had `import` paths pointing at `.js` files that were never emitted — those are corrected to `.mjs`.
-
-## 1.0.1
-
-### Patch Changes
-
-- 🐛 [`aeba918`](https://github.com/geekmidas/toolbox/commit/aeba918fc258f6ccdb96b8273b2bc01bd2190553) Thanks [@geekmidas](https://github.com/geekmidas)! - Fix schema, openapi generation and events testkit
-
-## 1.0.0
-
-### Major Changes
-
-- [`ff7b115`](https://github.com/geekmidas/toolbox/commit/ff7b11599f60f84ac6cdc73714c853ecf786b2e8) Thanks [@geekmidas](https://github.com/geekmidas)! - Version 1 Stable release

package/src/__benchmarks__/conversion.bench.ts

@@ -1,88 +0,0 @@
-import { bench, describe } from 'vitest';
-import { z } from 'zod';
-import { convertStandardSchemaToJsonSchema } from '../conversion';
-
-describe('Schema Conversion - Simple', () => {
-	const simpleSchema = z.object({
-		id: z.string(),
-		name: z.string(),
-		email: z.string().email(),
-	});
-
-	bench('simple object schema', async () => {
-		await convertStandardSchemaToJsonSchema(simpleSchema);
-	});
-
-	const primitiveSchema = z.string();
-	bench('primitive string schema', async () => {
-		await convertStandardSchemaToJsonSchema(primitiveSchema);
-	});
-
-	const arraySchema = z.array(z.string());
-	bench('array of strings schema', async () => {
-		await convertStandardSchemaToJsonSchema(arraySchema);
-	});
-});
-
-describe('Schema Conversion - Complex', () => {
-	const nestedSchema = z.object({
-		user: z.object({
-			profile: z.object({
-				name: z.string(),
-				bio: z.string().optional(),
-				settings: z.record(z.string(), z.unknown()),
-			}),
-			contacts: z.array(
-				z.object({
-					type: z.enum(['email', 'phone']),
-					value: z.string(),
-				}),
-			),
-		}),
-		metadata: z.object({
-			createdAt: z.string(),
-			updatedAt: z.string(),
-		}),
-	});
-
-	bench('deeply nested schema', async () => {
-		await convertStandardSchemaToJsonSchema(nestedSchema);
-	});
-
-	const unionSchema = z.discriminatedUnion('type', [
-		z.object({ type: z.literal('text'), content: z.string() }),
-		z.object({ type: z.literal('image'), url: z.string() }),
-		z.object({
-			type: z.literal('video'),
-			url: z.string(),
-			duration: z.number(),
-		}),
-	]);
-
-	bench('discriminated union schema', async () => {
-		await convertStandardSchemaToJsonSchema(unionSchema);
-	});
-
-	const largeSchema = z.object(
-		Object.fromEntries(
-			Array.from({ length: 50 }, (_, i) => [`field${i}`, z.string()]),
-		),
-	);
-
-	bench('large object (50 fields)', async () => {
-		await convertStandardSchemaToJsonSchema(largeSchema);
-	});
-});
-
-describe('Schema Conversion - With Refinements', () => {
-	const refinedSchema = z.object({
-		age: z.number().min(0).max(150),
-		email: z.string().email(),
-		url: z.string().url(),
-		uuid: z.string().uuid(),
-	});
-
-	bench('schema with refinements', async () => {
-		await convertStandardSchemaToJsonSchema(refinedSchema);
-	});
-});

package/src/__tests__/conversion.spec.ts

@@ -1,502 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod/v4';
-import {
-	convertSchemaWithComponents,
-	convertStandardSchemaToJsonSchema,
-	getSchemaMetadata,
-	getZodMetadata,
-	SchemaVendor,
-} from '../conversion';
-import { createComponentCollector } from '../openapi';
-
-describe('Schema Conversion', () => {
-	describe('convertStandardSchemaToJsonSchema', () => {
-		it('should convert Zod object schema to JSON Schema', async () => {
-			const schema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('type', 'object');
-			expect(jsonSchema).toHaveProperty('properties');
-			expect(jsonSchema.properties).toHaveProperty('name');
-			expect(jsonSchema.properties).toHaveProperty('age');
-		});
-
-		it('should return undefined for undefined schema', async () => {
-			const jsonSchema = await convertStandardSchemaToJsonSchema(undefined);
-
-			expect(jsonSchema).toBeUndefined();
-		});
-
-		it('should convert Zod string schema', async () => {
-			const schema = z.string();
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('type', 'string');
-		});
-
-		it('should convert Zod number schema', async () => {
-			const schema = z.number();
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('type', 'number');
-		});
-
-		it('should convert Zod array schema', async () => {
-			const schema = z.array(z.string());
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('type', 'array');
-			expect(jsonSchema).toHaveProperty('items');
-		});
-
-		it('should convert Zod enum schema', async () => {
-			const schema = z.enum(['active', 'inactive', 'pending']);
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('enum');
-			expect(jsonSchema.enum).toEqual(['active', 'inactive', 'pending']);
-		});
-
-		it('should convert nested object schema', async () => {
-			const schema = z.object({
-				user: z.object({
-					name: z.string(),
-					age: z.number(),
-				}),
-			});
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema.type).toBe('object');
-			expect(jsonSchema.properties).toHaveProperty('user');
-			expect(jsonSchema.properties.user).toHaveProperty('type', 'object');
-		});
-
-		it('should handle optional fields', async () => {
-			const schema = z.object({
-				required: z.string(),
-				optional: z.string().optional(),
-			});
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema.required).toContain('required');
-			expect(jsonSchema.required).not.toContain('optional');
-		});
-
-		it('should extract and convert $defs with component collector', async () => {
-			const userSchema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			const schema = z.object({
-				user: userSchema,
-			});
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				schema,
-				collector,
-			);
-
-			expect(jsonSchema).toBeDefined();
-			// $defs should be removed from main schema
-			expect(jsonSchema).not.toHaveProperty('$defs');
-		});
-
-		it('should throw error for unsupported vendor', async () => {
-			const invalidSchema = {
-				'~standard': {
-					vendor: 'unsupported' as any,
-					validate: vi.fn(),
-				},
-			};
-
-			await expect(
-				convertStandardSchemaToJsonSchema(invalidSchema as any),
-			).rejects.toThrow(/Unsupported or missing vendor/);
-		});
-
-		it('should throw error for missing vendor', async () => {
-			const invalidSchema = {
-				'~standard': {
-					vendor: undefined,
-					validate: vi.fn(),
-				},
-			};
-
-			await expect(
-				convertStandardSchemaToJsonSchema(invalidSchema as any),
-			).rejects.toThrow(/Unsupported or missing vendor/);
-		});
-
-		it('should handle schema with descriptions', async () => {
-			const schema = z
-				.object({
-					name: z.string(),
-				})
-				.describe('User information');
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema.description).toBe('User information');
-		});
-
-		it('should handle union types', async () => {
-			const schema = z.union([z.string(), z.number()]);
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('anyOf');
-		});
-	});
-
-	describe('getZodMetadata', () => {
-		it('should return undefined for non-Zod objects', async () => {
-			const schema = z.string();
-
-			const metadata = await getZodMetadata(schema);
-
-			expect(metadata).toBeUndefined();
-		});
-
-		it('should get metadata from Zod object with meta', async () => {
-			const schema = z.object({ name: z.string() }).meta({ id: 'User' });
-
-			const metadata = await getZodMetadata(schema);
-
-			expect(metadata).toEqual({ id: 'User' });
-		});
-
-		it('should return undefined for Zod object without meta', async () => {
-			const schema = z.object({ name: z.string() });
-
-			const metadata = await getZodMetadata(schema);
-
-			// Returns undefined when no meta is set
-			expect(metadata).toBeUndefined();
-		});
-	});
-
-	describe('getSchemaMetadata', () => {
-		it('should get metadata for Zod schema', async () => {
-			const schema = z.object({ name: z.string() }).meta({ id: 'UserMeta' });
-
-			const metadata = await getSchemaMetadata(schema);
-
-			expect(metadata).toEqual({ id: 'UserMeta' });
-		});
-
-		it('should return undefined for non-Zod vendor', async () => {
-			const schema = {
-				'~standard': {
-					vendor: 'valibot',
-					validate: vi.fn(),
-				},
-			};
-
-			const metadata = await getSchemaMetadata(schema as any);
-
-			expect(metadata).toBeUndefined();
-		});
-
-		it('should return undefined for schema without vendor', async () => {
-			const schema = {
-				'~standard': {
-					vendor: undefined,
-					validate: vi.fn(),
-				},
-			};
-
-			const metadata = await getSchemaMetadata(schema as any);
-
-			expect(metadata).toBeUndefined();
-		});
-	});
-
-	describe('convertSchemaWithComponents', () => {
-		it('should convert schema without component collector', async () => {
-			const schema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			const jsonSchema = await convertSchemaWithComponents(schema);
-
-			expect(jsonSchema).toHaveProperty('type', 'object');
-			expect(jsonSchema).toHaveProperty('properties');
-		});
-
-		it('should return undefined for undefined schema', async () => {
-			const jsonSchema = await convertSchemaWithComponents(undefined);
-
-			expect(jsonSchema).toBeUndefined();
-		});
-
-		it('should add schema with ID to component collector', async () => {
-			const schema = z.object({ name: z.string() }).meta({ id: 'UserComp' });
-
-			const collector = createComponentCollector();
-			const result = await convertSchemaWithComponents(schema, collector);
-
-			expect(result).toEqual({ $ref: '#/components/schemas/UserComp' });
-			expect(collector.schemas).toHaveProperty('UserComp');
-			expect(collector.schemas.UserComp).not.toHaveProperty('id');
-		});
-
-		it('should not add schema without ID to component collector', async () => {
-			const schema = z.object({ name: z.string() });
-
-			const collector = createComponentCollector();
-			const result = await convertSchemaWithComponents(schema, collector);
-
-			expect(result).not.toHaveProperty('$ref');
-			expect(Object.keys(collector.schemas)).toHaveLength(0);
-		});
-
-		it('should handle schema with id in JSON Schema', async () => {
-			const schema = z.object({ name: z.string() }).meta({ id: 'Person' });
-
-			const collector = createComponentCollector();
-			const result = await convertSchemaWithComponents(schema, collector);
-
-			expect(result).toEqual({ $ref: '#/components/schemas/Person' });
-			expect(collector.schemas).toHaveProperty('Person');
-		});
-
-		it('should convert multiple schemas with collector', async () => {
-			const schema1 = z.object({ name: z.string() }).meta({ id: 'UserMulti' });
-			const schema2 = z.object({ title: z.string() }).meta({ id: 'PostMulti' });
-
-			const collector = createComponentCollector();
-
-			await convertSchemaWithComponents(schema1, collector);
-			await convertSchemaWithComponents(schema2, collector);
-
-			expect(Object.keys(collector.schemas)).toHaveLength(2);
-			expect(collector.schemas).toHaveProperty('UserMulti');
-			expect(collector.schemas).toHaveProperty('PostMulti');
-		});
-
-		it('should handle nested objects with collector', async () => {
-			const schema = z
-				.object({
-					user: z.object({
-						name: z.string(),
-						profile: z.object({
-							bio: z.string(),
-						}),
-					}),
-				})
-				.meta({ id: 'UserData' });
-
-			const collector = createComponentCollector();
-			const result = await convertSchemaWithComponents(schema, collector);
-
-			expect(result).toEqual({ $ref: '#/components/schemas/UserData' });
-			expect(collector.schemas).toHaveProperty('UserData');
-		});
-	});
-
-	describe('SchemaVendor enum', () => {
-		it('should have zod vendor', () => {
-			expect(SchemaVendor.zod).toBe('zod');
-		});
-
-		it('should have valibot vendor', () => {
-			expect(SchemaVendor.valibot).toBe('valibot');
-		});
-	});
-
-	describe('extractAndConvertDefs edge cases', () => {
-		it('should handle $ref that does not start with #/$defs/', async () => {
-			// Create a schema with a $ref that doesn't use $defs pattern
-			const schema = z.object({
-				name: z.string(),
-			});
-
-			const collector = createComponentCollector();
-			// Add a schema first
-			collector.addSchema('ExternalRef', { type: 'string' });
-
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				schema,
-				collector,
-			);
-
-			// Basic test - the schema should still convert properly
-			expect(jsonSchema).toHaveProperty('type', 'object');
-		});
-
-		it('should process arrays in schema correctly', async () => {
-			const schema = z.object({
-				tags: z.array(z.string()),
-				numbers: z.array(z.number()),
-			});
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				schema,
-				collector,
-			);
-
-			expect(jsonSchema.properties.tags).toHaveProperty('type', 'array');
-			expect(jsonSchema.properties.numbers).toHaveProperty('type', 'array');
-		});
-
-		it('should skip $defs key during processing and extract to components', async () => {
-			// Create a schema that produces $defs in JSON Schema output
-			const addressSchema = z.object({
-				street: z.string(),
-				city: z.string(),
-			});
-
-			const personSchema = z.object({
-				name: z.string(),
-				address: addressSchema,
-			});
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				personSchema,
-				collector,
-			);
-
-			// $defs should be removed from the output
-			expect(jsonSchema).not.toHaveProperty('$defs');
-			expect(jsonSchema).toHaveProperty('type', 'object');
-		});
-
-		it('should handle null/undefined values in schema processing', async () => {
-			const schema = z.object({
-				nullableField: z.string().nullable(),
-				optionalField: z.string().optional(),
-			});
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				schema,
-				collector,
-			);
-
-			expect(jsonSchema).toHaveProperty('properties');
-			expect(jsonSchema.properties).toHaveProperty('nullableField');
-			expect(jsonSchema.properties).toHaveProperty('optionalField');
-		});
-
-		it('should handle deeply nested objects with arrays', async () => {
-			const schema = z.object({
-				users: z.array(
-					z.object({
-						name: z.string(),
-						addresses: z.array(
-							z.object({
-								street: z.string(),
-							}),
-						),
-					}),
-				),
-			});
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				schema,
-				collector,
-			);
-
-			expect(jsonSchema).toHaveProperty('type', 'object');
-			expect(jsonSchema.properties.users).toHaveProperty('type', 'array');
-		});
-
-		it('should handle primitive non-object schema types', async () => {
-			const stringSchema = z.string();
-			const numberSchema = z.number();
-			const booleanSchema = z.boolean();
-
-			const collector = createComponentCollector();
-
-			const stringJson = await convertStandardSchemaToJsonSchema(
-				stringSchema,
-				collector,
-			);
-			const numberJson = await convertStandardSchemaToJsonSchema(
-				numberSchema,
-				collector,
-			);
-			const booleanJson = await convertStandardSchemaToJsonSchema(
-				booleanSchema,
-				collector,
-			);
-
-			expect(stringJson).toMatchObject({ type: 'string' });
-			expect(numberJson).toMatchObject({ type: 'number' });
-			expect(booleanJson).toMatchObject({ type: 'boolean' });
-		});
-
-		it('should handle schema with discriminated unions', async () => {
-			const catSchema = z.object({
-				type: z.literal('cat'),
-				meows: z.boolean(),
-			});
-
-			const dogSchema = z.object({
-				type: z.literal('dog'),
-				barks: z.boolean(),
-			});
-
-			const petSchema = z.discriminatedUnion('type', [catSchema, dogSchema]);
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				petSchema,
-				collector,
-			);
-
-			// Should have oneOf or anyOf for discriminated union
-			expect(
-				jsonSchema.anyOf || jsonSchema.oneOf || jsonSchema.discriminator,
-			).toBeDefined();
-		});
-
-		it('should preserve $ref as-is when not matching $defs pattern', async () => {
-			// Test the extractAndConvertDefs function with a schema that has
-			// $ref not starting with #/$defs/
-			const schema = z.object({
-				name: z.string(),
-			});
-
-			// Without collector, refs should be preserved as-is
-			const jsonSchema = await convertStandardSchemaToJsonSchema(schema);
-
-			expect(jsonSchema).toHaveProperty('type', 'object');
-		});
-
-		it('should convert $defs references to component references with collector', async () => {
-			// Use lazy schema to create a recursive structure that produces $defs
-			const nodeSchema: z.ZodTypeAny = z.lazy(() =>
-				z.object({
-					value: z.string(),
-					children: z.array(nodeSchema).optional(),
-				}),
-			);
-
-			const collector = createComponentCollector();
-			const jsonSchema = await convertStandardSchemaToJsonSchema(
-				nodeSchema,
-				collector,
-			);
-
-			// $defs should be processed and potentially converted
-			expect(jsonSchema).not.toHaveProperty('$defs');
-		});
-	});
-});