@open-mercato/core 0.10.1-develop.7836.1.0ef0f453c6 → 0.10.1-develop.7841.1.af87ac614d

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)