semola 0.5.2 → 0.5.4

package/dist/lib/pubsub/index.cjs

@@ -4,9 +4,45 @@ const require_lib_errors_index = require("../errors/index.cjs");
 var PubSub = class {
 	options;
 	isSubscribed = false;
+	nextHandlerId = 0;
+	handlers = /* @__PURE__ */ new Map();
+	unsubscribeInFlight = null;
+	subscribeInFlight = null;
 	constructor(options) {
 		this.options = options;
 	}
+	async onMessage(message, channel) {
+		const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(message));
+		if (parseError) return;
+		if (!parsed) return;
+		const handlers = Array.from(this.handlers.values());
+		for (const handler of handlers) await require_lib_errors_index.mightThrow(Promise.resolve().then(() => handler(parsed, channel)));
+	}
+	async unsubscribeHandler(handlerId) {
+		const inFlightUnsubscribe = this.unsubscribeInFlight;
+		if (inFlightUnsubscribe) await inFlightUnsubscribe;
+		const handler = this.handlers.get(handlerId);
+		if (!handler) return require_lib_errors_index.err("UnsubscribeError", "Not subscribed");
+		this.handlers.delete(handlerId);
+		if (this.handlers.size > 0) return require_lib_errors_index.ok(true);
+		this.isSubscribed = false;
+		this.unsubscribeInFlight = require_lib_errors_index.mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
+		const unsubscribeInFlight = this.unsubscribeInFlight;
+		if (!unsubscribeInFlight) {
+			this.handlers.set(handlerId, handler);
+			this.isSubscribed = true;
+			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+		}
+		const [unsubscribeError] = await unsubscribeInFlight;
+		if (unsubscribeError) {
+			this.handlers.set(handlerId, handler);
+			this.isSubscribed = true;
+			this.unsubscribeInFlight = null;
+			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+		}
+		this.unsubscribeInFlight = null;
+		return require_lib_errors_index.ok(true);
+	}
 	async publish(message) {
 		const [stringifyError, stringified] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(message));
 		if (stringifyError || !stringified) return require_lib_errors_index.err("SerializationError", "Unable to serialize message");
@@ -15,33 +51,66 @@ var PubSub = class {
 		return require_lib_errors_index.ok(count);
 	}
 	async subscribe(handler) {
-		if (this.isActive()) return require_lib_errors_index.err("SubscribeError", "Already subscribed");
-		this.isSubscribed = true;
-		const wrappedHandler = async (message, channel) => {
-			const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(message));
-			if (parseError) return;
-			if (!parsed) return;
-			await require_lib_errors_index.mightThrow(Promise.resolve(handler(parsed, channel)));
-		};
-		const [subscribeError, count] = await require_lib_errors_index.mightThrow(this.options.subscriber.subscribe(this.options.channel, wrappedHandler));
+		const inFlightUnsubscribe = this.unsubscribeInFlight;
+		if (inFlightUnsubscribe) await inFlightUnsubscribe;
+		const handlerId = this.nextHandlerId;
+		this.nextHandlerId += 1;
+		this.handlers.set(handlerId, handler);
+		if (this.isActive()) return require_lib_errors_index.ok(() => this.unsubscribeHandler(handlerId));
+		const inFlightSubscribe = this.subscribeInFlight;
+		if (inFlightSubscribe) {
+			const [inFlightError] = await inFlightSubscribe;
+			if (inFlightError || !this.isSubscribed) {
+				this.handlers.delete(handlerId);
+				return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+			}
+			return require_lib_errors_index.ok(() => this.unsubscribeHandler(handlerId));
+		}
+		this.subscribeInFlight = require_lib_errors_index.mightThrow(this.options.subscriber.subscribe(this.options.channel, async (message, channel) => this.onMessage(message, channel)));
+		const subscribeInFlight = this.subscribeInFlight;
+		if (!subscribeInFlight) {
+			this.handlers.delete(handlerId);
+			return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+		}
+		const [subscribeError, count] = await subscribeInFlight;
+		this.subscribeInFlight = null;
 		if (subscribeError) {
-			this.isSubscribed = false;
+			this.handlers.delete(handlerId);
 			return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
 		}
-		return require_lib_errors_index.ok(count);
+		if (!count) {
+			this.handlers.delete(handlerId);
+			return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+		}
+		this.isSubscribed = true;
+		return require_lib_errors_index.ok(() => this.unsubscribeHandler(handlerId));
 	}
 	async unsubscribe() {
+		const inFlightUnsubscribe = this.unsubscribeInFlight;
+		if (inFlightUnsubscribe) await inFlightUnsubscribe;
 		if (!this.isActive()) return require_lib_errors_index.err("UnsubscribeError", "Not subscribed");
+		const handlers = new Map(this.handlers);
+		this.handlers.clear();
 		this.isSubscribed = false;
-		const [unsubscribeError] = await require_lib_errors_index.mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
+		this.unsubscribeInFlight = require_lib_errors_index.mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
+		const unsubscribeInFlight = this.unsubscribeInFlight;
+		if (!unsubscribeInFlight) {
+			this.handlers = handlers;
+			this.isSubscribed = true;
+			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+		}
+		const [unsubscribeError] = await unsubscribeInFlight;
 		if (unsubscribeError) {
+			this.handlers = handlers;
 			this.isSubscribed = true;
+			this.unsubscribeInFlight = null;
 			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
 		}
+		this.unsubscribeInFlight = null;
 		return require_lib_errors_index.ok(true);
 	}
 	isActive() {
-		return this.isSubscribed;
+		return this.handlers.size > 0 && this.isSubscribed;
 	}
 };
 //#endregion

package/dist/lib/pubsub/index.d.cts

@@ -1,27 +1,41 @@
-import { MessageHandler, PubSubOptions } from "../../pubsub/types.cjs";
-
+//#region src/lib/pubsub/types.d.ts
+type PubSubOptions = {
+  subscriber: Bun.RedisClient;
+  publisher: Bun.RedisClient;
+  channel: string;
+};
+type MessageHandler<T> = (message: T, channel: string) => void | Promise<void>;
+//#endregion
 //#region src/lib/pubsub/index.d.ts
 declare class PubSub<T extends Record<string, unknown>> {
   private options;
   private isSubscribed;
+  private nextHandlerId;
+  private handlers;
+  private unsubscribeInFlight;
+  private subscribeInFlight;
   constructor(options: PubSubOptions);
-  publish(message: T): Promise<readonly [null, number | null] | readonly [{
+  private onMessage;
+  private unsubscribeHandler;
+  publish(message: T): Promise<readonly [{
     readonly type: "SerializationError";
     readonly message: string;
   }, null] | readonly [{
     readonly type: "PublishError";
     readonly message: string;
-  }, null]>;
-  subscribe(handler: MessageHandler<T>): Promise<readonly [null, number | null] | readonly [{
+  }, null] | readonly [null, number]>;
+  subscribe(handler: MessageHandler<T>): Promise<readonly [null, () => Promise<readonly [{
+    readonly type: "UnsubscribeError";
+    readonly message: string;
+  }, null] | readonly [null, boolean]>] | readonly [{
     readonly type: "SubscribeError";
     readonly message: string;
   }, null]>;
-  unsubscribe(): Promise<readonly [null, boolean] | readonly [{
+  unsubscribe(): Promise<readonly [{
     readonly type: "UnsubscribeError";
     readonly message: string;
-  }, null]>;
+  }, null] | readonly [null, boolean]>;
   isActive(): boolean;
 }
 //#endregion
-export { PubSub };
-//# sourceMappingURL=index.d.cts.map
+export { PubSub };

package/dist/lib/pubsub/index.d.mts

@@ -1,27 +1,41 @@
-import { MessageHandler, PubSubOptions } from "../../pubsub/types.mjs";
-
+//#region src/lib/pubsub/types.d.ts
+type PubSubOptions = {
+  subscriber: Bun.RedisClient;
+  publisher: Bun.RedisClient;
+  channel: string;
+};
+type MessageHandler<T> = (message: T, channel: string) => void | Promise<void>;
+//#endregion
 //#region src/lib/pubsub/index.d.ts
 declare class PubSub<T extends Record<string, unknown>> {
   private options;
   private isSubscribed;
+  private nextHandlerId;
+  private handlers;
+  private unsubscribeInFlight;
+  private subscribeInFlight;
   constructor(options: PubSubOptions);
-  publish(message: T): Promise<readonly [null, number | null] | readonly [{
+  private onMessage;
+  private unsubscribeHandler;
+  publish(message: T): Promise<readonly [{
     readonly type: "SerializationError";
     readonly message: string;
   }, null] | readonly [{
     readonly type: "PublishError";
     readonly message: string;
-  }, null]>;
-  subscribe(handler: MessageHandler<T>): Promise<readonly [null, number | null] | readonly [{
+  }, null] | readonly [null, number]>;
+  subscribe(handler: MessageHandler<T>): Promise<readonly [null, () => Promise<readonly [{
+    readonly type: "UnsubscribeError";
+    readonly message: string;
+  }, null] | readonly [null, boolean]>] | readonly [{
     readonly type: "SubscribeError";
     readonly message: string;
   }, null]>;
-  unsubscribe(): Promise<readonly [null, boolean] | readonly [{
+  unsubscribe(): Promise<readonly [{
     readonly type: "UnsubscribeError";
     readonly message: string;
-  }, null]>;
+  }, null] | readonly [null, boolean]>;
   isActive(): boolean;
 }
 //#endregion
-export { PubSub };
-//# sourceMappingURL=index.d.mts.map
+export { PubSub };

package/dist/lib/pubsub/index.mjs

@@ -3,9 +3,45 @@ import { err, mightThrow, mightThrowSync, ok } from "../errors/index.mjs";
 var PubSub = class {
 	options;
 	isSubscribed = false;
+	nextHandlerId = 0;
+	handlers = /* @__PURE__ */ new Map();
+	unsubscribeInFlight = null;
+	subscribeInFlight = null;
 	constructor(options) {
 		this.options = options;
 	}
+	async onMessage(message, channel) {
+		const [parseError, parsed] = mightThrowSync(() => JSON.parse(message));
+		if (parseError) return;
+		if (!parsed) return;
+		const handlers = Array.from(this.handlers.values());
+		for (const handler of handlers) await mightThrow(Promise.resolve().then(() => handler(parsed, channel)));
+	}
+	async unsubscribeHandler(handlerId) {
+		const inFlightUnsubscribe = this.unsubscribeInFlight;
+		if (inFlightUnsubscribe) await inFlightUnsubscribe;
+		const handler = this.handlers.get(handlerId);
+		if (!handler) return err("UnsubscribeError", "Not subscribed");
+		this.handlers.delete(handlerId);
+		if (this.handlers.size > 0) return ok(true);
+		this.isSubscribed = false;
+		this.unsubscribeInFlight = mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
+		const unsubscribeInFlight = this.unsubscribeInFlight;
+		if (!unsubscribeInFlight) {
+			this.handlers.set(handlerId, handler);
+			this.isSubscribed = true;
+			return err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+		}
+		const [unsubscribeError] = await unsubscribeInFlight;
+		if (unsubscribeError) {
+			this.handlers.set(handlerId, handler);
+			this.isSubscribed = true;
+			this.unsubscribeInFlight = null;
+			return err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+		}
+		this.unsubscribeInFlight = null;
+		return ok(true);
+	}
 	async publish(message) {
 		const [stringifyError, stringified] = mightThrowSync(() => JSON.stringify(message));
 		if (stringifyError || !stringified) return err("SerializationError", "Unable to serialize message");
@@ -14,36 +50,67 @@ var PubSub = class {
 		return ok(count);
 	}
 	async subscribe(handler) {
-		if (this.isActive()) return err("SubscribeError", "Already subscribed");
-		this.isSubscribed = true;
-		const wrappedHandler = async (message, channel) => {
-			const [parseError, parsed] = mightThrowSync(() => JSON.parse(message));
-			if (parseError) return;
-			if (!parsed) return;
-			await mightThrow(Promise.resolve(handler(parsed, channel)));
-		};
-		const [subscribeError, count] = await mightThrow(this.options.subscriber.subscribe(this.options.channel, wrappedHandler));
+		const inFlightUnsubscribe = this.unsubscribeInFlight;
+		if (inFlightUnsubscribe) await inFlightUnsubscribe;
+		const handlerId = this.nextHandlerId;
+		this.nextHandlerId += 1;
+		this.handlers.set(handlerId, handler);
+		if (this.isActive()) return ok(() => this.unsubscribeHandler(handlerId));
+		const inFlightSubscribe = this.subscribeInFlight;
+		if (inFlightSubscribe) {
+			const [inFlightError] = await inFlightSubscribe;
+			if (inFlightError || !this.isSubscribed) {
+				this.handlers.delete(handlerId);
+				return err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+			}
+			return ok(() => this.unsubscribeHandler(handlerId));
+		}
+		this.subscribeInFlight = mightThrow(this.options.subscriber.subscribe(this.options.channel, async (message, channel) => this.onMessage(message, channel)));
+		const subscribeInFlight = this.subscribeInFlight;
+		if (!subscribeInFlight) {
+			this.handlers.delete(handlerId);
+			return err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+		}
+		const [subscribeError, count] = await subscribeInFlight;
+		this.subscribeInFlight = null;
 		if (subscribeError) {
-			this.isSubscribed = false;
+			this.handlers.delete(handlerId);
 			return err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
 		}
-		return ok(count);
+		if (!count) {
+			this.handlers.delete(handlerId);
+			return err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+		}
+		this.isSubscribed = true;
+		return ok(() => this.unsubscribeHandler(handlerId));
 	}
 	async unsubscribe() {
+		const inFlightUnsubscribe = this.unsubscribeInFlight;
+		if (inFlightUnsubscribe) await inFlightUnsubscribe;
 		if (!this.isActive()) return err("UnsubscribeError", "Not subscribed");
+		const handlers = new Map(this.handlers);
+		this.handlers.clear();
 		this.isSubscribed = false;
-		const [unsubscribeError] = await mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
+		this.unsubscribeInFlight = mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
+		const unsubscribeInFlight = this.unsubscribeInFlight;
+		if (!unsubscribeInFlight) {
+			this.handlers = handlers;
+			this.isSubscribed = true;
+			return err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+		}
+		const [unsubscribeError] = await unsubscribeInFlight;
 		if (unsubscribeError) {
+			this.handlers = handlers;
 			this.isSubscribed = true;
+			this.unsubscribeInFlight = null;
 			return err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
 		}
+		this.unsubscribeInFlight = null;
 		return ok(true);
 	}
 	isActive() {
-		return this.isSubscribed;
+		return this.handlers.size > 0 && this.isSubscribed;
 	}
 };
 //#endregion
 export { PubSub };
-
-//# sourceMappingURL=index.mjs.map

package/dist/lib/queue/index.d.cts

@@ -1,5 +1,48 @@
-import { QueueOptions } from "../../queue/types.cjs";
-
+//#region src/lib/queue/types.d.ts
+type Job<T> = {
+  id: string;
+  data: T;
+  attempts: number;
+  maxRetries: number;
+  createdAt: number;
+};
+type RetryContext<T> = {
+  job: Job<T>;
+  error: string;
+  nextRetryDelayMs: number;
+  retriesRemaining: number;
+  backoffMultiplier: number;
+};
+type ErrorContext<T> = {
+  job: Job<T>;
+  lastError: string;
+  totalDurationMs: number;
+  totalAttempts: number;
+  errorHistory: Array<{
+    attempt: number;
+    error: string;
+    timestamp: number;
+  }>;
+};
+type ParseErrorContext = {
+  rawJobData: string;
+  parseError: string;
+  timestamp: number;
+};
+type QueueOptions<T> = {
+  name: string;
+  redis: Bun.RedisClient;
+  handler: (data: T, signal?: AbortSignal) => void | Promise<void>;
+  onSuccess?: (job: Job<T>) => void | Promise<void>;
+  onRetry?: (context: RetryContext<T>) => void | Promise<void>;
+  onError?: (context: ErrorContext<T>) => void | Promise<void>;
+  onParseError?: (context: ParseErrorContext) => void | Promise<void>;
+  retries?: number;
+  timeout?: number;
+  concurrency?: number;
+  pollInterval?: number;
+};
+//#endregion
 //#region src/lib/queue/index.d.ts
 declare class Queue<T> {
   private options;
@@ -28,5 +71,4 @@ declare class Queue<T> {
   private retryJob;
 }
 //#endregion
-export { Queue };
-//# sourceMappingURL=index.d.cts.map
+export { Queue };

package/dist/lib/queue/index.d.mts

@@ -1,5 +1,48 @@
-import { QueueOptions } from "../../queue/types.mjs";
-
+//#region src/lib/queue/types.d.ts
+type Job<T> = {
+  id: string;
+  data: T;
+  attempts: number;
+  maxRetries: number;
+  createdAt: number;
+};
+type RetryContext<T> = {
+  job: Job<T>;
+  error: string;
+  nextRetryDelayMs: number;
+  retriesRemaining: number;
+  backoffMultiplier: number;
+};
+type ErrorContext<T> = {
+  job: Job<T>;
+  lastError: string;
+  totalDurationMs: number;
+  totalAttempts: number;
+  errorHistory: Array<{
+    attempt: number;
+    error: string;
+    timestamp: number;
+  }>;
+};
+type ParseErrorContext = {
+  rawJobData: string;
+  parseError: string;
+  timestamp: number;
+};
+type QueueOptions<T> = {
+  name: string;
+  redis: Bun.RedisClient;
+  handler: (data: T, signal?: AbortSignal) => void | Promise<void>;
+  onSuccess?: (job: Job<T>) => void | Promise<void>;
+  onRetry?: (context: RetryContext<T>) => void | Promise<void>;
+  onError?: (context: ErrorContext<T>) => void | Promise<void>;
+  onParseError?: (context: ParseErrorContext) => void | Promise<void>;
+  retries?: number;
+  timeout?: number;
+  concurrency?: number;
+  pollInterval?: number;
+};
+//#endregion
 //#region src/lib/queue/index.d.ts
 declare class Queue<T> {
   private options;
@@ -28,5 +71,4 @@ declare class Queue<T> {
   private retryJob;
 }
 //#endregion
-export { Queue };
-//# sourceMappingURL=index.d.mts.map
+export { Queue };

package/dist/lib/queue/index.mjs

@@ -179,5 +179,3 @@ var Queue = class {
 };
 //#endregion
 export { Queue };
-
-//# sourceMappingURL=index.mjs.map