@hexaijs/sqlite 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Sangwoo Hyun
+
+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,248 @@
+# @hexaijs/sqlite
+
+> SQLite transaction management for testing and lightweight use cases
+
+## Overview
+
+`@hexaijs/sqlite` provides an SQLite implementation of the `UnitOfWork` interface from `@hexaijs/core`. It enables transaction management against SQLite databases, making it particularly useful for fast, isolated integration tests.
+
+The package centers around `SqliteUnitOfWork`, which wraps operations in SQLite transactions. Unlike `PostgresUnitOfWork`, it uses a simpler architecture without `AsyncLocalStorage` or propagation modes—a deliberate trade-off that favors simplicity for scenarios where a single database connection is sufficient.
+
+The test utilities export makes it easy to spin up in-memory databases and use generic repositories for test fixtures. In-memory SQLite databases are ephemeral: they're created instantly, run entirely in RAM, and disappear when the connection closes. This makes them ideal for integration tests that need database behavior without the overhead of a real PostgreSQL server.
+
+## When to Use SQLite vs PostgreSQL
+
+| Scenario | Recommendation |
+|----------|----------------|
+| Unit/integration tests | **SQLite** - Fast, no external dependencies |
+| Production database | **PostgreSQL** - Full ACID, scalability, advanced features |
+| CI/CD pipelines | **SQLite** - No database setup required |
+| Local development | Either - SQLite for speed, PostgreSQL for parity with production |
+
+## Installation
+
+```bash
+npm install @hexaijs/sqlite
+```
+
+**Peer dependencies:**
+
+```bash
+npm install @hexaijs/core sqlite sqlite3
+```
+
+## Core Concepts
+
+### SqliteUnitOfWork
+
+The `SqliteUnitOfWork` implements `UnitOfWork<Database>` from `@hexaijs/core`. It manages transaction lifecycle for a given SQLite database connection.
+
+```typescript
+import { open } from "sqlite";
+import sqlite3 from "sqlite3";
+import { SqliteUnitOfWork } from "@hexaijs/sqlite";
+
+// Create an in-memory database
+const db = await open({
+    filename: ":memory:",
+    driver: sqlite3.Database,
+});
+
+// Create unit of work
+const unitOfWork = new SqliteUnitOfWork(db);
+```
+
+Unlike PostgreSQL's unit of work which accepts a client factory, `SqliteUnitOfWork` takes a pre-connected `Database` instance. This simpler model works well for SQLite's single-writer architecture.
+
+### Transaction Execution
+
+Use `wrap()` to execute operations within a transaction:
+
+```typescript
+const result = await unitOfWork.wrap(async (db) => {
+    await db.run("INSERT INTO orders (id, status) VALUES (?, ?)", [orderId, "pending"]);
+    await db.run("INSERT INTO order_items (order_id, product_id) VALUES (?, ?)", [orderId, productId]);
+    return { orderId };
+});
+// Transaction commits if successful
+```
+
+If an error is thrown, the transaction rolls back:
+
+```typescript
+try {
+    await unitOfWork.wrap(async (db) => {
+        await db.run("INSERT INTO orders (id, status) VALUES (?, ?)", [orderId, "pending"]);
+        throw new Error("Something went wrong");
+    });
+} catch (error) {
+    // Transaction rolled back - no order was inserted
+}
+```
+
+### Accessing the Client
+
+Within a transaction, access the database through `getClient()`:
+
+```typescript
+// Inside a command handler
+const db = ctx.getUnitOfWork().getClient();
+await db.run("UPDATE orders SET status = ? WHERE id = ?", ["confirmed", orderId]);
+```
+
+Note: `getClient()` throws an error if called outside of a `wrap()` call.
+
+### Nested Transactions
+
+Nested `wrap()` calls participate in the same transaction:
+
+```typescript
+await unitOfWork.wrap(async (db) => {
+    await db.run("INSERT INTO orders (id) VALUES (?)", ["order-1"]);
+
+    await unitOfWork.wrap(async (db) => {
+        await db.run("INSERT INTO order_items (order_id) VALUES (?)", ["order-1"]);
+    });
+    // Both inserts are in the same transaction
+});
+// Single COMMIT at the end
+```
+
+If any nested call throws, the entire transaction rolls back:
+
+```typescript
+try {
+    await unitOfWork.wrap(async (db) => {
+        await db.run("INSERT INTO orders (id) VALUES (?)", ["order-1"]);
+
+        await unitOfWork.wrap(async (db) => {
+            await db.run("INSERT INTO order_items (order_id) VALUES (?)", ["order-1"]);
+            throw new Error("Nested failure");
+        });
+    });
+} catch {
+    // Both inserts rolled back
+}
+```
+
+## Usage
+
+### Test Setup
+
+Use the test utilities for fast, isolated integration tests:
+
+```typescript
+import type { Database } from "sqlite";
+import { SqliteUnitOfWork } from "@hexaijs/sqlite";
+import { getSqliteConnection } from "@hexaijs/sqlite/test";
+
+describe("OrderRepository", () => {
+    let db: Database;
+    let unitOfWork: SqliteUnitOfWork;
+
+    beforeEach(async () => {
+        // Create fresh in-memory database
+        db = await getSqliteConnection();
+
+        // Create schema
+        await db.run(`
+            CREATE TABLE orders (
+                id TEXT PRIMARY KEY,
+                status TEXT NOT NULL
+            )
+        `);
+
+        unitOfWork = new SqliteUnitOfWork(db);
+    });
+
+    afterEach(async () => {
+        await db.close();
+    });
+
+    it("should persist orders", async () => {
+        await unitOfWork.wrap(async (db) => {
+            await db.run("INSERT INTO orders (id, status) VALUES (?, ?)", ["order-1", "pending"]);
+        });
+
+        const result = await db.get("SELECT * FROM orders WHERE id = ?", ["order-1"]);
+        expect(result.status).toBe("pending");
+    });
+});
+```
+
+### SqliteRepositoryForTest
+
+The `SqliteRepositoryForTest` provides a generic repository implementation for test fixtures. It implements the `Repository<E>` interface from `@hexaijs/core`.
+
+```typescript
+import { SqliteRepositoryForTest, getSqliteConnection } from "@hexaijs/sqlite/test";
+import { Identifiable, IdOf } from "@hexaijs/core";
+
+// Define your entity
+class Order implements Identifiable<OrderId> {
+    constructor(
+        private id: OrderId,
+        private status: string
+    ) {}
+
+    getId(): OrderId {
+        return this.id;
+    }
+
+    getStatus(): string {
+        return this.status;
+    }
+}
+
+// Define memento for serialization
+interface OrderMemento {
+    id: string;
+    status: string;
+}
+
+// Create repository
+const db = await getSqliteConnection();
+const orderRepository = new SqliteRepositoryForTest<Order, OrderMemento>(db, {
+    namespace: "orders",
+    hydrate: (m) => new Order(new OrderId(m.id), m.status),
+    dehydrate: (e) => ({ id: e.getId().getValue(), status: e.getStatus() }),
+});
+
+// Use repository
+await orderRepository.add(new Order(new OrderId("order-1"), "pending"));
+const order = await orderRepository.get(new OrderId("order-1"));
+await orderRepository.update(order);
+const count = await orderRepository.count();
+```
+
+The repository automatically creates its table on first use. Each repository uses a separate table identified by its namespace.
+
+### File-Based Database
+
+For scenarios requiring persistence across test runs or debugging:
+
+```typescript
+import { getSqliteConnection } from "@hexaijs/sqlite/test";
+
+// File-based database instead of in-memory
+const db = await getSqliteConnection("./test-database.sqlite");
+```
+
+## API Highlights
+
+| Export | Description |
+|--------|-------------|
+| `SqliteUnitOfWork` | Transaction management implementing `UnitOfWork<Database>` |
+
+**From `@hexaijs/sqlite/test`:**
+
+| Export | Description |
+|--------|-------------|
+| `getSqliteConnection` | Creates SQLite connection (in-memory by default) |
+| `SqliteRepositoryForTest` | Generic repository for test fixtures |
+
+## See Also
+
+- [@hexaijs/core](../core/README.md) - Core interfaces (`UnitOfWork`, `Repository`)
+- [@hexaijs/postgres](../postgres/README.md) - PostgreSQL implementation for production
+- [@hexaijs/application](../application/README.md) - Application context that provides `getUnitOfWork()`

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sqlite-unit-of-work";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sqlite-unit-of-work"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC"}

package/dist/sqlite-unit-of-work.d.ts

@@ -0,0 +1,10 @@
+import type { Database } from "sqlite";
+import { UnitOfWork } from "@hexaijs/core";
+export declare class SqliteUnitOfWork implements UnitOfWork<Database> {
+    private db;
+    private static transactions;
+    constructor(db: Database);
+    getClient(): Database;
+    wrap<T>(fn: (client: Database) => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=sqlite-unit-of-work.d.ts.map

package/dist/sqlite-unit-of-work.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-unit-of-work.d.ts","sourceRoot":"","sources":["../src/sqlite-unit-of-work.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,qBAAa,gBAAiB,YAAW,UAAU,CAAC,QAAQ,CAAC;IAS7C,OAAO,CAAC,EAAE;IARtB,OAAO,CAAC,MAAM,CAAC,YAAY,CAMvB;gBAEgB,EAAE,EAAE,QAAQ;IAShC,SAAS,IAAI,QAAQ;IAQf,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAwBlE"}

package/dist/sqlite-unit-of-work.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteUnitOfWork = void 0;
+class SqliteUnitOfWork {
+    db;
+    static transactions = new WeakMap();
+    constructor(db) {
+        this.db = db;
+        if (!SqliteUnitOfWork.transactions.has(db)) {
+            SqliteUnitOfWork.transactions.set(db, {
+                level: 0,
+                aborted: false,
+            });
+        }
+    }
+    getClient() {
+        const current = SqliteUnitOfWork.transactions.get(this.db);
+        if (!current || current.level === 0) {
+            throw new Error("No transaction is active");
+        }
+        return this.db;
+    }
+    async wrap(fn) {
+        const current = SqliteUnitOfWork.transactions.get(this.db);
+        if (++current.level === 1) {
+            await this.db.run("BEGIN TRANSACTION");
+        }
+        try {
+            return await fn(this.db);
+        }
+        catch (e) {
+            if (!current.aborted) {
+                current.aborted = true;
+            }
+            throw e;
+        }
+        finally {
+            if (--current.level === 0) {
+                if (current.aborted) {
+                    await this.db.run("ROLLBACK");
+                }
+                else {
+                    await this.db.run("COMMIT");
+                }
+            }
+        }
+    }
+}
+exports.SqliteUnitOfWork = SqliteUnitOfWork;
+//# sourceMappingURL=sqlite-unit-of-work.js.map

package/dist/sqlite-unit-of-work.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-unit-of-work.js","sourceRoot":"","sources":["../src/sqlite-unit-of-work.ts"],"names":[],"mappings":";;;AAIA,MAAa,gBAAgB;IASL;IARZ,MAAM,CAAC,YAAY,GAAG,IAAI,OAAO,EAMtC,CAAC;IAEJ,YAAoB,EAAY;QAAZ,OAAE,GAAF,EAAE,CAAU;QAC5B,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;YACzC,gBAAgB,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,EAAE;gBAClC,KAAK,EAAE,CAAC;gBACR,OAAO,EAAE,KAAK;aACjB,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED,SAAS;QACL,MAAM,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,IAAI,CAAC,EAAE,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,IAAI,CAAI,EAAoC;QAC9C,MAAM,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAE,CAAC;QAC5D,IAAI,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,CAAC;YACD,OAAO,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;gBACnB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;YAC3B,CAAC;YAED,MAAM,CAAC,CAAC;QACZ,CAAC;gBAAS,CAAC;YACP,IAAI,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;gBACxB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;oBAClB,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAClC,CAAC;qBAAM,CAAC;oBACJ,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAChC,CAAC;YACL,CAAC;QACL,CAAC;IACL,CAAC;;AAjDL,4CAkDC"}

package/dist/test/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sqlite-repository-for-test";
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,SAAS,CAAC"}

package/dist/test/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sqlite-repository-for-test"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/dist/test/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+DAA6C;AAC7C,0CAAwB"}

package/dist/test/sqlite-repository-for-test.d.ts

@@ -0,0 +1,19 @@
+import type { Database } from "sqlite";
+import { Identifiable, IdOf, Repository } from "@hexaijs/core";
+export declare class SqliteRepositoryForTest<E extends Identifiable<any>, M> implements Repository<E> {
+    protected db: Database;
+    protected namespace: string;
+    protected hydrate: (memento: M) => E;
+    protected dehydrate: (entity: E) => M;
+    constructor(db: Database, { namespace, hydrate, dehydrate, }: {
+        namespace: string;
+        hydrate: (memento: M) => E;
+        dehydrate: (entity: E) => M;
+    });
+    get(id: IdOf<E>): Promise<E>;
+    add(entity: E): Promise<void>;
+    update(entity: E): Promise<void>;
+    count(): Promise<number>;
+    protected ensureTableExists(): Promise<void>;
+}
+//# sourceMappingURL=sqlite-repository-for-test.d.ts.map

package/dist/test/sqlite-repository-for-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-repository-for-test.d.ts","sourceRoot":"","sources":["../../src/test/sqlite-repository-for-test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAEH,YAAY,EACZ,IAAI,EAEJ,UAAU,EACb,MAAM,eAAe,CAAC;AAEvB,qBAAa,uBAAuB,CAChC,CAAC,SAAS,YAAY,CAAC,GAAG,CAAC,EAC3B,CAAC,CACH,YAAW,UAAU,CAAC,CAAC,CAAC;IAMlB,SAAS,CAAC,EAAE,EAAE,QAAQ;IAL1B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IACrC,SAAS,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;gBAGxB,EAAE,EAAE,QAAQ,EACtB,EACI,SAAS,EACT,OAAO,EACP,SAAS,GACZ,EAAE;QACC,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QAC3B,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;KAC/B;IAOC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgB5B,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB7B,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBhC,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;cAUd,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;CAQrD"}

package/dist/test/sqlite-repository-for-test.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteRepositoryForTest = void 0;
+const core_1 = require("@hexaijs/core");
+class SqliteRepositoryForTest {
+    db;
+    namespace;
+    hydrate;
+    dehydrate;
+    constructor(db, { namespace, hydrate, dehydrate, }) {
+        this.db = db;
+        this.namespace = namespace;
+        this.hydrate = hydrate;
+        this.dehydrate = dehydrate;
+    }
+    async get(id) {
+        await this.ensureTableExists();
+        const row = await this.db.get(`SELECT * FROM ${this.namespace} WHERE id = ?`, id.getValue());
+        if (!row) {
+            throw new core_1.ObjectNotFoundError(`entity with id '${id.getValue()}' not found`);
+        }
+        return this.hydrate(JSON.parse(row.data));
+    }
+    async add(entity) {
+        await this.ensureTableExists();
+        try {
+            await this.db.run(`INSERT INTO ${this.namespace} (id, data)
+                 VALUES (?, ?)`, entity.getId().getValue(), JSON.stringify(this.dehydrate(entity)));
+        }
+        catch (e) {
+            if (e.message.includes("UNIQUE constraint failed")) {
+                throw new core_1.DuplicateObjectError(`entity with id '${entity
+                    .getId()
+                    .getValue()}' already exists`);
+            }
+            throw e;
+        }
+    }
+    async update(entity) {
+        await this.ensureTableExists();
+        const result = await this.db.run(`UPDATE ${this.namespace}
+                 SET data = ?
+                 WHERE id = ?`, JSON.stringify(this.dehydrate(entity)), entity.getId().getValue());
+        if (result.changes === 0) {
+            throw new core_1.ObjectNotFoundError(`entity with id '${entity.getId().getValue()}' not found`);
+        }
+    }
+    async count() {
+        await this.ensureTableExists();
+        const result = await this.db.get(`SELECT COUNT(*) AS count FROM ${this.namespace}`);
+        return result.count;
+    }
+    async ensureTableExists() {
+        await this.db.run(`
+            CREATE TABLE IF NOT EXISTS ${this.namespace} (
+                id TEXT NOT NULL PRIMARY KEY UNIQUE,
+                data TEXT NOT NULL
+            )
+        `);
+    }
+}
+exports.SqliteRepositoryForTest = SqliteRepositoryForTest;
+//# sourceMappingURL=sqlite-repository-for-test.js.map

package/dist/test/sqlite-repository-for-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-repository-for-test.js","sourceRoot":"","sources":["../../src/test/sqlite-repository-for-test.ts"],"names":[],"mappings":";;;AAEA,wCAMuB;AAEvB,MAAa,uBAAuB;IASlB;IALJ,SAAS,CAAS;IAClB,OAAO,CAAoB;IAC3B,SAAS,CAAmB;IAEtC,YACc,EAAY,EACtB,EACI,SAAS,EACT,OAAO,EACP,SAAS,GAKZ;QATS,OAAE,GAAF,EAAE,CAAU;QAWtB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,EAAW;QACjB,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE/B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CACzB,iBAAiB,IAAI,CAAC,SAAS,eAAe,EAC9C,EAAE,CAAC,QAAQ,EAAE,CAChB,CAAC;QACF,IAAI,CAAC,GAAG,EAAE,CAAC;YACP,MAAM,IAAI,0BAAmB,CACzB,mBAAmB,EAAE,CAAC,QAAQ,EAAE,aAAa,CAChD,CAAC;QACN,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,MAAS;QACf,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE/B,IAAI,CAAC;YACD,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CACb,eAAe,IAAI,CAAC,SAAS;+BACd,EACf,MAAM,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,EACzB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CACzC,CAAC;QACN,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAK,CAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAC,EAAE,CAAC;gBAC5D,MAAM,IAAI,2BAAoB,CAC1B,mBAAmB,MAAM;qBACpB,KAAK,EAAE;qBACP,QAAQ,EAAE,kBAAkB,CACpC,CAAC;YACN,CAAC;YAED,MAAM,CAAC,CAAC;QACZ,CAAC;IACL,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAS;QAClB,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAC5B,UAAU,IAAI,CAAC,SAAS;;8BAEN,EAClB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EACtC,MAAM,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,IAAI,MAAM,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,0BAAmB,CACzB,mBAAmB,MAAM,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,aAAa,CAC5D,CAAC;QACN,CAAC;IACL,CAAC;IAED,KAAK,CAAC,KAAK;QACP,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAE/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAC5B,iCAAiC,IAAI,CAAC,SAAS,EAAE,CACpD,CAAC;QAEF,OAAO,MAAM,CAAC,KAAK,CAAC;IACxB,CAAC;IAES,KAAK,CAAC,iBAAiB;QAC7B,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC;yCACe,IAAI,CAAC,SAAS;;;;SAI9C,CAAC,CAAC;IACP,CAAC;CACJ;AApGD,0DAoGC"}

package/dist/test/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from "sqlite";
+export declare function getSqliteConnection(filename?: string): Promise<Database>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,wBAAsB,mBAAmB,CACrC,QAAQ,SAAa,GACtB,OAAO,CAAC,QAAQ,CAAC,CAOnB"}

package/dist/test/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSqliteConnection = getSqliteConnection;
+async function getSqliteConnection(filename = ":memory:") {
+    const sqlite = await import("sqlite");
+    const sqlite3 = await import("sqlite3");
+    return await sqlite.open({
+        filename,
+        driver: sqlite3.default.Database,
+    });
+}
+//# sourceMappingURL=utils.js.map

package/dist/test/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":";;AAEA,kDASC;AATM,KAAK,UAAU,mBAAmB,CACrC,QAAQ,GAAG,UAAU;IAErB,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;IACxC,OAAO,MAAM,MAAM,CAAC,IAAI,CAAC;QACrB,QAAQ;QACR,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ;KACnC,CAAC,CAAC;AACP,CAAC"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@hexaijs/sqlite",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.1.0",
+  "description": "SQLite support for hexai",
+  "license": "MIT",
+  "author": "Sangwoo Hyun <wkdny.hyun@gmail.com>",
+  "contributors": [
+    "Seungcheol Baek <victoryiron.baek@gmail.com>",
+    "Donghyun Lee <edonghyun@naver.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/workingdanny911/hexai.git",
+    "directory": "packages/sqlite"
+  },
+  "homepage": "https://github.com/workingdanny911/hexai#readme",
+  "bugs": {
+    "url": "https://github.com/workingdanny911/hexai/issues"
+  },
+  "keywords": [
+    "hexai",
+    "hexagonal",
+    "clean-architecture",
+    "sqlite",
+    "database",
+    "typescript"
+  ],
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./test": {
+      "types": "./dist/test/index.d.ts",
+      "import": "./dist/test/index.js",
+      "require": "./dist/test/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
+    "@hexaijs/core": "^0.2.0"
+  },
+  "devDependencies": {
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsc -p ./tsconfig.build.json && tsc-alias"
+  }
+}