Treat vendored schema compiler as internal code

Author: RhysSullivan

packages/core/sdk/package.json

@@ -59,7 +59,7 @@
     }
   },
   "scripts": {
-    "build": "tsup && mkdir -p dist/vendor/json-schema-to-typescript && cp src/vendor/json-schema-to-typescript/LICENCE.md dist/vendor/json-schema-to-typescript/LICENCE.md && (tsc --declaration --emitDeclarationOnly --outDir dist --rootDir src || true)",
+    "build": "tsup && (tsc --declaration --emitDeclarationOnly --outDir dist --rootDir src || true)",
     "typecheck": "tsgo --noEmit",
     "test": "vitest run",
     "typecheck:slow": "tsc --noEmit"

packages/core/sdk/src/schema-types.test.ts

@@ -1,6 +1,4 @@
 import { readFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "@effect/vitest";
 import { Schema } from "effect";
 
@@ -24,15 +22,6 @@ const stripeBalanceTransactionsFixture = Schema.decodeUnknownSync(
   ),
 );
 
-const sdkPackageRoot = fileURLToPath(new URL("..", import.meta.url));
-const TypeScriptPreviewOutput = Schema.Struct({
-  inputTypeScript: Schema.String,
-  outputTypeScript: Schema.String,
-});
-const decodeTypeScriptPreviewOutput = Schema.decodeUnknownSync(
-  Schema.fromJsonString(TypeScriptPreviewOutput),
-);
-
 describe("schema-types", () => {
   it("reuses referenced definitions instead of inlining them", async () => {
     const schema = {
@@ -383,33 +372,22 @@ describe("schema-types", () => {
     });
   });
 
-  it("loads the vendored compiler through Bun's TypeScript loader", () => {
-    const output = execFileSync(
-      "bun",
-      [
-        "-e",
-        `
-          import { buildToolTypeScriptPreview } from "./src/schema-types.ts";
-          const preview = await buildToolTypeScriptPreview({
-            inputSchema: {
-              type: "object",
-              properties: {
-                account_id: { type: "string" },
-                body: {}
-              },
-              required: ["account_id", "body"],
-              additionalProperties: false
-            },
-            outputSchema: {},
-            defs: new Map()
-          });
-          console.log(JSON.stringify(preview));
-        `,
-      ],
-      { cwd: sdkPackageRoot, encoding: "utf8" },
-    );
-
-    expect(decodeTypeScriptPreviewOutput(output)).toEqual({
+  it("renders unconstrained schemas as unknown", async () => {
+    await expect(
+      buildToolTypeScriptPreview({
+        inputSchema: {
+          type: "object",
+          properties: {
+            account_id: { type: "string" },
+            body: {},
+          },
+          required: ["account_id", "body"],
+          additionalProperties: false,
+        },
+        outputSchema: {},
+        defs: new Map(),
+      }),
+    ).resolves.toEqual({
       inputTypeScript: "{ account_id: string; body: unknown; }",
       outputTypeScript: "unknown",
     });

packages/core/sdk/src/schema-types.ts

@@ -1,4 +1,5 @@
 import { hoistDefinitions, normalizeRefs } from "./schema-refs";
+import { compile } from "./vendor/json-schema-to-typescript";
 
 type JsonSchemaRecord = Record<string, unknown>;
 type CompilerJsonSchema = JsonSchemaRecord | boolean;
@@ -19,13 +20,6 @@ type SchemaCompilerOptions = {
   unknownAny?: boolean;
   unreachableDefinitions?: boolean;
 };
-type SchemaCompiler = {
-  compile: (
-    schema: CompilerJsonSchema,
-    name: string,
-    options: Partial<SchemaCompilerOptions>,
-  ) => Promise<string>;
-};
 
 export type TypeScriptRenderOptions = {
   compilerOptions?: Partial<SchemaCompilerOptions>;
@@ -56,16 +50,6 @@ const DEFAULT_COMPILER_OPTIONS = {
   },
 } satisfies Partial<SchemaCompilerOptions>;
 
-const schemaCompilerModulePath = (): string =>
-  import.meta.url.endsWith(".ts")
-    ? "./vendor/json-schema-to-typescript/index.ts"
-    : "./vendor/json-schema-to-typescript/index.js";
-
-const loadSchemaCompiler = async (): Promise<SchemaCompiler> => {
-  const compilerModule: unknown = await import(schemaCompilerModulePath());
-  return compilerModule as SchemaCompiler;
-};
-
 const DEFINITION_REF_PATTERN = /^#\/definitions\/(.+)$/;
 const IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 
@@ -764,7 +748,6 @@ const compileSchemaPreview = async (
   options: TypeScriptRenderOptions,
 ): Promise<TypeScriptSchemaPreview> => {
   const wrappedSchema = buildWrappedSchema(schema, defs);
-  const { compile } = await loadSchemaCompiler();
   const source = await compile(wrappedSchema, ROOT_WRAPPER_NAME, compilerOptionsFrom(options));
   return previewFromCompiledTypeScript(source);
 };
@@ -816,10 +799,7 @@ export const buildToolTypeScriptPreview = async (input: {
   }
 
   const wrappedSchema = buildWrappedObjectSchema(properties, input.defs);
-  return loadSchemaCompiler()
-    .then(({ compile }) =>
-      compile(wrappedSchema, ROOT_WRAPPER_NAME, compilerOptionsFrom(input.options ?? {})),
-    )
+  return compile(wrappedSchema, ROOT_WRAPPER_NAME, compilerOptionsFrom(input.options ?? {}))
     .then(
       (source) => previewToolFromCompiledTypeScript(source),
       () => ({

packages/core/sdk/src/vendor/json-schema-to-typescript/compat.ts

@@ -10,15 +10,16 @@ export const isPlainObject = (value: unknown): value is Record<string, unknown>
 
 export const cloneDeep = <T>(value: T): T => structuredClone(value);
 
-export const merge = <T extends Record<string, unknown>>(
+export const merge = <T extends object>(
   target: T,
-  ...sources: ReadonlyArray<Record<string, unknown> | undefined>
+  ...sources: ReadonlyArray<object | undefined>
 ): T => {
+  const output = target as Record<string, unknown>;
   for (const source of sources) {
     if (!source) continue;
-    for (const [key, value] of Object.entries(source)) {
-      const current = target[key];
-      target[key] =
+    for (const [key, value] of Object.entries(source as Record<string, unknown>)) {
+      const current = output[key];
+      output[key] =
         isPlainObject(current) && isPlainObject(value)
           ? merge({ ...current }, value)
           : cloneDeep(value);

packages/core/sdk/src/vendor/json-schema-to-typescript/generator.ts

@@ -377,7 +377,7 @@ function generateStandaloneType(ast: ASTWithStandaloneName, options: Options): s
   return (
     (hasComment(ast) ? generateComment(ast.comment) + "\n" : "") +
     `export type ${toSafeString(ast.standaloneName)} = ${generateType(
-      omit<AST>(ast, "standaloneName") as AST /* TODO */,
+      omit(ast, "standaloneName") as AST /* TODO */,
       options,
     )}`
   );

packages/core/sdk/src/vendor/json-schema-to-typescript/index.ts

@@ -164,7 +164,7 @@ export async function compile(
 ): Promise<string> {
   validateOptions(options);
 
-  const _options = merge({}, DEFAULT_OPTIONS, options);
+  const _options = merge({} as Options, DEFAULT_OPTIONS, options);
 
   const start = Date.now();
   function time() {

packages/core/sdk/src/vendor/json-schema-to-typescript/parser.ts

@@ -47,8 +47,9 @@ export function parse(
     return parseLiteral(schema, keyName);
   }
 
-  const intersection = schema[Intersection];
-  const types = schema[Types];
+  const normalizedSchema = schema as NormalizedJSONSchema;
+  const intersection = normalizedSchema[Intersection];
+  const types = normalizedSchema[Types];
 
   if (intersection) {
     const ast = parseAsTypeWithCache(
@@ -61,17 +62,19 @@ export function parse(
     ) as TIntersection;
 
     types.forEach((type) => {
-      ast.params.push(parseAsTypeWithCache(schema, type, options, keyName, processed, usedNames));
+      ast.params.push(
+        parseAsTypeWithCache(normalizedSchema, type, options, keyName, processed, usedNames),
+      );
     });
 
-    log("blue", "parser", "Types:", [...types], "Input:", schema, "Output:", ast);
+    log("blue", "parser", "Types:", [...types], "Input:", normalizedSchema, "Output:", ast);
     return ast;
   }
 
   if (types.size === 1) {
     const type = [...types][0];
-    const ast = parseAsTypeWithCache(schema, type, options, keyName, processed, usedNames);
-    log("blue", "parser", "Type:", type, "Input:", schema, "Output:", ast);
+    const ast = parseAsTypeWithCache(normalizedSchema, type, options, keyName, processed, usedNames);
+    log("blue", "parser", "Type:", type, "Input:", normalizedSchema, "Output:", ast);
     return ast;
   }
 

packages/core/sdk/src/vendor/json-schema-to-typescript/types/json-schema.ts

@@ -17,11 +17,11 @@ export type JSONSchema4Type =
   | JSONSchema4Type[];
 
 export interface JSONSchema4Object {
-  readonly [key: string]: unknown;
+  [key: string]: any;
 }
 
 export interface JSONSchema4 {
-  readonly [key: string]: unknown;
+  [key: string]: any;
   $id?: string;
   $ref?: string;
   $schema?: string;
@@ -44,7 +44,7 @@ export interface JSONSchema4 {
   oneOf?: JSONSchema4[];
   patternProperties?: Record<string, JSONSchema4>;
   properties?: Record<string, JSONSchema4>;
-  required?: string[];
+  required?: string[] | false;
   title?: string;
   type?: JSONSchema4TypeName | JSONSchema4TypeName[];
 }

packages/core/sdk/src/vendor/json-schema-to-typescript/utils.ts

@@ -148,10 +148,10 @@ export function traverse(
     }
   }
   if (schema.definitions) {
-    traverseObjectKeys(schema.definitions, callback, processed);
+    traverseObjectKeys(schema.definitions as Record<string, LinkedJSONSchema>, callback, processed);
   }
   if (schema.$defs) {
-    traverseObjectKeys(schema.$defs, callback, processed);
+    traverseObjectKeys(schema.$defs as Record<string, LinkedJSONSchema>, callback, processed);
   }
   if (schema.not) {
     traverse(schema.not, callback, processed);
@@ -360,7 +360,7 @@ export function isSchemaLike(schema: any): schema is LinkedJSONSchema {
   }
 
   // top-level schema
-  const parent = schema[Parent];
+  const parent = (schema as LinkedJSONSchema)[Parent] as LinkedJSONSchema | null;
   if (parent === null) {
     return true;
   }

packages/core/sdk/tsconfig.json

@@ -20,6 +20,5 @@
       }
     ]
   },
-  "include": ["src"],
-  "exclude": ["src/vendor/json-schema-to-typescript"]
+  "include": ["src"]
 }