/**
* @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)
)
)
)
)