@wix/sdk 1.12.8 → 1.12.10

package/build/context.d.ts

@@ -1,5 +1,5 @@
-import { BuildRESTFunction, RESTFunctionDescriptor } from '@wix/sdk-types';
-export declare function elevate<T extends RESTFunctionDescriptor | BuildRESTFunction<any>>(restModule: T): T;
+import { RESTFunctionDescriptor } from '@wix/sdk-types';
+export declare function elevate<T extends RESTFunctionDescriptor>(restModule: T): T;
 export declare const fetchWithAuth: typeof fetch & ((restModuleOpts: import("@wix/sdk-types").HttpClient) => typeof fetch);
 export { graphql } from './graphql.js';
 export { setGlobalWixContext } from './wix-context.js';

package/build/event-handlers-modules.d.ts

@@ -1,4 +1,48 @@
-import { BaseEventMetadata, EventDefinition, EventHandler } from '@wix/sdk-types';
+import { AuthenticationStrategy, EventDefinition, EventHandler, EventIdentity } from '@wix/sdk-types';
+import { Emitter } from './nanoevents.js';
 export declare const isEventHandlerModule: (val: any) => val is EventDefinition<unknown, string>;
 export declare function buildEventDefinition<T extends EventDefinition<any, string>>(eventDefinition: T, registerHandler: (eventDefinition: T, handler: EventHandler<T>) => void): (handler: EventHandler<T>) => void;
-export declare function runHandler<T extends EventDefinition>(eventDefinition: T, handler: EventHandler<T>, payload: unknown, baseEventMetadata: BaseEventMetadata): void | Promise<void>;
+type ResolvePossibleEvents<T extends EventDefinition<any>[]> = {
+    [K in keyof T]: T[K] extends EventDefinition<any> ? {
+        eventType: T[K]['type'];
+        payload: T[K]['__payload'];
+    } : never;
+} extends (infer U)[] ? U : never;
+export type ProcessedEvent<T extends EventDefinition<any>[] = []> = {
+    instanceId: string;
+    identity?: EventIdentity;
+} & (T['length'] extends 0 ? {
+    eventType: string;
+    payload: unknown;
+} : ResolvePossibleEvents<T>);
+export type EventHandlersClient = Emitter<{
+    registered: (event: EventDefinition<any>) => void;
+}> & {
+    getRegisteredEvents(): Map<string, {
+        eventDefinition: EventDefinition;
+        handler: EventHandler<EventDefinition>;
+    }[]>;
+    process<ExpectedEvents extends EventDefinition<any>[] = []>(jwt: string, opts?: {
+        expectedEvents: ExpectedEvents;
+    }): Promise<ProcessedEvent<ExpectedEvents>>;
+    processRequest<ExpectedEvents extends EventDefinition<any>[] = []>(request: Request, opts?: {
+        expectedEvents: ExpectedEvents;
+    }): Promise<ProcessedEvent<ExpectedEvents>>;
+    parseJWT(jwt: string): Promise<ProcessedEvent>;
+    parseRequest(request: Request): Promise<ProcessedEvent>;
+    executeHandlers(event: ProcessedEvent): Promise<void>;
+    apps: {
+        AppInstalled: EventDefinition<{
+            appId: string;
+            originInstanceId: string;
+        }, 'AppInstalled'>;
+        AppRemoved: EventDefinition<{
+            appId: string;
+        }, 'AppRemoved'>;
+    };
+};
+export declare function eventHandlersModules(authStrategy: AuthenticationStrategy<any>): {
+    initModule(eventDefinition: EventDefinition<any, string>): (handler: EventHandler<EventDefinition<any, string>>) => void;
+    client: EventHandlersClient;
+};
+export {};

package/build/event-handlers-modules.js

@@ -1,10 +1,12 @@
+import { EventDefinition, } from '@wix/sdk-types';
+import { createNanoEvents } from './nanoevents.js';
 export const isEventHandlerModule = (val) => val.__type === 'event-definition';
 export function buildEventDefinition(eventDefinition, registerHandler) {
     return (handler) => {
         registerHandler(eventDefinition, handler);
     };
 }
-export function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
+function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
     let envelope;
     if (eventDefinition.isDomainEvent) {
         const domainEventPayload = payload;
@@ -46,3 +48,99 @@ export function runHandler(eventDefinition, handler, payload, baseEventMetadata)
     const transformFromRESTFn = eventDefinition.transformations ?? ((x) => x);
     return handler(transformFromRESTFn(envelope));
 }
+export function eventHandlersModules(authStrategy) {
+    const eventHandlers = new Map();
+    const webhooksEmitter = createNanoEvents();
+    const client = {
+        ...webhooksEmitter,
+        getRegisteredEvents: () => eventHandlers,
+        async process(jwt, opts = {
+            expectedEvents: [],
+        }) {
+            const { eventType, identity, instanceId, payload } = await this.parseJWT(jwt);
+            const allExpectedEvents = [
+                ...opts.expectedEvents,
+                ...Array.from(eventHandlers.keys()).map((type) => ({ type })),
+            ];
+            if (allExpectedEvents.length > 0 &&
+                !allExpectedEvents.some(({ type }) => type === eventType)) {
+                throw new Error(`Unexpected event type: ${eventType}. Expected one of: ${allExpectedEvents
+                    .map((x) => x.type)
+                    .join(', ')}`);
+            }
+            const handlers = eventHandlers.get(eventType) ?? [];
+            await Promise.all(handlers.map(({ eventDefinition, handler }) => runHandler(eventDefinition, handler, payload, {
+                instanceId,
+                identity,
+            })));
+            return {
+                instanceId,
+                eventType,
+                payload,
+                identity,
+            };
+        },
+        async processRequest(request, opts) {
+            const body = await request.text();
+            return this.process(body, opts);
+        },
+        async parseJWT(jwt) {
+            if (!authStrategy.decodeJWT) {
+                throw new Error('decodeJWT is not supported by the authentication strategy');
+            }
+            const { decoded, valid } = await authStrategy.decodeJWT(jwt);
+            if (!valid) {
+                throw new Error('JWT is not valid');
+            }
+            if (typeof decoded.data !== 'string') {
+                throw new Error(`Unexpected type of JWT data: expected string, got ${typeof decoded.data}`);
+            }
+            const parsedDecoded = JSON.parse(decoded.data);
+            const eventType = parsedDecoded.eventType;
+            const instanceId = parsedDecoded.instanceId;
+            const identity = parsedDecoded.identity
+                ? JSON.parse(parsedDecoded.identity)
+                : undefined;
+            const payload = JSON.parse(parsedDecoded.data);
+            return {
+                instanceId,
+                eventType,
+                payload,
+                identity,
+            };
+        },
+        async parseRequest(request) {
+            const jwt = await request.text();
+            return this.parseJWT(jwt);
+        },
+        async executeHandlers(event) {
+            const allExpectedEvents = Array.from(eventHandlers.keys()).map((type) => ({ type }));
+            if (allExpectedEvents.length > 0 &&
+                !allExpectedEvents.some(({ type }) => type === event.eventType)) {
+                throw new Error(`Unexpected event type: ${event.eventType}. Expected one of: ${allExpectedEvents
+                    .map((x) => x.type)
+                    .join(', ')}`);
+            }
+            const handlers = eventHandlers.get(event.eventType) ?? [];
+            await Promise.all(handlers.map(({ eventDefinition, handler }) => runHandler(eventDefinition, handler, event.payload, {
+                instanceId: event.instanceId,
+                identity: event.identity,
+            })));
+        },
+        apps: {
+            AppInstalled: EventDefinition('AppInstalled')(),
+            AppRemoved: EventDefinition('AppRemoved')(),
+        },
+    };
+    return {
+        initModule(eventDefinition) {
+            return (handler) => {
+                const handlers = eventHandlers.get(eventDefinition.type) ?? [];
+                handlers.push({ eventDefinition, handler });
+                eventHandlers.set(eventDefinition.type, handlers);
+                webhooksEmitter.emit('registered', eventDefinition);
+            };
+        },
+        client,
+    };
+}

package/build/nanoevents.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Create event emitter.
+ *
+ * ```js
+ * import { createNanoEvents } from 'nanoevents'
+ *
+ * class Ticker {
+ * constructor() {
+ * this.emitter = createNanoEvents()
+ * }
+ * on(...args) {
+ * return this.emitter.on(...args)
+ * }
+ * tick() {
+ * this.emitter.emit('tick')
+ * }
+ * }
+ * ```
+ * @returns Event emitter.
+ */
+export declare function createNanoEvents<Events extends EventsMap = DefaultEvents>(): Emitter<Events>;
+interface EventsMap {
+    [event: string]: any;
+}
+interface DefaultEvents extends EventsMap {
+    [event: string]: (...args: any) => void;
+}
+export type Unsubscribe = () => void;
+export interface Emitter<Events extends EventsMap = DefaultEvents> {
+    /**
+     * Calls each of the listeners registered for a given event.
+     *
+     * ```js
+     * ee.emit('tick', tickType, tickDuration)
+     * ```
+     * @param event The event name.
+     * @param args The arguments for listeners.
+     */
+    emit<K extends keyof Events>(this: this, event: K, ...args: Parameters<Events[K]>): void;
+    /**
+     * Event names in keys and arrays with listeners in values.
+     *
+     * ```js
+     * emitter1.events = emitter2.events
+     * emitter2.events = { }
+     * ```
+     */
+    events: Partial<{
+        [E in keyof Events]: Events[E][];
+    }>;
+    /**
+     * Add a listener for a given event.
+     *
+     * ```js
+     * const unbind = ee.on('tick', (tickType, tickDuration) => {
+     * count += 1
+     * })
+     *
+     * disable () {
+     * unbind()
+     * }
+     * ```
+     * @param event The event name.
+     * @param cb The listener function.
+     * @returns Unbind listener from event.
+     */
+    on<K extends keyof Events>(this: this, event: K, cb: Events[K]): Unsubscribe;
+}
+export {};

package/build/nanoevents.js

@@ -0,0 +1,37 @@
+// Inlined from https://github.com/ai/nanoevents/blob/main/index.js
+/**
+ * Create event emitter.
+ *
+ * ```js
+ * import { createNanoEvents } from 'nanoevents'
+ *
+ * class Ticker {
+ * constructor() {
+ * this.emitter = createNanoEvents()
+ * }
+ * on(...args) {
+ * return this.emitter.on(...args)
+ * }
+ * tick() {
+ * this.emitter.emit('tick')
+ * }
+ * }
+ * ```
+ * @returns Event emitter.
+ */
+export function createNanoEvents() {
+    return {
+        emit(event, ...args) {
+            for (let i = 0, callbacks = this.events[event] || [], length = callbacks.length; i < length; i++) {
+                callbacks[i](...args);
+            }
+        },
+        events: {},
+        on(event, cb) {
+            (this.events[event] ||= []).push(cb);
+            return () => {
+                this.events[event] = this.events[event]?.filter((i) => cb !== i);
+            };
+        },
+    };
+}

package/build/service-plugin-modules.d.ts

@@ -1,8 +1,33 @@
-import { ServicePluginContract, ServicePluginDefinition } from '@wix/sdk-types';
+import { AuthenticationStrategy, ServicePluginContract, ServicePluginDefinition } from '@wix/sdk-types';
+import { Emitter } from './nanoevents.js';
 export declare const isServicePluginModule: (val: any) => val is ServicePluginDefinition<ServicePluginContract>;
-export declare function buildServicePluginDefinition<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T, registrServicePluginImplementation: (servicePluginDefinition: T, implementation: T['__contract']) => void, decodeJWT?: (token: string, verifyCallerClaims?: boolean) => Promise<{
-    decoded: {
-        data: string;
-    };
-    valid: boolean;
-}>): (implementation: T['__contract']) => void;
+export type UnknownServicePluginResponse = unknown;
+type ServicePluginRequestMetadata = {
+    instanceId: string;
+    appExtensionType: string;
+};
+type ServicePluginRequest = {
+    metadata: ServicePluginRequestMetadata;
+    request: unknown;
+};
+export type ServicePluginsClient = Emitter<{
+    registered: (servicePluginDefinition: ServicePluginDefinition<ServicePluginContract>) => void;
+}> & {
+    getRegisteredServicePlugins(): Map<string, {
+        servicePluginDefinition: ServicePluginDefinition<any>;
+        implementation: ServicePluginContract;
+    }[]>;
+    process(request: {
+        url: string;
+        body: string;
+    }): Promise<unknown>;
+    processRequest(request: Request): Promise<Response>;
+    parseJWT(jwt: string): Promise<ServicePluginRequest>;
+    parseRequest(request: Request): Promise<ServicePluginRequest>;
+    executeHandler(servicePluginRequest: ServicePluginRequest, url: string): Promise<UnknownServicePluginResponse>;
+};
+export declare function servicePluginsModules(authStrategy: AuthenticationStrategy<any>): {
+    initModule<T extends ServicePluginDefinition<any>>(servicePluginDefinition: T): (implementation: T["__contract"]) => void;
+    client: ServicePluginsClient;
+};
+export {};

package/build/service-plugin-modules.js

@@ -1,6 +1,74 @@
+import { createNanoEvents } from './nanoevents.js';
 export const isServicePluginModule = (val) => val.__type === 'service-plugin-definition';
-export function buildServicePluginDefinition(servicePluginDefinition, registrServicePluginImplementation, decodeJWT) {
-    return (implementation) => {
-        registrServicePluginImplementation(servicePluginDefinition, implementation);
+export function servicePluginsModules(authStrategy) {
+    const servicePluginsImplementations = new Map();
+    const servicePluginsEmitter = createNanoEvents();
+    const client = {
+        ...servicePluginsEmitter,
+        getRegisteredServicePlugins: () => servicePluginsImplementations,
+        async parseJWT(jwt) {
+            if (!authStrategy.decodeJWT) {
+                throw new Error('decodeJWT is not supported by the authentication strategy');
+            }
+            const { decoded, valid } = await authStrategy.decodeJWT(jwt, true);
+            if (!valid) {
+                throw new Error('JWT is not valid');
+            }
+            if (typeof decoded.data !== 'object' ||
+                decoded.data === null ||
+                !('metadata' in decoded.data) ||
+                typeof decoded.data.metadata !== 'object' ||
+                decoded.data.metadata === null ||
+                !('appExtensionType' in decoded.data.metadata) ||
+                typeof decoded.data.metadata.appExtensionType !== 'string') {
+                throw new Error('Unexpected JWT data: expected object with metadata.appExtensionType string');
+            }
+            return decoded.data;
+        },
+        async process(request) {
+            const servicePluginRequest = await this.parseJWT(request.body);
+            return this.executeHandler(servicePluginRequest, request.url);
+        },
+        async parseRequest(request) {
+            const body = await request.text();
+            return this.parseJWT(body);
+        },
+        async processRequest(request) {
+            const url = request.url;
+            const body = await request.text();
+            const implMethodResult = await this.process({ url, body });
+            return Response.json(implMethodResult);
+        },
+        async executeHandler(servicePluginRequest, url) {
+            const componentType = servicePluginRequest.metadata.appExtensionType.toLowerCase();
+            const implementations = servicePluginsImplementations.get(componentType) ?? [];
+            if (implementations.length === 0) {
+                throw new Error(`No service plugin implementations found for component type ${componentType}`);
+            }
+            else if (implementations.length > 1) {
+                throw new Error(`Multiple service plugin implementations found for component type ${componentType}. This is currently not supported`);
+            }
+            const { implementation: impl, servicePluginDefinition } = implementations[0];
+            const method = servicePluginDefinition.methods.find((m) => url.endsWith(m.primaryHttpMappingPath));
+            if (!method) {
+                throw new Error('Unexpect request: request url did not match any method: ' + url);
+            }
+            const implMethod = impl[method.name];
+            if (!implMethod) {
+                throw new Error(`Got request for service plugin method ${method.name} but no implementation was provided. Available methods: ${Object.keys(impl).join(', ')}`);
+            }
+            return method.transformations.toREST(await implMethod(method.transformations.fromREST(servicePluginRequest)));
+        },
+    };
+    return {
+        initModule(servicePluginDefinition) {
+            return (implementation) => {
+                const implementations = servicePluginsImplementations.get(servicePluginDefinition.componentType.toLowerCase()) ?? [];
+                implementations.push({ servicePluginDefinition, implementation });
+                servicePluginsImplementations.set(servicePluginDefinition.componentType.toLowerCase(), implementations);
+                servicePluginsEmitter.emit('registered', servicePluginDefinition);
+            };
+        },
+        client,
     };
 }

package/build/wixClient.d.ts

@@ -1,6 +1,8 @@
-import { AuthenticationStrategy, BoundAuthenticationStrategy, BuildDescriptors, Descriptors, EventDefinition, EventIdentity, Host, HostModule, RESTFunctionDescriptor, ServicePluginContract, ServicePluginDefinition } from '@wix/sdk-types';
+import { AuthenticationStrategy, BoundAuthenticationStrategy, BuildDescriptors, Descriptors, Host, HostModule, RESTFunctionDescriptor } from '@wix/sdk-types';
 import { EmptyObject } from 'type-fest/source/empty-object.js';
 import type { GraphQLFormattedError } from 'graphql';
+import { EventHandlersClient } from './event-handlers-modules.js';
+import { ServicePluginsClient } from './service-plugin-modules.js';
 export type ContextType = 'global' | 'module';
 type Headers = Record<string, string>;
 /**
@@ -42,55 +44,9 @@ export type WixClient<H extends Host<any> | undefined = undefined, Z extends Aut
         data: Result;
         errors?: GraphQLFormattedError[];
     }>;
-    webhooks: {
-        getRegisteredEvents(): string[];
-        process<ExpectedEvents extends EventDefinition<any>[] = []>(jwt: string, opts?: {
-            expectedEvents: ExpectedEvents;
-        }): Promise<ProcessedEvent<ExpectedEvents>>;
-        processRequest<ExpectedEvents extends EventDefinition<any>[] = []>(request: Request, opts?: {
-            expectedEvents: ExpectedEvents;
-        }): Promise<ProcessedEvent<ExpectedEvents>>;
-        parseJWT(jwt: string): Promise<ProcessedEvent>;
-        parseRequest(request: Request): Promise<ProcessedEvent>;
-        executeHandlers(event: ProcessedEvent): Promise<void>;
-        apps: {
-            AppInstalled: EventDefinition<{
-                appId: string;
-                originInstanceId: string;
-            }, 'AppInstalled'>;
-            AppRemoved: EventDefinition<{
-                appId: string;
-            }, 'AppRemoved'>;
-        };
-    };
-    servicePlugins: {
-        getRegisteredServicePlugins(): Map<string, {
-            servicePluginDefinition: ServicePluginDefinition<any>;
-            implementation: ServicePluginContract;
-        }[]>;
-        process(request: {
-            url: string;
-            body: string;
-        }): Promise<unknown>;
-        processRequest(request: Request): Promise<Response>;
-        parseJWT(jwt: string): Promise<unknown>;
-        parseRequest(request: Request): Promise<unknown>;
-        executeHandler(servicePluginRequest: ProcessedEvent): Promise<void>;
-    };
+    webhooks: EventHandlersClient;
+    servicePlugins: ServicePluginsClient;
 } & BuildDescriptors<T, H>;
-type ResolvePossibleEvents<T extends EventDefinition<any>[]> = {
-    [K in keyof T]: T[K] extends EventDefinition<any> ? {
-        eventType: T[K]['type'];
-        payload: T[K]['__payload'];
-    } : never;
-} extends (infer U)[] ? U : never;
-export type ProcessedEvent<T extends EventDefinition<any>[] = []> = {
-    instanceId: string;
-    identity?: EventIdentity;
-} & (T['length'] extends 0 ? {
-    eventType: string;
-    payload: unknown;
-} : ResolvePossibleEvents<T>);
 export declare function createClient<H extends Host<any> | undefined = undefined, Z extends AuthenticationStrategy<H> = AuthenticationStrategy<H>, T extends Descriptors = EmptyObject>(config: {
     modules?: H extends Host<any> ? AssertHostMatches<T, H> : T;
     auth?: Z;

package/build/wixClient.js

@@ -1,23 +1,23 @@
 import { wixContext } from '@wix/sdk-context';
-import { EventDefinition, SERVICE_PLUGIN_ERROR_TYPE, } from '@wix/sdk-types';
+import { SERVICE_PLUGIN_ERROR_TYPE, } from '@wix/sdk-types';
 import { ambassadorModuleOptions, isAmbassadorModule, toHTTPModule, } from './ambassador-modules.js';
 import { API_URL, PUBLIC_METADATA_KEY } from './common.js';
 import { FetchErrorResponse } from './fetch-error.js';
 import { getDefaultContentHeader, isObject } from './helpers.js';
 import { buildHostModule, isHostModule } from './host-modules.js';
 import { buildRESTDescriptor } from './rest-modules.js';
-import { buildEventDefinition, isEventHandlerModule, runHandler, } from './event-handlers-modules.js';
-import { buildServicePluginDefinition, isServicePluginModule, } from './service-plugin-modules.js';
+import { eventHandlersModules, isEventHandlerModule, } from './event-handlers-modules.js';
+import { isServicePluginModule, servicePluginsModules, } from './service-plugin-modules.js';
 export function createClient(config) {
     const _headers = config.headers || { Authorization: '' };
-    const eventHandlers = new Map();
-    const servicePluginsImplementations = new Map();
     const authStrategy = config.auth ||
         {
             getAuthHeaders: (_) => Promise.resolve({ headers: {} }),
         };
     const boundGetAuthHeaders = authStrategy.getAuthHeaders.bind(undefined, config.host);
     authStrategy.getAuthHeaders = boundGetAuthHeaders;
+    const { client: servicePluginsClient, initModule: initServicePluginModule } = servicePluginsModules(authStrategy);
+    const { client: eventHandlersClient, initModule: initEventHandlerModule } = eventHandlersModules(authStrategy);
     const boundFetch = async (url, options) => {
         const authHeaders = await boundGetAuthHeaders();
         const defaultContentTypeHeader = getDefaultContentHeader(options);
@@ -36,18 +36,10 @@ export function createClient(config) {
     // excessively deep and possibly infinite.`
     const use = (modules, metadata) => {
         if (isEventHandlerModule(modules)) {
-            return buildEventDefinition(modules, (eventDefinition, handler) => {
-                const handlers = eventHandlers.get(eventDefinition.type) ?? [];
-                handlers.push({ eventDefinition, handler });
-                eventHandlers.set(eventDefinition.type, handlers);
-            });
+            return initEventHandlerModule(modules);
         }
         else if (isServicePluginModule(modules)) {
-            return buildServicePluginDefinition(modules, (servicePluginDefinition, implementation) => {
-                const implementations = servicePluginsImplementations.get(servicePluginDefinition.componentType.toLowerCase()) ?? [];
-                implementations.push({ servicePluginDefinition, implementation });
-                servicePluginsImplementations.set(servicePluginDefinition.componentType.toLowerCase(), implementations);
-            });
+            return initServicePluginModule(modules);
         }
         else if (isHostModule(modules) && config.host) {
             return buildHostModule(modules, config.host);
@@ -161,137 +153,7 @@ export function createClient(config) {
             const { data, errors } = await res.json();
             return { data: data ?? {}, errors };
         },
-        webhooks: {
-            getRegisteredEvents: () => Array.from(eventHandlers.keys()),
-            async process(jwt, opts = {
-                expectedEvents: [],
-            }) {
-                const { eventType, identity, instanceId, payload } = await this.parseJWT(jwt);
-                const allExpectedEvents = [
-                    ...opts.expectedEvents,
-                    ...Array.from(eventHandlers.keys()).map((type) => ({ type })),
-                ];
-                if (allExpectedEvents.length > 0 &&
-                    !allExpectedEvents.some(({ type }) => type === eventType)) {
-                    throw new Error(`Unexpected event type: ${eventType}. Expected one of: ${allExpectedEvents
-                        .map((x) => x.type)
-                        .join(', ')}`);
-                }
-                const handlers = eventHandlers.get(eventType) ?? [];
-                await Promise.all(handlers.map(({ eventDefinition, handler }) => runHandler(eventDefinition, handler, payload, {
-                    instanceId,
-                    identity,
-                })));
-                return {
-                    instanceId,
-                    eventType,
-                    payload,
-                    identity,
-                };
-            },
-            async processRequest(request, opts) {
-                const body = await request.text();
-                return this.process(body, opts);
-            },
-            async parseJWT(jwt) {
-                if (!authStrategy.decodeJWT) {
-                    throw new Error('decodeJWT is not supported by the authentication strategy');
-                }
-                const { decoded, valid } = await authStrategy.decodeJWT(jwt);
-                if (!valid) {
-                    throw new Error('JWT is not valid');
-                }
-                if (typeof decoded.data !== 'string') {
-                    throw new Error(`Unexpected type of JWT data: expected string, got ${typeof decoded.data}`);
-                }
-                const parsedDecoded = JSON.parse(decoded.data);
-                const eventType = parsedDecoded.eventType;
-                const instanceId = parsedDecoded.instanceId;
-                const identity = parsedDecoded.identity
-                    ? JSON.parse(parsedDecoded.identity)
-                    : undefined;
-                const payload = JSON.parse(parsedDecoded.data);
-                return {
-                    instanceId,
-                    eventType,
-                    payload,
-                    identity,
-                };
-            },
-            async parseRequest(request) {
-                const jwt = await request.text();
-                return this.parseJWT(jwt);
-            },
-            async executeHandlers(event) {
-                const allExpectedEvents = Array.from(eventHandlers.keys()).map((type) => ({ type }));
-                if (allExpectedEvents.length > 0 &&
-                    !allExpectedEvents.some(({ type }) => type === event.eventType)) {
-                    throw new Error(`Unexpected event type: ${event.eventType}. Expected one of: ${allExpectedEvents
-                        .map((x) => x.type)
-                        .join(', ')}`);
-                }
-                const handlers = eventHandlers.get(event.eventType) ?? [];
-                await Promise.all(handlers.map(({ eventDefinition, handler }) => runHandler(eventDefinition, handler, event.payload, {
-                    instanceId: event.instanceId,
-                    identity: event.identity,
-                })));
-            },
-            apps: {
-                AppInstalled: EventDefinition('AppInstalled')(),
-                AppRemoved: EventDefinition('AppRemoved')(),
-            },
-        },
-        servicePlugins: {
-            getRegisteredServicePlugins: () => servicePluginsImplementations,
-            async process(request) {
-                const servicePluginRequest = await this.parseJWT(request.body);
-                return this.executeHandler(servicePluginRequest, request.url);
-            },
-            async processRequest(request) {
-                const url = request.url;
-                const body = await request.text();
-                const implMethodResult = await this.process({ url, body });
-                return Response.json(implMethodResult);
-            },
-            async parseJWT(jwt) {
-                if (!authStrategy.decodeJWT) {
-                    throw new Error('decodeJWT is not supported by the authentication strategy');
-                }
-                const { decoded, valid } = await authStrategy.decodeJWT(jwt, true);
-                if (!valid) {
-                    throw new Error('JWT is not valid');
-                }
-                if (typeof decoded.data !== 'object' ||
-                    decoded.data === null ||
-                    !('metadata' in decoded.data) ||
-                    typeof decoded.data.metadata !== 'object' ||
-                    decoded.data.metadata === null ||
-                    !('appExtensionType' in decoded.data.metadata) ||
-                    typeof decoded.data.metadata.appExtensionType !== 'string') {
-                    throw new Error('Unexpected JWT data: expected object with metadata.appExtensionType string');
-                }
-                return decoded.data;
-            },
-            async executeHandler(servicePluginRequest, url) {
-                const componentType = servicePluginRequest.metadata.appExtensionType.toLowerCase();
-                const implementations = servicePluginsImplementations.get(componentType) ?? [];
-                if (implementations.length === 0) {
-                    throw new Error(`No service plugin implementations found for component type ${componentType}`);
-                }
-                else if (implementations.length > 1) {
-                    throw new Error(`Multiple service plugin implementations found for component type ${componentType}. This is currently not supported`);
-                }
-                const { implementation: impl, servicePluginDefinition } = implementations[0];
-                const method = servicePluginDefinition.methods.find((m) => url.endsWith(m.primaryHttpMappingPath));
-                if (!method) {
-                    throw new Error('Unexpect request: request url did not match any method: ' + url);
-                }
-                const implMethod = impl[method.name];
-                if (!implMethod) {
-                    throw new Error(`Got request for service plugin method ${method.name} but no implementation was provided. Available methods: ${Object.keys(impl).join(', ')}`);
-                }
-                return method.transformations.toREST(await implMethod(method.transformations.fromREST(servicePluginRequest)));
-            },
-        },
+        webhooks: eventHandlersClient,
+        servicePlugins: servicePluginsClient,
     };
 }

package/cjs/build/context.d.ts

@@ -1,5 +1,5 @@
-import { BuildRESTFunction, RESTFunctionDescriptor } from '@wix/sdk-types';
-export declare function elevate<T extends RESTFunctionDescriptor | BuildRESTFunction<any>>(restModule: T): T;
+import { RESTFunctionDescriptor } from '@wix/sdk-types';
+export declare function elevate<T extends RESTFunctionDescriptor>(restModule: T): T;
 export declare const fetchWithAuth: typeof fetch & ((restModuleOpts: import("@wix/sdk-types").HttpClient) => typeof fetch);
 export { graphql } from './graphql.js';
 export { setGlobalWixContext } from './wix-context.js';