@open-mercato/checkout 0.10.1-develop.7716.1.cefe7975df → 0.10.1-develop.7721.1.b5c4a00a68

package/src/modules/checkout/commands/__tests__/link-undo-runtime-counters.test.ts

@@ -0,0 +1,222 @@
+/** @jest-environment node */
+
+import { commandRegistry } from '@open-mercato/shared/lib/commands/registry'
+import type { CommandRuntimeContext, CommandUndoLogEntry } from '@open-mercato/shared/lib/commands/types'
+import type { CheckoutLink } from '../../data/entities'
+import { createLinkFromSnapshot, restoreLinkFromSnapshot, type CheckoutLinkSnapshot } from '../shared'
+
+const ORG_ID = '123e4567-e89b-12d3-a456-426614174000'
+const TENANT_ID = '123e4567-e89b-12d3-a456-426614174001'
+const LINK_ID = '123e4567-e89b-12d3-a456-426614174010'
+
+const mockFindOneWithDecryption = jest.fn()
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: jest.fn((...args: unknown[]) => mockFindOneWithDecryption(...args)),
+  findWithDecryption: jest.fn(async () => []),
+}))
+
+jest.mock('../../lib/gatewayProviderAvailability', () => ({
+  ensureGatewayProviderConfigured: jest.fn(async () => undefined),
+  getGatewayProviderConfigurationMessageKey: jest.fn(() => null),
+}))
+
+jest.mock('@open-mercato/shared/lib/commands/helpers', () => ({
+  setCustomFieldsIfAny: jest.fn(async () => undefined),
+}))
+
+jest.mock('@open-mercato/shared/lib/commands/customFieldSnapshots', () => ({
+  loadCustomFieldSnapshot: jest.fn(async () => ({})),
+  buildCustomFieldResetMap: jest.fn(() => ({})),
+}))
+
+jest.mock('@open-mercato/shared/lib/crud/custom-fields', () => ({
+  loadCustomFieldValues: jest.fn(async () => ({})),
+}))
+
+jest.mock('../../events', () => ({
+  emitCheckoutEvent: jest.fn(async () => undefined),
+}))
+
+import '../links'
+
+type LiveLink = Record<string, unknown> & {
+  completionCount: number
+  activeReservationCount: number
+  isLocked: boolean
+}
+
+function liveLink(overrides: Partial<LiveLink> = {}): LiveLink {
+  return {
+    id: LINK_ID,
+    organizationId: ORG_ID,
+    tenantId: TENANT_ID,
+    name: 'Pay link',
+    title: 'Edited title',
+    slug: 'pay-link',
+    templateId: null,
+    status: 'active',
+    pricingMode: 'fixed',
+    fixedPriceAmount: '25.00',
+    fixedPriceCurrencyCode: 'USD',
+    gatewayProviderKey: 'mock',
+    gatewaySettings: {},
+    maxCompletions: 2,
+    completionCount: 1,
+    activeReservationCount: 0,
+    isLocked: false,
+    deletedAt: null,
+    ...overrides,
+  }
+}
+
+function snapshot(overrides: Partial<CheckoutLinkSnapshot> = {}): CheckoutLinkSnapshot {
+  return {
+    id: LINK_ID,
+    organizationId: ORG_ID,
+    tenantId: TENANT_ID,
+    name: 'Pay link',
+    title: 'Original title',
+    slug: 'pay-link',
+    templateId: null,
+    status: 'active',
+    pricingMode: 'fixed',
+    fixedPriceAmount: 25,
+    fixedPriceCurrencyCode: 'USD',
+    gatewayProviderKey: 'mock',
+    gatewaySettings: {},
+    maxCompletions: 2,
+    completionCount: 0,
+    activeReservationCount: 0,
+    isLocked: false,
+    passwordHash: null,
+    ...overrides,
+  } as CheckoutLinkSnapshot
+}
+
+function makeEm(link: LiveLink | null) {
+  return {
+    findOne: jest.fn(async (_entity: unknown, where: Record<string, unknown>) => (where.slug ? null : link)),
+    create: jest.fn((_entity: unknown, data: Record<string, unknown>) => ({ ...data })),
+    persist: jest.fn(),
+    flush: jest.fn(async () => undefined),
+  }
+}
+
+function makeContext(em: unknown): CommandRuntimeContext {
+  return {
+    container: {
+      resolve: (token: string) => {
+        if (token === 'em') return em
+        if (token === 'dataEngine') return {}
+        if (token === 'paymentGatewayDescriptorService') return {}
+        if (token === 'commandOptimisticLockGuardService') throw new Error('not registered')
+        return null
+      },
+    } as unknown as CommandRuntimeContext['container'],
+    auth: { sub: 'user-1', orgId: ORG_ID, tenantId: TENANT_ID } as CommandRuntimeContext['auth'],
+    organizationScope: null,
+    selectedOrganizationId: ORG_ID,
+    organizationIds: [ORG_ID],
+  }
+}
+
+function logEntry(undo: Record<string, unknown>): CommandUndoLogEntry {
+  return { commandPayload: { undo } } as CommandUndoLogEntry
+}
+
+async function runUndo(commandId: string, entry: CommandUndoLogEntry, em: unknown) {
+  const handler = commandRegistry.get(commandId)
+  if (!handler?.undo) throw new Error(`[internal] ${commandId} has no undo handler`)
+  return handler.undo({ input: {}, ctx: makeContext(em), logEntry: entry } as never)
+}
+
+async function runRedo(commandId: string, entry: CommandUndoLogEntry, em: unknown) {
+  const handler = commandRegistry.get(commandId)
+  if (!handler?.redo) throw new Error(`[internal] ${commandId} has no redo handler`)
+  return handler.redo({ input: {}, ctx: makeContext(em), logEntry: entry } as never)
+}
+
+describe('pay-link runtime counters across undo/redo', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('restores configuration from a snapshot but keeps the live counters', () => {
+    const target = liveLink({ completionCount: 2, activeReservationCount: 1, isLocked: true })
+
+    restoreLinkFromSnapshot(target as unknown as CheckoutLink, snapshot())
+
+    expect(target.title).toBe('Original title')
+    expect(target).toMatchObject({ completionCount: 2, activeReservationCount: 1, isLocked: true })
+  })
+
+  it('still seeds the counters when the snapshot becomes a brand-new row', () => {
+    expect(createLinkFromSnapshot(snapshot({ completionCount: 1, activeReservationCount: 0, isLocked: false }))).toMatchObject({
+      id: LINK_ID,
+      completionCount: 1,
+      activeReservationCount: 0,
+      isLocked: false,
+    })
+  })
+
+  it('undoing an edit keeps payments completed after the edit', async () => {
+    const link = liveLink({ completionCount: 2 })
+    const em = makeEm(link)
+
+    await runUndo('checkout.link.update', logEntry({ before: snapshot(), after: snapshot({ title: 'Edited title' }) }), em)
+
+    expect(em.flush).toHaveBeenCalled()
+    expect(link.title).toBe('Original title')
+    expect(link).toMatchObject({ completionCount: 2, activeReservationCount: 0, isLocked: false })
+  })
+
+  it('refuses to undo an edit while the link has payments in flight, like the edit itself', async () => {
+    const link = liveLink({ completionCount: 0, activeReservationCount: 1, isLocked: true })
+    const em = makeEm(link)
+
+    await expect(
+      runUndo('checkout.link.update', logEntry({ before: snapshot(), after: snapshot({ title: 'Edited title' }) }), em),
+    ).rejects.toMatchObject({ status: 422 })
+    expect(em.flush).not.toHaveBeenCalled()
+    expect(link).toMatchObject({ title: 'Edited title', activeReservationCount: 1, isLocked: true })
+  })
+
+  it('redoing a create keeps the counters of the soft-deleted row it revives', async () => {
+    const link = liveLink({ completionCount: 1, deletedAt: new Date() })
+    mockFindOneWithDecryption.mockResolvedValueOnce(link)
+    const em = makeEm(null)
+
+    await runRedo('checkout.link.create', logEntry({ after: snapshot() }), em)
+
+    expect(link.deletedAt).toBeNull()
+    expect(link).toMatchObject({ completionCount: 1, activeReservationCount: 0, isLocked: false })
+  })
+
+  it('undoing a delete keeps the counters of the restored row', async () => {
+    const link = liveLink({ completionCount: 2, deletedAt: new Date() })
+    const em = makeEm(link)
+
+    await runUndo('checkout.link.delete', logEntry({ before: snapshot({ completionCount: 1, deletedAt: null } as Partial<CheckoutLinkSnapshot>) }), em)
+
+    expect(link.deletedAt).toBeNull()
+    expect(link).toMatchObject({ completionCount: 2, activeReservationCount: 0, isLocked: false })
+  })
+
+  it('redoing an edit re-runs it and cannot write the runtime counters', async () => {
+    const link = liveLink({ completionCount: 2 })
+    mockFindOneWithDecryption.mockResolvedValueOnce(link)
+    const em = makeEm(link)
+    const handler = commandRegistry.get('checkout.link.update')
+    if (!handler) throw new Error('[internal] checkout.link.update not registered')
+
+    await handler.execute(
+      { id: LINK_ID, title: 'Edited again', completionCount: 0, activeReservationCount: 0, isLocked: false },
+      makeContext(em),
+    )
+
+    expect(em.flush).toHaveBeenCalled()
+    expect(link.title).toBe('Edited again')
+    expect(link).toMatchObject({ completionCount: 2, activeReservationCount: 0, isLocked: false })
+  })
+})

package/src/modules/checkout/commands/__tests__/update-transaction-status.test.ts

@@ -51,7 +51,21 @@ function makeTransaction(status: CheckoutTransaction['status']) {
   }
 }
 
-function makeLink() {
+type LinkRow = {
+  id: string
+  organizationId: string
+  tenantId: string
+  slug: string
+  templateId: string | null
+  gatewayProviderKey: string
+  activeReservationCount: number
+  completionCount: number
+  maxCompletions: number | null
+  isLocked: boolean
+  deletedAt: null
+}
+
+function makeLink(overrides: Partial<LinkRow> = {}): LinkRow {
   return {
     id: LINK_ID,
     organizationId: ORG_ID,
@@ -64,15 +78,20 @@ function makeLink() {
     maxCompletions: null,
     isLocked: false,
     deletedAt: null,
+    ...overrides,
   }
 }
 
+type ReleasedLinkRow = { completion_count: number; max_completions: number | null }
+
 type MockEm = {
   findOne: jest.Mock
   nativeUpdate: jest.Mock
+  execute: jest.Mock
   flush: jest.Mock
   refresh: jest.Mock
   transactional: (fn: (tx: MockEm) => Promise<unknown>) => Promise<unknown>
+  link: LinkRow
 }
 
 function makeMockEm(
@@ -81,9 +100,13 @@ function makeMockEm(
   // When nativeUpdate returns 0, the post-CAS findOne should return a
   // different status to simulate the winning writer's value.
   postCasStatus?: CheckoutTransaction['status'],
+  options: { link?: LinkRow; released?: ReleasedLinkRow[] } = {},
 ): MockEm {
   let findOneCallCount = 0
+  const link = options.link ?? makeLink()
+  const released = options.released ?? [{ completion_count: 1, max_completions: null }]
   const mockTx: MockEm = {
+    link,
     findOne: jest.fn(async (_entity: unknown, filter: Record<string, unknown>) => {
       findOneCallCount++
       if (filter.id === TX_ID) {
@@ -95,10 +118,11 @@ function makeMockEm(
         }
         return transaction
       }
-      if (filter.id === LINK_ID) return makeLink()
+      if (filter.id === LINK_ID) return link
       return null
     }),
     nativeUpdate: jest.fn(async () => nativeUpdateResult),
+    execute: jest.fn(async () => released),
     flush: jest.fn(async () => undefined),
     refresh: jest.fn(async () => undefined),
     transactional: (fn) => fn(mockTx),
@@ -132,6 +156,10 @@ function baseInput(status: string) {
   }
 }
 
+function linkCounterUpdateCalls(em: MockEm) {
+  return em.execute.mock.calls.filter(([sql]) => typeof sql === 'string' && sql.includes('UPDATE checkout_links'))
+}
+
 async function runUpdateStatus(em: MockEm, status: string) {
   const handler = commandRegistry.get('checkout.transaction.updateStatus')
   if (!handler) throw new Error('checkout.transaction.updateStatus not registered')
@@ -361,3 +389,97 @@ describe('updateTransactionStatusCommand — state-machine guard', () => {
   })
 })
 
+describe('updateTransactionStatusCommand — pay-link usage counters', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('processing → completed releases the reservation and counts the completion with one relative UPDATE', async () => {
+    const em = makeMockEm(makeTransaction('processing'), 1)
+
+    await runUpdateStatus(em, 'completed')
+
+    const calls = linkCounterUpdateCalls(em)
+    expect(calls).toHaveLength(1)
+    const [sql, params] = calls[0] as [string, unknown[]]
+    expect(sql).toMatch(/active_reservation_count = GREATEST\(active_reservation_count - 1, 0\)/)
+    expect(sql).toMatch(/completion_count = completion_count \+ \?/)
+    expect(sql).toMatch(/is_locked = GREATEST\(active_reservation_count - 1, 0\) > 0/)
+    expect(sql).toMatch(/organization_id = \?/)
+    expect(sql).toMatch(/tenant_id = \?/)
+    expect(sql).toMatch(/deleted_at IS NULL/)
+    expect(params).toEqual([1, LINK_ID, ORG_ID, TENANT_ID])
+  })
+
+  it.each(['failed', 'cancelled', 'expired'] as const)(
+    'processing → %s releases the reservation without counting a completion',
+    async (status) => {
+      const em = makeMockEm(makeTransaction('processing'), 1, undefined, {
+        released: [{ completion_count: 0, max_completions: 1 }],
+      })
+
+      await runUpdateStatus(em, status)
+
+      const calls = linkCounterUpdateCalls(em)
+      expect(calls).toHaveLength(1)
+      expect((calls[0] as [string, unknown[]])[1]).toEqual([0, LINK_ID, ORG_ID, TENANT_ID])
+      expect(emitCheckoutEvent).not.toHaveBeenCalledWith('checkout.link.usageLimitReached', expect.any(Object))
+    },
+  )
+
+  it('never writes counters computed from the link row it read earlier', async () => {
+    const em = makeMockEm(makeTransaction('processing'), 1, undefined, {
+      link: makeLink({ activeReservationCount: 1, completionCount: 0, isLocked: true }),
+      released: [{ completion_count: 3, max_completions: null }],
+    })
+
+    await runUpdateStatus(em, 'completed')
+
+    expect(em.link).toMatchObject({ activeReservationCount: 1, completionCount: 0, isLocked: true })
+  })
+
+  it('reports the usage limit from the committed count, not the stale count it read', async () => {
+    const em = makeMockEm(makeTransaction('processing'), 1, undefined, {
+      link: makeLink({ completionCount: 0, maxCompletions: 2 }),
+      released: [{ completion_count: 2, max_completions: 2 }],
+    })
+
+    await runUpdateStatus(em, 'completed')
+
+    expect(emitCheckoutEvent).toHaveBeenCalledWith('checkout.link.usageLimitReached', {
+      id: LINK_ID,
+      slug: 'test-link',
+      tenantId: TENANT_ID,
+      organizationId: ORG_ID,
+    })
+  })
+
+  it('reports the usage limit only for the completion that reaches it', async () => {
+    const em = makeMockEm(makeTransaction('processing'), 1, undefined, {
+      link: makeLink({ completionCount: 2, maxCompletions: 2 }),
+      released: [{ completion_count: 3, max_completions: 2 }],
+    })
+
+    await runUpdateStatus(em, 'completed')
+
+    expect(emitCheckoutEvent).toHaveBeenCalledWith('checkout.transaction.completed', expect.any(Object))
+    expect(emitCheckoutEvent).not.toHaveBeenCalledWith('checkout.link.usageLimitReached', expect.any(Object))
+  })
+
+  it('fails with 404 and emits nothing when the link row is gone by the time the reservation is released', async () => {
+    const em = makeMockEm(makeTransaction('processing'), 1, undefined, { released: [] })
+
+    await expect(runUpdateStatus(em, 'completed')).rejects.toMatchObject({ status: 404 })
+    expect(emitCheckoutEvent).not.toHaveBeenCalled()
+  })
+
+  it('does not touch the counters on a same-status redelivery or a non-terminal transition', async () => {
+    const redelivery = makeMockEm(makeTransaction('completed'), 1)
+    await runUpdateStatus(redelivery, 'completed')
+    expect(linkCounterUpdateCalls(redelivery)).toHaveLength(0)
+
+    const nonTerminal = makeMockEm(makeTransaction('pending'), 1)
+    await runUpdateStatus(nonTerminal, 'processing')
+    expect(linkCounterUpdateCalls(nonTerminal)).toHaveLength(0)
+  })
+})

package/src/modules/checkout/commands/links.ts

@@ -392,6 +392,12 @@ const updateLinkCommand: CommandHandler<Record<string, unknown>, { ok: true; slu
     const dataEngine = ctx.container.resolve('dataEngine') as DataEngine
     const link = await em.findOne(CheckoutLink, { id: before.id, ...scope, deletedAt: null })
     if (!link) return
+    if (link.isLocked) {
+      const { translate } = await resolveTranslations()
+      throw new CrudHttpError(422, {
+        error: translate('checkout.errors.links.lockedEdit', 'This link has active transactions and cannot be edited'),
+      })
+    }
     restoreLinkFromSnapshot(link, before)
     link.slug = await resolveRestoredLinkSlug(em, before)
     await em.flush()

package/src/modules/checkout/commands/shared.ts

@@ -266,6 +266,11 @@ export function restoreTemplateFromSnapshot(
   Object.assign(target, buildTemplateSnapshotData(snapshot))
 }
 
+/**
+ * Restores configuration onto an existing link. The usage counters and lock flag are
+ * owned by the link's transactions, so the live row keeps them: rewinding them to a
+ * snapshot would drop payments made after it was taken and reopen sold-out links.
+ */
 export function restoreLinkFromSnapshot(
   target: CheckoutLink,
   snapshot: CheckoutLinkSnapshot,
@@ -274,9 +279,6 @@ export function restoreLinkFromSnapshot(
     ...buildTemplateSnapshotData(snapshot),
     slug: snapshot.slug,
     templateId: snapshot.templateId ?? null,
-    completionCount: snapshot.completionCount,
-    activeReservationCount: snapshot.activeReservationCount,
-    isLocked: snapshot.isLocked,
   })
 }
 

package/src/modules/checkout/commands/transactions.ts

@@ -2,11 +2,11 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import type { CommandHandler } from '@open-mercato/shared/lib/commands'
 import { registerCommand } from '@open-mercato/shared/lib/commands'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import { CheckoutLink, CheckoutTransaction } from '../data/entities'
 import { transactionCreateSchema, transactionUpdateStatusSchema } from '../data/validators'
 import { emitCheckoutEvent } from '../events'
 import {
-  applyTerminalTransactionState,
   isTerminalCheckoutStatus,
   mapGatewayStatusToCheckoutStatus,
   parseCheckoutInput,
@@ -64,12 +64,21 @@ const createTransactionCommand: CommandHandler<Record<string, unknown>, { id: st
       if (currentLink.status !== 'active') {
         throw new CrudHttpError(422, { error: 'This payment link is not currently accepting payments' })
       }
-      const reserved = await tx.getConnection().execute<Array<{ id: string }>>(
+      const transaction = tx.create(CheckoutTransaction, {
+        ...parsed,
+        organizationId: scope.organizationId,
+        tenantId: scope.tenantId,
+        amount: toMoneyString(parsed.amount) ?? '0.00',
+        status: 'processing',
+      })
+      tx.persist(transaction)
+      await tx.flush()
+      const reserved = await tx.execute<Array<{ active_reservation_count: number }>>(
         `
           UPDATE checkout_links
           SET active_reservation_count = active_reservation_count + 1,
               is_locked = true,
-              updated_at = now()
+              updated_at = clock_timestamp()
           WHERE id = ?
             AND organization_id = ?
             AND tenant_id = ?
@@ -79,27 +88,18 @@ const createTransactionCommand: CommandHandler<Record<string, unknown>, { id: st
               max_completions IS NULL
               OR completion_count + active_reservation_count < max_completions
             )
-          RETURNING id
+          RETURNING active_reservation_count
         `,
         [parsed.linkId, scope.organizationId, scope.tenantId],
       )
-      if (!reserved[0]?.id) {
+      if (!reserved[0]) {
         throw new CrudHttpError(422, { error: 'This payment link is no longer available' })
       }
       lockedLinkId = currentLink.id
       lockedLinkSlug = currentLink.slug
       lockedLinkTemplateId = currentLink.templateId ?? null
       lockedLinkGatewayProvider = currentLink.gatewayProviderKey ?? null
-      shouldEmitLockedEvent = !currentLink.isLocked
-      const transaction = tx.create(CheckoutTransaction, {
-        ...parsed,
-        organizationId: scope.organizationId,
-        tenantId: scope.tenantId,
-        amount: toMoneyString(parsed.amount) ?? '0.00',
-        status: 'processing',
-      })
-      tx.persist(transaction)
-      await tx.flush()
+      shouldEmitLockedEvent = Number(reserved[0].active_reservation_count) === 1
       return transaction
     })
     if (shouldEmitLockedEvent && lockedLinkId && lockedLinkSlug) {
@@ -227,9 +227,33 @@ const updateTransactionStatusCommand: CommandHandler<Record<string, unknown>, {
       // status actually changes — prevents double-notification on idempotent
       // redeliveries (e.g. authorized → captured, both mapping to 'completed').
       if (!previousTerminal && nextTerminal) {
-        const { usageLimitReached } = applyTerminalTransactionState(link, nextStatus)
-        await tx.flush()
-        if (usageLimitReached) {
+        const released = await tx.execute<Array<{ completion_count: number; max_completions: number | null }>>(
+          `
+            UPDATE checkout_links
+            SET active_reservation_count = GREATEST(active_reservation_count - 1, 0),
+                completion_count = completion_count + ?,
+                is_locked = GREATEST(active_reservation_count - 1, 0) > 0,
+                updated_at = clock_timestamp()
+            WHERE id = ?
+              AND organization_id = ?
+              AND tenant_id = ?
+              AND deleted_at IS NULL
+            RETURNING completion_count, max_completions
+          `,
+          [nextStatus === 'completed' ? 1 : 0, link.id, scope.organizationId, scope.tenantId],
+        )
+        if (!released[0]) {
+          const { translate } = await resolveTranslations()
+          throw new CrudHttpError(404, {
+            error: translate('checkout.errors.links.notFound', 'Payment link not found'),
+          })
+        }
+        const maxCompletions = released[0].max_completions
+        if (
+          nextStatus === 'completed'
+          && maxCompletions != null
+          && Number(released[0].completion_count) === Number(maxCompletions)
+        ) {
           emitUsageLimitReached = true
           usageLimitReachedLinkId = link.id
           usageLimitReachedLinkSlug = link.slug

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

@@ -152,6 +152,8 @@
   "checkout.defaultCustomerFields.lastName.placeholder": "Doe",
   "checkout.defaultCustomerFields.phone.label": "Phone",
   "checkout.defaultCustomerFields.phone.placeholder": "+1 555 123 4567",
+  "checkout.errors.links.lockedEdit": "Dieser Zahlungslink hat aktive Transaktionen und kann nicht bearbeitet werden",
+  "checkout.errors.links.notFound": "Zahlungslink nicht gefunden",
   "checkout.gatewaySettings.notices.chooseProvider": "Choose a gateway provider to configure checkout session settings.",
   "checkout.gatewaySettings.notices.noSettings": "This provider does not expose additional session settings.",
   "checkout.gatewaySettings.selectPlaceholder": "Select…",

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

@@ -152,6 +152,8 @@
   "checkout.defaultCustomerFields.lastName.placeholder": "Doe",
   "checkout.defaultCustomerFields.phone.label": "Phone",
   "checkout.defaultCustomerFields.phone.placeholder": "+1 555 123 4567",
+  "checkout.errors.links.lockedEdit": "This link has active transactions and cannot be edited",
+  "checkout.errors.links.notFound": "Payment link not found",
   "checkout.gatewaySettings.notices.chooseProvider": "Choose a gateway provider to configure checkout session settings.",
   "checkout.gatewaySettings.notices.noSettings": "This provider does not expose additional session settings.",
   "checkout.gatewaySettings.selectPlaceholder": "Select…",

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

@@ -152,6 +152,8 @@
   "checkout.defaultCustomerFields.lastName.placeholder": "Doe",
   "checkout.defaultCustomerFields.phone.label": "Phone",
   "checkout.defaultCustomerFields.phone.placeholder": "+1 555 123 4567",
+  "checkout.errors.links.lockedEdit": "Este enlace de pago tiene transacciones activas y no se puede editar",
+  "checkout.errors.links.notFound": "No se encontro el enlace de pago",
   "checkout.gatewaySettings.notices.chooseProvider": "Choose a gateway provider to configure checkout session settings.",
   "checkout.gatewaySettings.notices.noSettings": "This provider does not expose additional session settings.",
   "checkout.gatewaySettings.selectPlaceholder": "Select…",

package/src/modules/checkout/i18n/ko.json

@@ -152,6 +152,8 @@
   "checkout.defaultCustomerFields.lastName.placeholder": "Doe",
   "checkout.defaultCustomerFields.phone.label": "전화번호",
   "checkout.defaultCustomerFields.phone.placeholder": "+1 555 123 4567",
+  "checkout.errors.links.lockedEdit": "이 결제 링크에는 활성 거래가 있어 편집할 수 없습니다",
+  "checkout.errors.links.notFound": "결제 링크를 찾을 수 없습니다",
   "checkout.gatewaySettings.notices.chooseProvider": "체크아웃 세션 설정을 구성하려면 게이트웨이 제공업체를 선택하세요.",
   "checkout.gatewaySettings.notices.noSettings": "이 제공업체는 추가 세션 설정을 제공하지 않습니다.",
   "checkout.gatewaySettings.selectPlaceholder": "선택…",

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

@@ -152,6 +152,8 @@
   "checkout.defaultCustomerFields.lastName.placeholder": "Kowalski",
   "checkout.defaultCustomerFields.phone.label": "Telefon",
   "checkout.defaultCustomerFields.phone.placeholder": "+48 500 123 456",
+  "checkout.errors.links.lockedEdit": "Ten link płatności ma aktywne transakcje i nie można go edytować",
+  "checkout.errors.links.notFound": "Nie znaleziono linku płatności",
   "checkout.gatewaySettings.notices.chooseProvider": "Wybierz dostawcę bramki, aby skonfigurować ustawienia sesji checkout.",
   "checkout.gatewaySettings.notices.noSettings": "Ten dostawca nie udostępnia dodatkowych ustawień sesji.",
   "checkout.gatewaySettings.selectPlaceholder": "Wybierz…",