new logger with suppression functionality

examples/mustache/mustache-java-r4-gen.ts

@@ -4,7 +4,7 @@ if (require.main === module) {
     console.log("📦 Generating FHIR R4 Core Types...");
 
     const builder = new APIBuilder()
-        .setLogLevel("DEBUG")
+        .setLogLevel("debug")
         .throwException()
         .fromPackage("hl7.fhir.r4.core", "4.0.1")
         .outputTo("./examples/mustache/mustache-java-r4-output")

examples/python/generate.ts

@@ -1,8 +1,14 @@
 import { APIBuilder, prettyReport } from "../../src";
+import { type Logger, makeLogger } from "../../src/utils/logger";
 
 console.log("📦 Generating FHIR R4 Core Types...");
 
-const builder = new APIBuilder()
+const logger: Logger = makeLogger({
+    prefix: "API",
+    suppressTags: ["FIELD_TYPE_NOT_FOUND", "LARGE_VALUESET"],
+});
+
+const builder = new APIBuilder({ logger })
     .throwException()
     .fromPackage("hl7.fhir.r4.core", "4.0.1")
     .python({

src/api/builder.ts

@@ -18,13 +18,7 @@ import type { IrConf, LogicalPromotionConf, TreeShakeConf } from "@root/typesche
 import { type Register, registerFromManager } from "@root/typeschema/register";
 import { type PackageMeta, packageMetaToNpm } from "@root/typeschema/types";
 import { mkTypeSchemaIndex, type TypeSchemaIndex } from "@root/typeschema/utils";
-import {
-    type CodegenLogger,
-    createLogger,
-    type LogLevel,
-    type LogLevelString,
-    parseLogLevel,
-} from "@root/utils/codegen-logger";
+import { type Logger, type LogLevel, makeLogger } from "@root/utils/logger";
 import { IntrospectionWriter, type IntrospectionWriterOptions } from "./writer-generator/introspection";
 import { IrReportWriterWriter, type IrReportWriterWriterOptions } from "./writer-generator/ir-report";
 import type { FileBasedMustacheGeneratorOptions } from "./writer-generator/mustache";
@@ -95,7 +89,7 @@ export interface LocalStructureDefinitionConfig {
     dependencies?: PackageMeta[];
 }
 
-const cleanup = async (opts: APIBuilderOptions, logger: CodegenLogger): Promise<void> => {
+const cleanup = async (opts: APIBuilderOptions, logger: Logger): Promise<void> => {
     logger.info(`Cleaning outputs...`);
     try {
         logger.info(`Clean ${opts.outputDir}`);
@@ -120,14 +114,14 @@ export class APIBuilder {
         localSDs: LocalPackageConfig[];
         localTgzPackages: TgzPackageConfig[];
     };
-    private logger: CodegenLogger;
+    private logger: Logger;
     private generators: { name: string; writer: FileSystemWriter }[] = [];
 
     constructor(
         userOpts: Partial<APIBuilderOptions> & {
             manager?: ReturnType<typeof CanonicalManager>;
             register?: Register;
-            logger?: CodegenLogger;
+            logger?: Logger;
         } = {},
     ) {
         const defaultOpts: APIBuilderOptions = {
@@ -137,7 +131,7 @@ export class APIBuilder {
             treeShake: undefined,
             promoteLogical: undefined,
             registry: undefined,
-            logLevel: parseLogLevel("INFO"),
+            logLevel: "info",
             dropCanonicalManagerCache: false,
         };
         const opts: APIBuilderOptions = {
@@ -167,7 +161,7 @@ export class APIBuilder {
                 registry: userOpts.registry,
                 dropCache: userOpts.dropCanonicalManagerCache,
             });
-        this.logger = userOpts.logger ?? createLogger({ prefix: "API", level: opts.logLevel });
+        this.logger = userOpts.logger ?? makeLogger({ prefix: "API", level: opts.logLevel });
         this.options = opts;
     }
 
@@ -328,8 +322,8 @@ export class APIBuilder {
         return this;
     }
 
-    setLogLevel(level: LogLevel | LogLevelString): APIBuilder {
-        this.logger?.setLevel(typeof level === "string" ? parseLogLevel(level) : level);
+    setLogLevel(level: LogLevel): APIBuilder {
+        this.logger?.setLevel(level);
         return this;
     }
 
@@ -437,7 +431,7 @@ export class APIBuilder {
 
             this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
         } catch (error) {
-            this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)));
+            this.logger.error(`Code generation failed: ${error instanceof Error ? error.message : String(error)}`);
             result.errors.push(error instanceof Error ? error.message : String(error));
             if (this.options.throwException) throw error;
         }

src/api/index.ts

@@ -8,7 +8,7 @@
  */
 
 export type { IrConf, LogicalPromotionConf, TreeShakeConf } from "../typeschema/ir/types";
-export { LogLevel } from "../utils/codegen-logger";
+export type { LogLevel } from "../utils/logger";
 export type { APIBuilderOptions, LocalStructureDefinitionConfig } from "./builder";
 export { APIBuilder, prettyReport } from "./builder";
 export type { CSharpGeneratorOptions } from "./writer-generator/csharp/csharp";

src/api/writer-generator/mustache.ts

@@ -22,7 +22,7 @@ import type {
     ViewModel,
 } from "@mustache/types";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Logger } from "@root/utils/logger";
 import { default as Mustache } from "mustache";
 import { FileSystemWriter, type FileSystemWriterOptions } from "./writer";
 
@@ -57,7 +57,7 @@ export type MustacheGeneratorOptions = FileSystemWriterOptions &
 
 export function loadMustacheGeneratorConfig(
     templatePath: string,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): Partial<FileBasedMustacheGeneratorOptions> {
     const filePath = Path.resolve(templatePath, "config.json");
     try {

src/api/writer-generator/writer.ts

@@ -2,12 +2,12 @@ import * as fs from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import * as Path from "node:path";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Logger } from "@root/utils/logger";
 
 export type FileSystemWriterOptions = {
     outputDir: string;
     inMemoryOnly?: boolean;
-    logger?: CodegenLogger;
+    logger?: Logger;
     resolveAssets?: (fn: string) => string;
 };
 
@@ -36,7 +36,7 @@ export abstract class FileSystemWriter<T extends FileSystemWriterOptions = FileS
         this.opts.outputDir = path;
     }
 
-    logger(): CodegenLogger | undefined {
+    logger(): Logger | undefined {
         return this.opts.logger;
     }
 

src/cli/commands/typeschema/generate.ts

@@ -6,7 +6,8 @@
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { complete, createLogger, list } from "@root/utils/codegen-logger";
+import { complete, list } from "@root/utils/codegen-logger";
+import { makeLogger } from "@root/utils/logger";
 import { generateTypeSchemas } from "@typeschema/index";
 import { registerFromPackageMetas } from "@typeschema/register";
 import type { PackageMeta } from "@typeschema/types";
@@ -73,12 +74,12 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
         },
     },
     handler: async (argv) => {
-        const logger = createLogger({
+        const logger = makeLogger({
             prefix: "TypeSchema",
         });
 
         try {
-            logger.step("Generating TypeSchema from FHIR packages");
+            logger.info("Generating TypeSchema from FHIR packages");
             logger.info(`Packages: ${argv.packages.join(", ")}`);
             logger.info(`Output: ${argv.output}`);
 
@@ -113,7 +114,7 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
                 return { name: packageSpec, version: "latest" };
             });
 
-            logger.progress(`Processing packages: ${packageMetas.map((p) => `${p.name}@${p.version}`).join(", ")}`);
+            logger.info(`Processing packages: ${packageMetas.map((p) => `${p.name}@${p.version}`).join(", ")}`);
 
             // Create register from packages
             const register = await registerFromPackageMetas(packageMetas, {
@@ -149,7 +150,7 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
 
             const duration = Date.now() - startTime;
             complete(`Generated ${allSchemas.length} TypeSchema definitions`, duration, { schemas: allSchemas.length });
-            logger.dim(`Output: ${outputPath}`);
+            logger.info(`Output: ${outputPath}`);
 
             if (argv.verbose) {
                 logger.debug("Generated schemas:");
@@ -160,7 +161,7 @@ export const generateTypeschemaCommand: CommandModule<Record<string, unknown>, G
                 list(schemaNames);
             }
         } catch (error) {
-            logger.error("Failed to generate TypeSchema", error instanceof Error ? error : new Error(String(error)));
+            logger.error(`Failed to generate TypeSchema: ${error instanceof Error ? error.message : String(error)}`);
             process.exit(1);
         }
     },

src/typeschema/core/binding.ts

@@ -7,7 +7,7 @@
 import assert from "node:assert";
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { CodeSystem, CodeSystemConcept } from "@root/fhir-types/hl7-fhir-r4-core";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Logger } from "@root/utils/logger";
 import type { Register } from "@typeschema/register";
 import type {
     BindingTypeSchema,
@@ -24,19 +24,15 @@ export function extractValueSetConceptsByUrl(
     register: Register,
     pkg: PackageMeta,
     valueSetUrl: CanonicalUrl,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): Concept[] | undefined {
     const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
     const valueSet = register.resolveVs(pkg, cleanUrl as CanonicalUrl);
     if (!valueSet) return undefined;
     return extractValueSetConcepts(register, valueSet, logger);
 }
 
-function extractValueSetConcepts(
-    register: Register,
-    valueSet: RichValueSet,
-    _logger?: CodegenLogger,
-): Concept[] | undefined {
+function extractValueSetConcepts(register: Register, valueSet: RichValueSet, _logger?: Logger): Concept[] | undefined {
     if (valueSet.expansion?.contains) {
         return valueSet.expansion.contains
             .filter((item) => item.code !== undefined)
@@ -106,7 +102,7 @@ export function buildEnum(
     register: Register,
     fhirSchema: RichFHIRSchema,
     element: FHIRSchemaElement,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): EnumDefinition | undefined {
     if (!element.binding) return undefined;
 
@@ -115,7 +111,7 @@ export function buildEnum(
     if (!valueSetUrl) return undefined;
 
     if (!BINDABLE_TYPES.has(element.type ?? "")) {
-        logger?.dryWarn(`eld-11: Binding on non-bindable type '${element.type}' (valueSet: ${valueSetUrl})`);
+        logger?.dryWarn("BINDING", `eld-11: Binding on non-bindable type '${element.type}' (valueSet: ${valueSetUrl})`);
         return undefined;
     }
 
@@ -132,6 +128,7 @@ export function buildEnum(
 
     if (codes.length > MAX_ENUM_LENGTH) {
         logger?.dryWarn(
+            "LARGE_VALUESET",
             `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`,
         );
         return undefined;
@@ -146,7 +143,7 @@ function generateBindingSchema(
     fhirSchema: RichFHIRSchema,
     path: string[],
     element: FHIRSchemaElement,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): BindingTypeSchema | undefined {
     if (!element.binding?.valueSet) return undefined;
 
@@ -171,7 +168,7 @@ function generateBindingSchema(
 export function collectBindingSchemas(
     register: Register,
     fhirSchema: RichFHIRSchema,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): BindingTypeSchema[] {
     const processedPaths = new Set<string>();
     if (!fhirSchema.elements) return [];

src/typeschema/core/field-builder.ts

@@ -6,7 +6,7 @@
 
 import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Logger } from "@root/utils/logger";
 import { packageMetaToFhir } from "@typeschema/types";
 import type {
     BindingIdentifier,
@@ -126,7 +126,7 @@ export function buildFieldType(
     fhirSchema: RichFHIRSchema,
     path: string[],
     element: FHIRSchemaElement,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): Identifier | undefined {
     if (element.elementReference) {
         const refPath = element.elementReference
@@ -149,6 +149,7 @@ export function buildFieldType(
         // Some packages (e.g., simplifier.core.r4.*) have incomplete element definitions
         // Log a warning but continue processing instead of throwing
         logger?.dryWarn(
+            "FIELD_TYPE_NOT_FOUND",
             `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): missing type info`,
         );
         return undefined;
@@ -160,7 +161,7 @@ export const mkField = (
     fhirSchema: RichFHIRSchema,
     path: string[],
     element: FHIRSchemaElement,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): Field => {
     let binding: BindingIdentifier | undefined;
     let enumResult: EnumDefinition | undefined;
@@ -175,7 +176,10 @@ export const mkField = (
     const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
     // TODO: should be an exception
     if (!fieldType)
-        logger?.dryWarn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
+        logger?.dryWarn(
+            "FIELD_TYPE_NOT_FOUND",
+            `Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`,
+        );
     return {
         type: fieldType as Identifier,
         required: isRequired(register, fhirSchema, path),
@@ -221,7 +225,7 @@ export function mkNestedField(
     fhirSchema: RichFHIRSchema,
     path: string[],
     element: FHIRSchemaElement,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): RegularField {
     const nestedIdentifier = mkNestedIdentifier(register, fhirSchema, path, logger);
     return {

src/typeschema/core/nested-types.ts

@@ -6,15 +6,15 @@
 
 import type { FHIRSchema, FHIRSchemaElement } from "@atomic-ehr/fhirschema";
 import type { Register } from "@root/typeschema/register";
-import type { CodegenLogger } from "@root/utils/codegen-logger";
+import type { Logger } from "@root/utils/logger";
 import type { CanonicalUrl, Field, Identifier, Name, NestedIdentifier, NestedType, RichFHIRSchema } from "../types";
 import { isNestedElement, mkField, mkNestedField } from "./field-builder";
 
 export function mkNestedIdentifier(
     register: Register,
     fhirSchema: RichFHIRSchema,
     path: string[],
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): NestedIdentifier {
     // NOTE: profiles should no redefine types, they should reuse already defined in previous specializations
     const nestedTypeOrigins = {} as Record<Name, CanonicalUrl>;
@@ -69,7 +69,7 @@ function transformNestedElements(
     fhirSchema: RichFHIRSchema,
     parentPath: string[],
     elements: Record<string, FHIRSchemaElement>,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): Record<string, Field> {
     const fields: Record<string, Field> = {};
 
@@ -90,7 +90,7 @@ function transformNestedElements(
 export function mkNestedTypes(
     register: Register,
     fhirSchema: RichFHIRSchema,
-    logger?: CodegenLogger,
+    logger?: Logger,
 ): NestedType[] | undefined {
     if (!fhirSchema.elements) return undefined;