@geekmidas/schema 9.0.2 → 10.0.0-alpha.1

package/src/__tests__/openapi.spec.ts

@@ -1,396 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	buildOpenApiSchema,
-	type ComponentCollector,
-	createComponentCollector,
-} from '../openapi';
-
-describe('OpenAPI Schema', () => {
-	describe('createComponentCollector', () => {
-		it('should create a component collector', () => {
-			const collector = createComponentCollector();
-
-			expect(collector).toHaveProperty('schemas');
-			expect(collector).toHaveProperty('addSchema');
-			expect(collector).toHaveProperty('getReference');
-			expect(collector.schemas).toEqual({});
-		});
-
-		it('should add schema to collector', () => {
-			const collector = createComponentCollector();
-
-			collector.addSchema('User', {
-				type: 'object',
-				properties: {
-					name: { type: 'string' },
-				},
-			});
-
-			expect(collector.schemas).toHaveProperty('User');
-			expect(collector.schemas.User).toEqual({
-				type: 'object',
-				properties: {
-					name: { type: 'string' },
-				},
-			});
-		});
-
-		it('should get reference to schema', () => {
-			const collector = createComponentCollector();
-
-			const reference = collector.getReference('User');
-
-			expect(reference).toEqual({ $ref: '#/components/schemas/User' });
-		});
-
-		it('should add multiple schemas', () => {
-			const collector = createComponentCollector();
-
-			collector.addSchema('User', {
-				type: 'object',
-				properties: { name: { type: 'string' } },
-			});
-
-			collector.addSchema('Post', {
-				type: 'object',
-				properties: { title: { type: 'string' } },
-			});
-
-			expect(Object.keys(collector.schemas)).toHaveLength(2);
-			expect(collector.schemas).toHaveProperty('User');
-			expect(collector.schemas).toHaveProperty('Post');
-		});
-
-		it('should overwrite existing schema with same name', () => {
-			const collector = createComponentCollector();
-
-			collector.addSchema('User', {
-				type: 'object',
-				properties: { name: { type: 'string' } },
-			});
-
-			collector.addSchema('User', {
-				type: 'object',
-				properties: { email: { type: 'string' } },
-			});
-
-			expect(collector.schemas.User.properties).toHaveProperty('email');
-			expect(collector.schemas.User.properties).not.toHaveProperty('name');
-		});
-
-		it('should handle complex nested schemas', () => {
-			const collector = createComponentCollector();
-
-			collector.addSchema('User', {
-				type: 'object',
-				properties: {
-					name: { type: 'string' },
-					address: {
-						type: 'object',
-						properties: {
-							street: { type: 'string' },
-							city: { type: 'string' },
-						},
-					},
-				},
-			});
-
-			expect(collector.schemas.User.properties?.address).toBeDefined();
-		});
-	});
-
-	describe('buildOpenApiSchema', () => {
-		it('should build OpenAPI schema with default options', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users': {
-							get: {
-								operationId: 'getUsers',
-								responses: {
-									'200': {
-										description: 'Success',
-									},
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint]);
-
-			expect(doc).toHaveProperty('openapi', '3.0.0');
-			expect(doc).toHaveProperty('info');
-			expect(doc.info).toEqual({
-				title: 'API',
-				version: '1.0.0',
-			});
-			expect(doc).toHaveProperty('paths');
-			expect(doc.paths).toHaveProperty('/users');
-		});
-
-		it('should build OpenAPI schema with custom options', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/posts': {
-							get: {
-								operationId: 'getPosts',
-								responses: {
-									'200': {
-										description: 'Success',
-									},
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint], {
-				title: 'My API',
-				version: '2.0.0',
-				description: 'API Description',
-			});
-
-			expect(doc.info).toEqual({
-				title: 'My API',
-				version: '2.0.0',
-				description: 'API Description',
-			});
-		});
-
-		it('should merge multiple endpoints into paths', async () => {
-			const endpoint1 = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users': {
-							get: {
-								operationId: 'getUsers',
-								responses: { '200': { description: 'Success' } },
-							},
-						},
-					};
-				},
-			};
-
-			const endpoint2 = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/posts': {
-							get: {
-								operationId: 'getPosts',
-								responses: { '200': { description: 'Success' } },
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([endpoint1, endpoint2]);
-
-			expect(Object.keys(doc.paths)).toHaveLength(2);
-			expect(doc.paths).toHaveProperty('/users');
-			expect(doc.paths).toHaveProperty('/posts');
-		});
-
-		it('should merge multiple methods for same path', async () => {
-			const endpoint1 = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users': {
-							get: {
-								operationId: 'getUsers',
-								responses: { '200': { description: 'Success' } },
-							},
-						},
-					};
-				},
-			};
-
-			const endpoint2 = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users': {
-							post: {
-								operationId: 'createUser',
-								responses: { '201': { description: 'Created' } },
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([endpoint1, endpoint2]);
-
-			expect(doc.paths['/users']).toHaveProperty('get');
-			expect(doc.paths['/users']).toHaveProperty('post');
-		});
-
-		it('should add components when schemas are collected', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(collector?: ComponentCollector) {
-					if (collector) {
-						collector.addSchema('User', {
-							type: 'object',
-							properties: {
-								name: { type: 'string' },
-							},
-						});
-					}
-
-					return {
-						'/users': {
-							get: {
-								operationId: 'getUsers',
-								responses: {
-									'200': {
-										description: 'Success',
-										content: {
-											'application/json': {
-												schema: collector?.getReference('User'),
-											},
-										},
-									},
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint]);
-
-			expect(doc).toHaveProperty('components');
-			expect(doc.components).toHaveProperty('schemas');
-			expect(doc.components?.schemas).toHaveProperty('User');
-		});
-
-		it('should not add components when no schemas collected', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/health': {
-							get: {
-								operationId: 'healthCheck',
-								responses: {
-									'200': {
-										description: 'Healthy',
-									},
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint]);
-
-			expect(doc).not.toHaveProperty('components');
-		});
-
-		it('should handle empty endpoints array', async () => {
-			const doc = await buildOpenApiSchema([]);
-
-			expect(doc.paths).toEqual({});
-			expect(doc).not.toHaveProperty('components');
-		});
-
-		it('should handle endpoints with parameters', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users/{id}': {
-							get: {
-								operationId: 'getUserById',
-								parameters: [
-									{
-										name: 'id',
-										in: 'path',
-										required: true,
-										schema: { type: 'string' },
-									},
-								],
-								responses: {
-									'200': {
-										description: 'Success',
-									},
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint]);
-
-			expect(doc.paths['/users/{id}']?.get?.parameters).toBeDefined();
-			expect(doc.paths['/users/{id}']?.get?.parameters).toHaveLength(1);
-		});
-
-		it('should handle endpoints with request body', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users': {
-							post: {
-								operationId: 'createUser',
-								requestBody: {
-									required: true,
-									content: {
-										'application/json': {
-											schema: {
-												type: 'object',
-												properties: {
-													name: { type: 'string' },
-												},
-											},
-										},
-									},
-								},
-								responses: {
-									'201': {
-										description: 'Created',
-									},
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint]);
-
-			expect(doc.paths['/users']?.post?.requestBody).toBeDefined();
-		});
-
-		it('should handle endpoints with multiple response codes', async () => {
-			const mockEndpoint = {
-				async toOpenApi3Route(_collector?: ComponentCollector) {
-					return {
-						'/users': {
-							get: {
-								operationId: 'getUsers',
-								responses: {
-									'200': { description: 'Success' },
-									'400': { description: 'Bad Request' },
-									'401': { description: 'Unauthorized' },
-									'500': { description: 'Server Error' },
-								},
-							},
-						},
-					};
-				},
-			};
-
-			const doc = await buildOpenApiSchema([mockEndpoint]);
-
-			const responses = doc.paths['/users']?.get?.responses;
-			expect(responses).toHaveProperty('200');
-			expect(responses).toHaveProperty('400');
-			expect(responses).toHaveProperty('401');
-			expect(responses).toHaveProperty('500');
-		});
-	});
-});

package/src/__tests__/parser.spec.ts

@@ -1,236 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import { parseSchema, validate } from '../parser';
-
-describe('Schema Parser', () => {
-	describe('validate', () => {
-		it('should validate data against a Zod schema', async () => {
-			const schema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			const result = await validate(schema, { name: 'John', age: 30 });
-
-			expect(result.issues).toBeUndefined();
-			if ('value' in result) {
-				expect(result.value).toEqual({ name: 'John', age: 30 });
-			}
-		});
-
-		it('should return issues for invalid data', async () => {
-			const schema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			const result = await validate(schema, { name: 'John', age: 'invalid' });
-
-			expect(result.issues).toBeDefined();
-		});
-
-		it('should validate string schema', async () => {
-			const schema = z.string();
-
-			const result = await validate(schema, 'test string');
-
-			expect(result.issues).toBeUndefined();
-			if ('value' in result) {
-				expect(result.value).toBe('test string');
-			}
-		});
-
-		it('should validate array schema', async () => {
-			const schema = z.array(z.number());
-
-			const result = await validate(schema, [1, 2, 3]);
-
-			expect(result.issues).toBeUndefined();
-			if ('value' in result) {
-				expect(result.value).toEqual([1, 2, 3]);
-			}
-		});
-
-		it('should return issues for invalid array items', async () => {
-			const schema = z.array(z.number());
-
-			const result = await validate(schema, [1, 'invalid', 3]);
-
-			expect(result.issues).toBeDefined();
-		});
-
-		it('should validate nested objects', async () => {
-			const schema = z.object({
-				user: z.object({
-					name: z.string(),
-					profile: z.object({
-						bio: z.string(),
-					}),
-				}),
-			});
-
-			const result = await validate(schema, {
-				user: {
-					name: 'John',
-					profile: { bio: 'Developer' },
-				},
-			});
-
-			expect(result.issues).toBeUndefined();
-			if ('value' in result) {
-				expect(result.value).toEqual({
-					user: {
-						name: 'John',
-						profile: { bio: 'Developer' },
-					},
-				});
-			}
-		});
-	});
-
-	describe('parseSchema', () => {
-		it('should parse valid data', async () => {
-			const schema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			const result = await parseSchema(schema, { name: 'John', age: 30 });
-
-			expect(result).toEqual({ name: 'John', age: 30 });
-		});
-
-		it('should throw for invalid data', async () => {
-			const schema = z.object({
-				name: z.string(),
-				age: z.number(),
-			});
-
-			await expect(
-				parseSchema(schema, { name: 'John', age: 'invalid' }),
-			).rejects.toBeDefined();
-		});
-
-		it('should return undefined for undefined schema', async () => {
-			const result = await parseSchema(undefined as any, { name: 'John' });
-
-			expect(result).toBeUndefined();
-		});
-
-		it('should parse string schema', async () => {
-			const schema = z.string().min(3);
-
-			const result = await parseSchema(schema, 'test');
-
-			expect(result).toBe('test');
-		});
-
-		it('should throw for string that is too short', async () => {
-			const schema = z.string().min(5);
-
-			await expect(parseSchema(schema, 'abc')).rejects.toBeDefined();
-		});
-
-		it('should parse number schema', async () => {
-			const schema = z.number().positive();
-
-			const result = await parseSchema(schema, 42);
-
-			expect(result).toBe(42);
-		});
-
-		it('should throw for negative number when positive required', async () => {
-			const schema = z.number().positive();
-
-			await expect(parseSchema(schema, -5)).rejects.toBeDefined();
-		});
-
-		it('should parse optional fields', async () => {
-			const schema = z.object({
-				required: z.string(),
-				optional: z.string().optional(),
-			});
-
-			const result = await parseSchema(schema, { required: 'value' });
-
-			expect(result).toEqual({ required: 'value' });
-		});
-
-		it('should parse with defaults', async () => {
-			const schema = z.object({
-				name: z.string(),
-				role: z.string().default('user'),
-			});
-
-			const result = await parseSchema(schema, { name: 'John' });
-
-			expect(result).toEqual({ name: 'John', role: 'user' });
-		});
-
-		it('should parse enum values', async () => {
-			const schema = z.object({
-				status: z.enum(['active', 'inactive', 'pending']),
-			});
-
-			const result = await parseSchema(schema, { status: 'active' });
-
-			expect(result).toEqual({ status: 'active' });
-		});
-
-		it('should throw for invalid enum value', async () => {
-			const schema = z.object({
-				status: z.enum(['active', 'inactive']),
-			});
-
-			await expect(
-				parseSchema(schema, { status: 'invalid' }),
-			).rejects.toBeDefined();
-		});
-
-		it('should parse union types', async () => {
-			const schema = z.union([z.string(), z.number()]);
-
-			const result1 = await parseSchema(schema, 'text');
-			const result2 = await parseSchema(schema, 42);
-
-			expect(result1).toBe('text');
-			expect(result2).toBe(42);
-		});
-
-		it('should throw for invalid union value', async () => {
-			const schema = z.union([z.string(), z.number()]);
-
-			await expect(parseSchema(schema, true)).rejects.toBeDefined();
-		});
-
-		it('should parse array of objects', async () => {
-			const schema = z.array(
-				z.object({
-					id: z.number(),
-					name: z.string(),
-				}),
-			);
-
-			const result = await parseSchema(schema, [
-				{ id: 1, name: 'Alice' },
-				{ id: 2, name: 'Bob' },
-			]);
-
-			expect(result).toEqual([
-				{ id: 1, name: 'Alice' },
-				{ id: 2, name: 'Bob' },
-			]);
-		});
-
-		it('should validate required fields', async () => {
-			const schema = z.object({
-				required: z.string(),
-				optional: z.string().optional(),
-			});
-
-			await expect(
-				parseSchema(schema, { optional: 'value' }),
-			).rejects.toBeDefined();
-		});
-	});
-});