semola 0.5.3 → 0.6.0

package/dist/lib/api/index.mjs

@@ -1,3 +1,535 @@
-import { Api } from "../../api/core/index.mjs";
-import { Middleware } from "../../api/middleware/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) => {
+	const metadata = schema["~standard"];
+	if (!metadata) return "";
+	if ("description" in metadata && typeof metadata.description === "string") return metadata.description;
+	return "";
+};
+const requestFields = [
+	"body",
+	"query",
+	"headers",
+	"cookies",
+	"params"
+];
+const mergeRequestSchemas = (schemas) => {
+	const merged = {};
+	for (const schema of schemas) {
+		if (!schema) continue;
+		for (const field of requestFields) if (schema[field]) merged[field] = schema[field];
+	}
+	return merged;
+};
+const mergeResponseSchemas = (schemas) => {
+	const merged = {};
+	for (const schema of schemas) {
+		if (!schema) continue;
+		for (const status in schema) {
+			const statusCode = Number(status);
+			const responseSchema = schema[statusCode];
+			if (responseSchema) merged[statusCode] = responseSchema;
+		}
+	}
+	return Object.keys(merged).length > 0 ? merged : void 0;
+};
+const convertSchemaToOpenApi = async (schema, io = "input") => {
+	const result = toOpenAPISchema(schema, io);
+	const { schema: jsonSchema } = result;
+	const schemaId = jsonSchema.id;
+	if (schemaId && typeof schemaId === "string") {
+		const schemaWithoutId = { ...jsonSchema };
+		delete schemaWithoutId.id;
+		delete schemaWithoutId.$schema;
+		return {
+			schema: { $ref: `#/components/schemas/${schemaId}` },
+			components: { schemas: { [schemaId]: schemaWithoutId } }
+		};
+	}
+	if (jsonSchema.$schema) {
+		const schemaWithoutMeta = { ...jsonSchema };
+		delete schemaWithoutMeta.$schema;
+		return {
+			schema: schemaWithoutMeta,
+			components: void 0
+		};
+	}
+	return result;
+};
+const convertSchemaToInlineOpenApi = async (schema, io = "input") => {
+	const { schema: jsonSchema } = toOpenAPISchema(schema, io);
+	const cleanSchema = { ...jsonSchema };
+	delete cleanSchema.$schema;
+	delete cleanSchema.id;
+	return {
+		schema: cleanSchema,
+		components: void 0
+	};
+};
+const extractParametersFromSchema = async (schema, location) => {
+	const { schema: jsonSchema, components } = await convertSchemaToInlineOpenApi(schema);
+	if (jsonSchema.type !== "object") return {
+		parameters: [],
+		components
+	};
+	if (!jsonSchema.properties) return {
+		parameters: [],
+		components
+	};
+	const parameters = [];
+	const requiredFields = jsonSchema.required ?? [];
+	for (const name in jsonSchema.properties) {
+		const propertySchema = jsonSchema.properties[name];
+		const isRequired = requiredFields.includes(name);
+		parameters.push({
+			name,
+			in: location,
+			required: isRequired,
+			schema: propertySchema
+		});
+	}
+	return {
+		parameters,
+		components
+	};
+};
+const normalizePathForOpenAPI = (path) => {
+	return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}");
+};
+const extractPathParameters = (path) => {
+	const matches = path.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
+	if (!matches) return [];
+	return matches.map((match) => match.slice(1));
+};
+const paramSources = [
+	["query", "query"],
+	["headers", "header"],
+	["cookies", "cookie"]
+];
+const createParameters = async (request, path) => {
+	const parameters = [];
+	const allComponents = [];
+	for (const [field, location] of paramSources) if (request[field]) {
+		const { parameters: params, components } = await extractParametersFromSchema(request[field], location);
+		parameters.push(...params);
+		if (components) allComponents.push(components);
+	}
+	const pathParamNames = extractPathParameters(path);
+	if (pathParamNames.length > 0 && request.params) {
+		const { schema: jsonSchema, components } = await convertSchemaToInlineOpenApi(request.params);
+		if (components) allComponents.push(components);
+		if (jsonSchema.type === "object" && jsonSchema.properties) for (const name of pathParamNames) {
+			const propertySchema = jsonSchema.properties[name];
+			if (propertySchema) parameters.push({
+				name,
+				in: "path",
+				required: true,
+				schema: propertySchema
+			});
+		}
+	}
+	return {
+		parameters,
+		components: allComponents
+	};
+};
+const createRequestBody = async (bodySchema) => {
+	const { schema, components } = await convertSchemaToOpenApi(bodySchema);
+	return {
+		components,
+		requestBody: {
+			required: true,
+			content: { "application/json": { schema } }
+		}
+	};
+};
+const createResponses = async (response) => {
+	const responses = {};
+	const allComponents = [];
+	if (!response) return {
+		responses,
+		components: allComponents
+	};
+	for (const status in response) {
+		const statusCode = String(status);
+		const schema = response[Number(status)];
+		if (!schema) continue;
+		const description = getSchemaDescription(schema);
+		const { schema: jsonSchema, components } = await convertSchemaToOpenApi(schema, "output");
+		if (components) allComponents.push(components);
+		responses[statusCode] = {
+			description: description || `Response with status ${statusCode}`,
+			content: { "application/json": { schema: jsonSchema } }
+		};
+	}
+	return {
+		responses,
+		components: allComponents
+	};
+};
+const createOperation = async (route, globalMiddlewares, prefix) => {
+	const allMiddlewares = [...globalMiddlewares ?? [], ...route.middlewares ?? []];
+	const requestSchemas = [];
+	const responseSchemas = [];
+	for (const middleware of allMiddlewares) {
+		requestSchemas.push(middleware.options.request);
+		responseSchemas.push(middleware.options.response);
+	}
+	requestSchemas.push(route.request);
+	responseSchemas.push(route.response);
+	const mergedRequest = mergeRequestSchemas(requestSchemas);
+	const mergedResponse = mergeResponseSchemas(responseSchemas);
+	const { parameters, components: parameterComponents } = await createParameters(mergedRequest, prefix ? prefix + route.path : route.path);
+	const { responses, components: responseComponents } = await createResponses(mergedResponse);
+	const operation = { responses };
+	const allComponents = [];
+	allComponents.push(...responseComponents);
+	allComponents.push(...parameterComponents);
+	for (const field of [
+		"summary",
+		"description",
+		"operationId"
+	]) if (route[field]) operation[field] = route[field];
+	if (route.tags && route.tags.length > 0) operation.tags = route.tags;
+	if (parameters.length > 0) operation.parameters = parameters;
+	const bodySchema = mergedRequest.body;
+	if (bodySchema) {
+		const { requestBody, components: bodyComponents } = await createRequestBody(bodySchema);
+		operation.requestBody = requestBody;
+		if (bodyComponents) allComponents.push(bodyComponents);
+	}
+	return {
+		operation,
+		components: allComponents
+	};
+};
+const componentKeys = [
+	"schemas",
+	"responses",
+	"parameters",
+	"requestBodies"
+];
+const mergeComponents = (componentsArray) => {
+	const merged = {};
+	for (const components of componentsArray) {
+		if (!components) continue;
+		for (const key of componentKeys) if (components[key]) merged[key] = {
+			...merged[key],
+			...components[key]
+		};
+	}
+	return merged;
+};
+const generateOpenApiSpec = async (options) => {
+	const spec = {
+		openapi: "3.1.0",
+		info: {
+			title: options.title,
+			description: options.description,
+			version: options.version
+		},
+		paths: {}
+	};
+	if (options.servers && options.servers.length > 0) spec.servers = options.servers;
+	if (options.securitySchemes) spec.components = { securitySchemes: options.securitySchemes };
+	const allRouteComponents = [];
+	for (const route of options.routes) {
+		const openApiPath = normalizePathForOpenAPI(options.prefix ? options.prefix + route.path : route.path);
+		const method = route.method.toLowerCase();
+		if (!spec.paths[openApiPath]) spec.paths[openApiPath] = {};
+		const { operation, components } = await createOperation(route, options.globalMiddlewares ?? [], options.prefix);
+		spec.paths[openApiPath][method] = operation;
+		allRouteComponents.push(...components);
+	}
+	const mergedComponents = mergeComponents(allRouteComponents);
+	if (!spec.components) spec.components = {};
+	if (options.securitySchemes) spec.components.securitySchemes = options.securitySchemes;
+	for (const key of componentKeys) {
+		const value = mergedComponents[key];
+		if (value && Object.keys(value).length > 0) spec.components[key] = value;
+	}
+	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 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 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) throw new ParseError("Invalid JSON body");
+	if (bodyCache) {
+		bodyCache.parsed = true;
+		bodyCache.value = parsedBody;
+	}
+	return validateSchema(bodySchema, parsedBody);
+};
+const validateQuery = async (req, querySchema) => {
+	if (!querySchema) return true;
+	const qIndex = req.url.indexOf("?");
+	if (qIndex === -1) return validateSchema(querySchema, {});
+	const hashIndex = req.url.indexOf("#", qIndex + 1);
+	const queryString = hashIndex === -1 ? req.url.slice(qIndex + 1) : req.url.slice(qIndex + 1, hashIndex);
+	const searchParams = new URLSearchParams(queryString);
+	const queryParams = {};
+	for (const key of searchParams.keys()) {
+		const values = searchParams.getAll(key);
+		const [firstValue] = values;
+		if (values.length === 1) queryParams[key] = firstValue;
+		else queryParams[key] = values;
+	}
+	return validateSchema(querySchema, queryParams);
+};
+const validateHeaders = async (req, headersSchema) => {
+	if (!headersSchema) return true;
+	const headers = {};
+	req.headers.forEach((value, key) => {
+		headers[key] = value;
+	});
+	return validateSchema(headersSchema, headers);
+};
+const validateCookies = async (req, cookiesSchema) => {
+	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 true;
+	return validateSchema(paramsSchema, req.params);
+};
+//#endregion
+//#region src/lib/api/core/index.ts
+const defaultValidated = Object.freeze({
+	body: void 0,
+	query: void 0,
+	headers: void 0,
+	cookies: void 0,
+	params: void 0
+});
+const responseHelpers = {
+	json: (status, data) => Response.json(data, { status }),
+	text: (status, text) => new Response(text, { status }),
+	html: (status, html) => new Response(html, {
+		status,
+		headers: { "Content-Type": "text/html" }
+	}),
+	redirect: (status, url) => Response.redirect(url, status)
+};
+const noopGet = () => void 0;
+const stripTrailingSlash = (path) => {
+	if (path !== "/" && path.endsWith("/")) return path.slice(0, -1);
+	return path;
+};
+const hasSchemas = (schema) => schema && (schema.body || schema.query || schema.headers || schema.cookies || schema.params);
+const needsBodyCache = (schema) => schema?.body !== void 0;
+const shouldCreateBodyCache = (hasMiddlewares, allMiddlewares, request) => {
+	if (needsBodyCache(request)) return true;
+	if (!hasMiddlewares) return false;
+	return allMiddlewares.some((mw) => needsBodyCache(mw.options.request));
+};
+const resolveValidation = (v) => {
+	if (v === void 0 || v === true) return {
+		input: true,
+		output: true
+	};
+	if (v === false) return {
+		input: false,
+		output: false
+	};
+	return {
+		input: v.input !== false,
+		output: v.output !== false
+	};
+};
+var Api = class {
+	options;
+	routes = [];
+	constructor(options = {}) {
+		this.options = options;
+	}
+	getFullPath(path) {
+		const normalizedPath = stripTrailingSlash(path) || "/";
+		if (!this.options.prefix) return normalizedPath;
+		const normalizedPrefix = stripTrailingSlash(this.options.prefix);
+		if (normalizedPrefix === "/") return normalizedPath;
+		if (normalizedPath === "/") return normalizedPrefix;
+		return normalizedPrefix + normalizedPath;
+	}
+	async validateRequestSchema(req, schema, bodyCache) {
+		if (!schema) return {
+			success: true,
+			data: {}
+		};
+		const v = {};
+		if (schema.body) {
+			const [err, val] = await mightThrow(validateBody(req, schema.body, bodyCache));
+			if (err) return {
+				success: false,
+				error: err
+			};
+			v.body = val;
+		}
+		if (schema.query) {
+			const [err, val] = await mightThrow(validateQuery(req, schema.query));
+			if (err) return {
+				success: false,
+				error: err
+			};
+			v.query = val;
+		}
+		if (schema.headers) {
+			const [err, val] = await mightThrow(validateHeaders(req, schema.headers));
+			if (err) return {
+				success: false,
+				error: err
+			};
+			v.headers = val;
+		}
+		if (schema.cookies) {
+			const [err, val] = await mightThrow(validateCookies(req, schema.cookies));
+			if (err) return {
+				success: false,
+				error: err
+			};
+			v.cookies = val;
+		}
+		if (schema.params) {
+			const [err, val] = await mightThrow(validateParams(req, schema.params));
+			if (err) return {
+				success: false,
+				error: err
+			};
+			v.params = val;
+		}
+		return {
+			success: true,
+			data: v
+		};
+	}
+	createContext(req, validated, extensions) {
+		return {
+			raw: req,
+			req: validated,
+			...responseHelpers,
+			get: (key) => extensions[key]
+		};
+	}
+	async validateResponseBody(response, schema) {
+		if (!schema) return response;
+		const statusSchema = schema[response.status];
+		if (!statusSchema) return response;
+		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 mightThrow(validateSchema(statusSchema, body));
+		if (validationError) return responseHelpers.json(400, { message: validationError.message });
+		return response;
+	}
+	buildBunRoutes() {
+		const bunRoutes = {};
+		const validationConfig = resolveValidation(this.options.validation);
+		for (const route of this.routes) {
+			const { path, method, handler, request, response, middlewares } = route;
+			const fullPath = this.getFullPath(path);
+			if (!bunRoutes[fullPath]) bunRoutes[fullPath] = {};
+			const allMiddlewares = [...this.options.middlewares ?? [], ...middlewares ?? []];
+			const hasMiddlewares = allMiddlewares.length > 0;
+			const hasRouteSchemas = hasSchemas(request);
+			const effectiveOutputValidation = validationConfig.output && !!response;
+			if (!hasMiddlewares && !(validationConfig.input && hasRouteSchemas) && !effectiveOutputValidation) bunRoutes[fullPath][method] = (req) => {
+				const context = Object.create(responseHelpers);
+				context.raw = req;
+				context.req = defaultValidated;
+				context.get = noopGet;
+				return handler(context);
+			};
+			else bunRoutes[fullPath][method] = async (req) => {
+				const extensions = {};
+				const bodyCache = validationConfig.input && shouldCreateBodyCache(hasMiddlewares, allMiddlewares, request) ? {
+					parsed: false,
+					value: void 0
+				} : void 0;
+				for (const mw of allMiddlewares) {
+					const { request: reqSchema, handler: mwHandler } = mw.options;
+					let validated = defaultValidated;
+					if (validationConfig.input && hasSchemas(reqSchema)) {
+						const result = await this.validateRequestSchema(req, reqSchema, bodyCache);
+						if (!result.success) return responseHelpers.json(400, { message: result.error?.message });
+						validated = result.data;
+					}
+					const mwResult = await mwHandler(this.createContext(req, validated, extensions));
+					if (mwResult instanceof Response) return mwResult;
+					if (mwResult) Object.assign(extensions, mwResult);
+				}
+				let routeValidated = defaultValidated;
+				if (validationConfig.input && hasRouteSchemas) {
+					const result = await this.validateRequestSchema(req, request, bodyCache);
+					if (!result.success) return responseHelpers.json(400, { message: result.error?.message });
+					routeValidated = result.data;
+				}
+				const handlerResponse = await handler(this.createContext(req, routeValidated, extensions));
+				if (effectiveOutputValidation) return this.validateResponseBody(handlerResponse, response);
+				return handlerResponse;
+			};
+		}
+		return bunRoutes;
+	}
+	defineRoute(config) {
+		this.routes.push(config);
+	}
+	getOpenApiSpec() {
+		return generateOpenApiSpec({
+			title: this.options.openapi?.title ?? "API",
+			description: this.options.openapi?.description,
+			version: this.options.openapi?.version ?? "1.0.0",
+			prefix: this.options.prefix,
+			servers: this.options.openapi?.servers,
+			securitySchemes: this.options.openapi?.securitySchemes,
+			routes: this.routes,
+			globalMiddlewares: this.options.middlewares
+		});
+	}
+	serve(port, callback) {
+		const bunRoutes = this.buildBunRoutes();
+		const server = Bun.serve({
+			port,
+			routes: bunRoutes,
+			fetch: () => new Response("Not found", { status: 404 })
+		});
+		if (callback) callback(server);
+	}
+};
+//#endregion
+//#region src/lib/api/middleware/index.ts
+var Middleware = class {
+	constructor(options) {
+		this.options = options;
+	}
+};
+//#endregion
 export { Api, Middleware };

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,30 +1,22 @@
-import { CacheOptions } from "../../cache/types.cjs";
-
+//#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.cts.map
+export { Cache };