@commercetools-frontend-extensions/operations 0.0.0-canary-20251209161906

package/src/@utils/form.ts

@@ -0,0 +1,20 @@
+export const mapFormikErrors = (
+  error: string | string[] | undefined | Record<string, boolean>
+): Record<string, boolean> => {
+  if (typeof error === 'string') {
+    return { [error]: true }
+  }
+
+  if (Array.isArray(error)) {
+    return error.reduce(
+      (errorAggregator, currentError) => ({
+        ...errorAggregator,
+        [currentError]: true,
+      }),
+      {}
+    )
+  }
+
+  if (!error) return {}
+  return error
+}

package/src/@utils/format.spec.ts

@@ -0,0 +1,62 @@
+import { formatErrorCode, appendCsvOrJsonExtensionIfAbsent } from './format'
+
+describe('formatErrorCode', () => {
+  it('should format camel case correctly', () => {
+    expect(formatErrorCode('ReferencedResourceNotFound')).toBe(
+      'Referenced resource not found'
+    )
+  })
+  it('should handle consecutive uppercase letters correctly', () => {
+    expect(formatErrorCode('InvalidJSONInput')).toBe('Invalid JSON input')
+  })
+  it('should handle single word correctly', () => {
+    expect(formatErrorCode('Error')).toBe('Error')
+  })
+  it('should handle already formatted string correctly', () => {
+    expect(formatErrorCode('Already formatted string')).toBe(
+      'Already formatted string'
+    )
+  })
+  it('should return the original code if formatting fails', () => {
+    const invalidCode = null as any
+    expect(formatErrorCode(invalidCode)).toBe(invalidCode)
+  })
+  it('should handle empty string correctly', () => {
+    expect(formatErrorCode('')).toBe('')
+  })
+  it('should uppercase specific words correctly', () => {
+    expect(formatErrorCode('InvalidAPIResponse')).toBe('Invalid API response')
+    expect(formatErrorCode('HttpRequestFailed')).toBe('HTTP request failed')
+  })
+})
+
+describe('appendCsvOrJsonExtensionIfAbsent', () => {
+  it('should append .csv if no extension is present', () => {
+    expect(appendCsvOrJsonExtensionIfAbsent('file', 'csv')).toBe('file.csv')
+  })
+  it('should append .json if no extension is present', () => {
+    expect(appendCsvOrJsonExtensionIfAbsent('file', 'json')).toBe('file.json')
+  })
+  it('should not append .csv if .csv is already present', () => {
+    expect(appendCsvOrJsonExtensionIfAbsent('file.csv', 'csv')).toBe('file.csv')
+  })
+  it('should not append .json if .json is already present', () => {
+    expect(appendCsvOrJsonExtensionIfAbsent('file.json', 'json')).toBe(
+      'file.json'
+    )
+  })
+  it('should be case insensitive to extensions', () => {
+    expect(appendCsvOrJsonExtensionIfAbsent('file.JSON', 'json')).toBe(
+      'file.JSON'
+    )
+    expect(appendCsvOrJsonExtensionIfAbsent('file.CSV', 'csv')).toBe('file.CSV')
+  })
+  it('should append .csv or .json extension if a different extension is present', () => {
+    expect(appendCsvOrJsonExtensionIfAbsent('file.txt', 'csv')).toBe(
+      'file.txt.csv'
+    )
+    expect(appendCsvOrJsonExtensionIfAbsent('file.txt', 'json')).toBe(
+      'file.txt.json'
+    )
+  })
+})

package/src/@utils/format.ts

@@ -0,0 +1,53 @@
+export function formatErrorCode(code: string): string {
+  try {
+    const formattedCode = code
+      .replace(/([a-z])([A-Z])/g, '$1 $2')
+      .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
+      .toLowerCase()
+    let result = formattedCode.charAt(0).toUpperCase() + formattedCode.slice(1)
+
+    const specialWords = ['json', 'api', 'http']
+    specialWords.forEach((word) => {
+      const regex = new RegExp(`\\b${word}\\b`, 'gi')
+      result = result.replace(regex, word.toUpperCase())
+    })
+
+    return result
+  } catch (error) {
+    return code
+  }
+}
+
+export function extractErrorDescriptionFromValidationMessage(
+  message: string
+): string | undefined {
+  return message.split('"').pop()
+}
+
+export function formatKeys(
+  obj: Record<string, unknown>,
+  conjunction: string = 'and'
+): string {
+  if (typeof obj !== 'object' || obj === null) return ''
+  const keys = Object.keys(obj).map((key) =>
+    key.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase()
+  )
+  if (keys.length === 0) return ''
+  if (keys.length === 1) return keys[0]
+  return `${keys.slice(0, -1).join(', ')} ${conjunction} ${
+    keys[keys.length - 1]
+  }`
+}
+
+export function appendCsvOrJsonExtensionIfAbsent(
+  fileName: string,
+  fileFormat: 'csv' | 'json'
+): string {
+  const extensionRegex = /\.(csv|json)$/i
+  if (!extensionRegex.test(fileName)) return `${fileName}.${fileFormat}`
+  return fileName
+}
+
+export function convertFileSizeToKB(sizeInBytes: number): number {
+  return sizeInBytes / 1000
+}

package/src/@utils/import-container.spec.ts

@@ -0,0 +1,26 @@
+import {
+  decodeFileNameFromImportContainerKey,
+  encodeFileNameWithTimestampToContainerKey,
+} from './import-container'
+
+describe('decodeFileNameFromImportContainerKey', () => {
+  it('should decode the file name from a encoded container key', () => {
+    const fileName = 'categories.csv'
+    const encodedKey =
+      'eyJ0aW1lc3RhbXAiOiAxNzA1MDExMTQ5MTgxLCAiZmlsZU5hbWUiOiAiY2F0ZWdvcmllcy5jc3YifQ'
+    expect(decodeFileNameFromImportContainerKey(encodedKey)).toBe(fileName)
+  })
+  it('should return empty string if decoding fails', () => {
+    const invalidKey = 'notBase64Strng'
+    expect(decodeFileNameFromImportContainerKey(invalidKey)).toBe('')
+  })
+})
+describe('encodeFileNameWithTimestampToContainerKey', () => {
+  it('should encode the file name and time stamp into a container key', () => {
+    const fileName = 'products.csv'
+    const encodedKey = encodeFileNameWithTimestampToContainerKey(fileName)
+    const decoded = JSON.parse(atob(encodedKey))
+    expect(decoded.fileName).toBe(fileName)
+    expect(typeof decoded.timestamp).toBe('number')
+  })
+})

package/src/@utils/import-container.ts

@@ -0,0 +1,34 @@
+interface ImportInfo {
+  fileName: string
+  timestamp: number
+}
+
+export const encodeFileNameWithTimestampToContainerKey = (fileName: string) => {
+  return btoa(
+    JSON.stringify({
+      timestamp: new Date().getTime(),
+      fileName,
+    })
+  ).replace(/=+$/g, '')
+}
+
+/**
+ * Check if an import container is a file upload import
+ * @param tags - Array of tags from the import container
+ * @returns True if the tags indicate this is a file upload import
+ */
+export const checkIfFileUploadImport = (tags?: string[]): boolean => {
+  return tags?.some((tag) => tag.startsWith('source:file-upload')) ?? false
+}
+
+export const decodeFileNameFromImportContainerKey = (
+  importContainerKey: string
+) => {
+  try {
+    const decodedImportContainerKey = atob(importContainerKey)
+    const importInfo: ImportInfo = JSON.parse(decodedImportContainerKey)
+    return importInfo.fileName
+  } catch {
+    return ''
+  }
+}

package/src/@utils/index.ts

@@ -0,0 +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/src/@utils/url.spec.ts

@@ -0,0 +1,75 @@
+import { formatQueryString } from './url'
+
+describe('formatQueryString', () => {
+  it('should return empty string with no params', () => {
+    const queryParam: Record<string, unknown> = {}
+    expect(formatQueryString(queryParam)).toEqual('')
+  })
+
+  it('should format multiple params', () => {
+    const queryParam: Record<string, unknown> = {
+      limit: 20,
+      offset: 10,
+    }
+    expect(formatQueryString(queryParam)).toEqual('?limit=20&offset=10')
+  })
+
+  it('should handle offset zero', () => {
+    const queryParam: Record<string, unknown> = {
+      limit: 20,
+      offset: 0,
+    }
+    expect(formatQueryString(queryParam)).toEqual('?limit=20&offset=0')
+  })
+
+  it('should handle array values', () => {
+    const queryParam: Record<string, unknown> = {
+      state: ['imported', 'validationFailed'],
+    }
+    expect(formatQueryString(queryParam)).toEqual(
+      '?state=imported&state=validationFailed'
+    )
+  })
+
+  it('should handle undefined values', () => {
+    const queryParam: Record<string, unknown> = {
+      state: undefined,
+    }
+    expect(formatQueryString(queryParam)).toEqual('')
+  })
+
+  it('should handle null values', () => {
+    const queryParam: Record<string, unknown> = {
+      state: null,
+    }
+    expect(formatQueryString(queryParam)).toEqual('')
+  })
+
+  it('should handle boolean values', () => {
+    const queryParam: Record<string, unknown> = {
+      debug: true,
+      verbose: false,
+    }
+    expect(formatQueryString(queryParam)).toEqual('?debug=true&verbose=false')
+  })
+
+  it('should handle numeric values', () => {
+    const queryParam: Record<string, unknown> = {
+      limit: 100,
+      offset: 50,
+    }
+    expect(formatQueryString(queryParam)).toEqual('?limit=100&offset=50')
+  })
+
+  it('should handle mixed types', () => {
+    const queryParam: Record<string, unknown> = {
+      limit: 20,
+      offset: 10,
+      state: ['imported', 'validationFailed'],
+      debug: true,
+    }
+    expect(formatQueryString(queryParam)).toEqual(
+      '?limit=20&offset=10&state=imported&state=validationFailed&debug=true'
+    )
+  })
+})

package/src/@utils/url.ts

@@ -0,0 +1,18 @@
+/**
+ * Formats an object into a URL query string
+ * @param queryParams - Object containing query parameters
+ * @returns Formatted query string with leading '?' or empty string
+ */
+export function formatQueryString(queryParams: Record<string, unknown> = {}) {
+  const queryString = new URLSearchParams()
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value !== undefined && value !== null) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => queryString.append(key, String(v)))
+      } else {
+        queryString.append(key, String(value))
+      }
+    }
+  }
+  return queryString.toString() ? `?${queryString.toString()}` : ''
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared package for operations
+ *
+ * This package provides shared functionality for import/export operations across:
+ * - application-operations
+ * - import-resources-modal
+ * - export-resources-modal
+ * - delete-resources-modal
+ * - unpublish-products-modal
+ *
+ * Public API includes:
+ * - Hooks: useImportContainerUpload, useFetch*, etc.
+ * - Components: FileDropArea, UploadingModal, UploadSettings, etc.
+ * - Utils: File validation, error mapping, formatting, etc.
+ * - Constants: Delimiters, upload limits, resource links, etc.
+ * - Types: All TypeScript types and interfaces
+ * - Errors: Custom error classes
+ * - API: Functions for interacting with import/export APIs
+ */
+
+export * from './@api'
+export * from './@components'
+export * from './@constants'
+export * from './@errors'
+export * from './@hooks'
+export * from './@types'
+export * from './@utils'

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "baseUrl": "src"
+  },
+  "include": ["src/**/*"]
+}