Use the Import API

import com.commercetools.importapi.client.ProjectApiRoot;
import com.commercetools.importapi.defaultconfig.ImportApiRootBuilder;
import com.commercetools.importapi.defaultconfig.ServiceRegion;
import io.vrap.rmf.base.client.oauth2.*;

public class ImportClientBuilder {
  public static ProjectApiRoot createImportApiClient() {
    final ProjectApiRoot importApiRoot = ImportApiRootBuilder.of()
      .defaultClient(ClientCredentials.of()
        .withClientId("{clientId}")
        .withClientSecret("{clientSecret}")
        .withScopes("{scopes}")
      .build(),ServiceRegion.GCP_EUROPE_WEST1)
    .build("{projectKey}");

    return importApiRoot;
  }
}

import fetch from 'node-fetch';
import { ClientBuilder } from '@commercetools/ts-client';
import 'dotenv/config';
import { createApiBuilderFromCtpClient } from '@commercetools/importapi-sdk';

// --- Configuration ---
const projectKey = process.env.CTP_PROJECT_KEY;
const clientId = process.env.CTP_CLIENT_ID;
const clientSecret = process.env.CTP_CLIENT_SECRET;
const authUrl = process.env.CTP_AUTH_URL;
const importApiUrl = process.env.CTP_IMPORT_API_URL;
const scopes = [];

// --- Middleware Functions ---

// Function for custom header middleware
function createCustomHeaderMiddleware() {
  return (next) => (request) => {
    return next({
      ...request,
      headers: {
        ...request.headers,
        'accept-language': 'en-AU',
      },
    });
  };
}

// Function for custom logger middleware
const customLoggerMiddleware = {
  logLevel: 'debug',
  httpMethods: ['POST', 'GET'],
  maskSensitiveData: true,
  logger: (method, ...args) => {
    console.log(`[CUSTOM LOGGER] ${method}`, ...args);
  },
};

// --- Middleware Options ---

// Auth Middleware Options
const authMiddlewareOptions = {
  host: authUrl,
  projectKey: projectKey,
  credentials: { clientId, clientSecret },
  scopes: scopes,
  httpClient: fetch,
};

// Http Middleware Options
const httpMiddlewareOptions = {
  host: importApiUrl,
  includeResponseHeaders: true,
  maskSensitiveHeaderData: true,
  includeOriginalRequest: true,
  includeRequestInErrorResponse: true,
  enableRetry: true,
  retryConfig: {
    maxRetries: 3,
    retryDelay: 200,
    backoff: false,
    retryCodes: [500, 503],
  },
  httpClient: fetch,
};

// Correlation ID Middleware Options
const correlationIdMiddlewareOptions = {
  // Replace with your own UUID, ULID, or a generator function. Do not use this example in production!
  generate: () => 'cd260fc9-c575-4ba3-8789-cc4c9980ee4e',
};

// Concurrent Modification Middleware Options
const concurrentModificationMiddlewareOptions = {
  concurrentModificationHandlerFn: (version, request) => {
    console.log(`Concurrent modification error, retry with version ${version}`);
    request.body.version = version;
    return JSON.stringify(request.body);
  },
};

// --- Optional Telemetry Middleware (Commented Out) ---
/*
const telemetryOptions = {
  createTelemetryMiddleware,
  apm: () => typeof require('newrelic'),
  tracer: () => typeof require('/absolute-path-to-a-tracer-module'),
};
*/

// --- Client Creation ---
const client = new ClientBuilder()
  .withProjectKey(projectKey)
  .withClientCredentialsFlow(authMiddlewareOptions)
  .withLoggerMiddleware(customLoggerMiddleware)
  .withCorrelationIdMiddleware(correlationIdMiddlewareOptions)
  .withMiddleware(createCustomHeaderMiddleware())
  .withHttpMiddleware(httpMiddlewareOptions)
  .withConcurrentModificationMiddleware(concurrentModificationMiddlewareOptions)
  // .withTelemetryMiddleware(telemetryOptions)
  .build();

// --- API Root Creation ---
const apiRootImport = createApiBuilderFromCtpClient(client).withProjectKeyValue(
  { projectKey }
);

export { apiRootImport };