@open-mercato/core 0.4.5-develop-0f0e676c72 → 0.4.5-develop-e694581d9f

package/src/modules/translations/api/[entityType]/[entityId]/route.ts

@@ -3,6 +3,8 @@ import { z } from 'zod'
 import { resolveTranslationsRouteContext } from '@open-mercato/core/modules/translations/api/context'
 import { translationBodySchema, entityTypeParamSchema, entityIdParamSchema } from '@open-mercato/core/modules/translations/data/validators'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { CommandBus } from '@open-mercato/shared/lib/commands'
+import { serializeOperationMetadata } from '@open-mercato/shared/lib/commands/operationMetadata'
 import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
 
 const paramsSchema = z.object({
@@ -67,64 +69,53 @@ export async function PUT(req: Request, ctx: { params?: { entityType?: string; e
     const rawBody = await req.json().catch(() => ({}))
     const translations = translationBodySchema.parse(rawBody)
 
-    const existing = await context.knex('entity_translations')
-      .where({
-        entity_type: entityType,
-        entity_id: entityId,
-      })
-      .andWhereRaw('tenant_id is not distinct from ?', [context.tenantId])
-      .andWhereRaw('organization_id is not distinct from ?', [context.organizationId])
-      .first()
-
-    const now = context.knex.fn.now()
-
-    if (existing) {
-      await context.knex('entity_translations')
-        .where({ id: existing.id })
-        .update({
-          translations,
-          updated_at: now,
-        })
-    } else {
-      await context.knex('entity_translations').insert({
-        entity_type: entityType,
-        entity_id: entityId,
-        organization_id: context.organizationId,
-        tenant_id: context.tenantId,
-        translations,
-        created_at: now,
-        updated_at: now,
-      })
-    }
-
-    try {
-      const bus = context.container.resolve<{ emitEvent: (event: string, payload: unknown) => Promise<void> }>('eventBus')
-      await bus.emitEvent('translations.translation.updated', {
+    const commandBus = context.container.resolve('commandBus') as CommandBus
+    const { result, logEntry } = await commandBus.execute<
+      { entityType: string; entityId: string; translations: typeof translations; organizationId: string | null; tenantId: string },
+      { rowId: string }
+    >('translations.translation.save', {
+      input: {
         entityType,
         entityId,
+        translations,
         organizationId: context.organizationId,
         tenantId: context.tenantId,
-      })
-    } catch (err) {
-      console.warn('[translations] Failed to emit translations.translation.updated:', err instanceof Error ? err.message : 'unknown')
-    }
+      },
+      ctx: context.commandCtx,
+    })
 
     const row = await context.knex('entity_translations')
-      .where({
-        entity_type: entityType,
-        entity_id: entityId,
-      })
-      .andWhereRaw('tenant_id is not distinct from ?', [context.tenantId])
-      .andWhereRaw('organization_id is not distinct from ?', [context.organizationId])
+      .where({ id: result.rowId })
       .first()
 
-    return NextResponse.json({
+    const response = NextResponse.json({
       entityType: row.entity_type,
       entityId: row.entity_id,
       translations: row.translations,
       createdAt: row.created_at,
       updatedAt: row.updated_at,
     })
+
+    if (logEntry?.undoToken && logEntry?.id && logEntry?.commandId) {
+      response.headers.set(
+        'x-om-operation',
+        serializeOperationMetadata({
+          id: logEntry.id,
+          undoToken: logEntry.undoToken,
+          commandId: logEntry.commandId,
+          actionLabel: logEntry.actionLabel ?? null,
+          resourceKind: logEntry.resourceKind ?? 'translations.translation',
+          resourceId: logEntry.resourceId ?? result.rowId,
+          executedAt: logEntry.createdAt instanceof Date
+            ? logEntry.createdAt.toISOString()
+            : typeof logEntry.createdAt === 'string'
+              ? logEntry.createdAt
+              : new Date().toISOString(),
+        }),
+      )
+    }
+
+    return response
   } catch (err) {
     if (err instanceof CrudHttpError) {
       return NextResponse.json(err.body, { status: err.status })
@@ -145,28 +136,42 @@ export async function DELETE(req: Request, ctx: { params?: { entityType?: string
       entityId: ctx.params?.entityId,
     })
 
-    await context.knex('entity_translations')
-      .where({
-        entity_type: entityType,
-        entity_id: entityId,
-      })
-      .andWhereRaw('tenant_id is not distinct from ?', [context.tenantId])
-      .andWhereRaw('organization_id is not distinct from ?', [context.organizationId])
-      .del()
-
-    try {
-      const bus = context.container.resolve<{ emitEvent: (event: string, payload: unknown) => Promise<void> }>('eventBus')
-      await bus.emitEvent('translations.translation.deleted', {
+    const commandBus = context.container.resolve('commandBus') as CommandBus
+    const { logEntry } = await commandBus.execute<
+      { entityType: string; entityId: string; organizationId: string | null; tenantId: string },
+      { deleted: boolean }
+    >('translations.translation.delete', {
+      input: {
         entityType,
         entityId,
         organizationId: context.organizationId,
         tenantId: context.tenantId,
-      })
-    } catch (err) {
-      console.warn('[translations] Failed to emit translations.translation.deleted:', err instanceof Error ? err.message : 'unknown')
+      },
+      ctx: context.commandCtx,
+    })
+
+    const response = new NextResponse(null, { status: 204 })
+
+    if (logEntry?.undoToken && logEntry?.id && logEntry?.commandId) {
+      response.headers.set(
+        'x-om-operation',
+        serializeOperationMetadata({
+          id: logEntry.id,
+          undoToken: logEntry.undoToken,
+          commandId: logEntry.commandId,
+          actionLabel: logEntry.actionLabel ?? null,
+          resourceKind: logEntry.resourceKind ?? 'translations.translation',
+          resourceId: logEntry.resourceId ?? null,
+          executedAt: logEntry.createdAt instanceof Date
+            ? logEntry.createdAt.toISOString()
+            : typeof logEntry.createdAt === 'string'
+              ? logEntry.createdAt
+              : new Date().toISOString(),
+        }),
+      )
     }
 
-    return new NextResponse(null, { status: 204 })
+    return response
   } catch (err) {
     if (err instanceof CrudHttpError) {
       return NextResponse.json(err.body, { status: err.status })

package/src/modules/translations/api/context.ts

@@ -2,6 +2,7 @@ import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import type { CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import type { AwilixContainer } from 'awilix'
 import type { Knex } from 'knex'
@@ -13,6 +14,7 @@ export type TranslationsRouteContext = {
   knex: Knex
   organizationId: string | null
   tenantId: string
+  commandCtx: CommandRuntimeContext
 }
 
 export async function resolveTranslationsRouteContext(req: Request): Promise<TranslationsRouteContext> {
@@ -28,6 +30,15 @@ export async function resolveTranslationsRouteContext(req: Request): Promise<Tra
   const tenantId: string = scope?.tenantId ?? auth.tenantId
   const organizationId = scope?.selectedId ?? auth.orgId ?? null
 
+  const commandCtx: CommandRuntimeContext = {
+    container,
+    auth,
+    organizationScope: scope,
+    selectedOrganizationId: organizationId,
+    organizationIds: scope?.filterIds ?? (auth.orgId ? [auth.orgId] : null),
+    request: req,
+  }
+
   return {
     container,
     auth,
@@ -35,5 +46,6 @@ export async function resolveTranslationsRouteContext(req: Request): Promise<Tra
     knex,
     organizationId,
     tenantId,
+    commandCtx,
   }
 }

package/src/modules/translations/commands/index.ts

@@ -0,0 +1 @@
+import './translations'

package/src/modules/translations/commands/translations.ts

@@ -0,0 +1,253 @@
+import { registerCommand } from '@open-mercato/shared/lib/commands'
+import type { CommandHandler, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
+import { ensureTenantScope } from '@open-mercato/shared/lib/commands/scope'
+import { extractUndoPayload } from '@open-mercato/shared/lib/commands/undo'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { Knex } from 'knex'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { emitTranslationsEvent } from '../events'
+
+type TranslationSnapshot = {
+  id: string | null
+  entityType: string
+  entityId: string
+  translations: Record<string, Record<string, string | null>> | null
+  organizationId: string | null
+  tenantId: string
+}
+
+type TranslationUndoPayload = {
+  before?: TranslationSnapshot | null
+  after?: TranslationSnapshot | null
+}
+
+type SaveInput = {
+  entityType: string
+  entityId: string
+  translations: Record<string, Record<string, string | null>>
+  organizationId: string | null
+  tenantId: string
+}
+
+type DeleteInput = {
+  entityType: string
+  entityId: string
+  organizationId: string | null
+  tenantId: string
+}
+
+function resolveKnex(ctx: CommandRuntimeContext): Knex {
+  const em = ctx.container.resolve('em') as EntityManager
+  return (em as unknown as { getConnection(): { getKnex(): Knex } }).getConnection().getKnex()
+}
+
+async function loadTranslationSnapshot(
+  knex: Knex,
+  entityType: string,
+  entityId: string,
+  tenantId: string,
+  organizationId: string | null,
+): Promise<TranslationSnapshot | null> {
+  const row = await knex('entity_translations')
+    .where({ entity_type: entityType, entity_id: entityId })
+    .andWhereRaw('tenant_id is not distinct from ?', [tenantId])
+    .andWhereRaw('organization_id is not distinct from ?', [organizationId])
+    .first()
+
+  if (!row) return null
+  return {
+    id: row.id,
+    entityType: row.entity_type,
+    entityId: row.entity_id,
+    translations: row.translations ?? null,
+    organizationId: row.organization_id ?? null,
+    tenantId: row.tenant_id,
+  }
+}
+
+const saveTranslationCommand: CommandHandler<SaveInput, { rowId: string }> = {
+  id: 'translations.translation.save',
+
+  async prepare(input, ctx) {
+    ensureTenantScope(ctx, input.tenantId)
+    const knex = resolveKnex(ctx)
+    const snapshot = await loadTranslationSnapshot(knex, input.entityType, input.entityId, input.tenantId, input.organizationId)
+    return { before: snapshot }
+  },
+
+  async execute(input, ctx) {
+    const knex = resolveKnex(ctx)
+    const existing = await knex('entity_translations')
+      .where({ entity_type: input.entityType, entity_id: input.entityId })
+      .andWhereRaw('tenant_id is not distinct from ?', [input.tenantId])
+      .andWhereRaw('organization_id is not distinct from ?', [input.organizationId])
+      .first()
+
+    const now = knex.fn.now()
+
+    if (existing) {
+      await knex('entity_translations')
+        .where({ id: existing.id })
+        .update({ translations: input.translations, updated_at: now })
+    } else {
+      await knex('entity_translations').insert({
+        entity_type: input.entityType,
+        entity_id: input.entityId,
+        organization_id: input.organizationId,
+        tenant_id: input.tenantId,
+        translations: input.translations,
+        created_at: now,
+        updated_at: now,
+      })
+    }
+
+    await emitTranslationsEvent('translations.translation.updated', {
+      entityType: input.entityType,
+      entityId: input.entityId,
+      organizationId: input.organizationId,
+      tenantId: input.tenantId,
+    }, { persistent: true }).catch(() => undefined)
+
+    const saved = await knex('entity_translations')
+      .where({ entity_type: input.entityType, entity_id: input.entityId })
+      .andWhereRaw('tenant_id is not distinct from ?', [input.tenantId])
+      .andWhereRaw('organization_id is not distinct from ?', [input.organizationId])
+      .first()
+
+    return { rowId: saved.id }
+  },
+
+  async captureAfter(input, _result, ctx) {
+    const knex = resolveKnex(ctx)
+    return await loadTranslationSnapshot(knex, input.entityType, input.entityId, input.tenantId, input.organizationId)
+  },
+
+  async buildLog({ snapshots, result }) {
+    const { translate } = await resolveTranslations()
+    const before = snapshots.before as TranslationSnapshot | null | undefined
+    const after = snapshots.after as TranslationSnapshot | null | undefined
+    return {
+      actionLabel: translate('translations.audit.save', 'Save translation'),
+      resourceKind: 'translations.translation',
+      resourceId: result.rowId,
+      tenantId: after?.tenantId ?? before?.tenantId ?? null,
+      organizationId: after?.organizationId ?? before?.organizationId ?? null,
+      snapshotBefore: before ?? null,
+      snapshotAfter: after ?? null,
+      payload: {
+        undo: { before: before ?? null, after: after ?? null } satisfies TranslationUndoPayload,
+      },
+    }
+  },
+
+  async undo({ logEntry, ctx }) {
+    const payload = extractUndoPayload<TranslationUndoPayload>(logEntry)
+    const before = payload?.before ?? null
+    const knex = resolveKnex(ctx)
+
+    if (!before || !before.translations) {
+      // Was a create — delete the record
+      const resourceId = logEntry?.resourceId
+      if (resourceId) {
+        await knex('entity_translations').where({ id: resourceId }).del()
+      }
+    } else {
+      // Was an update — restore previous translations
+      const existing = await knex('entity_translations')
+        .where({ entity_type: before.entityType, entity_id: before.entityId })
+        .andWhereRaw('tenant_id is not distinct from ?', [before.tenantId])
+        .andWhereRaw('organization_id is not distinct from ?', [before.organizationId])
+        .first()
+
+      if (existing) {
+        await knex('entity_translations')
+          .where({ id: existing.id })
+          .update({ translations: before.translations, updated_at: knex.fn.now() })
+      } else {
+        await knex('entity_translations').insert({
+          entity_type: before.entityType,
+          entity_id: before.entityId,
+          organization_id: before.organizationId,
+          tenant_id: before.tenantId,
+          translations: before.translations,
+          created_at: knex.fn.now(),
+          updated_at: knex.fn.now(),
+        })
+      }
+    }
+  },
+}
+
+const deleteTranslationCommand: CommandHandler<DeleteInput, { deleted: boolean }> = {
+  id: 'translations.translation.delete',
+
+  async prepare(input, ctx) {
+    ensureTenantScope(ctx, input.tenantId)
+    const knex = resolveKnex(ctx)
+    const snapshot = await loadTranslationSnapshot(knex, input.entityType, input.entityId, input.tenantId, input.organizationId)
+    return { before: snapshot }
+  },
+
+  async execute(input, ctx) {
+    const knex = resolveKnex(ctx)
+    const count = await knex('entity_translations')
+      .where({ entity_type: input.entityType, entity_id: input.entityId })
+      .andWhereRaw('tenant_id is not distinct from ?', [input.tenantId])
+      .andWhereRaw('organization_id is not distinct from ?', [input.organizationId])
+      .del()
+
+    await emitTranslationsEvent('translations.translation.deleted', {
+      entityType: input.entityType,
+      entityId: input.entityId,
+      organizationId: input.organizationId,
+      tenantId: input.tenantId,
+    }, { persistent: true }).catch(() => undefined)
+
+    return { deleted: count > 0 }
+  },
+
+  async buildLog({ snapshots }) {
+    const before = snapshots.before as TranslationSnapshot | null | undefined
+    if (!before) return null
+    const { translate } = await resolveTranslations()
+    return {
+      actionLabel: translate('translations.audit.delete', 'Delete translation'),
+      resourceKind: 'translations.translation',
+      resourceId: before.id ?? undefined,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      payload: {
+        undo: { before } satisfies TranslationUndoPayload,
+      },
+    }
+  },
+
+  async undo({ logEntry, ctx }) {
+    const payload = extractUndoPayload<TranslationUndoPayload>(logEntry)
+    const before = payload?.before
+    if (!before || !before.translations) return
+    const knex = resolveKnex(ctx)
+
+    const existing = await knex('entity_translations')
+      .where({ entity_type: before.entityType, entity_id: before.entityId })
+      .andWhereRaw('tenant_id is not distinct from ?', [before.tenantId])
+      .andWhereRaw('organization_id is not distinct from ?', [before.organizationId])
+      .first()
+
+    if (!existing) {
+      await knex('entity_translations').insert({
+        entity_type: before.entityType,
+        entity_id: before.entityId,
+        organization_id: before.organizationId,
+        tenant_id: before.tenantId,
+        translations: before.translations,
+        created_at: knex.fn.now(),
+        updated_at: knex.fn.now(),
+      })
+    }
+  },
+}
+
+registerCommand(saveTranslationCommand)
+registerCommand(deleteTranslationCommand)

package/src/modules/translations/index.ts

@@ -1,4 +1,5 @@
 import type { ModuleInfo } from '@open-mercato/shared/modules/registry'
+import './commands'
 
 export const metadata: ModuleInfo = {
   name: 'translations',

package/src/modules/workflows/migrations/Migration20260222205305.ts

@@ -0,0 +1,13 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260222205305 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table if not exists "workflow_event_triggers" ("id" uuid not null default gen_random_uuid(), "name" varchar(255) not null, "description" text null, "workflow_definition_id" uuid not null, "event_pattern" varchar(255) not null, "config" jsonb null, "enabled" boolean not null default true, "priority" int not null default 0, "tenant_id" uuid not null, "organization_id" uuid not null, "created_by" varchar(255) null, "updated_by" varchar(255) null, "created_at" timestamptz not null, "updated_at" timestamptz not null, "deleted_at" timestamptz null, constraint "workflow_event_triggers_pkey" primary key ("id"));`);
+    this.addSql(`create index if not exists "workflow_event_triggers_enabled_priority_idx" on "workflow_event_triggers" ("enabled", "priority");`);
+    this.addSql(`create index if not exists "workflow_event_triggers_tenant_org_idx" on "workflow_event_triggers" ("tenant_id", "organization_id");`);
+    this.addSql(`create index if not exists "workflow_event_triggers_definition_idx" on "workflow_event_triggers" ("workflow_definition_id");`);
+    this.addSql(`create index if not exists "workflow_event_triggers_event_pattern_idx" on "workflow_event_triggers" ("event_pattern", "enabled");`);
+  }
+
+}