@playfast/reform-db-sqlite 1.0.2 → 1.1.0

package/README.md

@@ -44,9 +44,7 @@ const DataLayer = QueriesAndProcedures.pipe(
 )
 
 // Ephemeral in-memory — the default for tests / proofs:
-const TestLayer = QueriesAndProcedures.pipe(
-  Layer.provideMerge(Sqlite.memory({ migrations })),
-)
+const TestLayer = QueriesAndProcedures.pipe(Layer.provideMerge(Sqlite.memory({ migrations })))
 ```
 
 Both layers build the `Db` service **synchronously** (bun:sqlite opens on a background

package/package.json

@@ -1,37 +1,39 @@
 {
   "name": "@playfast/reform-db-sqlite",
-  "playbook": "./playbook",
-  "version": "1.0.2",
-  "type": "module",
+  "version": "1.1.0",
   "description": "bun:sqlite engine for @playfast/reform-db — a Db driver backed by Bun's built-in SQLite, with emulated reactivity and serialize()/deserialize() snapshots.",
   "keywords": [
-    "reform",
-    "effect",
-    "sqlite",
     "bun",
-    "sql",
+    "effect",
+    "local-first",
     "reactive",
-    "local-first"
+    "reform",
+    "sql",
+    "sqlite"
   ],
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/playfast/reform.git",
     "directory": "packages/reform-db-sqlite"
   },
-  "bugs": {
-    "url": "https://github.com/playfast/reform/issues"
-  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
     "./*": "./src/*.ts"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
@@ -40,16 +42,14 @@
     "lint": "oxlint src",
     "lint:fix": "oxlint --fix src"
   },
-  "peerDependencies": {
-    "effect": "*",
-    "kysely": "*",
-    "@playfast/reform": "*",
-    "@playfast/reform-db": "*"
-  },
   "devDependencies": {
     "@types/bun": "^1.3.14"
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "peerDependencies": {
+    "@playfast/reform": "*",
+    "@playfast/reform-db": "*",
+    "effect": "*",
+    "kysely": "*"
+  },
+  "playbook": "./playbook"
 }

package/src/engine.ts

@@ -44,7 +44,8 @@ const openSqlite = Effect.fn('openSqlite')(function* (
 ): Effect.fn.Return<Database, DbError> {
   const { Database } = yield* Effect.tryPromise({
     try: () => import('bun:sqlite'),
-    catch: (cause) => new DbError({ reason: 'bun:sqlite unavailable (Bun runtime required)', cause }),
+    catch: (cause) =>
+      new DbError({ reason: 'bun:sqlite unavailable (Bun runtime required)', cause }),
   })
   // deserialize wants bytes sync; Blob is already in memory — read async then open sync.
   const seed = yield* Option.match(Option.fromNullable(options.loadDataDir), {

package/src/sqlite.bun.spec.ts

@@ -7,14 +7,14 @@ import {
   DbTable,
   Migration,
   type QueryData,
-} from "@playfast/reform-db";
-import { expect, it } from "@effect/vitest";
-import { Context, Effect, Exit, Layer, Schedule, Schema, Scope } from "effect";
-import { Sqlite } from "./index";
+} from '@playfast/reform-db'
+import { expect, it } from '@effect/vitest'
+import { Context, Effect, Exit, Layer, Schedule, Schema, Scope } from 'effect'
+import { Sqlite } from './index'
 
-const Meta = Schema.Struct({ note: Schema.String });
+const Meta = Schema.Struct({ note: Schema.String })
 
-const Items = DbTable.make("items", {
+const Items = DbTable.make('items', {
   columns: {
     id: DbColumn.text({ primaryKey: true }),
     label: DbColumn.text(),
@@ -22,130 +22,109 @@ const Items = DbTable.make("items", {
     done: DbColumn.boolean(),
     meta: DbColumn.json(Meta),
   },
-  primaryKey: "id",
-});
+  primaryKey: 'id',
+})
 
-const AppDb = DbSchema.make("app", { tables: [Items] });
-const migrations = Migration.fromSchema(AppDb, Migration.sqlite);
+const AppDb = DbSchema.make('app', { tables: [Items] })
+const migrations = Migration.fromSchema(AppDb, Migration.sqlite)
 
-const ItemsQuery = DbQuery.make("items", { output: Items.Row });
+const ItemsQuery = DbQuery.make('items', { output: Items.Row })
 
 type Item = {
-  readonly id: string;
-  readonly label: string;
-  readonly rank: number;
-  readonly done: boolean;
-  readonly meta: { readonly note: string };
-};
+  readonly id: string
+  readonly label: string
+  readonly rank: number
+  readonly done: boolean
+  readonly meta: { readonly note: string }
+}
 
 const rowsOf = (data: QueryData<Item>): ReadonlyArray<Item> =>
-  data._tag === "Success" ? data.value : [];
+  data._tag === 'Success' ? data.value : []
 
 const waitUntil = (predicate: () => boolean) =>
   Effect.sync(predicate).pipe(
     Effect.repeat({
       until: (ready) => ready,
-      schedule: Schedule.spaced("20 millis"),
+      schedule: Schedule.spaced('20 millis'),
     }),
-    Effect.timeout("5 seconds"),
-  );
+    Effect.timeout('5 seconds'),
+  )
 
 const liveLayer = (dataLayer: Layer.Layer<Db>) =>
   DbQuery.live(ItemsQuery, {
     schema: AppDb,
     inputs: [],
-    build: (_inputs, db) => db.selectFrom("items").selectAll().orderBy("rank"),
-  }).pipe(Layer.provideMerge(dataLayer));
-
-it.live(
-  "DbQuery reflects writes (emulated reactivity), decoding boolean + json columns",
-  () => {
-    const program = Effect.gen(function* () {
-      const store = yield* ItemsQuery.store;
-
-      yield* waitUntil(() => store.getSnapshot()._tag === "Success");
-      expect(rowsOf(store.getSnapshot())).toEqual([]);
-
-      const insert = (
-        id: string,
-        label: string,
-        rank: number,
-        done: boolean,
-        note: string,
-      ) =>
-        Db.exec(
-          AppDb.kysely
-            .insertInto("items")
-            .values({ id, label, rank, done, meta: { note } }),
-        );
-
-      yield* insert("b", "second", 2, false, "two");
-      yield* insert("a", "first", 1, true, "one");
-
-      yield* waitUntil(() => rowsOf(store.getSnapshot()).length === 2);
-      const rows = rowsOf(store.getSnapshot());
-      expect(rows.map((row) => row.label)).toEqual(["first", "second"]);
-      expect(rows.map((row) => row.done)).toEqual([true, false]);
-      expect(rows.map((row) => row.meta.note)).toEqual(["one", "two"]);
-    }).pipe(Effect.provide(liveLayer(Sqlite.memory({ migrations }))));
-
-    return program;
-  },
-);
-
-it.scopedLive(
-  "dump() → loadDataDir round-trips rows into a fresh in-memory db",
-  () =>
-    Effect.gen(function* () {
-      const dump = yield* Effect.scoped(
-        Effect.gen(function* () {
-          const context = yield* Layer.build(Sqlite.memory({ migrations }));
-          const driver = Context.get(context, Db);
-          yield* Db.exec(
-            AppDb.kysely
-              .insertInto("items")
-              .values({
-                id: "a",
-                label: "first",
-                rank: 1,
-                done: true,
-                meta: { note: "one" },
-              }),
-          ).pipe(Effect.provideService(Db, driver));
-          return yield* driver.dump();
-        }),
-      );
-
-      yield* Effect.scoped(
-        Effect.gen(function* () {
-          const store = yield* ItemsQuery.store;
-          yield* waitUntil(() => rowsOf(store.getSnapshot()).length === 1);
-          const row = rowsOf(store.getSnapshot())[0];
-          expect(row?.label).toBe("first");
-          expect(row?.done).toBe(true);
-          expect(row?.meta.note).toBe("one");
-        }).pipe(
-          Effect.provide(
-            liveLayer(Sqlite.memory({ migrations, loadDataDir: dump })),
-          ),
-        ),
-      );
-    }),
-);
+    build: (_inputs, db) => db.selectFrom('items').selectAll().orderBy('rank'),
+  }).pipe(Layer.provideMerge(dataLayer))
+
+it.live('DbQuery reflects writes (emulated reactivity), decoding boolean + json columns', () => {
+  const program = Effect.gen(function* () {
+    const store = yield* ItemsQuery.store
+
+    yield* waitUntil(() => store.getSnapshot()._tag === 'Success')
+    expect(rowsOf(store.getSnapshot())).toEqual([])
+
+    const insert = (id: string, label: string, rank: number, done: boolean, note: string) =>
+      Db.exec(AppDb.kysely.insertInto('items').values({ id, label, rank, done, meta: { note } }))
+
+    yield* insert('b', 'second', 2, false, 'two')
+    yield* insert('a', 'first', 1, true, 'one')
+
+    yield* waitUntil(() => rowsOf(store.getSnapshot()).length === 2)
+    const rows = rowsOf(store.getSnapshot())
+    expect(rows.map((row) => row.label)).toEqual(['first', 'second'])
+    expect(rows.map((row) => row.done)).toEqual([true, false])
+    expect(rows.map((row) => row.meta.note)).toEqual(['one', 'two'])
+  }).pipe(Effect.provide(liveLayer(Sqlite.memory({ migrations }))))
+
+  return program
+})
+
+it.scopedLive('dump() → loadDataDir round-trips rows into a fresh in-memory db', () =>
+  Effect.gen(function* () {
+    const dump = yield* Effect.scoped(
+      Effect.gen(function* () {
+        const context = yield* Layer.build(Sqlite.memory({ migrations }))
+        const driver = Context.get(context, Db)
+        yield* Db.exec(
+          AppDb.kysely.insertInto('items').values({
+            id: 'a',
+            label: 'first',
+            rank: 1,
+            done: true,
+            meta: { note: 'one' },
+          }),
+        ).pipe(Effect.provideService(Db, driver))
+        return yield* driver.dump()
+      }),
+    )
+
+    yield* Effect.scoped(
+      Effect.gen(function* () {
+        const store = yield* ItemsQuery.store
+        yield* waitUntil(() => rowsOf(store.getSnapshot()).length === 1)
+        const row = rowsOf(store.getSnapshot())[0]
+        expect(row?.label).toBe('first')
+        expect(row?.done).toBe(true)
+        expect(row?.meta.note).toBe('one')
+      }).pipe(Effect.provide(liveLayer(Sqlite.memory({ migrations, loadDataDir: dump })))),
+    )
+  }),
+)
 
 it.scopedLive(
-  "Sqlite.memory layer is sync-providable: store starts loading, then resolves to Success",
+  'Sqlite.memory layer is sync-providable: store starts loading, then resolves to Success',
   () =>
     Effect.gen(function* () {
-      const layer = liveLayer(Sqlite.memory({ migrations }));
+      const layer = liveLayer(Sqlite.memory({ migrations }))
 
       // Sync build (opens on background fiber) — must not throw "Fiber cannot be resolved synchronously".
-      const scope = Effect.runSync(Scope.make());
-      const context = Effect.runSync(Layer.buildWithScope(layer, scope));
-      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
-      const store = Context.get(context, ItemsQuery.store);
-      expect(store.getSnapshot()._tag).toBe("Loading");
-      yield* waitUntil(() => store.getSnapshot()._tag === "Success");
-      expect(rowsOf(store.getSnapshot())).toEqual([]);
+      const scope = Effect.runSync(Scope.make())
+      const context = Effect.runSync(Layer.buildWithScope(layer, scope))
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const store = Context.get(context, ItemsQuery.store)
+      expect(store.getSnapshot()._tag).toBe('Loading')
+      yield* waitUntil(() => store.getSnapshot()._tag === 'Success')
+      expect(rowsOf(store.getSnapshot())).toEqual([])
     }),
-);
+)