@livestore/utils-dev 0.4.0-dev.9 → 0.5.0-dev.0

package/src/node-vitest/Vitest.ts

@@ -1,5 +1,7 @@
 import * as inspector from 'node:inspector'
+
 import type * as Vitest from '@effect/vitest'
+
 import { IS_CI } from '@livestore/utils'
 import {
   type Cause,
@@ -14,30 +16,34 @@ import {
   type Scope,
 } from '@livestore/utils/effect'
 import { OtelLiveDummy } from '@livestore/utils/node'
+
 import { OtelLiveHttp } from '../node/mod.ts'
 
 export * from '@effect/vitest'
 
 export const DEBUGGER_ACTIVE = Boolean(process.env.DEBUGGER_ACTIVE ?? inspector.url() !== undefined)
 
+type WithoutTestCtxServices<R> = Exclude<Exclude<R, OtelTracer.OtelTracer>, Scope.Scope>
+type WithoutLayerAndTestCtxServices<R, ROut> = Exclude<Exclude<R, ROut | OtelTracer.OtelTracer>, Scope.Scope>
+
 export const makeWithTestCtx: <ROut = never, E1 = never, RIn = never>(
   ctxParams: WithTestCtxParams<ROut, E1, RIn>,
 ) => (testContext: Vitest.TestContext) => <A, E, R>(
   self: Effect.Effect<A, E, R>,
 ) => Effect.Effect<
   A,
-  E | E1 | Cause.TimeoutException,
+  E | E1 | Cause.TimeoutError,
   // Exclude dependencies provided by `withTestCtx` from the layer dependencies
-  | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
+  | WithoutTestCtxServices<RIn>
   // Exclude dependencies provided by `withTestCtx` **and** dependencies produced
   // by the layer from the effect dependencies
-  | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
+  | WithoutLayerAndTestCtxServices<R, ROut>
 > = (ctxParams) => (testContext: Vitest.TestContext) => withTestCtx(testContext, ctxParams)
 
 export type WithTestCtxParams<ROut, E1, RIn> = {
   suffix?: string
   makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn | Scope.Scope>
-  timeout?: Duration.DurationInput
+  timeout?: Duration.Input
   forceOtel?: boolean
 }
 
@@ -47,12 +53,12 @@ export const withTestCtx =
     {
       suffix,
       makeLayer,
-      timeout = IS_CI ? 60_000 : 10_000,
+      timeout = IS_CI === true ? 60_000 : 10_000,
       forceOtel = false,
     }: {
       suffix?: string
-      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn>
-      timeout?: Duration.DurationInput
+      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn | Scope.Scope>
+      timeout?: Duration.Input
       forceOtel?: boolean
     } = {},
   ) =>
@@ -60,35 +66,39 @@ export const withTestCtx =
     self: Effect.Effect<A, E, R>,
   ): Effect.Effect<
     A,
-    E | E1 | Cause.TimeoutException,
+    E | E1 | Cause.TimeoutError,
     // Exclude dependencies provided internally from the provided layer's dependencies
-    | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
+    | WithoutTestCtxServices<RIn>
     // Exclude dependencies provided internally **and** dependencies produced by the
     // provided layer from the effect dependencies
-    | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
+    | WithoutLayerAndTestCtxServices<R, ROut>
   > => {
-    const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix ? `:${suffix}` : ''}`
-    const layer = makeLayer?.(testContext) ?? Layer.empty
+    const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix !== undefined ? `:${suffix}` : ''}`
+    // `Layer.empty` provides `never`, which is narrower than an arbitrary generic
+    // `ROut`; widen it for the no-layer branch so `Effect.provide` can typecheck.
+    const layer: Layer.Layer<ROut, E1, RIn | Scope.Scope> =
+      makeLayer?.(testContext) ?? (Layer.empty as unknown as Layer.Layer<ROut, E1, RIn | Scope.Scope>)
+    const timeoutDuration = Duration.fromInputUnsafe(timeout)
 
     const otelLayer =
-      DEBUGGER_ACTIVE || forceOtel
+      DEBUGGER_ACTIVE === true || forceOtel === true
         ? OtelLiveHttp({ rootSpanName: spanName, serviceName: 'vitest-runner', skipLogUrl: false })
         : OtelLiveDummy
 
     const combinedLayer = layer.pipe(Layer.provideMerge(otelLayer))
 
     return self.pipe(
-      DEBUGGER_ACTIVE
+      DEBUGGER_ACTIVE === true
         ? identity
         : Effect.logWarnIfTakesLongerThan({
-            duration: Duration.toMillis(timeout) * 0.8,
-            label: `${spanName} approaching timeout (timeout: ${Duration.format(timeout)})`,
+            duration: Duration.toMillis(timeoutDuration) * 0.8,
+            label: `${spanName} approaching timeout (timeout: ${Duration.format(timeoutDuration)})`,
           }),
-      DEBUGGER_ACTIVE ? identity : Effect.timeout(timeout),
+      DEBUGGER_ACTIVE === true ? identity : Effect.timeout(timeout),
       Effect.provide(combinedLayer),
       Effect.scoped, // We need to scope the effect manually here because otherwise the span is not closed
       Effect.annotateLogs({ suffix }),
-    ) as any
+    )
   }
 
 /**
@@ -118,21 +128,19 @@ export type EnhancedTestContext =
 /**
  * Normalizes propOptions to ensure @effect/vitest receives correct fastCheck structure
  */
+type ArbitraryValues<Arbs extends Vitest.Vitest.Arbitraries> = {
+  [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Arbs[K] extends Schema.Schema<infer T> ? T : never
+}
+
+type PropOptions<Arbs extends Vitest.Vitest.Arbitraries> = Omit<Vitest.TestOptions, 'fastCheck'> & {
+  fastCheck?: FC.Parameters<ArbitraryValues<Arbs>>
+}
+
 const normalizePropOptions = <Arbs extends Vitest.Vitest.Arbitraries>(
-  propOptions:
-    | number
-    | (Vitest.TestOptions & {
-        fastCheck?: FC.Parameters<{
-          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
-        }>
-      }),
-): Vitest.TestOptions & {
-  fastCheck?: FC.Parameters<{
-    [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
-  }>
-} => {
+  propOptions: number | PropOptions<Arbs>,
+): PropOptions<Arbs> => {
   // If it's a number, treat as timeout and add our default fastCheck
-  if (!Predicate.isObject(propOptions)) {
+  if (Predicate.isObject(propOptions) === false) {
     return {
       timeout: propOptions,
       fastCheck: { numRuns: 100 },
@@ -140,7 +148,7 @@ const normalizePropOptions = <Arbs extends Vitest.Vitest.Arbitraries>(
   }
 
   // If no fastCheck property, add it with our default numRuns
-  if (!propOptions.fastCheck) {
+  if (propOptions.fastCheck == null) {
     return {
       ...propOptions,
       fastCheck: { numRuns: 100 },
@@ -148,7 +156,7 @@ const normalizePropOptions = <Arbs extends Vitest.Vitest.Arbitraries>(
   }
 
   // If fastCheck exists but no numRuns, add our default
-  if (propOptions.fastCheck && !propOptions.fastCheck.numRuns) {
+  if (propOptions.fastCheck !== undefined && propOptions.fastCheck.numRuns == null) {
     return {
       ...propOptions,
       fastCheck: {
@@ -177,23 +185,8 @@ export const asProp = <Arbs extends Vitest.Vitest.Arbitraries, A, E, R>(
   api: Vitest.Vitest.Tester<R>,
   name: string,
   arbitraries: Arbs,
-  test: Vitest.Vitest.TestFunction<
-    A,
-    E,
-    R,
-    [
-      { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
-      Vitest.TestContext,
-      EnhancedTestContext,
-    ]
-  >,
-  propOptions:
-    | number
-    | (Vitest.TestOptions & {
-        fastCheck?: FC.Parameters<{
-          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
-        }>
-      }),
+  test: Vitest.Vitest.TestFunction<A, E, R, [ArbitraryValues<Arbs>, Vitest.TestContext, EnhancedTestContext]>,
+  propOptions: number | PropOptions<Arbs>,
 ) => {
   const normalizedPropOptions = normalizePropOptions(propOptions)
   const numRuns = normalizedPropOptions.fastCheck?.numRuns ?? 100
@@ -205,31 +198,32 @@ export const asProp = <Arbs extends Vitest.Vitest.Arbitraries, A, E, R>(
     name,
     arbitraries,
     (properties, ctx) => {
-      if (ctx.signal.aborted) {
+      if (ctx.signal.aborted === true) {
         return ctx.skip('Test aborted')
       }
 
       totalExecutions++
       const isInShrinkingPhase = runIndex >= numRuns
 
-      if (isInShrinkingPhase) {
+      if (isInShrinkingPhase === true) {
         shrinkAttempts++
       }
 
-      const enhancedContext: EnhancedTestContext = isInShrinkingPhase
-        ? {
-            _tag: 'shrinking',
-            numRuns,
-            runIndex: runIndex++,
-            shrinkAttempt: shrinkAttempts,
-            totalExecutions,
-          }
-        : {
-            _tag: 'initial',
-            numRuns,
-            runIndex: runIndex++,
-            totalExecutions,
-          }
+      const enhancedContext: EnhancedTestContext =
+        isInShrinkingPhase === true
+          ? {
+              _tag: 'shrinking',
+              numRuns,
+              runIndex: runIndex++,
+              shrinkAttempt: shrinkAttempts,
+              totalExecutions,
+            }
+          : {
+              _tag: 'initial',
+              numRuns,
+              runIndex: runIndex++,
+              totalExecutions,
+            }
 
       return test(properties, ctx, enhancedContext)
     },

package/src/wrangler/WranglerDevServer.test.ts

@@ -1,42 +1,40 @@
-import { Effect, FetchHttpClient, Layer } from '@livestore/utils/effect'
-import { getFreePort, PlatformNode } from '@livestore/utils/node'
-import { Vitest } from '@livestore/utils-dev/node-vitest'
 import { expect } from 'vitest'
-import {
-  type StartWranglerDevServerArgs,
-  WranglerDevServerError,
-  WranglerDevServerService,
-} from './WranglerDevServer.ts'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Effect, FetchHttpClient, Layer, Result } from '@livestore/utils/effect'
+import { getFreePort, PlatformNode } from '@livestore/utils/node'
+
+import * as WranglerDevServer from './WranglerDevServer.ts'
 
 const testTimeout = 60_000
 
-const WranglerDevServerTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
-  WranglerDevServerService.Default({
+const WranglerDevServerTest = (args: Partial<WranglerDevServer.Options> = {}) =>
+  WranglerDevServer.layer({
     cwd: `${import.meta.dirname}/fixtures`,
     ...args,
   }).pipe(Layer.provide(FetchHttpClient.layer))
 
 Vitest.describe('WranglerDevServer', { timeout: testTimeout }, () => {
   Vitest.describe('Basic Operations', () => {
-    const withBasicTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+    const withBasicTest = (args: Partial<WranglerDevServer.Options> = {}) =>
       Vitest.makeWithTestCtx({
         timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
       })
 
-    Vitest.scopedLive('should start wrangler dev server and return port', (test) =>
+    Vitest.live('should start wrangler dev server and return port', (test) =>
       Effect.gen(function* () {
-        const server = yield* WranglerDevServerService
+        const server = yield* WranglerDevServer.WranglerDevServer
 
         expect(server.port).toBeGreaterThan(0)
         expect(server.url).toMatch(/http:\/\/127.0.0.1:\d+/)
       }).pipe(withBasicTest()(test)),
     )
 
-    Vitest.scopedLive('should use specified port when provided', (test) =>
+    Vitest.live('should use specified port when provided', (test) =>
       Effect.andThen(getFreePort, (port) =>
         Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
+          const server = yield* WranglerDevServer.WranglerDevServer
 
           expect(server.port).toBe(port)
           expect(server.url).toBe(`http://127.0.0.1:${port}`)
@@ -46,83 +44,83 @@ Vitest.describe('WranglerDevServer', { timeout: testTimeout }, () => {
   })
 
   Vitest.describe('Error Handling', () => {
-    const withErrorTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+    const withErrorTest = (args: Partial<WranglerDevServer.Options> = {}) =>
       Vitest.makeWithTestCtx({
         timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
       })
 
-    Vitest.scopedLive('should handle missing wrangler.toml but should timeout', (test) =>
+    Vitest.live('should handle missing wrangler.toml but should timeout', (test) =>
       Effect.gen(function* () {
-        const error = yield* WranglerDevServerService.pipe(
+        const error = yield* WranglerDevServer.WranglerDevServer.pipe(
           Effect.provide(
             WranglerDevServerTest({
               cwd: '/tmp',
               wranglerConfigPath: '/dev/null',
-              connectTimeout: '500 millis',
-            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+              readiness: { connectTimeout: '500 millis' },
+            }).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
           ),
           Effect.flip,
         )
 
-        expect(error).toBeInstanceOf(WranglerDevServerError)
+        expect(error).toBeInstanceOf(WranglerDevServer.WranglerDevServerError)
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should handle invalid working directory', (test) =>
+    Vitest.live('should handle invalid working directory', (test) =>
       Effect.gen(function* () {
-        const result = yield* WranglerDevServerService.pipe(
+        const result = yield* WranglerDevServer.WranglerDevServer.pipe(
           Effect.provide(
             WranglerDevServerTest({
               cwd: '/completely/nonexistent/directory',
-            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+            }).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
           ),
-          Effect.either,
+          Effect.result,
         )
 
-        expect(result._tag).toBe('Left')
-        if (result._tag === 'Left') {
-          expect(result.left).toBeInstanceOf(WranglerDevServerError)
+        expect(result._tag).toBe('Failure')
+        if (result._tag === 'Failure') {
+          expect(result.failure).toBeInstanceOf(WranglerDevServer.WranglerDevServerError)
         }
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should timeout if server fails to start', (test) =>
+    Vitest.live('should timeout if server fails to start', (test) =>
       Effect.gen(function* () {
         // Create a command that will never output "Ready on"
-        const result = yield* WranglerDevServerService.pipe(
+        const result = yield* WranglerDevServer.WranglerDevServer.pipe(
           // Override the timeout for this test to be shorter
           Effect.timeout('5 seconds'),
-          Effect.either,
+          Effect.result,
         )
 
         // This might succeed or fail depending on actual wrangler behavior
         // The main point is testing timeout functionality
-        expect(['Left', 'Right']).toContain(result._tag)
+        expect(['Failure', 'Success']).toContain(result._tag)
       }).pipe(withErrorTest()(test)),
     )
   })
 
   Vitest.describe('Service Pattern', () => {
-    const withServiceTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+    const withServiceTest = (args: Partial<WranglerDevServer.Options> = {}) =>
       Vitest.makeWithTestCtx({
         timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
       })
 
-    Vitest.scopedLive('should work with service pattern', (test) =>
+    Vitest.live('should work with service pattern', (test) =>
       Effect.gen(function* () {
-        const server = yield* WranglerDevServerService
+        const server = yield* WranglerDevServer.WranglerDevServer
 
         expect(server.port).toBeGreaterThan(0)
         expect(server.url).toMatch(/http:\/\/127.0.0.1:\d+/)
       }).pipe(withServiceTest()(test)),
     )
 
-    Vitest.scopedLive('should work with custom port via service', (test) =>
+    Vitest.live('should work with custom port via service', (test) =>
       Effect.andThen(getFreePort, (port) =>
         Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
+          const server = yield* WranglerDevServer.WranglerDevServer
 
           expect(server.port).toBe(port)
           expect(server.url).toBe(`http://127.0.0.1:${port}`)