@emmanuel-nike/ark-notify-js 0.1.0 → 0.1.2

package/dist/types-tQECeZab.d.ts

@@ -0,0 +1,257 @@
+type UserRole = 'SYSTEM_ADMIN' | 'ACCOUNT_ADMIN' | 'ACCOUNT_USER';
+interface User {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    role: UserRole;
+    createdAt: string;
+}
+interface ApiError {
+    error: string;
+    message: string;
+    reason?: string;
+    retryAfterSec?: number;
+}
+interface ConnectionCapabilities {
+    subscribe: boolean;
+    publish: boolean;
+    presence: boolean;
+}
+interface Application {
+    id: string;
+    name: string;
+    appKey: string;
+    tenantId: string;
+    authWebhookUrl: string | null;
+    requireClientAuth: boolean;
+    serverAuthUrl: string | null;
+    messageHistorySize: number;
+    createdAt: string;
+    updatedAt: string;
+    secret?: string;
+}
+interface CreateApplicationInput {
+    name: string;
+    authWebhookUrl?: string | null;
+    requireClientAuth?: boolean;
+    serverAuthUrl?: string | null;
+    messageHistorySize?: number;
+}
+interface UpdateApplicationInput {
+    name?: string;
+    authWebhookUrl?: string | null;
+    requireClientAuth?: boolean;
+    serverAuthUrl?: string | null;
+    messageHistorySize?: number;
+}
+interface LoginInput {
+    email: string;
+    password: string;
+}
+interface AuthResponse {
+    user: User;
+    token: string;
+}
+interface PublishEventInput {
+    channel: string;
+    event: string;
+    data?: unknown;
+}
+interface PublishEventResponse {
+    published: boolean;
+    channel: string;
+    event: string;
+}
+interface ChannelAuthInput {
+    socket_id?: string;
+    connection_id?: string;
+    channel_name: string;
+    user_data?: Record<string, unknown>;
+}
+interface ChannelAuthResponse {
+    auth: string;
+}
+interface ConnectionTokenInput {
+    client_id?: string;
+    clientId?: string;
+    user_data?: Record<string, unknown>;
+    userData?: Record<string, unknown>;
+    serverAuthUrl?: string | null;
+    server_auth_url?: string | null;
+    ttl?: number;
+    capabilities?: Partial<ConnectionCapabilities>;
+}
+interface ConnectionTokenResponse {
+    token: string;
+    client_id: string;
+    expires_at: number;
+    capabilities: ConnectionCapabilities;
+}
+/** Payload Ark Notify POSTs to your `serverAuthUrl`. */
+interface ServerAuthRequest {
+    client_id: string;
+    user_data?: Record<string, unknown> | null;
+    capabilities?: Partial<ConnectionCapabilities> | null;
+    ttl?: number | null;
+}
+/** Approve a connection token request (option A). */
+interface ServerAuthAllowedResponse {
+    allowed: true;
+    client_id: string;
+    capabilities?: ConnectionCapabilities;
+    ttl?: number;
+}
+/** Approve with a pre-signed token (option B). */
+interface ServerAuthTokenResponse {
+    token: string;
+}
+type ServerAuthApprovedResponse = ServerAuthAllowedResponse | ServerAuthTokenResponse;
+interface ServerAuthDeniedResponse {
+    allowed: false;
+    reason?: string;
+}
+type ServerAuthResponse = ServerAuthApprovedResponse | ServerAuthDeniedResponse;
+interface CreateAuthorizedServerAuthResponseOptions {
+    clientId: string;
+    capabilities?: Partial<ConnectionCapabilities>;
+    ttl?: number;
+    /** When provided, returns a pre-signed token instead of `{ allowed: true }`. */
+    credentials?: AppCredentials;
+}
+type ServerAuthDecision = false | {
+    clientId?: string;
+    capabilities?: Partial<ConnectionCapabilities>;
+    ttl?: number;
+};
+interface HandleServerAuthOptions {
+    request: ServerAuthRequest;
+    isAuthorized: (request: ServerAuthRequest) => ServerAuthDecision | Promise<ServerAuthDecision>;
+    credentials?: AppCredentials;
+}
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'failed';
+interface ConnectedMessage {
+    type: 'connected';
+    connection_id: string;
+    client_id: string;
+    app_key: string;
+    authenticated: boolean;
+    channels?: string[];
+}
+interface EventMessage {
+    type: 'event';
+    channel: string;
+    event: string;
+    data: unknown;
+    clientId: string | null;
+    timestamp: number;
+}
+interface PresenceMemberInfo {
+    connectionId: string;
+    clientId: string;
+    data: Record<string, unknown>;
+    updatedAt: number;
+}
+type PresenceAction = 'enter' | 'leave' | 'update' | 'sync';
+interface PresenceMessage {
+    type: 'presence';
+    channel: string;
+    action: PresenceAction;
+    member: PresenceMemberInfo | null;
+    members: PresenceMemberInfo[] | null;
+    timestamp: number;
+}
+interface SubscribedMessage {
+    type: 'subscribed';
+    channel: string;
+}
+interface UnsubscribedMessage {
+    type: 'unsubscribed';
+    channel: string;
+}
+interface PublishedMessage {
+    type: 'published';
+    channel: string;
+    event: string;
+}
+interface PongMessage {
+    type: 'pong';
+    timestamp: number;
+}
+interface PingMessage {
+    type: 'ping';
+}
+interface ServerErrorMessage {
+    type: 'error';
+    code: string;
+    message: string;
+}
+interface PresenceUpdatedMessage {
+    type: 'presence_updated';
+    channel: string;
+    data: Record<string, unknown>;
+}
+interface PresenceLeftMessage {
+    type: 'presence_left';
+    channel: string;
+}
+type ServerMessage = ConnectedMessage | EventMessage | PresenceMessage | SubscribedMessage | UnsubscribedMessage | PublishedMessage | PongMessage | PingMessage | ServerErrorMessage | PresenceUpdatedMessage | PresenceLeftMessage;
+interface ArkNotifyClientConfig {
+    baseUrl?: string;
+    token?: string | (() => string | null | undefined);
+    fetch?: typeof fetch;
+}
+interface AppCredentials {
+    appKey: string;
+    secret: string;
+}
+type PrivateChannelAuthHandler = (channel: string, connectionId: string) => Promise<string>;
+interface ArkNotifyConnectionConfig {
+    baseUrl?: string;
+    appKey: string;
+    clientId?: string;
+    /** Signed connection token, or a resolver. Omit to auto-fetch when `clientId` is set. */
+    token?: string | (() => string | null | undefined);
+    /** App credentials for auto-fetching a connection token (backend-only when no serverAuthUrl). */
+    credentials?: AppCredentials;
+    /** Override server auth URL when auto-fetching a token; uses the application default when omitted. */
+    serverAuthUrl?: string | null;
+    /** Forwarded to the connection-token endpoint when auto-fetching a token. */
+    user_data?: Record<string, unknown>;
+    autoReconnect?: boolean;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+    onPrivateChannelAuth?: PrivateChannelAuthHandler;
+    fetch?: typeof fetch;
+    WebSocket?: typeof WebSocket;
+}
+interface SubscribeOptions {
+    history?: boolean;
+    presence?: boolean;
+    presence_data?: Record<string, unknown>;
+    auth?: string;
+}
+interface ArkNotifySSEConfig {
+    baseUrl?: string;
+    appKey: string;
+    channels: string[];
+    clientId?: string;
+    token?: string | (() => string | null | undefined);
+    auth?: Record<string, string>;
+    user_data?: Record<string, unknown>;
+    history?: boolean;
+    onPrivateChannelAuth?: PrivateChannelAuthHandler;
+    EventSource?: typeof EventSource;
+}
+interface ChannelEventHandler<T = unknown> {
+    (data: T, message: EventMessage): void;
+}
+interface ChannelHandlers {
+    [eventName: string]: ChannelEventHandler;
+}
+interface HealthResponse {
+    status: string;
+    uptime: number;
+}
+
+export type { AppCredentials as A, PublishedMessage as B, ConnectionTokenInput as C, ServerAuthApprovedResponse as D, EventMessage as E, ServerAuthDecision as F, ServerAuthDeniedResponse as G, HandleServerAuthOptions as H, ServerAuthRequest as I, ServerAuthResponse as J, ServerAuthTokenResponse as K, LoginInput as L, ServerErrorMessage as M, ServerMessage as N, SubscribeOptions as O, PingMessage as P, SubscribedMessage as Q, UpdateApplicationInput as R, ServerAuthAllowedResponse as S, User as T, UnsubscribedMessage as U, UserRole as V, ConnectionTokenResponse as a, ApiError as b, Application as c, ArkNotifyClientConfig as d, ArkNotifyConnectionConfig as e, ArkNotifySSEConfig as f, AuthResponse as g, ChannelAuthInput as h, ChannelAuthResponse as i, ChannelEventHandler as j, ChannelHandlers as k, ConnectedMessage as l, ConnectionCapabilities as m, ConnectionState as n, CreateApplicationInput as o, CreateAuthorizedServerAuthResponseOptions as p, HealthResponse as q, PongMessage as r, PresenceAction as s, PresenceLeftMessage as t, PresenceMemberInfo as u, PresenceMessage as v, PresenceUpdatedMessage as w, PrivateChannelAuthHandler as x, PublishEventInput as y, PublishEventResponse as z };

package/dist/utils-BATAvEjJ.d.cts

@@ -0,0 +1,146 @@
+import { d as ArkNotifyClientConfig, q as HealthResponse, L as LoginInput, g as AuthResponse, T as User, c as Application, o as CreateApplicationInput, R as UpdateApplicationInput, A as AppCredentials, y as PublishEventInput, z as PublishEventResponse, h as ChannelAuthInput, i as ChannelAuthResponse, C as ConnectionTokenInput, a as ConnectionTokenResponse, e as ArkNotifyConnectionConfig, n as ConnectionState, l as ConnectedMessage, E as EventMessage, v as PresenceMessage, N as ServerMessage, O as SubscribeOptions, j as ChannelEventHandler, f as ArkNotifySSEConfig, b as ApiError } from './types-tQECeZab.cjs';
+
+declare const DEFAULT_BASE_URL = "https://ark-notify-933303906015.europe-north1.run.app";
+interface ArkNotifyGlobalConfig {
+    baseUrl?: string;
+}
+/** Set the default base URL once at application startup. */
+declare function configureArkNotify(config: ArkNotifyGlobalConfig): void;
+declare function resolveBaseUrl(baseUrl?: string): string;
+
+declare class ArkNotifyClient {
+    private readonly baseUrl;
+    private readonly fetchFn;
+    private token?;
+    constructor(config: ArkNotifyClientConfig);
+    setToken(token: string | null): void;
+    private getAuthHeader;
+    private request;
+    health(): Promise<HealthResponse>;
+    login(input: LoginInput): Promise<AuthResponse>;
+    me(): Promise<{
+        user: User;
+    }>;
+    listApplications(): Promise<{
+        apps: Application[];
+    }>;
+    createApplication(input: CreateApplicationInput): Promise<{
+        app: Application;
+    }>;
+    getApplication(id: string): Promise<{
+        app: Application;
+    }>;
+    updateApplication(id: string, input: UpdateApplicationInput): Promise<{
+        app: Application;
+    }>;
+    deleteApplication(id: string): Promise<{
+        deleted: boolean;
+        id: string;
+    }>;
+    regenerateSecret(id: string): Promise<{
+        app: Application;
+    }>;
+    publishEvent(appKey: string, credentials: AppCredentials, input: PublishEventInput): Promise<PublishEventResponse>;
+    authorizeChannel(appKey: string, credentials: AppCredentials, input: ChannelAuthInput): Promise<ChannelAuthResponse>;
+    issueConnectionToken(appKey: string, input: ConnectionTokenInput, credentials?: AppCredentials): Promise<ConnectionTokenResponse>;
+}
+
+type EventMap = {
+    state: (state: ConnectionState) => void;
+    connected: (message: ConnectedMessage) => void;
+    event: (message: EventMessage) => void;
+    presence: (message: PresenceMessage) => void;
+    message: (message: ServerMessage) => void;
+    error: (error: {
+        code: string;
+        message: string;
+    }) => void;
+    close: (event: {
+        code: number;
+        reason: string;
+    }) => void;
+};
+type EventName = keyof EventMap;
+declare class ArkNotifyConnection {
+    private readonly config;
+    private ws;
+    private state;
+    private connectionId;
+    private clientId;
+    private authenticated;
+    private subscribedChannels;
+    private pendingSubscriptions;
+    private listeners;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private intentionalClose;
+    private connectPromise;
+    private readonly WebSocketCtor;
+    constructor(config: ArkNotifyConnectionConfig);
+    getConnectionState(): ConnectionState;
+    getConnectionId(): string | null;
+    getClientId(): string | null;
+    isAuthenticated(): boolean;
+    getSubscribedChannels(): string[];
+    on<E extends EventName>(event: E, handler: EventMap[E]): () => void;
+    off<E extends EventName>(event: E, handler: EventMap[E]): void;
+    private emit;
+    private setState;
+    connect(): Promise<void>;
+    private doConnect;
+    disconnect(): void;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private send;
+    private handleMessage;
+    private resubscribeAll;
+    subscribe(channel: string, options?: SubscribeOptions): Promise<void>;
+    unsubscribe(channel: string): void;
+    publish(channel: string, event: string, data?: unknown): void;
+    presenceEnter(channel: string, data: Record<string, unknown>): void;
+    presenceUpdate(channel: string, data: Record<string, unknown>): void;
+    presenceLeave(channel: string): void;
+    presenceSync(channel: string): void;
+    ping(): void;
+    bind(channel: string, event: string, handler: ChannelEventHandler): () => void;
+    bindAll(channel: string, handler: ChannelEventHandler): () => void;
+}
+
+type SSEEventMap = {
+    connected: (message: ConnectedMessage) => void;
+    event: (message: EventMessage) => void;
+    presence: (message: PresenceMessage) => void;
+    message: (message: ServerMessage) => void;
+    error: (error: Error) => void;
+    close: () => void;
+};
+type SSEEventName = keyof SSEEventMap;
+declare class ArkNotifySSE {
+    private readonly config;
+    private es;
+    private connectionId;
+    private listeners;
+    private readonly EventSourceCtor;
+    constructor(config: ArkNotifySSEConfig);
+    getConnectionId(): string | null;
+    on<E extends SSEEventName>(event: E, handler: SSEEventMap[E]): () => void;
+    off<E extends SSEEventName>(event: E, handler: SSEEventMap[E]): void;
+    private emit;
+    connect(): Promise<void>;
+    disconnect(): void;
+    bind(channel: string, event: string, handler: (data: unknown, message: EventMessage) => void): () => void;
+    bindAll(channel: string, handler: (data: unknown, message: EventMessage) => void): () => void;
+}
+
+declare class ArkNotifyError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryAfterSec?: number;
+    readonly reason?: string;
+    constructor(status: number, body: ApiError);
+}
+declare function toWebSocketUrl(baseUrl: string, path: string): string;
+declare function resolveValue<T>(value: T | (() => T)): T;
+declare function isPrivateChannel(channel: string): boolean;
+
+export { ArkNotifyClient as A, DEFAULT_BASE_URL as D, ArkNotifyConnection as a, ArkNotifyError as b, type ArkNotifyGlobalConfig as c, ArkNotifySSE as d, configureArkNotify as e, resolveValue as f, isPrivateChannel as i, resolveBaseUrl as r, toWebSocketUrl as t };

package/dist/utils-DnRGShUO.d.ts

@@ -0,0 +1,146 @@
+import { d as ArkNotifyClientConfig, q as HealthResponse, L as LoginInput, g as AuthResponse, T as User, c as Application, o as CreateApplicationInput, R as UpdateApplicationInput, A as AppCredentials, y as PublishEventInput, z as PublishEventResponse, h as ChannelAuthInput, i as ChannelAuthResponse, C as ConnectionTokenInput, a as ConnectionTokenResponse, e as ArkNotifyConnectionConfig, n as ConnectionState, l as ConnectedMessage, E as EventMessage, v as PresenceMessage, N as ServerMessage, O as SubscribeOptions, j as ChannelEventHandler, f as ArkNotifySSEConfig, b as ApiError } from './types-tQECeZab.js';
+
+declare const DEFAULT_BASE_URL = "https://ark-notify-933303906015.europe-north1.run.app";
+interface ArkNotifyGlobalConfig {
+    baseUrl?: string;
+}
+/** Set the default base URL once at application startup. */
+declare function configureArkNotify(config: ArkNotifyGlobalConfig): void;
+declare function resolveBaseUrl(baseUrl?: string): string;
+
+declare class ArkNotifyClient {
+    private readonly baseUrl;
+    private readonly fetchFn;
+    private token?;
+    constructor(config: ArkNotifyClientConfig);
+    setToken(token: string | null): void;
+    private getAuthHeader;
+    private request;
+    health(): Promise<HealthResponse>;
+    login(input: LoginInput): Promise<AuthResponse>;
+    me(): Promise<{
+        user: User;
+    }>;
+    listApplications(): Promise<{
+        apps: Application[];
+    }>;
+    createApplication(input: CreateApplicationInput): Promise<{
+        app: Application;
+    }>;
+    getApplication(id: string): Promise<{
+        app: Application;
+    }>;
+    updateApplication(id: string, input: UpdateApplicationInput): Promise<{
+        app: Application;
+    }>;
+    deleteApplication(id: string): Promise<{
+        deleted: boolean;
+        id: string;
+    }>;
+    regenerateSecret(id: string): Promise<{
+        app: Application;
+    }>;
+    publishEvent(appKey: string, credentials: AppCredentials, input: PublishEventInput): Promise<PublishEventResponse>;
+    authorizeChannel(appKey: string, credentials: AppCredentials, input: ChannelAuthInput): Promise<ChannelAuthResponse>;
+    issueConnectionToken(appKey: string, input: ConnectionTokenInput, credentials?: AppCredentials): Promise<ConnectionTokenResponse>;
+}
+
+type EventMap = {
+    state: (state: ConnectionState) => void;
+    connected: (message: ConnectedMessage) => void;
+    event: (message: EventMessage) => void;
+    presence: (message: PresenceMessage) => void;
+    message: (message: ServerMessage) => void;
+    error: (error: {
+        code: string;
+        message: string;
+    }) => void;
+    close: (event: {
+        code: number;
+        reason: string;
+    }) => void;
+};
+type EventName = keyof EventMap;
+declare class ArkNotifyConnection {
+    private readonly config;
+    private ws;
+    private state;
+    private connectionId;
+    private clientId;
+    private authenticated;
+    private subscribedChannels;
+    private pendingSubscriptions;
+    private listeners;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private intentionalClose;
+    private connectPromise;
+    private readonly WebSocketCtor;
+    constructor(config: ArkNotifyConnectionConfig);
+    getConnectionState(): ConnectionState;
+    getConnectionId(): string | null;
+    getClientId(): string | null;
+    isAuthenticated(): boolean;
+    getSubscribedChannels(): string[];
+    on<E extends EventName>(event: E, handler: EventMap[E]): () => void;
+    off<E extends EventName>(event: E, handler: EventMap[E]): void;
+    private emit;
+    private setState;
+    connect(): Promise<void>;
+    private doConnect;
+    disconnect(): void;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private send;
+    private handleMessage;
+    private resubscribeAll;
+    subscribe(channel: string, options?: SubscribeOptions): Promise<void>;
+    unsubscribe(channel: string): void;
+    publish(channel: string, event: string, data?: unknown): void;
+    presenceEnter(channel: string, data: Record<string, unknown>): void;
+    presenceUpdate(channel: string, data: Record<string, unknown>): void;
+    presenceLeave(channel: string): void;
+    presenceSync(channel: string): void;
+    ping(): void;
+    bind(channel: string, event: string, handler: ChannelEventHandler): () => void;
+    bindAll(channel: string, handler: ChannelEventHandler): () => void;
+}
+
+type SSEEventMap = {
+    connected: (message: ConnectedMessage) => void;
+    event: (message: EventMessage) => void;
+    presence: (message: PresenceMessage) => void;
+    message: (message: ServerMessage) => void;
+    error: (error: Error) => void;
+    close: () => void;
+};
+type SSEEventName = keyof SSEEventMap;
+declare class ArkNotifySSE {
+    private readonly config;
+    private es;
+    private connectionId;
+    private listeners;
+    private readonly EventSourceCtor;
+    constructor(config: ArkNotifySSEConfig);
+    getConnectionId(): string | null;
+    on<E extends SSEEventName>(event: E, handler: SSEEventMap[E]): () => void;
+    off<E extends SSEEventName>(event: E, handler: SSEEventMap[E]): void;
+    private emit;
+    connect(): Promise<void>;
+    disconnect(): void;
+    bind(channel: string, event: string, handler: (data: unknown, message: EventMessage) => void): () => void;
+    bindAll(channel: string, handler: (data: unknown, message: EventMessage) => void): () => void;
+}
+
+declare class ArkNotifyError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryAfterSec?: number;
+    readonly reason?: string;
+    constructor(status: number, body: ApiError);
+}
+declare function toWebSocketUrl(baseUrl: string, path: string): string;
+declare function resolveValue<T>(value: T | (() => T)): T;
+declare function isPrivateChannel(channel: string): boolean;
+
+export { ArkNotifyClient as A, DEFAULT_BASE_URL as D, ArkNotifyConnection as a, ArkNotifyError as b, type ArkNotifyGlobalConfig as c, ArkNotifySSE as d, configureArkNotify as e, resolveValue as f, isPrivateChannel as i, resolveBaseUrl as r, toWebSocketUrl as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emmanuel-nike/ark-notify-js",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "JavaScript SDK for Ark Notify — real-time pub/sub, presence, and platform management",
   "license": "MIT",
   "type": "module",
@@ -27,6 +27,16 @@
         "types": "./dist/react/index.d.cts",
         "default": "./dist/react/index.cjs"
       }
+    },
+    "./server": {
+      "import": {
+        "types": "./dist/server/index.d.ts",
+        "default": "./dist/server/index.js"
+      },
+      "require": {
+        "types": "./dist/server/index.d.cts",
+        "default": "./dist/server/index.cjs"
+      }
     }
   },
   "files": [
@@ -49,6 +59,7 @@
     }
   },
   "devDependencies": {
+    "@types/node": "^25.9.3",
     "@types/react": "^19.1.8",
     "react": "^19.1.0",
     "tsup": "^8.5.0",