semola 0.5.4 → 0.6.0

package/README.md

@@ -27,11 +27,11 @@ Type-safe APIs, Redis queues, pub/sub, i18n, caching & auth with tree-shakeable
 | **🌍 i18n**          | Compile-time validated internationalization            | `semola/i18n`     |
 | **💾 Cache**         | Redis cache wrapper with TTL & automatic serialization | `semola/cache`    |
 | **⏰ Cron**          | In-memory cron scheduler for periodic task execution   | `semola/cron`     |
-| **🔁 Workflow**      | Durable resumable workflows with step persistence      | `semola/workflow` |
+| **🔁 Workflow**      | Durable resumable workflows with retries and hooks   | `semola/workflow` |
 | **⚠️ Errors**        | Result-based error handling without try/catch          | `semola/errors`   |
 | **📃 Logging**       | A simple logging utility                               | `semola/logging`  |
 | **⌨️ Prompts**       | Interactive zero-dependency CLI prompts                | `semola/prompts`  |
-| **🗄️ ORM**           | Type-safe data layer with query APIs + migrations      | `semola/orm`      |
+| **🗄️ ORM**           | Type-safe data layer with query APIs                   | `semola/orm`      |
 
 ---
 
@@ -122,16 +122,14 @@ const pubsub = new PubSub({
 });
 
 // Subscribe to messages
-const [, unsubscribeHandler] = await pubsub.subscribe((message) => {
+const unsubscribe = await pubsub.subscribe((message) => {
   console.log("Received:", message);
 });
 
 // Publish a message
 await pubsub.publish({ userId: 123, text: "New alert!" });
 
-if (unsubscribeHandler) {
-  await unsubscribeHandler();
-}
+await unsubscribe();
 ```
 
 ### Cache Data with TTL
@@ -148,8 +146,8 @@ const cache = new Cache({
 await cache.set("user:123", { name: "John", age: 30 });
 
 // Retrieve data
-const [error, user] = await cache.get("user:123");
-if (!error) console.log(user);
+const user = await cache.get("user:123");
+console.log(user);
 ```
 
 ### Schedule Recurring Tasks
@@ -172,60 +170,35 @@ cleanup.start();
 ### Query a Database
 
 ```typescript
-import { createOrm, createTable, string, uuid } from "semola/orm";
+import { createOrm, defineTable, json, string, uuid } from "semola/orm";
 
-const users = createTable("users", {
-  id: uuid("id").primaryKey(),
+const users = defineTable("users", {
+  id: uuid("id").primaryKey().notNull(),
   name: string("name").notNull(),
   email: string("email").unique().notNull(),
+  metadata: json<{ plan: string }>("metadata"),
 });
 
 const db = createOrm({
-  url: "sqlite::memory:",
+  adapter: "sqlite",
+  url: ":memory:",
   tables: { users },
 });
 
-// Result-pattern query
-const [findErr, rows] = await db.users.findMany({
+const rows = await db.users.findMany({
   where: { name: { contains: "John" } },
   take: 10,
 });
 
-if (findErr) {
-  console.error(findErr.type, findErr.message);
-}
-
-// Create record (result pattern)
-const [createErr, user] = await db.users.create({
+const user = await db.users.create({
   data: {
+    id: "1",
     name: "John Doe",
     email: "john@example.com",
   },
 });
 
-// Low-level SQL-style methods are also available
-const insertedRows = await db.users.insert({
-  data: {
-    name: "Jane Doe",
-    email: "jane@example.com",
-  },
-  returning: true,
-});
-
-console.log(rows, user, createErr, insertedRows);
-```
-
-### Run ORM Migrations
-
-```bash
-# create migration from schema diff
-semola orm migrations create add-users
-
-# apply pending migrations
-semola orm migrations apply
-
-# rollback last applied migration
-semola orm migrations rollback
+console.log(rows, user);
 ```
 
 ### Check Permissions
@@ -345,14 +318,14 @@ _Higher is better for req/sec, lower is better for latency._
 - [Queue](./docs/queue.md) - Redis-backed job queue with timeouts & concurrency
 - [PubSub](./docs/pubsub.md) - Type-safe Redis pub/sub
 - [Cron](./docs/cron.md) - In-memory cron scheduler for periodic task execution
-- [Workflow](./docs/workflow.md) - Durable and resumable workflows with step persistence
+- [Workflow](./docs/workflow.md) - Durable and resumable workflows with retries and hooks
 - [Policy](./docs/policy.md) - Policy-based authorization
 - [i18n](./docs/i18n.md) - Type-safe internationalization
 - [Cache](./docs/cache.md) - Redis cache wrapper with TTL
 - [Errors](./docs/errors.md) - Result-based error handling
 - [Logging](./docs/logging.md) - Logging utility
 - [Prompts](./docs/prompts.md) - Interactive CLI prompts
-- [ORM](./docs/orm.md) - Type-safe data layer, result-pattern DX, and migrations
+- [ORM](./docs/orm.md) - Type-safe data layer with SQLite support
 
 ---
 

package/dist/chunk-CKQMccvm.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/lib/api/index.cjs

@@ -253,22 +253,36 @@ const generateOpenApiSpec = async (options) => {
 	return spec;
 };
 //#endregion
+//#region src/lib/api/errors.ts
+var ParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ParseError";
+	}
+};
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ValidationError";
+	}
+};
+//#endregion
 //#region src/lib/api/validation/index.ts
 const validateSchema = async (schema, data) => {
 	const result = await schema["~standard"].validate(data);
-	if (!result.issues) return require_lib_errors_index.ok(result.value);
-	return require_lib_errors_index.err("ValidationError", result.issues.map((issue) => {
+	if (!result.issues) return result.value;
+	throw new ValidationError(result.issues.map((issue) => {
 		let path = "unknown";
 		if (Array.isArray(issue.path)) path = issue.path.map(String).join(".");
 		return `${path}: ${issue.message ?? "validation failed"}`;
 	}).join(", "));
 };
 const validateBody = async (req, bodySchema, bodyCache) => {
-	if (!bodySchema) return require_lib_errors_index.ok(true);
-	if (!(req.headers.get("content-type") ?? "").includes("application/json")) return require_lib_errors_index.ok(void 0);
+	if (!bodySchema) return true;
+	if (!(req.headers.get("content-type") ?? "").includes("application/json")) return;
 	if (bodyCache?.parsed) return validateSchema(bodySchema, bodyCache.value);
 	const [parseError, parsedBody] = await require_lib_errors_index.mightThrow(req.json());
-	if (parseError) return require_lib_errors_index.err("ParseError", "Invalid JSON body");
+	if (parseError) throw new ParseError("Invalid JSON body");
 	if (bodyCache) {
 		bodyCache.parsed = true;
 		bodyCache.value = parsedBody;
@@ -276,7 +290,7 @@ const validateBody = async (req, bodySchema, bodyCache) => {
 	return validateSchema(bodySchema, parsedBody);
 };
 const validateQuery = async (req, querySchema) => {
-	if (!querySchema) return require_lib_errors_index.ok(true);
+	if (!querySchema) return true;
 	const qIndex = req.url.indexOf("?");
 	if (qIndex === -1) return validateSchema(querySchema, {});
 	const hashIndex = req.url.indexOf("#", qIndex + 1);
@@ -292,7 +306,7 @@ const validateQuery = async (req, querySchema) => {
 	return validateSchema(querySchema, queryParams);
 };
 const validateHeaders = async (req, headersSchema) => {
-	if (!headersSchema) return require_lib_errors_index.ok(true);
+	if (!headersSchema) return true;
 	const headers = {};
 	req.headers.forEach((value, key) => {
 		headers[key] = value;
@@ -300,13 +314,13 @@ const validateHeaders = async (req, headersSchema) => {
 	return validateSchema(headersSchema, headers);
 };
 const validateCookies = async (req, cookiesSchema) => {
-	if (!cookiesSchema) return require_lib_errors_index.ok(true);
+	if (!cookiesSchema) return true;
 	const cookieHeader = req.headers.get("cookie") ?? "";
 	const cookieMap = new Bun.CookieMap(cookieHeader);
 	return validateSchema(cookiesSchema, Object.fromEntries(cookieMap));
 };
 const validateParams = async (req, paramsSchema) => {
-	if (!paramsSchema) return require_lib_errors_index.ok(true);
+	if (!paramsSchema) return true;
 	return validateSchema(paramsSchema, req.params);
 };
 //#endregion
@@ -374,7 +388,7 @@ var Api = class {
 		};
 		const v = {};
 		if (schema.body) {
-			const [err, val] = await validateBody(req, schema.body, bodyCache);
+			const [err, val] = await require_lib_errors_index.mightThrow(validateBody(req, schema.body, bodyCache));
 			if (err) return {
 				success: false,
 				error: err
@@ -382,7 +396,7 @@ var Api = class {
 			v.body = val;
 		}
 		if (schema.query) {
-			const [err, val] = await validateQuery(req, schema.query);
+			const [err, val] = await require_lib_errors_index.mightThrow(validateQuery(req, schema.query));
 			if (err) return {
 				success: false,
 				error: err
@@ -390,7 +404,7 @@ var Api = class {
 			v.query = val;
 		}
 		if (schema.headers) {
-			const [err, val] = await validateHeaders(req, schema.headers);
+			const [err, val] = await require_lib_errors_index.mightThrow(validateHeaders(req, schema.headers));
 			if (err) return {
 				success: false,
 				error: err
@@ -398,7 +412,7 @@ var Api = class {
 			v.headers = val;
 		}
 		if (schema.cookies) {
-			const [err, val] = await validateCookies(req, schema.cookies);
+			const [err, val] = await require_lib_errors_index.mightThrow(validateCookies(req, schema.cookies));
 			if (err) return {
 				success: false,
 				error: err
@@ -406,7 +420,7 @@ var Api = class {
 			v.cookies = val;
 		}
 		if (schema.params) {
-			const [err, val] = await validateParams(req, schema.params);
+			const [err, val] = await require_lib_errors_index.mightThrow(validateParams(req, schema.params));
 			if (err) return {
 				success: false,
 				error: err
@@ -433,7 +447,7 @@ var Api = class {
 		if (!(response.headers.get("content-type") ?? "").includes("application/json")) return response;
 		const [parseError, body] = await require_lib_errors_index.mightThrow(response.clone().json());
 		if (parseError) return responseHelpers.json(400, { message: "Invalid response body" });
-		const [validationError] = await validateSchema(statusSchema, body);
+		const [validationError] = await require_lib_errors_index.mightThrow(validateSchema(statusSchema, body));
 		if (validationError) return responseHelpers.json(400, { message: validationError.message });
 		return response;
 	}

package/dist/lib/api/index.mjs

@@ -1,4 +1,4 @@
-import { err, mightThrow, ok } from "../errors/index.mjs";
+import { mightThrow } from "../errors/index.mjs";
 //#region src/lib/api/openapi/index.ts
 const toOpenAPISchema = (schema, io = "input") => ({ schema: schema["~standard"].jsonSchema[io]({ target: "draft-2020-12" }) });
 const getSchemaDescription = (schema) => {
@@ -252,22 +252,36 @@ const generateOpenApiSpec = async (options) => {
 	return spec;
 };
 //#endregion
+//#region src/lib/api/errors.ts
+var ParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ParseError";
+	}
+};
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ValidationError";
+	}
+};
+//#endregion
 //#region src/lib/api/validation/index.ts
 const validateSchema = async (schema, data) => {
 	const result = await schema["~standard"].validate(data);
-	if (!result.issues) return ok(result.value);
-	return err("ValidationError", result.issues.map((issue) => {
+	if (!result.issues) return result.value;
+	throw new ValidationError(result.issues.map((issue) => {
 		let path = "unknown";
 		if (Array.isArray(issue.path)) path = issue.path.map(String).join(".");
 		return `${path}: ${issue.message ?? "validation failed"}`;
 	}).join(", "));
 };
 const validateBody = async (req, bodySchema, bodyCache) => {
-	if (!bodySchema) return ok(true);
-	if (!(req.headers.get("content-type") ?? "").includes("application/json")) return ok(void 0);
+	if (!bodySchema) return true;
+	if (!(req.headers.get("content-type") ?? "").includes("application/json")) return;
 	if (bodyCache?.parsed) return validateSchema(bodySchema, bodyCache.value);
 	const [parseError, parsedBody] = await mightThrow(req.json());
-	if (parseError) return err("ParseError", "Invalid JSON body");
+	if (parseError) throw new ParseError("Invalid JSON body");
 	if (bodyCache) {
 		bodyCache.parsed = true;
 		bodyCache.value = parsedBody;
@@ -275,7 +289,7 @@ const validateBody = async (req, bodySchema, bodyCache) => {
 	return validateSchema(bodySchema, parsedBody);
 };
 const validateQuery = async (req, querySchema) => {
-	if (!querySchema) return ok(true);
+	if (!querySchema) return true;
 	const qIndex = req.url.indexOf("?");
 	if (qIndex === -1) return validateSchema(querySchema, {});
 	const hashIndex = req.url.indexOf("#", qIndex + 1);
@@ -291,7 +305,7 @@ const validateQuery = async (req, querySchema) => {
 	return validateSchema(querySchema, queryParams);
 };
 const validateHeaders = async (req, headersSchema) => {
-	if (!headersSchema) return ok(true);
+	if (!headersSchema) return true;
 	const headers = {};
 	req.headers.forEach((value, key) => {
 		headers[key] = value;
@@ -299,13 +313,13 @@ const validateHeaders = async (req, headersSchema) => {
 	return validateSchema(headersSchema, headers);
 };
 const validateCookies = async (req, cookiesSchema) => {
-	if (!cookiesSchema) return ok(true);
+	if (!cookiesSchema) return true;
 	const cookieHeader = req.headers.get("cookie") ?? "";
 	const cookieMap = new Bun.CookieMap(cookieHeader);
 	return validateSchema(cookiesSchema, Object.fromEntries(cookieMap));
 };
 const validateParams = async (req, paramsSchema) => {
-	if (!paramsSchema) return ok(true);
+	if (!paramsSchema) return true;
 	return validateSchema(paramsSchema, req.params);
 };
 //#endregion
@@ -373,7 +387,7 @@ var Api = class {
 		};
 		const v = {};
 		if (schema.body) {
-			const [err, val] = await validateBody(req, schema.body, bodyCache);
+			const [err, val] = await mightThrow(validateBody(req, schema.body, bodyCache));
 			if (err) return {
 				success: false,
 				error: err
@@ -381,7 +395,7 @@ var Api = class {
 			v.body = val;
 		}
 		if (schema.query) {
-			const [err, val] = await validateQuery(req, schema.query);
+			const [err, val] = await mightThrow(validateQuery(req, schema.query));
 			if (err) return {
 				success: false,
 				error: err
@@ -389,7 +403,7 @@ var Api = class {
 			v.query = val;
 		}
 		if (schema.headers) {
-			const [err, val] = await validateHeaders(req, schema.headers);
+			const [err, val] = await mightThrow(validateHeaders(req, schema.headers));
 			if (err) return {
 				success: false,
 				error: err
@@ -397,7 +411,7 @@ var Api = class {
 			v.headers = val;
 		}
 		if (schema.cookies) {
-			const [err, val] = await validateCookies(req, schema.cookies);
+			const [err, val] = await mightThrow(validateCookies(req, schema.cookies));
 			if (err) return {
 				success: false,
 				error: err
@@ -405,7 +419,7 @@ var Api = class {
 			v.cookies = val;
 		}
 		if (schema.params) {
-			const [err, val] = await validateParams(req, schema.params);
+			const [err, val] = await mightThrow(validateParams(req, schema.params));
 			if (err) return {
 				success: false,
 				error: err
@@ -432,7 +446,7 @@ var Api = class {
 		if (!(response.headers.get("content-type") ?? "").includes("application/json")) return response;
 		const [parseError, body] = await mightThrow(response.clone().json());
 		if (parseError) return responseHelpers.json(400, { message: "Invalid response body" });
-		const [validationError] = await validateSchema(statusSchema, body);
+		const [validationError] = await mightThrow(validateSchema(statusSchema, body));
 		if (validationError) return responseHelpers.json(400, { message: validationError.message });
 		return response;
 	}

package/dist/lib/cache/index.cjs

@@ -1,5 +1,37 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_lib_errors_index = require("../errors/index.cjs");
+//#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;
@@ -11,41 +43,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 require_lib_errors_index.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] = require_lib_errors_index.mightThrowSync(() => this.deserialize(value));
-		if (deserializeErr) return this.fail("CacheError", `Unable to deserialize value for key ${key}`);
-		return require_lib_errors_index.ok(deserialized);
+		if (deserializeErr) throw new DeserializationError(`Unable to deserialize value for key ${key}`);
+		return deserialized;
 	}
 	async set(key, value) {
-		if (!this.isEnabled) return require_lib_errors_index.ok(value);
+		if (!this.isEnabled) return value;
 		const [serializeErr, serialized] = require_lib_errors_index.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] = require_lib_errors_index.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 require_lib_errors_index.mightThrow(this.getSetPromise(resolvedKey, serialized, ttl));
-		if (setError) return this.fail("CacheError", `Unable to set value for key ${key}`);
-		return require_lib_errors_index.ok(value);
+		if (setError) throw new CacheError(`Unable to set value for key ${key}`);
+		return value;
 	}
 	async delete(key) {
-		if (!this.isEnabled) return require_lib_errors_index.ok(0);
+		if (!this.isEnabled) return 0;
 		const resolvedKey = this.resolveKey(key);
 		const [error, data] = await require_lib_errors_index.mightThrow(this.options.redis.del(resolvedKey));
-		if (error) return this.fail("CacheError", `Unable to delete key ${key}`);
-		return require_lib_errors_index.ok(data);
-	}
-	fail(type, message) {
-		this.options.onError?.({
-			type,
-			message
-		});
-		return require_lib_errors_index.err(type, message);
+		if (error) throw new CacheError(`Unable to delete key ${key}`);
+		return data;
 	}
 	get isEnabled() {
 		return this.options.enabled !== false;

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

@@ -1,5 +1,4 @@
 //#region src/lib/cache/types.d.ts
-type CacheError = "CacheError" | "InvalidTTLError" | "NotFoundError";
 type CacheOptions<T> = {
   redis: Bun.RedisClient;
   ttl?: number | ((key: string, value: T) => number);
@@ -7,10 +6,6 @@ type CacheOptions<T> = {
   prefix?: string;
   serializer?: (value: T) => string;
   deserializer?: (raw: string) => T;
-  onError?: (error: {
-    type: CacheError;
-    message: string;
-  }) => void;
 };
 //#endregion
 //#region src/lib/cache/index.d.ts
@@ -19,25 +14,9 @@ declare class Cache<T> {
   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;

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

@@ -1,5 +1,4 @@
 //#region src/lib/cache/types.d.ts
-type CacheError = "CacheError" | "InvalidTTLError" | "NotFoundError";
 type CacheOptions<T> = {
   redis: Bun.RedisClient;
   ttl?: number | ((key: string, value: T) => number);
@@ -7,10 +6,6 @@ type CacheOptions<T> = {
   prefix?: string;
   serializer?: (value: T) => string;
   deserializer?: (raw: string) => T;
-  onError?: (error: {
-    type: CacheError;
-    message: string;
-  }) => void;
 };
 //#endregion
 //#region src/lib/cache/index.d.ts
@@ -19,25 +14,9 @@ declare class Cache<T> {
   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;