@equinor/fusion-framework-module-services 5.1.1 → 5.1.2

package/src/context/related/generate-endpoint.ts

@@ -10,38 +10,86 @@ import type {
   RelatedContextOdataParameters,
 } from './types';
 
-const buildOdataFilter = (filterObj: RelatedContextOdataFilter) => {
-  return Object.keys(filterObj).reduce((acc, key) => {
-    switch (key) {
-      case 'type':
-        return filterObj[key]?.length ? { ...acc, [key]: { in: filterObj[key] } } : acc;
-      default:
-        return { ...acc, [key]: filterObj[key as keyof typeof filterObj] };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  }, {} as any);
-};
-const buildOdataObject = (parameters: RelatedContextOdataParameters) => {
-  return Object.entries(parameters)
-    .filter(([_, value]) => !!value)
-    .reduce((acc, [key, value]) => {
+/**
+ * Builds an OData filter object based on the provided filter object.
+ *
+ * @param filterObj - The filter object containing key-value pairs to be transformed into an OData filter.
+ * @returns A new object representing the OData filter.
+ *
+ * @example
+ * ```typescript
+ * const filter = buildOdataFilter({ type: ['exampleType'], otherKey: 'value' });
+ * // filter will be { $filter: { in: ['exampleType'] }, otherKey: 'value' }
+ * ```
+ */
+function buildOdataFilter(filterObj: RelatedContextOdataFilter): Record<string, unknown> {
+  return Object.keys(filterObj).reduce(
+    (acc, key) => {
       switch (key) {
-        case 'filter':
-          return {
-            ...acc,
-            [key]: buildOdataFilter(value as RelatedContextOdataFilter),
-          };
+        case 'type':
+          if (filterObj[key]?.length) {
+            acc[key] = { in: filterObj[key] };
+          }
+          break;
         default:
-          return { ...acc, [key]: parameters[key as keyof typeof parameters] };
+          acc[key] = filterObj[key as keyof typeof filterObj];
+          break;
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }, {} as any);
-};
+      return acc;
+    },
+    {} as Record<string, unknown>,
+  );
+}
 
-const createSearchParameters = (args: string | RelatedContextOdataParameters) => {
+/**
+ * Builds an OData object from the given parameters.
+ *
+ * This function takes an object of parameters and processes each key-value pair.
+ * It filters out any entries with falsy values and then reduces the remaining entries
+ * into a new object. For the 'filter' key, it calls a specific function to build the
+ * OData filter. For all other keys, it directly assigns the value from the parameters.
+ *
+ * @param parameters - The parameters to build the OData object from.
+ * @returns An object representing the OData parameters.
+ */
+function buildOdataObject(parameters: RelatedContextOdataParameters): Record<string, unknown> {
+  return Object.entries(parameters)
+    .filter(([_, value]) => !!value)
+    .reduce(
+      (acc, [key, value]) => {
+        switch (key) {
+          case 'filter':
+            acc[key] = buildOdataFilter(value as RelatedContextOdataFilter);
+            break;
+          default:
+            acc[key] = parameters[key as keyof typeof parameters];
+            break;
+        }
+        return acc;
+      },
+      {} as Record<string, unknown>,
+    );
+}
+
+/**
+ * Creates search parameters for a query.
+ *
+ * @param args - The arguments for creating search parameters. It can be either a string or an object of type `RelatedContextOdataParameters`.
+ * @returns The search parameters as a string.
+ */
+function createSearchParameters(args: string | RelatedContextOdataParameters): string {
   return typeof args === 'string' ? args : buildOdataQuery(buildOdataObject(args));
-};
+}
 
+/**
+ * Generates an endpoint URL based on the provided API version and arguments.
+ *
+ * @template TVersion - The type of the API version, defaults to the keys of `ApiVersion`.
+ * @param version - The API version to use for generating the endpoint.
+ * @param args - The arguments required to generate the endpoint, including `id` and `query`.
+ * @returns The generated endpoint URL as a string.
+ * @throws {UnsupportedApiVersion} If the provided API version is not supported.
+ */
 export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
   version: TVersion,
   args: RelatedContextArgs<TVersion>,

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '5.1.1';
+export const version = '5.1.2';

package/tests/context.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi, beforeEach, afterEach, type MockInstance } from 'vitest';
+
+import { BASE_URL } from './setup';
+
+import { ContextApiClient, ApiVersion } from '../src/context';
+
+import { HttpClient } from '@equinor/fusion-framework-module-http/client';
+import { UnsupportedApiVersion } from '../src/errors';
+
+import { mockContextItem } from './mocks';
+
+describe('Context', () => {
+  let httpClient: HttpClient;
+  let httpClientWatcher: MockInstance;
+  let contextClient: ContextApiClient;
+
+  beforeEach(() => {
+    httpClient = new HttpClient(BASE_URL, {
+      /* options */
+    });
+    httpClientWatcher = vi.spyOn(httpClient, 'json');
+    contextClient = new ContextApiClient(httpClient, 'json');
+  });
+
+  afterEach(() => {
+    httpClientWatcher.mockRestore();
+  });
+
+  describe('get', () => {
+    it('should generate parameters for valid API version and arguments for V1', async () => {
+      const contextId = '123e4567-e89b-12d3-a456-426614174000';
+      const expected = mockContextItem(contextId);
+      const result = await contextClient.get('v1', { id: contextId });
+
+      expect(result).toMatchObject(expected);
+
+      expect(httpClientWatcher).toHaveBeenCalledWith(
+        `/contexts/${contextId}/?api-version=${ApiVersion.v1}`,
+        undefined,
+      );
+    });
+
+    it('should throw UnsupportedApiVersion for unsupported API version', async () => {
+      // Attempt to get context with an unsupported API version 'v2'
+      // This should throw an UnsupportedApiVersion error because 'v2' is not a valid API version
+      try {
+        await contextClient.get('v2', { id: '123e4567-e89b-12d3-a456-426614174000' });
+        expect(true).toBe(false); // This line should not be reached
+      } catch (error) {
+        // Verify that the error is of type UnsupportedApiVersion
+        expect(error).toBeInstanceOf(UnsupportedApiVersion);
+      }
+    });
+  });
+
+  describe('query', () => {
+    it('should generate parameters for valid API version and arguments for V1', async () => {
+      const result = await contextClient.query('v1', { query: { filter: { type: ['master'] } } });
+
+      expect(result).toHaveLength(10);
+
+      const searchParams = new URLSearchParams();
+      searchParams.append('$filter', "type in ('master')");
+      searchParams.append('api-version', ApiVersion.v1);
+
+      expect(httpClientWatcher).toHaveBeenCalledWith(`/contexts/?${searchParams}`, undefined);
+    });
+
+    it('should throw UnsupportedApiVersion for unsupported API version', async () => {
+      // Attempt to get context with an unsupported API version 'v2'
+      // This should throw an UnsupportedApiVersion error because 'v2' is not a valid API version
+      try {
+        await contextClient.query('v2', { query: { filter: { type: ['master'] } } });
+        expect(true).toBe(false); // This line should not be reached
+      } catch (error) {
+        // Verify that the error is of type UnsupportedApiVersion
+        expect(error).toBeInstanceOf(UnsupportedApiVersion);
+      }
+    });
+  });
+
+  describe('related', () => {
+    it('should generate parameters for valid API version and arguments for V1', async () => {
+      const contextId = '123e4567-e89b-12d3-a456-426614174000';
+
+      await contextClient.related('v1', { id: contextId, query: { filter: { type: ['master'] } } });
+
+      const searchParams = new URLSearchParams();
+      searchParams.append('$filter', "type in ('master')");
+      searchParams.append('api-version', ApiVersion.v1);
+
+      expect(httpClientWatcher).toHaveBeenCalledWith(
+        `/contexts/${contextId}/relations?${searchParams}`,
+        undefined,
+      );
+    });
+    it('should throw UnsupportedApiVersion for unsupported API version', async () => {
+      // Attempt to get context with an unsupported API version 'v2'
+      // This should throw an UnsupportedApiVersion error because 'v2' is not a valid API version
+      try {
+        await contextClient.related('v2', { id: '123e4567-e89b-12d3-a456-426614174000' });
+        expect(true).toBe(false); // This line should not be reached
+      } catch (error) {
+        // Verify that the error is of type UnsupportedApiVersion
+        expect(error).toBeInstanceOf(UnsupportedApiVersion);
+      }
+    });
+  });
+});

package/tests/mocks/get-context-item.ts

@@ -0,0 +1,60 @@
+import { Faker, da, en } from '@faker-js/faker';
+import { type ApiContextEntity, ApiVersion } from '../../src/context';
+
+import { createHash } from 'node:crypto';
+
+/**
+ * Converts a string to a seed for the Faker.js library.
+ *
+ * @param uuid - The UUID string to convert.
+ * @returns A numeric seed derived from the UUID.
+ */
+function stringToSeed(uuid: string): number {
+  const hash = createHash('sha256').update(uuid).digest('hex');
+  return Number.parseInt(hash.slice(0, 8), 16);
+}
+
+/**
+ * Since generation of dates might have a slight difference in milliseconds
+ * we normalize the date to the nearest minute, so we can compare them.
+ * 
+ * @note
+ * This might fail at exactly midnight, but the odds for that are slim. Rerun the test if it fails.
+ * 
+ * @param date date to normalize
+ * @returns string
+ */
+function normalizeDateMock(date: Date): string {
+  date.setMinutes(0);
+  date.setSeconds(0);
+  date.setMilliseconds(0);
+  return date.toISOString();
+}
+
+export const mockContextItem = <V extends ApiVersion = ApiVersion.v1>(
+  id: string,
+  version: V = ApiVersion.v1 as V,
+): ApiContextEntity<V> => {
+  const seed = stringToSeed(id);
+  const faker = new Faker({ seed, locale: en });
+  switch (version) {
+    case ApiVersion.v1:
+      return {
+        id: String(id),
+        externalId: faker.string.uuid(),
+        created: normalizeDateMock(faker.date.recent()),
+        source: faker.string.uuid(),
+        type: {
+          id: faker.string.uuid(),
+          isChildType: false,
+          parentTypeIds: null,
+        },
+        value: null,
+        title: faker.lorem.sentence(),
+        isActive: true,
+        isDeleted: false,
+        updated: normalizeDateMock(faker.date.past()),
+      } satisfies ApiContextEntity<ApiVersion.v1> as ApiContextEntity<V>;
+  }
+  throw new Error('Not implemented');
+};

package/tests/mocks/index.ts

@@ -0,0 +1 @@
+export { mockContextItem } from './get-context-item';

package/tests/setup.ts

@@ -0,0 +1,73 @@
+import { afterAll, afterEach, beforeAll } from 'vitest';
+
+import { setupServer } from 'msw/node';
+import { http, HttpResponse } from 'msw';
+
+import { mockContextItem } from './mocks';
+
+import type { ApiVersion } from '../src/context';
+
+export const BASE_URL = 'https://localhost';
+
+// Define mock handlers for fetch requests
+const handlers = [
+  // Mock GET /contexts
+  http.get(new URL('contexts', BASE_URL).toString(), (req) => {
+    const url = new URL(req.request.url);
+    const apiVersion = url.searchParams.get('api-version');
+    if (!apiVersion) {
+      return HttpResponse.error();
+    }
+    return HttpResponse.json(
+      new Array(10)
+        .fill(null)
+        .map((_, index) => mockContextItem(`context-item-${index}`, apiVersion as ApiVersion.v1)),
+    );
+  }),
+
+  // Mock GET /contexts/:id
+  http.get(new URL('contexts/:id', BASE_URL).toString(), (req) => {
+    const { id } = req.params;
+    if (!id || typeof id !== 'string') {
+      return HttpResponse.error();
+    }
+    const url = new URL(req.request.url);
+    const apiVersion = url.searchParams.get('api-version');
+    if (!apiVersion) {
+      return HttpResponse.error();
+    }
+    return HttpResponse.json(mockContextItem(id, apiVersion as ApiVersion.v1));
+  }),
+
+  // Mock GET /contexts/:id/relations
+  http.get(new URL('contexts/:id/relations', BASE_URL).toString(), (req) => {
+    const { id } = req.params;
+    if (!id || typeof id !== 'string') {
+      return HttpResponse.error();
+    }
+    const url = new URL(req.request.url);
+    const apiVersion = url.searchParams.get('api-version');
+    if (!apiVersion) {
+      return HttpResponse.error();
+    }
+    return HttpResponse.json(
+      new Array(3)
+        .fill(null)
+        .map((_, index) =>
+          mockContextItem(`context--related-item-${index}`, apiVersion as ApiVersion.v1),
+        ),
+    );
+  }),
+];
+
+// Initialize the server
+export const server = setupServer(...handlers);
+
+// Start server before all tests
+beforeAll(() => server.listen({ onUnhandledRequest: 'warn' }));
+
+// Reset handlers after each test
+afterEach(() => server.resetHandlers());
+
+// Stop server after all tests
+afterAll(() => server.close());

package/tsconfig.json

@@ -7,7 +7,7 @@
     
     "paths": {
       "@equinor/fusion-framework-module-services": [
-        "."
+        "./"
       ],
       "@equinor/fusion-framework-module-services/*": [
         "./*"
@@ -29,10 +29,11 @@
     }
   ],
   "include": [
-    "src/**/*",
+    "src/**/*", "tests/**/*",
   ],
   "exclude": [
     "node_modules",
-    "lib"
+    "lib",
+    "tests"
   ]
 }

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineProject } from 'vitest/config';
+
+import { name, version } from './package.json';
+
+export default defineProject({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    name: `${name}@${version}`,
+    setupFiles: ['tests/setup.ts'],
+  },
+});