@open-mercato/core 0.6.6-develop.6290.1.4bb5a8ba3f → 0.6.6-develop.6299.1.29224e2d86

package/src/modules/configs/lib/module-config-service.ts

@@ -4,7 +4,7 @@ import type { AppContainer } from '@open-mercato/shared/lib/di/container'
 import { ModuleConfig } from '../data/entities'
 import { moduleConfigKeySchema } from '../data/validators'
 
-const CACHE_VERSION = 'v1'
+const CACHE_VERSION = 'v2'
 const CACHE_TTL_MS = 60_000
 
 type CachePayload = {
@@ -12,7 +12,10 @@ type CachePayload = {
   record?: ModuleConfigRecord | null
 }
 
-const cacheKey = (moduleId: string, name: string) => `module-config:${CACHE_VERSION}:${moduleId}:${name}`
+const scopeKeyPart = (tenantId?: string | null) => (tenantId ?? 'global')
+
+const cacheKey = (moduleId: string, name: string, tenantId?: string | null) =>
+  `module-config:${CACHE_VERSION}:${moduleId}:${name}:${scopeKeyPart(tenantId)}`
 const moduleTag = (moduleId: string) => `module-config:module:${moduleId}`
 
 const resolveEm = (container: AppContainer): EntityManager | null => {
@@ -31,10 +34,13 @@ const resolveCache = (container: AppContainer): CacheStrategy | null => {
   }
 }
 
-const toRecord = (entity: ModuleConfig): ModuleConfigRecord => ({
+const toRecord = (entity: ModuleConfig, source: ModuleConfigSource): ModuleConfigRecord => ({
   moduleId: entity.moduleId,
   name: entity.name,
   value: entity.valueJson ?? null,
+  tenantId: entity.tenantId ?? null,
+  organizationId: entity.organizationId ?? null,
+  source,
   createdAt: entity.createdAt.toISOString(),
   updatedAt: entity.updatedAt.toISOString(),
 })
@@ -73,10 +79,20 @@ const deleteCacheByModule = async (cache: CacheStrategy | null, moduleId: string
 
 const normalizeKey = (moduleId: string, name: string) => moduleConfigKeySchema.parse({ moduleId, name })
 
+export type ModuleConfigSource = 'tenant' | 'instance'
+
+export type ConfigScope = {
+  tenantId?: string | null
+  organizationId?: string | null
+}
+
 export type ModuleConfigRecord = {
   moduleId: string
   name: string
   value: unknown
+  tenantId: string | null
+  organizationId: string | null
+  source: ModuleConfigSource
   createdAt: string
   updatedAt: string
 }
@@ -88,18 +104,23 @@ export type ModuleConfigDefault = {
 }
 
 export type ModuleConfigService = {
-  getRecord(moduleId: string, name: string): Promise<ModuleConfigRecord | null>
-  getValue<T = unknown>(moduleId: string, name: string, options?: { defaultValue?: T | null }): Promise<T | null>
-  setValue(moduleId: string, name: string, value: unknown): Promise<ModuleConfigRecord | null>
+  getRecord(moduleId: string, name: string, scope?: ConfigScope): Promise<ModuleConfigRecord | null>
+  getValue<T = unknown>(
+    moduleId: string,
+    name: string,
+    options?: { defaultValue?: T | null; scope?: ConfigScope },
+  ): Promise<T | null>
+  setValue(moduleId: string, name: string, value: unknown, scope?: ConfigScope): Promise<ModuleConfigRecord | null>
   restoreDefaults(defaults: ModuleConfigDefault[], options?: { force?: boolean }): Promise<void>
-  invalidate(moduleId: string, name?: string): Promise<void>
+  invalidate(moduleId: string, name?: string, scope?: ConfigScope): Promise<void>
 }
 
 export function createModuleConfigService(container: AppContainer): ModuleConfigService {
-  const getRecord = async (rawModuleId: string, rawName: string): Promise<ModuleConfigRecord | null> => {
+  const getRecord = async (rawModuleId: string, rawName: string, scope?: ConfigScope): Promise<ModuleConfigRecord | null> => {
     const { moduleId, name } = normalizeKey(rawModuleId, rawName)
+    const tenantId = scope?.tenantId ?? null
     const cache = resolveCache(container)
-    const key = cacheKey(moduleId, name)
+    const key = cacheKey(moduleId, name, tenantId)
     const cached = await readCache(cache, key)
     if (cached) {
       if (!cached.found) return null
@@ -109,47 +130,84 @@ export function createModuleConfigService(container: AppContainer): ModuleConfig
     const em = resolveEm(container)
     if (!em) return null
     const repo = em.getRepository(ModuleConfig)
-    const entity = await repo.findOne({ moduleId, name })
-    if (!entity) {
+
+    if (tenantId) {
+      const scoped = await repo.findOne({ moduleId, name, tenantId })
+      if (scoped) {
+        const record = toRecord(scoped, 'tenant')
+        await writeCache(cache, key, { found: true, record }, moduleId)
+        return record
+      }
+      const global = await repo.findOne({ moduleId, name, tenantId: null })
+      if (!global) {
+        await writeCache(cache, key, { found: false }, moduleId)
+        return null
+      }
+      const record = toRecord(global, 'instance')
+      await writeCache(cache, key, { found: true, record }, moduleId)
+      return record
+    }
+
+    const global = await repo.findOne({ moduleId, name, tenantId: null })
+    if (!global) {
       await writeCache(cache, key, { found: false }, moduleId)
       return null
     }
-    const record = toRecord(entity)
+    const record = toRecord(global, 'instance')
     await writeCache(cache, key, { found: true, record }, moduleId)
     return record
   }
 
-  const getValue = async <T>(rawModuleId: string, rawName: string, options?: { defaultValue?: T | null }): Promise<T | null> => {
-    const record = await getRecord(rawModuleId, rawName)
+  const getValue = async <T>(
+    rawModuleId: string,
+    rawName: string,
+    options?: { defaultValue?: T | null; scope?: ConfigScope },
+  ): Promise<T | null> => {
+    const record = await getRecord(rawModuleId, rawName, options?.scope)
     if (!record) return options?.defaultValue ?? null
     const value = record.value as T | null | undefined
     if (value === undefined || value === null) return options?.defaultValue ?? null
     return value
   }
 
-  const setValue = async (rawModuleId: string, rawName: string, value: unknown): Promise<ModuleConfigRecord | null> => {
+  const setValue = async (
+    rawModuleId: string,
+    rawName: string,
+    value: unknown,
+    scope?: ConfigScope,
+  ): Promise<ModuleConfigRecord | null> => {
     const em = resolveEm(container)
     if (!em) return null
     const { moduleId, name } = normalizeKey(rawModuleId, rawName)
+    const tenantId = scope?.tenantId ?? null
+    const organizationId = scope?.organizationId ?? null
     const repo = em.getRepository(ModuleConfig)
     const now = new Date()
-    let entity = await repo.findOne({ moduleId, name })
+    let entity = await repo.findOne({ moduleId, name, tenantId })
     if (!entity) {
       entity = repo.create({
         moduleId,
         name,
         valueJson: value ?? null,
+        tenantId,
+        organizationId,
         createdAt: now,
         updatedAt: now,
       })
       em.persist(entity)
     } else {
       entity.valueJson = value ?? null
+      entity.organizationId = organizationId
       entity.updatedAt = now
     }
     await em.flush()
-    const record = toRecord(entity)
-    await writeCache(resolveCache(container), cacheKey(moduleId, name), { found: true, record }, moduleId)
+    const record = toRecord(entity, tenantId ? 'tenant' : 'instance')
+    const cache = resolveCache(container)
+    if (tenantId) {
+      await writeCache(cache, cacheKey(moduleId, name, tenantId), { found: true, record }, moduleId)
+    } else {
+      await deleteCacheByModule(cache, moduleId)
+    }
     return record
   }
 
@@ -165,12 +223,14 @@ export function createModuleConfigService(container: AppContainer): ModuleConfig
       let entity: ModuleConfig | null = null
       try {
         const { moduleId, name } = normalizeKey(entry.moduleId, entry.name)
-        entity = await repo.findOne({ moduleId, name })
+        entity = await repo.findOne({ moduleId, name, tenantId: null })
         if (!entity) {
           entity = repo.create({
             moduleId,
             name,
             valueJson: entry.value ?? null,
+            tenantId: null,
+            organizationId: null,
           })
           em.persist(entity)
           dirty = true
@@ -186,17 +246,17 @@ export function createModuleConfigService(container: AppContainer): ModuleConfig
     if (!dirty) return
     await em.flush()
     for (const entity of touched) {
-      const record = toRecord(entity)
-      await writeCache(cache, cacheKey(entity.moduleId, entity.name), { found: true, record }, entity.moduleId)
+      const record = toRecord(entity, 'instance')
+      await writeCache(cache, cacheKey(entity.moduleId, entity.name, null), { found: true, record }, entity.moduleId)
     }
   }
 
-  const invalidate = async (rawModuleId: string, rawName?: string) => {
+  const invalidate = async (rawModuleId: string, rawName?: string, scope?: ConfigScope) => {
     const cache = resolveCache(container)
     if (!cache) return
     if (rawName) {
       const { moduleId, name } = normalizeKey(rawModuleId, rawName)
-      await deleteCacheKey(cache, cacheKey(moduleId, name))
+      await deleteCacheKey(cache, cacheKey(moduleId, name, scope?.tenantId ?? null))
       return
     }
     const moduleId = moduleConfigKeySchema.shape.moduleId.parse(rawModuleId)
@@ -211,4 +271,3 @@ export function createModuleConfigService(container: AppContainer): ModuleConfig
     invalidate,
   }
 }
-

package/src/modules/configs/migrations/.snapshot-open-mercato.json

@@ -43,6 +43,24 @@
           "nullable": true,
           "mappedType": "json"
         },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "uuid",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "mappedType": "uuid"
+        },
+        "tenant_id": {
+          "name": "tenant_id",
+          "type": "uuid",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "mappedType": "uuid"
+        },
         "created_at": {
           "name": "created_at",
           "type": "timestamptz",
@@ -68,15 +86,34 @@
       "schema": "public",
       "indexes": [
         {
-          "keyName": "module_configs_module_name_unique",
+          "keyName": "module_configs_global_unique",
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"module_configs_global_unique\" on \"module_configs\" (\"module_id\", \"name\") where \"tenant_id\" is null"
+        },
+        {
+          "keyName": "module_configs_scoped_unique",
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"module_configs_scoped_unique\" on \"module_configs\" (\"module_id\", \"name\", \"tenant_id\") where \"tenant_id\" is not null"
+        },
+        {
+          "keyName": "module_configs_module_name_tenant_idx",
           "columnNames": [
             "module_id",
-            "name"
+            "name",
+            "tenant_id"
           ],
           "composite": true,
-          "constraint": true,
+          "constraint": false,
           "primary": false,
-          "unique": true
+          "unique": false
         },
         {
           "keyName": "module_configs_pkey",

package/src/modules/configs/migrations/.snapshot-openmercato.json

@@ -43,6 +43,24 @@
           "nullable": true,
           "mappedType": "json"
         },
+        "organization_id": {
+          "name": "organization_id",
+          "type": "uuid",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "mappedType": "uuid"
+        },
+        "tenant_id": {
+          "name": "tenant_id",
+          "type": "uuid",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "mappedType": "uuid"
+        },
         "created_at": {
           "name": "created_at",
           "type": "timestamptz",
@@ -68,15 +86,34 @@
       "schema": "public",
       "indexes": [
         {
-          "keyName": "module_configs_module_name_unique",
+          "keyName": "module_configs_global_unique",
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"module_configs_global_unique\" on \"module_configs\" (\"module_id\", \"name\") where \"tenant_id\" is null"
+        },
+        {
+          "keyName": "module_configs_scoped_unique",
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"module_configs_scoped_unique\" on \"module_configs\" (\"module_id\", \"name\", \"tenant_id\") where \"tenant_id\" is not null"
+        },
+        {
+          "keyName": "module_configs_module_name_tenant_idx",
           "columnNames": [
             "module_id",
-            "name"
+            "name",
+            "tenant_id"
           ],
           "composite": true,
-          "constraint": true,
+          "constraint": false,
           "primary": false,
-          "unique": true
+          "unique": false
         },
         {
           "keyName": "module_configs_pkey",

package/src/modules/configs/migrations/Migration20260617150000.ts

@@ -0,0 +1,21 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260617150000 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table "module_configs" add column "organization_id" uuid null, add column "tenant_id" uuid null;`);
+    this.addSql(`alter table "module_configs" drop constraint "module_configs_module_name_unique";`);
+    this.addSql(`create unique index "module_configs_global_unique" on "module_configs" ("module_id", "name") where "tenant_id" is null;`);
+    this.addSql(`create unique index "module_configs_scoped_unique" on "module_configs" ("module_id", "name", "tenant_id") where "tenant_id" is not null;`);
+    this.addSql(`create index "module_configs_module_name_tenant_idx" on "module_configs" ("module_id", "name", "tenant_id");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop index if exists "module_configs_module_name_tenant_idx";`);
+    this.addSql(`drop index if exists "module_configs_scoped_unique";`);
+    this.addSql(`drop index if exists "module_configs_global_unique";`);
+    this.addSql(`alter table "module_configs" add constraint "module_configs_module_name_unique" unique ("module_id", "name");`);
+    this.addSql(`alter table "module_configs" drop column "organization_id", drop column "tenant_id";`);
+  }
+
+}

package/src/modules/customers/api/activities/route.ts

@@ -74,6 +74,12 @@ const ADAPTER_HEADERS = {
 // canonical bridge) read path. Keeps memory bounded on tenants with large
 // activity history; deep-pagination beyond this window is not supported here —
 // use /api/customers/interactions instead.
+//
+// Audited for the #3386 rollout (P2): this merged path sorts only on
+// non-encrypted system timestamps (createdAt/occurredAt, see
+// resolveActivitySortValue), so the #3278 two-phase *encrypted*-sort migration
+// is intentionally not applied here. Merge-order correctness across the page
+// boundary is covered by __tests__/merged-pagination.test.ts.
 const MERGED_ACTIVITY_FETCH_CAP = 2000
 
 type ActivityItem = {

package/src/modules/inbox_ops/api/proposals/[id]/replies/[replyId]/send/route.ts

@@ -1,4 +1,5 @@
 import { NextResponse } from 'next/server'
+import { raw } from '@mikro-orm/core'
 import { Resend } from 'resend'
 import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
 import { resolveDefaultEmailFromAddress } from '@open-mercato/shared/lib/email/config'
@@ -111,6 +112,57 @@ export async function POST(req: Request) {
       headers['References'] = references.join(' ')
     }
 
+    // Atomically claim the send right before calling the external email provider so
+    // two concurrent requests cannot both deliver the same reply. The claim only
+    // succeeds when neither replySentAt nor replySendClaimedAt is already set in the
+    // metadata; a losing request gets 0 rows back and is rejected with 409.
+    const sendClaimedAt = new Date().toISOString()
+    const claimed = await ctx.em.nativeUpdate(
+      InboxProposalAction,
+      {
+        id: action.id,
+        proposalId: proposal.id,
+        actionType: 'draft_reply',
+        organizationId: ctx.organizationId,
+        tenantId: ctx.tenantId,
+        deletedAt: null,
+        status: 'executed',
+        [raw(`coalesce("metadata"->>'replySentAt', '')`)]: '',
+        [raw(`coalesce("metadata"->>'replySendClaimedAt', '')`)]: '',
+      },
+      {
+        metadata: raw(
+          `coalesce("metadata", '{}'::jsonb) || jsonb_build_object('replySendClaimedAt', ?::text)`,
+          [sendClaimedAt],
+        ),
+      },
+    )
+
+    if (claimed === 0) {
+      return NextResponse.json(
+        { error: 'Reply send is already in progress or has been sent for this action' },
+        { status: 409 },
+      )
+    }
+
+    const releaseSendClaim = async () => {
+      try {
+        await ctx.em.nativeUpdate(
+          InboxProposalAction,
+          {
+            id: action.id,
+            organizationId: ctx.organizationId,
+            tenantId: ctx.tenantId,
+            [raw(`coalesce("metadata"->>'replySentAt', '')`)]: '',
+            [raw(`("metadata"->>'replySendClaimedAt')`)]: sendClaimedAt,
+          },
+          { metadata: raw(`"metadata" - 'replySendClaimedAt'`) },
+        )
+      } catch (releaseError) {
+        console.error('[inbox_ops:reply:send] Failed to release send claim:', releaseError)
+      }
+    }
+
     const resend = new Resend(apiKey)
     const { data: sendData, error: sendError } = await resend.emails.send({
       to: toAddress,
@@ -121,6 +173,7 @@ export async function POST(req: Request) {
     })
 
     if (sendError) {
+      await releaseSendClaim()
       const errorMessage = sendError.message || 'Unknown error'
       return NextResponse.json({ error: `Failed to send email: ${errorMessage}` }, { status: 502 })
     }
@@ -182,7 +235,7 @@ export const openApi: OpenApiRouteDoc = {
         { status: 200, description: 'Reply sent successfully' },
         { status: 400, description: 'Missing required payload fields' },
         { status: 404, description: 'Reply action not found' },
-        { status: 409, description: 'Action in invalid state for sending' },
+        { status: 409, description: 'Action in invalid state for sending, or a send is already in progress / completed for this reply' },
         { status: 502, description: 'Email delivery failed' },
         { status: 503, description: 'Email service not configured or disabled' },
       ],