@commercetools-frontend-extensions/operations 2.0.1 → 3.1.0

package/src/@utils/file-import-job-helpers.spec.ts

@@ -0,0 +1,147 @@
+import type { ResourceTypeId } from '@commercetools/importapi-sdk'
+import type { FileImportJob } from '../@types'
+import {
+  getFileImportJobFileType,
+  isImportJobQueued,
+  isImportJobProcessing,
+  isImportJobValidated,
+  isImportJobInitializing,
+  isImportJobReady,
+  shouldContinuePollingForImportValidation,
+} from './file-import-job-helpers'
+
+describe('file-import-job-helpers', () => {
+  describe('getFileImportJobFileType', () => {
+    it('should return "json" for custom-object resource type', () => {
+      expect(getFileImportJobFileType('custom-object' as ResourceTypeId)).toBe(
+        'json'
+      )
+    })
+
+    it('should return "csv" for product resource type', () => {
+      expect(getFileImportJobFileType('product' as ResourceTypeId)).toBe('csv')
+    })
+
+    it('should return "csv" for category resource type', () => {
+      expect(getFileImportJobFileType('category' as ResourceTypeId)).toBe('csv')
+    })
+
+    it('should return "csv" for other resource types', () => {
+      expect(getFileImportJobFileType('price' as ResourceTypeId)).toBe('csv')
+      expect(
+        getFileImportJobFileType('inventory-entry' as ResourceTypeId)
+      ).toBe('csv')
+      expect(getFileImportJobFileType('customer' as ResourceTypeId)).toBe('csv')
+    })
+  })
+
+  const mockJob: FileImportJob = {
+    id: 'test-job-id',
+    fileName: 'test.csv',
+    importContainerKey: 'test-container',
+    state: 'validated',
+    summary: {
+      total: 100,
+      invalid: 5,
+      valid: 95,
+      fieldsCount: 10,
+      fields: ['field1', 'field2'],
+      ignoredFields: ['ignored1'],
+    },
+  }
+
+  describe('isImportJobQueued', () => {
+    it('should return true when job is queued', () => {
+      const queuedJob = { ...mockJob, state: 'queued' as const }
+      expect(isImportJobQueued(queuedJob)).toBe(true)
+    })
+
+    it('should return false when job is not queued', () => {
+      expect(isImportJobQueued(mockJob)).toBe(false)
+    })
+
+    it('should return false when job is undefined', () => {
+      expect(isImportJobQueued(undefined)).toBe(false)
+    })
+  })
+
+  describe('isImportJobProcessing', () => {
+    it('should return true when job is processing', () => {
+      const processingJob = { ...mockJob, state: 'processing' as const }
+      expect(isImportJobProcessing(processingJob)).toBe(true)
+    })
+
+    it('should return false when job is not processing', () => {
+      expect(isImportJobProcessing(mockJob)).toBe(false)
+    })
+  })
+
+  describe('isImportJobValidated', () => {
+    it('should return true when job is validated', () => {
+      expect(isImportJobValidated(mockJob)).toBe(true)
+    })
+
+    it('should return false when job is not validated', () => {
+      const processingJob = { ...mockJob, state: 'processing' as const }
+      expect(isImportJobValidated(processingJob)).toBe(false)
+    })
+
+    it('should return false when job is undefined', () => {
+      expect(isImportJobValidated(undefined)).toBe(false)
+    })
+  })
+
+  describe('isImportJobInitializing', () => {
+    it('should return true when job is initialising', () => {
+      const initialisingJob = { ...mockJob, state: 'initialising' as const }
+      expect(isImportJobInitializing(initialisingJob)).toBe(true)
+    })
+
+    it('should return false when job is not initialising', () => {
+      expect(isImportJobInitializing(mockJob)).toBe(false)
+    })
+  })
+
+  describe('isImportJobReady', () => {
+    it('should return true when job is ready', () => {
+      const readyJob = { ...mockJob, state: 'ready' as const }
+      expect(isImportJobReady(readyJob)).toBe(true)
+    })
+
+    it('should return false when job is not ready', () => {
+      expect(isImportJobReady(mockJob)).toBe(false)
+    })
+  })
+
+  describe('shouldContinuePollingForImportValidation', () => {
+    it('should return true when job is undefined', () => {
+      expect(shouldContinuePollingForImportValidation(undefined)).toBe(true)
+    })
+
+    it('should return true when job is queued', () => {
+      const queuedJob = { ...mockJob, state: 'queued' as const }
+      expect(shouldContinuePollingForImportValidation(queuedJob)).toBe(true)
+    })
+
+    it('should return true when job is processing', () => {
+      const processingJob = { ...mockJob, state: 'processing' as const }
+      expect(shouldContinuePollingForImportValidation(processingJob)).toBe(true)
+    })
+
+    it('should return false when job is validated', () => {
+      expect(shouldContinuePollingForImportValidation(mockJob)).toBe(false)
+    })
+
+    it('should return false when job is initialising', () => {
+      const initialisingJob = { ...mockJob, state: 'initialising' as const }
+      expect(shouldContinuePollingForImportValidation(initialisingJob)).toBe(
+        false
+      )
+    })
+
+    it('should return false when job is ready', () => {
+      const readyJob = { ...mockJob, state: 'ready' as const }
+      expect(shouldContinuePollingForImportValidation(readyJob)).toBe(false)
+    })
+  })
+})

package/src/@utils/file-import-job-helpers.ts

@@ -0,0 +1,47 @@
+import type { ResourceTypeId } from '@commercetools/importapi-sdk'
+import type { FileImportJob } from '../@types'
+
+export function getFileImportJobFileType(
+  resourceType: ResourceTypeId
+): 'csv' | 'json' {
+  return resourceType === 'custom-object' ? 'json' : 'csv'
+}
+
+export function toImportApiResourceType(resourceType: string): string {
+  return resourceType === 'product' ? 'product-draft' : resourceType
+}
+
+export function isImportJobQueued(job?: FileImportJob): boolean {
+  return job?.state === 'queued'
+}
+
+export function isImportJobProcessing(job?: FileImportJob): boolean {
+  return job?.state === 'processing'
+}
+
+export function isImportJobValidated(job?: FileImportJob): boolean {
+  return job?.state === 'validated'
+}
+
+export function isImportJobInitializing(job?: FileImportJob): boolean {
+  return job?.state === 'initialising'
+}
+
+export function isImportJobReady(job?: FileImportJob): boolean {
+  return job?.state === 'ready'
+}
+
+export function isImportJobRejected(job?: FileImportJob): boolean {
+  return job?.state === 'rejected'
+}
+
+export function isImportJobTerminal(job?: FileImportJob): boolean {
+  return isImportJobValidated(job) || isImportJobRejected(job)
+}
+
+export function shouldContinuePollingForImportValidation(
+  job?: FileImportJob
+): boolean {
+  if (!job) return true
+  return isImportJobQueued(job) || isImportJobProcessing(job)
+}

package/src/@utils/file-upload.ts

@@ -131,6 +131,45 @@ export const countJsonFileItems = async (
   }
 }
 
+/**
+ * Count unique resources in a CSV file by counting unique values in the "key" column.
+ * A single resource can span multiple rows (when it has array fields like variants, assets...),
+ * so we count unique keys rather than rows.
+ * @param file The CSV file to process
+ * @returns A promise that resolves to the number of unique resources
+ */
+export const countUniqueResourcesInCsv = (file: File): Promise<number> => {
+  return new Promise((resolve) => {
+    const uniqueKeys = new Set<string>()
+    let keyColumnIndex = -1
+    let isFirstRow = true
+
+    Papa.parse<string[]>(file, {
+      step: ({ data }) => {
+        if (!Array.isArray(data)) return
+
+        if (isFirstRow) {
+          keyColumnIndex = data.findIndex(
+            (col) => col?.toLowerCase().trim() === 'key'
+          )
+          isFirstRow = false
+          return
+        }
+
+        if (keyColumnIndex === -1) return
+
+        const keyValue = data[keyColumnIndex]?.trim()
+        if (keyValue) {
+          uniqueKeys.add(keyValue)
+        }
+      },
+      complete: () => {
+        resolve(uniqueKeys.size)
+      },
+    })
+  })
+}
+
 /**
  * Map file upload errors to upload file error rows with unique IDs
  * @param uploadFileErrors Array of file upload errors

package/src/@utils/index.ts

@@ -1,6 +1,8 @@
 export * from './error-mapping'
+export * from './file-import-job-helpers'
 export * from './file-upload'
 export * from './form'
 export * from './format'
 export * from './import-container'
+export * from './poll-job-until-validated'
 export * from './url'

package/src/@utils/poll-job-until-validated.ts

@@ -0,0 +1,76 @@
+import { getFileImportJob } from '../@api'
+import { PollingAbortedError } from '../@errors'
+import type { FileImportJob } from '../@types'
+import { isImportJobTerminal } from './file-import-job-helpers'
+
+export type PollJobUntilValidatedConfig = {
+  projectKey: string
+  jobId: string
+  importContainerKey: string
+  pollingInterval?: number
+  maxAttempts?: number
+  onJobUpdate?: (job: FileImportJob) => void
+  abortSignal?: AbortSignal
+}
+
+export const pollJobUntilValidated = async ({
+  projectKey,
+  jobId,
+  importContainerKey,
+  pollingInterval = 5000,
+  maxAttempts = 120,
+  onJobUpdate,
+  abortSignal,
+}: PollJobUntilValidatedConfig): Promise<FileImportJob> => {
+  let attempts = 0
+
+  while (attempts < maxAttempts) {
+    if (abortSignal?.aborted) {
+      throw new PollingAbortedError()
+    }
+
+    const job = await getFileImportJob({
+      projectKey,
+      importContainerKey,
+      jobId,
+    })
+
+    if (abortSignal?.aborted) {
+      throw new PollingAbortedError()
+    }
+
+    onJobUpdate?.(job)
+
+    if (isImportJobTerminal(job)) {
+      return job
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      let timeoutId: ReturnType<typeof setTimeout>
+
+      const onAbort = () => {
+        clearTimeout(timeoutId)
+        reject(new PollingAbortedError())
+      }
+
+      if (abortSignal?.aborted) {
+        reject(new PollingAbortedError())
+        return
+      }
+
+      timeoutId = setTimeout(() => {
+        abortSignal?.removeEventListener('abort', onAbort)
+        resolve()
+      }, pollingInterval)
+
+      abortSignal?.addEventListener('abort', onAbort)
+    })
+    attempts++
+  }
+
+  throw new Error(
+    `Job validation timeout after ${maxAttempts} attempts (${
+      (maxAttempts * pollingInterval) / 1000
+    }s)`
+  )
+}

package/dist/declarations/src/@constants/upload-limits.d.ts

@@ -1,10 +0,0 @@
-/**
- * Maximum file size for imports.
- * Recommended by backend, enforced in frontend validation.
- */
-export declare const MAX_FILE_SIZE_MB = 35;
-/**
- * Maximum row count for imports.
- * Recommended by backend, enforced in frontend validation.
- */
-export declare const MAX_ROW_COUNT = 80000;

package/src/@constants/upload-limits.ts

@@ -1,11 +0,0 @@
-/**
- * Maximum file size for imports.
- * Recommended by backend, enforced in frontend validation.
- */
-export const MAX_FILE_SIZE_MB = 35
-
-/**
- * Maximum row count for imports.
- * Recommended by backend, enforced in frontend validation.
- */
-export const MAX_ROW_COUNT = 80_000

package/src/@hooks/messages.ts

@@ -1,11 +0,0 @@
-import { defineMessages } from 'react-intl'
-
-export default defineMessages({
-  unexpectedError: {
-    id: 'operations.fetch.unexpectedError',
-    description:
-      'Generic error message displayed when an unexpected error occurs during data fetching',
-    defaultMessage:
-      'An unexpected error occurred while fetching the data. Please try again. If the problem persists, please contact support.',
-  },
-})