Clean up vendored schema compiler helpers

Author: RhysSullivan

…ndor/json-schema-to-typescript/lodash.ts …ndor/json-schema-to-typescript/compat.tspackages/core/sdk/src/vendor/json-schema-to-typescript/lodash.ts renamed to packages/core/sdk/src/vendor/json-schema-to-typescript/compat.ts packages/core/sdk/src/vendor/json-schema-to-typescript/lodash.ts renamed to packages/core/sdk/src/vendor/json-schema-to-typescript/compat.ts

@@ -1,3 +1,7 @@
+import { Struct } from "effect";
+
+// Keep these helpers deliberately small and local. They preserve only the
+// upstream helper behavior this vendored compiler actually uses.
 export const isPlainObject = (value: unknown): value is Record<string, unknown> => {
   if (value === null || typeof value !== "object") return false;
   const prototype = Object.getPrototypeOf(value);
@@ -6,8 +10,6 @@ export const isPlainObject = (value: unknown): value is Record<string, unknown>
 
 export const cloneDeep = <T>(value: T): T => structuredClone(value);
 
-export const endsWith = (value: string, suffix: string): boolean => value.endsWith(suffix);
-
 export const merge = <T extends Record<string, unknown>>(
   target: T,
   ...sources: ReadonlyArray<Record<string, unknown> | undefined>
@@ -36,13 +38,6 @@ export const findKey = <T>(
   return undefined;
 };
 
-export const includes = <T>(array: ReadonlyArray<T>, value: T): boolean => array.includes(value);
-
-export const map = <T, U>(
-  object: Record<string, T> | undefined,
-  iteratee: (value: T, key: string) => U,
-): U[] => (object ? Object.entries(object).map(([key, value]) => iteratee(value, key)) : []);
-
 export const memoize = <F extends (arg: any, ...rest: any[]) => any>(fn: F): F => {
   const cache = new Map<Parameters<F>[0], ReturnType<F>>();
   return ((arg: Parameters<F>[0], ...rest: unknown[]) => {
@@ -53,12 +48,8 @@ export const memoize = <F extends (arg: any, ...rest: any[]) => any>(fn: F): F =
   }) as F;
 };
 
-export const omit = <T extends object, K extends keyof T>(object: T, ...keys: K[]): Omit<T, K> => {
-  const omitted = new Set<PropertyKey>(keys);
-  return Object.fromEntries(
-    Object.entries(object).filter(([key]) => !omitted.has(key)),
-  ) as Omit<T, K>;
-};
+export const omit = <T extends object, K extends keyof T>(object: T, ...keys: K[]): Omit<T, K> =>
+  Struct.omit(object, keys);
 
 export const uniqBy = <T>(items: ReadonlyArray<T>, iteratee: (value: T) => string): T[] => {
   const seen = new Set<string>();
@@ -75,7 +66,5 @@ export const uniqBy = <T>(items: ReadonlyArray<T>, iteratee: (value: T) => strin
 export const deburr = (value: string): string =>
   value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
 
-export const trim = (value: string): string => value.trim();
-
 export const upperFirst = (value: string): string =>
   value.length === 0 ? value : value[0]!.toUpperCase() + value.slice(1);

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

@@ -1,4 +1,4 @@
-import { memoize, omit } from "./lodash";
+import { memoize, omit } from "./compat";
 import { DEFAULT_OPTIONS, type Options } from "./index";
 import { hasComment, hasStandaloneName, T_ANY, T_UNKNOWN } from "./types/AST";
 import type {

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

@@ -3,7 +3,7 @@
 import { readFileSync } from "fs";
 import type { JSONSchema4 } from "./types/json-schema";
 import type { ParserOptions as $RefOptions } from "@apidevtools/json-schema-ref-parser";
-import { cloneDeep, endsWith, merge } from "./lodash";
+import { cloneDeep, merge } from "./compat";
 import { dirname } from "path";
 import { format } from "./formatter";
 import { generate } from "./generator";
@@ -172,7 +172,7 @@ export async function compile(
   }
 
   // normalize options
-  if (!endsWith(_options.cwd, "/")) {
+  if (!_options.cwd.endsWith("/")) {
     _options.cwd += "/";
   }
 

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

@@ -1,6 +1,6 @@
 import { Parent } from "./types/JSONSchema";
 import type { JSONSchema, LinkedJSONSchema } from "./types/JSONSchema";
-import { isPlainObject } from "./lodash";
+import { isPlainObject } from "./compat";
 import type { JSONSchema4Type } from "./types/json-schema";
 
 /**

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

@@ -1,4 +1,4 @@
-import { uniqBy } from "./lodash";
+import { uniqBy } from "./compat";
 import type { Options } from ".";
 import { generateType } from "./generator";
 import { T_ANY, T_UNKNOWN } from "./types/AST";

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

@@ -1,5 +1,5 @@
 import type { JSONSchema4Type, JSONSchema4TypeName } from "./types/json-schema";
-import { findKey, includes, isPlainObject, map, memoize, omit } from "./lodash";
+import { findKey, isPlainObject, memoize, omit } from "./compat";
 import { format } from "util";
 import type { Options } from "./";
 import { applySchemaTyping } from "./applySchemaTyping";
@@ -428,10 +428,11 @@ function parseSchema(
   usedNames: UsedNames,
   parentSchemaName: string,
 ): TInterfaceParam[] {
-  let asts: TInterfaceParam[] = map(schema.properties, (value, key: string) => ({
+  const required = new Set(schema.required ?? []);
+  let asts: TInterfaceParam[] = Object.entries(schema.properties ?? {}).map(([key, value]) => ({
     ast: parse(value, options, key, processed, usedNames),
     isPatternProperty: false,
-    isRequired: includes(schema.required || [], key),
+    isRequired: required.has(key),
     isUnreachableDefinition: false,
     keyName: key,
   }));
@@ -445,15 +446,15 @@ function parseSchema(
       !schema.additionalProperties && Object.keys(schema.patternProperties).length === 1;
 
     asts = asts.concat(
-      map(schema.patternProperties, (value, key: string) => {
+      Object.entries(schema.patternProperties).map(([key, value]) => {
         const ast = parse(value, options, key, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key.replace("*/", "*\\/")}".`;
         ast.comment = ast.comment ? `${ast.comment}\n\n${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || includes(schema.required || [], key),
+          isRequired: singlePatternProperty || required.has(key),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key,
         };
@@ -463,15 +464,15 @@ via the \`patternProperty\` "${key.replace("*/", "*\\/")}".`;
 
   if (options.unreachableDefinitions) {
     asts = asts.concat(
-      map(schema.$defs, (value, key: string) => {
+      Object.entries(schema.$defs ?? {}).map(([key, value]) => {
         const ast = parse(value, options, key, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key}".`;
         ast.comment = ast.comment ? `${ast.comment}\n\n${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: includes(schema.required || [], key),
+          isRequired: required.has(key),
           isUnreachableDefinition: true,
           keyName: key,
         };

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

@@ -1,5 +1,5 @@
 import type { JSONSchema4, JSONSchema4Type, JSONSchema4TypeName } from "./json-schema";
-import { isPlainObject, memoize } from "../lodash";
+import { isPlainObject, memoize } from "../compat";
 
 export type SchemaType =
   | "ALL_OF"

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

@@ -1,4 +1,4 @@
-import { isPlainObject } from "./lodash";
+import { isPlainObject } from "./compat";
 import { isCompound } from "./types/JSONSchema";
 import type { JSONSchema, SchemaType } from "./types/JSONSchema";
 

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

@@ -1,4 +1,4 @@
-import { deburr, isPlainObject, trim, upperFirst } from "./lodash";
+import { deburr, isPlainObject, upperFirst } from "./compat";
 import { basename, dirname, extname, normalize, sep, posix } from "path";
 import {
   Intersection,
@@ -204,7 +204,7 @@ export function toSafeString(string: string): string {
       // uppercase letters after digits, dollars
       .replace(/([\d$]+[a-zA-Z])/g, (match) => match.toUpperCase())
       // uppercase first letter after whitespace
-      .replace(/\s+([a-zA-Z])/g, (match) => trim(match.toUpperCase()))
+      .replace(/\s+([a-zA-Z])/g, (match) => match.toUpperCase().trim())
       // remove remaining whitespace
       .replace(/\s/g, ""),
   );