semola 0.5.3 → 0.6.0

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

@@ -1,30 +1,22 @@
-import { CacheOptions } from "../../cache/types.mjs";
-
+//#region src/lib/cache/types.d.ts
+type CacheOptions<T> = {
+  redis: Bun.RedisClient;
+  ttl?: number | ((key: string, value: T) => number);
+  enabled?: boolean;
+  prefix?: string;
+  serializer?: (value: T) => string;
+  deserializer?: (raw: string) => T;
+};
+//#endregion
 //#region src/lib/cache/index.d.ts
 declare class Cache<T> {
   private options;
   private serialize;
   private deserialize;
   constructor(options: CacheOptions<T>);
-  get(key: string): Promise<readonly [{
-    readonly type: "NotFoundError";
-    readonly message: string;
-  }, null] | readonly [{
-    readonly type: "CacheError";
-    readonly message: string;
-  }, null] | readonly [null, T]>;
-  set(key: string, value: T): Promise<readonly [{
-    readonly type: "CacheError";
-    readonly message: string;
-  }, null] | readonly [null, T] | readonly [{
-    readonly type: "InvalidTTLError";
-    readonly message: string;
-  }, null]>;
-  delete(key: string): Promise<readonly [null, number] | readonly [{
-    readonly type: "CacheError";
-    readonly message: string;
-  }, null]>;
-  private fail;
+  get(key: string): Promise<T>;
+  set(key: string, value: T): Promise<T>;
+  delete(key: string): Promise<number>;
   private get isEnabled();
   private resolveKey;
   private resolveTTL;
@@ -32,5 +24,4 @@ declare class Cache<T> {
   private isTTLValid;
 }
 //#endregion
-export { Cache };
-//# sourceMappingURL=index.d.mts.map
+export { Cache };

package/dist/lib/cache/index.mjs

@@ -1,4 +1,36 @@
-import { err, mightThrow, mightThrowSync, ok } from "../errors/index.mjs";
+import { mightThrow, mightThrowSync } from "../errors/index.mjs";
+//#region src/lib/cache/errors.ts
+var CacheError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CacheError";
+	}
+};
+var InvalidTTLError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidTTLError";
+	}
+};
+var NotFoundError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NotFoundError";
+	}
+};
+var SerializationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SerializationError";
+	}
+};
+var DeserializationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DeserializationError";
+	}
+};
+//#endregion
 //#region src/lib/cache/index.ts
 var Cache = class {
 	options;
@@ -10,41 +42,34 @@ var Cache = class {
 		this.deserialize = options.deserializer ?? ((raw) => JSON.parse(raw));
 	}
 	async get(key) {
-		if (!this.isEnabled) return this.fail("NotFoundError", `Key ${key} not found`);
+		if (!this.isEnabled) throw new NotFoundError(`Key ${key} not found`);
 		const resolvedKey = this.resolveKey(key);
 		const [error, value] = await mightThrow(this.options.redis.get(resolvedKey));
-		if (error) return this.fail("CacheError", `Unable to get value for key ${key}`);
-		if (value === null || value === void 0) return this.fail("NotFoundError", `Key ${key} not found`);
+		if (error) throw new CacheError(`Unable to get value for key ${key}`);
+		if (value === null || value === void 0) throw new NotFoundError(`Key ${key} not found`);
 		const [deserializeErr, deserialized] = mightThrowSync(() => this.deserialize(value));
-		if (deserializeErr) return this.fail("CacheError", `Unable to deserialize value for key ${key}`);
-		return ok(deserialized);
+		if (deserializeErr) throw new DeserializationError(`Unable to deserialize value for key ${key}`);
+		return deserialized;
 	}
 	async set(key, value) {
-		if (!this.isEnabled) return ok(value);
+		if (!this.isEnabled) return value;
 		const [serializeErr, serialized] = mightThrowSync(() => this.serialize(value));
-		if (serializeErr) return this.fail("CacheError", `Unable to serialize value for key ${key}`);
-		if (serialized === null || serialized === void 0) return this.fail("CacheError", `Unable to serialize value for key ${key}`);
+		if (serializeErr) throw new SerializationError(`Unable to serialize value for key ${key}`);
+		if (serialized === null || serialized === void 0) throw new SerializationError(`Unable to serialize value for key ${key}`);
 		const [ttlErr, ttl] = mightThrowSync(() => this.resolveTTL(key, value));
-		if (ttlErr) return this.fail("InvalidTTLError", `Unable to resolve ttl for key ${key}`);
-		if (!this.isTTLValid(ttl)) return this.fail("InvalidTTLError", `Unable to save records with ttl equal to ${ttl}`);
+		if (ttlErr) throw new InvalidTTLError(`Unable to resolve ttl for key ${key}`);
+		if (!this.isTTLValid(ttl)) throw new InvalidTTLError(`Unable to save records with ttl equal to ${ttl}`);
 		const resolvedKey = this.resolveKey(key);
 		const [setError] = await mightThrow(this.getSetPromise(resolvedKey, serialized, ttl));
-		if (setError) return this.fail("CacheError", `Unable to set value for key ${key}`);
-		return ok(value);
+		if (setError) throw new CacheError(`Unable to set value for key ${key}`);
+		return value;
 	}
 	async delete(key) {
-		if (!this.isEnabled) return ok(0);
+		if (!this.isEnabled) return 0;
 		const resolvedKey = this.resolveKey(key);
 		const [error, data] = await mightThrow(this.options.redis.del(resolvedKey));
-		if (error) return this.fail("CacheError", `Unable to delete key ${key}`);
-		return ok(data);
-	}
-	fail(type, message) {
-		this.options.onError?.({
-			type,
-			message
-		});
-		return err(type, message);
+		if (error) throw new CacheError(`Unable to delete key ${key}`);
+		return data;
 	}
 	get isEnabled() {
 		return this.options.enabled !== false;
@@ -71,5 +96,3 @@ var Cache = class {
 };
 //#endregion
 export { Cache };
-
-//# sourceMappingURL=index.mjs.map