@geekmidas/schema 0.1.0 → 1.0.0

package/src/conversion.ts

@@ -1,195 +1,195 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 
 export enum SchemaVendor {
-  zod = 'zod',
-  valibot = 'valibot',
+	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;
-  }
+	if (!vendor) {
+		return false;
+	}
 
-  return Object.values(SchemaVendor).includes(vendor as SchemaVendor);
+	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 {
-      // Fallback to basic conversion if zod-to-json-schema is not available
-      return { type: 'object' };
-    }
-  },
-  valibot: async (schema): Promise<any> => {
-    const { toJsonSchema } = await import('@valibot/to-json-schema');
-    return toJsonSchema(schema as any);
-  },
+	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 {
+			// Fallback to basic conversion if zod-to-json-schema is not available
+			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 };
-  },
+	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);
+	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 };
-  },
+	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);
+	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,
+	schema: StandardSchemaV1,
 ): Promise<SchemaMeta | undefined> {
-  const { ZodObject } = await import('zod/v4');
+	const { ZodObject } = await import('zod/v4');
 
-  if (schema instanceof ZodObject) {
-    return schema.meta();
-  }
+	if (schema instanceof ZodObject) {
+		return schema.meta();
+	}
 
-  return undefined;
+	return undefined;
 }
 
 export async function getSchemaMetadata(
-  schema: StandardSchemaV1,
+	schema: StandardSchemaV1,
 ): Promise<SchemaMeta | undefined> {
-  const vendor = schema['~standard']?.vendor;
+	const vendor = schema['~standard']?.vendor;
 
-  if (vendor === 'zod') {
-    return getZodMetadata(schema);
-  }
+	if (vendor === 'zod') {
+		return getZodMetadata(schema);
+	}
 
-  return undefined;
+	return undefined;
 }
 
 interface SchemaMeta {
-  id?: string;
+	id?: string;
 }
 
 export async function convertSchemaWithComponents(
-  schema: StandardSchemaV1 | undefined,
-  componentCollector?: {
-    addSchema(id: string, schema: any): void;
-    getReference(id: string): { $ref: string };
-  },
+	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;
+	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

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

package/src/openapi.ts

@@ -1,29 +1,29 @@
 import type { OpenAPIV3_1 } from 'openapi-types';
 
 export interface OpenApiSchemaOptions {
-  title?: string;
-  version?: string;
-  description?: string;
+	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;
+	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> = {};
+	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}` };
-    },
-  };
+	return {
+		schemas,
+		addSchema(id: string, schema: OpenAPIV3_1.SchemaObject) {
+			schemas[id] = schema;
+		},
+		getReference(id: string): OpenAPIV3_1.ReferenceObject {
+			return { $ref: `#/components/schemas/${id}` };
+		},
+	};
 }
 
 /**
@@ -33,43 +33,43 @@ export function createComponentCollector(): ComponentCollector {
  * The actual implementation is in @geekmidas/constructs to avoid circular dependencies.
  */
 export async function buildOpenApiSchema(
-  endpoints: Array<{
-    toOpenApi3Route(collector?: ComponentCollector): Promise<any>;
-  }>,
-  options: OpenApiSchemaOptions = {},
+	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();
+	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);
+	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);
-    }
-  }
+		// 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,
-  };
+	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,
-    };
-  }
+	// Add components if any schemas were collected
+	if (Object.keys(componentCollector.schemas).length > 0) {
+		doc.components = {
+			schemas: componentCollector.schemas,
+		};
+	}
 
-  return doc;
+	return doc;
 }

package/src/parser.ts

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

package/src/types.ts

@@ -1,23 +1,23 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 
 export type InferStandardSchema<T> = T extends StandardSchemaV1
-  ? StandardSchemaV1.InferOutput<T>
-  : never;
+	? StandardSchemaV1.InferOutput<T>
+	: never;
 
 export type ComposableStandardSchema =
-  | StandardSchemaV1
-  | {
-      [key: string]: StandardSchemaV1 | undefined;
-    };
+	| 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;
-      }
-    : {};
+	? 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/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"]
+}

package/tsdown.config.ts

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