@wix/sdk 1.12.8 → 1.12.9

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';
 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';
 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/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';
 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';
 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/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';
 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/cjs/build/event-handlers-modules.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runHandler = exports.buildEventDefinition = exports.isEventHandlerModule = void 0;
+exports.eventHandlersModules = exports.buildEventDefinition = exports.isEventHandlerModule = void 0;
+const sdk_types_1 = require("@wix/sdk-types");
+const nanoevents_1 = require("nanoevents");
 const isEventHandlerModule = (val) => val.__type === 'event-definition';
 exports.isEventHandlerModule = isEventHandlerModule;
 function buildEventDefinition(eventDefinition, registerHandler) {
@@ -51,4 +53,100 @@ function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
     const transformFromRESTFn = eventDefinition.transformations ?? ((x) => x);
     return handler(transformFromRESTFn(envelope));
 }
-exports.runHandler = runHandler;
+function eventHandlersModules(authStrategy) {
+    const eventHandlers = new Map();
+    const webhooksEmitter = (0, nanoevents_1.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: (0, sdk_types_1.EventDefinition)('AppInstalled')(),
+            AppRemoved: (0, sdk_types_1.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,
+    };
+}
+exports.eventHandlersModules = eventHandlersModules;

package/cjs/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';
 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/cjs/build/service-plugin-modules.js

@@ -1,11 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildServicePluginDefinition = exports.isServicePluginModule = void 0;
+exports.servicePluginsModules = exports.isServicePluginModule = void 0;
+const nanoevents_1 = require("nanoevents");
 const isServicePluginModule = (val) => val.__type === 'service-plugin-definition';
 exports.isServicePluginModule = isServicePluginModule;
-function buildServicePluginDefinition(servicePluginDefinition, registrServicePluginImplementation, decodeJWT) {
-    return (implementation) => {
-        registrServicePluginImplementation(servicePluginDefinition, implementation);
+function servicePluginsModules(authStrategy) {
+    const servicePluginsImplementations = new Map();
+    const servicePluginsEmitter = (0, nanoevents_1.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,
     };
 }
-exports.buildServicePluginDefinition = buildServicePluginDefinition;
+exports.servicePluginsModules = servicePluginsModules;

package/cjs/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/cjs/build/wixClient.js

@@ -13,14 +13,14 @@ const event_handlers_modules_js_1 = require("./event-handlers-modules.js");
 const service_plugin_modules_js_1 = require("./service-plugin-modules.js");
 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 } = (0, service_plugin_modules_js_1.servicePluginsModules)(authStrategy);
+    const { client: eventHandlersClient, initModule: initEventHandlerModule } = (0, event_handlers_modules_js_1.eventHandlersModules)(authStrategy);
     const boundFetch = async (url, options) => {
         const authHeaders = await boundGetAuthHeaders();
         const defaultContentTypeHeader = (0, helpers_js_1.getDefaultContentHeader)(options);
@@ -39,18 +39,10 @@ function createClient(config) {
     // excessively deep and possibly infinite.`
     const use = (modules, metadata) => {
         if ((0, event_handlers_modules_js_1.isEventHandlerModule)(modules)) {
-            return (0, event_handlers_modules_js_1.buildEventDefinition)(modules, (eventDefinition, handler) => {
-                const handlers = eventHandlers.get(eventDefinition.type) ?? [];
-                handlers.push({ eventDefinition, handler });
-                eventHandlers.set(eventDefinition.type, handlers);
-            });
+            return initEventHandlerModule(modules);
         }
         else if ((0, service_plugin_modules_js_1.isServicePluginModule)(modules)) {
-            return (0, service_plugin_modules_js_1.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 ((0, host_modules_js_1.isHostModule)(modules) && config.host) {
             return (0, host_modules_js_1.buildHostModule)(modules, config.host);
@@ -164,138 +156,8 @@ 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 }) => (0, event_handlers_modules_js_1.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 }) => (0, event_handlers_modules_js_1.runHandler)(eventDefinition, handler, event.payload, {
-                    instanceId: event.instanceId,
-                    identity: event.identity,
-                })));
-            },
-            apps: {
-                AppInstalled: (0, sdk_types_1.EventDefinition)('AppInstalled')(),
-                AppRemoved: (0, sdk_types_1.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,
     };
 }
 exports.createClient = createClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/sdk",
-  "version": "1.12.8",
+  "version": "1.12.9",
   "license": "UNLICENSED",
   "author": {
     "name": "Ronny Ringel",
@@ -65,13 +65,14 @@
   "dependencies": {
     "@babel/runtime": "^7.23.2",
     "@wix/identity": "^1.0.78",
-    "@wix/image-kit": "^1.74.0",
+    "@wix/image-kit": "^1.77.0",
     "@wix/redirects": "^1.0.41",
     "@wix/sdk-context": "^0.0.1",
-    "@wix/sdk-runtime": "0.3.12",
+    "@wix/sdk-runtime": "0.3.14",
     "@wix/sdk-types": "^1.9.2",
     "crypto-js": "^4.2.0",
     "jose": "^5.2.1",
+    "nanoevents": "^9.0.0",
     "pkce-challenge": "^3.1.0",
     "querystring": "^0.2.1",
     "type-fest": "^4.9.0"
@@ -88,7 +89,7 @@
     "@wix/events": "^1.0.179",
     "@wix/metro": "^1.0.73",
     "@wix/metro-runtime": "^1.1677.0",
-    "@wix/sdk-runtime": "0.3.12",
+    "@wix/sdk-runtime": "0.3.14",
     "eslint": "^8.56.0",
     "eslint-config-sdk": "0.0.0",
     "graphql": "^16.8.0",
@@ -122,5 +123,5 @@
   "wallaby": {
     "autoDetect": true
   },
-  "falconPackageHash": "4a3ca02dc12093515b122a61d87d631718a0d7de19fe8ad5a6ef4ab4"
+  "falconPackageHash": "fac4a20ec702fb1a9e081a3fe2eb9dc105d284baeb49281de73dbf0e"
 }