@statezero/core/dist/core/eventReceivers.d.ts

The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate

/**
 * Set an event receiver for a specific backend.
 * @param {string} configKey - The backend configuration key
 * @param {EventReceiver} receiver - The event receiver instance
 */
export function setEventReceiver(configKey: string, receiver: EventReceiver): void;
/**
 * Get the event receiver for a specific backend.
 * @param {string} configKey - The backend configuration key
 * @returns {EventReceiver|null}
 */
export function getEventReceiver(configKey?: string): EventReceiver | null;
/**
 * Get all registered event receivers.
 * @returns {Map<string, EventReceiver>}
 */
export function getAllEventReceivers(): Map<string, EventReceiver>;
/**
 * Set a custom namespace resolver function for a specific backend.
 * @param {string} configKey - The backend configuration key
 * @param {NamespaceResolver} resolver
 */
export function setNamespaceResolver(configKey: string, resolver: NamespaceResolver): void;
/**
 * Event types that can be received from the server.
 */
export type EventType = string;
export namespace EventType {
    let CREATE: string;
    let UPDATE: string;
    let DELETE: string;
    let BULK_UPDATE: string;
    let BULK_DELETE: string;
}
/**
 * Callback for handling model events.
 * @callback EventHandler
 * @param {ModelEvent} event - The event object.
 */
/**
 * A namespace resolver function.
 * @callback NamespaceResolver
 * @param {string} modelName - The model name.
 * @returns {string} The namespace.
 */
/**
 * Options for instantiating a Pusher client.
 * @typedef {Object} PusherClientOptions
 * @property {string} appKey
 * @property {string} cluster
 * @property {boolean} [forceTLS]
 * @property {string} authEndpoint
 * @property {function(): Object<string, string>} [getAuthHeaders]
 */
/**
 * Configuration options for Pusher event receivers.
 * @typedef {Object} PusherReceiverOptions
 * @property {PusherClientOptions} clientOptions
 * @property {function(string): string} [formatChannelName] - Optional channel name formatter. Default: (namespace) => `private-${namespace}`
 * @property {NamespaceResolver} [namespaceResolver] - Optional namespace resolver. Default: (modelName) => modelName.
 */
/**
 * Implementation of EventReceiver that uses Pusher.
 */
export class PusherEventReceiver {
    /**
     * @param {PusherReceiverOptions} options
     * @param {string} configKey - The backend configuration key
     */
    constructor(options: PusherReceiverOptions, configKey: string);
    configKey: string;
    pusherClient: Pusher;
    formatChannelName: (ns: string) => string;
    namespaceResolver: (modelName: string) => string;
    channels: Map<any, any>;
    eventHandlers: Set<any>;
    /**
     * Set the namespace resolver function.
     * @param {NamespaceResolver} resolver
     */
    setNamespaceResolver(resolver: NamespaceResolver): void;
    /**
     * Connect to Pusher (no-op since Pusher handles connection automatically).
     */
    connect(): void;
    /**
     * Subscribe to events for a specific namespace.
     * @param {string} namespace
     */
    subscribe(namespace: string): void;
    unsubscribe(namespace: any): void;
    /**
     * Disconnect from Pusher.
     */
    disconnect(): void;
    /**
     * Add handler for model events
     * @param {EventHandler} handler
     */
    addModelEventHandler(handler: EventHandler): void;
    /**
     * Legacy method - adds event handler for backwards compatibility
     * @param {EventHandler} handler
     */
    addEventHandler(handler: EventHandler): void;
    /**
     * Remove an event handler callback.
     * @param {EventHandler} handler
     */
    removeEventHandler(handler: EventHandler): void;
    /**
     * Get namespace from model name using the resolver.
     * @param {string} modelName
     * @returns {string}
     */
    getNamespace(modelName: string): string;
}
/**
 * Structure of events received from the server.
 */
export type ModelEvent = {
    /**
     * - Support both frontend (type) and backend (event) naming conventions.
     */
    type?: string | undefined;
    event?: string | undefined;
    model: string;
    data?: any;
    operationId?: string | undefined;
    namespace?: string | undefined;
    /**
     * - For bulk events.
     */
    instances?: (string | number)[] | undefined;
    pk_field_name?: string | undefined;
    /**
     * - The backend configuration key this event is associated with.
     */
    configKey?: string | undefined;
    /**
     * - Additional open-ended keys.
     */
    key?: any;
};
/**
 * Callback for handling model events.
 */
export type EventHandler = (event: ModelEvent) => any;
/**
 * A namespace resolver function.
 */
export type NamespaceResolver = (modelName: string) => string;
/**
 * Options for instantiating a Pusher client.
 */
export type PusherClientOptions = {
    appKey: string;
    cluster: string;
    forceTLS?: boolean | undefined;
    authEndpoint: string;
    getAuthHeaders?: (() => {
        [x: string]: string;
    }) | undefined;
};
/**
 * Configuration options for Pusher event receivers.
 */
export type PusherReceiverOptions = {
    clientOptions: PusherClientOptions;
    /**
     * - Optional channel name formatter. Default: (namespace) => `private-${namespace}`
     */
    formatChannelName?: ((arg0: string) => string) | undefined;
    /**
     * - Optional namespace resolver. Default: (modelName) => modelName.
     */
    namespaceResolver?: NamespaceResolver | undefined;
};
import Pusher from 'pusher-js';