Payments

import { createClient } from '@01.software/sdk'

type Client = ReturnType<typeof createClient>

type Session = Awaited<
  ReturnType<Client['commerce']['paymentSessions']['retrievePortOne']>
>

export async function retryStandardAction(
  session: Session,
  requestPayment: (request: unknown) => Promise<unknown>,
) {
  if (
    session.presentationStatus === 'actionable' &&
    session.nextAction.type === 'portone_sdk'
  ) {
    const { cancelable, retryPolicy, ...paymentRequest } = session.nextAction
    if (!cancelable && retryPolicy === 'same_action_only') {
      // Adapter calls PortOne.requestPayment with this exact request.
      return requestPayment(paymentRequest)
    }
  }
  return null
}

import { createServerClient } from '@01.software/sdk/server'

type Server = ReturnType<typeof createServerClient>

export async function reconcilePayment(
  server: Server,
  selector: Parameters<Server['commerce']['paymentSessions']['findPortOne']>[0],
  idempotencyKey: string,
) {
  const local = await server.commerce.paymentSessions.findPortOne(selector)
  const reconciled = await server.commerce.paymentSessions.reconcilePortOne({
    ...selector,
    idempotencyKey,
  })
  return { local, reconciled }
}

import { createHmac } from 'node:crypto'
import { createServerClient } from '@01.software/sdk/server'

type Server = ReturnType<typeof createServerClient>
type Custom = Server['commerce']['paymentSessions']['custom']
type Session = Awaited<ReturnType<Custom['create']>>
type Confirmation = Awaited<ReturnType<Custom['confirm']>>
type Money = Session['money']

type Authority = {
  tenantId: string
  provider: string
  providerAccountId: string
  providerEnvironment: string
}

// Trusted app inputs, bound to the authorized app session/purchase, not a form.
export type CustomPurchase = Authority & {
  authorityId: string
  purchaseId: string
  checkoutId: string
  checkoutToken: string
  idempotencyKey: string
  providerPaymentId: string
  hmacRequired: boolean
}

export type VerifiedCapture = Authority & {
  providerSessionId: string
  providerPaymentId: string
  providerEventId: string
  money: Money
  occurredAt: string
}

type Retained = {
  session: Session | null
  capture: VerifiedCapture | null
  confirmation: Confirmation | null
}

// All three ports below are app-owned requirements, not SDK services.
export type CustomPaymentStore = {
  // Atomic unique claim by tenant + authority + purchase AND Checkout.
  // Persist the original key/body and payment mapping before returning.
  // An existing claim must match EVERY purchase field or throw; never replace.
  claim(purchase: CustomPurchase): Promise<void>
  read(purchase: CustomPurchase): Promise<Retained>
  // Atomic compare-and-set: retain once, accept exact replay, otherwise throw.
  // Retain only these typed fields, scoped to the original purchase claim.
  keepSession(purchase: CustomPurchase, session: Session): Promise<void>
  keepCapture(purchase: CustomPurchase, capture: VerifiedCapture): Promise<void>
  keepConfirmation(
    purchase: CustomPurchase,
    result: Confirmation,
  ): Promise<void>
}

export type CustomPaymentPorts = {
  store: CustomPaymentStore
  provider: {
    // Authenticate provider API/signed notification; verify tenant, provider,
    // account, environment, session/payment/event identity and captured Money.
    // Observe only the retained payment; this port must never create/charge it.
    verifyCapture(
      expected: Authority & {
        providerSessionId: string
        providerPaymentId: string
        money: Money
      },
    ): Promise<
      | { kind: 'captured'; capture: VerifiedCapture }
      | { kind: 'unknown' | 'failed' | 'rejected' }
    >
  }
  secrets: {
    // Separately provisioned app access to the SAME secret Console resolves.
    // This is neither SDK secret retrieval nor automatic platform sharing.
    readCustomPaymentSecret(authority: Authority): Promise<string>
  }
}

function sameMoney(left: Money, right: Money) {
  return (
    left.amountMinor === right.amountMinor && left.currency === right.currency
  )
}

function captureFor(
  purchase: CustomPurchase,
  session: Session,
  value: VerifiedCapture,
): VerifiedCapture {
  if (
    value.tenantId !== purchase.tenantId ||
    value.provider !== purchase.provider ||
    value.providerAccountId !== purchase.providerAccountId ||
    value.providerEnvironment !== purchase.providerEnvironment ||
    value.providerSessionId !== session.providerSessionId ||
    value.providerPaymentId !== purchase.providerPaymentId ||
    !value.providerEventId.trim() ||
    !Number.isFinite(Date.parse(value.occurredAt)) ||
    !sameMoney(value.money, session.money)
  )
    throw new Error(
      'Captured identity or Money mismatch; retain and investigate',
    )
  // Allowlist: never persist or forward a structurally assignable PSP object.
  return {
    tenantId: value.tenantId,
    provider: value.provider,
    providerAccountId: value.providerAccountId,
    providerEnvironment: value.providerEnvironment,
    providerSessionId: value.providerSessionId,
    providerPaymentId: value.providerPaymentId,
    providerEventId: value.providerEventId,
    money: {
      amountMinor: value.money.amountMinor,
      currency: value.money.currency,
    },
    occurredAt: value.occurredAt,
  }
}

export async function recoverCustomPayment(
  server: Server,
  providerSessionId: string,
  provider = 'portone',
) {
  const recovered = await server.commerce.paymentSessions.custom.retrieve({
    provider,
    by: { providerSessionId },
  })
  if (recovered.finalizationStatus === 'committed') {
    return { kind: 'committed' as const, orderId: recovered.orderId }
  }
  return { kind: 'pending' as const, recovered }
}

export async function completeCustomPayment(
  server: Server,
  purchase: CustomPurchase,
  ports: CustomPaymentPorts,
) {
  const { store } = ports
  await store.claim(purchase)
  const retained = await store.read(purchase)
  let savedSession = retained.session
  if (!savedSession) {
    const created = await server.commerce.paymentSessions.custom.create({
      provider: purchase.provider,
      checkoutToken: purchase.checkoutToken,
      idempotencyKey: purchase.idempotencyKey,
    })
    savedSession = {
      id: created.id,
      provider: created.provider,
      providerSessionId: created.providerSessionId,
      money: {
        amountMinor: created.money.amountMinor,
        currency: created.money.currency,
      },
    }
    await store.keepSession(purchase, savedSession)
  }
  const session = savedSession
  if (session.provider !== purchase.provider)
    throw new Error('Provider mismatch')
  const authority: Authority = {
    tenantId: purchase.tenantId,
    provider: purchase.provider,
    providerAccountId: purchase.providerAccountId,
    providerEnvironment: purchase.providerEnvironment,
  }
  const retrieve = async () => {
    const observed = await server.commerce.paymentSessions.custom.retrieve({
      provider: session.provider,
      by: { providerSessionId: session.providerSessionId },
    })
    if (
      observed.id !== session.id ||
      observed.provider !== session.provider ||
      observed.providerSessionId !== session.providerSessionId ||
      (observed.providerPaymentId !== null &&
        observed.providerPaymentId !== purchase.providerPaymentId) ||
      !sameMoney(observed.money, session.money)
    )
      throw new Error('Recovery identity or Money mismatch')
    return observed
  }
  await retrieve() // Observation only; never infers a capture.
  let capture = retained.capture
  if (!capture) {
    const verified = await ports.provider.verifyCapture({
      ...authority,
      providerSessionId: session.providerSessionId,
      providerPaymentId: purchase.providerPaymentId,
      money: {
        amountMinor: session.money.amountMinor,
        currency: session.money.currency,
      },
    })
    if (verified.kind !== 'captured') {
      return { kind: 'needs_attention' as const, observation: verified.kind }
    }
    capture = captureFor(purchase, session, verified.capture)
    await store.keepCapture(purchase, capture)
  }
  capture = captureFor(purchase, session, capture)
  let confirmation = retained.confirmation
  if (!confirmation) {
    // No confirm idempotency-key option. Replay the SAME retained capture.
    const secret = purchase.hmacRequired
      ? await ports.secrets.readCustomPaymentSecret(authority)
      : null
    if (purchase.hmacRequired && !secret?.trim())
      throw new Error('Missing app secret')
    const result = await server.commerce.paymentSessions.custom.confirm(
      {
        provider: capture.provider,
        providerSessionId: capture.providerSessionId,
        providerPaymentId: capture.providerPaymentId,
        providerEventId: capture.providerEventId,
        amount: capture.money.amountMinor,
        currency: capture.money.currency,
        occurredAt: capture.occurredAt,
      },
      secret === null
        ? {}
        : {
            createProof(rawBody) {
              const timestamp = new Date().toISOString()
              return {
                timestamp,
                signature: createHmac('sha256', secret)
                  .update(`${timestamp}.${rawBody}`, 'utf8')
                  .digest('hex'),
              }
            },
          },
    )
    confirmation = {
      orderId: result.orderId,
      transactionId: result.transactionId,
      status: result.status,
    }
    await store.keepConfirmation(purchase, confirmation)
  }
  const settled = await retrieve()
  if (
    settled.providerStatus !== 'captured' ||
    settled.finalizationStatus !== 'committed' ||
    settled.providerPaymentId !== capture.providerPaymentId ||
    !settled.orderId
  )
    return {
      kind: 'needs_attention' as const,
      observation: 'local_finalization',
    }
  const checkout = await server.commerce.checkouts.retrieve({
    checkoutId: purchase.checkoutId,
  })
  if (
    checkout.id !== purchase.checkoutId ||
    checkout.status !== 'placed' ||
    checkout.order.id !== confirmation.orderId ||
    settled.orderId !== confirmation.orderId
  )
    throw new Error('Original Checkout/order mismatch; retain and investigate')
  return { kind: 'committed' as const, orderId: confirmation.orderId }
}