polystore 0.20.0 → 0.21.1

package/index.js

@@ -179,7 +179,7 @@ var File = class extends Client {
   // Check if this is the right class for the given client
   static test = (client) => {
     if (client instanceof URL) client = client.href;
-    return typeof client === "string" && client.startsWith("file://") && client.includes(".");
+    return typeof client === "string" && client.startsWith("file://") && client.endsWith(".json");
   };
   // We want to make sure the file already exists, so attempt to
   // create the folders and the file (but not OVERWRITE it, that's why the x flag)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polystore",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "A small compatibility layer for many popular KV stores like localStorage, Redis, FileSystem, etc.",
   "homepage": "https://polystore.dev",
   "repository": "https://github.com/franciscop/polystore.git",
@@ -16,25 +16,36 @@
       "types": "./index.d.ts",
       "import": "./index.js"
     },
-    "./express": "./src/express.js"
+    "./express": {
+      "types": "./src/integrations/express.d.ts",
+      "import": "./src/integrations/express.js"
+    },
+    "./hono-sessions": {
+      "types": "./src/integrations/hono-sessions.d.ts",
+      "import": "./src/integrations/hono-sessions.js"
+    }
   },
   "files": [
     "index.js",
     "index.d.ts",
-    "src/express.js"
+    "src/integrations/express.js",
+    "src/integrations/express.d.ts",
+    "src/integrations/hono-sessions.js",
+    "src/integrations/hono-sessions.d.ts"
   ],
   "scripts": {
     "analyze": "npm run build && esbuild src/index.ts --bundle --packages=external --format=esm --minify --outfile=index.min.js && echo 'Final size:' && gzip-size index.min.js && rm index.min.js",
-    "build": "bunx tsup src/index.ts --format esm --dts --out-dir . --target node24",
+    "build": "bunx tsup src/index.ts --format esm --dts --out-dir . --target node24 && bunx tsup src/integrations/express.ts src/integrations/hono-sessions.ts --format esm --dts --out-dir src/integrations --target node24 --external polystore --external express-session --external hono-sessions",
     "lint": "npx tsc --noEmit",
     "start": "bun test --watch",
+    "service:db": "etcd",
+    "service:redis": "brew services start redis",
+    "service:postgres": "brew services start postgresql",
+    "service:server": "bun ./src/server.ts",
+    "services": "concurrently \"npm run service:db\" \"npm run service:redis\" \"npm run service:postgres\" \"npm run service:server\"",
     "test": "npm run test:bun && npm run test:jest",
-    "test:bun": "bun test ./test/index.test.ts",
-    "test:jest": "jest ./test/index.test.ts --detectOpenHandles --forceExit",
-    "run:db": "etcd",
-    "run:redis": "brew services start redis",
-    "run:postgres": "brew services start postgresql",
-    "run:server": "bun ./src/server.ts"
+    "test:bun": "bun test ./test/index.test.ts ./src/integrations/",
+    "test:jest": "jest ./test/index.test.ts --detectOpenHandles --forceExit"
   },
   "keywords": [
     "kv",
@@ -49,23 +60,32 @@
     "@deno/kv": "^0.8.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "^1.3.3",
+    "@types/express": "^5.0.6",
+    "@types/express-session": "^1.18.2",
     "@types/jest": "^30.0.0",
     "@types/jsdom": "^27.0.0",
     "@types/pg": "^8.11.10",
+    "@types/supertest": "^7.2.0",
     "better-sqlite3": "^12.6.0",
     "check-dts": "^0.8.0",
+    "concurrently": "^9.2.1",
     "cross-fetch": "^4.1.0",
     "dotenv": "^16.3.1",
     "edge-mock": "^0.0.15",
     "esbuild": "^0.27.0",
     "etcd3": "^1.1.2",
+    "express": "^5.2.1",
+    "express-session": "^1.19.0",
     "gzip-size-cli": "^5.1.0",
+    "hono": "^4.12.10",
+    "hono-sessions": "^0.8.1",
     "jest": "^30.2.0",
     "jsdom": "^27.2.0",
     "level": "^8.0.1",
     "localforage": "^1.10.0",
     "pg": "^8.13.1",
     "redis": "^4.6.10",
+    "supertest": "^7.2.2",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.1",

package/readme.md

@@ -63,7 +63,7 @@ MyApi({ cache: env.KV_NAMESPACE }); // OR
 
 First, install `polystore` and whatever [supported client](#clients) that you prefer. Let's see Redis as an example here:
 
-```
+```sh
 npm i polystore redis
 ```
 
@@ -93,7 +93,7 @@ await store.del(key);
 
 ## API
 
-The base `kv()` initialization is shared across clients ([see full clients list](#clients)); single argument that receives the client or a string representing the client:
+The base `kv()` initialization is shared across clients ([see full clients list](#clients)); an argument that receives the client or a string representing the client and then the options:
 
 ```js
 import kv from "polystore";
@@ -107,7 +107,7 @@ const store = kv(MyClientInstance, { expires: null, prefix: "" });
 > [!IMPORTANT]
 > The library delivers excellent performance for item-level operations (GET, SET, ADD, HAS, DEL). For other methods or detailed guidance, check the performance considerations and consult your specific client’s documentation.
 
-You can enforce **types** for store values either at store creation or at the method level:
+You can enforce **types** for the values either at store creation or at the method level:
 
 ```ts
 const store = kv<number>(new Map());
@@ -1225,6 +1225,155 @@ This keeps a single table while preserving namespace-style grouping through pref
 
 Please see the [creating a store](#creating-a-store) section for all the details!
 
+## Integrations
+
+Polystore has some easy integrations for you to use it as a simple connector.
+
+### Express
+
+Use any Polystore-compatible store as an [express-session](https://github.com/expressjs/session) store:
+
+```js
+import session from "express-session";
+import expressStore from "polystore/express";
+
+app.use(session({
+  secret: "my-secret",
+  store: expressStore(),
+}));
+```
+
+By default it uses an in-memory `Map`, which is fine for development. For production, pass any Polystore client:
+
+```js
+import { createClient } from "redis";
+// `npm install polystore`
+import expressStore from "polystore/express";
+
+const store = expressStore(createClient().connect());
+
+app.use(session({ secret: "my-secret", store }));
+```
+
+Any client works — Redis, Postgres, SQLite, file-based, etc. Session TTL is read automatically from `cookie.originalMaxAge` so you don't need to configure it separately.
+
+Use `.prefix()` to namespace sessions, for example in a multi-tenant app:
+
+```js
+const store = expressStore(createClient().connect());
+
+app.use((req, res, next) => {
+  req.sessionStore = store.prefix(`tenant:${req.params.tenant}:`);
+  next();
+});
+```
+
+### Hono Sessions
+
+Use any Polystore-compatible store as a [hono-sessions](https://github.com/jcs224/hono_sessions) store:
+
+```js
+import { Hono } from "hono";
+import { sessionMiddleware } from "hono-sessions";
+import honoStore from "polystore/hono-sessions";
+
+const app = new Hono();
+
+app.use("*", sessionMiddleware({
+  store: honoStore(),
+  encryptionKey: process.env.SESSION_KEY,
+  expireAfterSeconds: 3600,
+}));
+```
+
+By default it uses an in-memory `Map`. For production, pass any Polystore client:
+
+```js
+import { createClient } from "redis";
+import honoStore from "polystore/hono-sessions";
+
+app.use("*", sessionMiddleware({
+  store: honoStore(createClient().connect()),
+  encryptionKey: process.env.SESSION_KEY,
+  expireAfterSeconds: 3600,
+}));
+```
+
+Session TTL is derived automatically from `expireAfterSeconds` — hono-sessions writes it to `_expire` on the session data, and Polystore uses it to set the underlying store TTL for automatic cleanup.
+
+Use `.prefix()` to namespace sessions per tenant:
+
+```js
+const store = honoStore(createClient().connect());
+
+app.use("*", (c, next) => {
+  const tenant = c.req.param("tenant");
+  return sessionMiddleware({
+    store: store.prefix(`tenant:${tenant}:`),
+    encryptionKey: process.env.SESSION_KEY,
+  })(c, next);
+});
+```
+
+
+### fch
+
+[Fch](https://www.npmjs.com/package/fch) is a lightweight fetch wrapper that uses Polystore natively for caching. Pass any Polystore store as the `cache` option and GET responses are cached automatically:
+
+```js
+import fch from "fch";
+import kv from "polystore";
+
+const api = fch.create({
+  baseUrl: "https://api.example.com",
+  cache: kv(new Map(), { expires: "1h" }),
+});
+
+await api.get("/users"); // fetched from network, stored in cache
+await api.get("/users"); // served from cache
+```
+
+Swap the backend without changing anything else:
+
+```js
+import { createClient } from "redis";
+
+const api = fch.create({
+  cache: kv(createClient().connect(), { expires: "10min" }),
+});
+```
+
+You can override or skip the cache per request:
+
+```js
+const shortCache = kv(new Map(), { expires: "30s" });
+
+api.get("/realtime", { cache: null });         // skip cache
+api.get("/prices", { cache: shortCache });      // use a different cache
+```
+
+
+### @server/next
+
+> [!WARNING]
+> @server/next is still experimental, but it's the main reason I created Polystore and so I wanted to document it as well
+
+Server.js supports Polystore directly:
+
+```ts
+import kv from "polystore";
+import server from "@server/next";
+
+const session = kv(new Map());
+
+export default server({ session }).get("/", (ctx) => {
+  if (!ctx.session.counter) ctx.session.counter = 0;
+  ctx.session.counter++;
+  return `User visited ${ctx.session.counter} times`;
+});
+```
+
+
 ## Guides
 
 ### Performance
@@ -1610,23 +1759,3 @@ if (process.env.REDIS_URL) {
 
 export default store;
 ```
-
-### @server/next
-
-> [!info]
-> @server/next is still experimental, but it's the main reason I created Polystore and so I wanted to document it as well
-
-Server.js supports Polystore directly:
-
-```ts
-import kv from "polystore";
-import server from "../../";
-
-const session = kv(new Map());
-
-export default server({ session }).get("/", (ctx) => {
-  if (!ctx.session.counter) ctx.session.counter = 0;
-  ctx.session.counter++;
-  return `User visited ${ctx.session.counter} times`;
-});
-```

package/src/integrations/express.d.ts

@@ -0,0 +1,307 @@
+import { EventEmitter } from 'events';
+
+type Prefix = string;
+type Expires = number | null | string;
+type Options = {
+    prefix?: Prefix;
+    expires?: Expires;
+};
+type StoreData<T extends Serializable = Serializable> = {
+    value: T;
+    expires: number | null;
+};
+type Serializable = string | number | boolean | null | (Serializable | null)[] | {
+    [key: string]: Serializable | null;
+};
+interface ClientExpires {
+    TYPE: string;
+    HAS_EXPIRATION: true;
+    promise?: Promise<any>;
+    test?: (client: any) => boolean;
+    get<T extends Serializable>(key: string): Promise<T | null> | T | null;
+    set<T extends Serializable>(key: string, value: T, expires?: Expires): Promise<any> | any;
+    iterate<T extends Serializable>(prefix: string): AsyncGenerator<[string, T], void, unknown> | Generator<[string, T], void, unknown>;
+    add?<T extends Serializable>(prefix: string, value: T, expires?: Expires): Promise<string>;
+    has?(key: string): Promise<boolean> | boolean;
+    del?(key: string): Promise<any> | any;
+    keys?(prefix: string): Promise<string[]> | string[];
+    values?<T extends Serializable>(prefix: string): Promise<T[]> | T[];
+    entries?<T extends Serializable>(prefix: string): Promise<[string, T][]> | [string, T][];
+    all?<T extends Serializable>(prefix: string): Promise<Record<string, T>> | Record<string, T>;
+    clear?(prefix: string): Promise<any> | any;
+    clearAll?(): Promise<any> | any;
+    close?(): Promise<any> | any;
+}
+interface ClientNonExpires {
+    TYPE: string;
+    HAS_EXPIRATION: false;
+    promise?: Promise<any>;
+    test?: (client: any) => boolean;
+    get<T extends Serializable>(key: string): Promise<StoreData<T> | null> | StoreData<T> | null;
+    set<T extends Serializable>(key: string, value: StoreData<T> | null, ttl?: Expires): Promise<any> | any;
+    iterate<T extends Serializable>(prefix: string): AsyncGenerator<[string, StoreData<T>], void, unknown> | Generator<[string, StoreData<T>], void, unknown>;
+    add?<T extends Serializable>(prefix: string, value: StoreData<T>, ttl?: Expires): Promise<string>;
+    has?(key: string): Promise<boolean> | boolean;
+    del?(key: string): Promise<any> | any;
+    keys?(prefix: string): Promise<string[]> | string[];
+    values?<T extends Serializable>(prefix: string): Promise<StoreData<T>[]> | StoreData<T>[];
+    entries?<T extends Serializable>(prefix: string): Promise<[string, StoreData<T>][]> | [string, StoreData<T>][];
+    all?<T extends Serializable>(prefix: string): Promise<Record<string, StoreData<T>>> | Record<string, StoreData<T>>;
+    prune?(): Promise<any> | any;
+    clear?(prefix: string): Promise<any> | any;
+    clearAll?(): Promise<any> | any;
+    close?(): Promise<any> | any;
+}
+type Client = ClientExpires | ClientNonExpires;
+
+declare class Store<TD extends Serializable = Serializable> {
+    #private;
+    PREFIX: Prefix;
+    EXPIRES: Expires;
+    promise: Promise<Client> | null;
+    client: Client;
+    type: string;
+    constructor(clientPromise?: any, options?: Options);
+    /**
+     * Save the data on an autogenerated key, can add expiration as well:
+     *
+     * ```js
+     * const key1 = await store.add("value1");
+     * const key2 = await store.add({ hello: "world" });
+     * const key3 = await store.add("value3", { expires: "1h" });
+     * ```
+     *
+     * **[→ Full .add() Docs](https://polystore.dev/documentation#add)**
+     */
+    add(value: TD, options?: Options): Promise<string>;
+    add<T extends TD>(value: T, options?: Options): Promise<string>;
+    /**
+     * Save the data on the given key, can add expiration as well:
+     *
+     * ```js
+     * const key = await store.set("key1", "value1");
+     * await store.set("key2", { hello: "world" });
+     * await store.set("key3", "value3", { expires: "1h" });
+     * ```
+     *
+     * **[→ Full .set() Docs](https://polystore.dev/documentation#set)**
+     */
+    set(key: string, value: TD, options?: Options): Promise<string>;
+    set<T extends TD>(key: string, value: T, options?: Options): Promise<string>;
+    /**
+     * Read a single value from the KV store:
+     *
+     * ```js
+     * const value1 = await store.get("key1");
+     * // null (doesn't exist or has expired)
+     * const value2 = await store.get("key2");
+     * // "value2"
+     * const value3 = await store.get("key3");
+     * // { hello: "world" }
+     * ```
+     *
+     * **[→ Full .get() Docs](https://polystore.dev/documentation#get)**
+     */
+    get(key: string): Promise<TD | null>;
+    get<T extends TD>(key: string): Promise<T | null>;
+    /**
+     * Check whether a key exists or not:
+     *
+     * ```js
+     * if (await store.has("key1")) { ... }
+     * ```
+     *
+     * If you are going to use the value, it's better to just read it:
+     *
+     * ```js
+     * const val = await store.get("key1");
+     * if (val) { ... }
+     * ```
+     *
+     * **[→ Full .has() Docs](https://polystore.dev/documentation#has)**
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Remove a single key and its value from the store:
+     *
+     * ```js
+     * const key = await store.del("key1");
+     * ```
+     *
+     * **[→ Full .del() Docs](https://polystore.dev/documentation#del)**
+     */
+    del(key: string): Promise<string>;
+    /**
+     * @alias of .del(key: string)
+     * Remove a single key and its value from the store:
+     *
+     * ```js
+     * const key = await store.delete("key1");
+     * ```
+     *
+     * **[→ Full .del() Docs](https://polystore.dev/documentation#del)**
+     */
+    delete(key: string): Promise<string>;
+    /**
+     * An iterator that goes through all of the key:value pairs in the client
+     *
+     * ```js
+     * for await (const [key, value] of store) {
+     *   console.log(key, value);
+     * }
+     * ```
+     *
+     * **[→ Full Iterator Docs](https://polystore.dev/documentation#iterator)**
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<[string, TD], void, unknown>;
+    [Symbol.asyncIterator]<T extends TD>(): AsyncGenerator<[
+        string,
+        T
+    ], void, unknown>;
+    /**
+     * Return an array of the entries, in the [key, value] format:
+     *
+     * ```js
+     * const entries = await store.entries();
+     * // [["key1", "value1"], ["key2", { hello: "world" }], ...]
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").entries();
+     * ```
+     *
+     * **[→ Full .entries() Docs](https://polystore.dev/documentation#entries)**
+     */
+    entries(): Promise<[string, TD][]>;
+    entries<T extends TD>(): Promise<[string, T][]>;
+    /**
+     * Return an array of the keys in the store:
+     *
+     * ```js
+     * const keys = await store.keys();
+     * // ["key1", "key2", ...]
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").keys();
+     * ```
+     *
+     * **[→ Full .keys() Docs](https://polystore.dev/documentation#keys)**
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Return an array of the values in the store:
+     *
+     * ```js
+     * const values = await store.values();
+     * // ["value1", { hello: "world" }, ...]
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").values();
+     * ```
+     *
+     * **[→ Full .values() Docs](https://polystore.dev/documentation#values)**
+     */
+    values(): Promise<TD[]>;
+    values<T extends TD>(): Promise<T[]>;
+    /**
+     * Return an object with the keys:values in the store:
+     *
+     * ```js
+     * const obj = await store.all();
+     * // { key1: "value1", key2: { hello: "world" }, ... }
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").all();
+     * ```
+     *
+     * **[→ Full .all() Docs](https://polystore.dev/documentation#all)**
+     */
+    all(): Promise<Record<string, TD>>;
+    all<T extends TD>(): Promise<Record<string, T>>;
+    /**
+     * Create a substore where all the keys are stored with
+     * the given prefix:
+     *
+     * ```js
+     * const session = store.prefix("session:");
+     * await session.set("key1", "value1");
+     * console.log(await session.entries());  // session.
+     * // [["key1", "value1"]]
+     * console.log(await store.entries());  // store.
+     * // [["session:key1", "value1"]]
+     * ```
+     *
+     * **[→ Full .prefix() Docs](https://polystore.dev/documentation#prefix)**
+     */
+    prefix(prefix?: Prefix): Store<TD>;
+    /**
+     * Create a substore where all the keys are stored with
+     * the given prefix:
+     *
+     * ```js
+     * const session = store.prefix("session:");
+     * await session.set("key1", "value1");
+     * console.log(await session.entries());  // session.
+     * // [["key1", "value1"]]
+     * console.log(await store.entries());  // store.
+     * // [["session:key1", "value1"]]
+     * ```
+     *
+     * **[→ Full .prefix() Docs](https://polystore.dev/documentation#prefix)**
+     */
+    expires(expires?: Expires): Store<TD>;
+    /**
+     * Delete all of the records of the store:
+     *
+     * ```js
+     * await store.clear();
+     * ```
+     *
+     * It's useful for cache invalidation, clearing the data, and testing.
+     *
+     * **[→ Full .clear() Docs](https://polystore.dev/documentation#clear)**
+     */
+    clear(): Promise<void>;
+    /**
+     * Remove all expired records from the store.
+     *
+     * ```js
+     * await store.prune();
+     * ```
+     *
+     * Only affects stores where expiration is managed by this wrapper.
+     */
+    prune(): Promise<void>;
+    /**
+     * Stop the connection to the store, if any:
+     *
+     * ```js
+     * await session.set("key1", "value1");
+     * await store.close();
+     * await session.set("key2", "value2");  // error
+     * ```
+     *
+     * **[→ Full .close() Docs](https://polystore.dev/documentation#close)**
+     */
+    close(): Promise<void>;
+}
+
+interface SessionData {
+    cookie?: {
+        originalMaxAge?: number | null;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+type Callback = (err?: any) => void;
+declare class PolystoreSessionStore extends EventEmitter {
+    private store;
+    constructor(store: Store);
+    prefix(prefix?: string): PolystoreSessionStore;
+    get(sid: string, cb: (err: any, session?: SessionData | null) => void): void;
+    set(sid: string, data: SessionData, cb?: Callback): void;
+    destroy(sid: string, cb?: Callback): void;
+    touch(sid: string, data: SessionData, cb?: Callback): void;
+}
+declare function expressStore(client?: Map<any, any>): PolystoreSessionStore;
+
+export { PolystoreSessionStore, expressStore as default };

package/src/integrations/express.js

@@ -0,0 +1,42 @@
+// src/integrations/express.ts
+import session from "express-session";
+import kv from "polystore";
+var ttlFromSession = (data) => {
+  const maxAge = data?.cookie?.originalMaxAge;
+  return typeof maxAge === "number" ? { expires: Math.ceil(maxAge / 1e3) } : void 0;
+};
+var PolystoreSessionStore = class _PolystoreSessionStore extends session.Store {
+  store;
+  constructor(store) {
+    super();
+    this.store = store;
+  }
+  prefix(prefix = "") {
+    return new _PolystoreSessionStore(this.store.prefix(prefix));
+  }
+  get(sid, cb) {
+    this.store.get(sid).then((data) => cb(null, data)).catch((err) => err?.code === "ENOENT" ? cb(null, null) : cb(err));
+  }
+  set(sid, data, cb) {
+    this.store.set(sid, data, ttlFromSession(data)).then(() => cb?.()).catch((err) => cb?.(err));
+  }
+  destroy(sid, cb) {
+    this.store.del(sid).then(() => cb?.()).catch((err) => cb?.(err));
+  }
+  touch(sid, data, cb) {
+    this.store.set(sid, data, ttlFromSession(data)).then(() => cb?.()).catch((err) => cb?.(err));
+  }
+  all(cb) {
+    this.store.values().then((vals) => cb(null, vals)).catch(cb);
+  }
+  clear(cb) {
+    this.store.clear().then(() => cb?.()).catch((err) => cb?.(err));
+  }
+};
+function expressStore(client = /* @__PURE__ */ new Map()) {
+  return new PolystoreSessionStore(kv(client));
+}
+export {
+  PolystoreSessionStore,
+  expressStore as default
+};

package/src/integrations/hono-sessions.d.ts

@@ -0,0 +1,299 @@
+import { Store as Store$1, SessionData } from 'hono-sessions';
+
+type Prefix = string;
+type Expires = number | null | string;
+type Options = {
+    prefix?: Prefix;
+    expires?: Expires;
+};
+type StoreData<T extends Serializable = Serializable> = {
+    value: T;
+    expires: number | null;
+};
+type Serializable = string | number | boolean | null | (Serializable | null)[] | {
+    [key: string]: Serializable | null;
+};
+interface ClientExpires {
+    TYPE: string;
+    HAS_EXPIRATION: true;
+    promise?: Promise<any>;
+    test?: (client: any) => boolean;
+    get<T extends Serializable>(key: string): Promise<T | null> | T | null;
+    set<T extends Serializable>(key: string, value: T, expires?: Expires): Promise<any> | any;
+    iterate<T extends Serializable>(prefix: string): AsyncGenerator<[string, T], void, unknown> | Generator<[string, T], void, unknown>;
+    add?<T extends Serializable>(prefix: string, value: T, expires?: Expires): Promise<string>;
+    has?(key: string): Promise<boolean> | boolean;
+    del?(key: string): Promise<any> | any;
+    keys?(prefix: string): Promise<string[]> | string[];
+    values?<T extends Serializable>(prefix: string): Promise<T[]> | T[];
+    entries?<T extends Serializable>(prefix: string): Promise<[string, T][]> | [string, T][];
+    all?<T extends Serializable>(prefix: string): Promise<Record<string, T>> | Record<string, T>;
+    clear?(prefix: string): Promise<any> | any;
+    clearAll?(): Promise<any> | any;
+    close?(): Promise<any> | any;
+}
+interface ClientNonExpires {
+    TYPE: string;
+    HAS_EXPIRATION: false;
+    promise?: Promise<any>;
+    test?: (client: any) => boolean;
+    get<T extends Serializable>(key: string): Promise<StoreData<T> | null> | StoreData<T> | null;
+    set<T extends Serializable>(key: string, value: StoreData<T> | null, ttl?: Expires): Promise<any> | any;
+    iterate<T extends Serializable>(prefix: string): AsyncGenerator<[string, StoreData<T>], void, unknown> | Generator<[string, StoreData<T>], void, unknown>;
+    add?<T extends Serializable>(prefix: string, value: StoreData<T>, ttl?: Expires): Promise<string>;
+    has?(key: string): Promise<boolean> | boolean;
+    del?(key: string): Promise<any> | any;
+    keys?(prefix: string): Promise<string[]> | string[];
+    values?<T extends Serializable>(prefix: string): Promise<StoreData<T>[]> | StoreData<T>[];
+    entries?<T extends Serializable>(prefix: string): Promise<[string, StoreData<T>][]> | [string, StoreData<T>][];
+    all?<T extends Serializable>(prefix: string): Promise<Record<string, StoreData<T>>> | Record<string, StoreData<T>>;
+    prune?(): Promise<any> | any;
+    clear?(prefix: string): Promise<any> | any;
+    clearAll?(): Promise<any> | any;
+    close?(): Promise<any> | any;
+}
+type Client = ClientExpires | ClientNonExpires;
+
+declare class Store<TD extends Serializable = Serializable> {
+    #private;
+    PREFIX: Prefix;
+    EXPIRES: Expires;
+    promise: Promise<Client> | null;
+    client: Client;
+    type: string;
+    constructor(clientPromise?: any, options?: Options);
+    /**
+     * Save the data on an autogenerated key, can add expiration as well:
+     *
+     * ```js
+     * const key1 = await store.add("value1");
+     * const key2 = await store.add({ hello: "world" });
+     * const key3 = await store.add("value3", { expires: "1h" });
+     * ```
+     *
+     * **[→ Full .add() Docs](https://polystore.dev/documentation#add)**
+     */
+    add(value: TD, options?: Options): Promise<string>;
+    add<T extends TD>(value: T, options?: Options): Promise<string>;
+    /**
+     * Save the data on the given key, can add expiration as well:
+     *
+     * ```js
+     * const key = await store.set("key1", "value1");
+     * await store.set("key2", { hello: "world" });
+     * await store.set("key3", "value3", { expires: "1h" });
+     * ```
+     *
+     * **[→ Full .set() Docs](https://polystore.dev/documentation#set)**
+     */
+    set(key: string, value: TD, options?: Options): Promise<string>;
+    set<T extends TD>(key: string, value: T, options?: Options): Promise<string>;
+    /**
+     * Read a single value from the KV store:
+     *
+     * ```js
+     * const value1 = await store.get("key1");
+     * // null (doesn't exist or has expired)
+     * const value2 = await store.get("key2");
+     * // "value2"
+     * const value3 = await store.get("key3");
+     * // { hello: "world" }
+     * ```
+     *
+     * **[→ Full .get() Docs](https://polystore.dev/documentation#get)**
+     */
+    get(key: string): Promise<TD | null>;
+    get<T extends TD>(key: string): Promise<T | null>;
+    /**
+     * Check whether a key exists or not:
+     *
+     * ```js
+     * if (await store.has("key1")) { ... }
+     * ```
+     *
+     * If you are going to use the value, it's better to just read it:
+     *
+     * ```js
+     * const val = await store.get("key1");
+     * if (val) { ... }
+     * ```
+     *
+     * **[→ Full .has() Docs](https://polystore.dev/documentation#has)**
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Remove a single key and its value from the store:
+     *
+     * ```js
+     * const key = await store.del("key1");
+     * ```
+     *
+     * **[→ Full .del() Docs](https://polystore.dev/documentation#del)**
+     */
+    del(key: string): Promise<string>;
+    /**
+     * @alias of .del(key: string)
+     * Remove a single key and its value from the store:
+     *
+     * ```js
+     * const key = await store.delete("key1");
+     * ```
+     *
+     * **[→ Full .del() Docs](https://polystore.dev/documentation#del)**
+     */
+    delete(key: string): Promise<string>;
+    /**
+     * An iterator that goes through all of the key:value pairs in the client
+     *
+     * ```js
+     * for await (const [key, value] of store) {
+     *   console.log(key, value);
+     * }
+     * ```
+     *
+     * **[→ Full Iterator Docs](https://polystore.dev/documentation#iterator)**
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<[string, TD], void, unknown>;
+    [Symbol.asyncIterator]<T extends TD>(): AsyncGenerator<[
+        string,
+        T
+    ], void, unknown>;
+    /**
+     * Return an array of the entries, in the [key, value] format:
+     *
+     * ```js
+     * const entries = await store.entries();
+     * // [["key1", "value1"], ["key2", { hello: "world" }], ...]
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").entries();
+     * ```
+     *
+     * **[→ Full .entries() Docs](https://polystore.dev/documentation#entries)**
+     */
+    entries(): Promise<[string, TD][]>;
+    entries<T extends TD>(): Promise<[string, T][]>;
+    /**
+     * Return an array of the keys in the store:
+     *
+     * ```js
+     * const keys = await store.keys();
+     * // ["key1", "key2", ...]
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").keys();
+     * ```
+     *
+     * **[→ Full .keys() Docs](https://polystore.dev/documentation#keys)**
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Return an array of the values in the store:
+     *
+     * ```js
+     * const values = await store.values();
+     * // ["value1", { hello: "world" }, ...]
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").values();
+     * ```
+     *
+     * **[→ Full .values() Docs](https://polystore.dev/documentation#values)**
+     */
+    values(): Promise<TD[]>;
+    values<T extends TD>(): Promise<T[]>;
+    /**
+     * Return an object with the keys:values in the store:
+     *
+     * ```js
+     * const obj = await store.all();
+     * // { key1: "value1", key2: { hello: "world" }, ... }
+     *
+     * // To limit it to a given prefix, use `.prefix()`:
+     * const sessions = await store.prefix("session:").all();
+     * ```
+     *
+     * **[→ Full .all() Docs](https://polystore.dev/documentation#all)**
+     */
+    all(): Promise<Record<string, TD>>;
+    all<T extends TD>(): Promise<Record<string, T>>;
+    /**
+     * Create a substore where all the keys are stored with
+     * the given prefix:
+     *
+     * ```js
+     * const session = store.prefix("session:");
+     * await session.set("key1", "value1");
+     * console.log(await session.entries());  // session.
+     * // [["key1", "value1"]]
+     * console.log(await store.entries());  // store.
+     * // [["session:key1", "value1"]]
+     * ```
+     *
+     * **[→ Full .prefix() Docs](https://polystore.dev/documentation#prefix)**
+     */
+    prefix(prefix?: Prefix): Store<TD>;
+    /**
+     * Create a substore where all the keys are stored with
+     * the given prefix:
+     *
+     * ```js
+     * const session = store.prefix("session:");
+     * await session.set("key1", "value1");
+     * console.log(await session.entries());  // session.
+     * // [["key1", "value1"]]
+     * console.log(await store.entries());  // store.
+     * // [["session:key1", "value1"]]
+     * ```
+     *
+     * **[→ Full .prefix() Docs](https://polystore.dev/documentation#prefix)**
+     */
+    expires(expires?: Expires): Store<TD>;
+    /**
+     * Delete all of the records of the store:
+     *
+     * ```js
+     * await store.clear();
+     * ```
+     *
+     * It's useful for cache invalidation, clearing the data, and testing.
+     *
+     * **[→ Full .clear() Docs](https://polystore.dev/documentation#clear)**
+     */
+    clear(): Promise<void>;
+    /**
+     * Remove all expired records from the store.
+     *
+     * ```js
+     * await store.prune();
+     * ```
+     *
+     * Only affects stores where expiration is managed by this wrapper.
+     */
+    prune(): Promise<void>;
+    /**
+     * Stop the connection to the store, if any:
+     *
+     * ```js
+     * await session.set("key1", "value1");
+     * await store.close();
+     * await session.set("key2", "value2");  // error
+     * ```
+     *
+     * **[→ Full .close() Docs](https://polystore.dev/documentation#close)**
+     */
+    close(): Promise<void>;
+}
+
+declare class PolystoreHonoStore implements Store$1 {
+    private store;
+    constructor(store: Store);
+    prefix(prefix?: string): PolystoreHonoStore;
+    getSessionById(sessionId?: string): Promise<SessionData | null | undefined>;
+    createSession(sessionId: string, initialData: SessionData): Promise<void>;
+    persistSessionData(sessionId: string, sessionData: SessionData): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+}
+declare function honoStore(client?: Map<any, any>): PolystoreHonoStore;
+
+export { PolystoreHonoStore, honoStore as default };

package/src/integrations/hono-sessions.js

@@ -0,0 +1,36 @@
+// src/integrations/hono-sessions.ts
+import kv from "polystore";
+var ttlFromSession = (data) => {
+  if (!data._expire) return void 0;
+  const secs = Math.ceil((new Date(data._expire).getTime() - Date.now()) / 1e3);
+  return secs > 0 ? { expires: secs } : void 0;
+};
+var PolystoreHonoStore = class _PolystoreHonoStore {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  prefix(prefix = "") {
+    return new _PolystoreHonoStore(this.store.prefix(prefix));
+  }
+  async getSessionById(sessionId) {
+    if (!sessionId) return null;
+    return this.store.get(sessionId);
+  }
+  async createSession(sessionId, initialData) {
+    await this.store.set(sessionId, initialData, ttlFromSession(initialData));
+  }
+  async persistSessionData(sessionId, sessionData) {
+    await this.store.set(sessionId, sessionData, ttlFromSession(sessionData));
+  }
+  async deleteSession(sessionId) {
+    await this.store.del(sessionId);
+  }
+};
+function honoStore(client = /* @__PURE__ */ new Map()) {
+  return new PolystoreHonoStore(kv(client));
+}
+export {
+  PolystoreHonoStore,
+  honoStore as default
+};

package/src/express.js

@@ -1,47 +0,0 @@
-import session from "express-session";
-import kv from "../index.js";
-
-const ttlFromSession = (data) => {
-  const maxAge = data?.cookie?.originalMaxAge;
-  return typeof maxAge === "number" ? Math.ceil(maxAge / 1000) : null;
-};
-
-export class PolystoreSessionStore extends session.Store {
-  constructor(store) {
-    super();
-    this.store = store;
-  }
-
-  prefix(prefix = "") {
-    return new PolystoreSessionStore(this.store.prefix(prefix));
-  }
-
-  get(sid, cb) {
-    this.store.get(sid).then((data) => cb(null, data)).catch(cb);
-  }
-
-  set(sid, data, cb) {
-    this.store
-      .set(sid, data, ttlFromSession(data))
-      .then(() => cb && cb())
-      .catch((error) => cb && cb(error));
-  }
-
-  destroy(sid, cb) {
-    this.store
-      .del(sid)
-      .then(() => cb && cb())
-      .catch((error) => cb && cb(error));
-  }
-
-  touch(sid, data, cb) {
-    this.store
-      .set(sid, data, ttlFromSession(data))
-      .then(() => cb && cb())
-      .catch((error) => cb && cb(error));
-  }
-}
-
-export default function expressStore(client = new Map()) {
-  return new PolystoreSessionStore(kv(client));
-}