saeeol 1.2.5 → 1.2.7

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

@@ -1,98 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,394 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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: [],
-      },
-    }),
-  ),
-)