@effect/sql-sqlite-wasm 0.20.6 → 0.21.1

package/dist/esm/index.js

@@ -1,3 +1,7 @@
+/**
+ * @since 1.0.0
+ */
+export * as OpfsWorker from "./OpfsWorker.js";
 /**
  * @since 1.0.0
  */

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["SqliteClient","SqliteMigrator"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB","ignoreList":[]}
+{"version":3,"file":"index.js","names":["OpfsWorker","SqliteClient","SqliteMigrator"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,cAAc,MAAM,qBAAqB","ignoreList":[]}

package/dist/esm/internal/opfsWorker.js

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

package/dist/esm/internal/opfsWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfsWorker.js","names":[],"sources":["../../../src/internal/opfsWorker.ts"],"sourcesContent":[null],"mappings":"","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/sql-sqlite-wasm",
-  "version": "0.20.6",
+  "version": "0.21.1",
   "description": "A SQLite toolkit for Effect",
   "license": "MIT",
   "repository": {
@@ -10,11 +10,11 @@
   },
   "sideEffects": [],
   "dependencies": {
-    "@opentelemetry/semantic-conventions": "^1.25.1",
-    "@sqlite.org/sqlite-wasm": "3.46.0-build2"
+    "@opentelemetry/semantic-conventions": "^1.25.1"
   },
   "peerDependencies": {
-    "@effect/sql": "^0.20.6",
+    "@effect/wa-sqlite": "^0.1.2",
+    "@effect/sql": "^0.20.8",
     "effect": "^3.10.15"
   },
   "publishConfig": {
@@ -30,6 +30,11 @@
       "import": "./dist/esm/index.js",
       "default": "./dist/cjs/index.js"
     },
+    "./OpfsWorker": {
+      "types": "./dist/dts/OpfsWorker.d.ts",
+      "import": "./dist/esm/OpfsWorker.js",
+      "default": "./dist/cjs/OpfsWorker.js"
+    },
     "./SqliteClient": {
       "types": "./dist/dts/SqliteClient.d.ts",
       "import": "./dist/esm/SqliteClient.js",
@@ -48,6 +53,9 @@
   },
   "typesVersions": {
     "*": {
+      "OpfsWorker": [
+        "./dist/dts/OpfsWorker.d.ts"
+      ],
       "SqliteClient": [
         "./dist/dts/SqliteClient.d.ts"
       ],

package/src/OpfsWorker.ts

@@ -0,0 +1,101 @@
+/**
+ * @since 1.0.0
+ */
+/// <reference lib="webworker" />
+import { SqlError } from "@effect/sql/SqlError"
+import * as WaSqlite from "@effect/wa-sqlite"
+import SQLiteESMFactory from "@effect/wa-sqlite/dist/wa-sqlite.mjs"
+import { AccessHandlePoolVFS } from "@effect/wa-sqlite/src/examples/AccessHandlePoolVFS.js"
+import * as Effect from "effect/Effect"
+import type { OpfsWorkerMessage } from "./internal/opfsWorker.js"
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface OpfsWorkerConfig {
+  readonly port: EventTarget & Pick<MessagePort, "postMessage" | "close">
+  readonly dbName: string
+}
+
+/**
+ * @category constructor
+ * @since 1.0.0
+ */
+export const run = (
+  options: OpfsWorkerConfig
+): Effect.Effect<void, SqlError> =>
+  Effect.gen(function*() {
+    const factory = yield* Effect.promise(() => SQLiteESMFactory())
+    const sqlite3 = WaSqlite.Factory(factory)
+    const vfs = yield* Effect.promise(() => AccessHandlePoolVFS.create("opfs", factory))
+    sqlite3.vfs_register(vfs, false)
+    const db = yield* Effect.acquireRelease(
+      Effect.try({
+        try: () => sqlite3.open_v2(options.dbName, undefined, "opfs"),
+        catch: (cause) => new SqlError({ cause, message: "Failed to open database" })
+      }),
+      (db) => Effect.sync(() => sqlite3.close(db))
+    )
+
+    return yield* Effect.async<void>((resume) => {
+      const onMessage = (event: any) => {
+        let messageId: number
+        const message = event.data as OpfsWorkerMessage
+        try {
+          switch (message[0]) {
+            case "close": {
+              options.port.close()
+              return resume(Effect.void)
+            }
+            case "import": {
+              const [, id, data] = message
+              messageId = id
+              sqlite3.deserialize(db, "main", data, data.length, data.length, 1 | 2)
+              options.port.postMessage([id, void 0, void 0])
+              return
+            }
+            case "export": {
+              const [, id] = message
+              messageId = id
+              const data = sqlite3.serialize(db, "main")
+              options.port.postMessage([id, undefined, data], [data.buffer])
+              return
+            }
+            case "update_hook": {
+              messageId = -1
+              sqlite3.update_hook(db, (_op, _db, table, rowid) => {
+                if (!table) return
+                options.port.postMessage(["update_hook", table, Number(rowid)])
+              })
+              return
+            }
+            default: {
+              const [id, sql, params] = message
+              messageId = id
+              const results: Array<any> = []
+              let columns: Array<string> | undefined
+              for (const stmt of sqlite3.statements(db, sql)) {
+                sqlite3.bind_collection(stmt, params as any)
+                while (sqlite3.step(stmt) === WaSqlite.SQLITE_ROW) {
+                  columns = columns ?? sqlite3.column_names(stmt)
+                  const row = sqlite3.row(stmt)
+                  results.push(row)
+                }
+              }
+              options.port.postMessage([id, undefined, [columns, results]])
+              return
+            }
+          }
+        } catch (e: any) {
+          const message = "message" in e ? e.message : String(e)
+          options.port.postMessage([messageId!, message, undefined])
+        }
+      }
+      options.port.addEventListener("message", onMessage)
+      options.port.postMessage(["ready", undefined, undefined])
+      return Effect.sync(() => {
+        options.port.removeEventListener("message", onMessage)
+      })
+    })
+  }).pipe(Effect.scoped)

package/src/SqliteClient.ts

@@ -1,20 +1,31 @@
 /**
  * @since 1.0.0
  */
+import * as Reactivity from "@effect/experimental/Reactivity"
 import * as Client from "@effect/sql/SqlClient"
 import type { Connection } from "@effect/sql/SqlConnection"
 import { SqlError } from "@effect/sql/SqlError"
 import * as Statement from "@effect/sql/Statement"
+import * as WaSqlite from "@effect/wa-sqlite"
+import SQLiteESMFactory from "@effect/wa-sqlite/dist/wa-sqlite.mjs"
+import { MemoryVFS } from "@effect/wa-sqlite/src/examples/MemoryVFS.js"
 import * as Otel from "@opentelemetry/semantic-conventions"
-import type { DB, OpenMode, RowMode } from "@sqlite.org/sqlite-wasm"
-import sqliteInit from "@sqlite.org/sqlite-wasm"
 import * as Config from "effect/Config"
 import type { ConfigError } from "effect/ConfigError"
 import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberRef from "effect/FiberRef"
 import { identity } from "effect/Function"
+import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
+import type * as Mailbox from "effect/Mailbox"
+import type { ReadonlyRecord } from "effect/Record"
 import * as Scope from "effect/Scope"
+import * as ScopedRef from "effect/ScopedRef"
+import * as Stream from "effect/Stream"
+import type { OpfsWorkerMessage } from "./internal/opfsWorker.js"
 
 /**
  * @category type ids
@@ -34,8 +45,17 @@ export type TypeId = typeof TypeId
  */
 export interface SqliteClient extends Client.SqlClient {
   readonly [TypeId]: TypeId
-  readonly config: SqliteClientConfig
+  readonly config: SqliteClientMemoryConfig
+  readonly reactive: <A, E, R>(
+    keys: ReadonlyArray<string> | ReadonlyRecord<string, ReadonlyArray<number>>,
+    effect: Effect.Effect<A, E, R>
+  ) => Stream.Stream<A, E, R>
+  readonly reactiveMailbox: <A, E, R>(
+    keys: ReadonlyArray<string> | ReadonlyRecord<string, ReadonlyArray<number>>,
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<Mailbox.ReadonlyMailbox<A>, E, R | Scope.Scope>
   readonly export: Effect.Effect<Uint8Array, SqlError>
+  readonly import: (data: Uint8Array) => Effect.Effect<void, SqlError>
 
   /** Not supported in sqlite */
   readonly updateValues: never
@@ -51,74 +71,105 @@ export const SqliteClient = Context.GenericTag<SqliteClient>("@effect/sql-sqlite
  * @category models
  * @since 1.0.0
  */
-export type SqliteClientConfig =
-  | {
-    readonly mode?: "vfs"
-    readonly dbName?: string
-    readonly openMode?: OpenMode
-    readonly spanAttributes?: Record<string, unknown>
-    readonly transformResultNames?: (str: string) => string
-    readonly transformQueryNames?: (str: string) => string
-  }
-  | {
-    readonly mode: "opfs"
-    readonly dbName: string
-    readonly openMode?: OpenMode
-    readonly spanAttributes?: Record<string, unknown>
-    readonly transformResultNames?: (str: string) => string
-    readonly transformQueryNames?: (str: string) => string
-  }
+export interface SqliteClientMemoryConfig {
+  readonly installReactivityHooks?: boolean
+  readonly spanAttributes?: Record<string, unknown>
+  readonly transformResultNames?: (str: string) => string
+  readonly transformQueryNames?: (str: string) => string
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface SqliteClientConfig {
+  readonly worker: Effect.Effect<Worker | SharedWorker | MessagePort, never, Scope.Scope>
+  readonly installReactivityHooks?: boolean
+  readonly spanAttributes?: Record<string, unknown>
+  readonly transformResultNames?: (str: string) => string
+  readonly transformQueryNames?: (str: string) => string
+}
 
 interface SqliteConnection extends Connection {
   readonly export: Effect.Effect<Uint8Array, SqlError>
+  readonly import: (data: Uint8Array) => Effect.Effect<void, SqlError>
 }
 
+const initModule = Effect.runSync(
+  Effect.cached(Effect.promise(() => SQLiteESMFactory()))
+)
+
 const initEffect = Effect.runSync(
-  Effect.cached(Effect.promise(() => sqliteInit()))
+  Effect.cached(initModule.pipe(Effect.map((module) => WaSqlite.Factory(module))))
 )
 
+const registered = globalValue("@effect/sql-sqlite-wasm/registered", () => new Set<string>())
+
 /**
  * @category constructor
  * @since 1.0.0
  */
-export const make = (
-  options: SqliteClientConfig
-): Effect.Effect<SqliteClient, never, Scope.Scope> =>
-  Effect.gen(function*(_) {
+export const makeMemory = (
+  options: SqliteClientMemoryConfig
+): Effect.Effect<SqliteClient, SqlError, Scope.Scope | Reactivity.Reactivity> =>
+  Effect.gen(function*() {
+    const reactivity = yield* Reactivity.Reactivity
     const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
     const transformRows = Statement.defaultTransforms(
       options.transformResultNames!
     ).array
 
-    const makeConnection = Effect.gen(function*(_) {
-      const sqlite3 = yield* _(initEffect)
+    const makeConnection = Effect.gen(function*() {
+      const sqlite3 = yield* initEffect
 
-      let db: DB
-      if (options.mode === "opfs") {
-        if (!sqlite3.oo1.OpfsDb) {
-          yield* _(Effect.dieMessage("opfs mode not available"))
-        }
-        db = new sqlite3.oo1.OpfsDb!(options.dbName, options.openMode ?? "c")
-      } else {
-        db = new sqlite3.oo1.DB(options.dbName, options.openMode)
+      if (registered.has("memory-vfs") === false) {
+        registered.add("memory-vfs")
+        const module = yield* initModule
+        // @ts-expect-error
+        const vfs = new MemoryVFS("memory-vfs", module)
+        sqlite3.vfs_register(vfs as any, false)
       }
+      const db = yield* Effect.acquireRelease(
+        Effect.try({
+          try: () => sqlite3.open_v2(":memory:", undefined, "memory-vfs"),
+          catch: (cause) => new SqlError({ cause, message: "Failed to open database" })
+        }),
+        (db) => Effect.sync(() => sqlite3.close(db))
+      )
 
-      yield* _(Effect.addFinalizer(() => Effect.sync(() => db.close())))
+      if (options.installReactivityHooks) {
+        sqlite3.update_hook(db, (_op, _db, table, rowid) => {
+          if (!table) return
+          const id = Number(rowid)
+          reactivity.unsafeInvalidate({ [table]: [id] })
+        })
+      }
 
       const run = (
         sql: string,
         params: ReadonlyArray<Statement.Primitive> = [],
-        rowMode: RowMode = "object"
+        rowMode: "object" | "array" = "object"
       ) =>
         Effect.try({
           try: () => {
             const results: Array<any> = []
-            db.exec({
-              sql,
-              bind: params.length ? params : undefined,
-              rowMode,
-              resultRows: results
-            })
+            for (const stmt of sqlite3.statements(db, sql)) {
+              let columns: Array<string> | undefined
+              sqlite3.bind_collection(stmt, params as any)
+              while (sqlite3.step(stmt) === WaSqlite.SQLITE_ROW) {
+                columns = columns ?? sqlite3.column_names(stmt)
+                const row = sqlite3.row(stmt)
+                if (rowMode === "object") {
+                  const obj: Record<string, any> = {}
+                  for (let i = 0; i < columns.length; i++) {
+                    obj[columns[i]] = row[i]
+                  }
+                  results.push(obj)
+                } else {
+                  results.push(row)
+                }
+              }
+            }
             return results
           },
           catch: (cause) => new SqlError({ cause, message: "Failed to execute statement" })
@@ -144,18 +195,41 @@ export const make = (
         executeUnprepared(sql, params) {
           return runTransform(sql, params)
         },
-        executeStream() {
-          return Effect.dieMessage("executeStream not implemented")
+        executeStream(sql, params) {
+          return Stream.fromIterableEffect(Effect.try({
+            *try() {
+              for (const stmt of sqlite3.statements(db, sql)) {
+                let columns: Array<string> | undefined
+                sqlite3.bind_collection(stmt, params as any)
+                while (sqlite3.step(stmt) === WaSqlite.SQLITE_ROW) {
+                  columns = columns ?? sqlite3.column_names(stmt)
+                  const row = sqlite3.row(stmt)
+                  const obj: Record<string, any> = {}
+                  for (let i = 0; i < columns.length; i++) {
+                    obj[columns[i]] = row[i]
+                  }
+                  yield obj
+                }
+              }
+            },
+            catch: (cause) => new SqlError({ cause, message: "Failed to execute statement" })
+          }))
         },
         export: Effect.try({
-          try: () => sqlite3.capi.sqlite3_js_db_export(db.pointer),
+          try: () => sqlite3.serialize(db, "main"),
           catch: (cause) => new SqlError({ cause, message: "Failed to export database" })
-        })
+        }),
+        import(data) {
+          return Effect.try({
+            try: () => sqlite3.deserialize(db, "main", data, data.length, data.length, 1 | 2),
+            catch: (cause) => new SqlError({ cause, message: "Failed to import database" })
+          })
+        }
       })
     })
 
-    const semaphore = yield* _(Effect.makeSemaphore(1))
-    const connection = yield* _(makeConnection)
+    const semaphore = yield* Effect.makeSemaphore(1)
+    const connection = yield* makeConnection
 
     const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
     const transactionAcquirer = Effect.uninterruptibleMask((restore) =>
@@ -184,28 +258,239 @@ export const make = (
       {
         [TypeId]: TypeId as TypeId,
         config: options,
-        export: Effect.flatMap(acquirer, (_) => _.export)
+        reactive: reactivity.stream,
+        reactiveMailbox: reactivity.query,
+        export: semaphore.withPermits(1)(connection.export),
+        import(data: Uint8Array) {
+          return semaphore.withPermits(1)(connection.import(data))
+        }
       }
     )
   })
 
+/**
+ * @category constructor
+ * @since 1.0.0
+ */
+export const make = (
+  options: SqliteClientConfig
+): Effect.Effect<SqliteClient, SqlError, Scope.Scope | Reactivity.Reactivity> =>
+  Effect.gen(function*() {
+    const reactivity = yield* Reactivity.Reactivity
+    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
+    const transformRows = Statement.defaultTransforms(
+      options.transformResultNames!
+    ).array
+    const pending = new Map<number, (effect: Exit.Exit<any, SqlError>) => void>()
+
+    const makeConnection = Effect.gen(function*() {
+      let currentId = 0
+      const scope = yield* Effect.scope
+      const readyDeferred = yield* Deferred.make<void>()
+
+      const worker = yield* options.worker
+      const port = "port" in worker ? worker.port : worker
+      const postMessage = (message: OpfsWorkerMessage, transferables?: ReadonlyArray<any>) =>
+        port.postMessage(message, transferables as any)
+
+      yield* Scope.addFinalizer(scope, Effect.sync(() => postMessage(["close"])))
+
+      const onMessage = (event: any) => {
+        const [id, error, results] = event.data
+        if (id === "ready") {
+          Deferred.unsafeDone(readyDeferred, Exit.void)
+          return
+        } else if (id === "update_hook") {
+          reactivity.unsafeInvalidate({ [error]: [results] })
+          return
+        } else {
+          const resume = pending.get(id)
+          if (!resume) return
+          pending.delete(id)
+          if (error) {
+            resume(Exit.fail(new SqlError({ cause: error as string, message: "Failed to execute statement" })))
+          } else {
+            resume(Exit.succeed(results))
+          }
+        }
+      }
+      port.addEventListener("message", onMessage)
+
+      function onError() {
+        Effect.runFork(ScopedRef.set(connectionRef, makeConnection))
+      }
+      if ("onerror" in worker) {
+        worker.addEventListener("error", onError)
+      }
+
+      yield* Scope.addFinalizer(
+        scope,
+        Effect.sync(() => {
+          worker.removeEventListener("message", onMessage)
+          worker.removeEventListener("error", onError)
+        })
+      )
+
+      yield* Deferred.await(readyDeferred)
+
+      if (options.installReactivityHooks) {
+        postMessage(["update_hook"])
+      }
+
+      const send = (id: number, message: OpfsWorkerMessage, transferables?: ReadonlyArray<any>) =>
+        Effect.async<any, SqlError>((resume) => {
+          pending.set(id, resume)
+          postMessage(message, transferables)
+        })
+
+      const run = (
+        sql: string,
+        params: ReadonlyArray<Statement.Primitive> = [],
+        rowMode: "object" | "array" = "object"
+      ): Effect.Effect<Array<any>, SqlError, never> => {
+        const rows = Effect.withFiberRuntime<[Array<string>, Array<any>], SqlError>((fiber) => {
+          const id = currentId++
+          return send(id, [id, sql, params], fiber.getFiberRef(currentTransferables))
+        })
+        return rowMode === "object"
+          ? Effect.map(rows, extractObject)
+          : Effect.map(rows, extractRows)
+      }
+
+      const runTransform = options.transformResultNames
+        ? (sql: string, params?: ReadonlyArray<Statement.Primitive>) => Effect.map(run(sql, params), transformRows)
+        : run
+
+      return identity<SqliteConnection>({
+        execute(sql, params) {
+          return runTransform(sql, params)
+        },
+        executeRaw(sql, params) {
+          return run(sql, params)
+        },
+        executeValues(sql, params) {
+          return run(sql, params, "array")
+        },
+        executeWithoutTransform(sql, params) {
+          return run(sql, params)
+        },
+        executeUnprepared(sql, params) {
+          return runTransform(sql, params)
+        },
+        executeStream() {
+          return Effect.dieMessage("executeStream not implemented")
+        },
+        export: Effect.suspend(() => {
+          const id = currentId++
+          return send(id, ["export", id])
+        }),
+        import(data) {
+          return Effect.suspend(() => {
+            const id = currentId++
+            return send(id, ["import", id, data], [data.buffer])
+          })
+        }
+      })
+    })
+
+    const connectionRef = yield* ScopedRef.fromAcquire(makeConnection)
+
+    const semaphore = yield* Effect.makeSemaphore(1)
+    const acquirer = semaphore.withPermits(1)(ScopedRef.get(connectionRef))
+    const transactionAcquirer = Effect.uninterruptibleMask((restore) =>
+      Effect.zipRight(
+        Effect.zipRight(
+          restore(semaphore.take(1)),
+          Effect.tap(
+            Effect.scope,
+            (scope) => Scope.addFinalizer(scope, semaphore.release(1))
+          )
+        ),
+        ScopedRef.get(connectionRef)
+      )
+    )
+
+    return Object.assign(
+      Client.make({
+        acquirer,
+        compiler,
+        transactionAcquirer,
+        spanAttributes: [
+          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
+          [Otel.SEMATTRS_DB_SYSTEM, Otel.DBSYSTEMVALUES_SQLITE]
+        ]
+      }) as SqliteClient,
+      {
+        [TypeId]: TypeId as TypeId,
+        config: options,
+        reactive: reactivity.stream,
+        reactiveMailbox: reactivity.query,
+        export: Effect.flatMap(acquirer, (connection) => connection.export),
+        import(data: Uint8Array) {
+          return Effect.flatMap(acquirer, (connection) => connection.import(data))
+        }
+      }
+    )
+  })
+
+function rowToObject(columns: Array<string>, row: Array<any>) {
+  const obj: Record<string, any> = {}
+  for (let i = 0; i < columns.length; i++) {
+    obj[columns[i]] = row[i]
+  }
+  return obj
+}
+const extractObject = (rows: [Array<string>, Array<any>]) => rows[1].map((row) => rowToObject(rows[0], row))
+const extractRows = (rows: [Array<string>, Array<any>]) => rows[1]
+
+/**
+ * @category tranferables
+ * @since 1.0.0
+ */
+export const currentTransferables: FiberRef.FiberRef<ReadonlyArray<Transferable>> = globalValue(
+  "@effect/sql-sqlite-wasm/currentTransferables",
+  () => FiberRef.unsafeMake<ReadonlyArray<Transferable>>([])
+)
+
+/**
+ * @category tranferables
+ * @since 1.0.0
+ */
+export const withTransferables =
+  (transferables: ReadonlyArray<Transferable>) => <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.locally(effect, currentTransferables, transferables)
+
 /**
  * @category layers
  * @since 1.0.0
  */
-export const layerConfig = (
-  config: Config.Config.Wrap<SqliteClientConfig>
-): Layer.Layer<SqliteClient | Client.SqlClient, ConfigError> =>
+export const layerMemoryConfig = (
+  config: Config.Config.Wrap<SqliteClientMemoryConfig>
+): Layer.Layer<SqliteClient | Client.SqlClient, ConfigError | SqlError> =>
   Layer.scopedContext(
     Config.unwrap(config).pipe(
-      Effect.flatMap(make),
+      Effect.flatMap(makeMemory),
       Effect.map((client) =>
         Context.make(SqliteClient, client).pipe(
           Context.add(Client.SqlClient, client)
         )
       )
     )
-  )
+  ).pipe(Layer.provide(Reactivity.layer))
+
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerMemory = (
+  config: SqliteClientMemoryConfig
+): Layer.Layer<SqliteClient | Client.SqlClient, ConfigError | SqlError> =>
+  Layer.scopedContext(
+    Effect.map(makeMemory(config), (client) =>
+      Context.make(SqliteClient, client).pipe(
+        Context.add(Client.SqlClient, client)
+      ))
+  ).pipe(Layer.provide(Reactivity.layer))
 
 /**
  * @category layers
@@ -213,10 +498,28 @@ export const layerConfig = (
  */
 export const layer = (
   config: SqliteClientConfig
-): Layer.Layer<SqliteClient | Client.SqlClient, ConfigError> =>
+): Layer.Layer<SqliteClient | Client.SqlClient, ConfigError | SqlError> =>
   Layer.scopedContext(
     Effect.map(make(config), (client) =>
       Context.make(SqliteClient, client).pipe(
         Context.add(Client.SqlClient, client)
       ))
-  )
+  ).pipe(Layer.provide(Reactivity.layer))
+
+/**
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerConfig = (
+  config: Config.Config.Wrap<SqliteClientConfig>
+): Layer.Layer<SqliteClient | Client.SqlClient, ConfigError | SqlError> =>
+  Layer.scopedContext(
+    Config.unwrap(config).pipe(
+      Effect.flatMap(make),
+      Effect.map((client) =>
+        Context.make(SqliteClient, client).pipe(
+          Context.add(Client.SqlClient, client)
+        )
+      )
+    )
+  ).pipe(Layer.provide(Reactivity.layer))