@open-mercato/onboarding 0.6.5-develop.5337.1.534b781eac → 0.6.5

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

@@ -77,7 +77,10 @@
   "onboarding.preparing.descriptionWithTenant": "Estamos terminando de preparar el entorno de demostración para {tenant}. Le enviaremos un correo con el enlace correcto de acceso al tenant en cuanto esté listo.",
   "onboarding.preparing.emailNotice": "No necesita mantener esta página abierta. Le enviaremos un correo cuando todo esté listo.",
   "onboarding.preparing.homeCta": "Ir a la página principal",
+  "onboarding.preparing.loginCta": "Abrir acceso al tenant",
   "onboarding.preparing.redirecting": "Su espacio de trabajo ya está listo. Ahora le redirigimos a la página de acceso del tenant.",
+  "onboarding.preparing.statusErrorBody": "No pudimos comprobar el estado del espacio de trabajo. Es posible que aún se esté preparando; esta página seguirá intentándolo.",
+  "onboarding.preparing.statusErrorTitle": "Falló la comprobación de estado",
   "onboarding.preparing.title": "Estamos preparando su espacio de trabajo",
   "onboarding.readyEmail.body": "Su espacio de trabajo de Open Mercato para {organizationName} ya está listo. Use el enlace seguro de abajo para iniciar sesión.",
   "onboarding.readyEmail.cta": "Abrir acceso",
@@ -87,5 +90,11 @@
   "onboarding.readyEmail.preview": "Su espacio de trabajo está listo. Use su enlace seguro de acceso para iniciar sesión.",
   "onboarding.readyEmail.subject": "Su espacio de trabajo de Open Mercato está listo",
   "onboarding.subtitle": "Cuéntenos un poco sobre usted y configuraremos todo.",
-  "onboarding.title": "Cree su espacio de trabajo en Open Mercato"
+  "onboarding.title": "Cree su espacio de trabajo en Open Mercato",
+  "onboarding.verifyStatus.alreadyExists": "Ya tenemos una cuenta con este correo electrónico. Intente iniciar sesión o restablecer su contraseña.",
+  "onboarding.verifyStatus.error": "No pudimos completar la verificación. Intente de nuevo o comuníquese con soporte.",
+  "onboarding.verifyStatus.invalid": "El enlace de verificación no es válido o caducó. Envíe de nuevo el formulario de onboarding para recibir un enlace nuevo.",
+  "onboarding.verifyStatus.originNotAllowed": "El enlace de verificación se abrió desde un origen no permitido. Revise APP_URL y APP_ALLOWED_ORIGINS y abra el enlace de nuevo.",
+  "onboarding.verifyStatus.redirectMisconfigured": "El enlace de verificación no puede redirigir de forma segura porque APP_URL no coincide con la URL que procesó la solicitud. Revise APP_URL y APP_ALLOWED_ORIGINS y abra el enlace de nuevo.",
+  "onboarding.verifyStatus.urlNotConfigured": "La verificación de onboarding no está configurada. APP_URL debe estar definido antes de usar enlaces de verificación."
 }

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

@@ -77,7 +77,10 @@
   "onboarding.preparing.descriptionWithTenant": "Kończymy przygotowywać środowisko demo dla {tenant}. Gdy będzie gotowe, wyślemy Ci e-mail z poprawnym linkiem logowania do tenanta.",
   "onboarding.preparing.emailNotice": "Nie musisz zostawiać tej strony otwartej. Gdy wszystko będzie gotowe, wyślemy Ci e-mail.",
   "onboarding.preparing.homeCta": "Przejdź na stronę główną",
+  "onboarding.preparing.loginCta": "Otwórz logowanie do tenanta",
   "onboarding.preparing.redirecting": "Twój obszar roboczy jest gotowy. Przekierowujemy Cię teraz do strony logowania tenanta.",
+  "onboarding.preparing.statusErrorBody": "Nie udało się sprawdzić statusu obszaru roboczego. Obszar może nadal się przygotowywać; ta strona będzie ponawiać próbę.",
+  "onboarding.preparing.statusErrorTitle": "Nie udało się sprawdzić statusu obszaru",
   "onboarding.preparing.title": "Przygotowujemy Twój obszar roboczy",
   "onboarding.readyEmail.body": "Twój obszar roboczy Open Mercato dla {organizationName} jest już gotowy. Użyj bezpiecznego linku poniżej, aby się zalogować.",
   "onboarding.readyEmail.cta": "Otwórz logowanie",
@@ -87,5 +90,11 @@
   "onboarding.readyEmail.preview": "Twój obszar roboczy jest gotowy. Użyj bezpiecznego linku logowania, aby się zalogować.",
   "onboarding.readyEmail.subject": "Twój obszar roboczy Open Mercato jest gotowy",
   "onboarding.subtitle": "Opowiedz nam trochę o sobie, a my wszystko skonfigurujemy.",
-  "onboarding.title": "Utwórz swój obszar roboczy Open Mercato"
+  "onboarding.title": "Utwórz swój obszar roboczy Open Mercato",
+  "onboarding.verifyStatus.alreadyExists": "Mamy już konto z tym adresem email. Spróbuj się zalogować lub zresetować hasło.",
+  "onboarding.verifyStatus.error": "Nie udało się zakończyć weryfikacji. Spróbuj ponownie lub skontaktuj się z pomocą techniczną.",
+  "onboarding.verifyStatus.invalid": "Link weryfikacyjny jest nieprawidłowy albo wygasł. Wyślij formularz onboardingu ponownie, aby otrzymać nowy link.",
+  "onboarding.verifyStatus.originNotAllowed": "Link weryfikacyjny otwarto z niedozwolonego originu. Sprawdź APP_URL i APP_ALLOWED_ORIGINS, a potem otwórz link ponownie.",
+  "onboarding.verifyStatus.redirectMisconfigured": "Link weryfikacyjny nie może bezpiecznie przekierować, bo APP_URL nie zgadza się z URL-em, który obsłużył request. Sprawdź APP_URL i APP_ALLOWED_ORIGINS, a potem otwórz link ponownie.",
+  "onboarding.verifyStatus.urlNotConfigured": "Weryfikacja onboardingu nie jest skonfigurowana. APP_URL musi być ustawiony, zanim linki weryfikacyjne będą działać."
 }

package/src/modules/onboarding/lib/deferred-provisioning.ts

@@ -0,0 +1,295 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { SearchIndexer } from '@open-mercato/search'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { flattenSystemEntityIds } from '@open-mercato/shared/lib/entities/system-entities'
+import { getEntityIds } from '@open-mercato/shared/lib/encryption/entityIds'
+import { getModules } from '@open-mercato/shared/lib/modules/registry'
+import type { OnboardingRequest } from '@open-mercato/onboarding/modules/onboarding/data/entities'
+import { OnboardingService } from '@open-mercato/onboarding/modules/onboarding/lib/service'
+import { sendWorkspaceReadyEmail } from '@open-mercato/onboarding/modules/onboarding/lib/ready-email'
+import { reindexEntity } from '@open-mercato/core/modules/query_index/lib/reindexer'
+import { purgeIndexScope } from '@open-mercato/core/modules/query_index/lib/purge'
+import { refreshCoverageSnapshot } from '@open-mercato/core/modules/query_index/lib/coverage'
+import { isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
+import { PREPARATION_CLAIM_STALE_MS } from '@open-mercato/onboarding/modules/onboarding/lib/preparation-claim'
+
+const VECTOR_REINDEX_ENQUEUE_TIMEOUT_MS = 5_000
+const SEED_EXAMPLES_TIMEOUT_MS = 15_000
+
+export function resolveProvisioningIds(request: OnboardingRequest) {
+  if (!request.tenantId || !request.organizationId || !request.userId) return null
+  return {
+    tenantId: request.tenantId,
+    organizationId: request.organizationId,
+    userId: request.userId,
+  }
+}
+
+function createTimeoutPromise(label: string, timeoutMs: number): Promise<never> {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
+  })
+}
+
+async function runModuleSetupHook(args: {
+  moduleId: string
+  phase: 'seedExamples'
+  timeoutMs: number
+  run: () => Promise<void>
+}) {
+  const startedAt = Date.now()
+  console.info('[onboarding.verify] module hook started', {
+    moduleId: args.moduleId,
+    phase: args.phase,
+    timeoutMs: args.timeoutMs,
+  })
+  try {
+    await Promise.race([
+      args.run(),
+      createTimeoutPromise(`module ${args.moduleId} ${args.phase}`, args.timeoutMs),
+    ])
+    console.info('[onboarding.verify] module hook completed', {
+      moduleId: args.moduleId,
+      phase: args.phase,
+      durationMs: Math.max(0, Date.now() - startedAt),
+    })
+  } catch (error) {
+    if (isUniqueViolation(error)) {
+      // Deferred provisioning is re-triggered on every preparing-page status
+      // poll until preparationCompletedAt is set. seedExamples is not fully
+      // idempotent (e.g. catalog product handles are unique-scoped), so a
+      // re-run that lands before completion collides on an already-seeded row.
+      // The workspace is already provisioned and the collision is expected and
+      // harmless — log at info so genuine failures still stand out.
+      console.info('[onboarding.verify] module hook skipped (already seeded)', {
+        moduleId: args.moduleId,
+        phase: args.phase,
+        durationMs: Math.max(0, Date.now() - startedAt),
+      })
+    } else {
+      console.error('[onboarding.verify] module hook failed', {
+        moduleId: args.moduleId,
+        phase: args.phase,
+        durationMs: Math.max(0, Date.now() - startedAt),
+        timeoutMs: args.timeoutMs,
+        error,
+      })
+    }
+    throw error
+  }
+}
+
+async function markWorkspaceReady(args: {
+  requestId: string
+  service: OnboardingService
+}) {
+  const request = await args.service.findById(args.requestId)
+  // The status guard protects a request that was re-submitted (and reset to
+  // pending) while this chain was still running — completing it would let the
+  // new flow skip its own deferred provisioning.
+  if (!request || request.preparationCompletedAt || request.status !== 'completed') return
+  await args.service.markPreparationCompleted(request, new Date())
+}
+
+async function enqueueVectorReindex(args: {
+  container: { resolve: <T = unknown>(name: string) => T }
+  tenantId: string
+  organizationId: string
+}) {
+  let searchIndexer: SearchIndexer | null = null
+  try {
+    searchIndexer = args.container.resolve<SearchIndexer>('searchIndexer')
+  } catch {
+    searchIndexer = null
+  }
+  if (!searchIndexer) return
+
+  await Promise.race([
+    searchIndexer.reindexAllToVector({
+      tenantId: args.tenantId,
+      organizationId: args.organizationId,
+      purgeFirst: true,
+      useQueue: true,
+    }),
+    createTimeoutPromise('vector reindex enqueue', VECTOR_REINDEX_ENQUEUE_TIMEOUT_MS),
+  ])
+}
+
+async function rebuildTenantQueryIndexes(args: {
+  em: EntityManager
+  tenantId: string
+  organizationId: string
+}) {
+  const coverageRefreshKeys = new Set<string>()
+  try {
+    const allEntities = getEntityIds()
+    const entityIds = flattenSystemEntityIds(allEntities)
+    for (const entityType of entityIds) {
+      try {
+        await purgeIndexScope(args.em, { entityType, tenantId: args.tenantId })
+      } catch (error) {
+        console.error('[onboarding.verify] failed to purge query index scope', {
+          entityType,
+          tenantId: args.tenantId,
+          error,
+        })
+      }
+      try {
+        await reindexEntity(args.em, {
+          entityType,
+          tenantId: args.tenantId,
+          force: true,
+          emitVectorizeEvents: false,
+          vectorService: null,
+        })
+      } catch (error) {
+        console.error('[onboarding.verify] failed to reindex entity', {
+          entityType,
+          tenantId: args.tenantId,
+          error,
+        })
+      }
+      coverageRefreshKeys.add(`${entityType}|${args.tenantId}|__null__`)
+      coverageRefreshKeys.add(`${entityType}|${args.tenantId}|${args.organizationId}`)
+    }
+  } catch (error) {
+    console.error('[onboarding.verify] failed to rebuild query indexes', { tenantId: args.tenantId, error })
+  }
+
+  if (!coverageRefreshKeys.size) return
+
+  for (const entry of coverageRefreshKeys) {
+    const [entityType, tenantKey, orgKey] = entry.split('|')
+    const orgScope = orgKey === '__null__' ? null : orgKey
+    try {
+      await refreshCoverageSnapshot(
+        args.em,
+        {
+          entityType,
+          tenantId: tenantKey,
+          organizationId: orgScope,
+          withDeleted: false,
+        },
+      )
+    } catch (error) {
+      console.error('[onboarding.verify] failed to refresh coverage snapshot', {
+        entityType,
+        tenantId: tenantKey,
+        organizationId: orgScope,
+        error,
+      })
+    }
+  }
+}
+
+export async function runDeferredProvisioning(args: {
+  requestId: string
+  tenantId: string
+  organizationId: string
+}) {
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as EntityManager
+  const service = new OnboardingService(em)
+
+  // Single-flight guard: the preparing page polls the status endpoint every
+  // second and each poll (plus the verify handler) schedules this chain. The
+  // atomic claim collapses those triggers into one run per request — without
+  // it, dozens of concurrent seed + full-reindex chains exhaust the PG
+  // connection pool (2026-06-11 demo outage). A stale claim (crashed runner)
+  // becomes reclaimable after PREPARATION_CLAIM_STALE_MS.
+  const claimedAt = new Date()
+  const claimed = await service.claimPreparation(
+    args.requestId,
+    claimedAt,
+    new Date(claimedAt.getTime() - PREPARATION_CLAIM_STALE_MS),
+  )
+  if (!claimed) {
+    console.info('[onboarding.verify] deferred provisioning skipped (already claimed or completed)', {
+      requestId: args.requestId,
+      tenantId: args.tenantId,
+    })
+    return
+  }
+
+  const modules = getModules()
+
+  for (const mod of modules) {
+    if (!mod.setup?.seedExamples) continue
+    // Heartbeat: keep the lease fresh while legitimately working so a slow run
+    // (many modules × 15s seed timeout + rebuild) can never look stale and get
+    // double-claimed by a later poll.
+    await service.renewPreparation(args.requestId, new Date()).catch(() => {})
+    try {
+      await runModuleSetupHook({
+        moduleId: mod.id,
+        phase: 'seedExamples',
+        timeoutMs: SEED_EXAMPLES_TIMEOUT_MS,
+        run: () => mod.setup!.seedExamples!({
+          em,
+          tenantId: args.tenantId,
+          organizationId: args.organizationId,
+          container,
+        }),
+      })
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        console.info('[onboarding.verify] deferred seedExamples skipped (already applied)', {
+          moduleId: mod.id,
+          tenantId: args.tenantId,
+          organizationId: args.organizationId,
+        })
+      } else {
+        console.error('[onboarding.verify] deferred seedExamples failed', {
+          moduleId: mod.id,
+          tenantId: args.tenantId,
+          organizationId: args.organizationId,
+          error,
+        })
+      }
+    }
+  }
+
+  // The rebuild runs BEFORE the completion flag: preparationCompletedAt is the
+  // terminal gate for both the status-route scheduling and claimPreparation,
+  // so a runner that dies mid-rebuild must leave the flag unset — the stale
+  // claim then makes the whole chain reclaimable and the rebuild self-heals.
+  // rebuildTenantQueryIndexes never throws (it logs per-entity failures).
+  await service.renewPreparation(args.requestId, new Date()).catch(() => {})
+  await rebuildTenantQueryIndexes({
+    em,
+    tenantId: args.tenantId,
+    organizationId: args.organizationId,
+  })
+
+  await markWorkspaceReady({
+    requestId: args.requestId,
+    service,
+  })
+
+  // Non-fatal (#2954 contract): an email failure must not abort the chain.
+  // The status endpoint retries the ready email on later polls while
+  // readyEmailSentAt is unset.
+  await sendWorkspaceReadyEmail({
+    requestId: args.requestId,
+    tenantId: args.tenantId,
+  }).catch((error) => {
+    console.error('[onboarding.verify] ready email failed', {
+      requestId: args.requestId,
+      tenantId: args.tenantId,
+      organizationId: args.organizationId,
+      error,
+    })
+  })
+
+  await enqueueVectorReindex({
+    container,
+    tenantId: args.tenantId,
+    organizationId: args.organizationId,
+  }).catch((error) => {
+    console.warn('[onboarding.verify] vector reindex enqueue did not complete promptly', {
+      tenantId: args.tenantId,
+      organizationId: args.organizationId,
+      reason: error instanceof Error ? error.message : String(error),
+    })
+  })
+}

package/src/modules/onboarding/lib/preparation-claim.ts

@@ -0,0 +1,6 @@
+export const PREPARATION_CLAIM_STALE_MS = 10 * 60 * 1000
+
+export function isPreparationClaimActive(startedAt: Date | null | undefined, now: Date = new Date()): boolean {
+  if (!startedAt) return false
+  return startedAt.getTime() > now.getTime() - PREPARATION_CLAIM_STALE_MS
+}

package/src/modules/onboarding/lib/provisioning.ts

@@ -0,0 +1,35 @@
+import { isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
+
+export type BestEffortProvisioningResult = { ok: true } | { ok: false; error: unknown }
+
+type BestEffortLogger = Pick<Console, 'error' | 'info'>
+
+/**
+ * Runs a non-essential provisioning step without letting its failure abort
+ * onboarding. The tenant/org/primary user are created before these steps, so a
+ * throw or timeout here (reference-data seeding, marketing-consent recording)
+ * must NOT strand a freshly provisioned workspace — the verify handler still has
+ * to reach markCompleted so the user can sign in. Failures are logged for
+ * follow-up and reported back to the caller, never re-thrown.
+ */
+export async function runBestEffortProvisioningStep(
+  step: string,
+  run: () => Promise<void>,
+  logger: BestEffortLogger = console,
+): Promise<BestEffortProvisioningResult> {
+  try {
+    await run()
+    return { ok: true }
+  } catch (error) {
+    if (isUniqueViolation(error)) {
+      // Expected when a concurrent verify / re-verify re-applies a step against
+      // rows that already exist (seed hooks are not fully idempotent). The
+      // workspace is already provisioned, so the collision is harmless — log at
+      // info to keep genuine non-fatal failures visible.
+      logger.info('[onboarding.verify] non-fatal provisioning step skipped (already applied)', { step })
+      return { ok: false, error }
+    }
+    logger.error('[onboarding.verify] non-fatal provisioning step failed', { step, error })
+    return { ok: false, error }
+  }
+}

package/src/modules/onboarding/lib/service.ts

@@ -43,6 +43,7 @@ export class OnboardingService {
       existing.organizationId = null
       existing.userId = null
       existing.lastEmailSentAt = now
+      existing.preparationStartedAt = null
       existing.preparationCompletedAt = null
       existing.readyEmailSentAt = null
       await this.em.flush()
@@ -144,8 +145,40 @@ export class OnboardingService {
     await this.em.flush()
   }
 
+  async claimPreparation(requestId: string, claimedAt: Date, staleBefore: Date): Promise<boolean> {
+    const claimedRows = await this.em.nativeUpdate(
+      OnboardingRequest,
+      {
+        id: requestId,
+        status: 'completed',
+        preparationCompletedAt: null,
+        $or: [
+          { preparationStartedAt: null },
+          { preparationStartedAt: { $lt: staleBefore } },
+        ],
+      },
+      { preparationStartedAt: claimedAt, updatedAt: new Date() },
+    )
+    return claimedRows > 0
+  }
+
+  async renewPreparation(requestId: string, renewedAt: Date): Promise<boolean> {
+    const renewedRows = await this.em.nativeUpdate(
+      OnboardingRequest,
+      {
+        id: requestId,
+        status: 'completed',
+        preparationCompletedAt: null,
+        preparationStartedAt: { $ne: null },
+      },
+      { preparationStartedAt: renewedAt, updatedAt: new Date() },
+    )
+    return renewedRows > 0
+  }
+
   async markPreparationCompleted(request: OnboardingRequest, completedAt: Date) {
     request.preparationCompletedAt = completedAt
+    request.preparationStartedAt = null
     await this.em.flush()
   }
 }

package/src/modules/onboarding/lib/verify-base-url.ts

@@ -0,0 +1,107 @@
+import {
+  AppOriginConfigurationError,
+  AppOriginRejectedError,
+  getSecurityEmailBaseUrl,
+  resolveRequestOrigin,
+} from '@open-mercato/shared/lib/url'
+
+type EnvLike = Record<string, string | undefined>
+
+export type VerifyRedirectBaseUrlResult =
+  | { ok: true; baseUrl: string }
+  | {
+    ok: false
+    status: 'origin_not_allowed' | 'redirect_misconfigured' | 'url_not_configured'
+    message: string
+    redirectOrigin: string | null
+    httpStatus: number
+  }
+
+function normalizeOrigin(raw: string): string | null {
+  try {
+    return new URL(raw).origin
+  } catch {
+    return null
+  }
+}
+
+function originPort(url: URL): string {
+  if (url.port) return url.port
+  if (url.protocol === 'https:') return '443'
+  if (url.protocol === 'http:') return '80'
+  return ''
+}
+
+function isLoopbackHostname(hostname: string): boolean {
+  return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1'
+}
+
+function originsMatchForRedirect(configuredOrigin: string, requestOrigin: string): boolean {
+  if (configuredOrigin === requestOrigin) return true
+  try {
+    const configured = new URL(configuredOrigin)
+    const request = new URL(requestOrigin)
+    return (
+      configured.protocol === request.protocol &&
+      isLoopbackHostname(configured.hostname) &&
+      isLoopbackHostname(request.hostname) &&
+      originPort(configured) === originPort(request)
+    )
+  } catch {
+    return false
+  }
+}
+
+export function resolveVerifyRedirectBaseUrl(
+  req: Request,
+  env: EnvLike = process.env,
+): VerifyRedirectBaseUrlResult {
+  try {
+    const baseUrl = getSecurityEmailBaseUrl(req, env)
+    const configuredOrigin = normalizeOrigin(baseUrl)
+    const requestOrigin = normalizeOrigin(resolveRequestOrigin(req)) ?? normalizeOrigin(req.url)
+    if (configuredOrigin && requestOrigin && !originsMatchForRedirect(configuredOrigin, requestOrigin)) {
+      console.error('[onboarding.verify] APP_URL does not match verification request origin', {
+        requestUrl: req.url,
+        configuredOrigin,
+        requestOrigin,
+      })
+      return {
+        ok: false,
+        status: 'redirect_misconfigured',
+        message: 'Onboarding verification redirect is misconfigured.',
+        redirectOrigin: requestOrigin,
+        httpStatus: 400,
+      }
+    }
+    return { ok: true, baseUrl }
+  } catch (error) {
+    if (error instanceof AppOriginRejectedError) {
+      console.error('[onboarding.verify] rejected request origin for redirect base', {
+        requestUrl: req.url,
+        reason: error.message,
+      })
+      return {
+        ok: false,
+        status: 'origin_not_allowed',
+        message: 'Onboarding verification request origin is not allowed.',
+        redirectOrigin: null,
+        httpStatus: 400,
+      }
+    }
+    if (error instanceof AppOriginConfigurationError) {
+      console.error('[onboarding.verify] APP_URL is required for onboarding verification redirects', {
+        requestUrl: req.url,
+        reason: error.message,
+      })
+      return {
+        ok: false,
+        status: 'url_not_configured',
+        message: 'Onboarding verification redirect is not configured.',
+        redirectOrigin: null,
+        httpStatus: 500,
+      }
+    }
+    throw error
+  }
+}

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

@@ -176,6 +176,16 @@
           "length": 6,
           "mappedType": "datetime"
         },
+        "preparation_started_at": {
+          "name": "preparation_started_at",
+          "type": "timestamptz",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "length": 6,
+          "mappedType": "datetime"
+        },
         "preparation_completed_at": {
           "name": "preparation_completed_at",
           "type": "timestamptz",

package/src/modules/onboarding/migrations/Migration20260611120000.ts

@@ -0,0 +1,13 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260611120000 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table "onboarding_requests" add column "preparation_started_at" timestamptz null;`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table "onboarding_requests" drop column "preparation_started_at";`);
+  }
+
+}