@open-mercato/shared 0.4.9-develop-fefbbe0979 → 0.4.9-develop-db9ecc46fc

package/src/lib/middleware/page-executor.ts

@@ -0,0 +1,63 @@
+import type {
+  PageMiddlewareContext,
+  PageMiddlewareMode,
+  PageMiddlewareRegistryEntry,
+  PageMiddlewareResult,
+  PageRouteMiddleware,
+} from '@open-mercato/shared/modules/middleware/page'
+import { CONTINUE_PAGE_MIDDLEWARE, matchPageMiddlewareTarget } from '@open-mercato/shared/modules/middleware/page'
+
+type ExecutePageMiddlewareArgs = {
+  entries: PageMiddlewareRegistryEntry[]
+  context: PageMiddlewareContext
+  onError?: (error: unknown, middleware: Pick<PageRouteMiddleware, 'id' | 'priority'>) => void
+}
+
+const DEFAULT_PRIORITY = 100
+
+function shouldRunMiddleware(middleware: PageRouteMiddleware, mode: PageMiddlewareMode, pathname: string): boolean {
+  if (middleware.mode && middleware.mode !== mode) return false
+  return matchPageMiddlewareTarget(pathname, middleware.target)
+}
+
+function compareMiddleware(a: PageRouteMiddleware, b: PageRouteMiddleware): number {
+  const priorityDiff = (a.priority ?? DEFAULT_PRIORITY) - (b.priority ?? DEFAULT_PRIORITY)
+  if (priorityDiff !== 0) return priorityDiff
+  return a.id.localeCompare(b.id)
+}
+
+function flattenAndSortMiddleware(
+  entries: PageMiddlewareRegistryEntry[],
+  mode: PageMiddlewareMode,
+  pathname: string
+): PageRouteMiddleware[] {
+  return entries
+    .flatMap((entry) => entry.middleware)
+    .filter((middleware) => shouldRunMiddleware(middleware, mode, pathname))
+    .sort(compareMiddleware)
+}
+
+export async function executePageMiddleware(args: ExecutePageMiddlewareArgs): Promise<PageMiddlewareResult> {
+  const { entries, context, onError } = args
+  const matchedMiddleware = flattenAndSortMiddleware(entries, context.mode, context.pathname)
+  for (const middleware of matchedMiddleware) {
+    try {
+      const result = await middleware.run(context)
+      if (result.action === 'redirect') return result
+    } catch (error) {
+      if (onError) {
+        onError(error, { id: middleware.id, priority: middleware.priority })
+      } else {
+        console.error('[middleware:page] execution failed', { id: middleware.id, error })
+      }
+      throw error
+    }
+  }
+  return CONTINUE_PAGE_MIDDLEWARE
+}
+
+export async function resolvePageMiddlewareRedirect(args: ExecutePageMiddlewareArgs): Promise<string | null> {
+  const result = await executePageMiddleware(args)
+  if (result.action !== 'redirect') return null
+  return result.location
+}

package/src/modules/generators/index.ts

@@ -0,0 +1 @@
+export type { GeneratorPlugin, GeneratorPluginBootstrapRegistration } from './types'

package/src/modules/generators/types.ts

@@ -0,0 +1,29 @@
+export interface GeneratorPluginBootstrapRegistration {
+  /** Name of the variable exported from this plugin's output file, e.g. 'securityMfaProviderEntries' */
+  entriesExportName: string
+  /** Full TypeScript import statements needed for the registration call (e.g. the register function) */
+  registrationImports: string[]
+  /** Build the registration call expression, receives the entries variable name */
+  buildCall: (entriesExportName: string) => string
+}
+
+export interface GeneratorPlugin {
+  /** Unique ID, e.g. 'security.mfa-providers' */
+  id: string
+  /** Convention file path relative to module root, e.g. 'security.mfa-providers.ts' */
+  conventionFile: string
+  /** Import variable prefix used in generated code, e.g. 'SECURITY_MFA_PROVIDERS' */
+  importPrefix: string
+  /** Build the TypeScript entry expression for each discovered module */
+  configExpr: (importName: string, moduleId: string) => string
+  /** Output filename relative to the generated output directory, e.g. 'security-mfa-providers.generated.ts' */
+  outputFileName: string
+  /** Generate the full TypeScript file content from collected imports and entry literals */
+  buildOutput: (params: { importSection: string; entriesLiteral: string }) => string
+  /**
+   * When present, contributes a registration call to the auto-generated
+   * `bootstrap-registrations.generated.ts` file. This lets modules inject
+   * bootstrap-time side effects without bootstrap.ts knowing about them.
+   */
+  bootstrapRegistration?: GeneratorPluginBootstrapRegistration
+}

package/src/modules/middleware/page.ts

@@ -0,0 +1,52 @@
+import type { AuthContext } from '@open-mercato/shared/lib/auth/server'
+
+export type PageMiddlewareMode = 'frontend' | 'backend'
+
+export type PageRouteMeta = {
+  requireAuth?: boolean
+  requireRoles?: string[]
+  requireFeatures?: string[]
+}
+
+export type PageMiddlewareContainer = {
+  resolve: (name: string) => unknown
+}
+
+export type PageMiddlewareContext = {
+  pathname: string
+  mode: PageMiddlewareMode
+  routeMeta: PageRouteMeta
+  auth: AuthContext
+  ensureContainer: () => Promise<PageMiddlewareContainer>
+}
+
+export type PageMiddlewareResult =
+  | { action: 'continue' }
+  | { action: 'redirect'; location: string }
+
+export type PageMiddlewareTarget = string | RegExp
+
+export type PageRouteMiddleware = {
+  id: string
+  mode?: PageMiddlewareMode
+  target: PageMiddlewareTarget
+  priority?: number
+  run: (ctx: PageMiddlewareContext) => Promise<PageMiddlewareResult> | PageMiddlewareResult
+}
+
+export type PageMiddlewareRegistryEntry = {
+  moduleId: string
+  middleware: PageRouteMiddleware[]
+}
+
+export function matchPageMiddlewareTarget(pathname: string, target: PageMiddlewareTarget): boolean {
+  if (target instanceof RegExp) {
+    return target.test(pathname)
+  }
+  if (target.endsWith('*')) {
+    return pathname.startsWith(target.slice(0, -1))
+  }
+  return pathname === target
+}
+
+export const CONTINUE_PAGE_MIDDLEWARE: PageMiddlewareResult = { action: 'continue' }

package/src/modules/widgets/component-registry.ts

@@ -40,6 +40,19 @@ type RuntimeState = {
 
 const GLOBAL_COMPONENT_REGISTRY_KEY = '__openMercatoComponentRegistry__'
 
+function isComponentOverride(value: unknown): value is ComponentOverride {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const target = (value as { target?: { componentId?: unknown } }).target
+  if (!target || typeof target !== 'object') {
+    return false
+  }
+
+  return typeof target.componentId === 'string' && target.componentId.length > 0
+}
+
 function getState(): RuntimeState {
   const globalValue = (globalThis as Record<string, unknown>)[GLOBAL_COMPONENT_REGISTRY_KEY]
   if (globalValue && typeof globalValue === 'object') {
@@ -63,7 +76,7 @@ export function registerComponent<TProps = unknown>(entry: ComponentRegistryEntr
 
 export function registerComponentOverrides(overrides: ComponentOverride[]) {
   const state = getState()
-  state.overrides = [...overrides]
+  state.overrides = overrides.filter(isComponentOverride)
 }
 
 export function getComponentEntry(componentId: string): ComponentRegistryEntry | null {
@@ -74,6 +87,7 @@ export function getComponentEntry(componentId: string): ComponentRegistryEntry |
 export function getComponentOverrides(componentId: string, userFeatures?: readonly string[]): ComponentOverride[] {
   const state = getState()
   const relevant = state.overrides.filter((override) => {
+    if (!isComponentOverride(override)) return false
     if (override.target.componentId !== componentId) return false
     if (override.features && override.features.length > 0) {
       if (!hasAllFeatures(userFeatures, override.features)) return false