@equinor/fusion-framework-module-services 5.0.0-next-663bed8344cc2ca0111705b05045173328b3104d → 5.0.0

package/src/bookmarks/endpoints/user-bookmark-favourite.delete.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+
+import type {
+    ClientRequestInit,
+    FetchRequestInit,
+    IHttpClient,
+    JsonRequest,
+} from '@equinor/fusion-framework-module-http/client';
+
+import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
+
+import { extractVersion } from '../../utils';
+import { ApiVersion } from '../api-version';
+import { statusSelector } from '../selectors';
+
+/** API version which this operation uses. */
+type AvailableVersions = ApiVersion.v1;
+
+/** Defines the allowed versions for this operation. (key of enum as string or enum value) */
+type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
+
+/** Schema for the input arguments to this operation. */
+const ArgSchema = {
+    [ApiVersion.v1]: z.object({
+        bookmarkId: z.string(),
+    }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: z.boolean(),
+};
+
+/** Defines the expected output from the api. */
+type ApiResponse<TVersion extends AllowedVersions> = z.infer<
+    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the input arguments to this operation. */
+type MethodArg<TVersion extends AllowedVersions> = z.input<
+    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the expected output of this operation. */
+type MethodResult<
+    TVersion extends AllowedVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = ApiResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];
+
+/** utility function for generating http request initialization parameters  */
+const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
+    version: TVersion,
+    args: z.infer<(typeof ArgSchema)[TVersion]>,
+    init?: ClientRequestInit<IHttpClient, TResult>,
+): ClientRequestInit<IHttpClient, TResult> => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+                method: 'DELETE',
+                selector: statusSelector,
+            };
+            return Object.assign({}, baseInit, init);
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** utility function for generating the api path */
+const generateApiPath = <TVersion extends AvailableVersions>(
+    version: TVersion,
+    args: z.infer<(typeof ArgSchema)[TVersion]>,
+): string => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            return `/persons/me/bookmarks/favourites/${args.bookmarkId}?${String(params)}`;
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** executes the api call */
+const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
+    version: TVersion,
+    client: IHttpClient,
+    method: TMethod = 'json' as TMethod,
+) => {
+    type MethodVersion = ExtractApiVersion<TVersion>;
+    const apiVersion = extractVersion(ApiVersion, version);
+    return <
+        TResponse = ApiResponse<MethodVersion>,
+        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+    >(
+        input: MethodArg<MethodVersion>,
+        init?: ClientRequestInit<IHttpClient, TResponse>,
+    ): TResult => {
+        const args = ArgSchema[apiVersion].parse(input);
+        return client[method](
+            generateApiPath(apiVersion, args),
+            generateRequestParameters(apiVersion, args, init),
+        ) as TResult;
+    };
+};
+
+export {
+    AllowedVersions as RemoveBookmarkFavouriteVersion,
+    MethodArg as RemoveBookmarkFavouriteArgs,
+    ApiResponse as RemoveBookmarkFavouriteResponse,
+    MethodResult as RemoveBookmarkFavouriteResult,
+    executeApiCall as removeFavoriteBookmark,
+};

package/src/bookmarks/endpoints/user-bookmark-favourite.head.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+
+import type {
+    ClientRequestInit,
+    FetchRequestInit,
+    IHttpClient,
+    JsonRequest,
+} from '@equinor/fusion-framework-module-http/client';
+
+import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
+
+import { extractVersion } from '../../utils';
+import { ApiVersion } from '../api-version';
+import { headSelector } from '../selectors';
+
+/** API version which this operation uses. */
+type AvailableVersions = ApiVersion.v1;
+
+/** Defines the allowed versions for this operation. (key of enum as string or enum value) */
+type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
+
+/** Schema for the input arguments to this operation. */
+const ArgSchema = {
+    [ApiVersion.v1]: z.object({
+        bookmarkId: z.string(),
+    }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: z.boolean(),
+};
+
+/** Defines the expected output from the api. */
+type ApiResponse<TVersion extends AllowedVersions> = z.infer<
+    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the input arguments to this operation. */
+type MethodArg<TVersion extends AllowedVersions> = z.input<
+    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the expected output of this operation. */
+type MethodResult<
+    TVersion extends AllowedVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = ApiResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];
+
+/** utility function for generating http request initialization parameters  */
+const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
+    version: TVersion,
+    args: z.infer<(typeof ArgSchema)[TVersion]>,
+    init?: ClientRequestInit<IHttpClient, TResult>,
+): ClientRequestInit<IHttpClient, TResult> => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+                method: 'POST',
+                selector: headSelector,
+                body: args,
+            };
+            return Object.assign({}, baseInit, init);
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** utility function for generating the api path */
+const generateApiPath = <TVersion extends AvailableVersions>(
+    version: TVersion,
+    args: z.infer<(typeof ArgSchema)[TVersion]>,
+): string => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            return `/persons/me/bookmarks/favourites/${args.bookmarkId}?${String(params)}`;
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** executes the api call */
+const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
+    version: TVersion,
+    client: IHttpClient,
+    method: TMethod = 'json' as TMethod,
+) => {
+    type MethodVersion = ExtractApiVersion<TVersion>;
+    const apiVersion = extractVersion(ApiVersion, version);
+    return <
+        TResponse = ApiResponse<MethodVersion>,
+        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+    >(
+        input: MethodArg<MethodVersion>,
+        init?: ClientRequestInit<IHttpClient, TResponse>,
+    ): TResult => {
+        const args = ArgSchema[apiVersion].parse(input);
+        return client[method](
+            generateApiPath(apiVersion, args),
+            generateRequestParameters(apiVersion, args, init),
+        ) as TResult;
+    };
+};
+
+export {
+    AllowedVersions as IsFavoriteBookmarkVersion,
+    MethodArg as IsFavoriteBookmarkArgs,
+    ApiResponse as IsFavoriteBookmarkResponse,
+    MethodResult as IsFavoriteBookmarkResult,
+    executeApiCall as isFavoriteBookmark,
+};

package/src/bookmarks/endpoints/user-bookmark-favourite.post.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+
+import type {
+    ClientRequestInit,
+    FetchRequestInit,
+    IHttpClient,
+    JsonRequest,
+} from '@equinor/fusion-framework-module-http/client';
+
+import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
+
+import { extractVersion } from '../../utils';
+import { ApiVersion } from '../api-version';
+import { statusSelector } from '../selectors';
+
+/** API version which this operation uses. */
+type AvailableVersions = ApiVersion.v1;
+
+/** Defines the allowed versions for this operation. (key of enum as string or enum value) */
+type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
+
+/** Schema for the input arguments to this operation. */
+const ArgSchema = {
+    [ApiVersion.v1]: z.object({
+        bookmarkId: z.string(),
+    }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: z.boolean(),
+};
+
+/** Defines the expected output from the api. */
+type ApiResponse<TVersion extends AllowedVersions> = z.infer<
+    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the input arguments to this operation. */
+type MethodArg<TVersion extends AllowedVersions> = z.input<
+    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the expected output of this operation. */
+type MethodResult<
+    TVersion extends AllowedVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = ApiResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];
+
+/** utility function for generating http request initialization parameters  */
+const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
+    version: TVersion,
+    args: z.infer<(typeof ArgSchema)[TVersion]>,
+    init?: ClientRequestInit<IHttpClient, TResult>,
+): ClientRequestInit<IHttpClient, TResult> => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+                method: 'POST',
+                selector: statusSelector,
+                body: args,
+            };
+            return Object.assign({}, baseInit, init);
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** utility function for generating the api path */
+const generateApiPath = <TVersion extends AvailableVersions>(
+    version: TVersion,
+    _args: z.infer<(typeof ArgSchema)[TVersion]>,
+): string => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            return `/persons/me/bookmarks/favourites?${String(params)}`;
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** executes the api call */
+const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
+    version: TVersion,
+    client: IHttpClient,
+    method: TMethod = 'json' as TMethod,
+) => {
+    type MethodVersion = ExtractApiVersion<TVersion>;
+    const apiVersion = extractVersion(ApiVersion, version);
+    return <
+        TResponse = ApiResponse<MethodVersion>,
+        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+    >(
+        input: MethodArg<MethodVersion>,
+        init?: ClientRequestInit<IHttpClient, TResponse>,
+    ): TResult => {
+        const args = ArgSchema[apiVersion].parse(input);
+        return client[method](
+            generateApiPath(apiVersion, args),
+            generateRequestParameters(apiVersion, args, init),
+        ) as TResult;
+    };
+};
+
+export {
+    AllowedVersions as AddBookmarkFavouriteVersion,
+    MethodArg as AddBookmarkFavouriteArgs,
+    ApiResponse as AddBookmarkFavouriteResponse,
+    MethodResult as AddBookmarkFavouriteResult,
+    executeApiCall as addBookmarkAsFavourite,
+};

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

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+
+import type {
+    ClientRequestInit,
+    FetchRequestInit,
+    IHttpClient,
+    JsonRequest,
+} from '@equinor/fusion-framework-module-http/client';
+
+import type { ClientMethod, ExtractApiVersion, FilterAllowedApiVersions } from '../types';
+
+import { extractVersion, schemaSelector } from '../../utils';
+import { ApiVersion } from '../api-version';
+import { ApiBookmarkSchema, ApiSourceSystem } from '../schemas';
+
+/** API version which this operation uses. */
+type AvailableVersions = ApiVersion.v1;
+
+/** Defines the allowed versions for this operation. (key of enum as string or enum value) */
+type AllowedVersions = FilterAllowedApiVersions<AvailableVersions>;
+
+/** 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(),
+        })
+        .optional(),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: z.array(ApiBookmarkSchema[ApiVersion.v1]),
+};
+
+/** Defines the expected output from the api. */
+type ApiResponse<TVersion extends AllowedVersions> = z.infer<
+    (typeof ApiResponseSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the input arguments to this operation. */
+type MethodArg<TVersion extends AllowedVersions> = z.input<
+    (typeof ArgSchema)[ExtractApiVersion<TVersion>]
+>;
+
+/** Defines the expected output of this operation. */
+type MethodResult<
+    TVersion extends AllowedVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = ApiResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];
+
+/** utility function for generating http request initialization parameters  */
+const generateRequestParameters = <TResult, TVersion extends AvailableVersions>(
+    version: TVersion,
+    _args: z.infer<(typeof ArgSchema)[TVersion]>,
+    init?: ClientRequestInit<IHttpClient, TResult>,
+): ClientRequestInit<IHttpClient, TResult> => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const baseInit: FetchRequestInit<ApiResponse<ApiVersion.v1>, JsonRequest> = {
+                selector: schemaSelector(ApiResponseSchema[version]),
+            };
+            return Object.assign({}, baseInit, init);
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** utility function for generating the api path */
+const generateApiPath = <TVersion extends AvailableVersions>(
+    version: TVersion,
+    args: z.infer<(typeof ArgSchema)[TVersion]>,
+): string => {
+    switch (version) {
+        case ApiVersion.v1: {
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            args?.filter && params.append('$filter', args.filter);
+            return `/persons/me/bookmarks/?${String(params)}`;
+        }
+    }
+    throw Error(`Unknown API version: ${version}`);
+};
+
+/** executes the api call */
+const executeApiCall = <TVersion extends AllowedVersions, TMethod extends keyof ClientMethod>(
+    version: TVersion,
+    client: IHttpClient,
+    method: TMethod = 'json' as TMethod,
+) => {
+    type MethodVersion = ExtractApiVersion<TVersion>;
+    const apiVersion = extractVersion(ApiVersion, version);
+    return <
+        TResponse = ApiResponse<MethodVersion>,
+        TResult = MethodResult<MethodVersion, TMethod, TResponse>,
+    >(
+        input: MethodArg<MethodVersion>,
+        init?: ClientRequestInit<IHttpClient, TResponse>,
+    ): TResult => {
+        const args = ArgSchema[apiVersion].parse(input);
+        const path = generateApiPath(apiVersion, args);
+        const params = generateRequestParameters(apiVersion, args, init);
+        return client[method](path, params) as TResult;
+    };
+};
+
+export {
+    AllowedVersions as GetBookmarksVersion,
+    MethodArg as GetBookmarksArgs,
+    ApiResponse as GetBookmarksResponse,
+    MethodResult as GetBookmarksResult,
+    executeApiCall as getBookmarks,
+};

package/src/bookmarks/index.ts

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

package/src/bookmarks/schemas.ts

@@ -0,0 +1,81 @@
+import { ApiVersion } from './api-version';
+
+import { z } from 'zod';
+
+export const ApiDateSchema = z
+    .string()
+    .datetime({ offset: true })
+    .transform((x) => new Date(x));
+
+export const ApiPersonSchema = {
+    [ApiVersion.v1]: z.object({
+        azureUniqueId: z.string(),
+        name: z.string(),
+        mail: z.string().optional(),
+        phoneNumber: z.string().optional(),
+        jobTitle: z.string().optional(),
+        accountType: z
+            .enum(['Employee', 'Consultant', 'External', 'Application', 'Local'])
+            .optional(),
+        accountClassification: z.enum(['Unclassified', 'Internal', 'External']).optional(),
+    }),
+};
+
+export const ApiSourceSystem = {
+    [ApiVersion.v1]: z.object({
+        identifier: z.string(),
+        name: z.string().nullish(),
+        subSystem: z.string().nullish(),
+    }),
+};
+
+export const ApiFusionContext = {
+    [ApiVersion.v1]: z.object({
+        id: z.string(),
+        name: z.string().nullish(),
+        type: z.string().nullish(),
+    }),
+};
+
+/**
+ * Defines the schema for the API bookmark entity, which includes various properties such as the unique identifier, name, application key, description, sharing status, context, creator and updater information, creation and update timestamps, and source system details.
+ *
+ * This schema is defined for the v1 API version, and the properties are validated using the Zod library.
+ */
+export const ApiBookmarkSchema = {
+    get [ApiVersion.v1]() {
+        return z.object({
+            id: z.string(),
+            name: z.string(),
+            appKey: z.string(),
+            description: z.string().optional(),
+            isShared: z.boolean().optional(),
+            context: ApiFusionContext[ApiVersion.v1].optional(),
+            createdBy: ApiPersonSchema[ApiVersion.v1],
+            updatedBy: ApiPersonSchema[ApiVersion.v1].optional(),
+            created: ApiDateSchema,
+            updated: ApiDateSchema.optional(),
+            sourceSystem: ApiSourceSystem[ApiVersion.v1].optional(),
+        });
+    },
+    get [ApiVersion.v2]() {
+        return this[ApiVersion.v1];
+    },
+};
+
+export const ApiBookmarkPayload = {
+    get [ApiVersion.v1]() {
+        return z
+            .record(z.unknown())
+            .or(z.string())
+            .optional()
+            .default('')
+            .transform((x) => {
+                try {
+                    return typeof x === 'string' ? JSON.parse(x) : x;
+                } catch {
+                    return x;
+                }
+            });
+    },
+};

package/src/bookmarks/selectors.ts

@@ -0,0 +1,49 @@
+import { HttpJsonResponseError } from '@equinor/fusion-framework-module-http';
+import { type ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
+
+/**
+ * A response selector that checks the status of an HTTP response and throws an error if the response is not successful.
+ *
+ * @param res - The HTTP response to check.
+ * @returns `true` if the response is successful, otherwise throws an `HttpJsonResponseError`.
+ * @throws {HttpJsonResponseError} If the response is not successful, with the error message, response, and any additional data or cause.
+ */
+export const statusSelector: ResponseSelector<boolean> = async (res) => {
+    if (res.ok) {
+        return true;
+    }
+    const message = `Failed to execute request. Status code: ${res.status}`;
+    let cause: unknown;
+    let data: unknown;
+    switch (res.status) {
+        case 403:
+        case 404: {
+            try {
+                data = await res.json();
+            } catch (error) {
+                cause = error;
+            }
+        }
+    }
+    throw new HttpJsonResponseError(message, res, { cause, data });
+};
+
+/**
+ * A response selector that checks the status of an HTTP response is `2xx` = true or `404` = false, otherwise throws an error.
+ *
+ * @param res - The HTTP response to check.
+ * @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;
+    }
+};

package/src/bookmarks/types.ts

@@ -1 +1,16 @@
-export { ClientMethodType, ClientMethod, ApiClientArguments } from '..';
+import type {
+    FilterAllowedApiVersions as FilterAllowApiVersionsBase,
+    ExtractApiVersion as ExtractApiVersionBase,
+} from '../types';
+
+import { ApiVersion } from './api-version';
+
+export { ClientMethodType, ClientMethod, ApiClientArguments } from '../types';
+
+export type FilterAllowedApiVersions<TAllowed extends string = keyof typeof ApiVersion> =
+    FilterAllowApiVersionsBase<typeof ApiVersion, TAllowed>;
+
+export type ExtractApiVersion<
+    TVersion extends string,
+    TAllowed extends string = FilterAllowedApiVersions,
+> = ExtractApiVersionBase<typeof ApiVersion, TVersion, TAllowed>;

package/src/provider.ts

@@ -11,9 +11,9 @@ export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
     /**
      * @param method - Version of the service to use
      */
-    createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(
+    createBookmarksClient<TMethod extends keyof ClientMethod>(
         method: TMethod,
-    ): Promise<BookmarksApiClient<TMethod, TClient, TPayload>>;
+    ): Promise<BookmarksApiClient<TMethod, TClient>>;
 
     /**
      * @param method - Version of the service to use
@@ -92,9 +92,9 @@ export class ApiProvider<TClient extends IHttpClient = IHttpClient>
         return new NotificationApiClient(httpClient, method);
     }
 
-    public async createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(
+    public async createBookmarksClient<TMethod extends keyof ClientMethod>(
         method: TMethod,
-    ): Promise<BookmarksApiClient<TMethod, TClient, TPayload>> {
+    ): Promise<BookmarksApiClient<TMethod, TClient>> {
         const httpClient = await this._createClientFn('bookmarks');
         httpClient.responseHandler.add('validate_api_request', validateResponse);
         return new BookmarksApiClient(httpClient, method);