Fix initialization of loggers that check process.env.DEBUG; quiet templating logs

shared/src/model-visitor/logging-visitor.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { LoggingVisitor } from './logging-visitor';
 import { CalmCore } from '../model/core';
-import {CalmCoreSchema} from '../types/core-types';
+import { CalmCoreSchema } from '../types/core-types';
 
 describe('LoggingVisitor', () => {
 
@@ -24,7 +24,7 @@ describe('LoggingVisitor', () => {
                     }
                 ],
                 'details': {
-                    'detailed-architecture':  'http://example.com/arch-detail'
+                    'detailed-architecture': 'http://example.com/arch-detail'
                 }
             },
             {
@@ -82,11 +82,10 @@ describe('LoggingVisitor', () => {
         };
 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (LoggingVisitor as any).logger = logger;
         const json = JSON.stringify(testArch, null, 2);
         const architecture: CalmCoreSchema = JSON.parse(json);
         const core = CalmCore.fromSchema(architecture);
-        const visitor = new LoggingVisitor();
+        const visitor = new LoggingVisitor((logger as Logger));
         await visitor.visit(core);
 
         const logLines = logger.info.mock.calls.map(args => args[0]);

shared/src/model-visitor/logging-visitor.ts

@@ -1,12 +1,24 @@
-import {Resolvable, ResolvableAndAdaptable} from '../model/resolvable';
-import {CalmModelVisitor} from './calm-model-visitor';
-import { initLogger } from '../logger.js';
+import { Resolvable, ResolvableAndAdaptable } from '../model/resolvable';
+import { CalmModelVisitor } from './calm-model-visitor';
+import { initLogger, Logger } from '../logger.js';
 
 export class LoggingVisitor implements CalmModelVisitor {
-    private static logger = initLogger(process.env.DEBUG === 'true', LoggingVisitor.name);
+    private static _logger: Logger | undefined;
+    private readonly _loggerInstance?: Logger;
+
+    constructor(logger?: Logger) {
+        this._loggerInstance = logger;
+    }
+
+    private static get logger(): Logger {
+        if (!this._logger) {
+            this._logger = initLogger(process.env.DEBUG === 'true', LoggingVisitor.name);
+        }
+        return this._logger;
+    }
 
     async visit(obj: unknown, path: string[] = []): Promise<void> {
-        const logger = LoggingVisitor.logger;
+        const logger = this._loggerInstance ?? LoggingVisitor.logger;
         if (!obj || typeof obj !== 'object') return;
         const keys = Object.keys(obj);
         for (const key of keys) {

shared/src/resolver/calm-reference-resolver.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { initLogger } from '../logger.js';
+import { initLogger, Logger } from '../logger.js';
 import axios from 'axios';
 
 export interface CalmReferenceResolver {
@@ -8,8 +8,14 @@ export interface CalmReferenceResolver {
 }
 
 export class FileReferenceResolver implements CalmReferenceResolver {
+    private static _logger: Logger | undefined;
 
-    private static logger = initLogger(process.env.DEBUG === 'true', FileReferenceResolver.name);
+    private static get logger(): Logger {
+        if (!this._logger) {
+            this._logger = initLogger(process.env.DEBUG === 'true', FileReferenceResolver.name);
+        }
+        return this._logger;
+    }
 
     canResolve(ref: string): boolean {
         return fs.existsSync(ref);
@@ -48,7 +54,14 @@ export class InMemoryResolver implements CalmReferenceResolver {
 
 
 export class HttpReferenceResolver implements CalmReferenceResolver {
-    private static logger = initLogger(process.env.DEBUG === 'true', HttpReferenceResolver.name);
+    private static _logger: Logger | undefined;
+
+    private static get logger(): Logger {
+        if (!this._logger) {
+            this._logger = initLogger(process.env.DEBUG === 'true', HttpReferenceResolver.name);
+        }
+        return this._logger;
+    }
 
     canResolve(ref: string): boolean {
         return ref.startsWith('http://') || ref.startsWith('https://');
@@ -70,7 +83,15 @@ export class HttpReferenceResolver implements CalmReferenceResolver {
 }
 
 export class CompositeReferenceResolver implements CalmReferenceResolver {
-    private static logger = initLogger(process.env.DEBUG === 'true', CompositeReferenceResolver.name);
+    private static _logger: Logger | undefined;
+
+    private static get logger(): Logger {
+        if (!this._logger) {
+            this._logger = initLogger(process.env.DEBUG === 'true', CompositeReferenceResolver.name);
+        }
+        return this._logger;
+    }
+
     private httpResolver: HttpReferenceResolver;
     private fileResolver: FileReferenceResolver;
 
@@ -107,7 +128,7 @@ export class MappedReferenceResolver implements CalmReferenceResolver {
     constructor(
         private mapping: Map<string, string>,
         private delegate: CalmReferenceResolver
-    ) {}
+    ) { }
 
     canResolve(ref: string): boolean {
         const effective = this.getEffectiveRef(ref);

shared/src/template/template-bundle-file-loader.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import {IndexFile, TemplateEntry} from './types.js';
-import { initLogger } from '../logger.js';
+import { IndexFile, TemplateEntry } from './types.js';
+import { initLogger, Logger } from '../logger.js';
 
 
 export interface ITemplateBundleLoader {
@@ -88,7 +88,14 @@ export class TemplateBundleFileLoader implements ITemplateBundleLoader {
     private readonly templateBundlePath: string;
     private readonly config: IndexFile;
     private readonly templateFiles: Record<string, string>;
-    private static logger = initLogger(process.env.DEBUG === 'true', TemplateBundleFileLoader.name);
+    private static _logger: Logger | undefined;
+
+    private static get logger(): Logger {
+        if (!this._logger) {
+            this._logger = initLogger(process.env.DEBUG === 'true', TemplateBundleFileLoader.name);
+        }
+        return this._logger;
+    }
 
     constructor(templateBundlePath: string) {
         this.templateBundlePath = templateBundlePath;

shared/src/template/template-engine.spec.ts

@@ -14,6 +14,7 @@ vi.mock('./template-path-extractor.js');
 describe('TemplateEngine', () => {
     let mockFileLoader: ReturnType<typeof vi.mocked<TemplateBundleFileLoader>>;
     let mockTransformer: ReturnType<typeof vi.mocked<CalmTemplateTransformer>>;
+    let loggerDebugSpy: ReturnType<typeof vi.spyOn>;
     let loggerInfoSpy: ReturnType<typeof vi.spyOn>;
     let loggerWarnSpy: ReturnType<typeof vi.spyOn>;
     const testOutputDir = './test-output';
@@ -29,6 +30,7 @@ describe('TemplateEngine', () => {
             getTransformedModel: vi.fn(),
         } as unknown as ReturnType<typeof vi.mocked<CalmTemplateTransformer>>;
 
+        loggerDebugSpy = vi.spyOn(TemplateEngine['logger'], 'debug').mockImplementation(vi.fn());
         loggerInfoSpy = vi.spyOn(TemplateEngine['logger'], 'info').mockImplementation(vi.fn());
         loggerWarnSpy = vi.spyOn(TemplateEngine['logger'], 'warn').mockImplementation(vi.fn());
 
@@ -119,7 +121,7 @@ describe('TemplateEngine', () => {
 
         vi.spyOn(fs, 'existsSync').mockReturnValue(false);
         const mkdirSyncSpy = vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
-        const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
+        const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync').mockImplementation(() => { });
 
         const engine = new TemplateEngine(mockFileLoader, mockTransformer);
 
@@ -156,7 +158,7 @@ describe('TemplateEngine', () => {
 
         vi.spyOn(fs, 'existsSync').mockReturnValue(false);
         const mkdirSyncSpy = vi.spyOn(fs, 'mkdirSync').mockImplementation(() => undefined);
-        const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
+        const writeFileSyncSpy = vi.spyOn(fs, 'writeFileSync').mockImplementation(() => { });
 
         const engine = new TemplateEngine(mockFileLoader, mockTransformer);
 
@@ -276,7 +278,7 @@ describe('TemplateEngine', () => {
             new TemplateEngine(mockFileLoader, mockTransformer);
 
             expect(TemplatePreprocessor.preprocessTemplate).toHaveBeenCalledWith(originalTemplate);
-            expect(loggerInfoSpy).toHaveBeenCalledWith(preprocessedTemplate);
+            expect(loggerDebugSpy).toHaveBeenCalledWith(preprocessedTemplate);
         });
     });
 

shared/src/template/template-engine.ts

@@ -1,18 +1,25 @@
 /* eslint-disable  @typescript-eslint/no-explicit-any */
 import Handlebars from 'handlebars';
 import { IndexFile, TemplateEntry, CalmTemplateTransformer } from './types.js';
-import {ITemplateBundleLoader} from './template-bundle-file-loader.js';
-import { initLogger } from '../logger.js';
+import { ITemplateBundleLoader } from './template-bundle-file-loader.js';
+import { initLogger, Logger } from '../logger.js';
 import fs from 'fs';
 import path from 'path';
-import {TemplatePathExtractor} from './template-path-extractor.js';
-import {TemplatePreprocessor} from './template-preprocessor.js';
+import { TemplatePathExtractor } from './template-path-extractor.js';
+import { TemplatePreprocessor } from './template-preprocessor.js';
 
 export class TemplateEngine {
     private readonly templates: Record<string, Handlebars.TemplateDelegate>;
     private readonly config: IndexFile;
     private transformer: CalmTemplateTransformer;
-    private static logger = initLogger(process.env.DEBUG === 'true', TemplateEngine.name);
+    private static _logger: Logger | undefined;
+
+    private static get logger(): Logger {
+        if (!this._logger) {
+            this._logger = initLogger(process.env.DEBUG === 'true', TemplateEngine.name);
+        }
+        return this._logger;
+    }
 
     constructor(fileLoader: ITemplateBundleLoader, transformer: CalmTemplateTransformer) {
         this.config = fileLoader.getConfig();
@@ -27,7 +34,7 @@ export class TemplateEngine {
 
         for (const [fileName, content] of Object.entries(templateFiles)) {
             const preprocessed = TemplatePreprocessor.preprocessTemplate(content);
-            logger.info(preprocessed);
+            logger.debug(preprocessed);
             compiledTemplates[fileName] = Handlebars.compile(preprocessed);
         }