@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/errorx/errorx.ts

@@ -0,0 +1,625 @@
+export interface ErrorxAdditionalOpts {
+  privateFields?: object;
+  privateMessage?: string;
+  fields?: object;
+  skipLog?: boolean;
+  cause?: Error;
+}
+
+export interface ErrorxBaseOpts {
+  message: string;
+  code: string;
+  httpErrorStatus: number;
+}
+
+export type ErrorxOpts = ErrorxBaseOpts & ErrorxAdditionalOpts;
+
+/**
+ * Errorx is a custom error class that extends the native Error class.
+ */
+export class Errorx extends Error {
+  privateFields?: object;
+  privateMessage?: string;
+  fields?: object;
+  skipLog?: boolean;
+  cause?: Error;
+
+  message: string;
+  code: string;
+  httpErrorStatus: number;
+
+  constructor(opts: ErrorxOpts) {
+    super(opts.message);
+    this.privateFields = opts.privateFields;
+    this.privateMessage = opts.privateMessage;
+    this.fields = opts.fields;
+    this.skipLog = opts.skipLog;
+    this.cause = opts.cause;
+    this.message = opts.message;
+    this.code = opts.code;
+    this.httpErrorStatus = opts.httpErrorStatus;
+
+    this.cause = opts.cause;
+    this.name = this.code;
+  }
+}
+
+/**
+ * Allows multiple Errorx objects to be grouped together into a single response. Main purposes it so combine multiple of the same response types together.
+ * For example when the provided HTTP body schema validation fails this can be used to return all schema validation errors in one HTTP response
+ */
+export class MultiErrorx extends Error {
+  public errors: Errorx[];
+  constructor(errors: Errorx[]) {
+    if (errors.length > 0) {
+      const allHaveSameStatusCode = errors.every(
+        (v) => v.httpErrorStatus === errors[0].httpErrorStatus,
+      );
+      if (!allHaveSameStatusCode) {
+        throw new Error(
+          'MultiErrorx is only allow to have errors of the same HTTP status code.',
+        );
+      }
+    }
+
+    super(errors.map((e) => e.message).join(','));
+    this.errors = errors;
+  }
+}
+
+/**
+ * AuthErrorResponse (https://docs.commercetools.com/api/errors#autherrorresponse)
+ * Represents errors related to authentication and authorization in a format conforming to the OAuth 2.0 specification.
+ * {
+ *   "statusCode": 401,
+ *   "message": "invalid_token",
+ *   "errors": [
+ *     {
+ *       "code": "invalid_token",
+ *       "message": "invalid_token"
+ *     }
+ *   ],
+ *   "error": "invalid_token"
+ * }
+ */
+export class ErrorAuthErrorResponse extends Errorx {
+  constructor(
+    message?: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+    code?: string,
+  ) {
+    super({
+      code: code || 'invalid_token',
+      httpErrorStatus: 401,
+      message: message || 'Authentication error.',
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * General (https://docs.commercetools.com/api/errors#general)
+ * Returned when a server-side problem occurs.
+ */
+export class ErrorGeneral extends Errorx {
+  constructor(
+    msg: string = 'Unknown error.',
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    super({
+      code: 'General',
+      httpErrorStatus: 500,
+      message: msg,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * DuplicateFieldWithConflictingResource (https://docs.commercetools.com/api/errors#duplicatefieldwithconflictingresource)
+ * Returned when a field value conflicts with an existing value stored in a particular resource causing a duplicate.
+ */
+export class ErrorDuplicateFieldWithConflictingResource extends Errorx {
+  constructor(
+    field: string,
+    duplicateValue: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    super({
+      code: 'DuplicateFieldWithConflictingResource',
+      httpErrorStatus: 400,
+      message: `A duplicate value ${duplicateValue} exists for field ${field} in request.`,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * MissingProjectKey
+ * Missing the project key in the path.
+ */
+export class ErrorMissingProjectKey extends Errorx {
+  constructor(additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'MissingProjectKey',
+      httpErrorStatus: 400,
+      message: 'Missing project key in the request path.',
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * MissingApplicationKey
+ * Missing the project key in the path.
+ */
+export class ErrorMissingApplicationKey extends Errorx {
+  constructor(additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'MissingApplicationKey',
+      httpErrorStatus: 400,
+      message: 'Missing application key in request.',
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * MissingAuthenticationInfo
+ * Missing the project key in the path.
+ */
+export class ErrorMissingAuthenticationInfo extends Errorx {
+  constructor(additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'MissingAuthenticationInfo',
+      httpErrorStatus: 400,
+      message: 'Not able to identify the user',
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * InvalidInput (https://docs.commercetools.com/api/errors#invalidinput)
+ * Returned when an invalid input has been sent.
+ */
+export class ErrorInvalidInput extends Errorx {
+  constructor(message: string, additionalOpts?: ErrorxAdditionalOpts) {
+    const { ...rest } = additionalOpts || {};
+    super({
+      code: 'InvalidInput',
+      httpErrorStatus: 400,
+      message,
+      ...rest,
+    });
+  }
+}
+
+/**
+ * InvalidJsonInput (https://docs.commercetools.com/api/errors#invalidjsoninput)
+ * Returned when an invalid JSON input has been sent. Either the JSON is syntactically incorrect or does not conform to the expected shape (for example is missing a required field).
+ *
+ * The client application should validate the input according to the constraints described in the error message before sending the request.
+ */
+export class ErrorInvalidJsonInput extends Errorx {
+  constructor(
+    detailedErrorMessage?: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    const { fields, ...rest } = additionalOpts || {};
+    super({
+      code: 'InvalidJsonInput',
+      httpErrorStatus: 400,
+      message: 'Request body does not contain valid JSON.',
+      fields: {
+        ...fields,
+        detailedErrorMessage,
+      },
+      ...rest,
+    });
+  }
+}
+
+/**
+ * InvalidOperation (https://docs.commercetools.com/api/errors#invalidoperation)
+ * Returned when the resources involved in the request are not in a valid state for the operation.
+ *
+ * The client application should validate the constraints described in the error message before sending the request.
+ */
+export class ErrorInvalidOperation extends Errorx {
+  constructor(message: string, additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'InvalidOperation',
+      httpErrorStatus: 400,
+      message,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * InvalidField (https://docs.commercetools.com/api/errors#invalidfield)
+ * Returned when a field has an invalid value.
+ */
+export class ErrorInvalidField<T> extends Errorx {
+  constructor(
+    field: string,
+    invalidValue: T,
+    allowedValues?: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    const { fields, ...rest } = additionalOpts || {};
+    super({
+      code: 'InvalidField',
+      httpErrorStatus: 400,
+      message: `The value ${invalidValue} is not valid for field ${field}.`,
+      fields: {
+        ...fields,
+        field,
+        invalidValue,
+        ...(allowedValues ? { allowedValues } : {}),
+      },
+      ...rest,
+    });
+  }
+}
+
+/**
+ * InternalConstraintViolated (https://docs.commercetools.com/api/errors#internalconstraintviolated)
+ * Returned when certain API-specific constraints were not met. For example, the specified Discount Code was never applied and cannot be updated.
+ */
+export class ErrorInternalConstraintViolated extends Errorx {
+  constructor(message: string, additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'InternalConstraintViolated',
+      httpErrorStatus: 400,
+      message,
+      skipLog: true,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * MoneyOverflow (https://docs.commercetools.com/api/errors#moneyoverflow)
+ * Returned when a Money operation overflows the 64-bit integer range. See Money usage for more information.
+ */
+export class ErrorMoneyOverflow extends Errorx {
+  constructor(additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'MoneyOverflow',
+      httpErrorStatus: 400,
+      message: `A Money operation resulted in an overflow.`,
+      skipLog: true,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * MaxResourceLimitExceeded (https://docs.commercetools.com/api/errors#maxresourcelimitexceeded)
+ * Returned when a resource type cannot be created as it has reached its limits.
+ */
+export class ErrorMaxResourceLimitExceeded extends Errorx {
+  constructor(
+    limit: number,
+    resourceTypeId: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    super({
+      code: 'MaxResourceLimitExceeded',
+      httpErrorStatus: 400,
+      message: `You have exceeded the limit of ${limit} resources of type ${resourceTypeId}.`,
+      skipLog: true,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * ObjectNotFound (https://docs.commercetools.com/api/errors#objectnotfound)
+ * Returned when the requested resource was not found.
+ */
+export class ErrorObjectNotFound extends Errorx {
+  constructor(
+    resourceTypeId: string,
+    id: unknown,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    super({
+      code: 'ObjectNotFound',
+      httpErrorStatus: 400,
+      message: `A ${resourceTypeId} with identifier ${id} was unexpectedly not found.`,
+      skipLog: true,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * ReferenceExists (https://docs.commercetools.com/api/errors#invalidfield)
+ * Returned when a resource cannot be deleted because it is being referenced by another resource.
+ */
+export class ErrorReferenceExists extends Errorx {
+  constructor(
+    resource: string,
+    referencedBy?: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    const { fields, ...rest } = additionalOpts ?? {};
+    super({
+      code: 'ReferenceExists',
+      httpErrorStatus: 400,
+      message: `Can not delete a ${resource} while it is referenced by at least one ${referencedBy}.`,
+      fields: {
+        ...fields,
+        referencedBy,
+      },
+      ...rest,
+    });
+  }
+}
+
+/**
+ * ReferencedResourceNotFound (https://docs.commercetools.com/api/errors#referencedresourcenotfound)
+ * Returned when a resource referenced by a Reference or a ResourceIdentifier could not be found.
+ */
+export class ErrorReferencedResourceNotFound extends Errorx {
+  constructor(
+    typeId: string,
+    id?: string,
+    key?: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+    message?: string,
+  ) {
+    const { fields, ...rest } = additionalOpts || {};
+    super({
+      code: 'ReferencedResourceNotFound',
+      httpErrorStatus: 400,
+      message: message
+        ? message
+        : `The referenced object of type ${typeId} ${
+            id || key
+          } was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
+      fields: {
+        ...fields,
+        id,
+        key,
+        typeId,
+      },
+      ...rest,
+    });
+  }
+}
+
+/**
+ * ReferencedResourceNotFound (https://docs.commercetools.com/api/errors#referencedresourcenotfound)
+ * Returned when a resource referenced by a Reference or a ResourceIdentifier could not be found.
+ */
+export class ErrorRequiredField extends Errorx {
+  constructor(field: string, additionalOpts?: ErrorxAdditionalOpts) {
+    const { fields, ...rest } = additionalOpts || {};
+    super({
+      code: 'RequiredField',
+      httpErrorStatus: 400,
+      message: `A value is required for field ${field}.`,
+      fields: {
+        ...fields,
+        field,
+      },
+      ...rest,
+    });
+  }
+}
+
+/**
+ * SyntaxError (https://docs.commercetools.com/api/errors#syntaxerror)
+ * Returned when a Discount predicate, API Extension predicate, or search query does not have the correct syntax.
+ */
+export class ErrorSyntaxError extends Errorx {
+  constructor(fieldDefinition: string, additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'SyntaxError',
+      httpErrorStatus: 400,
+      message: `Syntax error while parsing ${fieldDefinition}.`,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * ResourceNotFound (https://docs.commercetools.com/api/errors#resourcenotfound)
+ * Returned when the resource addressed by the request URL does not exist.
+ */
+export class ErrorResourceNotFound extends Errorx {
+  constructor(
+    resourceIdentifier: string,
+    resourceId: string,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    super({
+      code: 'ResourceNotFound',
+      httpErrorStatus: 404,
+      message: `The Resource with ${resourceIdentifier} ${resourceId} was not found.`,
+      skipLog: false,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * ConcurrentModification (https://docs.commercetools.com/api/errors#concurrentmodification)
+ * Returned when the request conflicts with the current state of the involved resources. Typically, the request attempts to modify a resource that is out of date (that is modified by another client since it was last retrieved). The client application should resolve the conflict (with or without involving the end-user) before retrying the request.
+ */
+export class ErrorConcurrentModification extends Errorx {
+  constructor(
+    resourceId: string,
+    expectedVersion: number,
+    currentVersion: number,
+    additionalOpts?: ErrorxAdditionalOpts,
+  ) {
+    const { fields, ...rest } = additionalOpts || {};
+    super({
+      code: 'ConcurrentModification',
+      httpErrorStatus: 409,
+      message: `Object ${resourceId} has a different version than expected. Expected: ${expectedVersion} - Actual: ${currentVersion}.`,
+      skipLog: true,
+      fields: {
+        ...fields,
+        resourceId,
+        expectedVersion,
+        currentVersion,
+      },
+      ...rest,
+    });
+  }
+}
+
+/**
+ * Error class for proxying errors from commercetools API
+ */
+export class CommercetoolsApiError extends Errorx {
+  // TODO: Handle this better (add types)
+  // biome-ignore lint/suspicious/noExplicitAny: Accept any error object
+  constructor(err: any, additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: err.body?.code,
+      message: err?.body?.message || err?.message,
+      httpErrorStatus: err.statusCode,
+      cause: err,
+      fields: err.body?.errors,
+      ...additionalOpts,
+    });
+    this.name = 'CommercetoolsApiError';
+  }
+}
+
+/**
+ * Error class for proxying errors from commercetools API
+ */
+export class CommercetoolsEmptyResponseApiError extends Errorx {
+  constructor(httpStatus: number, additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'CommercetoolsEmptyResponseApiError',
+      message: 'Empty response from commercetools API',
+      httpErrorStatus: httpStatus,
+      ...additionalOpts,
+    });
+    this.name = 'CommercetoolsEmptyResponseApiError';
+  }
+}
+
+/**
+ * Error class for proxying errors from commercetools Connect API
+ */
+export class CommercetoolsConnectApiError extends Errorx {
+  constructor(
+    statusCode: number,
+    data: {
+      code?: string;
+      message?: string;
+      errors?: {
+        code?: string;
+        message?: string;
+        [key: string]: unknown;
+      }[];
+      [key: string]: unknown;
+    },
+  ) {
+    const errorData = data.errors ? data.errors[0] : data;
+
+    super({
+      code: errorData.code || 'ConnectUnknownError',
+      message: errorData.message || 'ConnectUnknownError',
+      httpErrorStatus: statusCode,
+      privateFields: data,
+      skipLog: true,
+    });
+    this.name = 'CommercetoolsConnectApiError';
+  }
+}
+
+/**
+ * ConnectorFailed
+ *
+ * Returned when the connector cannot be reached
+ */
+export class ConnectorFailedError extends Errorx {
+  constructor(url: string, additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'ConnectorFailed',
+      httpErrorStatus: 502,
+      message: `The connector could not be reached.`,
+      skipLog: false,
+      privateFields: {
+        url,
+      },
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * PaymentFailureError
+ *
+ * Returned when the payment cannot be completed succesfully
+ */
+export class PaymentFailureError extends Errorx {
+  constructor(additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'PaymentFailure',
+      httpErrorStatus: 502,
+      message: `Payment could not be completed succesfully.`,
+      skipLog: false,
+      ...additionalOpts,
+    });
+  }
+}
+
+/**
+ * Error class for proxying errors from commercetools Notification Service API
+ */
+export class CommercetoolsNotificationServiceApiError extends Errorx {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(
+    statusCode: number,
+    data: {
+      code?: string;
+      message?: string;
+      errors?: {
+        code?: string;
+        message?: string;
+        [key: string]: unknown;
+      }[];
+      [key: string]: unknown;
+    },
+  ) {
+    const errorData = data.errors ? data.errors[0] : data;
+
+    super({
+      code: errorData.code || 'NotificationServiceUnknownError',
+      message: errorData.message || 'NotificationServiceUnknownError',
+      httpErrorStatus: statusCode,
+      privateFields: data,
+      skipLog: false,
+    });
+    this.name = 'CommercetoolsNotificationServiceApiError';
+  }
+}
+
+/**
+ * ServiceUnavailableError
+ *
+ * Returned when the service is unavailable, for example when the Notification Service is down.
+ */
+export class ServiceUnavailableError extends Errorx {
+  constructor(additionalOpts?: ErrorxAdditionalOpts) {
+    super({
+      code: 'ServiceUnavailable',
+      httpErrorStatus: 503,
+      message: `The service is unavailable.`,
+      skipLog: false,
+      ...additionalOpts,
+    });
+  }
+}

package/src/errorx/index.ts

@@ -0,0 +1 @@
+export * from '@/errorx/errorx.js';

package/src/errorx/types.ts

@@ -0,0 +1,5 @@
+export type {
+  ErrorxAdditionalOpts,
+  ErrorxBaseOpts,
+  ErrorxOpts,
+} from '@/errorx/errorx.js';

package/src/fetch/decorators/base.decorator.ts

@@ -0,0 +1,13 @@
+import type { Fetcher } from '@/fetch/types/fetch.type.js';
+
+/**
+ * Basic fetcher implementation
+ */
+export class BasicFetcher implements Fetcher {
+  run(
+    input: string | URL | globalThis.Request,
+    init?: RequestInit,
+  ): Promise<Response> {
+    return fetch(input, init);
+  }
+}

package/src/fetch/decorators/monitoring.decorator.ts

@@ -0,0 +1,41 @@
+import type { ContextProvider, RequestContextData } from '@api-types';
+import type { Fetcher } from '@/fetch/types/fetch.type.js';
+
+/**
+ * Decorates the fetcher with the correlation id and request id
+ */
+export class MonitoringFetcherDecorator implements Fetcher {
+  private decoratee: Fetcher;
+  private contextProvider: ContextProvider<RequestContextData>;
+
+  constructor(
+    decoratee: Fetcher,
+    contextProvider: ContextProvider<RequestContextData>,
+  ) {
+    this.decoratee = decoratee;
+    this.contextProvider = contextProvider;
+  }
+
+  async run(
+    input: string | URL | globalThis.Request,
+    init?: RequestInit,
+  ): Promise<Response> {
+    init = init || {};
+
+    const { requestId, correlationId } = this.contextProvider.getContextData();
+    if (requestId || correlationId) {
+      if (!init) {
+        init = {};
+      }
+      init.headers = new Headers(init.headers);
+      if (requestId) {
+        init.headers.set('x-request-id', requestId);
+      }
+      if (correlationId) {
+        init.headers.set('x-correlation-id', correlationId);
+      }
+    }
+
+    return this.decoratee.run(input, init);
+  }
+}