effect-start 0.25.0 → 0.27.0

package/dist/sql/bun/index.js

@@ -1,142 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FiberRef from "effect/FiberRef"
-import * as GlobalValue from "effect/GlobalValue"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Sql from "../Sql.js"
-
-const errorCode = (error) => {
-  const e = error
-  if (typeof e?.errno === "string") return e.errno
-  return e?.code ?? "UNKNOWN"
-}
-
-const wrapError = (error) =>
-  new Sql.SqlError({
-    code: errorCode(error),
-    message: error instanceof Error ? error.message : String(error),
-    cause: error,
-  })
-
-const wrap = (fn) =>
-  Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError })
-
-const makeValues = (obj, ...columns) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
-}
-
-const currentTransaction = GlobalValue.globalValue(
-  Symbol.for("effect-start/sql/bun/currentTransaction"),
-  () => FiberRef.unsafeMake(Option.none()),
-)
-
-const makeRun =
-  (bunSql) =>
-  (fn) =>
-    Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
-      wrap(() => fn(Option.isSome(txOpt) ? txOpt.value.conn : bunSql)),
-    )
-
-const makeWithTransaction =
-  (bunSql) =>
-  (self) =>
-    Effect.uninterruptibleMask((restore) =>
-      Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-        if (Option.isSome(txOpt)) {
-          const { conn, depth } = txOpt.value
-          const name = `sp_${depth}`
-          return Effect.gen(function* () {
-            yield* wrap(() => conn.unsafe(`SAVEPOINT ${name}`))
-            const exit = yield* Effect.exit(
-              restore(
-                Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 })),
-              ),
-            )
-            if (Exit.isSuccess(exit)) {
-              yield* wrap(() => conn.unsafe(`RELEASE SAVEPOINT ${name}`))
-              return exit.value
-            }
-            yield* wrap(() => conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)).pipe(Effect.orDie)
-            return yield* exit
-          })
-        }
-
-        const runTx = (conn) =>
-          Effect.gen(function* () {
-            yield* wrap(() => conn.unsafe("BEGIN"))
-            const exit = yield* Effect.exit(
-              restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: 1 }))),
-            )
-            if (Exit.isSuccess(exit)) {
-              yield* wrap(() => conn.unsafe("COMMIT"))
-              return exit.value
-            }
-            yield* wrap(() => conn.unsafe("ROLLBACK")).pipe(Effect.orDie)
-            return yield* exit
-          })
-
-        return Effect.matchEffect(
-          wrap(() => bunSql.reserve()),
-          {
-            onFailure: () => runTx(bunSql),
-            onSuccess: (reserved) =>
-              Effect.ensuring(
-                runTx(reserved),
-                Effect.sync(() => reserved.release()),
-              ),
-          },
-        )
-      }),
-    )
-
-export const layer = (
-  config,
-) =>
-  Layer.scoped(
-    Sql.SqlClient,
-    Effect.acquireRelease(
-      Effect.try({
-        try: () => {
-          const bunSql = new Bun.SQL(config)
-          const run = makeRun(bunSql)
-          const use = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError })
-          return Object.assign(
-            (strings, ...values) =>
-              run((conn) => conn(strings, ...values)),
-            {
-              unsafe: (query, values) =>
-                run((conn) => conn.unsafe(query, values)),
-              values: makeValues,
-              withTransaction: makeWithTransaction(bunSql),
-              reserve: Effect.acquireRelease(
-                wrap(() => bunSql.reserve()),
-                (reserved) => Effect.sync(() => reserved.release()),
-              ).pipe(
-                Effect.map(
-                  (reserved) =>
-                    Object.assign(
-                      (strings, ...values) =>
-                        wrap(() => reserved(strings, ...values)),
-                      {
-                        unsafe: (query, values) =>
-                          wrap(() => reserved.unsafe(query, values)),
-                        values: makeValues,
-                      },
-                    ),
-                ),
-              ),
-              close: (options) =>
-                use((bunSql) => bunSql.close(options)),
-              use,
-            },
-          )
-        },
-        catch: wrapError,
-      }),
-      (client) => client.close().pipe(Effect.orDie),
-    ),
-  )

package/dist/sql/index.js

@@ -1 +0,0 @@
-export * as Sql from "./Sql.js"

package/dist/sql/libsql/index.js

@@ -1,156 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FiberRef from "effect/FiberRef"
-import * as GlobalValue from "effect/GlobalValue"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Sql from "../Sql.js"
-
-const wrapError = (error) =>
-  new Sql.SqlError({
-    code: (error)?.code ?? "UNKNOWN",
-    message: error instanceof Error ? error.message : String(error),
-    cause: error,
-  })
-
-const wrap = (fn) =>
-  Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError })
-
-const makeValues = (obj, ...columns) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
-}
-
-const resultSetToRows = (result) => {
-  const { columns, rows } = result
-  return rows.map((row) => {
-    const obj = {}
-    for (let i = 0; i < columns.length; i++) obj[columns[i]] = row[i]
-    return obj
-  })
-}
-
-const buildQuery = (strings, values) => {
-  let sql = strings[0]
-  for (let i = 0; i < values.length; i++) sql += "?" + strings[i + 1]
-  return { sql, args: values }
-}
-
-const loadLibsql = () => import("@libsql/client")
-
-const currentTransaction = GlobalValue.globalValue(
-  Symbol.for("effect-start/sql/libsql/currentTransaction"),
-  () => FiberRef.unsafeMake(Option.none()),
-)
-
-const executeQuery = (
-  client,
-  sql,
-  args,
-) =>
-  wrap(() => client.execute({ sql, args })).pipe(Effect.map(resultSetToRows<T>))
-
-const runQuery = (
-  client,
-  strings,
-  values,
-) => {
-  const { sql, args } = buildQuery(strings, values)
-  return executeQuery(client, sql, args)
-}
-
-const runUnsafe = (
-  client,
-  query,
-  values,
-) =>
-  executeQuery(client, query, values ?? [])
-
-const exec = (client, sql) =>
-  wrap(() => client.execute(sql))
-
-const makeWithTransaction =
-  (client) =>
-  (self) =>
-    Effect.uninterruptibleMask((restore) =>
-      Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-        if (Option.isSome(txOpt)) {
-          const { depth } = txOpt.value
-          const name = `sp_${depth}`
-          return Effect.gen(function* () {
-            yield* exec(client, `SAVEPOINT ${name}`)
-            const exit = yield* Effect.exit(
-              restore(
-                Effect.locally(self, currentTransaction, Option.some({ depth: depth + 1 })),
-              ),
-            )
-            if (Exit.isSuccess(exit)) {
-              yield* exec(client, `RELEASE SAVEPOINT ${name}`)
-              return exit.value
-            }
-            yield* exec(client, `ROLLBACK TO SAVEPOINT ${name}`).pipe(Effect.orDie)
-            return yield* exit
-          })
-        }
-
-        return Effect.gen(function* () {
-          yield* exec(client, "BEGIN")
-          const exit = yield* Effect.exit(
-            restore(Effect.locally(self, currentTransaction, Option.some({ depth: 1 }))),
-          )
-          if (Exit.isSuccess(exit)) {
-            yield* exec(client, "COMMIT")
-            return exit.value
-          }
-          yield* exec(client, "ROLLBACK").pipe(Effect.orDie)
-          return yield* exit
-        })
-      }),
-    )
-
-export const layer = (config) =>
-  Layer.scoped(
-    Sql.SqlClient,
-    Effect.acquireRelease(
-      wrap(() => loadLibsql()).pipe(
-        Effect.map((libsql) => {
-          const client = libsql.createClient(config)
-          const use = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(client)), catch: wrapError })
-          return Object.assign(
-            (strings, ...values) =>
-              runQuery(client, strings, values),
-            {
-              unsafe: (query, values) =>
-                runUnsafe(client, query, values),
-              values: makeValues,
-              withTransaction: makeWithTransaction(client),
-              reserve: Effect.acquireRelease(
-                wrap(() => loadLibsql()).pipe(
-                  Effect.map((m) => m.createClient(config)),
-                ),
-                (reserved) => Effect.sync(() => reserved.close()),
-              ).pipe(
-                Effect.map(
-                  (reserved) =>
-                    Object.assign(
-                      (strings, ...values) =>
-                        runQuery(reserved, strings, values),
-                      {
-                        unsafe: (query, values) =>
-                          runUnsafe(reserved, query, values),
-                        values: makeValues,
-                      },
-                    ),
-                ),
-              ),
-              close: () => Effect.sync(() => client.close()),
-              use,
-            },
-          )
-        }),
-      ),
-      (client) => client.close().pipe(Effect.orDie),
-    ),
-  )

package/dist/sql/mssql/docker.js

@@ -1,110 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Stream from "effect/Stream"
-
-import * as System from "../../System.js"
-import * as BunChildProcessSpawner from "../../bun/BunChildProcessSpawner.js"
-
-const PORT = 1433
-const PASSWORD = "TestPass123"
-const CONTAINER = "effect-start-mssql"
-
-const exec = (
-  ...args
-) =>
-  Effect.scoped(
-    Effect.gen(function* () {
-      const handle = yield* System.spawn("docker", args, {
-        stdout: "ignore",
-        stderr: "inherit",
-      })
-      return yield* handle.exitCode
-    }),
-  )
-
-const execStdout = (
-  ...args
-) =>
-  Effect.scoped(
-    Effect.gen(function* () {
-      const handle = yield* System.spawn("docker", args, {
-        stdout: "pipe",
-        stderr: "inherit",
-      })
-      const [stdout] = yield* Effect.all(
-        [handle.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString), handle.exitCode],
-        { concurrency: 2 },
-      )
-      return stdout
-    }),
-  )
-
-const containerRunning = execStdout("ps", "-q", "-f", `name=${CONTAINER}`).pipe(
-  Effect.map((stdout) => stdout.trim().length > 0),
-)
-
-const removeContainer = exec("rm", "-f", CONTAINER).pipe(Effect.ignore)
-
-const loadMssql = () => import("mssql")
-
-const canConnect = Effect.tryPromise({
-  try: async () => {
-    const { ConnectionPool } = await loadMssql()
-    const pool = new ConnectionPool({
-      server: "localhost",
-      user: "sa",
-      password: PASSWORD,
-      port: PORT,
-      options: { encrypt: true, trustServerCertificate: true, connectTimeout: 3000 },
-    })
-    await pool.connect()
-    await pool.close()
-    return true
-  },
-  catch: () => /** @type {const} */ false,
-}).pipe(Effect.orElseSucceed(() => false))
-
-const waitReady = Effect.gen(function* () {
-  const deadline = Date.now() + 60_000
-  while (Date.now() < deadline) {
-    if (yield* canConnect) return
-    yield* Effect.sleep("2 seconds")
-  }
-  return yield* Effect.fail(new Error("Timed out waiting for MSSQL"))
-})
-
-const program = Effect.gen(function* () {
-  if (yield* containerRunning) {
-    yield* Effect.log("MSSQL container already running")
-    return
-  }
-
-  yield* removeContainer
-
-  yield* Effect.log("Starting MSSQL container...")
-  const code = yield* exec(
-    "run",
-    "-d",
-    "--name",
-    CONTAINER,
-    "-p",
-    `${PORT}:1433`,
-    "-e",
-    "ACCEPT_EULA=Y",
-    "-e",
-    `MSSQL_SA_PASSWORD=${PASSWORD}`,
-    "mcr.microsoft.com/azure-sql-edge",
-  )
-  if (code !== 0) {
-    return yield* Effect.fail(new Error(`docker run exited with code ${code}`))
-  }
-
-  yield* waitReady
-  yield* Effect.log("MSSQL ready")
-})
-
-const run = (effect) =>
-  Effect.runPromise(Effect.provide(effect, BunChildProcessSpawner.layer))
-
-export const start = () => run(program)
-
-export const stop = () => run(removeContainer)

package/dist/sql/mssql/index.js

@@ -1,194 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as FiberRef from "effect/FiberRef"
-import * as GlobalValue from "effect/GlobalValue"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Sql from "../Sql.js"
-
-const wrapError = (error) =>
-  new Sql.SqlError({
-    code:
-      (error)?.code ??
-      ((error)?.number != null ? String((error).number) : "UNKNOWN"),
-    message: error instanceof Error ? error.message : String(error),
-    cause: error,
-  })
-
-const makeValues = (obj, ...columns) => {
-  const items = Array.isArray(obj) ? obj : [obj]
-  const cols = columns.length > 0 ? columns : Object.keys(items[0])
-  return { value: items, columns: cols }
-}
-
-const buildQuery = (strings, values) => {
-  let text = strings[0]
-  for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
-  return { text, values }
-}
-
-const addInputs = (request, values) => {
-  for (let i = 0; i < values.length; i++) {
-    request.input(`p${i + 1}`, values[i])
-  }
-}
-
-const loadMssql = () => import("mssql")
-
-const currentTransaction = GlobalValue.globalValue(
-  Symbol.for("effect-start/sql/mssql/currentTransaction"),
-  () => FiberRef.unsafeMake(Option.none()),
-)
-
-const executeQuery = (
-  pool,
-  text,
-  values,
-) =>
-  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
-    addInputs(request, values)
-    return Effect.tryPromise({
-      try: () => request.query(text),
-      catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
-
-const runQuery = (
-  pool,
-  strings,
-  values,
-) => {
-  const { text, values: params } = buildQuery(strings, values)
-  return executeQuery(pool, text, params)
-}
-
-const runUnsafe = (
-  pool,
-  query,
-  values,
-) =>
-  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
-    if (values) addInputs(request, values)
-    return Effect.tryPromise({
-      try: () => request.query(query),
-      catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
-
-const makeWithTransaction =
-  (pool) =>
-  (self) =>
-    Effect.uninterruptibleMask((restore) =>
-      Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
-        if (Option.isSome(txOpt)) {
-          const { transaction, depth } = txOpt.value
-          const name = `sp_${depth}`
-          return Effect.gen(function* () {
-            const req = transaction.request()
-            yield* Effect.tryPromise({
-              try: () => req.query(`SAVE TRANSACTION ${name}`),
-              catch: wrapError,
-            })
-            const exit = yield* Effect.exit(
-              restore(
-                Effect.locally(
-                  self,
-                  currentTransaction,
-                  Option.some({ transaction, depth: depth + 1 }),
-                ),
-              ),
-            )
-            if (Exit.isSuccess(exit)) {
-              return exit.value
-            }
-            const rbReq = transaction.request()
-            yield* Effect.tryPromise({
-              try: () => rbReq.query(`ROLLBACK TRANSACTION ${name}`),
-              catch: wrapError,
-            }).pipe(Effect.orDie)
-            return yield* exit
-          })
-        }
-
-        return Effect.gen(function* () {
-          const transaction = pool.transaction()
-          yield* Effect.tryPromise({ try: () => transaction.begin(), catch: wrapError })
-          const exit = yield* Effect.exit(
-            restore(
-              Effect.locally(self, currentTransaction, Option.some({ transaction, depth: 1 })),
-            ),
-          )
-          if (Exit.isSuccess(exit)) {
-            yield* Effect.tryPromise({ try: () => transaction.commit(), catch: wrapError })
-            return exit.value
-          }
-          yield* Effect.tryPromise({ try: () => transaction.rollback(), catch: wrapError }).pipe(
-            Effect.orDie,
-          )
-          return yield* exit
-        })
-      }),
-    )
-
-export const layer = (config) =>
-  Layer.scoped(
-    Sql.SqlClient,
-    Effect.acquireRelease(
-      Effect.tryPromise({
-        try: async () => {
-          const mssql = await loadMssql()
-          const pool = await new mssql.ConnectionPool(config).connect()
-          return { mssql, pool }
-        },
-        catch: wrapError,
-      }).pipe(
-        Effect.map(({ mssql, pool }) => {
-          const use = (fn) =>
-            Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError })
-          return Object.assign(
-            (strings, ...values) =>
-              runQuery(pool, strings, values),
-            {
-              unsafe: (query, values) =>
-                runUnsafe(pool, query, values),
-              values: makeValues,
-              withTransaction: makeWithTransaction(pool),
-              reserve: Effect.acquireRelease(
-                Effect.tryPromise({
-                  try: () =>
-                    new mssql.ConnectionPool({
-                      ...config,
-                      pool: { max: 1, min: 1 },
-                    }).connect(),
-                  catch: wrapError,
-                }),
-                (reserved) =>
-                  Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(
-                    Effect.asVoid,
-                    Effect.orDie,
-                  ),
-              ).pipe(
-                Effect.map(
-                  (reserved) =>
-                    Object.assign(
-                      (strings, ...values) =>
-                        runQuery(reserved, strings, values),
-                      {
-                        unsafe: (query, values) =>
-                          runUnsafe(reserved, query, values),
-                        values: makeValues,
-                      },
-                    ),
-                ),
-              ),
-              close: () => use((pool) => pool.close()),
-              use,
-            },
-          )
-        }),
-      ),
-      (client) => client.close().pipe(Effect.orDie),
-    ),
-  )

package/dist/testing/TestLogger.js

@@ -1,42 +0,0 @@
-import * as Cause from "effect/Cause"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as FiberRef from "effect/FiberRef"
-import * as HashSet from "effect/HashSet"
-import * as Layer from "effect/Layer"
-import * as Logger from "effect/Logger"
-import * as MutableRef from "effect/MutableRef"
-import * as Ref from "effect/Ref"
-
-export class TestLogger extends Context.Tag("effect-start/TestLogger")() {}
-
-export function layer() {
-  return Layer.effect(
-    TestLogger,
-    Effect.gen(function* () {
-      const messages = yield* Ref.make([])
-      const mutableRef = (messages).ref
-
-      const customLogger = Logger.make(({ message, logLevel, cause }) => {
-        const causeStr = !Cause.isEmpty(cause)
-          ? ` ${Cause.pretty(cause, { renderErrorCause: true })}`
-          : ""
-        MutableRef.update(mutableRef, (msgs) => [
-          ...msgs,
-          `[${logLevel._tag}] ${String(message)}${causeStr}`,
-        ])
-      })
-
-      yield* FiberRef.update(FiberRef.currentLoggers, (loggers) =>
-        HashSet.add(HashSet.remove(loggers, Logger.defaultLogger), customLogger),
-      )
-
-      return { messages }
-    }),
-  )
-}
-
-export const messages = Effect.gen(function* () {
-  const logger = yield* TestLogger
-  return yield* Ref.get(logger.messages)
-})

package/dist/testing/index.js

@@ -1,2 +0,0 @@
-export * as TestLogger from "./TestLogger.js"
-export * from "./utils.js"