@geekmidas/schema 9.0.2 → 10.0.0-alpha.0

package/src/conversion.ts

@@ -1,220 +0,0 @@
-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 {
-			// 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 };
-	},
-): 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;
-}
-
-/**
- * Return JSON Schema for every schema registered in zod v4's global registry
- * via `.meta({ id })`. Returns an empty object when zod v4 is unavailable or
- * no schemas are registered.
- *
- * `unrepresentable: 'any'` keeps a single unrepresentable schema from
- * collapsing the whole result.
- */
-export async function getRegisteredZodJsonSchemas(): Promise<
-	Record<string, any>
-> {
-	try {
-		const { z } = await import('zod/v4').catch(() => ({ z: null as any }));
-		if (!z?.toJSONSchema || !z.globalRegistry) {
-			return {};
-		}
-		const result = z.toJSONSchema(z.globalRegistry, {
-			unrepresentable: 'any',
-		});
-		return (result?.schemas ?? {}) as Record<string, any>;
-	} catch {
-		return {};
-	}
-}
-
-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

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

package/src/openapi.ts

@@ -1,75 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,37 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-
-export type InferStandardSchema<T> = T extends StandardSchemaV1
-	? StandardSchemaV1.InferOutput<T>
-	: never;
-
-/**
- * The *input* type a Standard Schema accepts (before any transform/coercion),
- * as opposed to {@link InferStandardSchema} which is the output type.
- *
- * Use this for the value a producer must HAND TO the schema (e.g. an endpoint
- * handler's return that will be parsed by its output schema): the schema may
- * coerce it (a `Date` → an ISO `string`, a default applied, etc.), so the
- * producer should be allowed to supply the looser input type while consumers
- * still see the narrower output type.
- */
-export type InferStandardSchemaInput<T> = T extends StandardSchemaV1
-	? StandardSchemaV1.InferInput<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/tsconfig.json

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

package/tsdown.config.ts

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