@open-mercato/core 0.6.2-develop.3400.2.d948268f50 → 0.6.2-develop.3406.1.2b403f40da

package/src/modules/workflows/api/definitions/[id]/route.ts

@@ -18,8 +18,9 @@ import {
   updateWorkflowDefinitionInputSchema,
   type UpdateWorkflowDefinitionApiInput,
 } from '../../../data/validators'
-import { serializeWorkflowDefinition } from '../serialize'
+import { serializeWorkflowDefinition, serializeCodeWorkflowDefinition } from '../serialize'
 import { invalidateTriggerCache } from '../../../lib/event-trigger-service'
+import { getCodeWorkflow } from '../../../lib/code-registry'
 
 export const metadata = {
   requireAuth: true,
@@ -55,6 +56,21 @@ export async function GET(
     const tenantId = auth.tenantId
     const orgFilter = resolveOrganizationScopeFilter(scope, auth)
 
+    // Handle code-based workflow definitions (code:<workflowId>)
+    if (params.id.startsWith('code:')) {
+      const workflowId = params.id.slice(5)
+      const codeDef = getCodeWorkflow(workflowId)
+      if (!codeDef) {
+        return NextResponse.json(
+          { error: 'Workflow definition not found' },
+          { status: 404 }
+        )
+      }
+      return NextResponse.json({
+        data: serializeCodeWorkflowDefinition(codeDef, params.id),
+      })
+    }
+
     const definition = await em.findOne(WorkflowDefinition, {
       id: params.id,
       tenantId,
@@ -136,6 +152,90 @@ export async function PUT(
 
     const input: UpdateWorkflowDefinitionApiInput = validation.data
 
+    // Handle customizing a code-based workflow definition
+    if (params.id.startsWith('code:')) {
+      const workflowId = params.id.slice(5)
+      const codeDef = getCodeWorkflow(workflowId)
+      if (!codeDef) {
+        return NextResponse.json(
+          { error: 'Workflow definition not found' },
+          { status: 404 }
+        )
+      }
+
+      // Check if an override already exists (including soft-deleted, due to unique constraint on workflowId+tenantId)
+      const existingOverride = await em.findOne(WorkflowDefinition, {
+        workflowId: codeDef.workflowId,
+        tenantId,
+      })
+
+      let savedOverride: WorkflowDefinition
+      if (existingOverride) {
+        // Revive if soft-deleted, then apply updates
+        existingOverride.deletedAt = null
+        existingOverride.workflowName = codeDef.workflowName
+        existingOverride.description = codeDef.description
+        existingOverride.version = codeDef.version
+        existingOverride.definition = input.definition ?? codeDef.definition
+        existingOverride.metadata = codeDef.metadata ?? null
+        existingOverride.enabled = input.enabled ?? codeDef.enabled
+        existingOverride.codeWorkflowId = codeDef.workflowId
+        existingOverride.updatedBy = auth.sub
+        existingOverride.updatedAt = new Date()
+        await em.flush()
+        savedOverride = existingOverride
+      } else {
+        // Create DB override row from code definition + user changes
+        const override = em.create(WorkflowDefinition, {
+          workflowId: codeDef.workflowId,
+          workflowName: codeDef.workflowName,
+          description: codeDef.description,
+          version: codeDef.version,
+          definition: input.definition ?? codeDef.definition,
+          metadata: codeDef.metadata,
+          enabled: input.enabled ?? codeDef.enabled,
+          codeWorkflowId: codeDef.workflowId,
+          tenantId,
+          organizationId,
+          createdBy: auth.sub,
+          updatedBy: auth.sub,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        })
+
+        em.persist(override)
+        await em.flush()
+        savedOverride = override
+      }
+
+      try {
+        const eventBus = container.resolve('eventBus') as
+          | { emitEvent(event: string, payload: unknown, options?: unknown): Promise<void> }
+          | undefined
+        if (eventBus && typeof eventBus.emitEvent === 'function') {
+          await eventBus.emitEvent(
+            'workflows.definition.customized',
+            {
+              id: savedOverride.id,
+              workflowId: savedOverride.workflowId,
+              codeWorkflowId: savedOverride.codeWorkflowId ?? null,
+              tenantId: savedOverride.tenantId,
+              organizationId: savedOverride.organizationId,
+              userId: auth.sub ?? null,
+            },
+            { tenantId: savedOverride.tenantId, organizationId: savedOverride.organizationId, persistent: true },
+          )
+        }
+      } catch (eventError) {
+        console.error('Failed to emit workflows.definition.customized event:', eventError)
+      }
+
+      return NextResponse.json({
+        data: serializeWorkflowDefinition(savedOverride),
+        message: 'Workflow definition customized successfully',
+      })
+    }
+
     // Find existing definition
     const definition = await em.findOne(WorkflowDefinition, {
       id: params.id,
@@ -151,14 +251,18 @@ export async function PUT(
       )
     }
 
-    // Update fields. workflowId and version are intentionally ignored —
-    // they identify the row and bumping versions is handled elsewhere.
+    // Update fields. workflowId is intentionally ignored — it identifies the
+    // row and renaming would break references. Version is user-managed and
+    // applied when supplied so the edit form can bump it explicitly.
     if (input.workflowName !== undefined) {
       definition.workflowName = input.workflowName
     }
     if (input.description !== undefined) {
       definition.description = input.description
     }
+    if (input.version !== undefined) {
+      definition.version = input.version
+    }
     if (input.definition !== undefined) {
       definition.definition = input.definition
     }
@@ -295,7 +399,7 @@ export const openApi = {
       description: 'Get a single workflow definition by ID. Returns the complete workflow structure including steps and transitions (with embedded activities).',
       tags: ['Workflows'],
       pathParams: z.object({
-        id: z.string().uuid(),
+        id: z.string().describe('UUID for DB definitions, or "code:<workflowId>" for code-based definitions'),
       }),
       responses: [
         {

package/src/modules/workflows/api/definitions/route.ts

@@ -17,8 +17,9 @@ import {
   createWorkflowDefinitionInputSchema,
   type CreateWorkflowDefinitionApiInput,
 } from '../../data/validators'
-import { serializeWorkflowDefinition } from './serialize'
+import { serializeWorkflowDefinition, serializeCodeWorkflowDefinition } from './serialize'
 import { invalidateTriggerCache } from '../../lib/event-trigger-service'
+import { getAllCodeWorkflows } from '../../lib/code-registry'
 
 export const metadata = {
   requireAuth: true,
@@ -97,18 +98,61 @@ export async function GET(request: NextRequest) {
       ]
     }
 
-    const [definitions, total] = await em.findAndCount(
-      WorkflowDefinition,
-      where,
-      {
-        orderBy: { createdAt: 'DESC' },
-        limit,
-        offset,
-      }
+    // Determine which code workflows are shadowed by a DB row (so we can
+    // exclude them from the code-only list) without loading all DB rows.
+    const enabledFilter = enabled !== null ? enabled === 'true' : null
+    const searchLower = search ? search.toLowerCase() : null
+    const allCodeIds = getAllCodeWorkflows().map((cw) => cw.workflowId)
+    const shadowed = allCodeIds.length > 0
+      ? new Set(
+          (
+            await em.find(
+              WorkflowDefinition,
+              { ...where, workflowId: { $in: allCodeIds } },
+              { fields: ['workflowId'] as const },
+            )
+          ).map((d: WorkflowDefinition) => d.workflowId),
+        )
+      : new Set<string>()
+
+    const codeOnly = getAllCodeWorkflows()
+      .filter((cw) => !shadowed.has(cw.workflowId))
+      .filter((cw) => {
+        if (searchLower) {
+          const matches =
+            cw.workflowId.toLowerCase().includes(searchLower) ||
+            cw.workflowName.toLowerCase().includes(searchLower)
+          if (!matches) return false
+        }
+        if (enabledFilter !== null && cw.enabled !== enabledFilter) return false
+        if (workflowId && cw.workflowId !== workflowId) return false
+        return true
+      })
+      .map((cw) => serializeCodeWorkflowDefinition(cw, `code:${cw.workflowId}`))
+
+    const dbCount = await em.count(WorkflowDefinition, where)
+    const total = dbCount + codeOnly.length
+
+    // Fetch only the prefix of DB rows we might need to fill the requested
+    // page after merging with the (already-filtered) code-only list.
+    const dbWindowLimit = offset + limit
+    const dbWindow = dbWindowLimit > 0
+      ? await em.find(WorkflowDefinition, where, {
+          orderBy: { workflowName: 'ASC' },
+          limit: dbWindowLimit,
+        })
+      : []
+
+    const serializedDb = dbWindow.map(serializeWorkflowDefinition)
+
+    const merged = [...serializedDb, ...codeOnly].sort((a, b) =>
+      a.workflowName.localeCompare(b.workflowName),
     )
 
+    const paginated = merged.slice(offset, offset + limit)
+
     return NextResponse.json({
-      data: definitions.map(serializeWorkflowDefinition),
+      data: paginated,
       pagination: {
         total,
         limit,

package/src/modules/workflows/api/definitions/serialize.ts

@@ -1,6 +1,20 @@
 import type { WorkflowDefinition } from '../../data/entities'
+import type { CodeWorkflowDefinition } from '@open-mercato/shared/modules/workflows'
+import { getCodeWorkflow } from '../../lib/code-registry'
+
+export type WorkflowDefinitionSource = 'code' | 'code_override' | 'user'
+
+function resolveSource(definition: WorkflowDefinition): WorkflowDefinitionSource {
+  if (definition.codeWorkflowId) return 'code_override'
+  return 'user'
+}
 
 export function serializeWorkflowDefinition(definition: WorkflowDefinition) {
+  const source = resolveSource(definition)
+  const codeModuleId =
+    source === 'code_override' && definition.codeWorkflowId
+      ? getCodeWorkflow(definition.codeWorkflowId)?.moduleId ?? null
+      : null
   return {
     id: definition.id,
     workflowId: definition.workflowId,
@@ -19,5 +33,33 @@ export function serializeWorkflowDefinition(definition: WorkflowDefinition) {
     createdAt: definition.createdAt,
     updatedAt: definition.updatedAt,
     deletedAt: definition.deletedAt ?? null,
+    source,
+    isCodeBased: source === 'code' || source === 'code_override',
+    codeModuleId,
+  }
+}
+
+export function serializeCodeWorkflowDefinition(codeDef: CodeWorkflowDefinition, syntheticId: string) {
+  return {
+    id: syntheticId,
+    workflowId: codeDef.workflowId,
+    workflowName: codeDef.workflowName,
+    description: codeDef.description ?? null,
+    version: codeDef.version,
+    definition: codeDef.definition,
+    metadata: codeDef.metadata ?? null,
+    enabled: codeDef.enabled,
+    effectiveFrom: null,
+    effectiveTo: null,
+    tenantId: null,
+    organizationId: null,
+    createdBy: null,
+    updatedBy: null,
+    createdAt: null,
+    updatedAt: null,
+    deletedAt: null,
+    source: 'code' as const,
+    isCodeBased: true,
+    codeModuleId: codeDef.moduleId,
   }
 }

package/src/modules/workflows/backend/definitions/[id]/page.tsx

@@ -7,8 +7,13 @@ import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { CrudForm } from '@open-mercato/ui/backend/CrudForm'
 import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { Button } from '@open-mercato/ui/primitives/button'
+import { Alert, AlertDescription } from '@open-mercato/ui/primitives/alert'
 import { apiFetch } from '@open-mercato/ui/backend/utils/api'
+import { readJsonSafe } from '@open-mercato/ui/backend/utils/serverErrors'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
 import {
   workflowDefinitionFormSchema,
   createFormGroups,
@@ -64,24 +69,121 @@ export default function EditWorkflowDefinitionPage() {
     setTriggers(initialValues?.triggers ?? [])
   }, [initialValues])
 
+  const source = definition?.source as 'code' | 'code_override' | 'user' | undefined
+  const isCodeOnly = source === 'code'
+  const isCodeOverride = source === 'code_override'
+
+  const { confirm, ConfirmDialogElement } = useConfirmDialog()
+
+  const mutationContextId = React.useMemo(
+    () => `workflows.definitions.detail:${definitionId ?? 'unknown'}`,
+    [definitionId],
+  )
+  const { runMutation, retryLastMutation } = useGuardedMutation<Record<string, unknown>>({
+    contextId: mutationContextId,
+  })
+
   const handleSubmit = async (values: WorkflowDefinitionFormValues) => {
     const payload = buildWorkflowPayload({ ...values, triggers })
 
-    const response = await apiFetch(`/api/workflows/definitions/${definitionId}`, {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload),
+    await runMutation({
+      operation: async () => {
+        const response = await apiFetch(`/api/workflows/definitions/${definitionId}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(payload),
+        })
+        if (!response.ok) {
+          const errorBody = await readJsonSafe<{ error?: string }>(response, null)
+          throw new Error(errorBody?.error || t('workflows.errors.updateFailed'))
+        }
+        return response
+      },
+      mutationPayload: { resourceId: definitionId, operation: 'update' },
+      context: {
+        formId: mutationContextId,
+        resourceKind: 'workflows.definition',
+        resourceId: definitionId,
+        operation: 'update',
+        retryLastMutation,
+      },
     })
 
-    if (!response.ok) {
-      const error = await response.json()
-      throw new Error(error.error || t('workflows.errors.updateFailed'))
-    }
-
     router.push('/backend/definitions')
     router.refresh()
   }
 
+  const handleCustomize = async () => {
+    try {
+      const result = await runMutation({
+        operation: async () => {
+          const response = await apiFetch(`/api/workflows/definitions/${definitionId}/customize`, {
+            method: 'POST',
+          })
+          if (!response.ok) {
+            const errorBody = await readJsonSafe<{ error?: string }>(response, null)
+            throw new Error(errorBody?.error || t('workflows.errors.updateFailed'))
+          }
+          return readJsonSafe<{ data?: { id?: string } }>(response, null)
+        },
+        mutationPayload: { resourceId: definitionId, operation: 'customize' },
+        context: {
+          formId: mutationContextId,
+          resourceKind: 'workflows.definition',
+          resourceId: definitionId,
+          operation: 'customize',
+          retryLastMutation,
+        },
+      })
+      if (result?.data?.id) {
+        router.push(`/backend/definitions/${result.data.id}`)
+        router.refresh()
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : t('workflows.errors.updateFailed')
+      flash(message, 'error')
+    }
+  }
+
+  const handleResetToCode = async () => {
+    const confirmed = await confirm({
+      title: t('workflows.actions.resetToCode'),
+      description: t('workflows.actions.resetConfirm'),
+      confirmText: t('workflows.actions.resetToCode'),
+      variant: 'destructive',
+    })
+    if (!confirmed) return
+
+    try {
+      const result = await runMutation({
+        operation: async () => {
+          const response = await apiFetch(`/api/workflows/definitions/${definitionId}/reset-to-code`, {
+            method: 'POST',
+          })
+          if (!response.ok) {
+            const errorBody = await readJsonSafe<{ error?: string }>(response, null)
+            throw new Error(errorBody?.error || t('workflows.messages.updateFailed'))
+          }
+          return readJsonSafe<{ data?: { id?: string } }>(response, null)
+        },
+        mutationPayload: { resourceId: definitionId, operation: 'reset-to-code' },
+        context: {
+          formId: mutationContextId,
+          resourceKind: 'workflows.definition',
+          resourceId: definitionId,
+          operation: 'reset-to-code',
+          retryLastMutation,
+        },
+      })
+      flash(t('workflows.messages.updated'), 'success')
+      const codeId = result?.data?.id || `code:${definition?.workflowId}`
+      router.push(`/backend/definitions/${codeId}`)
+      router.refresh()
+    } catch {
+      flash(t('workflows.messages.updateFailed'), 'error')
+    }
+  }
+
   const fields = React.useMemo(() => createFieldDefinitions(t), [t])
 
   const formGroups = React.useMemo(
@@ -128,6 +230,26 @@ export default function EditWorkflowDefinitionPage() {
   return (
     <Page>
       <PageBody>
+        {isCodeOnly && (
+          <Alert variant="info" className="mb-4">
+            <AlertDescription className="flex items-center justify-between">
+              <span>{t('workflows.source.code.readonlyBanner')}</span>
+              <Button variant="outline" size="sm" onClick={handleCustomize}>
+                {t('workflows.actions.customize')}
+              </Button>
+            </AlertDescription>
+          </Alert>
+        )}
+        {isCodeOverride && (
+          <Alert variant="warning" className="mb-4">
+            <AlertDescription className="flex items-center justify-between">
+              <span>{t('workflows.source.code_override.banner')}</span>
+              <Button variant="outline" size="sm" onClick={handleResetToCode}>
+                {t('workflows.actions.resetToCode')}
+              </Button>
+            </AlertDescription>
+          </Alert>
+        )}
         <div className="mb-4 p-4 bg-status-info-bg border border-status-info-border rounded-lg flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
           <div className="flex items-start gap-3">
             <svg className="w-5 h-5 text-status-info-icon" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -150,7 +272,7 @@ export default function EditWorkflowDefinitionPage() {
         </div>
         <CrudForm
           key={definitionId}
-          title={t('workflows.edit.title')}
+          title={isCodeOnly ? definition?.workflowName || t('workflows.edit.title') : t('workflows.edit.title')}
           backHref="/backend/definitions"
           schema={workflowDefinitionFormSchema}
           fields={fields}
@@ -158,7 +280,8 @@ export default function EditWorkflowDefinitionPage() {
           onSubmit={handleSubmit}
           cancelHref="/backend/definitions"
           groups={formGroups}
-          submitLabel={t('workflows.form.update')}
+          submitLabel={isCodeOnly ? t('workflows.actions.customize') : t('workflows.form.update')}
+          {...(isCodeOnly ? { readOnly: true } : {})}
         />
 
         {/* Mobile Steps & Transitions View */}
@@ -184,6 +307,7 @@ export default function EditWorkflowDefinitionPage() {
           />
         </div>
       </PageBody>
+      {ConfirmDialogElement}
     </Page>
   )
 }

package/src/modules/workflows/backend/definitions/page.tsx

@@ -25,6 +25,8 @@ import { useT } from '@open-mercato/shared/lib/i18n/context'
 import type { FilterDef, FilterValues } from '@open-mercato/ui/backend/FilterBar'
 import { Trash2 } from 'lucide-react'
 
+type WorkflowDefinitionSource = 'code' | 'code_override' | 'user'
+
 type WorkflowDefinition = {
   id: string
   workflowId: string
@@ -45,6 +47,8 @@ type WorkflowDefinition = {
   createdAt: string
   updatedAt: string
   createdBy: string | null
+  source?: WorkflowDefinitionSource
+  isCodeBased?: boolean
 }
 
 type DefinitionsResponse = {
@@ -241,7 +245,15 @@ export default function WorkflowDefinitionsListPage() {
       meta: { truncate: false },
       cell: ({ row }) => (
         <div>
-          <div className="font-medium">{row.original.workflowName}</div>
+          <div className="flex items-center gap-2">
+            <span className="font-medium">{row.original.workflowName}</span>
+            {row.original.source === 'code' && (
+              <Badge variant="secondary">{t('workflows.source.code')}</Badge>
+            )}
+            {row.original.source === 'code_override' && (
+              <Badge variant="outline">{t('workflows.source.code_override')}</Badge>
+            )}
+          </div>
           {row.original.description && (
             <div className="text-xs text-gray-500">
               {row.original.description}
@@ -316,38 +328,38 @@ export default function WorkflowDefinitionsListPage() {
     {
       id: 'actions',
       header: '',
-      cell: ({ row }) => (
-        <RowActions
-          items={[
-            {
-              id: 'edit',
-              label: t('common.edit'),
-              href: `/backend/definitions/${row.original.id}`,
-            },
-            {
-              id: 'edit-visual',
-              label: t('workflows.actions.editVisually'),
-              href: `/backend/definitions/visual-editor?id=${row.original.id}`,
-            },
-            {
-              id: row.original.enabled ? 'disable' : 'enable',
-              label: row.original.enabled ? t('common.disable') : t('common.enable'),
-              onSelect: () => handleToggleEnabled(row.original.id, row.original.enabled),
-            },
-            {
-              id: 'duplicate',
-              label: t('common.duplicate'),
-              onSelect: () => handleDuplicate(row.original),
-            },
-            {
-              id: 'delete',
-              label: t('common.delete'),
-              onSelect: () => handleDelete(row.original.id, row.original.workflowName),
-              destructive: true,
-            },
-          ]}
-        />
-      ),
+      cell: ({ row }) => {
+        const isCodeOnly = row.original.source === 'code'
+        const items = [
+          {
+            id: 'edit',
+            label: isCodeOnly ? t('common.view') : t('common.edit'),
+            href: `/backend/definitions/${row.original.id}`,
+          },
+          ...(!isCodeOnly ? [{
+            id: 'edit-visual',
+            label: t('workflows.actions.editVisually'),
+            href: `/backend/definitions/visual-editor?id=${row.original.id}`,
+          }] : []),
+          ...(!isCodeOnly ? [{
+            id: row.original.enabled ? 'disable' : 'enable',
+            label: row.original.enabled ? t('common.disable') : t('common.enable'),
+            onSelect: () => handleToggleEnabled(row.original.id, row.original.enabled),
+          }] : []),
+          ...(!isCodeOnly ? [{
+            id: 'duplicate',
+            label: t('common.duplicate'),
+            onSelect: () => handleDuplicate(row.original),
+          }] : []),
+          ...(!isCodeOnly ? [{
+            id: 'delete',
+            label: t('common.delete'),
+            onSelect: () => handleDelete(row.original.id, row.original.workflowName),
+            destructive: true,
+          }] : []),
+        ]
+        return <RowActions items={items} />
+      },
     },
   ]