@geekmidas/schema 0.0.1

package/src/__tests__/parser.spec.ts

@@ -0,0 +1,236 @@
+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();
+    });
+  });
+});

package/src/conversion.ts

@@ -0,0 +1,199 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+export enum SchemaVendor {
+  zod = 'zod',
+  valibot = 'valibot',
+}
+
+export type VendorConvertor = (schema: any) => Promise<any>;
+export type VendorConvertors = Record<SchemaVendor, VendorConvertor>;
+
+function isSchemaVendor(vendor?: string): vendor is SchemaVendor {
+  if (!vendor) {
+    return false;
+  }
+
+  return Object.values(SchemaVendor).includes(vendor as SchemaVendor);
+}
+
+export const StandardSchemaJsonSchema: VendorConvertors = {
+  zod: async (schema): Promise<any> => {
+    try {
+      const { z } = await import('zod/v4').catch(() => ({ z: {} }));
+
+      if ('toJSONSchema' in z && typeof z.toJSONSchema === 'function') {
+        return z.toJSONSchema(schema);
+      }
+      const { zodToJsonSchema } = await import('zod-to-json-schema');
+
+      const result = zodToJsonSchema(schema, {
+        removeAdditionalStrategy: 'strict',
+      });
+
+      return result;
+    } catch (error) {
+      // Fallback to basic conversion if zod-to-json-schema is not available
+      console.warn(
+        'zod-to-json-schema not available, using basic conversion',
+        error,
+      );
+      return { type: 'object' };
+    }
+  },
+  valibot: async (schema): Promise<any> => {
+    const { toJsonSchema } = await import('@valibot/to-json-schema');
+    return toJsonSchema(schema as any);
+  },
+};
+
+function extractAndConvertDefs(
+  jsonSchema: any,
+  componentCollector?: {
+    addSchema(id: string, schema: any): void;
+    getReference(id: string): { $ref: string };
+  },
+): any {
+  if (!jsonSchema || typeof jsonSchema !== 'object') {
+    return jsonSchema;
+  }
+
+  // Process the schema recursively to update references
+  const processSchema = (schema: any): any => {
+    if (!schema || typeof schema !== 'object') {
+      return schema;
+    }
+
+    // Handle $ref
+    if (schema.$ref && typeof schema.$ref === 'string') {
+      // Convert #/$defs/X to #/components/schemas/X
+      if (schema.$ref.startsWith('#/$defs/')) {
+        const refName = schema.$ref.replace('#/$defs/', '');
+        return componentCollector
+          ? componentCollector.getReference(refName)
+          : schema;
+      }
+      return schema;
+    }
+
+    // Handle arrays
+    if (Array.isArray(schema)) {
+      return schema.map(processSchema);
+    }
+
+    // Process all properties recursively
+    const processed: any = {};
+    for (const [key, value] of Object.entries(schema)) {
+      if (key === '$defs') {
+        // Skip $defs as they've been extracted
+        continue;
+      }
+      processed[key] = processSchema(value);
+    }
+    return processed;
+  };
+
+  // Extract $defs if present
+  if (jsonSchema.$defs && componentCollector) {
+    for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) {
+      // Process the definition recursively to handle nested $refs
+      const processedDefSchema = processSchema(defSchema);
+      // Add each definition to the component collector
+      componentCollector.addSchema(defName, processedDefSchema);
+    }
+  }
+
+  // Process the schema and remove $defs
+  const { $defs, ...schemaWithoutDefs } = jsonSchema;
+  return processSchema(schemaWithoutDefs);
+}
+
+export async function convertStandardSchemaToJsonSchema(
+  schema?: StandardSchemaV1,
+  componentCollector?: {
+    addSchema(id: string, schema: any): void;
+    getReference(id: string): { $ref: string };
+  },
+): Promise<any> {
+  if (!schema) {
+    return undefined;
+  }
+
+  const vendor = schema['~standard']?.vendor;
+  if (!isSchemaVendor(vendor)) {
+    throw new Error(
+      `Unsupported or missing vendor "${vendor}" for Standard Schema. Supported vendors are: ${Object.keys(StandardSchemaJsonSchema).join(', ')}`,
+    );
+  }
+
+  const toJSONSchema = StandardSchemaJsonSchema[vendor];
+  const jsonSchema = await toJSONSchema(schema);
+
+  // Extract and convert $defs to components
+  return extractAndConvertDefs(jsonSchema, componentCollector);
+}
+
+export async function getZodMetadata(
+  schema: StandardSchemaV1,
+): Promise<SchemaMeta | undefined> {
+  const { ZodObject } = await import('zod/v4');
+
+  if (schema instanceof ZodObject) {
+    return schema.meta();
+  }
+
+  return undefined;
+}
+
+export async function getSchemaMetadata(
+  schema: StandardSchemaV1,
+): Promise<SchemaMeta | undefined> {
+  const vendor = schema['~standard']?.vendor;
+
+  if (vendor === 'zod') {
+    return getZodMetadata(schema);
+  }
+
+  return undefined;
+}
+
+interface SchemaMeta {
+  id?: string;
+}
+
+export async function convertSchemaWithComponents(
+  schema: StandardSchemaV1 | undefined,
+  componentCollector?: {
+    addSchema(id: string, schema: any): void;
+    getReference(id: string): { $ref: string };
+  },
+): Promise<any> {
+  if (!schema) {
+    return undefined;
+  }
+
+  // Convert to JSON Schema with component collector to handle $defs
+  const jsonSchema = await convertStandardSchemaToJsonSchema(
+    schema,
+    componentCollector,
+  );
+
+  if (!componentCollector) {
+    return jsonSchema;
+  }
+
+  // Check if this schema has metadata with an ID
+  const metadata = await getSchemaMetadata(schema);
+
+  // Also check if the JSON Schema itself has an id field (from Zod's meta)
+  const schemaId = metadata?.id || jsonSchema?.id;
+
+  if (schemaId) {
+    // Remove the id from the schema before adding to components
+    const { id, ...schemaWithoutId } = jsonSchema;
+    // Add this schema to components and return a reference
+    componentCollector.addSchema(schemaId, schemaWithoutId);
+    return componentCollector.getReference(schemaId);
+  }
+
+  return jsonSchema;
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export type {
+  InferStandardSchema,
+  ComposableStandardSchema,
+  InferComposableStandardSchema,
+} from './types';
+
+// Re-export conversion utilities for convenience
+export {
+  convertStandardSchemaToJsonSchema,
+  convertSchemaWithComponents,
+} from './conversion';
+
+// Re-export OpenAPI utilities for convenience
+export { buildOpenApiSchema, createComponentCollector } from './openapi';
+export type { OpenApiSchemaOptions, ComponentCollector } from './openapi';

package/src/openapi.ts

@@ -0,0 +1,75 @@
+import type { OpenAPIV3_1 } from 'openapi-types';
+
+export interface OpenApiSchemaOptions {
+  title?: string;
+  version?: string;
+  description?: string;
+}
+
+export interface ComponentCollector {
+  schemas: Record<string, OpenAPIV3_1.SchemaObject>;
+  addSchema(id: string, schema: OpenAPIV3_1.SchemaObject): void;
+  getReference(id: string): OpenAPIV3_1.ReferenceObject;
+}
+
+export function createComponentCollector(): ComponentCollector {
+  const schemas: Record<string, OpenAPIV3_1.SchemaObject> = {};
+
+  return {
+    schemas,
+    addSchema(id: string, schema: OpenAPIV3_1.SchemaObject) {
+      schemas[id] = schema;
+    },
+    getReference(id: string): OpenAPIV3_1.ReferenceObject {
+      return { $ref: `#/components/schemas/${id}` };
+    },
+  };
+}
+
+/**
+ * Builds OpenAPI 3.1 schema from an array of endpoints.
+ *
+ * Note: This function requires endpoints with toOpenApi3Route method.
+ * The actual implementation is in @geekmidas/constructs to avoid circular dependencies.
+ */
+export async function buildOpenApiSchema(
+  endpoints: Array<{
+    toOpenApi3Route(collector?: ComponentCollector): Promise<any>;
+  }>,
+  options: OpenApiSchemaOptions = {},
+): Promise<OpenAPIV3_1.Document> {
+  const { title = 'API', version = '1.0.0', description } = options;
+  const paths: OpenAPIV3_1.PathsObject = {};
+  const componentCollector = createComponentCollector();
+
+  for (const endpoint of endpoints) {
+    const route = await endpoint.toOpenApi3Route(componentCollector);
+
+    // Merge the route into the paths object
+    for (const [path, methods] of Object.entries(route)) {
+      if (!paths[path]) {
+        paths[path] = {};
+      }
+      Object.assign(paths[path], methods);
+    }
+  }
+
+  const doc: OpenAPIV3_1.Document = {
+    openapi: '3.0.0',
+    info: {
+      title,
+      version,
+      ...(description && { description }),
+    },
+    paths,
+  };
+
+  // Add components if any schemas were collected
+  if (Object.keys(componentCollector.schemas).length > 0) {
+    doc.components = {
+      schemas: componentCollector.schemas,
+    };
+  }
+
+  return doc;
+}

package/src/parser.ts

@@ -0,0 +1,30 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { InferStandardSchema } from './types';
+
+/**
+ * Validates data against a StandardSchema.
+ *
+ * @param schema - The StandardSchema to validate against
+ * @param data - The data to validate
+ * @returns Validation result with value or issues
+ */
+export function validate<T extends StandardSchemaV1>(schema: T, data: unknown) {
+  return schema['~standard'].validate(data);
+}
+
+export async function parseSchema<T extends StandardSchemaV1>(
+  schema: T,
+  data: unknown,
+): Promise<InferStandardSchema<T>> {
+  if (!schema) {
+    return undefined as InferStandardSchema<T>;
+  }
+
+  const parsed = await validate(schema as unknown as StandardSchemaV1, data);
+
+  if (parsed.issues) {
+    throw parsed.issues;
+  }
+
+  return parsed.value as InferStandardSchema<T>;
+}

package/src/types.ts

@@ -0,0 +1,23 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+export type InferStandardSchema<T> = T extends StandardSchemaV1
+  ? StandardSchemaV1.InferOutput<T>
+  : never;
+
+export type ComposableStandardSchema =
+  | StandardSchemaV1
+  | {
+      [key: string]: StandardSchemaV1 | undefined;
+    };
+
+export type InferComposableStandardSchema<T> = T extends StandardSchemaV1
+  ? StandardSchemaV1.InferOutput<T>
+  : T extends { [key: string]: StandardSchemaV1 | undefined }
+    ? {
+        [K in keyof T as T[K] extends StandardSchemaV1
+          ? K
+          : never]: T[K] extends StandardSchemaV1
+          ? StandardSchemaV1.InferOutput<T[K]>
+          : never;
+      }
+    : {};

package/tsdown.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  external: ['@valibot/to-json-schema', 'zod', 'zod-to-json-schema'],
+});