@comity/sql-kysely 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Filippo Bovo and contributors
+
+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,59 @@
+# @comity/sql-kysely
+
+Kysely adapter for @comity/sql.
+
+---
+
+## Purpose
+
+Implements the SQL contracts from `@comity/sql` on top of Kysely. Maps Kysely operations to the SQL client and result contracts without exposing Kysely internals directly.
+
+---
+
+## Scope
+
+This package:
+
+- ✅ provides a Kysely-backed SQL client implementation
+- ✅ maps Kysely errors to Comity SQL error types
+- ✅ maps Kysely transactions to the SQL transaction contract
+
+This package does NOT:
+
+- ❌ define SQL contracts
+- ❌ manage connection pools or pooling strategies
+- ❌ expose Kysely internals through public contracts
+
+---
+
+## Public API
+
+- `createKyselySqlClient` — factory that creates a Kysely-based SQL client
+
+No exhaustive reference; see docs for constraints.
+
+---
+
+## Documentation
+
+- docs/overview.md
+- docs/conventions.md
+- docs/architecture.md
+- docs/error-mapping.md
+- docs/transactions.md
+
+---
+
+## Related Packages
+
+- @comity/sql — SQL contracts and error types
+
+---
+
+## Status
+
+Stable
+
+_Review Completed: 2026-07-25_
+_Reviewer: Hobiri MAGI (DeepSeek v4 Pro)_
+_Compliance Score: 99.5% (Green)_

package/dist/cjs/client/create-kysely.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKyselySqlClient = createKyselySqlClient;
+const execute_js_1 = require("../query/execute.js");
+const execute_js_2 = require("../transaction/execute.js");
+/**
+ * Create a SqlClient backed by a Kysely database instance.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ *
+ * @param options - Immutable client configuration including db and adapter name
+ *
+ * @returns SqlClient implementation that executes queries and transactions via Kysely
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ *
+ * @remarks
+ * - Public API does not expose Kysely types
+ * - Error reasons use kebab-case domain format (sql:<error-kind>)
+ */
+function createKyselySqlClient(options) {
+    return {
+        /** @inheritdoc  */
+        query: (q) => (0, execute_js_1.executeQuery)(options.db, q, options.adapter),
+        /** @inheritdoc */
+        begin: () => (0, execute_js_2.executeTransaction)(options.db, options.adapter),
+    };
+}
+//# sourceMappingURL=create-kysely.js.map

package/dist/cjs/client/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKyselySqlClient = void 0;
+var create_kysely_js_1 = require("./client/create-kysely.js");
+Object.defineProperty(exports, "createKyselySqlClient", { enumerable: true, get: function () { return create_kysely_js_1.createKyselySqlClient; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/internal/assert-client.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertKyselyClient = assertKyselyClient;
+const errors_1 = require("@comity/sql/errors");
+/**
+ * Validate the client shape and throw a structured error if invalid.
+ *
+ * @param client - Value to validate as KyselyDatabase
+ *
+ * @throws SqlError with reason "sql:invalid_configuration" if invalid
+ */
+function assertKyselyClient(client) {
+    if (!client ||
+        typeof client !== "object" ||
+        typeof client.executeQuery !== "function" ||
+        typeof client.transaction !== "function") {
+        throw new errors_1.SqlError("invalid_configuration", {
+            details: {
+                retriable: false,
+                expected: "KyselyDatabase",
+            },
+        });
+    }
+}
+//# sourceMappingURL=assert-client.js.map

package/dist/cjs/internal/map-sql-error.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRIVER_ERROR_MAPPINGS = void 0;
+exports.mapSqlError = mapSqlError;
+const errors_1 = require("@comity/sql/errors");
+/**
+ * Driver-specific error code mappings.
+ */
+exports.DRIVER_ERROR_MAPPINGS = {
+    postgres: {
+        "57014": { reason: "cancelled", retriable: true },
+        "42601": { reason: "invalid_query", retriable: false },
+        "08006": { reason: "connection_failed", retriable: true },
+        "42883": { reason: "invalid_query", retriable: false },
+    },
+    mysql: {
+        "1317": { reason: "cancelled", retriable: true },
+        "1064": { reason: "invalid_query", retriable: false },
+    },
+};
+/**
+ * Maps various error types and messages into a standardized SqlError.
+ *
+ * @param cause - The original error thrown during a SQL operation
+ * @param operation - The type of SQL operation being performed
+ * @param adapter - Optional database adapter name
+ *
+ * @returns A standardized SqlError instance
+ */
+function mapSqlError(cause, operation, adapter) {
+    // 1. Abort / cancellation
+    if (cause instanceof DOMException && cause.name === "AbortError") {
+        return new errors_1.SqlError("cancelled", {
+            details: { operation, adapter, retriable: true },
+            cause,
+        });
+    }
+    // 2. Driver-specific error code mappings
+    if (adapter in exports.DRIVER_ERROR_MAPPINGS &&
+        typeof exports.DRIVER_ERROR_MAPPINGS[adapter] === "object" &&
+        typeof cause === "object" &&
+        cause &&
+        "code" in cause &&
+        typeof cause.code === "string" &&
+        cause.code in exports.DRIVER_ERROR_MAPPINGS[adapter] &&
+        exports.DRIVER_ERROR_MAPPINGS[adapter][cause.code]) {
+        const mapping = exports.DRIVER_ERROR_MAPPINGS[adapter][cause.code];
+        // Return mapped error
+        if (mapping && mapping.reason) {
+            return new errors_1.SqlError(mapping.reason, {
+                details: { operation, adapter, retriable: mapping.retriable },
+                context: { originalCode: cause.code },
+                cause,
+            });
+        }
+    }
+    // 3. Operation-aware fallback
+    if (operation === "transaction") {
+        return new errors_1.SqlError("transaction_failed", {
+            details: { operation, adapter, retriable: false },
+            cause,
+        });
+    }
+    // 4. Last-resort fallback
+    return new errors_1.SqlError("query_failed", {
+        details: { operation, adapter, retriable: false },
+        cause,
+    });
+}
+//# sourceMappingURL=map-sql-error.js.map

package/dist/cjs/query/execute.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeQuery = executeQuery;
+const errors_1 = require("@comity/sql/errors");
+const kysely_1 = require("kysely");
+const map_sql_error_js_1 = require("../internal/map-sql-error.js");
+/**
+ * Execute a SQL query via Kysely and return an explicit operation result.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ * @typeParam T - Row shape produced by the query
+ *
+ * @param db - Kysely database instance
+ * @param query - Immutable SQL query payload
+ * @param adapter - Adapter name for diagnostics
+ *
+ * @returns Operation result wrapping a SqlResult<T>
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ */
+async function executeQuery(db, query, adapter) {
+    if (query.params && !Array.isArray(query.params)) {
+        return {
+            success: false,
+            error: new errors_1.SqlError("invalid_query", {
+                details: {
+                    retriable: false,
+                    adapter,
+                    operation: "query",
+                },
+                context: {
+                    violation: "named_parameters",
+                },
+            }),
+        };
+    }
+    try {
+        const compiled = kysely_1.CompiledQuery.raw(query.statement, (query.params ?? []));
+        const result = await db.executeQuery(compiled);
+        return {
+            success: true,
+            value: {
+                rows: result.rows,
+                rowCount: typeof result.numAffectedRows === "bigint"
+                    ? Number(result.numAffectedRows)
+                    : result.rows.length,
+            },
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: (0, map_sql_error_js_1.mapSqlError)(e, "query", adapter),
+        };
+    }
+}
+//# sourceMappingURL=execute.js.map

package/dist/cjs/transaction/execute.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTransaction = executeTransaction;
+const map_sql_error_js_1 = require("../internal/map-sql-error.js");
+const execute_js_1 = require("../query/execute.js");
+/**
+ * Begin a transaction via Kysely and return a transactional capability.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ *
+ * @param db - Kysely database instance
+ * @param adapter - Adapter name for diagnostics
+ *
+ * @returns Operation result wrapping a SqlTransaction capability
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ */
+async function executeTransaction(db, adapter) {
+    try {
+        let trx;
+        let resolve;
+        let reject;
+        const barrier = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        const txPromise = db.transaction().execute(async (t) => {
+            trx = t;
+            await barrier;
+        });
+        const transaction = {
+            /** @inheritdoc */
+            query: (q) => (0, execute_js_1.executeQuery)(trx, q, adapter),
+            /** @inheritdoc */
+            commit: async () => {
+                try {
+                    resolve();
+                    await txPromise;
+                    return { success: true, value: undefined };
+                }
+                catch (e) {
+                    return { success: false, error: (0, map_sql_error_js_1.mapSqlError)(e, "transaction", adapter) };
+                }
+            },
+            /** @inheritdoc */
+            rollback: async () => {
+                try {
+                    reject(new Error("rollback"));
+                    await txPromise.catch(() => { });
+                    return { success: true, value: undefined };
+                }
+                catch (e) {
+                    return { success: false, error: (0, map_sql_error_js_1.mapSqlError)(e, "transaction", adapter) };
+                }
+            },
+        };
+        return {
+            success: true,
+            value: transaction,
+        };
+    }
+    catch (e) {
+        return { success: false, error: (0, map_sql_error_js_1.mapSqlError)(e, "transaction", adapter) };
+    }
+}
+//# sourceMappingURL=execute.js.map

package/dist/esm/client/create-kysely.js

@@ -0,0 +1,26 @@
+import { executeQuery } from "../query/execute.js";
+import { executeTransaction } from "../transaction/execute.js";
+/**
+ * Create a SqlClient backed by a Kysely database instance.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ *
+ * @param options - Immutable client configuration including db and adapter name
+ *
+ * @returns SqlClient implementation that executes queries and transactions via Kysely
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ *
+ * @remarks
+ * - Public API does not expose Kysely types
+ * - Error reasons use kebab-case domain format (sql:<error-kind>)
+ */
+export function createKyselySqlClient(options) {
+    return {
+        /** @inheritdoc  */
+        query: (q) => executeQuery(options.db, q, options.adapter),
+        /** @inheritdoc */
+        begin: () => executeTransaction(options.db, options.adapter),
+    };
+}
+//# sourceMappingURL=create-kysely.js.map

package/dist/esm/client/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export { createKyselySqlClient } from "./client/create-kysely.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/internal/assert-client.js

@@ -0,0 +1,22 @@
+import { SqlError } from "@comity/sql/errors";
+/**
+ * Validate the client shape and throw a structured error if invalid.
+ *
+ * @param client - Value to validate as KyselyDatabase
+ *
+ * @throws SqlError with reason "sql:invalid_configuration" if invalid
+ */
+export function assertKyselyClient(client) {
+    if (!client ||
+        typeof client !== "object" ||
+        typeof client.executeQuery !== "function" ||
+        typeof client.transaction !== "function") {
+        throw new SqlError("invalid_configuration", {
+            details: {
+                retriable: false,
+                expected: "KyselyDatabase",
+            },
+        });
+    }
+}
+//# sourceMappingURL=assert-client.js.map

package/dist/esm/internal/map-sql-error.js

@@ -0,0 +1,66 @@
+import { SqlError } from "@comity/sql/errors";
+/**
+ * Driver-specific error code mappings.
+ */
+export const DRIVER_ERROR_MAPPINGS = {
+    postgres: {
+        "57014": { reason: "cancelled", retriable: true },
+        "42601": { reason: "invalid_query", retriable: false },
+        "08006": { reason: "connection_failed", retriable: true },
+        "42883": { reason: "invalid_query", retriable: false },
+    },
+    mysql: {
+        "1317": { reason: "cancelled", retriable: true },
+        "1064": { reason: "invalid_query", retriable: false },
+    },
+};
+/**
+ * Maps various error types and messages into a standardized SqlError.
+ *
+ * @param cause - The original error thrown during a SQL operation
+ * @param operation - The type of SQL operation being performed
+ * @param adapter - Optional database adapter name
+ *
+ * @returns A standardized SqlError instance
+ */
+export function mapSqlError(cause, operation, adapter) {
+    // 1. Abort / cancellation
+    if (cause instanceof DOMException && cause.name === "AbortError") {
+        return new SqlError("cancelled", {
+            details: { operation, adapter, retriable: true },
+            cause,
+        });
+    }
+    // 2. Driver-specific error code mappings
+    if (adapter in DRIVER_ERROR_MAPPINGS &&
+        typeof DRIVER_ERROR_MAPPINGS[adapter] === "object" &&
+        typeof cause === "object" &&
+        cause &&
+        "code" in cause &&
+        typeof cause.code === "string" &&
+        cause.code in DRIVER_ERROR_MAPPINGS[adapter] &&
+        DRIVER_ERROR_MAPPINGS[adapter][cause.code]) {
+        const mapping = DRIVER_ERROR_MAPPINGS[adapter][cause.code];
+        // Return mapped error
+        if (mapping && mapping.reason) {
+            return new SqlError(mapping.reason, {
+                details: { operation, adapter, retriable: mapping.retriable },
+                context: { originalCode: cause.code },
+                cause,
+            });
+        }
+    }
+    // 3. Operation-aware fallback
+    if (operation === "transaction") {
+        return new SqlError("transaction_failed", {
+            details: { operation, adapter, retriable: false },
+            cause,
+        });
+    }
+    // 4. Last-resort fallback
+    return new SqlError("query_failed", {
+        details: { operation, adapter, retriable: false },
+        cause,
+    });
+}
+//# sourceMappingURL=map-sql-error.js.map

package/dist/esm/query/execute.js

@@ -0,0 +1,54 @@
+import { SqlError } from "@comity/sql/errors";
+import { CompiledQuery } from "kysely";
+import { mapSqlError } from "../internal/map-sql-error.js";
+/**
+ * Execute a SQL query via Kysely and return an explicit operation result.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ * @typeParam T - Row shape produced by the query
+ *
+ * @param db - Kysely database instance
+ * @param query - Immutable SQL query payload
+ * @param adapter - Adapter name for diagnostics
+ *
+ * @returns Operation result wrapping a SqlResult<T>
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ */
+export async function executeQuery(db, query, adapter) {
+    if (query.params && !Array.isArray(query.params)) {
+        return {
+            success: false,
+            error: new SqlError("invalid_query", {
+                details: {
+                    retriable: false,
+                    adapter,
+                    operation: "query",
+                },
+                context: {
+                    violation: "named_parameters",
+                },
+            }),
+        };
+    }
+    try {
+        const compiled = CompiledQuery.raw(query.statement, (query.params ?? []));
+        const result = await db.executeQuery(compiled);
+        return {
+            success: true,
+            value: {
+                rows: result.rows,
+                rowCount: typeof result.numAffectedRows === "bigint"
+                    ? Number(result.numAffectedRows)
+                    : result.rows.length,
+            },
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: mapSqlError(e, "query", adapter),
+        };
+    }
+}
+//# sourceMappingURL=execute.js.map

package/dist/esm/transaction/execute.js

@@ -0,0 +1,63 @@
+import { mapSqlError } from "../internal/map-sql-error.js";
+import { executeQuery } from "../query/execute.js";
+/**
+ * Begin a transaction via Kysely and return a transactional capability.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ *
+ * @param db - Kysely database instance
+ * @param adapter - Adapter name for diagnostics
+ *
+ * @returns Operation result wrapping a SqlTransaction capability
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ */
+export async function executeTransaction(db, adapter) {
+    try {
+        let trx;
+        let resolve;
+        let reject;
+        const barrier = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        const txPromise = db.transaction().execute(async (t) => {
+            trx = t;
+            await barrier;
+        });
+        const transaction = {
+            /** @inheritdoc */
+            query: (q) => executeQuery(trx, q, adapter),
+            /** @inheritdoc */
+            commit: async () => {
+                try {
+                    resolve();
+                    await txPromise;
+                    return { success: true, value: undefined };
+                }
+                catch (e) {
+                    return { success: false, error: mapSqlError(e, "transaction", adapter) };
+                }
+            },
+            /** @inheritdoc */
+            rollback: async () => {
+                try {
+                    reject(new Error("rollback"));
+                    await txPromise.catch(() => { });
+                    return { success: true, value: undefined };
+                }
+                catch (e) {
+                    return { success: false, error: mapSqlError(e, "transaction", adapter) };
+                }
+            },
+        };
+        return {
+            success: true,
+            value: transaction,
+        };
+    }
+    catch (e) {
+        return { success: false, error: mapSqlError(e, "transaction", adapter) };
+    }
+}
+//# sourceMappingURL=execute.js.map

package/dist/types/client/create-kysely.d.ts

@@ -0,0 +1,29 @@
+import type { SqlClient, SqlClientOptions } from "@comity/sql";
+import type { Kysely } from "kysely";
+/**
+ * Kysely client factory options.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ */
+export interface KyselySqlClientOptions<DB> extends SqlClientOptions {
+    /** Kysely database instance */
+    readonly db: Kysely<DB>;
+    /** Adapter name for diagnostics */
+    readonly adapter: string;
+}
+/**
+ * Create a SqlClient backed by a Kysely database instance.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ *
+ * @param options - Immutable client configuration including db and adapter name
+ *
+ * @returns SqlClient implementation that executes queries and transactions via Kysely
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ *
+ * @remarks
+ * - Public API does not expose Kysely types
+ * - Error reasons use kebab-case domain format (sql:<error-kind>)
+ */
+export declare function createKyselySqlClient<DB = unknown>(options: KyselySqlClientOptions<DB>): SqlClient;

package/dist/types/client/types.d.ts

@@ -0,0 +1,18 @@
+import type { Compilable } from "kysely";
+/**
+ * Minimal Kysely database interface used by this adapter.
+ */
+export interface KyselyDatabase {
+    /** Execute a compiled query and return rows with optional affected count */
+    executeQuery<T = unknown>(query: Compilable): Promise<{
+        /** Result rows */
+        rows: T[];
+        /** Optional affected rows count as bigint */
+        numAffectedRows?: bigint;
+    }>;
+    /** Start a transaction and execute the provided function within it */
+    transaction(): {
+        /** Execute transactional work and resolve with the function's result */
+        execute<T>(fn: (trx: KyselyDatabase) => Promise<T>): Promise<T>;
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { createKyselySqlClient } from "./client/create-kysely.js";

package/dist/types/internal/assert-client.d.ts

@@ -0,0 +1,9 @@
+import type { KyselyDatabase } from "../client/types.js";
+/**
+ * Validate the client shape and throw a structured error if invalid.
+ *
+ * @param client - Value to validate as KyselyDatabase
+ *
+ * @throws SqlError with reason "sql:invalid_configuration" if invalid
+ */
+export declare function assertKyselyClient(client: unknown): asserts client is KyselyDatabase;

package/dist/types/internal/map-sql-error.d.ts

@@ -0,0 +1,26 @@
+import type { SqlErrorReason } from "@comity/sql/errors";
+import { SqlError } from "@comity/sql/errors";
+/**
+ * Internal type for driver-specific error code mappings.
+ */
+type ErrorDetails = {
+    /** Error reason */
+    reason: SqlErrorReason;
+    /** Indicates if the error is retriable */
+    retriable: boolean;
+};
+/**
+ * Driver-specific error code mappings.
+ */
+export declare const DRIVER_ERROR_MAPPINGS: Record<string, Record<string, ErrorDetails>>;
+/**
+ * Maps various error types and messages into a standardized SqlError.
+ *
+ * @param cause - The original error thrown during a SQL operation
+ * @param operation - The type of SQL operation being performed
+ * @param adapter - Optional database adapter name
+ *
+ * @returns A standardized SqlError instance
+ */
+export declare function mapSqlError(cause: unknown, operation: "connect" | "query" | "transaction", adapter: string): SqlError;
+export {};

package/dist/types/query/execute.d.ts

@@ -0,0 +1,17 @@
+import type { SqlOperationResult, SqlQuery, SqlResult } from "@comity/sql";
+import type { Kysely } from "kysely";
+/**
+ * Execute a SQL query via Kysely and return an explicit operation result.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ * @typeParam T - Row shape produced by the query
+ *
+ * @param db - Kysely database instance
+ * @param query - Immutable SQL query payload
+ * @param adapter - Adapter name for diagnostics
+ *
+ * @returns Operation result wrapping a SqlResult<T>
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ */
+export declare function executeQuery<DB, T>(db: Kysely<DB>, query: SqlQuery, adapter: string): Promise<SqlOperationResult<SqlResult<T>>>;

package/dist/types/transaction/execute.d.ts

@@ -0,0 +1,15 @@
+import type { SqlOperationResult, SqlTransaction } from "@comity/sql";
+import type { Kysely } from "kysely";
+/**
+ * Begin a transaction via Kysely and return a transactional capability.
+ *
+ * @typeParam DB - Database shape used by Kysely
+ *
+ * @param db - Kysely database instance
+ * @param adapter - Adapter name for diagnostics
+ *
+ * @returns Operation result wrapping a SqlTransaction capability
+ *
+ * @throws Errors are not thrown; failures are returned via SqlOperationResult
+ */
+export declare function executeTransaction<DB>(db: Kysely<DB>, adapter: string): Promise<SqlOperationResult<SqlTransaction>>;

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@comity/sql-kysely",
+  "version": "0.9.0",
+  "description": "Kysely ORM adapter for @comity/sql contracts",
+  "type": "module",
+  "private": false,
+  "author": "Filippo Bovo <hello@filippobovo.com>",
+  "license": "MIT",
+  "comity": {
+    "layer": "technology-adapter",
+    "implements": "@comity/sql"
+  },
+  "homepage": "https://github.com/comityjs/framework#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/comityjs/framework.git"
+  },
+  "bugs": {
+    "url": "https://github.com/comityjs/framework/issues"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "keywords": [
+    "comity",
+    "adapter",
+    "kysely",
+    "sql",
+    "typescript"
+  ],
+  "files": [
+    "./dist",
+    "!./dist/**/*.map"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {}
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "kysely": "^0.28.0",
+    "@comity/sql": "0.9.0"
+  },
+  "dependencies": {
+    "@comity/sql": "0.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.4",
+    "kysely": "^0.28.17",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build.mjs",
+    "dev": "node ../../scripts/build.mjs --watch",
+    "test": "vitest run --coverage",
+    "type-check": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint --ext .ts src"
+  }
+}