@open-mercato/core 0.6.7-develop.6696.1.4236709f7e → 0.6.7-develop.6725.1.07a748cfc2

package/src/modules/integrations/widgets/injection/external-ids/widget.ts

@@ -0,0 +1,13 @@
+import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'
+import ExternalIdsWidget from './widget.client'
+
+const widget: InjectionWidgetModule = {
+  metadata: {
+    id: 'integrations.injection.external-ids',
+    title: 'External IDs',
+    features: ['integrations.view'],
+  },
+  Widget: ExternalIdsWidget,
+}
+
+export default widget

package/src/modules/messages/lib/searchLookup.ts

@@ -1,10 +1,9 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
-import { type Kysely, sql } from 'kysely'
-import { resolveSearchConfig } from '@open-mercato/shared/lib/search/config'
-import { tokenizeText } from '@open-mercato/shared/lib/search/tokenize'
+import type { Kysely } from 'kysely'
+import { findEntityIdsBySearchTokensCompat, type SearchTokenDatabase } from '@open-mercato/shared/lib/search/tokenLookup'
 
-function getDb(em: EntityManager): Kysely<any> {
-  return em.getKysely<any>()
+function getDb(em: EntityManager): Kysely<SearchTokenDatabase> {
+  return em.getKysely<SearchTokenDatabase>()
 }
 
 export async function findMessageIdsBySearchTokens({
@@ -20,33 +19,11 @@ export async function findMessageIdsBySearchTokens({
   organizationId: string | null
   fields?: string[]
 }): Promise<string[] | null> {
-  const trimmed = query.trim()
-  if (!trimmed) return null
-
-  const tokens = tokenizeText(trimmed, resolveSearchConfig())
-  if (!tokens.hashes.length) return []
-
-  const db = getDb(em) as any
-  let searchQuery = db
-    .selectFrom('search_tokens')
-    .select('entity_id')
-    .where('entity_type', '=', 'messages:message')
-    .where('field', 'in', fields)
-    .where('token_hash', 'in', tokens.hashes)
-    .where(sql<boolean>`tenant_id is not distinct from ${tenantId}`)
-
-  if (organizationId) {
-    searchQuery = searchQuery.where('organization_id', '=', organizationId)
-  } else {
-    searchQuery = searchQuery.where(sql<boolean>`organization_id is not distinct from ${null}`)
-  }
-
-  const rows = await searchQuery
-    .groupBy('entity_id')
-    .having(sql<boolean>`count(distinct token_hash) >= ${tokens.hashes.length}`)
-    .execute()
-
-  return rows
-    .map((row: { entity_id?: unknown }) => (typeof row.entity_id === 'string' ? row.entity_id : null))
-    .filter((id: string | null): id is string => typeof id === 'string' && id.length > 0)
+  return findEntityIdsBySearchTokensCompat({
+    db: getDb(em),
+    entityType: 'messages:message',
+    query,
+    fields,
+    scope: { tenantId, organizationId },
+  })
 }

package/src/modules/payment_gateways/api/sessions/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { createSessionSchema } from '../../data/validators'
 import type { PaymentGatewayService } from '../../lib/gateway-service'
 import { paymentGatewaysTag } from '../openapi'
@@ -98,6 +99,9 @@ export async function POST(req: Request) {
       paymentId: transaction.paymentId,
     }, { status: 201 })
   } catch (err: unknown) {
+    if (isCrudHttpError(err)) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
     const message = err instanceof Error ? err.message : 'Failed to create payment session'
     const status = message.includes('No gateway adapter') ? 422 : 502
     return NextResponse.json({ error: message }, { status })
@@ -113,6 +117,7 @@ export const openApi = {
       tags: [paymentGatewaysTag],
       responses: [
         { status: 201, description: 'Payment session created' },
+        { status: 409, description: 'Amount or currency does not match the referenced order' },
         { status: 422, description: 'Invalid payload or unknown provider' },
         { status: 502, description: 'Gateway provider error' },
       ],

package/src/modules/payment_gateways/di.ts

@@ -4,9 +4,11 @@ import type { AppContainer } from '@open-mercato/shared/lib/di/container'
 import type { CredentialsService } from '../integrations/lib/credentials-service'
 import type { IntegrationLogService } from '../integrations/lib/log-service'
 import type { IntegrationStateService } from '../integrations/lib/state-service'
+import type { PaymentOrderTotalResolver } from '@open-mercato/shared/modules/payment_gateways/types'
 import { GatewayTransaction, WebhookProcessedEvent } from './data/entities'
 import { createPaymentGatewayDescriptorService } from './lib/descriptor-service'
 import { createPaymentGatewayService } from './lib/gateway-service'
+import { isPaymentOrderTotalResolver } from './lib/order-amount-reconciliation'
 
 type Cradle = {
   em: EntityManager
@@ -15,10 +17,34 @@ type Cradle = {
   integrationStateService: IntegrationStateService
 }
 
+const ORDER_TOTAL_RESOLVER_NAME = 'paymentOrderTotalResolver'
+
+/**
+ * The order-total resolver is owned by whichever module owns orders (`sales`
+ * registers the default one). Its absence is the only supported reason to skip
+ * amount reconciliation, so this only tolerates a missing registration: a
+ * registered resolver that fails to build or does not satisfy the contract
+ * throws instead of silently disabling the check.
+ */
+function resolveOrderTotalResolver(container: AppContainer, cradle: Cradle): PaymentOrderTotalResolver | null {
+  if (!container.hasRegistration(ORDER_TOTAL_RESOLVER_NAME)) return null
+  const candidate = (cradle as Cradle & { paymentOrderTotalResolver?: unknown })[ORDER_TOTAL_RESOLVER_NAME]
+  if (!isPaymentOrderTotalResolver(candidate)) {
+    throw new Error(`[internal] ${ORDER_TOTAL_RESOLVER_NAME} does not implement resolveOrderTotal`)
+  }
+  return candidate
+}
+
 export function register(container: AppContainer) {
   container.register({
-    paymentGatewayService: asFunction(({ em, integrationCredentialsService, integrationLogService, integrationStateService }: Cradle) =>
-      createPaymentGatewayService({ em, integrationCredentialsService, integrationLogService, integrationStateService }),
+    paymentGatewayService: asFunction((cradle: Cradle) =>
+      createPaymentGatewayService({
+        em: cradle.em,
+        integrationCredentialsService: cradle.integrationCredentialsService,
+        integrationLogService: cradle.integrationLogService,
+        integrationStateService: cradle.integrationStateService,
+        paymentOrderTotalResolver: resolveOrderTotalResolver(container, cradle),
+      }),
     ).scoped().proxy(),
     paymentGatewayDescriptorService: asFunction(({ integrationCredentialsService, integrationStateService }: Cradle) =>
       createPaymentGatewayDescriptorService({ integrationCredentialsService, integrationStateService }),

package/src/modules/payment_gateways/i18n/de.json

@@ -2,6 +2,9 @@
   "payment_gateways.captureMethod.automatic": "Automatisch",
   "payment_gateways.captureMethod.manual": "Manuell",
   "payment_gateways.column.gatewayStatus": "Gateway-Status",
+  "payment_gateways.errors.sessionAmountMismatch": "Der Betrag der Zahlungssitzung {amount} stimmt nicht mit dem fälligen Betrag der Bestellung {orderId} überein",
+  "payment_gateways.errors.sessionCurrencyMismatch": "Die Währung der Zahlungssitzung {currencyCode} stimmt nicht mit der Währung der Bestellung {orderId} überein",
+  "payment_gateways.errors.sessionOrderNotFound": "Bestellung {orderId} wurde im aktuellen Gültigkeitsbereich nicht gefunden",
   "payment_gateways.feature.capture": "Autorisierte Zahlungen erfassen",
   "payment_gateways.feature.manage": "Zahlungssitzungen verwalten",
   "payment_gateways.feature.refund": "Erfasste Zahlungen erstatten",

package/src/modules/payment_gateways/i18n/en.json

@@ -2,6 +2,9 @@
   "payment_gateways.captureMethod.automatic": "Automatic",
   "payment_gateways.captureMethod.manual": "Manual",
   "payment_gateways.column.gatewayStatus": "Gateway status",
+  "payment_gateways.errors.sessionAmountMismatch": "Payment session amount {amount} does not match the amount due for order {orderId}",
+  "payment_gateways.errors.sessionCurrencyMismatch": "Payment session currency {currencyCode} does not match the currency of order {orderId}",
+  "payment_gateways.errors.sessionOrderNotFound": "Order {orderId} was not found in the current scope",
   "payment_gateways.feature.capture": "Capture authorized payments",
   "payment_gateways.feature.manage": "Manage payment sessions",
   "payment_gateways.feature.refund": "Refund captured payments",

package/src/modules/payment_gateways/i18n/es.json

@@ -2,6 +2,9 @@
   "payment_gateways.captureMethod.automatic": "Automatica",
   "payment_gateways.captureMethod.manual": "Manual",
   "payment_gateways.column.gatewayStatus": "Estado de la pasarela",
+  "payment_gateways.errors.sessionAmountMismatch": "El importe de la sesión de pago {amount} no coincide con el importe pendiente del pedido {orderId}",
+  "payment_gateways.errors.sessionCurrencyMismatch": "La moneda de la sesión de pago {currencyCode} no coincide con la moneda del pedido {orderId}",
+  "payment_gateways.errors.sessionOrderNotFound": "No se encontró el pedido {orderId} en el ámbito actual",
   "payment_gateways.feature.capture": "Capturar pagos autorizados",
   "payment_gateways.feature.manage": "Gestionar sesiones de pago",
   "payment_gateways.feature.refund": "Reembolsar pagos capturados",

package/src/modules/payment_gateways/i18n/pl.json

@@ -2,6 +2,9 @@
   "payment_gateways.captureMethod.automatic": "Automatyczny",
   "payment_gateways.captureMethod.manual": "Manualny",
   "payment_gateways.column.gatewayStatus": "Status bramki",
+  "payment_gateways.errors.sessionAmountMismatch": "Kwota sesji płatności {amount} nie zgadza się z kwotą do zapłaty dla zamówienia {orderId}",
+  "payment_gateways.errors.sessionCurrencyMismatch": "Waluta sesji płatności {currencyCode} nie zgadza się z walutą zamówienia {orderId}",
+  "payment_gateways.errors.sessionOrderNotFound": "Nie znaleziono zamówienia {orderId} w bieżącym zakresie",
   "payment_gateways.feature.capture": "Przechwytywanie autoryzowanych płatności",
   "payment_gateways.feature.manage": "Zarządzanie sesjami płatności",
   "payment_gateways.feature.refund": "Zwroty przechwyconych płatności",

package/src/modules/payment_gateways/lib/gateway-service.ts

@@ -11,6 +11,7 @@ import {
   type GatewayAdapter,
   type GatewayPaymentStatus,
   type PaymentGatewayPresentationRequest,
+  type PaymentOrderTotalResolver,
   type UnifiedPaymentStatus,
 } from '@open-mercato/shared/modules/payment_gateways/types'
 import type { CredentialsService } from '../../integrations/lib/credentials-service'
@@ -21,6 +22,7 @@ import { GatewayPaymentOperation, GatewaySessionInitialization, GatewayTransacti
 import { canApplyManualAction, isValidTransition, type ManualGatewayAction } from './status-machine'
 import { emitPaymentGatewayEvent } from '../events'
 import { readGatewayMetadata, readWebhookLog } from './transaction-fields'
+import { reconcileSessionAmountWithOrder } from './order-amount-reconciliation'
 import {
   alignCapturedAmountWithStatus,
   assertCaptureWithinRemaining,
@@ -76,6 +78,11 @@ export interface PaymentGatewayServiceDeps {
   integrationCredentialsService: CredentialsService
   integrationStateService?: IntegrationStateService
   integrationLogService?: IntegrationLogService
+  /**
+   * Optional seam supplied by the module that owns orders (`sales` by default).
+   * When absent, session amounts cannot be reconciled and are accepted as-is.
+   */
+  paymentOrderTotalResolver?: PaymentOrderTotalResolver | null
   sessionClaimOptions?: {
     staleAfterMs?: number
     heartbeatIntervalMs?: number
@@ -405,6 +412,13 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
   return {
     async createPaymentSession(input: CreatePaymentSessionInput): Promise<{ transaction: GatewayTransaction; session: CreateSessionResult }> {
       const scope = { organizationId: input.organizationId, tenantId: input.tenantId }
+      await reconcileSessionAmountWithOrder({
+        orderId: input.orderId,
+        amount: input.amount,
+        currencyCode: input.currencyCode,
+        scope,
+        resolver: deps.paymentOrderTotalResolver,
+      })
       const { adapter, credentials } = await resolveAdapterAndCredentials(input.providerKey, scope)
 
       const sessionInput: CreateSessionInput = {

package/src/modules/payment_gateways/lib/order-amount-reconciliation.ts

@@ -0,0 +1,93 @@
+import { conflict } from '@open-mercato/shared/lib/crud/errors'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { createFallbackTranslator, type TranslateWithFallbackFn } from '@open-mercato/shared/lib/i18n/translate'
+import type {
+  PaymentGatewayScope,
+  PaymentOrderTotal,
+  PaymentOrderTotalResolver,
+} from '@open-mercato/shared/modules/payment_gateways/types'
+
+/** Amounts are stored as numeric(18,4); anything below that is rounding noise, not a mismatch. */
+const AMOUNT_TOLERANCE = 0.0001
+
+function normalizeCurrencyCode(currencyCode: string): string {
+  return currencyCode.trim().toUpperCase()
+}
+
+/**
+ * Conflict copy is served from the module catalog on a request path. Contexts
+ * without a registered module dictionary (CLI commands, workers, unit tests)
+ * fall back to the English template shipped with each call, so a missing
+ * dictionary degrades the wording of a rejection but never its outcome.
+ */
+async function resolveConflictTranslator(): Promise<TranslateWithFallbackFn> {
+  try {
+    const { translate } = await resolveTranslations()
+    return translate
+  } catch {
+    return createFallbackTranslator({})
+  }
+}
+
+export function isPaymentOrderTotalResolver(candidate: unknown): candidate is PaymentOrderTotalResolver {
+  return !!candidate
+    && typeof candidate === 'object'
+    && typeof (candidate as PaymentOrderTotalResolver).resolveOrderTotal === 'function'
+}
+
+export function assertSessionAmountMatchesOrderTotal(
+  requested: { orderId: string; amount: number; currencyCode: string },
+  orderTotal: PaymentOrderTotal,
+  translate: TranslateWithFallbackFn,
+): void {
+  if (normalizeCurrencyCode(requested.currencyCode) !== normalizeCurrencyCode(orderTotal.currencyCode)) {
+    throw conflict(translate(
+      'payment_gateways.errors.sessionCurrencyMismatch',
+      'Payment session currency {currencyCode} does not match the currency of order {orderId}',
+      { currencyCode: normalizeCurrencyCode(requested.currencyCode), orderId: requested.orderId },
+    ))
+  }
+  if (Math.abs(requested.amount - orderTotal.amountDue) > AMOUNT_TOLERANCE) {
+    throw conflict(translate(
+      'payment_gateways.errors.sessionAmountMismatch',
+      'Payment session amount {amount} does not match the amount due for order {orderId}',
+      { amount: requested.amount, orderId: requested.orderId },
+    ))
+  }
+}
+
+/**
+ * Reconciles a caller-supplied session amount against the authoritative amount
+ * due for the referenced order. Reconciliation is skipped when the request
+ * references no order, or when no module registered a resolver (for example an
+ * installation without the `sales` module) — there is nothing authoritative to
+ * compare against in either case. A referenced order that does not resolve
+ * inside the caller's tenant/organization scope is rejected exactly like an
+ * unknown one, so the response never reveals whether it exists elsewhere.
+ */
+export async function reconcileSessionAmountWithOrder(input: {
+  orderId?: string
+  amount: number
+  currencyCode: string
+  scope: PaymentGatewayScope
+  resolver?: PaymentOrderTotalResolver | null
+}): Promise<void> {
+  const { orderId, resolver } = input
+  if (!orderId || !resolver) return
+
+  const orderTotal = await resolver.resolveOrderTotal(orderId, input.scope)
+  const translate = await resolveConflictTranslator()
+  if (!orderTotal) {
+    throw conflict(translate(
+      'payment_gateways.errors.sessionOrderNotFound',
+      'Order {orderId} was not found in the current scope',
+      { orderId },
+    ))
+  }
+
+  assertSessionAmountMatchesOrderTotal(
+    { orderId, amount: input.amount, currencyCode: input.currencyCode },
+    orderTotal,
+    translate,
+  )
+}

package/src/modules/query_index/api/openapi.ts

@@ -37,13 +37,25 @@ export const queryIndexJobSchema = z.object({
 
 export const queryIndexStatusItemSchema = z.object({
   entityId: z.string(),
+  /** Human label. Code-defined entities have no label registry, so this mirrors `entityId`. */
   label: z.string(),
   baseCount: z.number().int().nonnegative().nullable(),
   indexCount: z.number().int().nonnegative().nullable(),
   vectorCount: z.number().int().nonnegative().nullable().optional(),
+  /** The entity declares `buildSource`, i.e. it is configured for vector search. */
   vectorEnabled: z.boolean().optional(),
+  /** Additive: vector indexing can actually run (auto-indexing on, provider reachable, tenant opted in). */
+  vectorIndexingActive: z.boolean().optional(),
+  fulltextCount: z.number().int().nonnegative().nullable().optional(),
+  fulltextEnabled: z.boolean().optional(),
+  /** Additive: the entity has active custom field definitions in the current scope. */
+  hasCustomFields: z.boolean().optional(),
+  /** Aggregate health: query index in sync AND, when vector-configured, vector coverage complete. */
   ok: z.boolean(),
+  /** Additive: query index alone is in sync with the base table, independent of vector/fulltext. */
+  queryIndexOk: z.boolean().optional(),
   job: queryIndexJobSchema,
+  refreshedAt: z.string().datetime().nullable().optional(),
 })
 
 export const queryIndexErrorLogSchema = z.object({