@open-mercato/shared 0.6.7-develop.6860.1.f796b22e80 → 0.6.7

package/src/lib/bootstrap/dynamicLoader.ts

@@ -1,98 +1,16 @@
 import type { BootstrapData } from './types'
-import type { AppDiRegistrar } from '../di/container'
 import { findAppRoot, type AppRoot } from './appResolver'
 import { registerEntityIds } from '../encryption/entityIds'
-import { createLogger } from '../logger'
 import {
   ensureMikroOrmV7GeneratedCacheCompatibility,
   recoverMikroOrmV7GeneratedCacheFromImportError,
 } from './generatedCacheRecovery'
-import { CLIENT_ONLY_STUB_NAMESPACE, createClientOnlyStubPlugin } from './clientOnlyModules'
 import path from 'node:path'
 import fs from 'node:fs'
 import crypto from 'node:crypto'
 import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
 
-const logger = createLogger('shared').child({ component: 'bootstrap' })
-
-/**
- * Thrown when an expected generated source file is absent.
- *
- * Optional registries treat this as the supported compatibility case (an app
- * that never generated the file), which is what makes it distinguishable from
- * a file that exists but fails to compile or import.
- */
-class GeneratedFileNotFoundError extends Error {
-  readonly filePath: string
-
-  constructor(filePath: string) {
-    super(`Generated file not found: ${filePath}`)
-    this.name = 'GeneratedFileNotFoundError'
-    this.filePath = filePath
-  }
-}
-
-/**
- * esbuild plugins for the CLI bundle, in resolution order. The client-only stub must come
- * first so it wins over the alias and external plugins for `*.client` dynamic imports.
- *
- * Exported so the wiring itself is testable: a test that only exercises
- * `createClientOnlyStubPlugin` in isolation stays green if the plugin is dropped from this
- * list, which would silently reintroduce #4623.
- */
-export function createCliBundlePlugins(appRoot: string): import('esbuild').Plugin[] {
-  // Plugin to resolve the @/ alias the way the app tsconfig maps it:
-  // `@/.mercato/*` to the app root, every other `@/*` to the app's src/ directory.
-  const aliasPlugin: import('esbuild').Plugin = {
-    name: 'alias-resolver',
-    setup(build) {
-      build.onResolve({ filter: /^@\// }, (args) => {
-        const rest = args.path.slice('@/'.length)
-        const bases = rest.startsWith('.mercato/')
-          ? [path.join(appRoot, rest)]
-          : [path.join(appRoot, 'src', rest), path.join(appRoot, rest)]
-        for (const base of bases) {
-          if (fs.existsSync(base) && fs.statSync(base).isFile()) {
-            return { path: base }
-          }
-          for (const suffix of ['.ts', '.tsx', '/index.ts', '/index.tsx']) {
-            if (fs.existsSync(base + suffix)) {
-              return { path: base + suffix }
-            }
-          }
-        }
-        // Nothing matched — hand esbuild the literal mapping so it reports the
-        // missing file against the path the app author actually wrote.
-        return { path: path.join(appRoot, rest) }
-      })
-    },
-  }
-
-  // Plugin to mark non-JSON package imports as external
-  const externalNonJsonPlugin: import('esbuild').Plugin = {
-    name: 'external-non-json',
-    setup(build) {
-      // Mark all package imports as external EXCEPT JSON files
-      // Filter matches paths that don't start with . or / (package imports like @open-mercato/shared)
-      build.onResolve({ filter: /^[^./]/ }, (args) => {
-        // Skip Windows absolute paths (e.g., C:\...) - they're local files, not packages
-        if (/^[a-zA-Z]:/.test(args.path)) {
-          return null // Let esbuild handle it
-        }
-        // If it's a JSON file, let esbuild bundle it
-        if (args.path.endsWith('.json')) {
-          return null // Let esbuild handle it
-        }
-        // Otherwise mark as external
-        return { path: args.path, external: true }
-      })
-    },
-  }
-
-  return [createClientOnlyStubPlugin(), aliasPlugin, externalNonJsonPlugin]
-}
-
 const DYNAMIC_LOADER_CACHE_VERSION = 4
 
 type DynamicLoaderCacheMetadata = {
@@ -249,7 +167,6 @@ function collectDependencyHashes(
 ): Record<string, string> {
   return Object.fromEntries(
     Object.keys(inputs)
-      .filter((inputPath) => !inputPath.startsWith(`${CLIENT_ONLY_STUB_NAMESPACE}:`))
       .map((inputPath) => {
         const absolutePath = path.isAbsolute(inputPath)
           ? inputPath
@@ -304,33 +221,14 @@ function cacheIsValid(
     && dependenciesAreValid(appRoot, metadata.dependencies)
 }
 
-/**
- * Options for `compileAndImport`.
- *
- * Both paths default to the generated-registry layout (`<appRoot>/.mercato/generated/<file>.ts`
- * compiled to a `.mjs` sibling). Sources that live elsewhere in the app — `src/di.ts` — MUST pass
- * both explicitly: the default app root is derived by walking three directories up from the source,
- * which only holds inside `.mercato/generated`.
- */
-type CompileAndImportOptions = {
-  appRoot?: string
-  outFile?: string
-  allowRecovery?: boolean
-}
-
 /**
  * Compile a TypeScript file to JavaScript using esbuild bundler.
  * This bundles the file and all its dependencies, handling JSON imports properly.
- * The compiled file is written next to the source file with a .mjs extension unless
- * `outFile` says otherwise.
+ * The compiled file is written next to the source file with a .mjs extension.
  */
-async function compileAndImport(
-  tsPath: string,
-  options: CompileAndImportOptions = {},
-): Promise<Record<string, unknown>> {
-  const allowRecovery = options.allowRecovery ?? true
-  const jsPath = options.outFile ?? tsPath.replace(/\.ts$/, '.mjs')
-  const appRoot = options.appRoot ?? path.dirname(path.dirname(path.dirname(tsPath)))
+async function compileAndImport(tsPath: string, allowRecovery: boolean = true): Promise<Record<string, unknown>> {
+  const jsPath = tsPath.replace(/\.ts$/, '.mjs')
+  const appRoot = path.dirname(path.dirname(path.dirname(tsPath)))
   const appTsconfig = path.join(appRoot, 'tsconfig.json')
   const metadataPath = cacheMetadataPath(jsPath)
 
@@ -338,7 +236,7 @@ async function compileAndImport(
   const tsconfigExists = fs.existsSync(appTsconfig)
 
   if (!tsExists) {
-    throw new GeneratedFileNotFoundError(tsPath)
+    throw new Error(`Generated file not found: ${tsPath}`)
   }
   if (!tsconfigExists) {
     throw new Error(`App TypeScript config not found: ${appTsconfig}`)
@@ -349,10 +247,50 @@ async function compileAndImport(
   const needsCompile = !cacheIsValid(appRoot, jsPath, metadataPath, expectedInputHash)
 
   if (needsCompile) {
-    fs.mkdirSync(path.dirname(jsPath), { recursive: true })
     // Dynamically import esbuild only when needed
     const esbuild = await import('esbuild')
 
+    // Plugin to resolve @/ alias to app root (works for @app modules)
+    const aliasPlugin: import('esbuild').Plugin = {
+      name: 'alias-resolver',
+      setup(build) {
+        // Resolve @/ alias to app root
+        build.onResolve({ filter: /^@\// }, (args) => {
+          const resolved = path.join(appRoot, args.path.slice(2))
+          // Try with .ts extension if base path doesn't exist
+          if (!fs.existsSync(resolved) && fs.existsSync(resolved + '.ts')) {
+            return { path: resolved + '.ts' }
+          }
+          // Also check for /index.ts if it's a directory
+          if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory() && fs.existsSync(path.join(resolved, 'index.ts'))) {
+            return { path: path.join(resolved, 'index.ts') }
+          }
+          return { path: resolved }
+        })
+      },
+    }
+
+    // Plugin to mark non-JSON package imports as external
+    const externalNonJsonPlugin: import('esbuild').Plugin = {
+      name: 'external-non-json',
+      setup(build) {
+        // Mark all package imports as external EXCEPT JSON files
+        // Filter matches paths that don't start with . or / (package imports like @open-mercato/shared)
+        build.onResolve({ filter: /^[^./]/ }, (args) => {
+          // Skip Windows absolute paths (e.g., C:\...) - they're local files, not packages
+          if (/^[a-zA-Z]:/.test(args.path)) {
+            return null // Let esbuild handle it
+          }
+          // If it's a JSON file, let esbuild bundle it
+          if (args.path.endsWith('.json')) {
+            return null // Let esbuild handle it
+          }
+          // Otherwise mark as external
+          return { path: args.path, external: true }
+        })
+      },
+    }
+
     // Use esbuild.build with bundling to handle JSON imports
     const result = await esbuild.build({
       entryPoints: [tsPath],
@@ -364,7 +302,7 @@ async function compileAndImport(
       platform: 'node',
       target: 'node18',
       tsconfig: appTsconfig,
-      plugins: createCliBundlePlugins(appRoot),
+      plugins: [aliasPlugin, externalNonJsonPlugin],
       // Allow JSON imports
       loader: { '.json': 'json' },
     })
@@ -395,45 +333,25 @@ async function compileAndImport(
       throw error
     }
 
-    return compileAndImport(tsPath, { ...options, allowRecovery: false })
+    return compileAndImport(tsPath, false)
   }
 }
 
 
 /**
- * Load a generated registry that older apps may not have generated yet.
+ * Dynamically load bootstrap data from a resolved app directory.
+ *
+ * IMPORTANT: This only works in unbundled contexts (CLI, tsx).
+ * Do NOT use this in Next.js bundled code - use static imports instead.
  *
- * An absent source file is the supported compatibility case and resolves to
- * `fallback` quietly. Any other failure — a compile error, a broken import, a
- * runtime throw at module scope — still resolves to `fallback` so bootstrap
- * keeps working, but is reported at error level: a registry that silently
- * degrades to nothing is exactly how command interceptors stopped applying in
- * worker/CLI processes (#4327, #4491).
+ * For CLI context, we skip loading modules.generated.ts which has Next.js dependencies.
+ * CLI commands are discovered separately via the CLI module system.
+ *
+ * @param appRoot - Optional explicit app root path. If not provided, will search from cwd.
+ * @returns The loaded bootstrap data
+ * @throws Error if app root cannot be found or generated files are missing
  */
-async function loadOptionalGeneratedModule(
-  tsPath: string,
-  fallback: Record<string, unknown>,
-): Promise<Record<string, unknown>> {
-  try {
-    return await compileAndImport(tsPath)
-  } catch (error) {
-    if (error instanceof GeneratedFileNotFoundError) {
-      logger.debug('Optional generated registry not present, using empty fallback', {
-        file: path.basename(tsPath),
-      })
-      return fallback
-    }
-
-    logger.error('Failed to load generated registry, continuing without its entries', {
-      file: path.basename(tsPath),
-      filePath: tsPath,
-      err: error,
-    })
-    return fallback
-  }
-}
-
-function resolveAppRootOrThrow(appRoot?: string): AppRoot {
+export async function loadBootstrapData(appRoot?: string): Promise<BootstrapData> {
   const resolved: AppRoot | null = appRoot
     ? {
         generatedDir: path.join(appRoot, '.mercato', 'generated'),
@@ -450,68 +368,6 @@ function resolveAppRootOrThrow(appRoot?: string): AppRoot {
     )
   }
 
-  return resolved
-}
-
-/**
- * Load the app-level DI registrar (`src/di.ts`) for the dynamic bootstrap path.
- *
- * The Next.js runtime imports `@/di` statically from its own `src/bootstrap.ts` and hands the
- * registrar to `createBootstrap`. Worker, scheduler and CLI processes bootstrap through
- * `bootstrapFromAppRoot` instead, where the `@/` alias does not exist — so without this the app's
- * DI registrations silently never ran there, and every request container paid a failed
- * `import('@/di')` resolution (the compatibility fallback in `lib/di/container.ts`).
- *
- * An absent `src/di.ts` is the supported case and resolves to `null` quietly. A file that exists
- * but cannot be compiled, imported, or does not export `register` is reported at error level and
- * still resolves to `null`, so a broken app DI module degrades the same way a broken generated
- * registry does (#4327, #4491) instead of taking the whole process down.
- */
-async function loadAppDiRegistrar(appDir: string): Promise<AppDiRegistrar | null> {
-  const tsPath = path.join(appDir, 'src', 'di.ts')
-  if (!fs.existsSync(tsPath)) {
-    logger.debug('App-level DI module not present, skipping its registrations', { filePath: tsPath })
-    return null
-  }
-
-  try {
-    const appDiModule = await compileAndImport(tsPath, {
-      appRoot: appDir,
-      outFile: path.join(appDir, '.mercato', 'generated', 'app-di.compiled.mjs'),
-    })
-    const register = appDiModule.register
-    if (typeof register !== 'function') {
-      logger.error('App-level DI module exports no register(); its registrations are skipped', {
-        filePath: tsPath,
-      })
-      return null
-    }
-    return register as AppDiRegistrar
-  } catch (error) {
-    logger.error('Failed to load the app-level DI module; its registrations are skipped', {
-      filePath: tsPath,
-      err: error,
-    })
-    return null
-  }
-}
-
-/**
- * Dynamically load bootstrap data from a resolved app directory.
- *
- * IMPORTANT: This only works in unbundled contexts (CLI, tsx).
- * Do NOT use this in Next.js bundled code - use static imports instead.
- *
- * For CLI context, we skip loading modules.generated.ts which has Next.js dependencies.
- * CLI commands are discovered separately via the CLI module system.
- *
- * @param appRoot - Optional explicit app root path. If not provided, will search from cwd.
- * @returns The loaded bootstrap data
- * @throws Error if app root cannot be found or generated files are missing
- */
-export async function loadBootstrapData(appRoot?: string): Promise<BootstrapData> {
-  const resolved = resolveAppRootOrThrow(appRoot)
-
   const { generatedDir } = resolved
 
   ensureMikroOrmV7GeneratedCacheCompatibility(resolved.appDir)
@@ -536,12 +392,10 @@ export async function loadBootstrapData(appRoot?: string): Promise<BootstrapData
     compileAndImport(path.join(generatedDir, 'modules.cli.generated.ts')),
     compileAndImport(path.join(generatedDir, 'entities.generated.ts')),
     compileAndImport(path.join(generatedDir, 'di.generated.ts')),
-    loadOptionalGeneratedModule(path.join(generatedDir, 'search.generated.ts'), { searchModuleConfigs: [] }),
-    loadOptionalGeneratedModule(path.join(generatedDir, 'command-loaders.generated.ts'), { commandLoaderEntries: [] }),
-    loadOptionalGeneratedModule(path.join(generatedDir, 'command-interceptors.generated.ts'), {
-      commandInterceptorEntries: [],
-    }),
-    loadOptionalGeneratedModule(path.join(generatedDir, 'workflows.generated.ts'), { allCodeWorkflows: [] }),
+    compileAndImport(path.join(generatedDir, 'search.generated.ts')).catch(() => ({ searchModuleConfigs: [] })),
+    compileAndImport(path.join(generatedDir, 'command-loaders.generated.ts')).catch(() => ({ commandLoaderEntries: [] })),
+    compileAndImport(path.join(generatedDir, 'command-interceptors.generated.ts')).catch(() => ({ commandInterceptorEntries: [] })),
+    compileAndImport(path.join(generatedDir, 'workflows.generated.ts')).catch(() => ({ allCodeWorkflows: [] })),
   ])
 
   return {
@@ -583,10 +437,8 @@ export async function loadBootstrapData(appRoot?: string): Promise<BootstrapData
  */
 export async function bootstrapFromAppRoot(appRoot?: string): Promise<BootstrapData> {
   const { createBootstrap, waitForAsyncRegistration } = await import('./factory.js')
-  const resolved = resolveAppRootOrThrow(appRoot)
-  const data = await loadBootstrapData(resolved.appDir)
-  const appDiRegistrar = await loadAppDiRegistrar(resolved.appDir)
-  const bootstrap = createBootstrap(data, appDiRegistrar ? { appDiRegistrar } : {})
+  const data = await loadBootstrapData(appRoot)
+  const bootstrap = createBootstrap(data)
   bootstrap()
   // In CLI context, wait for async registrations (UI widgets, search configs, etc.)
   await waitForAsyncRegistration()

package/src/lib/commands/__tests__/command-interceptor-runner.test.ts

@@ -7,10 +7,6 @@ import {
 } from '../command-interceptor-runner'
 import type { CommandInterceptor, CommandInterceptorContext, CommandInterceptorUndoContext } from '../command-interceptor'
 import { createLogger } from '@open-mercato/shared/lib/logger'
-import {
-  applyAclFeatureOverrides,
-  resetModuleContractOverridesForTests,
-} from '@open-mercato/shared/modules/overrides'
 
 jest.mock('@open-mercato/shared/lib/logger', () => {
   const mocked = {
@@ -63,10 +59,6 @@ describe('matchesCommandPattern', () => {
 })
 
 describe('runCommandInterceptorsBefore', () => {
-  afterEach(() => {
-    resetModuleContractOverridesForTests()
-  })
-
   it('returns ok when no interceptors match', async () => {
     const interceptor = makeInterceptor({
       id: 'i1',
@@ -166,26 +158,6 @@ describe('runCommandInterceptorsBefore', () => {
     expect(withWildcard.ok).toBe(false)
     expect(withWildcard.error?.message).toBe('Blocked by wildcard')
   })
-
-  it('does not run an interceptor gated by a nulled ACL feature', async () => {
-    applyAclFeatureOverrides({ 'premium.audit': null })
-    const interceptor = makeInterceptor({
-      id: 'i1',
-      features: ['premium.audit'],
-      beforeExecute: jest.fn().mockResolvedValue({ ok: false }),
-    })
-
-    const result = await runCommandInterceptorsBefore(
-      [interceptor],
-      'customers.create-person',
-      {},
-      baseContext,
-      ['*', 'premium.audit'],
-    )
-
-    expect(result.ok).toBe(true)
-    expect(interceptor.beforeExecute).not.toHaveBeenCalled()
-  })
 })
 
 describe('runCommandInterceptorsAfter', () => {

package/src/lib/commands/command-bus.ts

@@ -31,7 +31,6 @@ import {
 } from './command-interceptor-runner'
 import type { CommandInterceptorContext } from './command-interceptor'
 import { CommandInterceptorError } from './errors'
-import { isReadProjectionAlwaysConsistent } from '@open-mercato/shared/lib/data/consistency'
 import { createLogger } from '../logger'
 
 const logger = createLogger('shared').child({ component: 'commands' })
@@ -698,10 +697,7 @@ export class CommandBus {
     try {
       const dataEngine = (container.resolve('dataEngine') as DataEngine)
       await dataEngine.flushOrmEntityChanges(suppress)
-    } catch (error) {
-      if (isReadProjectionAlwaysConsistent()) {
-        throw error
-      }
+    } catch {
       // best-effort: failures should not block command execution
     }
   }

package/src/lib/commands/command-interceptor-runner.ts

@@ -3,7 +3,7 @@ import type {
   CommandInterceptorContext,
   CommandInterceptorUndoContext,
 } from './command-interceptor'
-import { authorizeFeatures } from '../../security/featurePolicy'
+import { hasAllFeatures } from '../../security/features'
 import { createLogger } from '../logger'
 
 const logger = createLogger('shared').child({ component: 'commands' })
@@ -33,7 +33,7 @@ function collectMatching(
 ): CommandInterceptor[] {
   return interceptors
     .filter((i) => matchesCommandPattern(i.targetCommand, commandId))
-    .filter((i) => authorizeFeatures(i.features ?? [], { grantedFeatures: userFeatures }))
+    .filter((i) => hasAllFeatures(userFeatures, i.features))
     .sort((a, b) => (a.priority ?? 50) - (b.priority ?? 50))
 }