Remove vendored compiler debug logging

Author: RhysSullivan

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

@@ -11,7 +11,7 @@ import type {
   TNamedInterface,
   TUnion,
 } from "./types/AST";
-import { log, toSafeString } from "./utils";
+import { toSafeString } from "./utils";
 
 export function generate(ast: AST, options = DEFAULT_OPTIONS): string {
   return (
@@ -172,8 +172,6 @@ function generateTypeUnmemoized(ast: AST, options: Options): string {
 export const generateType = memoize(generateTypeUnmemoized);
 
 function generateRawType(ast: AST, options: Options): string {
-  log("magenta", "generator", ast);
-
   if (hasStandaloneName(ast)) {
     return toSafeString(ast.standaloneName);
   }

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

@@ -6,7 +6,6 @@ import { normalize } from "./normalizer";
 import { optimize } from "./optimizer";
 import { parse } from "./parser";
 import { dereference } from "./resolver";
-import { error, isVerbose, log } from "./utils";
 import { validate } from "./validator";
 import { link } from "./linker";
 import { validateOptions } from "./optionValidator";
@@ -145,47 +144,21 @@ export function compile(schema: JSONSchema4, name: string, options: Partial<Opti
 
   const _options = merge({} as Options, DEFAULT_OPTIONS, options);
 
-  const start = Date.now();
-  function time() {
-    return `(${Date.now() - start}ms)`;
-  }
-
   // Initial clone to avoid mutating the input
   const _schema = cloneDeep(schema);
 
   const { dereferencedPaths, dereferencedSchema } = dereference(_schema);
-  if (isVerbose()) {
-    log("green", "dereferencer", time(), "ok Result:", dereferencedSchema);
-  }
-
   const linked = link(dereferencedSchema);
-  if (isVerbose()) {
-    log("green", "linker", time(), "ok No change");
-  }
-
   const errors = validate(linked, name);
   if (errors.length) {
-    errors.forEach((_) => error(_));
-    throw new ValidationError();
-  }
-  if (isVerbose()) {
-    log("green", "validator", time(), "ok No change");
+    throw new ValidationError(errors.join("\n"));
   }
 
   const normalized = normalize(linked, dereferencedPaths, name, _options);
-  log("yellow", "normalizer", time(), "ok Result:", normalized);
-
   const parsed = parse(normalized, _options);
-  log("blue", "parser", time(), "ok Result:", parsed);
-
   const optimized = optimize(parsed, _options);
-  log("cyan", "optimizer", time(), "ok Result:", optimized);
-
   const generated = generate(optimized, _options);
-  log("magenta", "generator", time(), "ok Result:", generated);
-
   const formatted = format(generated, _options);
-  log("white", "formatter", time(), "ok Result:", formatted);
 
   return formatted;
 }

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

@@ -3,7 +3,6 @@ import type { Options } from ".";
 import { generateType } from "./generator";
 import { T_ANY, T_UNKNOWN } from "./types/AST";
 import type { AST } from "./types/AST";
-import { log } from "./utils";
 
 export function optimize(ast: AST, options: Options, processed = new Set<AST>()): AST {
   if (processed.has(ast)) {
@@ -32,13 +31,11 @@ export function optimize(ast: AST, options: Options, processed = new Set<AST>())
 
       // [A, B, C, Any] -> Any
       if (optimizedAST.params.some((_) => _.type === "ANY")) {
-        log("cyan", "optimizer", "[A, B, C, Any] -> Any", optimizedAST);
         return T_ANY;
       }
 
       // [A, B, C, Unknown] -> Unknown
       if (optimizedAST.params.some((_) => _.type === "UNKNOWN")) {
-        log("cyan", "optimizer", "[A, B, C, Unknown] -> Unknown", optimizedAST);
         return T_UNKNOWN;
       }
 
@@ -51,14 +48,12 @@ export function optimize(ast: AST, options: Options, processed = new Set<AST>())
         }) &&
         optimizedAST.params.some((_) => _.standaloneName !== undefined)
       ) {
-        log("cyan", "optimizer", "[A (named), A] -> [A (named)]", optimizedAST);
         optimizedAST.params = optimizedAST.params.filter((_) => _.standaloneName !== undefined);
       }
 
       // [A, B, B] -> [A, B]
       const params = uniqBy(optimizedAST.params, (_) => generateType(_, options));
       if (params.length !== optimizedAST.params.length) {
-        log("cyan", "optimizer", "[A, B, B] -> [A, B]", optimizedAST);
         optimizedAST.params = params;
       }
 

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

@@ -25,7 +25,7 @@ import type {
   SchemaType,
 } from "./types/JSONSchema";
 import { Intersection, Types, getRootSchema, isBoolean, isPrimitive } from "./types/JSONSchema";
-import { generateName, log, maybeStripDefault } from "./utils";
+import { generateName, maybeStripDefault } from "./utils";
 
 export type Processed = Map<NormalizedJSONSchema, Map<SchemaType, AST>>;
 
@@ -66,7 +66,6 @@ export function parse(
       );
     });
 
-    log("blue", "parser", "Types:", [...types], "Input:", normalizedSchema, "Output:", ast);
     return ast;
   }
 
@@ -80,7 +79,6 @@ export function parse(
       processed,
       usedNames,
     );
-    log("blue", "parser", "Type:", type, "Input:", normalizedSchema, "Output:", ast);
     return ast;
   }
 

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

@@ -1,5 +1,4 @@
 import type { JSONSchema } from "./types/JSONSchema";
-import { log } from "./utils";
 
 export type DereferencedPaths = WeakMap<JSONSchema, string>;
 
@@ -134,7 +133,6 @@ export function dereference(schema: JSONSchema): {
   dereferencedPaths: DereferencedPaths;
   dereferencedSchema: JSONSchema;
 } {
-  log("green", "dereferencer", "Dereferencing input schema:", schema);
   const dereferencedPaths: DereferencedPaths = new WeakMap();
   const dereferencedSchema = dereferenceNode(
     schema,

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

@@ -219,42 +219,6 @@ export function generateName(from: string, usedNames: Set<string>) {
   return name;
 }
 
-export function isVerbose(): boolean {
-  const global = globalThis as { process?: { env?: Record<string, string | undefined> } };
-  return global.process?.env?.VERBOSE != null;
-}
-
-export function error(...messages: any[]): void {
-  if (!isVerbose()) {
-    return console.error(messages);
-  }
-  console.error("error", ...messages);
-}
-
-type LogStyle = "blue" | "cyan" | "green" | "magenta" | "red" | "white" | "yellow";
-
-export function log(style: LogStyle, title: string, ...messages: unknown[]): void {
-  if (!isVerbose()) {
-    return;
-  }
-  let lastMessage = null;
-  if (messages.length > 1 && typeof messages[messages.length - 1] !== "string") {
-    lastMessage = messages.splice(messages.length - 1, 1);
-  }
-  console.info("debug", getStyledTextForLogging(style)?.(title), ...messages);
-  if (lastMessage) {
-    console.dir(lastMessage, { depth: 6, maxArrayLength: 6 });
-  }
-}
-
-function getStyledTextForLogging(style: LogStyle): ((text: string) => string) | undefined {
-  if (!isVerbose()) {
-    return;
-  }
-  void style;
-  return (text) => text;
-}
-
 /**
  * escape block comments in schema descriptions so that they don't unexpectedly close JSDoc comments in generated typescript interfaces
  */