saeeol 1.3.0 → 1.3.1

package/test/effect/app-runtime-logger.test.ts

@@ -0,0 +1,98 @@
+import { expect } from "bun:test"
+import { Context, Effect, Layer, Logger } from "effect"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { EffectBridge } from "@/effect/bridge"
+import { InstanceRef } from "../../src/effect/instance-ref"
+import * as EffectLogger from "@saeeol/core/effect/logger"
+import { makeRuntime } from "../../src/effect/run-service"
+import { provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(CrossSpawnSpawner.defaultLayer)
+
+function check(loggers: ReadonlySet<Logger.Logger<unknown, any>>) {
+  return {
+    defaultLogger: loggers.has(Logger.defaultLogger),
+    tracerLogger: loggers.has(Logger.tracerLogger),
+    effectLogger: loggers.has(EffectLogger.logger),
+    size: loggers.size,
+  }
+}
+
+it.live("makeRuntime installs EffectLogger through Observability.layer", () =>
+  Effect.gen(function* () {
+    class Dummy extends Context.Service<Dummy, { readonly current: () => Effect.Effect<ReturnType<typeof check>> }>()(
+      "@test/Dummy",
+    ) {}
+
+    const layer = Layer.effect(
+      Dummy,
+      Effect.gen(function* () {
+        return Dummy.of({
+          current: () => Effect.map(Effect.service(Logger.CurrentLoggers), check),
+        })
+      }),
+    )
+
+    const current = yield* Effect.promise(() => makeRuntime(Dummy, layer).runPromise((svc) => svc.current()))
+
+    expect(current.effectLogger).toBe(true)
+    expect(current.defaultLogger).toBe(false)
+  }),
+)
+
+it.live("AppRuntime also installs EffectLogger through Observability.layer", () =>
+  Effect.gen(function* () {
+    const current = yield* Effect.promise(() =>
+      AppRuntime.runPromise(Effect.map(Effect.service(Logger.CurrentLoggers), check)),
+    )
+
+    expect(current.effectLogger).toBe(true)
+    expect(current.defaultLogger).toBe(false)
+  }),
+)
+
+it.live("AppRuntime attaches InstanceRef from ALS", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+    const current = yield* Effect.promise(() =>
+      AppRuntime.runPromise(
+        Effect.gen(function* () {
+          return (yield* InstanceRef)?.directory
+        }),
+      ),
+    ).pipe(provideInstance(dir))
+
+    expect(current).toBe(dir)
+  }),
+)
+
+it.live("EffectBridge preserves logger and instance context across async boundaries", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+    const result = yield* Effect.promise(() =>
+      AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const bridge = yield* EffectBridge.make()
+          return yield* Effect.promise(() =>
+            Promise.resolve().then(() =>
+              bridge.promise(
+                Effect.gen(function* () {
+                  return {
+                    directory: (yield* InstanceRef)?.directory,
+                    ...check(yield* Effect.service(Logger.CurrentLoggers)),
+                  }
+                }),
+              ),
+            ),
+          )
+        }),
+      ),
+    ).pipe(provideInstance(dir))
+
+    expect(result.directory).toBe(dir)
+    expect(result.effectLogger).toBe(true)
+    expect(result.defaultLogger).toBe(false)
+  }),
+)

package/test/effect/config-service.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect } from "bun:test"
+import { Config, ConfigProvider, Context, Effect, Layer, Option } from "effect"
+import { ConfigService } from "../../src/effect/config-service"
+import { it } from "../lib/effect"
+
+class TestConfig extends ConfigService.Service<TestConfig>()("@test/ConfigService", {
+  name: Config.string("NAME"),
+  token: Config.string("TOKEN").pipe(Config.option),
+  port: Config.number("PORT").pipe(Config.withDefault(3000)),
+}) {}
+
+const fromConfig = (input: Record<string, unknown>) =>
+  TestConfig.defaultLayer.pipe(Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown(input))))
+
+const readConfig = TestConfig.useSync((config) => config)
+
+describe("ConfigService", () => {
+  it.effect("defaultLayer parses values from the active ConfigProvider", () =>
+    Effect.gen(function* () {
+      const config = yield* readConfig.pipe(
+        Effect.provide(
+          fromConfig({
+            NAME: "kit",
+            TOKEN: "secret",
+            PORT: "4096",
+          }),
+        ),
+      )
+
+      expect(config.name).toBe("kit")
+      expect(config.token).toEqual(Option.some("secret"))
+      expect(config.port).toBe(4096)
+    }),
+  )
+
+  it.effect("defaultLayer applies Effect Config defaults", () =>
+    Effect.gen(function* () {
+      const config = yield* readConfig.pipe(Effect.provide(fromConfig({ NAME: "kit" })))
+
+      expect(config.name).toBe("kit")
+      expect(config.token).toEqual(Option.none())
+      expect(config.port).toBe(3000)
+    }),
+  )
+
+  it.effect("layer provides an already parsed service value", () =>
+    Effect.gen(function* () {
+      const config = yield* readConfig.pipe(
+        Effect.provide(
+          TestConfig.layer({
+            name: "direct",
+            token: Option.some("parsed"),
+            port: 9000,
+          }),
+        ),
+      )
+
+      expect(config).toEqual({
+        name: "direct",
+        token: Option.some("parsed"),
+        port: 9000,
+      } satisfies Context.Service.Shape<typeof TestConfig>)
+    }),
+  )
+})

package/test/effect/instance-state.test.ts

@@ -0,0 +1,394 @@
+import { afterEach, expect } from "bun:test"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { $ } from "bun"
+import { Context, Deferred, Duration, Effect, Exit, Fiber, Layer } from "effect"
+import { InstanceState } from "@/effect/instance-state"
+import { InstanceStore } from "../../src/project/instance-store"
+import { Instance } from "../../src/project/instance"
+import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(CrossSpawnSpawner.defaultLayer)
+
+const access = <A, E>(state: InstanceState.InstanceState<A, E>, dir: string) =>
+  InstanceState.get(state).pipe(provideInstance(dir))
+
+const tmpdirGitScoped = Effect.gen(function* () {
+  const dir = yield* tmpdirScoped({ git: true })
+  yield* Effect.promise(() => $`git commit --allow-empty --amend -m ${`root commit ${dir}`}`.cwd(dir).quiet())
+  return dir
+})
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+it.live("InstanceState caches values per directory", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped()
+    let n = 0
+    const state = yield* InstanceState.make(() => Effect.sync(() => ({ n: ++n })))
+
+    const a = yield* access(state, dir)
+    const b = yield* access(state, dir)
+
+    expect(a).toBe(b)
+    expect(n).toBe(1)
+  }),
+)
+
+it.live("InstanceState isolates directories", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirScoped()
+    const two = yield* tmpdirScoped()
+    let n = 0
+    const state = yield* InstanceState.make((dir) => Effect.sync(() => ({ dir, n: ++n })))
+
+    const a = yield* access(state, one)
+    const b = yield* access(state, two)
+    const c = yield* access(state, one)
+
+    expect(a).toBe(c)
+    expect(a).not.toBe(b)
+    expect(n).toBe(2)
+  }),
+)
+
+it.live("InstanceState invalidates on reload", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped()
+    const seen: string[] = []
+    let n = 0
+    const state = yield* InstanceState.make(() =>
+      Effect.acquireRelease(
+        Effect.sync(() => ({ n: ++n })),
+        (value) =>
+          Effect.sync(() => {
+            seen.push(String(value.n))
+          }),
+      ),
+    )
+
+    const a = yield* access(state, dir)
+    yield* Effect.promise(() => InstanceStore.reloadInstance({ directory: dir }))
+    const b = yield* access(state, dir)
+
+    expect(a).not.toBe(b)
+    expect(seen).toEqual(["1"])
+  }),
+)
+
+it.live("InstanceState invalidates on disposeAll", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirScoped()
+    const two = yield* tmpdirScoped()
+    const seen: string[] = []
+    const state = yield* InstanceState.make((ctx) =>
+      Effect.acquireRelease(
+        Effect.sync(() => ({ dir: ctx.directory })),
+        (value) =>
+          Effect.sync(() => {
+            seen.push(value.dir)
+          }),
+      ),
+    )
+
+    yield* access(state, one)
+    yield* access(state, two)
+    yield* Effect.promise(disposeAllInstances)
+
+    expect(seen.sort()).toEqual([one, two].sort())
+  }),
+)
+
+it.live("InstanceState.get reads the current directory lazily", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirScoped()
+    const two = yield* tmpdirScoped()
+
+    interface Api {
+      readonly get: () => Effect.Effect<string>
+    }
+
+    class Test extends Context.Service<Test, Api>()("@test/InstanceStateLazy") {
+      static readonly layer = Layer.effect(
+        Test,
+        Effect.gen(function* () {
+          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+          const get = InstanceState.get(state)
+
+          return Test.of({
+            get: Effect.fn("Test.get")(function* () {
+              return yield* get
+            }),
+          })
+        }),
+      )
+    }
+
+    yield* Effect.gen(function* () {
+      const a = yield* Test.use((svc) => svc.get()).pipe(provideInstance(one))
+      const b = yield* Test.use((svc) => svc.get()).pipe(provideInstance(two))
+
+      expect(a).toBe(one)
+      expect(b).toBe(two)
+    }).pipe(Effect.provide(Test.layer))
+  }),
+)
+
+it.live("InstanceState preserves directory across async boundaries", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirGitScoped
+    const two = yield* tmpdirGitScoped
+    const three = yield* tmpdirGitScoped
+
+    interface Api {
+      readonly get: () => Effect.Effect<{ directory: string; worktree: string; project: string }>
+    }
+
+    class Test extends Context.Service<Test, Api>()("@test/InstanceStateAsync") {
+      static readonly layer = Layer.effect(
+        Test,
+        Effect.gen(function* () {
+          const state = yield* InstanceState.make((ctx) =>
+            Effect.sync(() => ({
+              directory: ctx.directory,
+              worktree: ctx.worktree,
+              project: ctx.project.id,
+            })),
+          )
+
+          return Test.of({
+            get: Effect.fn("Test.get")(function* () {
+              yield* Effect.promise(() => Bun.sleep(1))
+              yield* Effect.sleep(Duration.millis(1))
+              for (let i = 0; i < 100; i++) {
+                yield* Effect.yieldNow
+              }
+              for (let i = 0; i < 100; i++) {
+                yield* Effect.promise(() => Promise.resolve())
+              }
+              yield* Effect.sleep(Duration.millis(2))
+              yield* Effect.promise(() => Bun.sleep(1))
+              return yield* InstanceState.get(state)
+            }),
+          })
+        }),
+      )
+    }
+
+    yield* Effect.gen(function* () {
+      const [a, b, c] = yield* Effect.all(
+        [one, two, three].map((dir) => Test.use((svc) => svc.get()).pipe(provideInstance(dir))),
+        { concurrency: "unbounded" },
+      )
+
+      expect(a).toEqual({ directory: one, worktree: one, project: a.project })
+      expect(b).toEqual({ directory: two, worktree: two, project: b.project })
+      expect(c).toEqual({ directory: three, worktree: three, project: c.project })
+      expect(a.project).not.toBe(b.project)
+      expect(a.project).not.toBe(c.project)
+      expect(b.project).not.toBe(c.project)
+    }).pipe(Effect.provide(Test.layer))
+  }),
+)
+
+it.live("InstanceState survives high-contention concurrent access", () =>
+  Effect.gen(function* () {
+    const dirs = yield* Effect.all(
+      Array.from({ length: 20 }, () => tmpdirScoped()),
+      { concurrency: "unbounded" },
+    )
+
+    interface Api {
+      readonly get: () => Effect.Effect<string>
+    }
+
+    class Test extends Context.Service<Test, Api>()("@test/HighContention") {
+      static readonly layer = Layer.effect(
+        Test,
+        Effect.gen(function* () {
+          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+
+          return Test.of({
+            get: Effect.fn("Test.get")(function* () {
+              for (let i = 0; i < 10; i++) {
+                yield* Effect.promise(() => Bun.sleep(Math.random() * 3))
+                yield* Effect.yieldNow
+                yield* Effect.promise(() => Promise.resolve())
+              }
+              return yield* InstanceState.get(state)
+            }),
+          })
+        }),
+      )
+    }
+
+    yield* Effect.gen(function* () {
+      const results = yield* Effect.all(
+        dirs.map((dir) => Test.use((svc) => svc.get()).pipe(provideInstance(dir))),
+        { concurrency: "unbounded" },
+      )
+
+      expect(results).toEqual(dirs)
+    }).pipe(Effect.provide(Test.layer))
+  }),
+)
+
+it.live("InstanceState correct after interleaved init and dispose", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirScoped()
+    const two = yield* tmpdirScoped()
+
+    interface Api {
+      readonly get: () => Effect.Effect<string>
+    }
+
+    class Test extends Context.Service<Test, Api>()("@test/InterleavedDispose") {
+      static readonly layer = Layer.effect(
+        Test,
+        Effect.gen(function* () {
+          const state = yield* InstanceState.make((ctx) =>
+            Effect.promise(async () => {
+              await Bun.sleep(5)
+              return ctx.directory
+            }),
+          )
+
+          return Test.of({
+            get: Effect.fn("Test.get")(function* () {
+              return yield* InstanceState.get(state)
+            }),
+          })
+        }),
+      )
+    }
+
+    yield* Effect.gen(function* () {
+      const a = yield* Test.use((svc) => svc.get()).pipe(provideInstance(one))
+      expect(a).toBe(one)
+
+      const [, b] = yield* Effect.all(
+        [
+          Effect.promise(() => InstanceStore.reloadInstance({ directory: one })),
+          Test.use((svc) => svc.get()).pipe(provideInstance(two)),
+        ],
+        { concurrency: "unbounded" },
+      )
+      expect(b).toBe(two)
+
+      const c = yield* Test.use((svc) => svc.get()).pipe(provideInstance(one))
+      expect(c).toBe(one)
+    }).pipe(Effect.provide(Test.layer))
+  }),
+)
+
+it.live("InstanceState mutation in one directory does not leak to another", () =>
+  Effect.gen(function* () {
+    const one = yield* tmpdirScoped()
+    const two = yield* tmpdirScoped()
+    const state = yield* InstanceState.make(() => Effect.sync(() => ({ count: 0 })))
+
+    const s1 = yield* access(state, one)
+    s1.count = 42
+
+    const s2 = yield* access(state, two)
+    expect(s2.count).toBe(0)
+
+    const s1again = yield* access(state, one)
+    expect(s1again.count).toBe(42)
+    expect(s1again).toBe(s1)
+  }),
+)
+
+it.live("InstanceState dedupes concurrent lookups", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped()
+    let n = 0
+    const state = yield* InstanceState.make(() =>
+      Effect.promise(async () => {
+        n += 1
+        await Bun.sleep(10)
+        return { n }
+      }),
+    )
+
+    const [a, b] = yield* Effect.all([access(state, dir), access(state, dir)], { concurrency: "unbounded" })
+    expect(a).toBe(b)
+    expect(n).toBe(1)
+  }),
+)
+
+it.live("InstanceState survives deferred resume from the same instance context", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+
+    interface Api {
+      readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
+    }
+
+    class Test extends Context.Service<Test, Api>()("@test/DeferredResume") {
+      static readonly layer = Layer.effect(
+        Test,
+        Effect.gen(function* () {
+          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+
+          return Test.of({
+            get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
+              yield* Deferred.await(gate)
+              return yield* InstanceState.get(state)
+            }),
+          })
+        }),
+      )
+    }
+
+    yield* Effect.gen(function* () {
+      const gate = yield* Deferred.make<void>()
+      const fiber = yield* Test.use((svc) => svc.get(gate)).pipe(provideInstance(dir), Effect.forkScoped)
+
+      yield* Deferred.succeed(gate, undefined).pipe(provideInstance(dir))
+      const exit = yield* Fiber.await(fiber)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+      if (Exit.isSuccess(exit)) expect(exit.value).toBe(dir)
+    }).pipe(Effect.provide(Test.layer))
+  }),
+)
+
+it.live("InstanceState survives deferred resume outside ALS when InstanceRef is set", () =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+
+    interface Api {
+      readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
+    }
+
+    class Test extends Context.Service<Test, Api>()("@test/DeferredResumeOutside") {
+      static readonly layer = Layer.effect(
+        Test,
+        Effect.gen(function* () {
+          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+
+          return Test.of({
+            get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
+              yield* Deferred.await(gate)
+              return yield* InstanceState.get(state)
+            }),
+          })
+        }),
+      )
+    }
+
+    yield* Effect.gen(function* () {
+      const gate = yield* Deferred.make<void>()
+      const fiber = yield* Test.use((svc) => svc.get(gate)).pipe(provideInstance(dir), Effect.forkScoped)
+
+      yield* Deferred.succeed(gate, undefined)
+      const exit = yield* Fiber.await(fiber)
+
+      expect(Exit.isSuccess(exit)).toBe(true)
+      if (Exit.isSuccess(exit)) expect(exit.value).toBe(dir)
+    }).pipe(Effect.provide(Test.layer))
+  }),
+)

package/test/effect/run-service.test.ts

@@ -0,0 +1,89 @@
+import { expect } from "bun:test"
+import { Effect, Layer, Context } from "effect"
+import { InstanceRef } from "../../src/effect/instance-ref"
+import { makeRuntime } from "../../src/effect/run-service"
+import { ProjectID } from "../../src/project/schema"
+import { it } from "../lib/effect"
+
+class Shared extends Context.Service<Shared, { readonly id: number }>()("@test/Shared") {}
+const testDirectory = "/tmp/saeeol-test"
+
+it.live("makeRuntime shares dependent layers through the shared memo map", () =>
+  Effect.gen(function* () {
+    let n = 0
+
+    const shared = Layer.effect(
+      Shared,
+      Effect.sync(() => {
+        n += 1
+        return Shared.of({ id: n })
+      }),
+    )
+
+    class One extends Context.Service<One, { readonly get: () => Effect.Effect<number> }>()("@test/One") {}
+    const one = Layer.effect(
+      One,
+      Effect.gen(function* () {
+        const svc = yield* Shared
+        return One.of({
+          get: Effect.fn("One.get")(() => Effect.succeed(svc.id)),
+        })
+      }),
+    ).pipe(Layer.provide(shared))
+
+    class Two extends Context.Service<Two, { readonly get: () => Effect.Effect<number> }>()("@test/Two") {}
+    const two = Layer.effect(
+      Two,
+      Effect.gen(function* () {
+        const svc = yield* Shared
+        return Two.of({
+          get: Effect.fn("Two.get")(() => Effect.succeed(svc.id)),
+        })
+      }),
+    ).pipe(Layer.provide(shared))
+
+    const { runPromise: runOne } = makeRuntime(One, one)
+    const { runPromise: runTwo } = makeRuntime(Two, two)
+
+    expect(yield* Effect.promise(() => runOne((svc) => svc.get()))).toBe(1)
+    expect(yield* Effect.promise(() => runTwo((svc) => svc.get()))).toBe(1)
+    expect(n).toBe(1)
+  }),
+)
+
+it.live("makeRuntime inherits InstanceRef from the current fiber", () =>
+  Effect.gen(function* () {
+    class NeedsInstance extends Context.Service<
+      NeedsInstance,
+      { readonly directory: () => Effect.Effect<string | undefined> }
+    >()("@test/NeedsInstance") {}
+
+    const runtime = makeRuntime(
+      NeedsInstance,
+      Layer.succeed(
+        NeedsInstance,
+        NeedsInstance.of({
+          directory: () =>
+            Effect.gen(function* () {
+              return (yield* InstanceRef)?.directory
+            }),
+        }),
+      ),
+    )
+
+    const actual = yield* Effect.promise(() => runtime.runPromise((svc) => svc.directory()))
+
+    expect(actual).toBe(testDirectory)
+  }).pipe(
+    Effect.provideService(InstanceRef, {
+      directory: testDirectory,
+      worktree: testDirectory,
+      project: {
+        id: ProjectID.global,
+        worktree: testDirectory,
+        time: { created: 0, updated: 0 },
+        sandboxes: [],
+      },
+    }),
+  ),
+)