@holo-js/broadcast 0.2.6 → 0.3.0

package/dist/contracts.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedHoloBroadcastConfig } from '@holo-js/config';
+import { NormalizedHoloBroadcastConfig } from './config.js';
 import { ValidationSchema, InferSchemaData } from '@holo-js/validation';
 
 declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/index.d.ts

@@ -4,12 +4,37 @@ import { authorizeBroadcastChannel, parseBroadcastAuthEndpointPayload, renderBro
 export { broadcastAuthInternals } from './auth.js';
 import { renderBroadcastClientConfigResponse, resolveBroadcastClientConfig } from './client-config.js';
 export { BroadcastClientConfig } from './client-config.js';
-import { NormalizedHoloBroadcastConfig, NormalizedHoloQueueConfig, NormalizedHoloRedisConfig } from '@holo-js/config';
-export { HoloBroadcastConfig, NormalizedHoloBroadcastConfig, defineBroadcastConfig } from '@holo-js/config';
+import { NormalizedHoloBroadcastConfig } from './config.js';
+export { HoloBroadcastConfig, defineBroadcastConfig, holoBroadcastDefaults, normalizeBroadcastConfig } from './config.js';
+import { NormalizedHoloRedisConfig } from '@holo-js/kernel';
+import { NormalizedHoloQueueConfig } from '@holo-js/queue';
+import { ServerResponse } from 'node:http';
 import { broadcast, broadcastRaw, configureBroadcastRuntime, getBroadcastRuntime, getBroadcastRuntimeBindings, resetBroadcastRuntime } from './runtime.js';
 export { broadcastRuntimeInternals } from './runtime.js';
 import '@holo-js/validation';
 
+type WorkerPublishBody = {
+    readonly name: string;
+    readonly channels: readonly string[];
+    readonly data: string;
+    readonly socket_id?: string;
+};
+declare function parseWorkerSocketMessage(rawMessage: string): {
+    readonly event: string;
+    readonly channel?: string;
+    readonly data: Record<string, unknown>;
+};
+declare function normalizeWorkerPublishBody(value: unknown): WorkerPublishBody;
+declare function createWorkerPusherSignature(secret: string, method: string, pathname: string, params: URLSearchParams): string;
+declare function verifyWorkerPusherSignature(providedSignature: string, expectedSignature: string): boolean;
+declare function parseWorkerChannelKind(channel: string): {
+    readonly kind: 'public' | 'private' | 'presence';
+    readonly canonical: string;
+};
+
+declare function readLimitedRequestText(request: Request, maxBytes: number): Promise<string>;
+declare function writeNodeRequestBodyError(response: ServerResponse, error: unknown): void;
+
 type WorkerConnectionInfo = {
     readonly socketId: string;
     readonly app: BroadcastWorkerApp;
@@ -19,12 +44,6 @@ type WorkerWebSocketConnection = WorkerConnectionInfo & {
     readonly send: (payload: string) => void;
     readonly close: (code?: number, reason?: string) => void;
 };
-type PublishBody = {
-    readonly name: string;
-    readonly channels: readonly string[];
-    readonly data: string;
-    readonly socket_id?: string;
-};
 type BroadcastWorkerApp = {
     readonly connection: string;
     readonly appId: string;
@@ -33,6 +52,10 @@ type BroadcastWorkerApp = {
     readonly authEndpoint?: string;
 };
 type PresenceMember = Readonly<Record<string, unknown>>;
+type ClientChannelAuth = {
+    readonly auth: string;
+    readonly channelData?: string;
+};
 type WorkerRuntimeOptions = {
     readonly config: NormalizedHoloBroadcastConfig;
     readonly channelAuth?: BroadcastChannelAuthRuntimeBindings;
@@ -75,6 +98,15 @@ interface StartedBroadcastWorker {
     readonly port: number;
     readonly stop: () => Promise<void>;
 }
+declare function isAllowedWorkerOrigin(request: Request, allowedOrigins: readonly string[]): boolean;
+type RealtimeSocketAction = 'query' | 'mutation' | 'subscribe' | 'unsubscribe';
+type RealtimeSocketMessage = {
+    readonly id: string;
+    readonly action: RealtimeSocketAction;
+    readonly name?: string;
+    readonly args: Record<string, unknown>;
+};
+type RealtimeWireErrorKind = 'authorization' | 'transport' | 'runtime';
 type BroadcastRedisScalingConnection = {
     readonly url?: string;
     readonly clusters?: readonly {
@@ -103,27 +135,37 @@ type BroadcastWorkerScalingRuntime = {
     readonly eventChannel: string;
     readonly adapter: BroadcastScalingAdapter;
 };
-declare function parseSocketMessage(rawMessage: string): {
-    readonly event: string;
-    readonly channel?: string;
-    readonly data: Record<string, unknown>;
+declare function normalizeRealtimeAction(value: unknown): RealtimeSocketAction;
+declare function normalizeRealtimeArgs(value: unknown): Record<string, unknown>;
+declare function parseRealtimeSocketMessage(data: Record<string, unknown>): RealtimeSocketMessage;
+declare function logSocketMessageError(socketId: string, error: unknown): void;
+declare function logScalingMessageError(error: unknown): void;
+declare function logSocketCleanupError(socketId: string, channel: string, error: unknown): void;
+declare function logRealtimeSubscriptionCleanupError(socketId: string, subscriptionId: string, error: unknown): void;
+declare function safeEqual(left: string, right: string): boolean;
+declare function signChannelAuth(secret: string, socketId: string, channel: string, channelData: string): string;
+declare function parseClientChannelAuth(data: Record<string, unknown>): ClientChannelAuth | undefined;
+declare function parseSignedChannelData(value: string | undefined): {
+    readonly whispers: readonly string[];
+    readonly member?: PresenceMember;
 };
-declare function normalizePublishBody(value: unknown): PublishBody;
-declare function createPusherSignature(secret: string, method: string, pathname: string, params: URLSearchParams): string;
-declare function verifyPusherSignature(providedSignature: string, expectedSignature: string): boolean;
-declare function parseChannelKind(channel: string): {
-    readonly kind: 'public' | 'private' | 'presence';
-    readonly canonical: string;
+declare function verifyClientChannelAuth(app: BroadcastWorkerApp, socketId: string, channel: string, clientAuth: ClientChannelAuth): {
+    readonly whispers: readonly string[];
+    readonly member?: PresenceMember;
 };
 declare function createSocketId(): string;
 declare function createScalingNodeId(): string;
 declare function resolveScalingEventChannel(connection: string): string;
+declare function resolvePresenceMemberId(member: PresenceMember, fallback: string): string;
 declare function parsePresenceHashMembers(values: Readonly<Record<string, string>>): Map<string, PresenceMember>;
 declare function resolveRedisScalingConnection(queueConfig: NormalizedHoloQueueConfig | undefined, connectionName: string, redisConfig?: NormalizedHoloRedisConfig): BroadcastRedisScalingConnection;
 declare function createRedisScalingAdapter(connection: BroadcastRedisScalingConnection, dependencies?: {
     readonly loadRedisModule?: () => Promise<unknown>;
 }): Promise<BroadcastScalingAdapter>;
 declare function buildWorkerApps(config: NormalizedHoloBroadcastConfig): Readonly<Record<string, BroadcastWorkerApp>>;
+declare function resolveRealtimeErrorStatus(error: unknown): number | undefined;
+declare function resolveRealtimeErrorCode(error: unknown): string | undefined;
+declare function resolveRealtimeErrorKind(error: unknown, status: number | undefined): RealtimeWireErrorKind;
 declare function createBroadcastWorkerRuntime(options: WorkerRuntimeOptions): BroadcastWorkerRuntime;
 declare function startBroadcastWorker(runtimeBindings: Pick<BroadcastRuntimeBindings, 'config' | 'channelAuth'> & {
     readonly realtime?: BroadcastRealtimeRuntimeBindings;
@@ -139,17 +181,39 @@ declare const workerInternals: {
     buildWorkerApps: typeof buildWorkerApps;
     createScalingNodeId: typeof createScalingNodeId;
     createRedisScalingAdapter: typeof createRedisScalingAdapter;
-    createPusherSignature: typeof createPusherSignature;
-    verifyPusherSignature: typeof verifyPusherSignature;
+    createPusherSignature: typeof createWorkerPusherSignature;
+    verifyPusherSignature: typeof verifyWorkerPusherSignature;
     createSocketId: typeof createSocketId;
     resolveRedisScalingConnection: typeof resolveRedisScalingConnection;
     resolveScalingEventChannel: typeof resolveScalingEventChannel;
-    normalizePublishBody: typeof normalizePublishBody;
-    parseChannelKind: typeof parseChannelKind;
+    normalizePublishBody: typeof normalizeWorkerPublishBody;
+    parseChannelKind: typeof parseWorkerChannelKind;
     parsePresenceHashMembers: typeof parsePresenceHashMembers;
-    parseSocketMessage: typeof parseSocketMessage;
+    parseSocketMessage: typeof parseWorkerSocketMessage;
+    isAllowedWorkerOrigin: typeof isAllowedWorkerOrigin;
+    readLimitedRequestText: typeof readLimitedRequestText;
+    normalizeRealtimeAction: typeof normalizeRealtimeAction;
+    normalizeRealtimeArgs: typeof normalizeRealtimeArgs;
+    parseRealtimeSocketMessage: typeof parseRealtimeSocketMessage;
+    logSocketMessageError: typeof logSocketMessageError;
+    logScalingMessageError: typeof logScalingMessageError;
+    logSocketCleanupError: typeof logSocketCleanupError;
+    logRealtimeSubscriptionCleanupError: typeof logRealtimeSubscriptionCleanupError;
+    safeEqual: typeof safeEqual;
+    signChannelAuth: typeof signChannelAuth;
+    parseClientChannelAuth: typeof parseClientChannelAuth;
+    parseSignedChannelData: typeof parseSignedChannelData;
+    verifyClientChannelAuth: typeof verifyClientChannelAuth;
+    resolvePresenceMemberId: typeof resolvePresenceMemberId;
+    resolveRealtimeErrorStatus: typeof resolveRealtimeErrorStatus;
+    resolveRealtimeErrorCode: typeof resolveRealtimeErrorCode;
+    resolveRealtimeErrorKind: typeof resolveRealtimeErrorKind;
+    writeNodeRequestBodyError: typeof writeNodeRequestBodyError;
 };
 
+declare function loadBroadcastPluginDrivers(projectRoot?: string, pluginNames?: readonly string[]): Promise<void>;
+declare function resetBroadcastPluginDrivers(): void;
+
 declare function normalizeDriverName(name: string): string;
 declare function registerBroadcastDriver(name: string, driver: BroadcastDriver, options?: RegisterBroadcastDriverOptions): RegisteredBroadcastDriver;
 declare function getRegisteredBroadcastDriver(name: string): BroadcastDriver | undefined;
@@ -183,4 +247,4 @@ declare const broadcastPackage: Readonly<{
     createBroadcastWorkerRuntime: typeof createBroadcastWorkerRuntime;
 }>;
 
-export { BroadcastChannelAuthRuntimeBindings, BroadcastDriver, BroadcastRealtimeRuntimeBindings, BroadcastRuntimeBindings, type BroadcastWorkerRuntime, type BroadcastWorkerStats, RegisterBroadcastDriverOptions, RegisteredBroadcastDriver, type StartedBroadcastWorker, authorizeBroadcastChannel, broadcast, broadcastRaw, broadcastRegistryInternals, channel, configureBroadcastRuntime, createBroadcastWorkerRuntime, broadcastPackage as default, defineBroadcast, defineChannel, getBroadcastRuntime, getBroadcastRuntimeBindings, getRegisteredBroadcastDriver, listRegisteredBroadcastDrivers, parseBroadcastAuthEndpointPayload, presenceChannel, privateChannel, registerBroadcastDriver, renderBroadcastAuthResponse, renderBroadcastClientConfigResponse, resetBroadcastDriverRegistry, resetBroadcastRuntime, resolveBroadcastChannelGuard, resolveBroadcastClientConfig, resolveBroadcastWhisperSchema, startBroadcastWorker, validateBroadcastWhisperPayload, workerInternals };
+export { BroadcastChannelAuthRuntimeBindings, BroadcastDriver, BroadcastRealtimeRuntimeBindings, BroadcastRuntimeBindings, type BroadcastWorkerRuntime, type BroadcastWorkerStats, NormalizedHoloBroadcastConfig, RegisterBroadcastDriverOptions, RegisteredBroadcastDriver, type StartedBroadcastWorker, authorizeBroadcastChannel, broadcast, broadcastRaw, broadcastRegistryInternals, channel, configureBroadcastRuntime, createBroadcastWorkerRuntime, broadcastPackage as default, defineBroadcast, defineChannel, getBroadcastRuntime, getBroadcastRuntimeBindings, getRegisteredBroadcastDriver, listRegisteredBroadcastDrivers, loadBroadcastPluginDrivers, parseBroadcastAuthEndpointPayload, presenceChannel, privateChannel, registerBroadcastDriver, renderBroadcastAuthResponse, renderBroadcastClientConfigResponse, resetBroadcastDriverRegistry, resetBroadcastPluginDrivers, resetBroadcastRuntime, resolveBroadcastChannelGuard, resolveBroadcastClientConfig, resolveBroadcastWhisperSchema, startBroadcastWorker, validateBroadcastWhisperPayload, workerInternals };