@ecodrix/erix-client 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -38,6 +38,49 @@ export interface RateLimitResult {
     remaining: number;
     resetAt: number;
 }
+export interface JobV2<T = JsonValue> {
+    id: string;
+    queueName: string;
+    data: T;
+    status: "waiting" | "active" | "completed" | "failed" | "delayed";
+    attempts: number;
+    maxAttempts: number;
+    priority: number;
+    createdAt: string;
+    runAt: string;
+    clientCode?: string;
+    progress?: number;
+    error?: string;
+    result?: JsonValue;
+}
+export interface EnqueueOptionsV2 {
+    priority?: number;
+    maxAttempts?: number;
+    delayMs?: number;
+    runAt?: Date | string;
+    clientCode?: string;
+    metadata?: Record<string, JsonValue>;
+}
+export interface CacheSetOptions {
+    /** TTL in milliseconds */
+    ttl?: number;
+    /** Tags for bulk invalidation */
+    tags?: string[];
+    /**
+     * Stale-While-Revalidate window in milliseconds.
+     * The server serves the old value for this duration after TTL expires
+     * while refreshing in the background.
+     */
+    staleFor?: number;
+}
+export interface QueueEventHandlers<T = JsonValue> {
+    onAdded?: (job: JobV2<T>) => void;
+    onActive?: (job: JobV2<T>) => void;
+    onCompleted?: (job: JobV2<T>) => void;
+    onFailed?: (job: JobV2<T>) => void;
+    onZombie?: (job: JobV2<T>) => void;
+    onError?: (err: Error) => void;
+}
 export declare class ErixClient {
     private readonly baseUrl;
     private readonly headers;
@@ -77,14 +120,64 @@ export declare class ErixClient {
         lpop: <T = JsonValue>(key: string) => Promise<T | null>;
     };
     queue: {
-        /** Enqueue a job payload into a named queue */
+        /** Enqueue a job payload into a named queue (simple list-based) */
         push: (name: string, data: JsonValue) => Promise<void>;
         /** Dequeue the oldest job from a named queue. Returns `null` if empty. */
         pop: <T = JsonValue>(name: string) => Promise<T | null>;
     };
+    /** Advanced Queue (v2) — supports priority, delay, retries, heartbeat, and SSE push */
+    queueV2: {
+        /** Enqueue a job into an advanced queue */
+        push: <T = JsonValue>(queueName: string, data: T, options?: EnqueueOptionsV2) => Promise<JobV2<T>>;
+        /** Claim the next eligible job from the queue */
+        claim: <T = JsonValue>(queueName: string) => Promise<JobV2<T> | null>;
+        /** Mark a job as completed */
+        complete: (jobId: string, result?: JsonValue) => Promise<void>;
+        /** Mark a job as failed */
+        fail: (jobId: string, error: string) => Promise<void>;
+        /** Update job progress (0-100) */
+        updateProgress: (jobId: string, progress: number) => Promise<void>;
+        /**
+         * Send a worker heartbeat to keep the job alive in the reaper.
+         * Call every 15–30 seconds from inside a long-running job handler.
+         * If silent for 60s the reaper will fail and requeue the job.
+         */
+        heartbeat: (jobId: string) => Promise<void>;
+        /** Get job by ID */
+        get: <T = JsonValue>(jobId: string) => Promise<JobV2<T> | null>;
+        /**
+         * Subscribe to queue events via Server-Sent Events.
+         * Returns an EventSource-like object — call `.close()` to unsubscribe.
+         *
+         * Workers should use this instead of polling `claim()` on an interval.
+         * On `job:added` or `job:active` events, call `claim()` to get the job.
+         *
+         * @example
+         * const sub = client.queueV2.subscribe('crm', {
+         *   onAdded: () => processNextJob(),
+         *   onError: (e) => console.error(e),
+         * });
+         * // later:
+         * sub.close();
+         */
+        subscribe: <T = JsonValue>(queueName: string, handlers: QueueEventHandlers<T>) => {
+            close: () => void;
+        };
+    };
     pubsub: {
         /** Publish a message to a channel */
         publish: (channel: string, message: JsonValue) => Promise<void>;
+        /**
+         * Subscribe to a pub/sub channel via Server-Sent Events.
+         * Returns a controller with a `.close()` method.
+         *
+         * @example
+         * const sub = client.pubsub.subscribe('alerts', (msg) => console.log(msg));
+         * sub.close(); // unsubscribe
+         */
+        subscribe: (channel: string, onMessage: (message: JsonValue) => void, onError?: (err: Error) => void) => {
+            close: () => void;
+        };
     };
     /**
      * Check if an operation is within rate limits.
@@ -101,4 +194,25 @@ export declare class ErixClient {
         /** Get all members of a set */
         smembers: (key: string) => Promise<string[]>;
     };
+    cache: {
+        /** Get a cached value */
+        get: <T = JsonValue>(key: string) => Promise<T | null>;
+        /** Set a cached value with optional TTL, tags, and stale-while-revalidate */
+        set: (key: string, value: JsonValue, options?: CacheSetOptions) => Promise<void>;
+        /** Delete a cached key */
+        del: (key: string) => Promise<void>;
+        /** Invalidate all keys with a specific tag */
+        invalidateByTag: (tag: string) => Promise<number>;
+        /** Invalidate all keys matching multiple tags */
+        invalidateByTags: (tags: string[]) => Promise<number>;
+        /** Get cache statistics (hit rate, size, evictions) */
+        stats: () => Promise<unknown>;
+    };
+    /**
+     * Opens a persistent SSE connection and dispatches named events to a handler.
+     * Returns a controller with `.close()` to terminate the connection.
+     *
+     * Uses native fetch with a ReadableStream reader — works in Node 18+.
+     */
+    private openEventStream;
 }

package/dist/index.js

@@ -81,7 +81,7 @@ export class ErixClient {
         };
         // ─── Queue (FIFO job queue, built on List) ────────────────────────────
         this.queue = {
-            /** Enqueue a job payload into a named queue */
+            /** Enqueue a job payload into a named queue (simple list-based) */
             push: async (name, data) => {
                 await this.list.rpush(`q:${name}`, data);
             },
@@ -90,12 +90,91 @@ export class ErixClient {
                 return this.list.lpop(`q:${name}`);
             },
         };
+        /** Advanced Queue (v2) — supports priority, delay, retries, heartbeat, and SSE push */
+        this.queueV2 = {
+            /** Enqueue a job into an advanced queue */
+            push: async (queueName, data, options = {}) => {
+                const res = await this.req("POST", `/queue/v2/${queueName}/jobs`, { data, ...options });
+                return res.job;
+            },
+            /** Claim the next eligible job from the queue */
+            claim: async (queueName) => {
+                const res = await this.req("POST", `/queue/v2/${queueName}/claim`);
+                return res.job;
+            },
+            /** Mark a job as completed */
+            complete: async (jobId, result) => {
+                await this.req("POST", `/queue/v2/jobs/${jobId}/complete`, { result });
+            },
+            /** Mark a job as failed */
+            fail: async (jobId, error) => {
+                await this.req("POST", `/queue/v2/jobs/${jobId}/fail`, { error });
+            },
+            /** Update job progress (0-100) */
+            updateProgress: async (jobId, progress) => {
+                await this.req("PATCH", `/queue/v2/jobs/${jobId}/progress`, { progress });
+            },
+            /**
+             * Send a worker heartbeat to keep the job alive in the reaper.
+             * Call every 15–30 seconds from inside a long-running job handler.
+             * If silent for 60s the reaper will fail and requeue the job.
+             */
+            heartbeat: async (jobId) => {
+                await this.req("PATCH", `/queue/v2/jobs/${jobId}/heartbeat`);
+            },
+            /** Get job by ID */
+            get: async (jobId) => {
+                const res = await this.req("GET", `/queue/v2/jobs/${jobId}`);
+                return res.job;
+            },
+            /**
+             * Subscribe to queue events via Server-Sent Events.
+             * Returns an EventSource-like object — call `.close()` to unsubscribe.
+             *
+             * Workers should use this instead of polling `claim()` on an interval.
+             * On `job:added` or `job:active` events, call `claim()` to get the job.
+             *
+             * @example
+             * const sub = client.queueV2.subscribe('crm', {
+             *   onAdded: () => processNextJob(),
+             *   onError: (e) => console.error(e),
+             * });
+             * // later:
+             * sub.close();
+             */
+            subscribe: (queueName, handlers) => {
+                return this.openEventStream(`/queue/v2/${queueName}/events`, (event, data) => {
+                    const job = data;
+                    if (event === "job:added")
+                        handlers.onAdded?.(job);
+                    else if (event === "job:active")
+                        handlers.onActive?.(job);
+                    else if (event === "job:completed")
+                        handlers.onCompleted?.(job);
+                    else if (event === "job:failed")
+                        handlers.onFailed?.(job);
+                    else if (event === "job:zombie")
+                        handlers.onZombie?.(job);
+                }, handlers.onError);
+            },
+        };
         // ─── PubSub ───────────────────────────────────────────────────────────
         this.pubsub = {
             /** Publish a message to a channel */
             publish: async (channel, message) => {
                 await this.req("POST", "/pubsub/publish", { channel, message });
             },
+            /**
+             * Subscribe to a pub/sub channel via Server-Sent Events.
+             * Returns a controller with a `.close()` method.
+             *
+             * @example
+             * const sub = client.pubsub.subscribe('alerts', (msg) => console.log(msg));
+             * sub.close(); // unsubscribe
+             */
+            subscribe: (channel, onMessage, onError) => {
+                return this.openEventStream(`/pubsub/${encodeURIComponent(channel)}/stream`, (_event, data) => onMessage(data), onError);
+            },
         };
         // ─── Set ──────────────────────────────────────────────────────────────
         this.set_ = {
@@ -109,6 +188,45 @@ export class ErixClient {
                 return data.members;
             },
         };
+        // ─── Cache (advanced) ────────────────────────────────────────────────
+        this.cache = {
+            /** Get a cached value */
+            get: async (key) => {
+                try {
+                    const res = await this.req("GET", `/cache/${encodeURIComponent(key)}`);
+                    return res.value ?? null;
+                }
+                catch {
+                    return null;
+                }
+            },
+            /** Set a cached value with optional TTL, tags, and stale-while-revalidate */
+            set: async (key, value, options = {}) => {
+                await this.req("POST", `/cache/${encodeURIComponent(key)}`, {
+                    value,
+                    ...options,
+                });
+            },
+            /** Delete a cached key */
+            del: async (key) => {
+                await this.req("DELETE", `/cache/${encodeURIComponent(key)}`);
+            },
+            /** Invalidate all keys with a specific tag */
+            invalidateByTag: async (tag) => {
+                const res = await this.req("DELETE", `/cache/tags/${encodeURIComponent(tag)}`);
+                return res.count;
+            },
+            /** Invalidate all keys matching multiple tags */
+            invalidateByTags: async (tags) => {
+                const res = await this.req("POST", "/cache/tags/invalidate", { tags });
+                return res.count;
+            },
+            /** Get cache statistics (hit rate, size, evictions) */
+            stats: async () => {
+                const res = await this.req("GET", "/cache/_stats");
+                return res.stats;
+            },
+        };
         this.baseUrl = options.baseUrl.replace(/\/$/, ""); // strip trailing slash
         this.timeoutMs = options.timeoutMs ?? 5000;
         this.headers = {
@@ -193,4 +311,60 @@ export class ErixClient {
             window,
         });
     }
+    // ─── Internal SSE helper ─────────────────────────────────────────────
+    /**
+     * Opens a persistent SSE connection and dispatches named events to a handler.
+     * Returns a controller with `.close()` to terminate the connection.
+     *
+     * Uses native fetch with a ReadableStream reader — works in Node 18+.
+     */
+    openEventStream(path, onEvent, onError) {
+        const controller = new AbortController();
+        const url = `${this.baseUrl}${path}`;
+        const run = async () => {
+            try {
+                const res = await fetch(url, {
+                    headers: this.headers,
+                    signal: controller.signal,
+                });
+                if (!res.ok || !res.body) {
+                    throw new Error(`[erix-store] SSE ${path} → ${res.status}: ${res.statusText}`);
+                }
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                let currentEvent = "message";
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        if (line.startsWith("event:")) {
+                            currentEvent = line.slice(6).trim();
+                        }
+                        else if (line.startsWith("data:")) {
+                            try {
+                                const data = JSON.parse(line.slice(5).trim());
+                                onEvent(currentEvent, data);
+                            }
+                            catch {
+                                // non-JSON data line, skip
+                            }
+                            currentEvent = "message";
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (!controller.signal.aborted) {
+                    onError?.(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+        };
+        run();
+        return { close: () => controller.abort() };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecodrix/erix-client",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Type-safe HTTP client for the erix-store in-memory data service. Zero dependencies — uses native fetch.",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,10 +15,6 @@
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
   "keywords": [
     "erix-store",
     "cache",
@@ -42,5 +38,8 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/dhanesh125/erix-store"
+  },
+  "scripts": {
+    "build": "tsc"
   }
-}
+}