feat: support logger log level configuration

octoshikari · octoshikari · commit 7e5484e02c9b · 2025-11-17T13:10:48.000+03:00
diff --git a/examples/typescript-us-core/generate.ts b/examples/typescript-us-core/generate.ts
@@ -2,13 +2,14 @@
 // bun run examples/typescript-us-core/generate.ts
 
 import { APIBuilder } from "../../src/api/builder";
+import { LogLevel } from "../../src/utils/codegen-logger";
 
 if (require.main === module) {
     console.log("📦 Generating FHIR R4 Core Types...");
 
     const builder = new APIBuilder()
-        .verbose()
         .throwException()
+        .logLevel(LogLevel.INFO)
         .fromPackage("hl7.fhir.us.core", "6.1.0")
         .typescript({ withDebugComment: false, withProfiles: true })
         .outputTo("./examples/typescript-us-core/fhir-types")
diff --git a/src/api/builder.ts b/src/api/builder.ts
@@ -17,7 +17,7 @@ import { generateTypeSchemas, TypeSchemaCache, TypeSchemaGenerator, TypeSchemaPa
 import { extractNameFromCanonical, packageMetaToFhir, packageMetaToNpm, type TypeSchema } from "@typeschema/types";
 import type { Config, TypeSchemaConfig } from "../config";
 import { formatDuration } from "../utils";
-import { CodegenLogger, createLogger } from "../utils/codegen-logger";
+import { CodegenLogger, createLogger, type LogLevel } from "../utils/codegen-logger";
 import type { GeneratorInput } from "./generators/base/BaseGenerator";
 import { TypeScriptGenerator as TypeScriptGeneratorDepricated } from "./generators/typescript";
 import * as TS2 from "./writer-generator/typescript/index";
@@ -378,6 +378,11 @@ export class APIBuilder {
         return this;
     }
 
+    logLevel(level: LogLevel): APIBuilder {
+        this.logger?.configure({ logLevel: level });
+        return this;
+    }
+
     throwException(enabled = true): APIBuilder {
         this.options.throwException = enabled;
         return this;
diff --git a/src/api/index.ts b/src/api/index.ts
@@ -20,6 +20,7 @@ export type {
     PackageMeta as PackageInfo,
     TypeSchema,
 } from "@typeschema/types";
+export { LogLevel } from "../utils/codegen-logger";
 // Export types and interfaces
 export type {
     APIBuilderOptions,
diff --git a/src/api/writer-generator/typescript/field-accessor.ts b/src/api/writer-generator/typescript/field-accessor.ts
@@ -24,10 +24,7 @@ function isChoiceFieldInstance(field: Field): field is ChoiceFieldInstance {
 /**
  * Check if profile field adds constraints compared to base resource
  */
-function fieldAddsConstraints(
-    profileField: Field,
-    baseField: Field | undefined,
-): boolean {
+function fieldAddsConstraints(profileField: Field, baseField: Field | undefined): boolean {
     if (!baseField) return true; // New field added by profile
     if (isChoiceDeclarationField(profileField) || isChoiceDeclarationField(baseField)) return false;
 
diff --git a/src/typeschema/core/transformer.ts b/src/typeschema/core/transformer.ts
@@ -221,38 +221,38 @@ function extractExtensions(fhirSchema: RichFHIRSchema, logger?: CodegenLogger):
 
     const extensions: ProfileExtension[] = [];
 
-    // Extensions are elements with path containing "extension:" or "modifierExtension:"
+    // Look for extension elements with slicing
     for (const [path, element] of Object.entries(fhirSchema.elements)) {
-        if (path.includes("extension:") || path.includes("modifierExtension:")) {
-            // Extract extension slice name
-            const sliceName = path.split(":")[1];
-            if (!sliceName) continue;
-
-            // Get extension URL from type profile
-            let extensionUrl: string | string[] | undefined;
-            if (element.type) {
-                const types = Array.isArray(element.type) ? element.type : [element.type];
-                for (const t of types) {
-                    const typeObj = typeof t === "string" ? { code: t } : t;
-                    if (typeObj.code === "Extension" && typeObj.profile) {
-                        extensionUrl = typeObj.profile;
-                        break;
-                    }
+        // Check if this is an extension or modifierExtension element with slices
+        if (
+            (path === "extension" ||
+                path === "modifierExtension" ||
+                path.endsWith(".extension") ||
+                path.endsWith(".modifierExtension")) &&
+            element.slicing?.slices
+        ) {
+            // Extract each slice as an extension
+            for (const [sliceName, slice] of Object.entries(element.slicing.slices)) {
+                // Slice contains {match, schema} - we need the schema part
+                const sliceSchema = (slice as any).schema;
+                if (!sliceSchema) continue;
+
+                // Get extension URL from slice schema
+                const extensionUrl = sliceSchema.url;
+
+                if (!extensionUrl) {
+                    logger?.warn(`Cannot determine URL for extension slice '${sliceName}' in ${fhirSchema.url}`);
+                    continue;
                 }
-            }
 
-            if (!extensionUrl) {
-                logger?.warn(`Cannot determine URL for extension ${sliceName} in ${fhirSchema.url}`);
-                continue;
+                extensions.push({
+                    path: sliceName,
+                    profile: extensionUrl,
+                    min: sliceSchema.min,
+                    max: sliceSchema.max !== undefined ? String(sliceSchema.max) : undefined,
+                    mustSupport: sliceSchema.mustSupport,
+                });
             }
-
-            extensions.push({
-                path: sliceName,
-                profile: extensionUrl,
-                min: element.min,
-                max: element.max !== undefined ? String(element.max) : undefined,
-                mustSupport: element.mustSupport,
-            });
         }
     }
 
@@ -298,9 +298,31 @@ function transformProfile(register: Register, fhirSchema: RichFHIRSchema, logger
 
     // Debug extension extraction for us-core-patient
     if (logger && fhirSchema.url?.includes("us-core-patient")) {
-        const extPaths = Object.keys(fhirSchema.elements || {}).filter(p => p.toLowerCase().includes("extension"));
+        const extPaths = Object.keys(fhirSchema.elements || {}).filter((p) => p.toLowerCase().includes("extension"));
         logger.debug(`  [DEBUG] Extension-related paths in elements: ${extPaths.slice(0, 10).join(", ")}`);
         logger.debug(`  [DEBUG] Total extension paths: ${extPaths.length}`);
+
+        // Check the extension element structure
+        const extElement = fhirSchema.elements?.extension;
+        if (extElement) {
+            logger.debug(`  [DEBUG] extension element has slicing: ${extElement.slicing ? "YES" : "NO"}`);
+            logger.debug(`  [DEBUG] extension element type: ${JSON.stringify(extElement.type).substring(0, 100)}`);
+            if (extElement.slicing && extElement.slicing.slices) {
+                logger.debug(`  [DEBUG] slicing discriminator: ${JSON.stringify(extElement.slicing.discriminator)}`);
+                logger.debug(
+                    `  [DEBUG] slicing slices: ${JSON.stringify(Object.keys(extElement.slicing.slices || {}))}`,
+                );
+
+                // Log first slice structure
+                const firstSliceKey = Object.keys(extElement.slicing.slices)[0];
+                if (firstSliceKey) {
+                    const firstSlice = extElement.slicing.slices[firstSliceKey];
+                    logger.debug(
+                        `  [DEBUG] First slice (${firstSliceKey}): ${JSON.stringify(firstSlice).substring(0, 200)}`,
+                    );
+                }
+            }
+        }
     }
 
     // Build nested types
diff --git a/src/utils/codegen-logger.ts b/src/utils/codegen-logger.ts
@@ -19,6 +19,7 @@ export interface LogOptions {
     timestamp?: boolean;
     verbose?: boolean;
     suppressLoggingLevel?: LogLevel[] | "all";
+    logLevel?: LogLevel;
 }
 
 /**
@@ -29,20 +30,29 @@ export class CodegenLogger {
     private dryWarnSet: Set<string> = new Set();
 
     constructor(options: LogOptions = {}) {
+        // Backward compatibility: if verbose is set, use DEBUG level
+        const logLevel = options.logLevel ?? (options.verbose ? LogLevel.DEBUG : LogLevel.INFO);
+
         this.options = {
             timestamp: false,
             verbose: false,
             ...options,
+            logLevel, // Use the computed logLevel (respects options.logLevel or options.verbose)
         };
     }
 
-    private static consoleLevelsMap: Record<LogLevel, Function> = {
-        [LogLevel.INFO]: console.log,
-        [LogLevel.WARN]: console.warn,
-        [LogLevel.ERROR]: console.error,
-        [LogLevel.DEBUG]: console.log,
-        [LogLevel.SILENT]: () => {},
-    };
+    private getConsoleMethod(level: LogLevel): (message: string) => void {
+        switch (level) {
+            case LogLevel.WARN:
+                return console.warn;
+            case LogLevel.ERROR:
+                return console.error;
+            case LogLevel.SILENT:
+                return () => {};
+            default:
+                return console.log;
+        }
+    }
 
     private formatMessage(level: string, message: string, color: (str: string) => string): string {
         const timestamp = this.options.timestamp ? `${pc.gray(new Date().toLocaleTimeString())} ` : "";
@@ -51,14 +61,19 @@ export class CodegenLogger {
     }
 
     private isSuppressed(level: LogLevel): boolean {
-        return (
-            this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level) || false
-        );
+        // Check if this level is explicitly suppressed
+        if (this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level)) {
+            return true;
+        }
+
+        // Check if the message level is below the configured log level
+        const configuredLevel = this.options.logLevel ?? LogLevel.INFO;
+        return level < configuredLevel;
     }
 
     private tryWriteToConsole(level: LogLevel, formattedMessage: string): void {
         if (this.isSuppressed(level)) return;
-        const logFn = CodegenLogger.consoleLevelsMap[level] || console.log;
+        const logFn = this.getConsoleMethod(level);
         logFn(formattedMessage);
     }
 
@@ -105,12 +120,10 @@ export class CodegenLogger {
     }
 
     /**
-     * Debug message (only shows in verbose mode)
+     * Debug message (only shows when logLevel is DEBUG)
      */
     debug(message: string): void {
-        if (this.options.verbose) {
-            this.tryWriteToConsole(LogLevel.DEBUG, this.formatMessage("🐛", message, pc.magenta));
-        }
+        this.tryWriteToConsole(LogLevel.DEBUG, this.formatMessage("🐛", message, pc.magenta));
     }
 
     /**
diff --git a/test/unit/utils/log-level.test.ts b/test/unit/utils/log-level.test.ts
