@ogcio/building-blocks-sdk 0.0.19 → 0.0.21

package/src/__tests__/client/utils/client-utils.test.ts

@@ -0,0 +1,198 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import {
+  type PaginationParams,
+  formatError,
+  formatResponse,
+  preparePaginationParams,
+  toStringOrUndefined,
+} from "./../../../client/utils/client-utils.js";
+import type {
+  ApiError,
+  TestNestedResponseObject,
+  TestResponseObject,
+  TypedErrorResponse,
+  TypedSuccessResponse,
+} from "./response-types.js";
+describe("toStringOrUndefined", () => {
+  test("should convert numbers and booleans to strings", () => {
+    assert.strictEqual(
+      toStringOrUndefined(42),
+      "42",
+      "Expected number to be converted to string",
+    );
+    assert.strictEqual(
+      toStringOrUndefined(true),
+      "true",
+      "Expected boolean true to be converted to string",
+    );
+    assert.strictEqual(
+      toStringOrUndefined(false),
+      "false",
+      "Expected boolean false to be converted to string",
+    );
+  });
+
+  test("should return undefined if input is undefined", () => {
+    assert.strictEqual(
+      toStringOrUndefined(undefined),
+      undefined,
+      "Expected undefined input to return undefined",
+    );
+  });
+
+  test("should convert offset and limit to strings if provided", () => {
+    const params: PaginationParams = { offset: 10, limit: 20 };
+    const result = preparePaginationParams(params);
+    assert.deepStrictEqual(
+      result,
+      { offset: "10", limit: "20" },
+      "Expected offset and limit to be converted to strings",
+    );
+  });
+
+  test("should handle string inputs for offset and limit", () => {
+    const params: PaginationParams = { offset: "5", limit: "15" };
+    const result = preparePaginationParams(params);
+    assert.deepStrictEqual(
+      result,
+      { offset: "5", limit: "15" },
+      "Expected offset and limit to remain strings if already provided as strings",
+    );
+  });
+
+  test("should return an empty object if no pagination parameters are provided", () => {
+    const result = preparePaginationParams();
+    assert.deepStrictEqual(
+      result,
+      {},
+      "Expected empty object if no pagination parameters are provided",
+    );
+  });
+});
+
+describe("preparePaginationParams", () => {
+  test("should handle missing offset and limit individually", () => {
+    const offsetOnly: PaginationParams = { offset: 30 };
+    const limitOnly: PaginationParams = { limit: 50 };
+
+    const resultOffsetOnly = preparePaginationParams(offsetOnly);
+    assert.deepStrictEqual(
+      resultOffsetOnly,
+      { offset: "30" },
+      "Expected only offset to be set when limit is not provided",
+    );
+
+    const resultLimitOnly = preparePaginationParams(limitOnly);
+    assert.deepStrictEqual(
+      resultLimitOnly,
+      { limit: "50" },
+      "Expected only limit to be set when offset is not provided",
+    );
+  });
+});
+
+describe("formatResponse", () => {
+  test("should handle response with plain data", () => {
+    // Create a properly typed success response
+    const mockResponse: TypedSuccessResponse<{ value: string }> = {
+      data: { value: "test" },
+      response: new Response(),
+    };
+
+    const result = formatResponse<
+      TestResponseObject["get"],
+      Record<string, unknown>
+    >(mockResponse);
+
+    assert.deepStrictEqual(result, {
+      data: { value: "test" },
+      metadata: undefined,
+      error: undefined,
+    });
+  });
+
+  test("should handle response with nested data property", () => {
+    // Create a properly typed nested success response
+    const mockResponse: TypedSuccessResponse<{
+      data: {
+        nested: {
+          value: string;
+        };
+      };
+    }> = {
+      data: {
+        data: {
+          nested: {
+            value: "test",
+          },
+        },
+      },
+      response: new Response(),
+    };
+
+    const result = formatResponse<
+      TestNestedResponseObject["get"],
+      Record<string, unknown>
+    >(mockResponse);
+
+    assert.deepStrictEqual(result, {
+      data: {
+        nested: {
+          value: "test",
+        },
+      },
+      metadata: undefined,
+      error: undefined,
+    });
+  });
+
+  test("should format typed error correctly", () => {
+    const mockError: ApiError = {
+      message: "Test error",
+      code: "500",
+    };
+
+    const errorResponse: TypedErrorResponse<ApiError> = {
+      error: mockError,
+      response: new Response(),
+    };
+
+    const result = formatResponse<
+      TestResponseObject["get"],
+      Record<string, unknown>
+    >(errorResponse);
+
+    assert.deepStrictEqual(result, {
+      data: undefined,
+      metadata: undefined,
+      error: mockError,
+    });
+  });
+});
+
+describe("formatError", () => {
+  test("should format error correctly", () => {
+    const error = new Error("Test error");
+    const result = formatError(error);
+    assert.deepStrictEqual(result, {
+      error: error,
+    });
+  });
+
+  test("should handle non-error objects", () => {
+    const errorObj = { code: 500, message: "Server error" };
+    const result = formatError(errorObj);
+    assert.deepStrictEqual(result, {
+      error: errorObj,
+    });
+  });
+
+  test("should handle primitive error values", () => {
+    const errorMessage = "Something went wrong";
+    const result = formatError(errorMessage);
+    assert.deepStrictEqual(result, {
+      error: errorMessage,
+    });
+  });
+});

package/src/__tests__/client/utils/response-types.d.ts

@@ -0,0 +1,59 @@
+export type TestResponseObject = {
+  get: {
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            value: string;
+          };
+        };
+      };
+      "4XX": {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": {
+            code: string;
+            message: string;
+          };
+        };
+      };
+    };
+  };
+};
+
+export type TestNestedResponseObject = {
+  get: {
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            data: {
+              nested: {
+                value: string;
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+
+export type TypedSuccessResponse<T> = {
+  data: T;
+  error?: never;
+  response: Response;
+};
+
+export type TypedErrorResponse<T> = {
+  data?: never;
+  error: T;
+  response: Response;
+};
+
+export type ApiError = {
+  message: string;
+  code: string;
+};

package/src/client/base-client.ts

@@ -64,37 +64,4 @@ export abstract class BaseClient<T extends {}> {
   public isInitialized() {
     return this.initialized;
   }
-
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  protected formatResponse<G extends Record<string | number, any>, O>(
-    response: FetchResponse<G, O, "application/json">,
-  ): DataResponseValue<G, O> {
-    let outputData = undefined;
-    let outputMetadata = undefined;
-    if (!response) {
-      return {} as DataResponseValue<G, O>;
-    }
-    if (response.data) {
-      const dataEntries = Object.entries(response.data);
-      // by docs the body should contain a "data"
-      // properties with the response values
-      const containsData = dataEntries.find((x) => x[0] === "data");
-      const containsMetadata = dataEntries.find((x) => x[0] === "metadata");
-
-      if (containsMetadata) {
-        outputMetadata = containsMetadata[1];
-      }
-      outputData = containsData ? containsData[1] : response.data;
-    }
-
-    return {
-      data: outputData,
-      metadata: outputMetadata,
-      error: response.error,
-    } as unknown as DataResponseValue<G, O>;
-  }
-
-  protected formatError<G, O>(reason: unknown): DataResponseValue<G, O> {
-    return { error: reason } as unknown as DataResponseValue<G, O>;
-  }
 }

package/src/client/clients/featureFlags/index.ts

@@ -2,6 +2,7 @@ import type createClient from "openapi-fetch";
 import type { BaseApiClientParams } from "../../../types/index.js";
 import { FEATURE_FLAGS } from "../../../types/index.js";
 import { BaseClient } from "../../base-client.js";
+import { formatError, formatResponse } from "../../utils/client-utils.js";
 import { DEFAULT_PROJECT_ID } from "./const.js";
 import type { components, paths } from "./schema.js";
 
@@ -69,14 +70,14 @@ export class FeatureFlags extends BaseClient<paths> {
       .then(
         (response) => {
           // @ts-expect-error: TODO: fix me
-          const { data, metadata, error } = this.formatResponse(response);
+          const { data, metadata, error } = formatResponse(response);
           return {
             data: data?.features as components["schemas"]["projectFeatureSchema"][],
             metadata,
             error,
           };
         },
-        (reason) => this.formatError(reason),
+        (reason) => formatError(reason),
       );
   }
 }

package/src/client/clients/messaging/index.ts

@@ -4,6 +4,8 @@ import { MESSAGING } from "../../../types/index.js";
 import { BaseClient } from "../../base-client.js";
 import {
   type PaginationParams,
+  formatError,
+  formatResponse,
   preparePaginationParams,
   toStringOrUndefined,
 } from "../../utils/client-utils.js";
@@ -39,8 +41,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -58,8 +60,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -71,8 +73,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { messageId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -84,8 +86,8 @@ export class Messaging extends BaseClient<paths> {
         body,
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -99,8 +101,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -116,8 +118,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -194,8 +196,8 @@ export class Messaging extends BaseClient<paths> {
     body: paths["/api/v1/templates/"]["post"]["requestBody"]["content"]["application/json"],
   ) {
     return this.client.POST("/api/v1/templates/", { body }).then(
-      (response) => this.formatResponse(response),
-      (reason) => this.formatError(reason),
+      (response) => formatResponse(response),
+      (reason) => formatError(reason),
     );
   }
 
@@ -209,8 +211,8 @@ export class Messaging extends BaseClient<paths> {
         body,
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -222,8 +224,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { templateId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -292,8 +294,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -318,8 +320,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -329,8 +331,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { providerId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -403,8 +405,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -427,8 +429,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -438,8 +440,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { providerId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -467,8 +469,8 @@ export class Messaging extends BaseClient<paths> {
         body: toImport.records,
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -478,8 +480,8 @@ export class Messaging extends BaseClient<paths> {
         parseAs: "blob",
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -496,8 +498,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -518,8 +520,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -529,8 +531,8 @@ export class Messaging extends BaseClient<paths> {
         params: { query: { importId, activeOnly: String(activeOnly) } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -544,8 +546,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -555,8 +557,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { organisationSettingId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -570,8 +572,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { organisationSettingId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -583,8 +585,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -594,8 +596,8 @@ export class Messaging extends BaseClient<paths> {
         params: { path: { eventId } },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -609,8 +611,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -630,8 +632,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -649,8 +651,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }
 
@@ -668,8 +670,8 @@ export class Messaging extends BaseClient<paths> {
         },
       })
       .then(
-        (response) => this.formatResponse(response),
-        (reason) => this.formatError(reason),
+        (response) => formatResponse(response),
+        (reason) => formatError(reason),
       );
   }