Function make

packages/sql/sqlite-wasm/src/SqliteClient.ts:300–462

(
  options: SqliteClientConfig
)

 * @since 4.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 = options.transformResultNames ?
      Statement.defaultTransforms(options.transformResultNames).array :
      undefined
    const makeConnection = Effect.gen(function*() {
      let currentId = 0
      const pending = new Map<number, (effect: Exit.Exit<any, SqlError>) => void>()
      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.doneUnsafe(readyDeferred, Exit.void)
          return
        } else if (id === "update_hook") {
          reactivity.invalidateUnsafe({ [error]: [results] })
          return
        } else {
          const resume = pending.get(id)
          if (!resume) return
          pending.delete(id)
          if (error) {
            resume(
              Exit.fail(
                new SqlError({ reason: classifyError(error as string, "Failed to execute statement", "execute") })
              )
            )
          } else {
            resume(Exit.succeed(results))
          }
        }
      }
      port.addEventListener("message", onMessage)

      function onError(cause: Event) {
        const exit = Exit.fail(
          new SqlError({ reason: classifyError(cause, "SQLite WASM worker failed", "worker") })
        )
        const requests = Array.from(pending.values())
        pending.clear()
        for (const resume of requests) {
          resume(exit)
        }
        Effect.runFork(ScopedRef.set(connectionRef, makeConnection))
      }