@equinor/fusion-framework-module-services 5.0.0 → 5.1.0-bookmark-preview-53d7010af49af3f3128a5ca800f7cfc796dc6089

package/src/bookmarks/endpoints/user-bookmarks.get.ts

@@ -14,44 +14,65 @@ import { ApiVersion } from '../api-version';
 import { ApiBookmarkSchema, ApiSourceSystem } from '../schemas';
 
 /** API version which this operation uses. */
-type AvailableVersions = ApiVersion.v1;
+type AvailableVersions = ApiVersion.v1 | ApiVersion.v2;
 
 /** Defines the allowed versions for this operation. (key of enum as string or enum value) */
 type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
 
+/**
+ * Schema transformer of the filter object to an OData filter string.
+ *
+ * @todo This function should be moved to a shared utility module.
+ */
+const transformOdataFilter = (filter: Record<string, unknown>) => {
+    return Object.entries(filter)
+        .map(([key, value]) => {
+            if (value === null) {
+                return `${key} eq null`;
+            }
+            if (typeof value === 'string') {
+                return `${key} eq '${value}'`;
+            }
+            if (typeof value === 'boolean') {
+                return `${key} eq ${value}`;
+            }
+            if (typeof value === 'object') {
+                return Object.entries(value)
+                    .map(([subKey, subValue]) => `${key}.${subKey} eq '${subValue}'`)
+                    .join(' and ');
+            }
+        })
+        .filter((x) => !!x)
+        .join(' and ');
+};
+
+const filterSchema_v1 = z
+    .object({
+        appKey: z.string().optional(),
+        contextId: z.string().optional(),
+        sourceSystem: ApiSourceSystem[ApiVersion.v1].partial().optional(),
+    })
+    .transform(transformOdataFilter);
+
+const filterSchema_v2 = z
+    .object({
+        appKey: z.string().optional(),
+        contextId: z.string().optional(),
+        sourceSystem: ApiSourceSystem[ApiVersion.v1].partial().optional(),
+        isFavourite: z.boolean().optional(),
+    })
+    .transform(transformOdataFilter);
+
 /** Schema for the input arguments to this operation. */
 const ArgSchema = {
     [ApiVersion.v1]: z
         .object({
-            filter: z
-                .string()
-                .or(
-                    z
-                        .object({
-                            appKey: z.string().optional(),
-                            contextId: z.string().optional(),
-                            sourceSystem: ApiSourceSystem[ApiVersion.v1].partial().optional(),
-                        })
-                        .transform((x) => {
-                            return Object.entries(x)
-                                .map(([key, value]) => {
-                                    if (typeof value === 'string') {
-                                        return `${key} eq '${value}'`;
-                                    }
-                                    if (typeof value === 'object') {
-                                        return Object.entries(value)
-                                            .map(
-                                                ([subKey, subValue]) =>
-                                                    `${key}.${subKey} eq '${subValue}'`,
-                                            )
-                                            .join(' and ');
-                                    }
-                                })
-                                .filter((x) => !!x)
-                                .join(' and ');
-                        }),
-                )
-                .optional(),
+            filter: z.string().or(filterSchema_v1).optional(),
+        })
+        .optional(),
+    [ApiVersion.v2]: z
+        .object({
+            filter: z.string().or(filterSchema_v2).optional(),
         })
         .optional(),
 };
@@ -59,6 +80,7 @@ const ArgSchema = {
 /** Schema for the response from the API. */
 const ApiResponseSchema = {
     [ApiVersion.v1]: z.array(ApiBookmarkSchema[ApiVersion.v1]),
+    [ApiVersion.v2]: z.array(ApiBookmarkSchema[ApiVersion.v2]),
 };
 
 /** Defines the expected output from the api. */
@@ -85,7 +107,8 @@ const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
     init?: ClientRequestInit<IHttpClient, TResult>,
 ): ClientRequestInit<IHttpClient, TResult> => {
     switch (version) {
-        case ApiVersion.v1: {
+        case ApiVersion.v1:
+        case ApiVersion.v2: {
             const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
                 selector: schemaSelector(ApiResponseSchema[version]),
             };
@@ -101,7 +124,8 @@ const generateApiPath = <TVersion extends AvailableVersions>(
     args: z.infer<(typeof ArgSchema)[TVersion]>,
 ): string => {
     switch (version) {
-        case ApiVersion.v1: {
+        case ApiVersion.v1:
+        case ApiVersion.v2: {
             const params = new URLSearchParams();
             params.append('api-version', version);
             args?.filter && params.append('$filter', args.filter);

package/src/bookmarks/index.ts

@@ -1,4 +1,4 @@
 export { BookmarksApiClient, default } from './client';
 export { ApiVersion } from './api-version';
-export type * from './schemas';
+export * from './schemas';
 export type * from './types';

package/src/bookmarks/schemas.ts

@@ -17,7 +17,7 @@ export const ApiPersonSchema = {
         accountType: z
             .enum(['Employee', 'Consultant', 'External', 'Application', 'Local'])
             .optional(),
-        accountClassification: z.enum(['Unclassified', 'Internal', 'External']).optional(),
+        accountClassification: z.enum(['Unclassified', 'Internal', 'External']).nullish(),
     }),
 };
 
@@ -55,7 +55,7 @@ export const ApiBookmarkSchema = {
             updatedBy: ApiPersonSchema[ApiVersion.v1].optional(),
             created: ApiDateSchema,
             updated: ApiDateSchema.optional(),
-            sourceSystem: ApiSourceSystem[ApiVersion.v1].optional(),
+            sourceSystem: ApiSourceSystem[ApiVersion.v1].nullish(),
         });
     },
     get [ApiVersion.v2]() {

package/src/bookmarks/selectors.ts

@@ -1,4 +1,4 @@
-import { HttpJsonResponseError } from '@equinor/fusion-framework-module-http';
+import { HttpJsonResponseError, HttpResponseError } from '@equinor/fusion-framework-module-http';
 import { type ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
 
 /**
@@ -35,15 +35,12 @@ export const statusSelector: ResponseSelector<boolean> = async (res) => {
  * @returns `true` if the response is successful, `false` if the response has a 404 status code, otherwise throws an `HttpJsonResponseError`.
  * @throws {HttpJsonResponseError} If the response is not successful and does not have a 404 status code, with the error message, response, and any additional data or cause.
  */
-export const headSelector: ResponseSelector<boolean> = (res) => {
-    try {
-        return statusSelector(res);
-    } catch (error) {
-        if (error instanceof HttpJsonResponseError) {
-            if (error.response.status === 404) {
-                return Promise.resolve(false);
-            }
-        }
-        throw error;
+export const headSelector: ResponseSelector<boolean> = async (res) => {
+    if (res.ok) {
+        return true;
+    }
+    if (res.status === 404) {
+        return false;
     }
+    throw new HttpResponseError(`Failed to execute request. Status code: ${res.status}`, res);
 };

package/src/provider.ts

@@ -96,7 +96,9 @@ export class ApiProvider<TClient extends IHttpClient = IHttpClient>
         method: TMethod,
     ): Promise<BookmarksApiClient<TMethod, TClient>> {
         const httpClient = await this._createClientFn('bookmarks');
-        httpClient.responseHandler.add('validate_api_request', validateResponse);
+        // TODO: update when new ResponseOperator is available
+        // will fail because 'HEAD' will return 404 when no bookmarks are found
+        // httpClient.responseHandler.add('validate_api_request', validateResponse);
         return new BookmarksApiClient(httpClient, method);
     }
 

package/src/version.ts

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