/** * @since 1.0.0 */ import * as Client from "@effect/sql/Client" import type { Connection } from "@effect/sql/Connection" import { SqlError } from "@effect/sql/Error" import * as Statement from "@effect/sql/Statement" import * as Sqlite from "@op-engineering/op-sqlite" import * as Otel from "@opentelemetry/semantic-conventions" import * as Config from "effect/Config" import type { ConfigError } from "effect/ConfigError" import * as Context from "effect/Context" import * as Effect from "effect/Effect" import * as FiberRef from "effect/FiberRef" import { identity } from "effect/Function" import { globalValue } from "effect/GlobalValue" import * as Layer from "effect/Layer" import * as Queue from "effect/Queue" import * as Scope from "effect/Scope" import * as Stream from "effect/Stream" /** * @category type ids * @since 1.0.0 */ export const TypeId: unique symbol = Symbol.for("@effect/sql-sqlite-react-native/Client") /** * @category type ids * @since 1.0.0 */ export type TypeId = typeof TypeId /** * @category models * @since 1.0.0 */ export interface SqliteClient extends Client.Client { readonly [TypeId]: TypeId readonly config: SqliteClientConfig readonly reactive: ( statement: Statement.Statement, fireOn: ReadonlyArray<{ readonly table: string readonly ids?: ReadonlyArray }> ) => Stream.Stream, SqlError> /** Not supported in sqlite */ readonly updateValues: never } /** * @category tags * @since 1.0.0 */ export const SqliteClient = Context.GenericTag("@effect/sql-sqlite-react-native/Client") /** * @category models * @since 1.0.0 */ export interface SqliteClientConfig { readonly filename: string readonly location?: string | undefined readonly encryptionKey?: string | undefined readonly spanAttributes?: Record | undefined readonly transformResultNames?: ((str: string) => string) | undefined readonly transformQueryNames?: ((str: string) => string) | undefined } /** * @category fiber refs * @since 1.0.0 */ export const asyncQuery: FiberRef.FiberRef = globalValue( "@effect/sql-sqlite-react-native/Client/asyncQuery", () => FiberRef.unsafeMake(false) ) /** * @category fiber refs * @since 1.0.0 */ export const withAsyncQuery = (effect: Effect.Effect) => Effect.locally(effect, asyncQuery, true) interface SqliteConnection extends Connection { readonly reactive: ( statement: Statement.Statement, fireOn: ReadonlyArray<{ readonly table: string readonly ids?: ReadonlyArray }> ) => Stream.Stream, SqlError> } /** * @category constructor * @since 1.0.0 */ export const make = ( options: SqliteClientConfig ): Effect.Effect => Effect.gen(function*(_) { const clientOptions: Parameters[0] = { name: options.filename } if (options.location) { clientOptions.location = options.location } if (options.encryptionKey) { clientOptions.encryptionKey = options.encryptionKey } const compiler = Statement.makeCompilerSqlite(options.transformQueryNames) const transformRows = Statement.defaultTransforms( options.transformResultNames! ).array const handleError = (error: any) => new SqlError({ error }) const makeConnection = Effect.gen(function*(_) { const db = Sqlite.open(clientOptions) yield* _(Effect.addFinalizer(() => Effect.sync(() => db.close()))) const run = ( sql: string, params: ReadonlyArray = [] ) => Effect.withFiberRuntime, SqlError>((fiber) => { if (fiber.getFiberRef(asyncQuery)) { return Effect.map( Effect.tryPromise({ try: () => db.executeAsync(sql, params as Array), catch: handleError }), (result) => result.rows?._array ?? [] ) } return Effect.try({ try: () => db.execute(sql, params as Array).rows?._array ?? [], catch: handleError }) }) const runTransform = options.transformResultNames ? (sql: string, params?: ReadonlyArray) => Effect.map(run(sql, params), transformRows) : run return identity({ execute(sql, params) { return runTransform(sql, params) }, executeValues(sql, params) { return Effect.map(run(sql, params), (results) => { if (results.length === 0) { return [] } const columns = Object.keys(results[0]) return results.map((row) => columns.map((column) => row[column])) }) }, executeWithoutTransform(sql, params) { return run(sql, params) }, executeRaw(sql, params) { return runTransform(sql, params) }, executeStream() { return Effect.dieMessage("executeStream not implemented") }, reactive( statement: Statement.Statement, fireOn: ReadonlyArray<{ readonly table: string readonly ids?: ReadonlyArray }> ) { const [query, params] = statement.compile() return Queue.sliding>(1).pipe( Effect.tap((queue) => this.execute(query, params).pipe( Effect.flatMap((rows) => queue.offer(rows)) ) ), Effect.tap((queue) => Effect.acquireRelease( Effect.try({ try: () => db.reactiveExecute({ query, arguments: params as any, fireOn: fireOn as any, callback(data) { queue.unsafeOffer(data.rows) } }), catch: handleError }), (cancel) => Effect.sync(cancel) ) ), Effect.map(Stream.fromQueue), Stream.unwrapScoped ) } }) }) const semaphore = yield* _(Effect.makeSemaphore(1)) const connection = yield* _(makeConnection) const acquirer = semaphore.withPermits(1)(Effect.succeed(connection)) const transactionAcquirer = Effect.uninterruptibleMask((restore) => Effect.as( Effect.zipRight( restore(semaphore.take(1)), Effect.tap( Effect.scope, (scope) => Scope.addFinalizer(scope, semaphore.release(1)) ) ), connection ) ) 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, config: options, reactive( statement: Statement.Statement, fireOn: ReadonlyArray<{ readonly table: string readonly ids?: ReadonlyArray }> ) { return Stream.unwrap(Effect.map( acquirer, (connection) => connection.reactive(statement, fireOn) )) } } ) }) /** * @category layers * @since 1.0.0 */ export const layer = ( config: Config.Config.Wrap ): Layer.Layer => Layer.scopedContext( Config.unwrap(config).pipe( Effect.flatMap(make), Effect.map((client) => Context.make(SqliteClient, client).pipe( Context.add(Client.Client, client) ) ) ) )