@open-mercato/core 0.6.6-develop.6551.1.1511bfa890 → 0.6.6

package/src/modules/sync_excel/lib/parser.ts

@@ -1,5 +1,3 @@
-import { TextDecoder } from 'util'
-
 export type CsvPreviewRow = Record<string, string | null>
 
 export type CsvPreview = {
@@ -18,36 +16,10 @@ export type CsvDocument = {
   encoding: 'utf-8'
 }
 
-export type CsvStreamMetadata = {
-  headers: string[]
-  totalRows: number
-  delimiter: ',' | ';'
-  encoding: 'utf-8'
-}
-
-export type CsvDocumentBatch = {
-  headers: string[]
-  rows: CsvPreviewRow[]
-  rowStart: number
-  nextOffset: number
-  delimiter: ',' | ';'
-  encoding: 'utf-8'
-}
-
 type ParseCsvPreviewOptions = {
   maxRows?: number
 }
 
-type ParseCsvBatchOptions = {
-  batchSize: number
-  startOffset?: number
-}
-
-type CsvInputChunk = Buffer | Uint8Array | string
-
-const CSV_DELIMITER_PROBE_ROWS = 5
-const CSV_DELIMITER_PROBE_MAX_CHARS = 64 * 1024
-
 function stripUtf8Bom(value: string): string {
   return value.charCodeAt(0) === 0xfeff ? value.slice(1) : value
 }
@@ -159,223 +131,6 @@ function rowsToObjects(headers: string[], rows: string[][], maxRows: number): Cs
   })
 }
 
-async function createCsvRowStream(input: AsyncIterable<CsvInputChunk>): Promise<{
-  delimiter: ',' | ';'
-  rows: AsyncIterable<string[]>
-}> {
-  const iterator = input[Symbol.asyncIterator]()
-  const decoder = new TextDecoder('utf-8')
-  const prefixTexts: string[] = []
-  let probeText = ''
-
-  while (probeText.length < CSV_DELIMITER_PROBE_MAX_CHARS) {
-    const next = await iterator.next()
-    if (next.done) break
-
-    const text = typeof next.value === 'string' ? next.value : decoder.decode(next.value, { stream: true })
-    prefixTexts.push(text)
-    probeText += text
-
-    if (parseCsvText(probeText, ',').length >= CSV_DELIMITER_PROBE_ROWS) {
-      break
-    }
-  }
-
-  const delimiter = detectCsvDelimiter(probeText)
-
-  async function* decodedChunks(): AsyncIterable<string> {
-    for (const text of prefixTexts) {
-      yield text
-    }
-    while (true) {
-      const next = await iterator.next()
-      if (next.done) break
-      yield typeof next.value === 'string' ? next.value : decoder.decode(next.value, { stream: true })
-    }
-    const finalChunk = decoder.decode()
-    if (finalChunk.length > 0) {
-      yield finalChunk
-    }
-  }
-
-  return {
-    delimiter,
-    rows: parseCsvRowsFromTextChunks(decodedChunks(), delimiter),
-  }
-}
-
-async function* parseCsvRowsFromTextChunks(
-  chunks: AsyncIterable<string>,
-  delimiter: ',' | ';',
-): AsyncIterable<string[]> {
-  let currentRow: string[] = []
-  let currentValue = ''
-  let inQuotes = false
-  let isFirstChunk = true
-  let previousWasCarriageReturn = false
-  let pendingQuote = false
-  let pendingQuoteWasInQuotes = false
-
-  const completeRow = (): string[] | null => {
-    currentRow.push(currentValue)
-    const completedRow = currentRow
-    currentRow = []
-    currentValue = ''
-    return completedRow.some((value) => value.trim().length > 0) ? completedRow : null
-  }
-
-  for await (const chunk of chunks) {
-    const text = isFirstChunk ? stripUtf8Bom(chunk) : chunk
-    isFirstChunk = false
-
-    for (let index = 0; index < text.length; index += 1) {
-      const character = text[index]
-
-      if (pendingQuote) {
-        pendingQuote = false
-        if (pendingQuoteWasInQuotes && character === '"') {
-          currentValue += '"'
-          continue
-        }
-        inQuotes = !pendingQuoteWasInQuotes
-      }
-
-      if (previousWasCarriageReturn) {
-        previousWasCarriageReturn = false
-        if (character === '\n') {
-          continue
-        }
-      }
-
-      if (character === '"') {
-        if (index + 1 >= text.length) {
-          pendingQuote = true
-          pendingQuoteWasInQuotes = inQuotes
-          continue
-        }
-        if (inQuotes && text[index + 1] === '"') {
-          currentValue += '"'
-          index += 1
-          continue
-        }
-        inQuotes = !inQuotes
-        continue
-      }
-
-      if (!inQuotes && character === delimiter) {
-        currentRow.push(currentValue)
-        currentValue = ''
-        continue
-      }
-
-      if (character === '\r') {
-        previousWasCarriageReturn = true
-        if (inQuotes) {
-          currentValue += '\n'
-        } else {
-          const row = completeRow()
-          if (row) yield row
-        }
-        continue
-      }
-
-      if (character === '\n') {
-        if (inQuotes) {
-          currentValue += '\n'
-        } else {
-          const row = completeRow()
-          if (row) yield row
-        }
-        continue
-      }
-
-      currentValue += character
-    }
-  }
-
-  if (currentValue.length > 0 || currentRow.length > 0) {
-    const row = completeRow()
-    if (row) yield row
-  }
-}
-
-export async function parseCsvStreamMetadata(input: AsyncIterable<CsvInputChunk>): Promise<CsvStreamMetadata> {
-  const stream = await createCsvRowStream(input)
-  let headers: string[] = []
-  let hasHeaders = false
-  let totalRows = 0
-
-  for await (const row of stream.rows) {
-    if (!hasHeaders) {
-      headers = normalizeHeaders(row)
-      hasHeaders = true
-      continue
-    }
-    totalRows += 1
-  }
-
-  return {
-    headers,
-    totalRows,
-    delimiter: stream.delimiter,
-    encoding: 'utf-8',
-  }
-}
-
-export async function* parseCsvDocumentBatches(
-  input: AsyncIterable<CsvInputChunk>,
-  options: ParseCsvBatchOptions,
-): AsyncIterable<CsvDocumentBatch> {
-  const stream = await createCsvRowStream(input)
-  const batchSize = Math.max(1, Math.floor(options.batchSize))
-  const startOffset = Math.max(0, Math.floor(options.startOffset ?? 0))
-  let headers: string[] | null = null
-  let rowOffset = 0
-  let batchRows: string[][] = []
-  let batchStart = startOffset
-
-  for await (const row of stream.rows) {
-    if (!headers) {
-      headers = normalizeHeaders(row)
-      continue
-    }
-
-    if (rowOffset < startOffset) {
-      rowOffset += 1
-      continue
-    }
-
-    if (batchRows.length === 0) {
-      batchStart = rowOffset
-    }
-    batchRows.push(row)
-    rowOffset += 1
-
-    if (batchRows.length >= batchSize) {
-      yield {
-        headers,
-        rows: rowsToObjects(headers, batchRows, batchRows.length),
-        rowStart: batchStart,
-        nextOffset: rowOffset,
-        delimiter: stream.delimiter,
-        encoding: 'utf-8',
-      }
-      batchRows = []
-    }
-  }
-
-  if (headers && batchRows.length > 0) {
-    yield {
-      headers,
-      rows: rowsToObjects(headers, batchRows, batchRows.length),
-      rowStart: batchStart,
-      nextOffset: rowOffset,
-      delimiter: stream.delimiter,
-      encoding: 'utf-8',
-    }
-  }
-}
-
 export function parseCsvPreview(buffer: Buffer, options: ParseCsvPreviewOptions = {}): CsvPreview {
   const text = buffer.toString('utf-8')
   const delimiter = detectCsvDelimiter(text)

package/src/modules/sync_excel/lib/upload-storage.ts

@@ -1,5 +1,4 @@
-import { createReadStream, promises as fs } from 'fs'
-import { Readable } from 'stream'
+import { promises as fs } from 'fs'
 import { randomUUID } from 'crypto'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { Attachment, AttachmentPartition } from '../../attachments/data/entities'
@@ -80,24 +79,3 @@ export async function readSyncExcelUploadBuffer(
     throw error
   }
 }
-
-export async function createSyncExcelUploadReadStream(
-  attachment: Pick<Attachment, 'partitionCode' | 'storagePath' | 'storageDriver' | 'storageMetadata'>,
-): Promise<Readable> {
-  const inlineCsvBase64 = attachment.storageMetadata?.inlineCsvBase64
-
-  try {
-    const absolutePath = resolveAttachmentAbsolutePath(
-      attachment.partitionCode,
-      attachment.storagePath,
-      attachment.storageDriver,
-    )
-    await fs.access(absolutePath)
-    return createReadStream(absolutePath)
-  } catch (error) {
-    if (typeof inlineCsvBase64 === 'string' && inlineCsvBase64.length > 0) {
-      return Readable.from([Buffer.from(inlineCsvBase64, 'base64')])
-    }
-    throw error
-  }
-}

package/src/modules/workflows/frontend/checkout-demo/page.tsx

@@ -389,9 +389,20 @@ export default function CheckoutDemoPage() {
             currencyCode: selectedCurrency || 'USD', // Ensure currency is always set
             kind: 'product' as const,
             productId: item.id,
-            lineDescription: item.name,
+            name: item.name,
             unitPriceGross: item.price,
           })),
+          // Fold the demo's shipping and tax into order-level adjustments so the
+          // created order's grand total matches the cart total shown to the user
+          // (line items alone only cover the product subtotal).
+          orderAdjustments: [
+            ...(shipping > 0
+              ? [{ kind: 'shipping' as const, label: 'Shipping', currencyCode: selectedCurrency || 'USD', amountGross: shipping }]
+              : []),
+            ...(tax > 0
+              ? [{ kind: 'tax' as const, label: 'Tax', currencyCode: selectedCurrency || 'USD', amountGross: tax }]
+              : []),
+          ],
           itemCount: demoCart.reduce((sum, item) => sum + item.quantity, 0),
           subtotal: subtotal,
           tax: tax,

package/src/modules/workflows/lib/activity-executor.ts

@@ -929,8 +929,28 @@ export async function executeCallApi(
   // 3. Import the one-time API key helper
   const { withOnetimeApiKey } = await import('../../api_keys/services/apiKeyService')
 
-  // 4. Get EntityManager from container (for correct type)
-  const apiKeyEm = container.resolve<PostgreSqlEntityManager>('em')
+  // 4. Create the one-time API key on an EntityManager that is fully detached
+  //    from the surrounding request/transaction context.
+  //
+  //    CALL_API runs inside `workflowExecutor.executeWorkflow()`, which wraps
+  //    the whole execution in `em.transactional(...)`. The request EM is forked
+  //    with `useContext: true`, so while that transaction is open, EVERY
+  //    operation on the container's `em` — including this API key's
+  //    persist/flush — is transparently redirected to the uncommitted
+  //    transaction fork (MikroORM `getContext()` → `TransactionContext`). The
+  //    key would therefore stay invisible until the transaction commits, but
+  //    the commit cannot happen until this activity returns. The outbound
+  //    self-authenticated `fetch` below opens a SEPARATE DB connection that
+  //    cannot see the uncommitted row, so the internal API responds `401` and
+  //    the activity fails (issue #4202).
+  //
+  //    Forking with `useContext: false` (matching the query_index/webhooks
+  //    isolated-EM convention) gives the key its own pooled connection with
+  //    autocommit, so it is committed and visible to the internal request
+  //    immediately.
+  const apiKeyEm = container
+    .resolve<PostgreSqlEntityManager>('em')
+    .fork({ clear: true, freshEventManager: true, useContext: false }) as PostgreSqlEntityManager
 
   // 5. Resolve the roles that the one-time API key will inherit.
   //

package/src/modules/workflows/lib/find-definition.ts

@@ -80,9 +80,17 @@ export async function findWorkflowDefinition(
   // so disabled code workflows aren't silently executable.
   if (version === undefined && !codeDef.enabled) return null
 
+  return buildVirtualCodeDefinition(codeDef, tenantId, organizationId)
+}
+
+function buildVirtualCodeDefinition(
+  codeDef: NonNullable<ReturnType<typeof getCodeWorkflow>>,
+  tenantId: string,
+  organizationId: string,
+): WorkflowDefinition {
   // Construct a virtual WorkflowDefinition object (not persisted)
   const virtual = new WorkflowDefinition()
-  virtual.id = codeWorkflowUuid(workflowId)
+  virtual.id = codeWorkflowUuid(codeDef.workflowId)
   virtual.workflowId = codeDef.workflowId
   virtual.workflowName = codeDef.workflowName
   virtual.description = codeDef.description ?? null
@@ -98,3 +106,47 @@ export async function findWorkflowDefinition(
 
   return virtual
 }
+
+/**
+ * Resolve a virtual code definition for an already-started instance whose
+ * `definitionId` does not exist in the database.
+ *
+ * Instances started from a virtual code definition persist the deterministic
+ * `codeWorkflowUuid(workflowId)` as their `definitionId`. Runtime handlers
+ * (step/transition/signal/timer/task) load definitions by that id, so without
+ * this fallback an unpersisted code workflow starts but can never advance.
+ *
+ * The UUID equality gate ensures the fallback never substitutes the code
+ * definition for a hard-deleted persisted row: those rows have their own
+ * random UUIDs that can never match the deterministic code UUID.
+ */
+export function resolveCodeDefinitionForInstance(instance: {
+  definitionId: string
+  workflowId: string
+  tenantId: string
+  organizationId: string
+}): WorkflowDefinition | null {
+  const codeDef = getCodeWorkflow(instance.workflowId)
+  if (!codeDef) return null
+  if (codeWorkflowUuid(instance.workflowId) !== instance.definitionId) return null
+  return buildVirtualCodeDefinition(codeDef, instance.tenantId, instance.organizationId)
+}
+
+/**
+ * Find the definition backing a workflow instance: database row by id first,
+ * falling back to the in-memory code registry for instances started from an
+ * unpersisted code definition.
+ */
+export async function findDefinitionForInstance(
+  em: EntityManager,
+  instance: {
+    definitionId: string
+    workflowId: string
+    tenantId: string
+    organizationId: string
+  },
+): Promise<WorkflowDefinition | null> {
+  const dbDef = await em.findOne(WorkflowDefinition, { id: instance.definitionId })
+  if (dbDef) return dbDef
+  return resolveCodeDefinitionForInstance(instance)
+}

package/src/modules/workflows/lib/signal-handler.ts

@@ -13,6 +13,7 @@ import type * as eventLoggerModule from './event-logger'
 import type * as stepHandlerModule from './step-handler'
 import type * as transitionHandlerModule from './transition-handler'
 import type * as workflowExecutorModule from './workflow-executor'
+import { resolveCodeDefinitionForInstance } from './find-definition'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('workflows')
@@ -95,13 +96,13 @@ export async function sendSignal(
   // Branch-scoped signal: a FORKED instance routes the signal to the branch
   // paused at a matching WAIT_FOR_SIGNAL step.
   if (instance.status === 'FORKED') {
-    const branchDefinition = await findOneWithDecryption(
+    const branchDefinition = (await findOneWithDecryption(
       em as PostgreSqlEntityManager,
       WorkflowDefinition,
       { id: instance.definitionId, tenantId: instance.tenantId, organizationId: instance.organizationId, deletedAt: null },
       undefined,
       { tenantId: instance.tenantId, organizationId: instance.organizationId },
-    )
+    )) ?? resolveCodeDefinitionForInstance(instance)
     if (!branchDefinition) {
       throw new SignalError('Workflow definition not found', 'DEFINITION_NOT_FOUND', { definitionId: instance.definitionId })
     }
@@ -173,7 +174,7 @@ export async function sendSignal(
   }
 
   // Load workflow definition with tenant/org scope to check current step
-  const definition = await findOneWithDecryption(
+  const definition = (await findOneWithDecryption(
     em as PostgreSqlEntityManager,
     WorkflowDefinition,
     {
@@ -184,7 +185,7 @@ export async function sendSignal(
     },
     undefined,
     { tenantId: instance.tenantId, organizationId: instance.organizationId },
-  )
+  )) ?? resolveCodeDefinitionForInstance(instance)
   if (!definition) {
     throw new SignalError(
       'Workflow definition not found',

package/src/modules/workflows/lib/step-handler.ts

@@ -13,7 +13,6 @@ import { EntityManager } from '@mikro-orm/core'
 import {
   WorkflowInstance,
   WorkflowBranchInstance,
-  WorkflowDefinition,
   StepInstance,
   UserTask,
   WorkflowEvent,
@@ -22,6 +21,7 @@ import {
 } from '../data/entities'
 import { parseDuration } from './duration'
 import { logWorkflowEvent } from './event-logger'
+import { findDefinitionForInstance } from './find-definition'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('workflows')
@@ -76,9 +76,7 @@ export async function enterStep(
   branch?: WorkflowBranchInstance | null
 ): Promise<StepInstance> {
   // Load workflow definition to get step details
-  const definition = await em.findOne(WorkflowDefinition, {
-    id: instance.definitionId,
-  })
+  const definition = await findDefinitionForInstance(em, instance)
 
   if (!definition) {
     throw new StepExecutionError(
@@ -213,9 +211,7 @@ export async function executeStep(
     const stepInstance = await enterStep(em, instance, stepId, context, branch)
 
     // Load workflow definition to get step configuration
-    const definition = await em.findOne(WorkflowDefinition, {
-      id: instance.definitionId,
-    })
+    const definition = await findDefinitionForInstance(em, instance)
 
     if (!definition) {
       throw new StepExecutionError(
@@ -359,7 +355,7 @@ async function executeStepByType(
           { stepType, stepId: stepDef.stepId }
         )
       }
-      const definition = await em.findOne(WorkflowDefinition, { id: instance.definitionId })
+      const definition = await findDefinitionForInstance(em, instance)
       if (!definition) {
         throw new StepExecutionError(
           `Workflow definition not found: ${instance.definitionId}`,

package/src/modules/workflows/lib/task-handler.ts

@@ -17,9 +17,9 @@ import {
   WorkflowInstance,
   WorkflowEvent,
   StepInstance,
-  WorkflowDefinition,
 } from '../data/entities'
 import { executeWorkflow } from './workflow-executor'
+import { findDefinitionForInstance } from './find-definition'
 import * as stepHandler from './step-handler'
 import * as transitionHandler from './transition-handler'
 import { createLogger } from '@open-mercato/shared/lib/logger'
@@ -191,9 +191,7 @@ export async function completeUserTask(
   const currentStepId = instance.currentStepId
 
   // Load workflow definition to find transitions
-  const definition = await em.findOne(WorkflowDefinition, {
-    id: instance.definitionId,
-  })
+  const definition = await findDefinitionForInstance(em, instance)
 
   if (!definition) {
     throw new UserTaskError(

package/src/modules/workflows/lib/timer-handler.ts

@@ -14,6 +14,7 @@ import type * as eventLoggerModule from './event-logger'
 import type * as stepHandlerModule from './step-handler'
 import type * as transitionHandlerModule from './transition-handler'
 import type * as workflowExecutorModule from './workflow-executor'
+import { resolveCodeDefinitionForInstance } from './find-definition'
 
 export interface FireTimerOptions {
   instanceId: string
@@ -110,7 +111,7 @@ export async function fireTimer(
     )
   }
 
-  const definition = await findOneWithDecryption(
+  const definition = (await findOneWithDecryption(
     em as PostgreSqlEntityManager,
     WorkflowDefinition,
     {
@@ -121,7 +122,7 @@ export async function fireTimer(
     },
     undefined,
     { tenantId: instance.tenantId, organizationId: instance.organizationId },
-  )
+  )) ?? resolveCodeDefinitionForInstance(instance)
   if (!definition) {
     throw new TimerError(
       'Workflow definition not found',

package/src/modules/workflows/lib/transition-handler.ts

@@ -15,7 +15,6 @@ import type { AwilixContainer } from 'awilix'
 import type { EventBus } from '@open-mercato/events'
 import {
   WorkflowInstance,
-  WorkflowDefinition,
   WorkflowEvent,
 } from '../data/entities'
 import * as ruleEvaluator from '../../business_rules/lib/rule-evaluator'
@@ -23,6 +22,7 @@ import * as ruleEngine from '../../business_rules/lib/rule-engine'
 import * as activityExecutor from './activity-executor'
 import type { ActivityDefinition } from './activity-executor'
 import * as stepHandler from './step-handler'
+import { findDefinitionForInstance } from './find-definition'
 import {
   type ExecutionToken,
   rootToken,
@@ -116,9 +116,7 @@ export async function evaluateTransition(
 
   try {
     // Load workflow definition
-    const definition = await em.findOne(WorkflowDefinition, {
-      id: instance.definitionId,
-    })
+    const definition = await findDefinitionForInstance(em, instance)
 
     if (!definition) {
       return {
@@ -227,9 +225,7 @@ export async function findValidTransitions(
 ): Promise<TransitionEvaluationResult[]> {
   try {
     // Load workflow definition
-    const definition = await em.findOne(WorkflowDefinition, {
-      id: instance.definitionId,
-    })
+    const definition = await findDefinitionForInstance(em, instance)
 
     if (!definition) {
       return []
@@ -752,9 +748,7 @@ async function evaluatePreConditions(
 ): Promise<ruleEngine.RuleEngineResult> {
   try {
     // Load workflow definition to get workflow ID
-    const definition = await em.findOne(WorkflowDefinition, {
-      id: instance.definitionId,
-    })
+    const definition = await findDefinitionForInstance(em, instance)
 
     if (!definition) {
       return {
@@ -881,9 +875,7 @@ async function evaluatePostConditions(
 ): Promise<ruleEngine.RuleEngineResult> {
   try {
     // Load workflow definition to get workflow ID
-    const definition = await em.findOne(WorkflowDefinition, {
-      id: instance.definitionId,
-    })
+    const definition = await findDefinitionForInstance(em, instance)
 
     if (!definition) {
       return {

package/src/modules/workflows/lib/workflow-executor.ts

@@ -19,7 +19,7 @@ import {
   type WorkflowInstanceStatus,
 } from '../data/entities'
 import { compensateWorkflow } from './compensation-handler'
-import { findWorkflowDefinition } from './find-definition'
+import { findWorkflowDefinition, findDefinitionForInstance } from './find-definition'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('workflows')
@@ -278,9 +278,7 @@ export async function executeWorkflow(
         )
       }
 
-      const definition = await trx.findOne(WorkflowDefinition, {
-        id: instance.definitionId,
-      })
+      const definition = await findDefinitionForInstance(trx, instance)
 
       if (!definition) {
         throw new WorkflowExecutionError(
@@ -614,7 +612,7 @@ export async function completeWorkflow(
 
   // Trigger compensation if workflow failed and has compensatable activities (Phase 8.2)
   if (status === 'FAILED') {
-    const definition = await em.findOne(WorkflowDefinition, { id: instance.definitionId })
+    const definition = await findDefinitionForInstance(em, instance)
 
     if (definition && checkIfCompensationNeeded(definition)) {
       try {
@@ -836,9 +834,14 @@ export async function resumeWorkflowAfterActivities(
       fromStepId: instance.currentStepId,
     })
 
-    const definition = await trx.findOneOrFail(WorkflowDefinition, {
-      id: instance.definitionId,
-    })
+    const definition = await findDefinitionForInstance(trx, instance)
+    if (!definition) {
+      throw new WorkflowExecutionError(
+        `Workflow definition not found: ${instance.definitionId}`,
+        'DEFINITION_NOT_FOUND',
+        { definitionId: instance.definitionId }
+      )
+    }
 
     const step = definition.definition.steps.find(s => s.stepId === pendingTransition.toStepId)