Revise schema-to-json for bundle safety and tests

The package @trigger.dev/schema-to-json has been revised to ensure bundle safety by removing direct dependencies on schema libraries such as Zod, Yup, and Effect. This change minimizes bundle size and enhances tree-shaking by allowing external conversion libraries to be utilized only at runtime if necessary. As a result, the README was updated to reflect this usage pattern.

- Introduced `initializeSchemaConverters` function to load necessary conversion libraries at runtime, keeping the base package slim.
- Adjusted test suite to initialize converters before tests, ensuring accurate testing of schema conversion capabilities.
- Updated `schemaToJsonSchema` function to dynamically check for availability of conversion libraries, improving flexibility without increasing the package size.
- Added configuration files for Vitest to support the new testing framework, reflecting the transition from previous test setups.

These enhancements ensure that only the schema libraries actively used in an application are bundled, optimizing performance and resource usage.

Author: ericallam

packages/schema-to-json/.gitignore

@@ -0,0 +1,6 @@
+node_modules
+dist
+.tshy
+.tshy-build
+*.log
+.DS_Store

packages/schema-to-json/README.md

@@ -8,26 +8,61 @@ Convert various schema validation libraries to JSON Schema format.
 npm install @trigger.dev/schema-to-json
 ```
 
+## Important: Bundle Safety
+
+This package is designed to be **bundle-safe**. It does NOT bundle any schema libraries (zod, yup, etc.) as dependencies. Instead:
+
+1. **Built-in conversions** work immediately (ArkType, Zod 4, TypeBox)
+2. **External conversions** (Zod 3, Yup, Effect) require the conversion libraries to be available at runtime
+
+This design ensures that:
+- ✅ Your bundle size stays small
+- ✅ You only include the schema libraries you actually use
+- ✅ Tree-shaking works properly
+- ✅ No unnecessary dependencies are installed
+
 ## Supported Schema Libraries
 
 - ✅ **Zod** - Full support
-  - Zod 4: Native support via built-in `toJsonSchema` method
-  - Zod 3: Support via `zod-to-json-schema` library
-- ✅ **Yup** - Full support via `@sodaru/yup-to-json-schema`
+  - Zod 4: Native support via built-in `toJsonSchema` method (no external deps needed)
+  - Zod 3: Requires `zod-to-json-schema` to be installed
+- ✅ **Yup** - Requires `@sodaru/yup-to-json-schema` to be installed
 - ✅ **ArkType** - Native support (built-in `toJsonSchema` method)
-- ✅ **Effect/Schema** - Full support via Effect's JSONSchema module
+- ✅ **Effect/Schema** - Requires `effect` or `@effect/schema` to be installed
 - ✅ **TypeBox** - Native support (already JSON Schema compliant)
 - ⏳ **Valibot** - Coming soon
 - ⏳ **Superstruct** - Coming soon
 - ⏳ **Runtypes** - Coming soon
 
 ## Usage
 
+### Basic Usage (Built-in conversions only)
+
 ```typescript
 import { schemaToJsonSchema } from '@trigger.dev/schema-to-json';
+import { type } from 'arktype';
+
+// Works immediately for schemas with built-in conversion
+const arkSchema = type({
+  name: 'string',
+  age: 'number',
+});
+
+const result = schemaToJsonSchema(arkSchema);
+console.log(result);
+// { jsonSchema: {...}, schemaType: 'arktype' }
+```
+
+### Full Usage (With external conversion libraries)
+
+```typescript
+import { schemaToJsonSchema, initializeSchemaConverters } from '@trigger.dev/schema-to-json';
 import { z } from 'zod';
 
-// Convert a Zod schema
+// Initialize converters once in your app (loads conversion libraries if available)
+await initializeSchemaConverters();
+
+// Now you can convert Zod 3, Yup, and Effect schemas
 const zodSchema = z.object({
   name: z.string(),
   age: z.number(),
@@ -66,6 +101,12 @@ Convert a schema to JSON Schema format.
 - `{ jsonSchema, schemaType }` - The converted JSON Schema and detected type
 - `undefined` - If the schema cannot be converted
 
+### `initializeSchemaConverters()`
+
+Initialize the external conversion libraries. Call this once in your application if you need to convert schemas that don't have built-in JSON Schema support (Zod 3, Yup, Effect).
+
+**Returns:** `Promise<void>`
+
 ### `canConvertSchema(schema)`
 
 Check if a schema can be converted to JSON Schema.
@@ -78,6 +119,12 @@ Detect the type of schema.
 
 **Returns:** `'zod' | 'yup' | 'arktype' | 'effect' | 'valibot' | 'superstruct' | 'runtypes' | 'typebox' | 'unknown'`
 
+### `areConvertersInitialized()`
+
+Check which conversion libraries are available.
+
+**Returns:** `{ zod: boolean, yup: boolean, effect: boolean }`
+
 ## Peer Dependencies
 
 Each schema library is an optional peer dependency. Install only the ones you need:

packages/schema-to-json/src/__tests__/index.test.ts

@@ -1,12 +1,32 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeAll } from 'vitest';
 import { z } from 'zod';
 import * as y from 'yup';
 import { type } from 'arktype';
 import { Schema } from '@effect/schema';
 import { Type } from '@sinclair/typebox';
-import { schemaToJsonSchema, canConvertSchema, detectSchemaType } from '../index.js';
+import { 
+  schemaToJsonSchema, 
+  canConvertSchema, 
+  detectSchemaType, 
+  initializeSchemaConverters,
+  areConvertersInitialized 
+} from '../index.js';
+
+// Initialize converters before running tests
+beforeAll(async () => {
+  await initializeSchemaConverters();
+});
 
 describe('schemaToJsonSchema', () => {
+  describe('Initialization', () => {
+    it('should have converters initialized', () => {
+      const status = areConvertersInitialized();
+      expect(status.zod).toBe(true);
+      expect(status.yup).toBe(true);
+      expect(status.effect).toBe(true);
+    });
+  });
+
   describe('Zod schemas', () => {
     it('should convert a simple Zod object schema', () => {
       const schema = z.object({

packages/schema-to-json/src/index.ts

@@ -24,17 +24,32 @@ export interface ConversionResult {
 
 /**
  * Convert a schema from various validation libraries to JSON Schema
+ * 
+ * This function attempts to convert schemas without requiring external dependencies to be bundled.
+ * It will only succeed if:
+ * 1. The schema has built-in JSON Schema conversion (ArkType, Zod 4, TypeBox)
+ * 2. The required conversion library is available at runtime (zod-to-json-schema, @sodaru/yup-to-json-schema, etc.)
+ * 
+ * @param schema The schema to convert
+ * @param options Optional conversion options
+ * @returns The conversion result or undefined if conversion is not possible
  */
 export function schemaToJsonSchema(schema: Schema, options?: ConversionOptions): ConversionResult | undefined {
   const parser = schema as any;
 
-  // Check if schema has a built-in toJsonSchema method (e.g., ArkType)
+  // Check if schema has a built-in toJsonSchema method (e.g., ArkType, Zod 4)
   if (typeof parser.toJsonSchema === "function") {
-    const jsonSchema = parser.toJsonSchema();
-    return {
-      jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
-      schemaType: 'arktype'
-    };
+    try {
+      const jsonSchema = parser.toJsonSchema();
+      // Determine if it's Zod or ArkType based on other methods
+      const schemaType = (typeof parser.parseAsync === "function" || typeof parser.parse === "function") ? 'zod' : 'arktype';
+      return {
+        jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
+        schemaType
+      };
+    } catch (error) {
+      // If toJsonSchema fails, continue to other checks
+    }
   }
 
   // Check if it's a TypeBox schema (has Static and Kind symbols)
@@ -46,106 +61,116 @@ export function schemaToJsonSchema(schema: Schema, options?: ConversionOptions):
     };
   }
 
-  // Check if it's a Zod schema
+  // For schemas that need external libraries, we need to check if they're available
+  // This approach avoids bundling the dependencies while still allowing runtime usage
+  
+  // Check if it's a Zod schema (without built-in toJsonSchema)
   if (typeof parser.parseAsync === "function" || typeof parser.parse === "function") {
-    // Check if it's Zod 4 with built-in toJsonSchema method
-    if (typeof parser.toJsonSchema === "function") {
-      try {
-        const jsonSchema = parser.toJsonSchema();
-        return {
-          jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
-          schemaType: 'zod'
-        };
-      } catch (error) {
-        console.warn('Failed to convert Zod 4 schema using built-in toJsonSchema:', error);
-      }
-    }
-
-    // Fall back to zod-to-json-schema library (for Zod 3 or if built-in method fails)
     try {
-      const { zodToJsonSchema } = require('zod-to-json-schema');
-      const jsonSchema = options?.name 
-        ? zodToJsonSchema(parser, options.name)
-        : zodToJsonSchema(parser);
-      
-      if (jsonSchema && typeof jsonSchema === 'object' && '$schema' in jsonSchema) {
-        // Remove the $schema property as it's not needed for our use case
-        const { $schema, ...rest } = jsonSchema as any;
+      // Try to access zod-to-json-schema if it's available
+      // @ts-ignore - This is intentionally dynamic
+      if (typeof globalThis.__zodToJsonSchema !== 'undefined') {
+        // @ts-ignore
+        const { zodToJsonSchema } = globalThis.__zodToJsonSchema;
+        const jsonSchema = options?.name 
+          ? zodToJsonSchema(parser, options.name)
+          : zodToJsonSchema(parser);
+        
+        if (jsonSchema && typeof jsonSchema === 'object' && '$schema' in jsonSchema) {
+          const { $schema, ...rest } = jsonSchema as any;
+          return {
+            jsonSchema: options?.additionalProperties ? { ...rest, ...options.additionalProperties } : rest,
+            schemaType: 'zod'
+          };
+        }
+        
         return {
-          jsonSchema: options?.additionalProperties ? { ...rest, ...options.additionalProperties } : rest,
+          jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
           schemaType: 'zod'
         };
       }
-      
-      return {
-        jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
-        schemaType: 'zod'
-      };
     } catch (error) {
-      console.warn('Failed to convert Zod schema to JSON Schema using zod-to-json-schema:', error);
-      return undefined;
+      // Library not available
     }
   }
 
   // Check if it's a Yup schema
   if (typeof parser.validateSync === "function" && typeof parser.describe === "function") {
     try {
-      const { convertSchema } = require('@sodaru/yup-to-json-schema');
-      const jsonSchema = convertSchema(parser);
-      return {
-        jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
-        schemaType: 'yup'
-      };
+      // @ts-ignore
+      if (typeof globalThis.__yupToJsonSchema !== 'undefined') {
+        // @ts-ignore
+        const { convertSchema } = globalThis.__yupToJsonSchema;
+        const jsonSchema = convertSchema(parser);
+        return {
+          jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
+          schemaType: 'yup'
+        };
+      }
     } catch (error) {
-      console.warn('Failed to convert Yup schema to JSON Schema:', error);
-      return undefined;
+      // Library not available
     }
   }
 
   // Check if it's an Effect schema
   if (parser._tag === "Schema" || parser._tag === "SchemaClass" || typeof parser.ast === "function") {
     try {
-      // Try to load Effect's JSONSchema module
-      const effectModule = require('effect');
-      const schemaModule = require('@effect/schema');
-      
-      if (effectModule?.JSONSchema && schemaModule?.JSONSchema) {
-        const JSONSchema = schemaModule.JSONSchema || effectModule.JSONSchema;
+      // @ts-ignore
+      if (typeof globalThis.__effectJsonSchema !== 'undefined') {
+        // @ts-ignore
+        const { JSONSchema } = globalThis.__effectJsonSchema;
         const jsonSchema = JSONSchema.make(parser);
         return {
           jsonSchema: options?.additionalProperties ? { ...jsonSchema, ...options.additionalProperties } : jsonSchema,
           schemaType: 'effect'
         };
       }
     } catch (error) {
-      console.warn('Failed to convert Effect schema to JSON Schema:', error);
-      return undefined;
+      // Library not available
     }
   }
 
-  // Check if it's a Valibot schema
-  if (typeof parser === "function" && parser._def?.kind !== undefined) {
-    // Valibot doesn't have built-in JSON Schema conversion yet
-    // We could implement a basic converter for common types
-    return undefined;
-  }
+  // Future schema types can be added here...
 
-  // Check if it's a Superstruct schema
-  if (typeof parser.create === "function" && parser.TYPE !== undefined) {
-    // Superstruct doesn't have built-in JSON Schema conversion
-    // We could implement a basic converter for common types
-    return undefined;
+  // Unknown schema type
+  return undefined;
+}
+
+/**
+ * Initialize the schema conversion libraries
+ * This should be called by the consuming application if they want to enable
+ * conversion for schemas that don't have built-in JSON Schema support
+ */
+export async function initializeSchemaConverters(): Promise<void> {
+  try {
+    // @ts-ignore
+    globalThis.__zodToJsonSchema = await import('zod-to-json-schema');
+  } catch {
+    // Zod conversion not available
   }
 
-  // Check if it's a Runtypes schema
-  if (typeof parser.guard === "function" && parser._tag !== undefined) {
-    // Runtypes doesn't have built-in JSON Schema conversion
-    // We could implement a basic converter for common types
-    return undefined;
+  try {
+    // @ts-ignore
+    globalThis.__yupToJsonSchema = await import('@sodaru/yup-to-json-schema');
+  } catch {
+    // Yup conversion not available
   }
 
-  // Unknown schema type
-  return undefined;
+  try {
+    // Try Effect first, then @effect/schema
+    let module;
+    try {
+      module = await import('effect');
+    } catch {
+      module = await import('@effect/schema');
+    }
+    if (module?.JSONSchema) {
+      // @ts-ignore
+      globalThis.__effectJsonSchema = { JSONSchema: module.JSONSchema };
+    }
+  } catch {
+    // Effect conversion not available
+  }
 }
 
 /**
@@ -162,4 +187,22 @@ export function canConvertSchema(schema: Schema): boolean {
 export function detectSchemaType(schema: Schema): ConversionResult['schemaType'] {
   const result = schemaToJsonSchema(schema);
   return result?.schemaType ?? 'unknown';
+}
+
+/**
+ * Check if the conversion libraries are initialized
+ */
+export function areConvertersInitialized(): {
+  zod: boolean;
+  yup: boolean;
+  effect: boolean;
+} {
+  return {
+    // @ts-ignore
+    zod: typeof globalThis.__zodToJsonSchema !== 'undefined',
+    // @ts-ignore
+    yup: typeof globalThis.__yupToJsonSchema !== 'undefined',
+    // @ts-ignore
+    effect: typeof globalThis.__effectJsonSchema !== 'undefined',
+  };
 }

packages/schema-to-json/tsconfig.test.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../.configs/tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./",
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["./src/**/*.test.ts", "./test/**/*.ts"]
+}