@daiso-tech/core 0.45.0 → 0.46.0

package/README.md

@@ -1,64 +1,70 @@
+# @daiso-tech/core
+
 [![npm version](https://img.shields.io/npm/v/@daiso-tech/core)](https://www.npmjs.com/package/@daiso-tech/core)
 ![NPM Downloads](https://img.shields.io/npm/dy/@daiso-tech/core)
-![Static Badge](https://img.shields.io/badge/TypeScript-3178C6?logo=TypeScript&logoColor=white)
+![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=TypeScript&logoColor=white)
 [![ES Modules](https://img.shields.io/badge/module%20type-ESM-blue)](https://nodejs.org/api/esm.html)
 [![License](https://img.shields.io/npm/l/@daiso-tech/core)](LICENSE)
 
-# @daiso-tech/core
-
-`@daiso-tech/core` is a TypeScript-first backend library for building web apps and API servers. It includes an ecosystem of official packages designed to work seamlessly together.
-
-**@daiso-tech/core** is a library of backend server components designed for maximum flexibility. While each component is fully functional on its own, they are written to work seamlessly together to build robust server-side logic.
-
-Key Features:
-- **Framework Agnostic:** Built without a dependency injection (DI) container, the library integrates effortlessly into any framework / library. Whether you use Express.js, backend frameworks like AdonisJS or NestJS, or full-stack frameworks like Next.js, Nuxt, or TanStack Start, these components "just work."
-
-- **Runtime Portability:** By leveraging the Adapter Pattern, the library remains decoupled from specific runtimes. Easily implement custom adapters, such as Cloudflare Durable Objects or Amazon DynamoDB, for better serverless integration with cloudflare workers or aws lambda.
-
-- **Test Friendly:** Testing is simple because every component comes with an "in-memory" adapter. This means you can run your tests instantly without needing to connect to a real database or server.
-
-- **Developer Friendly:** Save time with high-quality documentation and a readable, well-documented codebase. Clear comments and a logical structure make it easy to understand and extend system functionality.
-
-- **Type safe:**
-  We pay a closer look at type-safety, seamless intellisense, and support for auto imports when designing library APIs.
+`@daiso-tech/core` is a **TypeScript-first backend toolkit** designed for building resilient web applications and API servers. It provides a suite of decoupled, high-performance components that work seamlessly across any JavaScript runtime.
 
-- **ESM ready:**
-  @daiso-tech/core leverages modern JavaScript primitives, including ES modules
+[**Explore the Docs**](https://daiso-core.vercel.app/docs/Installation) | [**NPM Package**](https://www.npmjs.com/package/@daiso-tech/core)
 
-- **Supports standard schema:**
-  Integrated seamlessly with [standard schema](https://standardschema.dev/) allowing you to use libraries like zod to ensure both compile time and runtime typesafety.
+---
 
-[Get started now](https://daiso-core.vercel.app/docs/Installation)
+## 🚀 Key Features
 
-## A growing collection of officially maintained components
+* **Framework Agnostic** No Dependency Injection (DI) containers required. Effortlessly integrate with Express, NestJS, AdonisJS, or full-stack frameworks like Next.js, Nuxt, and TanStack Start.
+* **Runtime Portability** Leverages the **Adapter Pattern** to decouple your logic from the runtime. Switch between Node.js, Cloudflare Workers (Durable Objects), or AWS Lambda without rewriting core logic.
+* **Test-Driven Excellence** Every component includes a built-in **"in-memory" adapter**. Run unit tests instantly without spinning up databases or external infrastructure.
+* **Type Safety & DX** Deep IntelliSense support and strict type-safety. Designed for auto-imports and modern developer workflows.
+* **Standard Schema Support** Native integration with [Standard Schema](https://standardschema.dev/), allowing you to use **Zod**, **Valibot**, or **ArkType** for unified runtime validation.
 
-- **Cache:**
-  Speed up your applications by storing slowly changing data in a cache store.
+---
 
-- **EventBus:**
-  Easily send events accross different applications or in-memory.
+## 🛠 Quick Start
 
-- **Circuit-breaker:**
-  A circuit-breaker is a resilience primitive preventing cascading failures from external services by stopping calls to a failing service.
+```bash
+npm install @daiso-tech/core
+```
 
-- **Rate-limiter:**
-  A Rate-limiter is a resilience primitive used to control the rate of traffic sent or received by a network interface or a service.
+## 📦 Core Components
 
-- **Lock:**
-  Synchronize the access to a shared resource to prevents several processes, or concurrent code, from executing a section of code at the same time.
+The `@daiso-tech/core` ecosystem provides a growing collection of officially maintained primitives for building robust systems:
 
-- **Semaphore:**
-  A semaphore is a concurrency control primitive used to limit the number of processes or systems that can access a shared resource of code concurrently.
+### Resilience
+| | |
+| :--- | :--- |
+| **Circuit Breaker** | Prevents cascading failures by stopping calls to failing external services. |
+| **Rate Limiter** | Controls traffic flow to protect your network interfaces and services. |
+| **Retry** | Retry middleware with support for different backoffs with jitter. |
+| **Timeout** | Timeout middleware that prevents resource exhaustion by killing long-running tasks. |
+| **Fallback** | Fallback middleware that ensures graceful degradation by returning default values. |
 
-- **Shared-lock:**
-  A shared-lock (a.k.a reader writer lock) is a concurrency primitive offering better concurrency than a lock by coordinating a reader semaphore for concurrent access and an writer lock for mutual exclusion, strictly preventing conflicting simultaneous access and maintaining data consistency.
+### Concurrency
+| | |
+| :--- | :--- |
+| **Lock** | Ensures mutual exclusion for shared resources across servers or procceses. |
+| **Semaphore** | Limits the number of concurrent servers or procceses accessing a specific resource. |
+| **Shared Lock** | Reader-writer lock coordinating concurrent reads and exclusive writes. |
 
-- **Serde:**
-  Add custom serialization and deserialization logic that seamlessly integrates with all other components.
+### Misc
+| | |
+| :--- | :--- |
+| **Cache** | High-performance caching with support for multiple store adapters. |
+| **EventBus** | Decoupled event-driven communication (In-memory or Distributed via redis). |
 
-- **Collection:**
-  Effortlessly work with Arrays, Iterables, and AsyncIterables. Filter and transform with precision.
+### Utilities
+| | |
+| :--- | :--- |
+| **Hooks** | Agnostic sync/async middleware that integrates with all components. |
+| **Serde** | Custom serialization/deserialization logic that integrates with all components. |
+| **Collection** | Precision filtering and transformation for Arrays, Iterables, AsyncIterables and ArrayLike objects. |
+| **TimeSpan** | A duration class offering seamless time manipulation while integrating with all components. |
+---
 
-- **Hooks:**
-  Extend any sync and async function with agnostic hooks.@daiso-tech/core includes predefined retry, fallback, timeout and hedging hooks to easily allow handling transient failures.
+## 🛠 Quick Start
 
+```bash
+npm install @daiso-tech/core
+```

package/dist/cache/contracts/database-cache-adapter.contract.d.ts

@@ -1,6 +1,7 @@
 /**
  * @module Cache
  */
+import { type InvokableFn } from "../../utilities/_module.js";
 /**
  *
  * IMPORT_PATH: `"@daiso-tech/core/cache/contracts"`
@@ -11,32 +12,20 @@ export type ICacheData<TType = unknown> = {
     expiration: Date | null;
 };
 /**
- *
  * IMPORT_PATH: `"@daiso-tech/core/cache/contracts"`
  * @group Contracts
  */
-export type ICacheDataExpiration = {
-    expiration: Date | null;
+export type IDatabaseCacheTransaction<TType = unknown> = {
+    find(key: string): Promise<ICacheData<TType> | null>;
+    upsert(key: string, value: TType, expiration?: Date | null): Promise<void>;
 };
 /**
- *
  * IMPORT_PATH: `"@daiso-tech/core/cache/contracts"`
  * @group Contracts
  */
-export type ICacheInsert<TType = unknown> = {
-    key: string;
-    value: TType;
+export type ICacheDataExpiration = {
     expiration: Date | null;
 };
-/**
- *
- * IMPORT_PATH: `"@daiso-tech/core/cache/contracts"`
- * @group Contracts
- */
-export type ICacheUpdate<TType = unknown> = {
-    key: string;
-    value: TType;
-};
 /**
  * The `IDatabaseCacheAdapter` contract defines a way for as key-value pairs independent of data storage.
  * This contract simplifies the implementation of cache adapters with CRUD-based databases, such as SQL databases and ORMs like TypeOrm and MikroOrm.
@@ -45,39 +34,12 @@ export type ICacheUpdate<TType = unknown> = {
  * @group Contracts
  */
 export type IDatabaseCacheAdapter<TType = unknown> = {
-    /**
-     * The `find` method returns the the `key` data which includs {@link ICacheData | `ICacheData.value`}  and {@link ICacheData | `ICacheData.expiration`}.
-     */
     find(key: string): Promise<ICacheData<TType> | null>;
-    /**
-     * The `insert` method inserts the given cache `data`.
-     */
-    insert(data: ICacheInsert<TType>): Promise<void>;
-    /**
-     * The `upsert` method inserts a key and if the key already exists then key will be updated with new `data.value` and `data.expiration`.
-     * The method always returns the old cache data if it exists otherwise null will be returned.
-     */
-    upsert(data: ICacheInsert<TType>): Promise<ICacheDataExpiration | null>;
-    /**
-     * The `removeExpiredMany` method updates a expired `key`.
-     */
-    updateExpired(data: ICacheInsert<TType>): Promise<number>;
-    /**
-     * The `removeExpiredMany` method updates a unexpired `key`.
-     */
-    updateUnexpired(data: ICacheUpdate<TType>): Promise<number>;
-    /**
-     * The `incrementUnexpired` should always throw an error if the existing item is not a number type.
-     */
-    incrementUnexpired(data: ICacheUpdate<number>): Promise<number>;
-    /**
-     * The `removeExpiredMany` method removes multiple expired `keys`.
-     */
-    removeExpiredMany(keys: string[]): Promise<number>;
-    /**
-     * The `removeExpiredMany` method removes multiple unexpired `keys`.
-     */
-    removeUnexpiredMany(keys: string[]): Promise<number>;
+    transaction<TValue>(trxFn: InvokableFn<[
+        trx: IDatabaseCacheTransaction<TType>
+    ], Promise<TValue>>): Promise<TValue>;
+    update(key: string, value: TType): Promise<ICacheDataExpiration | null>;
+    removeMany(keys: string[]): Promise<ICacheDataExpiration[]>;
     /**
      * The `removeAll` method removes all keys from the cache.
      */

package/dist/cache/contracts/database-cache-adapter.contract.js

@@ -1,5 +1,5 @@
 /**
  * @module Cache
  */
-export {};
+import {} from "../../utilities/_module.js";
 //# sourceMappingURL=database-cache-adapter.contract.js.map

package/dist/cache/contracts/database-cache-adapter.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"database-cache-adapter.contract.js","sourceRoot":"","sources":["../../../src/cache/contracts/database-cache-adapter.contract.ts"],"names":[],"mappings":"AAAA;;GAEG"}
+{"version":3,"file":"database-cache-adapter.contract.js","sourceRoot":"","sources":["../../../src/cache/contracts/database-cache-adapter.contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,MAAM,wBAAwB,CAAC"}

package/dist/cache/implementations/adapters/kysely-cache-adapter/kysely-cache-adapter.d.ts

@@ -2,35 +2,32 @@
  * @module Cache
  */
 import { type Kysely } from "kysely";
-import { type ICacheData, type ICacheInsert, type ICacheUpdate, type IDatabaseCacheAdapter } from "../../../../cache/contracts/_module.js";
+import { type ICacheData, type ICacheDataExpiration, type IDatabaseCacheAdapter, type IDatabaseCacheTransaction } from "../../../../cache/contracts/_module.js";
 import { type ISerde } from "../../../../serde/contracts/_module.js";
 import { type ITimeSpan } from "../../../../time-span/contracts/_module.js";
-import { type IDeinitizable, type IInitizable, type IPrunable } from "../../../../utilities/_module.js";
+import { type IDeinitizable, type IInitizable, type InvokableFn, type IPrunable } from "../../../../utilities/_module.js";
 /**
- *
  * IMPORT_PATH: `"@daiso-tech/core/cache/kysely-cache-adapter"`
  * @group Adapters
  */
-export type KyselyCacheAdapterTable = {
+export type KyselyCacheTable = {
     key: string;
     value: string;
     expiration: number | string | null;
 };
 /**
- *
  * IMPORT_PATH: `"@daiso-tech/core/cache/kysely-cache-adapter"`
  * @group Adapters
  */
-export type KyselyCacheAdapterTables = {
-    cache: KyselyCacheAdapterTable;
+export type KyselyCacheTables = {
+    cache: KyselyCacheTable;
 };
 /**
- *
  * IMPORT_PATH: `"@daiso-tech/core/cache/kysely-cache-adapter"`
  * @group Adapters
  */
 export type KyselyCacheAdapterSettings = {
-    kysely: Kysely<KyselyCacheAdapterTables>;
+    kysely: Kysely<KyselyCacheTables>;
     serde: ISerde<string>;
     /**
      * @default
@@ -46,6 +43,17 @@ export type KyselyCacheAdapterSettings = {
      */
     shouldRemoveExpiredKeys?: boolean;
 };
+/**
+ * @internal
+ */
+export declare class DatabaseCacheTransaction<TType> implements IDatabaseCacheTransaction<TType> {
+    private readonly kysely;
+    private readonly serde;
+    private readonly isMysql;
+    constructor(kysely: Kysely<KyselyCacheTables>, serde: ISerde<string>);
+    find(key: string): Promise<ICacheData<TType> | null>;
+    upsert(key: string, value: TType, expiration?: Date | null): Promise<void>;
+}
 /**
  * To utilize the `KyselyCacheAdapter`, you must install the [`"kysely"`](https://www.npmjs.com/package/kysely) package and configure a `Kysely` class instance.
  * The adapter have been tested with `sqlite`, `postgres` and `mysql` databases.
@@ -54,8 +62,7 @@ export type KyselyCacheAdapterSettings = {
  * @group Adapters
  */
 export declare class KyselyCacheAdapter<TType = unknown> implements IDatabaseCacheAdapter<TType>, IInitizable, IDeinitizable, IPrunable {
-    private static filterUnexpiredKeys;
-    private static filterExpiredKeys;
+    private readonly isMysql;
     private readonly serde;
     private readonly kysely;
     private readonly shouldRemoveExpiredKeys;
@@ -93,14 +100,12 @@ export declare class KyselyCacheAdapter<TType = unknown> implements IDatabaseCac
      */
     deInit(): Promise<void>;
     find(key: string): Promise<ICacheData<TType> | null>;
-    insert(data: ICacheInsert<TType>): Promise<void>;
-    private transaction;
-    upsert(data: ICacheInsert<TType>): Promise<ICacheData<TType> | null>;
-    updateExpired(data: ICacheInsert<TType>): Promise<number>;
-    updateUnexpired(data: ICacheUpdate<TType>): Promise<number>;
-    incrementUnexpired(data: ICacheUpdate<number>): Promise<number>;
-    removeExpiredMany(keys: string[]): Promise<number>;
-    removeUnexpiredMany(keys: string[]): Promise<number>;
+    private _transaction;
+    transaction<TValue>(trxFn: InvokableFn<[
+        trx: IDatabaseCacheTransaction<TType>
+    ], Promise<TValue>>): Promise<TValue>;
+    update(key: string, value: TType): Promise<ICacheDataExpiration | null>;
+    removeMany(keys: string[]): Promise<ICacheDataExpiration[]>;
     removeAll(): Promise<void>;
     removeByKeyPrefix(prefix: string): Promise<void>;
 }

package/dist/cache/implementations/adapters/kysely-cache-adapter/kysely-cache-adapter.js

@@ -1,12 +1,70 @@
 /**
  * @module Cache
  */
-import { MysqlAdapter, Transaction, } from "kysely";
+import { MysqlAdapter, Transaction } from "kysely";
 import {} from "../../../../cache/contracts/_module.js";
 import {} from "../../../../serde/contracts/_module.js";
 import {} from "../../../../time-span/contracts/_module.js";
 import { TimeSpan } from "../../../../time-span/implementations/_module.js";
 import {} from "../../../../utilities/_module.js";
+/**
+ * @internal
+ */
+export class DatabaseCacheTransaction {
+    kysely;
+    serde;
+    isMysql;
+    constructor(kysely, serde) {
+        this.kysely = kysely;
+        this.serde = serde;
+        this.isMysql =
+            this.kysely.getExecutor().adapter instanceof MysqlAdapter;
+    }
+    async find(key) {
+        const cacheData = await this.kysely
+            .selectFrom("cache")
+            .where("cache.key", "=", key)
+            .select(["cache.expiration", "cache.value"])
+            .executeTakeFirst();
+        if (cacheData === undefined) {
+            return null;
+        }
+        return {
+            value: this.serde.deserialize(cacheData.value),
+            expiration: cacheData.expiration === null
+                ? null
+                : new Date(Number(cacheData.expiration)),
+        };
+    }
+    async upsert(key, value, expiration) {
+        let expirationAsMs;
+        if (expiration instanceof Date) {
+            expirationAsMs = expiration.getTime();
+        }
+        else {
+            expirationAsMs = expiration;
+        }
+        const serializedValue = this.serde.serialize(value);
+        await this.kysely
+            .insertInto("cache")
+            .values({
+            key,
+            value: serializedValue,
+            expiration: expirationAsMs,
+        })
+            .$if(!this.isMysql, (eb) => eb.onConflict((eb) => eb.column("key").doUpdateSet({
+            key,
+            value: serializedValue,
+            expiration: expirationAsMs,
+        })))
+            .$if(this.isMysql, (eb) => eb.onDuplicateKeyUpdate({
+            key,
+            value: serializedValue,
+            expiration: expirationAsMs,
+        }))
+            .execute();
+    }
+}
 /**
  * To utilize the `KyselyCacheAdapter`, you must install the [`"kysely"`](https://www.npmjs.com/package/kysely) package and configure a `Kysely` class instance.
  * The adapter have been tested with `sqlite`, `postgres` and `mysql` databases.
@@ -15,29 +73,7 @@ import {} from "../../../../utilities/_module.js";
  * @group Adapters
  */
 export class KyselyCacheAdapter {
-    static filterUnexpiredKeys(keys) {
-        return (eb) => {
-            const hasNoExpiration = eb("cache.expiration", "is", null);
-            const hasExpiration = eb("cache.expiration", "is not", null);
-            const hasNotExpired = eb("cache.expiration", ">", Date.now());
-            const keysMatch = eb("cache.key", "in", keys);
-            return eb.and([
-                keysMatch,
-                eb.or([
-                    hasNoExpiration,
-                    eb.and([hasExpiration, hasNotExpired]),
-                ]),
-            ]);
-        };
-    }
-    static filterExpiredKeys(keys) {
-        return (eb) => {
-            const keysMatch = eb("cache.key", "in", keys);
-            const hasExpiration = eb("cache.expiration", "is not", null);
-            const hasExpired = eb("cache.expiration", "<=", Date.now());
-            return eb.and([keysMatch, hasExpiration, hasExpired]);
-        };
-    }
+    isMysql;
     serde;
     kysely;
     shouldRemoveExpiredKeys;
@@ -73,6 +109,8 @@ export class KyselyCacheAdapter {
         this.serde = serde;
         this.expiredKeysRemovalInterval = TimeSpan.fromTimeSpan(expiredKeysRemovalInterval);
         this.shouldRemoveExpiredKeys = shouldRemoveExpiredKeys;
+        this.isMysql =
+            this.kysely.getExecutor().adapter instanceof MysqlAdapter;
     }
     async removeAllExpired() {
         await this.kysely
@@ -138,135 +176,101 @@ export class KyselyCacheAdapter {
         }
     }
     async find(key) {
-        const row = await this.kysely
+        const cacheData = await this.kysely
             .selectFrom("cache")
             .where("cache.key", "=", key)
             .select(["cache.expiration", "cache.value"])
             .executeTakeFirst();
-        if (row === undefined) {
+        if (cacheData === undefined) {
             return null;
         }
         return {
-            value: this.serde.deserialize(row.value),
-            expiration: row.expiration !== null
-                ? new Date(Number(row.expiration))
-                : null,
+            value: this.serde.deserialize(cacheData.value),
+            expiration: cacheData.expiration === null
+                ? null
+                : new Date(Number(cacheData.expiration)),
         };
     }
-    async insert(data) {
-        await this.kysely
-            .insertInto("cache")
-            .values({
-            key: data.key,
-            value: this.serde.serialize(data.value),
-            expiration: data.expiration?.getTime() ?? null,
-        })
-            .executeTakeFirst();
-    }
-    async transaction(fn) {
+    _transaction(trxFn) {
         if (this.disableTransaction) {
-            return fn(this.kysely);
+            return trxFn(this.kysely);
         }
-        return await this.kysely
-            .transaction()
-            .setIsolationLevel("serializable")
-            .execute(fn);
-    }
-    async upsert(data) {
-        const expiration = data.expiration?.getTime() ?? null;
-        return await this.transaction(async (trx) => {
-            const prevRow = await trx
-                .selectFrom("cache")
-                .select(["cache.key", "cache.value", "cache.expiration"])
-                .where(KyselyCacheAdapter.filterUnexpiredKeys([data.key]))
-                .executeTakeFirst();
-            const isMysqlRunning = this.kysely.getExecutor().adapter instanceof MysqlAdapter;
-            await trx
-                .insertInto("cache")
-                .values({
-                key: data.key,
-                value: this.serde.serialize(data.value),
-                expiration,
-            })
-                .$if(isMysqlRunning, (eb) => eb.onDuplicateKeyUpdate({
-                value: this.serde.serialize(data.value),
-                expiration,
-            }))
-                .$if(!isMysqlRunning, (eb) => eb.onConflict((eb) => eb.columns(["key"]).doUpdateSet({
-                value: this.serde.serialize(data.value),
-                expiration,
-            })))
-                .executeTakeFirst();
-            if (prevRow === undefined) {
-                return null;
-            }
-            return {
-                value: this.serde.deserialize(prevRow.value),
-                expiration: prevRow.expiration !== null
-                    ? new Date(Number(prevRow.expiration))
-                    : null,
-            };
+        return this.kysely.transaction().execute(async (trx) => {
+            return await trxFn(trx);
         });
     }
-    async updateExpired(data) {
-        const updateResult = await this.kysely
-            .updateTable("cache")
-            .where(KyselyCacheAdapter.filterExpiredKeys([data.key]))
-            .set({
-            value: this.serde.serialize(data.value),
-            expiration: data.expiration?.getTime() ?? null,
-        })
-            .executeTakeFirst();
-        return Number(updateResult.numUpdatedRows);
-    }
-    async updateUnexpired(data) {
-        const updateResult = await this.kysely
-            .updateTable("cache")
-            .where(KyselyCacheAdapter.filterUnexpiredKeys([data.key]))
-            .set({
-            value: this.serde.serialize(data.value),
-        })
-            .executeTakeFirst();
-        return Number(updateResult.numUpdatedRows);
+    async transaction(trxFn) {
+        return await this._transaction((trx) => trxFn(new DatabaseCacheTransaction(trx, this.serde)));
     }
-    async incrementUnexpired(data) {
-        return await this.transaction(async (trx) => {
-            const row = await trx
-                .selectFrom("cache")
-                .select(["cache.value"])
-                .where(KyselyCacheAdapter.filterUnexpiredKeys([data.key]))
-                .executeTakeFirst();
-            if (row === undefined) {
-                return 0;
-            }
-            const { value: serializedValue } = row;
-            const value = this.serde.deserialize(serializedValue);
-            if (typeof value !== "number") {
-                throw new TypeError(`Unable to increment or decrement none number type key "${data.key}"`);
-            }
-            const updateResult = await trx
+    async update(key, value) {
+        let row;
+        const serializedValue = this.serde.serialize(value);
+        if (this.isMysql) {
+            row = await this._transaction(async (trx) => {
+                const rows = await trx
+                    .selectFrom("cache")
+                    .where("cache.key", "=", key)
+                    .select("cache.expiration")
+                    .executeTakeFirst();
+                await trx
+                    .updateTable("cache")
+                    .where("cache.key", "=", key)
+                    .set({
+                    value: serializedValue,
+                })
+                    .execute();
+                return rows;
+            });
+        }
+        else {
+            row = await this.kysely
                 .updateTable("cache")
-                .where(KyselyCacheAdapter.filterUnexpiredKeys([data.key]))
+                .where("cache.key", "=", key)
                 .set({
-                value: this.serde.serialize(value + data.value),
+                value: serializedValue,
             })
+                .returning("cache.expiration")
                 .executeTakeFirst();
-            return Number(updateResult.numUpdatedRows);
-        });
-    }
-    async removeExpiredMany(keys) {
-        const deleteResult = await this.kysely
-            .deleteFrom("cache")
-            .where(KyselyCacheAdapter.filterExpiredKeys(keys))
-            .executeTakeFirst();
-        return Number(deleteResult.numDeletedRows);
+        }
+        if (row === undefined) {
+            return null;
+        }
+        return {
+            expiration: row.expiration === null
+                ? null
+                : new Date(Number(row.expiration)),
+        };
     }
-    async removeUnexpiredMany(keys) {
-        const deleteResult = await this.kysely
-            .deleteFrom("cache")
-            .where(KyselyCacheAdapter.filterUnexpiredKeys(keys))
-            .executeTakeFirst();
-        return Number(deleteResult.numDeletedRows);
+    async removeMany(keys) {
+        let rows;
+        if (this.isMysql) {
+            rows = await this._transaction(async (trx) => {
+                const rows = await trx
+                    .selectFrom("cache")
+                    .where("cache.key", "in", keys)
+                    .select("cache.expiration")
+                    .execute();
+                await trx
+                    .deleteFrom("cache")
+                    .where("cache.key", "in", keys)
+                    .execute();
+                return rows;
+            });
+        }
+        else {
+            rows = await this.kysely
+                .deleteFrom("cache")
+                .where("cache.key", "in", keys)
+                .returning("cache.expiration")
+                .execute();
+        }
+        return rows.map((row) => {
+            return {
+                expiration: row.expiration === null
+                    ? null
+                    : new Date(Number(row.expiration)),
+            };
+        });
     }
     async removeAll() {
         await this.kysely.deleteFrom("cache").execute();