effect-start 0.23.0 → 0.25.0

package/dist/node/NodeUtils.js

@@ -1,20 +1,23 @@
-import * as NFS from "node:fs/promises";
-import * as NPath from "node:path";
-export const getEntrypoint = () => NPath.dirname(process.argv[1]);
+import * as NFS from "node:fs/promises"
+import * as NPath from "node:path"
+
+export const getEntrypoint = () => NPath.dirname(process.argv[1])
+
 export const findClosestPackageJson = async (path) => {
-    const resolved = NPath.resolve(path);
-    const stat = await NFS.stat(resolved).catch(() => undefined);
-    let dir = stat?.isDirectory() ? resolved : NPath.dirname(resolved);
-    const root = NPath.parse(dir).root;
-    while (dir !== root) {
-        const candidate = NPath.join(dir, "package.json");
-        try {
-            await NFS.access(candidate);
-            return candidate;
-        }
-        catch {
-            dir = NPath.dirname(dir);
-        }
+  const resolved = NPath.resolve(path)
+  const stat = await NFS.stat(resolved).catch(() => undefined)
+  let dir = stat?.isDirectory() ? resolved : NPath.dirname(resolved)
+  const root = NPath.parse(dir).root
+
+  while (dir !== root) {
+    const candidate = NPath.join(dir, "package.json")
+    try {
+      await NFS.access(candidate)
+      return candidate
+    } catch {
+      dir = NPath.dirname(dir)
     }
-    return undefined;
-};
+  }
+
+  return undefined
+}

package/dist/sql/Sql.js

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+
+export class SqlError extends Data.TaggedError("SqlError") {}
+
+export const SqlClient = Context.GenericTag(
+  "effect-start/Sql/SqlClient",
+)

package/dist/sql/bun/index.js

@@ -1,75 +1,142 @@
-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";
+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({
+  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 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 }))));
+  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(`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 TO SAVEPOINT ${name}`)).pipe(Effect.orDie)
+            return yield* exit
+          })
         }
-        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)));
+
+        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

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

package/dist/sql/libsql/index.js

@@ -0,0 +1,156 @@
+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,67 +1,110 @@
-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, {
+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, {
+      })
+      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 [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: () => false,
-}).pipe(Effect.orElseSucceed(() => false));
+  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 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);
+  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)