@open-mercato/shared 0.6.6-develop.6460.1.f94c74174c → 0.6.6-develop.6471.1.9ab5bdd79a

package/src/modules/__tests__/route-overrides.test.ts

@@ -26,7 +26,22 @@ import {
   resetModuleContractOverridesForTests,
   type ApiRouteOverridesMap,
 } from '../overrides'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+jest.mock('@open-mercato/shared/lib/logger', () => {
+  const mocked = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: jest.fn(),
+  }
+  mocked.child.mockImplementation(() => mocked)
+  return { createLogger: jest.fn(() => mocked) }
+})
+const loggerWarn = createLogger('shared').warn as jest.Mock
 import {
+
   getApiRouteManifests,
   getBackendRouteManifests,
   getFrontendRouteManifests,
@@ -165,20 +180,19 @@ describe('applyApiOverridesToManifests', () => {
   })
 
   it('warns when an override key does not match any manifest entry', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
     applyApiOverridesToManifests([makeEntry('a', '/api/foo', ['GET'])], {
       'GET /api/missing': null,
     })
-    const staleCalls = warnSpy.mock.calls.filter((args) =>
+    const staleCalls = loggerWarn.mock.calls.filter((args) =>
       typeof args[0] === 'string' && args[0].includes('did not match any registered API route'),
     )
     expect(staleCalls).toHaveLength(1)
-    expect(staleCalls[0][0]).toContain('GET /api/missing')
-    warnSpy.mockRestore()
+    expect(staleCalls[0][1]).toEqual(expect.objectContaining({ key: 'GET /api/missing' }))
   })
 
   it('skips malformed override values (not null and not a definition)', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
     const entries = [makeEntry('a', '/api/foo', ['GET'])]
     const result = applyApiOverridesToManifests(entries, {
       // @ts-expect-error intentionally malformed
@@ -186,8 +200,7 @@ describe('applyApiOverridesToManifests', () => {
     })
     expect(result).toHaveLength(1)
     expect(result[0].methods).toEqual(['GET'])
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
+    expect(loggerWarn).toHaveBeenCalled()
   })
 })
 
@@ -203,17 +216,16 @@ describe('applyApiRouteOverrides (programmatic)', () => {
   })
 
   it('warns on malformed keys and skips them', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
     applyApiRouteOverrides({
       'NOT_A_METHOD /api/foo': null,
       'GET': null,
       '': null,
     })
     expect(Object.keys(composeApiRouteOverrides())).toHaveLength(0)
-    expect(warnSpy.mock.calls.filter((c) =>
+    expect(loggerWarn.mock.calls.filter((c) =>
       typeof c[0] === 'string' && c[0].includes('malformed routes.api key'),
     )).toHaveLength(3)
-    warnSpy.mockRestore()
   })
 
   it('supersedes modules.ts inline overrides for the same key', () => {
@@ -231,23 +243,22 @@ describe('applyApiRouteOverrides (programmatic)', () => {
 
 describe('dispatcher → routes applier', () => {
   it('routes `overrides.routes.api` to the wired applier without the "not yet wired" warning', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
     applyModuleOverridesFromEnabledModules([
       {
         id: 'app',
         overrides: { routes: { api: { 'GET /api/foo': null } } },
       },
     ])
-    const unwiredCalls = warnSpy.mock.calls.filter((args) =>
-      typeof args[0] === 'string' && args[0].includes('Domain "routes" not yet wired'),
+    const unwiredCalls = loggerWarn.mock.calls.filter((args) =>
+      typeof args[0] === 'string' && args[0].includes('not yet wired') && args[1]?.domain === 'routes',
     )
     expect(unwiredCalls).toHaveLength(0)
     expect(composeApiRouteOverrides()['GET /api/foo']).toBeNull()
-    warnSpy.mockRestore()
   })
 
   it('routes `overrides.routes.pages` to the page override composer', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
     applyModuleOverridesFromEnabledModules([
       {
         id: 'first',
@@ -271,7 +282,7 @@ describe('dispatcher → routes applier', () => {
         },
       },
     ])
-    const unwiredCalls = warnSpy.mock.calls.filter((args) =>
+    const unwiredCalls = loggerWarn.mock.calls.filter((args) =>
       typeof args[0] === 'string' && args[0].includes('not yet wired'),
     )
     expect(unwiredCalls).toHaveLength(0)
@@ -280,7 +291,6 @@ describe('dispatcher → routes applier', () => {
       'backend:/backend/bar': null,
       'frontend:/store': { metadata: { title: 'Store Override' } },
     })
-    warnSpy.mockRestore()
   })
 
   it('preserves module load order when multiple entries override the same key (last wins)', () => {
@@ -301,7 +311,7 @@ describe('dispatcher → routes applier', () => {
   })
 
   it('ignores malformed sub-keys but still processes well-formed ones', () => {
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    loggerWarn.mockClear()
     const handler = makeHandler('ok')
     applyModuleOverridesFromEnabledModules([
       {
@@ -317,10 +327,9 @@ describe('dispatcher → routes applier', () => {
       },
     ])
     expect(composeApiRouteOverrides()['GET /api/ok']).toEqual({ handler })
-    expect(warnSpy.mock.calls.filter((c) =>
+    expect(loggerWarn.mock.calls.filter((c) =>
       typeof c[0] === 'string' && c[0].includes('malformed routes.api key'),
     )).toHaveLength(1)
-    warnSpy.mockRestore()
   })
 })
 

package/src/modules/analytics.ts

@@ -1,3 +1,7 @@
+import { createLogger } from '../lib/logger'
+
+const logger = createLogger('shared').child({ component: 'analytics-registry' })
+
 export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max'
 
 export type DateGranularity = 'day' | 'week' | 'month' | 'quarter' | 'year'
@@ -38,7 +42,7 @@ let _analyticsModuleConfigs: AnalyticsModuleConfig[] | null = null
 
 export function registerAnalyticsModuleConfigs(configs: AnalyticsModuleConfig[]): void {
   if (_analyticsModuleConfigs !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Analytics module configs re-registered (this may occur during HMR)')
+    logger.debug('Analytics module configs re-registered (this may occur during HMR)')
   }
   _analyticsModuleConfigs = configs
 }

package/src/modules/dashboard/widgets.ts

@@ -1,4 +1,7 @@
 import React, { type ComponentType } from 'react'
+import { createLogger } from '../../lib/logger'
+
+const logger = createLogger('dashboard').child({ component: 'widgets' })
 
 export type DashboardWidgetSize = 'sm' | 'md' | 'lg'
 
@@ -94,7 +97,7 @@ export function lazyDashboardWidget<TSettings>(
         .catch((err) => {
           if (!cancelled) {
             try {
-              console.error('Failed to load dashboard widget component', err)
+              logger.error('Failed to load dashboard widget component', { err })
             } catch {}
             setTick((value) => value + 1)
           }

package/src/modules/events/factory.ts

@@ -4,6 +4,7 @@
  * Provides factory functions for creating type-safe event configurations.
  */
 
+import { createLogger } from '../../lib/logger'
 import type {
   EventDefinition,
   EventModuleConfig,
@@ -13,6 +14,8 @@ import type {
   ModuleEventEmitter,
 } from './types'
 
+const logger = createLogger('events').child({ component: 'factory' })
+
 // =============================================================================
 // Global Event Bus Reference
 // =============================================================================
@@ -130,7 +133,7 @@ let _registeredEventConfigs: EventModuleConfig[] | null = null
  */
 export function registerEventModuleConfigs(configs: EventModuleConfig[]): void {
   if (_registeredEventConfigs !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Event module configs re-registered (this may occur during HMR)')
+    logger.debug('Event module configs re-registered (this may occur during HMR)')
   }
   _registeredEventConfigs = configs
   for (const config of configs) {
@@ -224,7 +227,7 @@ export function createModuleEvents<
       if (strict) {
         throw new Error(message)
       } else {
-        console.error(message)
+        logger.error('Module tried to emit undeclared event — add it to the module events.ts first', { moduleId, eventId })
         // In non-strict mode, still emit but with warning
       }
     }
@@ -232,7 +235,7 @@ export function createModuleEvents<
     // Get event bus from global reference
     const eventBus = getGlobalEventBus()
     if (!eventBus) {
-      console.warn(`[events] Event bus not available, cannot emit "${eventId}"`)
+      logger.warn('Event bus not available, cannot emit event', { eventId })
       return
     }
 

package/src/modules/overrides.ts

@@ -59,6 +59,7 @@ export interface AiOverridesShape {
   extensions?: unknown[]
 }
 
+
 type LooseOverrideMap = Record<string, unknown>
 
 /**
@@ -270,9 +271,7 @@ export function applyModuleOverridesFromEnabledModules(
       if (!warnedUnwiredDomains.has(domain)) {
         warnedUnwiredDomains.add(domain)
         const moduleIds = Array.from(new Set(entries.map((e) => e.moduleId))).join(', ')
-        console.warn(
-          `[Module Overrides] Domain "${domain}" not yet wired — entry.overrides.${domain} for module(s) [${moduleIds}] was ignored. ${TRACKING_ISSUE_HINT}`,
-        )
+        logger.warn('Override domain not yet wired — entry ignored', { domain, moduleIds, hint: TRACKING_ISSUE_HINT })
       }
       continue
     }
@@ -330,6 +329,7 @@ import type {
   ModuleSubscriber,
   ModuleWorker,
 } from './registry'
+import { createLogger } from '../lib/logger'
 import type { ModuleInjectionTable } from './widgets/injection'
 import type { ComponentOverride } from './widgets/component-registry'
 import type { NotificationHandler } from './notifications/handler'
@@ -341,6 +341,8 @@ import type { ResponseEnricher } from '../lib/crud/response-enricher'
 import type { CommandInterceptor } from '../lib/commands/command-interceptor'
 import type { PageMiddlewareRegistryEntry, PageRouteMiddleware } from './middleware/page'
 
+const logger = createLogger('shared').child({ component: 'module-overrides' })
+
 /** Override for a single API route entry: replace handler/metadata, or `null` to disable. */
 export interface ApiRouteOverrideDefinition {
   /** Replacement handler. Same signature as the original API route handler. */
@@ -443,7 +445,7 @@ function normalizeIdOverrideKey(key: string, label: string): string | null {
   if (typeof key !== 'string') return null
   const trimmed = key.trim()
   if (trimmed) return trimmed
-  console.warn(`[Module Overrides] Skipping malformed ${label} key "${key}" — expected a non-empty string.`)
+  logger.warn('Skipping malformed override key — expected a non-empty string', { label, key })
   return null
 }
 
@@ -514,17 +516,13 @@ function applyArrayOverrides<T>(
     const replacement = overrides[id]
     if (replacement === null) continue
     if (options.isReplacement && !options.isReplacement(replacement)) {
-      console.warn(
-        `[Module Overrides] Skipping malformed ${options.label} override for "${id}" — replacement has the wrong shape.`,
-      )
+      logger.warn('Skipping malformed override — replacement has the wrong shape', { label: options.label, id })
       result.push(item)
       continue
     }
     const replacementId = options.getId(replacement)
     if (replacementId !== id) {
-      console.warn(
-        `[Module Overrides] Skipping malformed ${options.label} override for "${id}" — replacement id must match the override key.`,
-      )
+      logger.warn('Skipping malformed override — replacement id must match the override key', { label: options.label, id })
       result.push(item)
       continue
     }
@@ -537,7 +535,7 @@ function applyArrayOverrides<T>(
 function warnStaleOverrides(label: string, overrides: Readonly<Record<string, unknown>>, consumed: ReadonlySet<string>): void {
   for (const key of Object.keys(overrides)) {
     if (!consumed.has(key)) {
-      console.warn(`[Module Overrides] ${label} override "${key}" did not match any registered entry — override skipped.`)
+      logger.warn('Override did not match any registered entry — override skipped', { label, key })
     }
   }
 }
@@ -686,9 +684,7 @@ export function applyApiRouteOverrides(overrides: ApiRouteOverridesMap): void {
   for (const [rawKey, value] of Object.entries(overrides)) {
     const key = normalizeApiRouteOverrideKey(rawKey)
     if (!key) {
-      console.warn(
-        `[Module Overrides] Skipping malformed routes.api key "${rawKey}" — expected "METHOD /api/path".`,
-      )
+      logger.warn('Skipping malformed routes.api key — expected "METHOD /api/path"', { key: rawKey })
       continue
     }
     programmaticApiRouteOverrides[key] = value
@@ -929,9 +925,7 @@ export function applyApiOverridesToManifests<T extends ApiRouteManifestEntry>(
         methodOverrides.set(method, value)
         remainingMethods.push(method)
       } else {
-        console.warn(
-          `[Module Overrides] Skipping malformed routes.api override for "${key}" — expected { handler, metadata? } or null.`,
-        )
+        logger.warn('Skipping malformed routes.api override — expected { handler, metadata? } or null', { key })
         remainingMethods.push(method)
       }
     }
@@ -971,9 +965,7 @@ export function applyApiOverridesToManifests<T extends ApiRouteManifestEntry>(
 
   for (const key of overrideKeys) {
     if (!consumedKeys.has(key)) {
-      console.warn(
-        `[Module Overrides] routes.api override "${key}" did not match any registered API route — override skipped.`,
-      )
+      logger.warn('routes.api override did not match any registered API route — override skipped', { key })
     }
   }
 
@@ -990,9 +982,7 @@ export function applyPageOverridesToManifests<T extends BackendRouteManifestEntr
   for (const [rawKey, value] of Object.entries(overrides)) {
     const key = normalizePageRouteOverrideKey(rawKey)
     if (!key) {
-      console.warn(
-        `[Module Overrides] Skipping malformed routes.pages key "${rawKey}" — expected "/backend/path" or "/frontend/path".`,
-      )
+      logger.warn('Skipping malformed routes.pages key — expected "/backend/path" or "/frontend/path"', { key: rawKey })
       continue
     }
     normalizedOverrides[key] = value
@@ -1015,9 +1005,7 @@ export function applyPageOverridesToManifests<T extends BackendRouteManifestEntr
     const override = normalizedOverrides[key]
     if (override === null) continue
     if (!override || typeof override !== 'object') {
-      console.warn(
-        `[Module Overrides] Skipping malformed routes.pages override for "${key}" — expected { load?, Component?, metadata? } or null.`,
-      )
+      logger.warn('Skipping malformed routes.pages override — expected { load?, Component?, metadata? } or null', { key })
       result.push(entry)
       continue
     }
@@ -1025,9 +1013,7 @@ export function applyPageOverridesToManifests<T extends BackendRouteManifestEntr
     const hasLoad = typeof override.load === 'function'
     const hasComponent = typeof override.Component === 'function'
     if (!hasLoad && !hasComponent && override.metadata === undefined) {
-      console.warn(
-        `[Module Overrides] Skipping malformed routes.pages override for "${key}" — expected a loader, component, metadata, or null.`,
-      )
+      logger.warn('Skipping malformed routes.pages override — expected a loader, component, metadata, or null', { key })
       result.push(entry)
       continue
     }
@@ -1182,13 +1168,13 @@ export function applyComponentOverridesToEntries(
     const value = overrides[key]
     if (value === null) continue
     if (!isComponentOverrideValue(value)) {
-      console.warn(`[Module Overrides] Skipping malformed widgets.components override for "${key}" — expected ComponentOverride, ComponentOverride[], or null.`)
+      logger.warn('Skipping malformed widgets.components override — expected ComponentOverride, ComponentOverride[], or null', { key })
       continue
     }
     const values = Array.isArray(value) ? value : [value]
     for (const override of values) {
       if (override.target.componentId !== key) {
-        console.warn(`[Module Overrides] Skipping malformed widgets.components override for "${key}" — target.componentId must match the override key.`)
+        logger.warn('Skipping malformed widgets.components override — target.componentId must match the override key', { key })
         continue
       }
       additions.push(override)
@@ -1415,9 +1401,7 @@ function routesOverridesApplier(
       for (const [rawKey, value] of Object.entries(api)) {
         const key = normalizeApiRouteOverrideKey(rawKey)
         if (!key) {
-          console.warn(
-            `[Module Overrides] Skipping malformed routes.api key "${rawKey}" — expected "METHOD /api/path".`,
-          )
+          logger.warn('Skipping malformed routes.api key — expected "METHOD /api/path"', { key: rawKey })
           continue
         }
         modulesConfigApiRouteOverrides[key] = value as ApiRouteOverride

package/src/modules/registry.ts

@@ -4,6 +4,7 @@ import type { SyncCrudEventResult } from '../lib/crud/sync-event-types'
 import type { DashboardWidgetModule } from './dashboard/widgets'
 import type { InjectionAnyWidgetModule, ModuleInjectionTable } from './widgets/injection'
 import type { IntegrationBundle, IntegrationDefinition } from './integrations/types'
+import { createLogger } from '../lib/logger'
 import {
   applyApiOverridesToManifests,
   applyModuleOverridesToModules,
@@ -12,6 +13,8 @@ import {
   composePageRouteOverrides,
 } from './overrides'
 
+const logger = createLogger('shared').child({ component: 'cli-registry' })
+
 // Context passed to dynamic metadata guards
 export type RouteVisibilityContext = { path?: string; auth?: any }
 
@@ -481,7 +484,7 @@ let _cliModules: Module[] | null = null
 
 export function registerCliModules(modules: Module[]) {
   if (_cliModules !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] CLI modules re-registered (this may occur during HMR)')
+    logger.debug('CLI modules re-registered (this may occur during HMR)')
   }
   _cliModules = applyModuleOverridesToModules(modules)
 }

package/src/modules/search.ts

@@ -1,4 +1,7 @@
 import type { EntityId } from './entities'
+import { createLogger } from '../lib/logger'
+
+const logger = createLogger('shared').child({ component: 'search-registry' })
 
 // =============================================================================
 // Strategy Identifiers
@@ -337,7 +340,7 @@ let _searchModuleConfigs: SearchModuleConfig[] | null = null
  */
 export function registerSearchModuleConfigs(configs: SearchModuleConfig[]): void {
   if (_searchModuleConfigs !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Search module configs re-registered (this may occur during HMR)')
+    logger.debug('Search module configs re-registered (this may occur during HMR)')
   }
   _searchModuleConfigs = configs
 }

package/src/modules/widgets/injection-loader.ts

@@ -10,11 +10,14 @@ import type {
   ModuleInjectionTable,
   InjectionWidgetPlacement,
 } from './injection'
+import { createLogger } from '../../lib/logger'
 import {
   applyInjectionWidgetOverridesToEntries,
   applyInjectionWidgetOverridesToTables,
 } from '../overrides'
 
+const logger = createLogger('widgets').child({ component: 'injection-loader' })
+
 type LoadedWidgetModule = InjectionWidgetModule<any, any> & { metadata: InjectionWidgetMetadata }
 type LoadedDataWidgetModule = InjectionDataWidgetModule & { metadata: InjectionWidgetMetadata }
 
@@ -140,7 +143,7 @@ function notifyInjectionRegistryChanged() {
 
 export function registerCoreInjectionWidgets(entries: ModuleInjectionWidgetEntry[]) {
   if (_coreInjectionWidgetEntries !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Core injection widgets re-registered (this may occur during HMR)')
+    logger.debug('Core injection widgets re-registered (this may occur during HMR)')
   }
   const finalEntries = applyInjectionWidgetOverridesToEntries(entries)
   _coreInjectionWidgetEntries = finalEntries
@@ -163,7 +166,7 @@ export function getCoreInjectionWidgets(): ModuleInjectionWidgetEntry[] {
 
 export function registerCoreInjectionTables(tables: Array<{ moduleId: string; table: ModuleInjectionTable }>) {
   if (_coreInjectionTables !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Core injection tables re-registered (this may occur during HMR)')
+    logger.debug('Core injection tables re-registered (this may occur during HMR)')
   }
   const finalTables = applyInjectionWidgetOverridesToTables(tables)
   _coreInjectionTables = finalTables
@@ -186,7 +189,7 @@ export function registerEnabledModuleIds(moduleIds: Iterable<string>) {
     if (typeof moduleId === 'string' && moduleId.length > 0) next.add(moduleId)
   }
   if (_enabledModuleIds !== null && process.env.NODE_ENV === 'development') {
-    console.debug('[Bootstrap] Enabled module IDs re-registered (this may occur during HMR)')
+    logger.debug('Enabled module IDs re-registered (this may occur during HMR)')
   }
   _enabledModuleIds = next
   writeGlobalEnabledModuleIds(next)
@@ -539,9 +542,7 @@ function warnSkippedWidget(metadataId: string, missingModules: string[]) {
   if (warnedRequiredModuleSkips.has(key)) return
   warnedRequiredModuleSkips.add(key)
   if (process.env.NODE_ENV === 'development') {
-    console.debug(
-      `[InjectionLoader] Skipping widget "${metadataId}" — required module(s) not enabled: ${missingModules.join(', ')}`,
-    )
+    logger.debug('Skipping widget — required module(s) not enabled', { metadataId, missingModules })
   }
 }
 

package/src/modules/widgets/injection-position.ts

@@ -1,3 +1,7 @@
+import { createLogger } from '../../lib/logger'
+
+const logger = createLogger('widgets').child({ component: 'injection-placement' })
+
 export enum InjectionPosition {
   Before = 'before',
   After = 'after',
@@ -18,7 +22,7 @@ export function getInjectionPosition(placement?: InjectionPlacement): InjectionP
 function warnInvalidRelativeTo(relativeTo: string | undefined) {
   if (process.env.NODE_ENV !== 'development') return
   if (!relativeTo) return
-  console.warn(`[InjectionPlacement] relativeTo target "${relativeTo}" not found, appending item at the end.`)
+  logger.warn('relativeTo target not found, appending item at the end', { relativeTo })
 }
 
 export function insertByInjectionPlacement<T>(