@commercetools-frontend-extensions/operations 0.0.0

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

@@ -0,0 +1,104 @@
+import type {
+  ImportContainerPagedResponse,
+  ImportContainer,
+  ImportContainerDraft,
+} from '@commercetools/importapi-sdk'
+import { hasRequiredFields } from './shared'
+import { type DecimalSeparator } from './file-upload'
+import {
+  type ExtendedImportSummary,
+  type ImportSummary,
+} from './import-summary'
+import { type ImportStates } from './import-states'
+
+export function assertImportContainerPagedResponse(
+  maybeImportContainerPagedResponse: unknown
+): asserts maybeImportContainerPagedResponse is ImportContainerPagedResponse {
+  const requiredFields = ['count', 'results']
+  if (hasRequiredFields(maybeImportContainerPagedResponse, requiredFields))
+    return
+  throw new Error('Invalid response')
+}
+
+export function assertImportSummary(
+  maybeImportSummary: unknown
+): asserts maybeImportSummary is ExtendedImportSummary {
+  const requiredFields = ['states', 'total']
+  if (hasRequiredFields(maybeImportSummary, requiredFields)) return
+  throw new Error('Invalid response')
+}
+
+export function assertImportContainer(
+  maybeImportContainerResponse: unknown
+): asserts maybeImportContainerResponse is ImportContainer {
+  const requiredFields = ['key', 'version']
+  if (hasRequiredFields(maybeImportContainerResponse, requiredFields)) return
+  throw new Error('Invalid response')
+}
+
+export type CancelContainerResponse = {
+  message: string
+}
+
+export function assertCancelContainerResponse(
+  maybeCancelContainerResponse: unknown
+): asserts maybeCancelContainerResponse is CancelContainerResponse {
+  if (
+    typeof maybeCancelContainerResponse === 'object' &&
+    maybeCancelContainerResponse !== null
+  ) {
+    const responseData = maybeCancelContainerResponse as Record<string, unknown>
+    if (typeof responseData.message === 'string') {
+      return
+    }
+  }
+  throw new Error('Invalid response')
+}
+
+export type ImportContainerQueryParams = {
+  limit?: number
+  offset?: number
+  sort?: string
+  tags?: string
+}
+
+// Extended types to support settings that aren't in the base SDK yet
+export interface ExtendedImportContainer extends ImportContainer {
+  settings?: {
+    resourceType?: string
+    format?: string
+    decimalSeparator?: DecimalSeparator
+    options?: {
+      publishAllChanges?: boolean
+      unpublishAllChanges?: boolean
+    }
+  }
+  tags?: string[]
+}
+
+export interface ExtendedImportContainerDraft extends ImportContainerDraft {
+  settings?: {
+    resourceType?: string
+    format?: string
+    decimalSeparator?: DecimalSeparator
+    options?: {
+      publishAllChanges?: boolean
+      unpublishAllChanges?: boolean
+    }
+  }
+  tags?: string[]
+}
+
+export type ImportContainerDetails = {
+  importContainer: ExtendedImportContainer
+  importState: ImportStates
+  importSummary: ImportSummary
+  isFileUploadImport: boolean
+}
+
+export type ImportSummaries = {
+  results: Array<Promise<ImportContainerDetails>>
+  count: number
+  total: number
+  queryParams: ImportContainerQueryParams
+}

package/src/@types/import-operation.ts

@@ -0,0 +1,31 @@
+import type {
+  ImportOperation,
+  ImportOperationPagedResponse,
+} from '@commercetools/importapi-sdk'
+import { hasRequiredFields } from './shared'
+
+export type ImportOperationQueryParams = {
+  limit?: number
+  offset?: number
+  state?: string | string[]
+}
+
+// TODO: Remove the temporarily extended ImportOperation when the SDK is updated
+export interface ExtendedImportOperation extends ImportOperation {
+  tags?: string[]
+}
+
+// TODO: Remove the temporarily extended ImportOperationPagedResponse when the SDK is updated
+export interface ExtendedImportOperationPagedResponse
+  extends ImportOperationPagedResponse {
+  results: ExtendedImportOperation[]
+}
+
+export function assertImportOperationPagedResponse(
+  maybeImportOperationPagedResponse: unknown
+): asserts maybeImportOperationPagedResponse is ExtendedImportOperationPagedResponse {
+  const requiredFields = ['count', 'total', 'results']
+  if (hasRequiredFields(maybeImportOperationPagedResponse, requiredFields))
+    return
+  throw new Error('Invalid response')
+}

package/src/@types/import-states.ts

@@ -0,0 +1,9 @@
+export enum ImportStates {
+  Processing = 'processing',
+  WaitForUnresolvedReferences = 'wait-for-unresolved-references',
+  PartiallyCompleted = 'partially-completed',
+  Failed = 'failed',
+  SuccessfullyCompleted = 'successfully-completed',
+  NoRunningImports = 'no-running-imports',
+  Canceled = 'canceled',
+}

package/src/@types/import-summary.ts

@@ -0,0 +1,22 @@
+import type {
+  OperationStates,
+  ImportSummary,
+} from '@commercetools/importapi-sdk'
+
+interface ExtendedOperationStates extends OperationStates {
+  /**
+   * The number of resources in the `canceled` state.
+   */
+  readonly canceled: number
+  /**
+   * The number of resources in the `deleted` state.
+   */
+  readonly deleted: number
+}
+
+export interface ExtendedImportSummary extends ImportSummary {
+  readonly states: ExtendedOperationStates
+}
+
+// Re-export as ImportSummary for convenience
+export { type ExtendedImportSummary as ImportSummary }

package/src/@types/index.ts

@@ -0,0 +1,9 @@
+export * from './api'
+export * from './basic-error-data-type'
+export * from './export-operation'
+export * from './file-upload'
+export * from './import-container'
+export * from './import-operation'
+export * from './import-states'
+export * from './import-summary'
+export * from './shared'

package/src/@types/shared.ts

@@ -0,0 +1,52 @@
+export function hasOwnProperty<X extends {}, Y extends PropertyKey>(
+  obj: X,
+  prop: Y
+): obj is X & Record<Y, unknown> {
+  return typeof obj === 'object' && obj !== null && obj.hasOwnProperty(prop)
+}
+
+export function hasRequiredFields(
+  maybeValidObject: unknown,
+  requiredFields: Array<string>
+): boolean {
+  return (
+    typeof maybeValidObject === 'object' &&
+    maybeValidObject !== null &&
+    requiredFields.every((property) =>
+      hasOwnProperty(maybeValidObject, property)
+    )
+  )
+}
+
+export function getMissingRequiredFields(
+  maybeValidObject: unknown,
+  requiredFields: Array<string>
+): string[] | false {
+  return (
+    typeof maybeValidObject === 'object' &&
+    maybeValidObject !== null &&
+    requiredFields.filter((property) => !(property in maybeValidObject))
+  )
+}
+
+export function isError(maybeError: unknown): maybeError is Error {
+  if (maybeError instanceof Error) return true
+  return false
+}
+
+export function isAbortError(error: unknown): error is DOMException {
+  return error instanceof DOMException && error.name === 'AbortError'
+}
+
+export function isResourceType<T extends string>(
+  maybeResourceType: unknown
+): maybeResourceType is T {
+  return typeof maybeResourceType === 'string'
+}
+
+export function assertResourceType<T extends string>(
+  maybeResourceType: unknown
+): asserts maybeResourceType is T {
+  if (typeof maybeResourceType === 'string') return
+  throw new Error(`Invalid value: ${maybeResourceType}`)
+}

package/src/@utils/error-mapping.spec.ts

@@ -0,0 +1,126 @@
+import { mapUploadFileErrorsResponseToUploadFileErrorRows } from './error-mapping'
+
+type RowErrorsResponse = {
+  row?: number
+  index?: number
+  errors: Array<{ field: string; code: string; message: string }>
+}
+
+describe('mapUploadFileErrorsResponseToUploadFileErrorRows', () => {
+  it('should return an empty array if uploadFileErrorsResponse is undefined', () => {
+    const result = mapUploadFileErrorsResponseToUploadFileErrorRows(undefined)
+    expect(result).toEqual([])
+  })
+  it('should map the response errors correctly', () => {
+    const sampleErrorsResponse: Array<RowErrorsResponse> = [
+      {
+        row: 1,
+        errors: [
+          {
+            code: 'InvalidField',
+            message: '"name.de2" is not allowed',
+            field: 'name.de2',
+          },
+          {
+            code: 'InvalidField',
+            message: '"name.enn" is not allowed',
+            field: 'name.enn',
+          },
+        ],
+      },
+      {
+        row: 2,
+        errors: [
+          {
+            code: 'InvalidField',
+            message: '"slug.RU" is not allowed',
+            field: 'slug.RU',
+          },
+        ],
+      },
+    ]
+    const result =
+      mapUploadFileErrorsResponseToUploadFileErrorRows(sampleErrorsResponse)
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "InvalidField",
+          "field": "name.de2",
+          "id": "1",
+          "row": 1,
+          "validationMessage": ""name.de2" is not allowed",
+        },
+        {
+          "code": "InvalidField",
+          "field": "name.enn",
+          "id": "2",
+          "row": 1,
+          "validationMessage": ""name.enn" is not allowed",
+        },
+        {
+          "code": "InvalidField",
+          "field": "slug.RU",
+          "id": "3",
+          "row": 2,
+          "validationMessage": ""slug.RU" is not allowed",
+        },
+      ]
+    `)
+  })
+  it('should map the response errors correctly for json payload', () => {
+    const sampleErrorsResponse: Array<RowErrorsResponse> = [
+      {
+        index: 0,
+        errors: [
+          {
+            code: 'InvalidField',
+            message: '"name.de2" is not allowed',
+            field: 'name.de2',
+          },
+          {
+            code: 'InvalidField',
+            message: '"name.enn" is not allowed',
+            field: 'name.enn',
+          },
+        ],
+      },
+      {
+        index: 1,
+        errors: [
+          {
+            code: 'InvalidField',
+            message: '"slug.RU" is not allowed',
+            field: 'slug.RU',
+          },
+        ],
+      },
+    ]
+    const result =
+      mapUploadFileErrorsResponseToUploadFileErrorRows(sampleErrorsResponse)
+    expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "InvalidField",
+          "field": "name.de2",
+          "id": "1",
+          "index": 0,
+          "validationMessage": ""name.de2" is not allowed",
+        },
+        {
+          "code": "InvalidField",
+          "field": "name.enn",
+          "id": "2",
+          "index": 0,
+          "validationMessage": ""name.enn" is not allowed",
+        },
+        {
+          "code": "InvalidField",
+          "field": "slug.RU",
+          "id": "3",
+          "index": 1,
+          "validationMessage": ""slug.RU" is not allowed",
+        },
+      ]
+    `)
+  })
+})

package/src/@utils/error-mapping.ts

@@ -0,0 +1,39 @@
+export function getFileUploadErrorsCount(
+  errors?: Array<{ errors: Array<unknown> }>
+): number {
+  if (!errors || !Array.isArray(errors)) return 0
+  return errors.reduce((acc, curr) => (acc += curr.errors.length), 0)
+}
+
+export function mapUploadFileErrorsResponseToUploadFileErrorRows(
+  uploadFileErrorsResponse?: Array<{
+    row?: number
+    index?: number
+    errors: Array<{ field: string; code: string; message: string }>
+  }>
+): Array<{
+  id: string
+  row?: number
+  index?: number
+  field: string
+  code: string
+  validationMessage: string
+}> {
+  if (!uploadFileErrorsResponse || !Array.isArray(uploadFileErrorsResponse))
+    return []
+  let idCounter = 1
+  return uploadFileErrorsResponse.flatMap((rowErrorsResponse) =>
+    rowErrorsResponse.errors.map((rowError) => ({
+      id: String(idCounter++),
+      ...(rowErrorsResponse.row !== undefined
+        ? { row: rowErrorsResponse.row }
+        : {}),
+      ...(rowErrorsResponse.index !== undefined
+        ? { index: rowErrorsResponse.index }
+        : {}),
+      field: rowError.field,
+      code: rowError.code,
+      validationMessage: rowError.message,
+    }))
+  )
+}

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

@@ -0,0 +1,151 @@
+import { act } from '@testing-library/react'
+import { validateDelimiter, getRowCount } from './file-upload'
+import { COLUMN_DELIMITERS } from '../@constants'
+
+const createFakeFile = (content: string) => {
+  const blob = new Blob([content], { type: 'text/csv' })
+  return new File([blob], 'test.csv', {
+    type: 'text/csv',
+  })
+}
+
+describe('validateDelimiter', () => {
+  it('returns true for an allowed delimiter ","', async () => {
+    const fileContent =
+      'key,externalId,orderHint,name.de\nsample-category-key,sample-category-external-id,0.5,sample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(true)
+  })
+  it('returns true for an allowed delimiter ";"', async () => {
+    const fileContent =
+      'key;externalId;orderHint;name.de\nsample-category-key;sample-category-external-id;0.5;sample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(true)
+  })
+  it('returns true for an allowed delimiter "|"', async () => {
+    const fileContent =
+      'key|externalId|orderHint|name.de\nsample-category-key|sample-category-external-id|0.5|sample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(true)
+  })
+  it('returns true for an allowed delimiter "\\t"', async () => {
+    const fileContent =
+      'key\texternalId\torderHint\tname.de\nsample-category-key\tsample-category-external-id\t0.5\tsample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(true)
+  })
+  it('returns false for a non-allowed delimiter "."', async () => {
+    const fileContent =
+      'key.externalId.orderHint.name.de\nsample-category-key.sample-category-external-id.0.5.sample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(false)
+  })
+  it('returns false for a non-allowed delimiter " "', async () => {
+    const fileContent =
+      'key externalId orderHint name.de\nsample-category-key sample-category-external-id 0.5 sample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(false)
+  })
+  it('returns false for a non-allowed delimiter "%"', async () => {
+    const fileContent =
+      'key%externalId%orderHint%name.de\nsample-category-key%sample-category-external-id%0.5%sample-category-name-de'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(false)
+  })
+  it('returns true for a single-column file', async () => {
+    const fileContent = 'key'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(true)
+  })
+  it('returns false for a file with undetectable delimiter', async () => {
+    const fileContent =
+      'key.externalId.orderHint.name\nvalue1.value2.value3.value4'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(false)
+  })
+  it('returns false for a file with a non allowed column delimiter', async () => {
+    const fileContent =
+      'key externalId orderHint name\nvalue1 value2 value3 value4'
+    const file = createFakeFile(fileContent)
+    let result: boolean = false
+    await act(async () => {
+      result = await validateDelimiter(file, COLUMN_DELIMITERS)
+    })
+    expect(result).toBe(false)
+  })
+})
+
+describe('getRowCount', () => {
+  it('returns count > 1 for a file with a header and at least one data row', async () => {
+    const fileContent = 'header1,header2\nsample-cell1,sample-cell2'
+    const file = createFakeFile(fileContent)
+    let rowCount: number
+    await act(async () => {
+      rowCount = await getRowCount(file)
+    })
+    expect(rowCount!).toBeGreaterThanOrEqual(1)
+  })
+  it('returns count of 0 for a file with only a header', async () => {
+    const fileContent = 'header1,header2'
+    const file = createFakeFile(fileContent)
+    let rowCount: number
+    await act(async () => {
+      rowCount = await getRowCount(file)
+    })
+    expect(rowCount!).toBe(0)
+  })
+  it('returns count of 0 for a file with only a header and empty line', async () => {
+    const fileContent = 'header1,header2\n'
+    const file = createFakeFile(fileContent)
+    let rowCount: number
+    await act(async () => {
+      rowCount = await getRowCount(file)
+    })
+    expect(rowCount!).toBe(0)
+  })
+  it('returns count of 0 for an empty file', async () => {
+    const fileContent = ''
+    const file = createFakeFile(fileContent)
+    let rowCount: number
+    await act(async () => {
+      rowCount = await getRowCount(file)
+    })
+    expect(rowCount!).toBe(0)
+  })
+})

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

@@ -0,0 +1,150 @@
+import Papa from 'papaparse'
+
+/**
+ * Convert megabytes to bytes
+ */
+export const toBytes = (megabytes: number): number => megabytes * 1024 * 1024
+
+/**
+ * Returns the number of rows in a CSV file excluding the header
+ * @param file The CSV file to process
+ * @returns A promise that resolves to the number of rows
+ */
+export const getRowCount = (file: File): Promise<number> => {
+  return new Promise((resolve) => {
+    let lineCount = 0
+    Papa.parse(file, {
+      step: ({ data }: { data: unknown[] }) => {
+        // empty lines at the end of the file should not be counted
+        if (Array.isArray(data) && data.find(Boolean)) lineCount++
+      },
+      complete: () => {
+        // Subtract 1 for the header row
+        // We use Math.max to make sure the count is not less than 0, this is needed for empty files
+        resolve(Math.max(0, lineCount - 1))
+      },
+    })
+  })
+}
+
+/**
+ * Check if a CSV file has a single key column
+ * @param file The CSV file to check
+ * @returns A promise that resolves to true if the file has only one column named 'key'
+ */
+export const hasSingleKeyColumn = (file: File): Promise<boolean> => {
+  return new Promise((resolve) => {
+    Papa.parse(file, {
+      preview: 1,
+      complete: (result) => {
+        const headerRow = result.data?.[0]
+        const hasSingleColumn =
+          Array.isArray(headerRow) && headerRow.length === 1
+        const isKeyColumn =
+          hasSingleColumn && headerRow[0].toLowerCase() === 'key'
+        resolve(isKeyColumn)
+      },
+    })
+  })
+}
+
+/**
+ * Validate delimiter in a CSV file
+ * @param file The CSV file to validate
+ * @param allowedDelimiters Array of allowed delimiters
+ * @returns A promise that resolves to false if delimiter is invalid
+ */
+export const validateDelimiter = (
+  file: File,
+  allowedDelimiters: string[]
+): Promise<boolean> => {
+  // Delimiters not included in this array may be treated as part of a column content
+  // potentially causing the file to be parsed as a single-column CSV and pass this validation
+  const NON_ALLOWED_COLUMN_DELIMITERS = ['%', '.', ' ']
+  const DELIMITERS_TO_GUESS = [
+    ...allowedDelimiters,
+    ...NON_ALLOWED_COLUMN_DELIMITERS,
+  ]
+
+  return new Promise((resolve) => {
+    Papa.parse<unknown[]>(file, {
+      delimitersToGuess: DELIMITERS_TO_GUESS,
+      preview: 10,
+      complete: (result) => {
+        const headerRow = result.data?.[0]
+        const isOnlyOneColumn =
+          Array.isArray(headerRow) && headerRow.length === 1
+
+        if (isOnlyOneColumn) {
+          resolve(true)
+          return
+        }
+
+        const detectedDelimiter = result.meta.delimiter
+        let isValid = false
+
+        if (
+          detectedDelimiter !== null &&
+          allowedDelimiters.includes(detectedDelimiter)
+        ) {
+          const isUndetectableDelimiter = result.errors.some(
+            (error) => error.code === 'UndetectableDelimiter'
+          )
+          if (!isUndetectableDelimiter) {
+            isValid = true
+          }
+        }
+        resolve(isValid)
+      },
+    })
+  })
+}
+
+/**
+ * Returns columns from the provided `columns` excluding those specified in the `ignoredColumns`
+ */
+export const getValidatedColumns = (
+  columns: string[],
+  ignoredColumns: string[]
+): string[] => {
+  return columns.filter((column) => !ignoredColumns.includes(column))
+}
+
+/**
+ * Count items in a JSON file
+ * @param file The JSON file to process
+ * @returns Object with isValid flag and optional itemsCount
+ */
+export const countJsonFileItems = async (
+  file: File
+): Promise<{ isValid: false } | { isValid: true; itemsCount: number }> => {
+  const jsonContent = await file.text()
+  try {
+    const content = JSON.parse(jsonContent)
+    const isValid = Array.isArray(content)
+    if (isValid) {
+      return { isValid, itemsCount: content.length }
+    }
+    return { isValid }
+  } catch {
+    return { isValid: false }
+  }
+}
+
+/**
+ * Map file upload errors to upload file error rows with unique IDs
+ * @param uploadFileErrors Array of file upload errors
+ * @returns Array of upload file errors with unique id field
+ */
+export const mapFileUploadErrorsToUploadFileErrorRows = <
+  T extends Record<string, unknown>
+>(
+  uploadFileErrors: T[]
+): Array<T & { id: string }> => {
+  let idCounter = 1
+  return uploadFileErrors.map((uploadFileError) => ({
+    // DataTable component requires unique `id` field
+    ...uploadFileError,
+    id: String(idCounter++),
+  }))
+}