@open-mercato/core 0.10.1-develop.7833.1.d6cbf0e3ab → 0.10.1-develop.7841.1.af87ac614d

package/src/modules/staff/backend/staff/time-tracking/projects/[id]/edit/page.tsx

@@ -15,6 +15,8 @@ import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
 import { DEFAULT_BUDGET_WARN_AT_PERCENT, type ProjectBudgetKind } from '../../../../../../lib/time-tracking-ui/ProjectFormSections'
 import { NoProjectAccess } from '../../../../../../lib/time-tracking-ui/NoProjectAccess'
+import { useProjectAccessScope } from '../../../../../../lib/time-tracking-ui/projectAccessScope'
+import { readResolvedProjectAccessScope, type ResolvedProjectAccessScope } from '../../../../../../lib/time-tracking-ui/projectAccessScopeHeaders'
 import {
   buildProjectPayload,
   createProjectFormFields,
@@ -36,7 +38,7 @@ const NO_PROJECT_ACCESS_REASON = 'no_project_access'
 
 /** Thrown by the loader so the caller can branch on the guard state. */
 class ProjectAccessDeniedError extends Error {
-  constructor() {
+  constructor(readonly resolvedScope: ResolvedProjectAccessScope | null) {
     super('[internal] no project access')
     this.name = 'ProjectAccessDeniedError'
   }
@@ -106,25 +108,28 @@ export default function TimeTrackingProjectEditPage({ params }: { params?: { id?
   const t = useT()
   const router = useRouter()
   const scopeVersion = useOrganizationScopeVersion()
+  const { scopeKey: projectAccessScopeKey, resolvedScope, resolveScope } = useProjectAccessScope(projectId)
 
   const [initialValues, setInitialValues] = React.useState<ProjectFormValues | null>(null)
   const [loading, setLoading] = React.useState(true)
   const [error, setError] = React.useState<string | null>(null)
   const [isNotFound, setIsNotFound] = React.useState(false)
-  const [accessDenied, setAccessDenied] = React.useState(false)
+  const [accessDeniedScopeKey, setAccessDeniedScopeKey] = React.useState<string | null>(null)
+  const [loadedScopeKey, setLoadedScopeKey] = React.useState<string | null>(null)
+  const accessDenied = accessDeniedScopeKey === projectAccessScopeKey
 
-  const fetchProject = React.useCallback(async (): Promise<ProjectRecord | null> => {
+  const fetchProject = React.useCallback(async (): Promise<{ record: ProjectRecord | null; scope: ResolvedProjectAccessScope | null }> => {
     const call = await apiCall<{ items?: ProjectRecord[]; reason?: unknown }>(
       `/api/staff/timesheets/time-projects?ids=${projectId}&pageSize=1`,
     )
     if (call.status === 404 && call.result?.reason === NO_PROJECT_ACCESS_REASON) {
-      throw new ProjectAccessDeniedError()
+      throw new ProjectAccessDeniedError(readResolvedProjectAccessScope(call.response))
     }
     if (!call.ok) {
       throw new Error(t('staff.timesheets.projects.errors.load', 'Failed to load project.'))
     }
     const record = Array.isArray(call.result?.items) ? call.result.items[0] : null
-    return record ?? null
+    return { record: record ?? null, scope: readResolvedProjectAccessScope(call.response) }
   }, [projectId, t])
 
   /**
@@ -137,7 +142,7 @@ export default function TimeTrackingProjectEditPage({ params }: { params?: { id?
   const handleCurrencyChanged = React.useCallback(() => {
     if (!projectId) return
     void fetchProject()
-      .then((record) => { if (record) setInitialValues(toValues(record)) })
+      .then(({ record }) => { if (record) setInitialValues(toValues(record)) })
       .catch(() => {
         // Best effort: the optimistic-lock conflict bar remains the backstop.
       })
@@ -159,25 +164,30 @@ export default function TimeTrackingProjectEditPage({ params }: { params?: { id?
   // it was loaded for. The decision looks at the load this one replaces,
   // settled or not: a version-0 load cancelled by a quick second switch must
   // not let that switch through.
-  const lastLoadRef = React.useRef<{ projectId: string; scopeVersion: number } | null>(null)
+  const lastLoadRef = React.useRef<{ projectId: string; scopeVersion: number; scopeKey: string } | null>(null)
   React.useEffect(() => {
     if (!projectId) return
     let cancelled = false
     const replaced = lastLoadRef.current
-    lastLoadRef.current = { projectId, scopeVersion }
-    const keepScreen = replaced !== null && replaced.projectId === projectId && replaced.scopeVersion === 0
+    lastLoadRef.current = { projectId, scopeVersion, scopeKey: projectAccessScopeKey }
+    const keepScreen = replaced !== null
+      && replaced.projectId === projectId
+      && replaced.scopeVersion === 0
+      && replaced.scopeKey === projectAccessScopeKey
     async function load() {
       if (!keepScreen) setLoading(true)
       const settle = (outcome: { values?: ProjectFormValues; accessDenied?: boolean; isNotFound?: boolean; error?: string }) => {
         if (cancelled) return
-        setAccessDenied(outcome.accessDenied === true)
+        setAccessDeniedScopeKey(outcome.accessDenied === true ? projectAccessScopeKey : null)
         setIsNotFound(outcome.isNotFound === true)
         setError(outcome.error ?? null)
         if (outcome.values) setInitialValues(outcome.values)
+        setLoadedScopeKey(projectAccessScopeKey)
         setLoading(false)
       }
       try {
-        const record = await fetchProject()
+        const { record, scope } = await fetchProject()
+        if (!cancelled) resolveScope(scope)
         if (!record) {
           settle({ isNotFound: true })
           return
@@ -185,6 +195,7 @@ export default function TimeTrackingProjectEditPage({ params }: { params?: { id?
         settle({ values: toValues(record) })
       } catch (err) {
         if (err instanceof ProjectAccessDeniedError) {
+          if (!cancelled) resolveScope(err.resolvedScope)
           settle({ accessDenied: true })
           return
         }
@@ -197,16 +208,16 @@ export default function TimeTrackingProjectEditPage({ params }: { params?: { id?
     }
     load()
     return () => { cancelled = true }
-  }, [projectId, fetchProject, scopeVersion, t])
+  }, [projectId, fetchProject, scopeVersion, t, projectAccessScopeKey, resolveScope])
 
-  if (loading) {
+  if (!accessDenied && (loading || loadedScopeKey !== projectAccessScopeKey)) {
     return <Page><PageBody><LoadingMessage label={t('staff.timesheets.projects.loading', 'Loading project...')} /></PageBody></Page>
   }
 
   // Screen 17 — the caller may not open this project. Same guard state the
   // detail page renders; it names neither the customer nor the project.
   if (accessDenied) {
-    return <NoProjectAccess timeProjectId={projectId} />
+    return <NoProjectAccess timeProjectId={projectId} resolvedScope={resolvedScope} />
   }
 
   if (isNotFound) {

package/src/modules/staff/backend/staff/time-tracking/projects/[id]/page.tsx

@@ -33,6 +33,8 @@ import { formatCurrency } from '@open-mercato/ui/utils/format'
 import { KpiCard, Sparkline } from '@open-mercato/ui/backend/charts'
 import { ProjectTeamDrawer } from '../../../../../lib/time-tracking-ui/ProjectTeamDrawer'
 import { NoProjectAccess } from '../../../../../lib/time-tracking-ui/NoProjectAccess'
+import { useProjectAccessScope } from '../../../../../lib/time-tracking-ui/projectAccessScope'
+import { readResolvedProjectAccessScope } from '../../../../../lib/time-tracking-ui/projectAccessScopeHeaders'
 import { ProjectBudgetCell } from '../../../../../lib/timesheets-projects-ui/ProjectBudgetCell'
 import { computeBudgetBurn } from '../../../../../lib/timesheets-projects/budgetBurn'
 import { resolveProjectColorHex } from '../../../../../lib/timesheets-ui/colors'
@@ -177,6 +179,7 @@ export default function TimesheetProjectDetailPage({ params }: { params?: { id?:
   const translateRef = React.useRef(t)
   React.useEffect(() => { translateRef.current = t }, [t])
   const scopeVersion = useOrganizationScopeVersion()
+  const { scopeKey: projectAccessScopeKey, resolvedScope, resolveScope } = useProjectAccessScope(projectId)
   const { confirm, ConfirmDialogElement } = useConfirmDialog()
   const router = useRouter()
   const pathname = usePathname()
@@ -186,13 +189,9 @@ export default function TimesheetProjectDetailPage({ params }: { params?: { id?:
   const [loading, setLoading] = React.useState(true)
   const [error, setError] = React.useState<string | null>(null)
   const [isNotFound, setIsNotFound] = React.useState(false)
-  // Keyed by project id so a route change to another project never shows the
-  // previous project's guard (with a live request button) while the new one loads.
-  const [accessDeniedProjectId, setAccessDeniedProjectId] = React.useState<string | null>(null)
-  const accessDenied = accessDeniedProjectId !== null && accessDeniedProjectId === projectId
-  // The id the last finished load was for. Until it matches the route, the page
-  // is still loading — never the previous project's error or empty state.
-  const [settledProjectId, setSettledProjectId] = React.useState<string | null>(null)
+  const [accessDeniedScopeKey, setAccessDeniedScopeKey] = React.useState<string | null>(null)
+  const [loadedScopeKey, setLoadedScopeKey] = React.useState<string | null>(null)
+  const accessDenied = accessDeniedScopeKey === projectAccessScopeKey
 
   const [employees, setEmployees] = React.useState<EmployeeAssignment[]>([])
   const [employeesLoading, setEmployeesLoading] = React.useState(false)
@@ -407,13 +406,14 @@ export default function TimesheetProjectDetailPage({ params }: { params?: { id?:
         const call = await apiCall<ProjectResponse>(
           `/api/staff/timesheets/time-projects?${queryParams.toString()}`,
         )
+        if (!cancelled) resolveScope(readResolvedProjectAccessScope(call.response))
         // Screen 17: the route answers 404 with this discriminator for a project
         // the caller is not a member of, without naming it.
         if (call.status === 404 && readDenialReason(call.result) === NO_PROJECT_ACCESS_REASON) {
-          if (!cancelled) setAccessDeniedProjectId(projectId ?? null)
+          if (!cancelled) setAccessDeniedScopeKey(projectAccessScopeKey)
           return
         }
-        if (!cancelled) setAccessDeniedProjectId(null)
+        if (!cancelled) setAccessDeniedScopeKey(null)
         if (!call.ok) {
           throw new Error(translateRef.current('staff.timesheets.projects.errors.load', 'Failed to load project.'))
         }
@@ -426,18 +426,19 @@ export default function TimesheetProjectDetailPage({ params }: { params?: { id?:
         if (!cancelled) setProject(record)
       } catch (loadError) {
         if (!cancelled) {
+          setAccessDeniedScopeKey(null)
           setError(loadError instanceof Error ? loadError.message : translateRef.current('staff.timesheets.projects.errors.load', 'Failed to load project.'))
         }
       } finally {
         if (!cancelled) {
+          setLoadedScopeKey(projectAccessScopeKey)
           setLoading(false)
-          setSettledProjectId(projectId ?? null)
         }
       }
     }
     loadProject()
     return () => { cancelled = true }
-  }, [projectId, scopeVersion])
+  }, [projectId, scopeVersion, projectAccessScopeKey, resolveScope])
 
   // --- Load employees with name resolution ---
   const loadEmployees = React.useCallback(async () => {
@@ -709,10 +710,10 @@ export default function TimesheetProjectDetailPage({ params }: { params?: { id?:
   // resolving late) keeps the guard mounted instead of resetting a request the
   // user has just sent.
   if (accessDenied) {
-    return <NoProjectAccess timeProjectId={projectId} />
+    return <NoProjectAccess timeProjectId={projectId} resolvedScope={resolvedScope} />
   }
 
-  if (loading || settledProjectId !== (projectId ?? null)) {
+  if (loading || loadedScopeKey !== projectAccessScopeKey) {
     return (
       <Page>
         <PageBody>

package/src/modules/staff/lib/time-tracking-ui/NoProjectAccess.tsx

@@ -10,6 +10,8 @@ import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { apiCallOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
 import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { useProjectAccessScope } from './projectAccessScope'
+import type { ResolvedProjectAccessScope } from './projectAccessScopeHeaders'
 
 export const MY_WORK_HREF = '/backend/staff/time-tracking'
 export const ACCESS_REQUEST_ENDPOINT = '/api/staff/timesheets/access-requests'
@@ -22,36 +24,52 @@ export type AccessRequestButtonProps = {
    * project exists to a user who has no right to it.
    */
   timeProjectId?: string | null
+  resolvedScope?: ResolvedProjectAccessScope | null
   label: string
   sentLabel: string
   variant?: 'default' | 'outline'
 }
 
-export function AccessRequestButton({
+export function AccessRequestButton(props: AccessRequestButtonProps) {
+  const { scopeKey, isCurrentScope } = useProjectAccessScope(props.timeProjectId, props.resolvedScope)
+  return <ScopedAccessRequestButton key={scopeKey} {...props} isCurrentScope={isCurrentScope} />
+}
+
+function ScopedAccessRequestButton({
   timeProjectId,
   label,
   sentLabel,
   variant = 'outline',
-}: AccessRequestButtonProps) {
+  isCurrentScope,
+}: AccessRequestButtonProps & { isCurrentScope: () => boolean }) {
   const t = useT()
   const [submitting, setSubmitting] = React.useState(false)
   const [sent, setSent] = React.useState(false)
+  const mounted = React.useRef(true)
+  React.useEffect(() => {
+    mounted.current = true
+    return () => { mounted.current = false }
+  }, [])
   const { runMutation, retryLastMutation } = useGuardedMutation<Record<string, unknown>>({
     contextId: ACCESS_REQUEST_CONTEXT_ID,
     blockedMessage: t('ui.forms.flash.saveBlocked', 'Save blocked by validation'),
   })
 
   const requestAccess = React.useCallback(async () => {
+    const isCurrent = () => mounted.current && isCurrentScope()
+    if (!isCurrent()) return
     const payload = timeProjectId ? { timeProjectId } : {}
     setSubmitting(true)
     try {
       await runMutation({
-        operation: () =>
-          apiCallOrThrow(ACCESS_REQUEST_ENDPOINT, {
+        operation: () => {
+          if (!isCurrent()) throw new Error('[internal] Access request scope changed')
+          return apiCallOrThrow(ACCESS_REQUEST_ENDPOINT, {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
             body: JSON.stringify(payload),
-          }),
+          })
+        },
         context: {
           formId: ACCESS_REQUEST_CONTEXT_ID,
           resourceKind: 'staff.timesheets.access_request',
@@ -59,6 +77,7 @@ export function AccessRequestButton({
         },
         mutationPayload: payload,
       })
+      if (!isCurrent()) return
       setSent(true)
       flash(
         t(
@@ -68,14 +87,15 @@ export function AccessRequestButton({
         'success',
       )
     } catch {
+      if (!isCurrent()) return
       flash(
         t('staff.time_tracking.access.request.error', 'Could not send the access request.'),
         'error',
       )
     } finally {
-      setSubmitting(false)
+      if (isCurrent()) setSubmitting(false)
     }
-  }, [retryLastMutation, runMutation, t, timeProjectId])
+  }, [isCurrentScope, retryLastMutation, runMutation, t, timeProjectId])
 
   return (
     <Button type="button" variant={variant} onClick={requestAccess} disabled={submitting || sent}>
@@ -87,6 +107,7 @@ export function AccessRequestButton({
 
 export type NoProjectAccessProps = {
   timeProjectId?: string | null
+  resolvedScope?: ResolvedProjectAccessScope | null
   /** Where the "Back to My work" action returns to. */
   myWorkHref?: string
 }
@@ -97,7 +118,7 @@ export type NoProjectAccessProps = {
  * access" and "access was revoked" (note 2); navigation stays untouched because
  * the caller still has other projects (note 3).
  */
-export function NoProjectAccess({ timeProjectId, myWorkHref = MY_WORK_HREF }: NoProjectAccessProps) {
+export function NoProjectAccess({ timeProjectId, resolvedScope, myWorkHref = MY_WORK_HREF }: NoProjectAccessProps) {
   const t = useT()
   return (
     <Page>
@@ -121,6 +142,7 @@ export function NoProjectAccess({ timeProjectId, myWorkHref = MY_WORK_HREF }: No
               </Button>
               <AccessRequestButton
                 timeProjectId={timeProjectId}
+                resolvedScope={resolvedScope}
                 label={t('staff.time_tracking.access.denied.request', 'Request access')}
                 sentLabel={t('staff.time_tracking.access.request.sent', 'Request sent')}
               />

package/src/modules/staff/lib/time-tracking-ui/projectAccessScope.ts

@@ -0,0 +1,102 @@
+"use client"
+
+import * as React from 'react'
+import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'
+import {
+  parseSelectedOrganizationCookie,
+  parseSelectedTenantCookie,
+} from '@open-mercato/core/modules/directory/utils/scopeCookies'
+import type { ResolvedProjectAccessScope } from './projectAccessScopeHeaders'
+
+export type ProjectAccessScope = {
+  projectId: string | null
+  tenantId: string | null
+  organizationId: string | null
+}
+
+export type ProjectAccessScopeState = {
+  /** Stable while the scope stays the same; changes when the project, tenant or organization changes. */
+  scopeKey: string
+  /** Reads the scope cookies again, so it also catches a change that has not been rendered yet. */
+  isCurrentScope: () => boolean
+  resolvedScope: ResolvedProjectAccessScope | null
+  resolveScope: (scope: ResolvedProjectAccessScope | null) => void
+}
+
+type ProjectAccessScopeBinding = {
+  scope: ProjectAccessScope
+  generation: number
+  resolvedScope: ResolvedProjectAccessScope | null
+}
+
+export function readProjectAccessScope(timeProjectId?: string | null): ProjectAccessScope {
+  const cookieHeader = typeof document === 'undefined' ? null : document.cookie
+  return {
+    projectId: timeProjectId ?? null,
+    tenantId: parseSelectedTenantCookie(cookieHeader),
+    organizationId: parseSelectedOrganizationCookie(cookieHeader),
+  }
+}
+
+export function bindProjectAccessScope(
+  bound: ProjectAccessScope,
+  current: ProjectAccessScope,
+  resolvedScope?: ResolvedProjectAccessScope | null,
+): ProjectAccessScope | null {
+  const continues = (boundValue: string | null, currentValue: string | null, resolvedValue?: string) =>
+    boundValue === currentValue || (boundValue === null && currentValue === resolvedValue)
+  if (bound.projectId !== current.projectId) return null
+  if (!continues(bound.tenantId, current.tenantId, resolvedScope?.tenantId)) return null
+  if (!continues(bound.organizationId, current.organizationId, resolvedScope?.organizationId)) return null
+  return current
+}
+
+function isSameProjectAccessScope(left: ProjectAccessScope, right: ProjectAccessScope): boolean {
+  return left.projectId === right.projectId
+    && left.tenantId === right.tenantId
+    && left.organizationId === right.organizationId
+}
+
+function rebindProjectAccessScope(
+  binding: ProjectAccessScopeBinding,
+  current: ProjectAccessScope,
+): ProjectAccessScopeBinding {
+  const continued = bindProjectAccessScope(binding.scope, current, binding.resolvedScope)
+  if (!continued) return { scope: current, generation: binding.generation + 1, resolvedScope: null }
+  if (isSameProjectAccessScope(continued, binding.scope)) return binding
+  return { ...binding, scope: continued }
+}
+
+export function useProjectAccessScope(
+  timeProjectId?: string | null,
+  initialResolvedScope?: ResolvedProjectAccessScope | null,
+): ProjectAccessScopeState {
+  useOrganizationScopeVersion()
+  const current = readProjectAccessScope(timeProjectId)
+  const [binding, setBinding] = React.useState<ProjectAccessScopeBinding>(() => ({
+    scope: current,
+    generation: 0,
+    resolvedScope: initialResolvedScope ?? null,
+  }))
+  const nextBinding = rebindProjectAccessScope(binding, current)
+  if (nextBinding !== binding) setBinding(nextBinding)
+  const boundScope = React.useRef(nextBinding)
+  boundScope.current = nextBinding
+  const generation = nextBinding.generation
+  const isCurrentScope = React.useCallback(() => {
+    const active = boundScope.current
+    return active.generation === generation
+      && bindProjectAccessScope(active.scope, readProjectAccessScope(timeProjectId), active.resolvedScope) !== null
+  }, [generation, timeProjectId])
+  const resolveScope = React.useCallback((resolvedScope: ResolvedProjectAccessScope | null) => {
+    setBinding((previous) => {
+      if (previous.generation !== generation) return previous
+      if (!bindProjectAccessScope(previous.scope, readProjectAccessScope(timeProjectId), resolvedScope)) return previous
+      const changed = previous.resolvedScope !== null && resolvedScope !== null
+        && (previous.resolvedScope.tenantId !== resolvedScope.tenantId
+          || previous.resolvedScope.organizationId !== resolvedScope.organizationId)
+      return { ...previous, resolvedScope, generation: previous.generation + (changed ? 1 : 0) }
+    })
+  }, [generation, timeProjectId])
+  return { scopeKey: String(generation), isCurrentScope, resolvedScope: nextBinding.resolvedScope, resolveScope }
+}

package/src/modules/staff/lib/time-tracking-ui/projectAccessScopeHeaders.ts

@@ -0,0 +1,15 @@
+export const PROJECT_SCOPE_TENANT_HEADER = 'x-om-project-scope-tenant-id'
+export const PROJECT_SCOPE_ORGANIZATION_HEADER = 'x-om-project-scope-organization-id'
+
+export type ResolvedProjectAccessScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export function readResolvedProjectAccessScope(
+  response: { headers?: Pick<Headers, 'get'> },
+): ResolvedProjectAccessScope | null {
+  const tenantId = response.headers?.get(PROJECT_SCOPE_TENANT_HEADER)
+  const organizationId = response.headers?.get(PROJECT_SCOPE_ORGANIZATION_HEADER)
+  return tenantId && organizationId ? { tenantId, organizationId } : null
+}

package/src/modules/sync_excel/index.ts

@@ -2,6 +2,16 @@ export const metadata = {
   id: 'sync_excel',
   title: 'Excel / CSV Import',
   description: 'File-upload-based CSV import foundation built on top of the data sync hub.',
+  /**
+   * `customers` is a HARD dependency: `lib/adapters/customers.ts` reads `E.customers.*` at module scope.
+   *
+   * `E` only carries a key for an ENABLED module, so with `customers` switched off that read is
+   * `undefined.customer_entity` and it throws while the adapter is being imported — not inside a request, where
+   * it could be traced. Declaring it has the generator refuse the combination before anybody starts the app.
+   *
+   * `data_sync` is the hub this is built on, named in the description and now in the manifest too.
+   */
+  requires: ['customers', 'data_sync'],
 }
 
 export default metadata

package/src/modules/translations/di.ts

@@ -2,6 +2,7 @@ import { registerTranslatableFields } from '@open-mercato/shared/lib/localizatio
 import { registerTranslationOverlayPlugin } from '@open-mercato/shared/lib/localization/overlay-plugin'
 import { registerSupportedLocalesResolver } from '@open-mercato/shared/lib/i18n/locale-registry'
 import { translatableFields as catalogFields } from '../catalog/translations'
+import { translatableFields as customerFields } from '../customers/translations'
 import { translatableFields as dictionaryFields } from '../dictionaries/translations'
 import { translatableFields as entitiesFields } from '../entities/translations'
 import { translatableFields as resourcesFields } from '../resources/translations'
@@ -19,6 +20,7 @@ registerSupportedLocalesResolver(resolveTenantSupportedLocales)
 
 export function register() {
   registerTranslatableFields(catalogFields)
+  registerTranslatableFields(customerFields)
   registerTranslatableFields(dictionaryFields)
   registerTranslatableFields(entitiesFields)
   registerTranslatableFields(resourcesFields)