trustline 0.0.1 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Charles Fonseca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,301 @@
+# Trustline
+
+[![npm version](https://img.shields.io/npm/v/trustline)](https://www.npmjs.com/package/trustline)
+[![docs](https://img.shields.io/badge/docs-github%20pages-blue)](https://barddoo.github.io/trustline/)
+
+Service identity and authorization for modern JavaScript runtimes.
+
+Trustline is a machine-to-machine authentication library for internal services. It is designed around dedicated core and integration entry points:
+
+- `trustline`: provider, guard, memory storage, and shared core exports
+- `trustline/client`: token fetching and caching for outgoing requests
+- `trustline/frameworks/*`: framework adapters for receiving services
+- `trustline/adapters/*`: SQL storage adapters
+
+The package now ships the first full stack: provider, client, guard, framework adapters, memory storage, and SQL storage adapters for SQLite, Postgres, and MySQL.
+
+## Installation
+
+Trustline is intended to be consumed as the `trustline` package:
+
+```bash
+bun add trustline
+```
+
+Or with npm:
+
+```bash
+npm install trustline
+```
+
+Install only the integrations you use. For example, Express users install `express`; SQLite users install `better-sqlite3` and `kysely`.
+
+Example installs:
+
+```bash
+npm install trustline express
+npm install trustline better-sqlite3 kysely
+```
+
+If you are working from this repository before package publication, build the package locally and install or link it from the repo source.
+
+## Quick start
+
+Provider:
+
+```ts
+import { createProvider, memoryStorage } from "trustline";
+
+const provider = createProvider({
+  issuer: "https://auth.internal",
+  storage: memoryStorage(),
+  env: "production",
+});
+
+const service = await provider.clients.create({
+  name: "order-processor",
+  scopes: ["read:orders", "write:inventory"],
+});
+```
+
+Client:
+
+```ts
+import { createClient } from "trustline/client";
+
+const client = createClient({
+  tokenUrl: "https://auth.internal/token",
+  clientId: service.clientId,
+  clientSecret: service.clientSecret,
+  audience: "inventory-service",
+});
+
+const token = await client.getToken();
+```
+
+Guard:
+
+```ts
+import { createGuard } from "trustline";
+
+const guard = createGuard({
+  issuer: "https://auth.internal",
+  audience: "inventory-service",
+  scopes: ["read:orders"],
+  env: "production",
+});
+
+const identity = await guard.verify(token);
+```
+
+Trustline derives the JWKS endpoint automatically for verification:
+
+```txt
+issuer: https://auth.internal
+jwks:   https://auth.internal/.well-known/jwks.json
+```
+
+## Bun
+
+Trustline does not need a Bun-specific adapter. Bun already uses the standard Web `Request` and `Response` APIs, so use the provider's `handle()` method directly and call `guard.verify()` inside your `fetch` handler.
+
+```ts
+import { createGuard, createProvider, memoryStorage } from "trustline";
+
+const provider = createProvider({
+  issuer: "https://auth.internal",
+  storage: memoryStorage(),
+});
+
+Bun.serve({
+  port: 3000,
+  fetch: provider.handle,
+});
+
+const guard = createGuard({
+  issuer: "https://auth.internal",
+  audience: "inventory-service",
+});
+
+Bun.serve({
+  port: 4000,
+  fetch: async (request) => {
+    const header = request.headers.get("authorization");
+    const token = header?.replace(/^Bearer\s+/, "") ?? "";
+    const identity = await guard.verify(token);
+
+    return Response.json({
+      caller: identity.name ?? identity.clientId,
+    });
+  },
+});
+```
+
+## Express
+
+```ts
+import express from "express";
+import { createGuard, createProvider, memoryStorage } from "trustline";
+import {
+  createExpressGuard,
+  createExpressProvider,
+  type TrustlineRequest,
+} from "trustline/frameworks/express";
+
+const app = express();
+
+const provider = createProvider({
+  issuer: "https://auth.internal",
+  storage: memoryStorage(),
+});
+
+const guard = createGuard({
+  issuer: "https://auth.internal",
+  audience: "inventory-service",
+});
+
+app.use(createExpressProvider(provider));
+app.use(createExpressGuard(guard));
+
+app.get("/internal", (request: TrustlineRequest, response) => {
+  response.json({
+    caller: request.trustline?.name ?? request.trustline?.clientId,
+  });
+});
+```
+
+## API
+
+Current public API includes:
+
+```ts
+interface ProviderOptions {
+  issuer: string;
+  storage: StorageAdapter;
+  signing?: {
+    algorithm?: "ES256" | "RS256";
+    privateKey?: string;
+    keyId?: string;
+  };
+  token?: {
+    ttl?: number;
+  };
+  env?: string;
+}
+
+interface GuardOptions {
+  issuer: string;
+  jwksUrl?: string;
+  audience?: string | string[];
+  scopes?: string[];
+  env?: string;
+  clockTolerance?: number;
+}
+
+interface ServiceIdentity {
+  clientId: string;
+  name: string | null;
+  scopes: string[];
+  env: string | null;
+  raw: Record<string, unknown>;
+}
+```
+
+Adapter surface:
+
+- `provider.handle(request)`
+- `guard.verify(token)`
+- `createExpressProvider(provider)`
+- `createExpressGuard(guard)`
+- `createFastifyProvider(provider)`
+- `createFastifyGuard(guard)`
+- `createHonoProvider(provider)`
+- `createHonoGuard(guard)`
+
+Supported signing algorithms:
+
+- `RS256`
+- `ES256`
+
+Bundled storage adapters via dedicated subpaths:
+
+- `memoryStorage()`
+- `sqliteStorage(path | database)`
+- `postgresStorage(pool)`
+- `mysqlStorage(pool)`
+
+SQL adapters follow the Better Auth-style pattern of receiving ready-made database handles:
+
+```ts
+import Database from "better-sqlite3";
+import { createPool as createMysqlPool } from "mysql2";
+import { Pool as PostgresPool } from "pg";
+import { mysqlStorage } from "trustline/adapters/mysql";
+import { postgresStorage } from "trustline/adapters/postgres";
+import { sqliteStorage } from "trustline/adapters/sqlite";
+
+const sqlite = sqliteStorage(new Database("./trustline.sqlite"));
+const postgres = postgresStorage(
+  new PostgresPool({ connectionString: process.env.DATABASE_URL }),
+);
+const mysql = mysqlStorage(createMysqlPool(process.env.DATABASE_URL!));
+```
+
+## Documentation
+
+The VitePress docs site lives in `docs/`.
+
+Runnable examples live under `examples/`. For a full Hono-based flow with a dedicated auth provider plus caller and receiver services, see `examples/hono-services/`.
+
+Key pages:
+
+- `docs/index.md`
+- `docs/get-started.md`
+- `docs/concepts.md`
+- `docs/middleware.md`
+- `docs/reference.md`
+- `docs/roadmap.md`
+
+To run the docs locally:
+
+```bash
+cd docs
+bun run docs:dev
+```
+
+To build the docs:
+
+```bash
+cd docs
+bun run docs:build
+```
+
+## Development
+
+Build the package:
+
+```bash
+bun run build
+```
+
+Run type checks:
+
+```bash
+bun run typecheck
+```
+
+Run tests:
+
+```bash
+bun run test
+```
+
+Run formatting and lint checks:
+
+```bash
+bun run check
+```
+
+## License
+
+MIT

package/dist/adapters/mysql/index.cjs

@@ -0,0 +1,199 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/mysql/index.ts
+var mysql_exports = {};
+__export(mysql_exports, {
+  mysqlStorage: () => mysqlStorage
+});
+module.exports = __toCommonJS(mysql_exports);
+
+// src/storage/mysql.ts
+var import_kysely2 = require("kysely");
+
+// src/storage/sql.ts
+var import_kysely = require("kysely");
+function createSqlStorage(database, dialect, options) {
+  const tables = resolveTables(options);
+  let schemaPromise = null;
+  async function ensureSchema() {
+    if (!schemaPromise) {
+      schemaPromise = createSchema(database, dialect, tables);
+    }
+    await schemaPromise;
+  }
+  return {
+    async findClient(clientId) {
+      await ensureSchema();
+      const row = await database.selectFrom(tables.clients).selectAll().where("client_id", "=", clientId).executeTakeFirst();
+      return row ? mapClientRow(row) : null;
+    },
+    async createClient(client) {
+      await ensureSchema();
+      await database.insertInto(tables.clients).values({
+        id: client.id,
+        client_id: client.clientId,
+        client_secret: client.clientSecret,
+        name: client.name,
+        scopes: JSON.stringify(client.scopes),
+        created_at: client.createdAt.toISOString(),
+        last_seen_at: client.lastSeenAt?.toISOString() ?? null
+      }).execute();
+    },
+    async deleteClient(clientId) {
+      await ensureSchema();
+      await database.deleteFrom(tables.clients).where("client_id", "=", clientId).execute();
+    },
+    async listClients() {
+      await ensureSchema();
+      const rows = await database.selectFrom(tables.clients).selectAll().orderBy("created_at", "asc").execute();
+      return rows.map(mapClientRow);
+    },
+    async touchClient(clientId, lastSeenAt) {
+      await ensureSchema();
+      await database.updateTable(tables.clients).set({
+        last_seen_at: lastSeenAt.toISOString()
+      }).where("client_id", "=", clientId).execute();
+    },
+    async getSigningKeys() {
+      await ensureSchema();
+      const rows = await database.selectFrom(tables.signingKeys).selectAll().orderBy("created_at", "asc").execute();
+      return rows.map(mapSigningKeyRow);
+    },
+    async addSigningKey(key) {
+      await ensureSchema();
+      await database.insertInto(tables.signingKeys).values({
+        key_id: key.keyId,
+        algorithm: key.algorithm,
+        private_key: key.privateKey,
+        public_key: key.publicKey,
+        created_at: key.createdAt.toISOString(),
+        retired_at: key.retiredAt?.toISOString() ?? null
+      }).execute();
+    },
+    async retireKey(keyId) {
+      await ensureSchema();
+      await database.updateTable(tables.signingKeys).set({
+        retired_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).where("key_id", "=", keyId).execute();
+    }
+  };
+}
+function resolveTables(options) {
+  const prefix = options?.tablePrefix ?? "trustline_";
+  return {
+    clients: options?.tables?.clients ?? `${prefix}clients`,
+    signingKeys: options?.tables?.signingKeys ?? `${prefix}signing_keys`
+  };
+}
+async function createSchema(database, dialect, tables) {
+  await createClientsTable(database, dialect, tables.clients);
+  await createSigningKeysTable(database, dialect, tables.signingKeys);
+}
+async function createClientsTable(database, dialect, tableName) {
+  if (dialect === "mysql") {
+    await import_kysely.sql`
+      create table if not exists ${import_kysely.sql.table(tableName)} (
+        id varchar(255) not null,
+        client_id varchar(255) not null primary key,
+        client_secret text not null,
+        name varchar(255) not null,
+        scopes text not null,
+        created_at varchar(64) not null,
+        last_seen_at varchar(64) null
+      )
+    `.execute(database);
+    return;
+  }
+  await import_kysely.sql`
+    create table if not exists ${import_kysely.sql.table(tableName)} (
+      id varchar(255) not null,
+      client_id varchar(255) not null primary key,
+      client_secret text not null,
+      name varchar(255) not null,
+      scopes text not null,
+      created_at varchar(64) not null,
+      last_seen_at varchar(64)
+    )
+  `.execute(database);
+}
+async function createSigningKeysTable(database, dialect, tableName) {
+  if (dialect === "mysql") {
+    await import_kysely.sql`
+      create table if not exists ${import_kysely.sql.table(tableName)} (
+        key_id varchar(255) not null primary key,
+        algorithm varchar(32) not null,
+        private_key text not null,
+        public_key text not null,
+        created_at varchar(64) not null,
+        retired_at varchar(64) null
+      )
+    `.execute(database);
+    return;
+  }
+  await import_kysely.sql`
+    create table if not exists ${import_kysely.sql.table(tableName)} (
+      key_id varchar(255) not null primary key,
+      algorithm varchar(32) not null,
+      private_key text not null,
+      public_key text not null,
+      created_at varchar(64) not null,
+      retired_at varchar(64)
+    )
+  `.execute(database);
+}
+function mapClientRow(row) {
+  return {
+    id: row.id,
+    clientId: row.client_id,
+    clientSecret: row.client_secret,
+    name: row.name,
+    scopes: JSON.parse(row.scopes),
+    createdAt: new Date(row.created_at),
+    lastSeenAt: row.last_seen_at ? new Date(row.last_seen_at) : null
+  };
+}
+function mapSigningKeyRow(row) {
+  return {
+    keyId: row.key_id,
+    algorithm: row.algorithm,
+    privateKey: row.private_key,
+    publicKey: row.public_key,
+    createdAt: new Date(row.created_at),
+    retiredAt: row.retired_at ? new Date(row.retired_at) : null
+  };
+}
+
+// src/storage/mysql.ts
+function mysqlStorage(pool, options) {
+  return createSqlStorage(
+    new import_kysely2.Kysely({
+      dialect: new import_kysely2.MysqlDialect({
+        pool
+      })
+    }),
+    "mysql",
+    options
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mysqlStorage
+});
+//# sourceMappingURL=index.cjs.map

package/dist/adapters/mysql/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/mysql/index.ts","../../../src/storage/mysql.ts","../../../src/storage/sql.ts"],"sourcesContent":["export type {\n  SqlStorageOptions,\n  StorageAdapter,\n} from \"../../storage/interface\";\nexport { mysqlStorage } from \"../../storage/mysql\";\n","import { Kysely, MysqlDialect } from \"kysely\";\nimport type { Pool } from \"mysql2\";\n\nimport type { SqlStorageOptions, StorageAdapter } from \"./interface\";\nimport { createSqlStorage } from \"./sql\";\n\nexport function mysqlStorage(\n  pool: Pool,\n  options?: SqlStorageOptions,\n): StorageAdapter {\n  return createSqlStorage(\n    new Kysely({\n      dialect: new MysqlDialect({\n        pool,\n      }),\n    }),\n    \"mysql\",\n    options,\n  );\n}\n","import { type Kysely, sql } from \"kysely\";\n\nimport type {\n  ServiceClient,\n  SigningKey,\n  SqlStorageOptions,\n  StorageAdapter,\n} from \"./interface\";\n\ntype SqlDialect = \"mysql\" | \"postgres\" | \"sqlite\";\n\ninterface SqlTables {\n  clients: string;\n  signingKeys: string;\n}\n\ninterface SqlDatabase {\n  [tableName: string]: SqlRow;\n}\n\ninterface SqlRow {\n  algorithm?: SigningKey[\"algorithm\"];\n  client_id?: string;\n  client_secret?: string;\n  created_at: string;\n  id?: string;\n  key_id?: string;\n  last_seen_at?: string | null;\n  name?: string;\n  private_key?: string;\n  public_key?: string;\n  retired_at?: string | null;\n  scopes?: string;\n}\n\ninterface ClientRow {\n  id: string;\n  client_id: string;\n  client_secret: string;\n  name: string;\n  scopes: string;\n  created_at: string;\n  last_seen_at: string | null;\n}\n\ninterface SigningKeyRow {\n  key_id: string;\n  algorithm: SigningKey[\"algorithm\"];\n  private_key: string;\n  public_key: string;\n  created_at: string;\n  retired_at: string | null;\n}\n\nexport function createSqlStorage(\n  database: Kysely<SqlDatabase>,\n  dialect: SqlDialect,\n  options?: SqlStorageOptions,\n): StorageAdapter {\n  const tables = resolveTables(options);\n  let schemaPromise: Promise<void> | null = null;\n\n  async function ensureSchema(): Promise<void> {\n    if (!schemaPromise) {\n      schemaPromise = createSchema(database, dialect, tables);\n    }\n\n    await schemaPromise;\n  }\n\n  return {\n    async findClient(clientId) {\n      await ensureSchema();\n\n      const row = (await database\n        .selectFrom(tables.clients)\n        .selectAll()\n        .where(\"client_id\", \"=\", clientId)\n        .executeTakeFirst()) as ClientRow | undefined;\n\n      return row ? mapClientRow(row) : null;\n    },\n    async createClient(client) {\n      await ensureSchema();\n\n      await database\n        .insertInto(tables.clients)\n        .values({\n          id: client.id,\n          client_id: client.clientId,\n          client_secret: client.clientSecret,\n          name: client.name,\n          scopes: JSON.stringify(client.scopes),\n          created_at: client.createdAt.toISOString(),\n          last_seen_at: client.lastSeenAt?.toISOString() ?? null,\n        })\n        .execute();\n    },\n    async deleteClient(clientId) {\n      await ensureSchema();\n\n      await database\n        .deleteFrom(tables.clients)\n        .where(\"client_id\", \"=\", clientId)\n        .execute();\n    },\n    async listClients() {\n      await ensureSchema();\n\n      const rows = (await database\n        .selectFrom(tables.clients)\n        .selectAll()\n        .orderBy(\"created_at\", \"asc\")\n        .execute()) as ClientRow[];\n\n      return rows.map(mapClientRow);\n    },\n    async touchClient(clientId, lastSeenAt) {\n      await ensureSchema();\n\n      await database\n        .updateTable(tables.clients)\n        .set({\n          last_seen_at: lastSeenAt.toISOString(),\n        })\n        .where(\"client_id\", \"=\", clientId)\n        .execute();\n    },\n    async getSigningKeys() {\n      await ensureSchema();\n\n      const rows = (await database\n        .selectFrom(tables.signingKeys)\n        .selectAll()\n        .orderBy(\"created_at\", \"asc\")\n        .execute()) as SigningKeyRow[];\n\n      return rows.map(mapSigningKeyRow);\n    },\n    async addSigningKey(key) {\n      await ensureSchema();\n\n      await database\n        .insertInto(tables.signingKeys)\n        .values({\n          key_id: key.keyId,\n          algorithm: key.algorithm,\n          private_key: key.privateKey,\n          public_key: key.publicKey,\n          created_at: key.createdAt.toISOString(),\n          retired_at: key.retiredAt?.toISOString() ?? null,\n        })\n        .execute();\n    },\n    async retireKey(keyId) {\n      await ensureSchema();\n\n      await database\n        .updateTable(tables.signingKeys)\n        .set({\n          retired_at: new Date().toISOString(),\n        })\n        .where(\"key_id\", \"=\", keyId)\n        .execute();\n    },\n  };\n}\n\nfunction resolveTables(options?: SqlStorageOptions): SqlTables {\n  const prefix = options?.tablePrefix ?? \"trustline_\";\n\n  return {\n    clients: options?.tables?.clients ?? `${prefix}clients`,\n    signingKeys: options?.tables?.signingKeys ?? `${prefix}signing_keys`,\n  };\n}\n\nasync function createSchema(\n  database: Kysely<SqlDatabase>,\n  dialect: SqlDialect,\n  tables: SqlTables,\n): Promise<void> {\n  await createClientsTable(database, dialect, tables.clients);\n  await createSigningKeysTable(database, dialect, tables.signingKeys);\n}\n\nasync function createClientsTable(\n  database: Kysely<SqlDatabase>,\n  dialect: SqlDialect,\n  tableName: string,\n): Promise<void> {\n  if (dialect === \"mysql\") {\n    await sql`\n      create table if not exists ${sql.table(tableName)} (\n        id varchar(255) not null,\n        client_id varchar(255) not null primary key,\n        client_secret text not null,\n        name varchar(255) not null,\n        scopes text not null,\n        created_at varchar(64) not null,\n        last_seen_at varchar(64) null\n      )\n    `.execute(database);\n    return;\n  }\n\n  await sql`\n    create table if not exists ${sql.table(tableName)} (\n      id varchar(255) not null,\n      client_id varchar(255) not null primary key,\n      client_secret text not null,\n      name varchar(255) not null,\n      scopes text not null,\n      created_at varchar(64) not null,\n      last_seen_at varchar(64)\n    )\n  `.execute(database);\n}\n\nasync function createSigningKeysTable(\n  database: Kysely<SqlDatabase>,\n  dialect: SqlDialect,\n  tableName: string,\n): Promise<void> {\n  if (dialect === \"mysql\") {\n    await sql`\n      create table if not exists ${sql.table(tableName)} (\n        key_id varchar(255) not null primary key,\n        algorithm varchar(32) not null,\n        private_key text not null,\n        public_key text not null,\n        created_at varchar(64) not null,\n        retired_at varchar(64) null\n      )\n    `.execute(database);\n    return;\n  }\n\n  await sql`\n    create table if not exists ${sql.table(tableName)} (\n      key_id varchar(255) not null primary key,\n      algorithm varchar(32) not null,\n      private_key text not null,\n      public_key text not null,\n      created_at varchar(64) not null,\n      retired_at varchar(64)\n    )\n  `.execute(database);\n}\n\nfunction mapClientRow(row: ClientRow): ServiceClient {\n  return {\n    id: row.id,\n    clientId: row.client_id,\n    clientSecret: row.client_secret,\n    name: row.name,\n    scopes: JSON.parse(row.scopes) as string[],\n    createdAt: new Date(row.created_at),\n    lastSeenAt: row.last_seen_at ? new Date(row.last_seen_at) : null,\n  };\n}\n\nfunction mapSigningKeyRow(row: SigningKeyRow): SigningKey {\n  return {\n    keyId: row.key_id,\n    algorithm: row.algorithm,\n    privateKey: row.private_key,\n    publicKey: row.public_key,\n    createdAt: new Date(row.created_at),\n    retiredAt: row.retired_at ? new Date(row.retired_at) : null,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,IAAAA,iBAAqC;;;ACArC,oBAAiC;AAsD1B,SAAS,iBACd,UACA,SACA,SACgB;AAChB,QAAM,SAAS,cAAc,OAAO;AACpC,MAAI,gBAAsC;AAE1C,iBAAe,eAA8B;AAC3C,QAAI,CAAC,eAAe;AAClB,sBAAgB,aAAa,UAAU,SAAS,MAAM;AAAA,IACxD;AAEA,UAAM;AAAA,EACR;AAEA,SAAO;AAAA,IACL,MAAM,WAAW,UAAU;AACzB,YAAM,aAAa;AAEnB,YAAM,MAAO,MAAM,SAChB,WAAW,OAAO,OAAO,EACzB,UAAU,EACV,MAAM,aAAa,KAAK,QAAQ,EAChC,iBAAiB;AAEpB,aAAO,MAAM,aAAa,GAAG,IAAI;AAAA,IACnC;AAAA,IACA,MAAM,aAAa,QAAQ;AACzB,YAAM,aAAa;AAEnB,YAAM,SACH,WAAW,OAAO,OAAO,EACzB,OAAO;AAAA,QACN,IAAI,OAAO;AAAA,QACX,WAAW,OAAO;AAAA,QAClB,eAAe,OAAO;AAAA,QACtB,MAAM,OAAO;AAAA,QACb,QAAQ,KAAK,UAAU,OAAO,MAAM;AAAA,QACpC,YAAY,OAAO,UAAU,YAAY;AAAA,QACzC,cAAc,OAAO,YAAY,YAAY,KAAK;AAAA,MACpD,CAAC,EACA,QAAQ;AAAA,IACb;AAAA,IACA,MAAM,aAAa,UAAU;AAC3B,YAAM,aAAa;AAEnB,YAAM,SACH,WAAW,OAAO,OAAO,EACzB,MAAM,aAAa,KAAK,QAAQ,EAChC,QAAQ;AAAA,IACb;AAAA,IACA,MAAM,cAAc;AAClB,YAAM,aAAa;AAEnB,YAAM,OAAQ,MAAM,SACjB,WAAW,OAAO,OAAO,EACzB,UAAU,EACV,QAAQ,cAAc,KAAK,EAC3B,QAAQ;AAEX,aAAO,KAAK,IAAI,YAAY;AAAA,IAC9B;AAAA,IACA,MAAM,YAAY,UAAU,YAAY;AACtC,YAAM,aAAa;AAEnB,YAAM,SACH,YAAY,OAAO,OAAO,EAC1B,IAAI;AAAA,QACH,cAAc,WAAW,YAAY;AAAA,MACvC,CAAC,EACA,MAAM,aAAa,KAAK,QAAQ,EAChC,QAAQ;AAAA,IACb;AAAA,IACA,MAAM,iBAAiB;AACrB,YAAM,aAAa;AAEnB,YAAM,OAAQ,MAAM,SACjB,WAAW,OAAO,WAAW,EAC7B,UAAU,EACV,QAAQ,cAAc,KAAK,EAC3B,QAAQ;AAEX,aAAO,KAAK,IAAI,gBAAgB;AAAA,IAClC;AAAA,IACA,MAAM,cAAc,KAAK;AACvB,YAAM,aAAa;AAEnB,YAAM,SACH,WAAW,OAAO,WAAW,EAC7B,OAAO;AAAA,QACN,QAAQ,IAAI;AAAA,QACZ,WAAW,IAAI;AAAA,QACf,aAAa,IAAI;AAAA,QACjB,YAAY,IAAI;AAAA,QAChB,YAAY,IAAI,UAAU,YAAY;AAAA,QACtC,YAAY,IAAI,WAAW,YAAY,KAAK;AAAA,MAC9C,CAAC,EACA,QAAQ;AAAA,IACb;AAAA,IACA,MAAM,UAAU,OAAO;AACrB,YAAM,aAAa;AAEnB,YAAM,SACH,YAAY,OAAO,WAAW,EAC9B,IAAI;AAAA,QACH,aAAY,oBAAI,KAAK,GAAE,YAAY;AAAA,MACrC,CAAC,EACA,MAAM,UAAU,KAAK,KAAK,EAC1B,QAAQ;AAAA,IACb;AAAA,EACF;AACF;AAEA,SAAS,cAAc,SAAwC;AAC7D,QAAM,SAAS,SAAS,eAAe;AAEvC,SAAO;AAAA,IACL,SAAS,SAAS,QAAQ,WAAW,GAAG,MAAM;AAAA,IAC9C,aAAa,SAAS,QAAQ,eAAe,GAAG,MAAM;AAAA,EACxD;AACF;AAEA,eAAe,aACb,UACA,SACA,QACe;AACf,QAAM,mBAAmB,UAAU,SAAS,OAAO,OAAO;AAC1D,QAAM,uBAAuB,UAAU,SAAS,OAAO,WAAW;AACpE;AAEA,eAAe,mBACb,UACA,SACA,WACe;AACf,MAAI,YAAY,SAAS;AACvB,UAAM;AAAA,mCACyB,kBAAI,MAAM,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MASjD,QAAQ,QAAQ;AAClB;AAAA,EACF;AAEA,QAAM;AAAA,iCACyB,kBAAI,MAAM,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASjD,QAAQ,QAAQ;AACpB;AAEA,eAAe,uBACb,UACA,SACA,WACe;AACf,MAAI,YAAY,SAAS;AACvB,UAAM;AAAA,mCACyB,kBAAI,MAAM,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQjD,QAAQ,QAAQ;AAClB;AAAA,EACF;AAEA,QAAM;AAAA,iCACyB,kBAAI,MAAM,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQjD,QAAQ,QAAQ;AACpB;AAEA,SAAS,aAAa,KAA+B;AACnD,SAAO;AAAA,IACL,IAAI,IAAI;AAAA,IACR,UAAU,IAAI;AAAA,IACd,cAAc,IAAI;AAAA,IAClB,MAAM,IAAI;AAAA,IACV,QAAQ,KAAK,MAAM,IAAI,MAAM;AAAA,IAC7B,WAAW,IAAI,KAAK,IAAI,UAAU;AAAA,IAClC,YAAY,IAAI,eAAe,IAAI,KAAK,IAAI,YAAY,IAAI;AAAA,EAC9D;AACF;AAEA,SAAS,iBAAiB,KAAgC;AACxD,SAAO;AAAA,IACL,OAAO,IAAI;AAAA,IACX,WAAW,IAAI;AAAA,IACf,YAAY,IAAI;AAAA,IAChB,WAAW,IAAI;AAAA,IACf,WAAW,IAAI,KAAK,IAAI,UAAU;AAAA,IAClC,WAAW,IAAI,aAAa,IAAI,KAAK,IAAI,UAAU,IAAI;AAAA,EACzD;AACF;;;ADzQO,SAAS,aACd,MACA,SACgB;AAChB,SAAO;AAAA,IACL,IAAI,sBAAO;AAAA,MACT,SAAS,IAAI,4BAAa;AAAA,QACxB;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,IACD;AAAA,IACA;AAAA,EACF;AACF;","names":["import_kysely"]}

package/dist/adapters/mysql/index.d.cts

@@ -0,0 +1,6 @@
+import { S as SqlStorageOptions, a as StorageAdapter } from '../../interface-BzT_DC3u.cjs';
+import { Pool } from 'mysql2';
+
+declare function mysqlStorage(pool: Pool, options?: SqlStorageOptions): StorageAdapter;
+
+export { SqlStorageOptions, StorageAdapter, mysqlStorage };

package/dist/adapters/mysql/index.d.ts

@@ -0,0 +1,6 @@
+import { S as SqlStorageOptions, a as StorageAdapter } from '../../interface-BzT_DC3u.js';
+import { Pool } from 'mysql2';
+
+declare function mysqlStorage(pool: Pool, options?: SqlStorageOptions): StorageAdapter;
+
+export { SqlStorageOptions, StorageAdapter, mysqlStorage };

package/dist/adapters/mysql/index.js

@@ -0,0 +1,21 @@
+import {
+  createSqlStorage
+} from "../../chunk-CTPFKR4O.js";
+
+// src/storage/mysql.ts
+import { Kysely, MysqlDialect } from "kysely";
+function mysqlStorage(pool, options) {
+  return createSqlStorage(
+    new Kysely({
+      dialect: new MysqlDialect({
+        pool
+      })
+    }),
+    "mysql",
+    options
+  );
+}
+export {
+  mysqlStorage
+};
+//# sourceMappingURL=index.js.map

package/dist/adapters/mysql/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/storage/mysql.ts"],"sourcesContent":["import { Kysely, MysqlDialect } from \"kysely\";\nimport type { Pool } from \"mysql2\";\n\nimport type { SqlStorageOptions, StorageAdapter } from \"./interface\";\nimport { createSqlStorage } from \"./sql\";\n\nexport function mysqlStorage(\n  pool: Pool,\n  options?: SqlStorageOptions,\n): StorageAdapter {\n  return createSqlStorage(\n    new Kysely({\n      dialect: new MysqlDialect({\n        pool,\n      }),\n    }),\n    \"mysql\",\n    options,\n  );\n}\n"],"mappings":";;;;;AAAA,SAAS,QAAQ,oBAAoB;AAM9B,SAAS,aACd,MACA,SACgB;AAChB,SAAO;AAAA,IACL,IAAI,OAAO;AAAA,MACT,SAAS,IAAI,aAAa;AAAA,QACxB;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,IACD;AAAA,IACA;AAAA,EACF;AACF;","names":[]}