@equinor/fusion-framework-module-services 4.1.5 → 5.0.0

package/src/bookmarks/endpoints/bookmark-apply.get.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, schemaSelector } from '../../utils';
+import { ApiVersion } from '../api-version';
+import { ApiBookmarkPayload } 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({ bookmarkId: z.string() }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: z.object({
+        id: z.string(),
+        payload: ApiBookmarkPayload[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> = {
+                method: 'GET',
+                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);
+            return `/bookmarks/${args.bookmarkId}/apply?${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 BookmarkApplyVersion,
+    MethodArg as BookmarkApplyArgs,
+    ApiResponse as BookmarkApplyResponse,
+    MethodResult as BookmarkApplyResult,
+    executeApiCall as getBookmarkApply,
+};

package/src/bookmarks/endpoints/bookmark.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 `/bookmarks/${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 DeleteBookmarkVersion,
+    MethodArg as DeleteBookmarkArg,
+    ApiResponse as DeleteBookmarkResponse,
+    MethodResult as DeleteBookmarksResult,
+    executeApiCall as deleteBookmark,
+};

package/src/bookmarks/endpoints/bookmark.get.ts

@@ -0,0 +1,118 @@
+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 } from '../schemas';
+
+/** API version which this operation uses. */
+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 for the input arguments to this operation. */
+const ArgSchema = {
+    [ApiVersion.v1]: z.object({
+        bookmarkId: z.string(),
+    }),
+    [ApiVersion.v2]: z.object({
+        bookmarkId: z.string(),
+    }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1],
+    [ApiVersion.v2]: ApiBookmarkSchema[ApiVersion.v2],
+};
+
+/** 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:
+        case ApiVersion.v2: {
+            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:
+        case ApiVersion.v2: {
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            return `/bookmarks/${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 GetBookmarkVersion,
+    MethodArg as GetBookmarkArg,
+    ApiResponse as GetBookmarkResponse,
+    MethodResult as GetBookmarkResult,
+    executeApiCall as getBookmark,
+};

package/src/bookmarks/endpoints/bookmark.patch.ts

@@ -0,0 +1,135 @@
+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 { ApiBookmarkPayload, ApiBookmarkSchema } 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({
+        bookmarkId: z.string(),
+        updates: z.object({
+            name: z.string().nullish(),
+            description: z.string().nullish(),
+            isShared: z.boolean().nullish(),
+            payload: z
+                .record(z.unknown())
+                .or(z.string())
+                .nullish()
+                .transform((x) => (typeof x === 'object' ? JSON.stringify(x) : x)),
+            sourceSystem: z
+                .object({
+                    identifier: z.string().nullish(),
+                    name: z.string().nullish(),
+                    subSystem: z.string().nullish(),
+                })
+                .nullish(),
+        }),
+    }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1].and(
+        z.object({
+            payload: ApiBookmarkPayload[ApiVersion.v1].optional(),
+        }),
+    ),
+};
+
+/** 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: 'PATCH',
+                selector: schemaSelector(ApiResponseSchema[version]),
+                body: args.updates,
+            };
+            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 `/bookmarks/${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 PatchBookmarkVersion,
+    MethodArg as PatchBookmarkArg,
+    ApiResponse as PatchBookmarkResponse,
+    MethodResult as PatchBookmarksResult,
+    executeApiCall as patchBookmark,
+};

package/src/bookmarks/endpoints/bookmark.post.ts

@@ -0,0 +1,124 @@
+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 { ApiBookmarkPayload, 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({
+        name: z.string(),
+        appKey: z.string(),
+        payload: z.record(z.unknown()).or(z.string()).optional(),
+        description: z.string().nullish(),
+        isShared: z.boolean().nullish(),
+        contextId: z.string().nullish(),
+        sourceSystem: ApiSourceSystem[ApiVersion.v1].nullish(),
+    }),
+};
+
+/** Schema for the response from the API. */
+const ApiResponseSchema = {
+    [ApiVersion.v1]: ApiBookmarkSchema[ApiVersion.v1].and(
+        z.object({
+            payload: ApiBookmarkPayload[ApiVersion.v1].optional(),
+        }),
+    ),
+};
+
+/** 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: schemaSelector(ApiResponseSchema[version]),
+                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 `/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);
+        return client[method](
+            generateApiPath(apiVersion, args),
+            generateRequestParameters(apiVersion, args, init),
+        ) as TResult;
+    };
+};
+
+export {
+    AllowedVersions as CreateBookmarkVersion,
+    MethodArg as CreateBookmarkArg,
+    ApiResponse as CreateBookmarkResponse,
+    MethodResult as CreateBookmarksResult,
+    executeApiCall as createBookmark,
+};