@livestore/utils-dev 0.0.0-snapshot-e5a7caabcf7660aefa55568a44ed0fe306d00597 → 0.0.0-snapshot-9d8807d2c51c95b4df3556744702cea55dc7ded3

package/src/node-vitest/Vitest.ts

@@ -1,238 +0,0 @@
-import * as inspector from 'node:inspector'
-import type * as Vitest from '@effect/vitest'
-import { IS_CI } from '@livestore/utils'
-import {
-  type Cause,
-  Duration,
-  Effect,
-  type FastCheck as FC,
-  identity,
-  Layer,
-  type OtelTracer,
-  Predicate,
-  type Schema,
-  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)
-
-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,
-  // Exclude dependencies provided by `withTestCtx` from the layer dependencies
-  | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
-  // Exclude dependencies provided by `withTestCtx` **and** dependencies produced
-  // by the layer from the effect dependencies
-  | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
-> = (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
-  forceOtel?: boolean
-}
-
-export const withTestCtx =
-  <ROut = never, E1 = never, RIn = never>(
-    testContext: Vitest.TestContext,
-    {
-      suffix,
-      makeLayer,
-      timeout = IS_CI ? 60_000 : 10_000,
-      forceOtel = false,
-    }: {
-      suffix?: string
-      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn>
-      timeout?: Duration.DurationInput
-      forceOtel?: boolean
-    } = {},
-  ) =>
-  <A, E, R>(
-    self: Effect.Effect<A, E, R>,
-  ): Effect.Effect<
-    A,
-    E | E1 | Cause.TimeoutException,
-    // Exclude dependencies provided internally from the provided layer's dependencies
-    | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
-    // Exclude dependencies provided internally **and** dependencies produced by the
-    // provided layer from the effect dependencies
-    | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
-  > => {
-    const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix ? `:${suffix}` : ''}`
-    const layer = makeLayer?.(testContext) ?? Layer.empty
-
-    const otelLayer =
-      DEBUGGER_ACTIVE || forceOtel
-        ? OtelLiveHttp({ rootSpanName: spanName, serviceName: 'vitest-runner', skipLogUrl: false })
-        : OtelLiveDummy
-
-    const combinedLayer = layer.pipe(Layer.provideMerge(otelLayer))
-
-    return self.pipe(
-      DEBUGGER_ACTIVE
-        ? identity
-        : Effect.logWarnIfTakesLongerThan({
-            duration: Duration.toMillis(timeout) * 0.8,
-            label: `${spanName} approaching timeout (timeout: ${Duration.format(timeout)})`,
-          }),
-      DEBUGGER_ACTIVE ? 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
-  }
-
-/**
- * Shared properties for all enhanced test context phases
- */
-export interface EnhancedTestContextBase {
-  numRuns: number
-  /** 0-based index */
-  runIndex: number
-  /** Total number of executions including initial runs and shrinking attempts */
-  totalExecutions: number
-}
-
-/**
- * Enhanced context for property-based tests that includes shrinking phase information
- */
-export type EnhancedTestContext =
-  | (EnhancedTestContextBase & {
-      _tag: 'initial'
-    })
-  | (EnhancedTestContextBase & {
-      _tag: 'shrinking'
-      /** Number of shrinking attempts */
-      shrinkAttempt: number
-    })
-
-/**
- * Normalizes propOptions to ensure @effect/vitest receives correct fastCheck structure
- */
-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]>
-  }>
-} => {
-  // If it's a number, treat as timeout and add our default fastCheck
-  if (!Predicate.isObject(propOptions)) {
-    return {
-      timeout: propOptions,
-      fastCheck: { numRuns: 100 },
-    }
-  }
-
-  // If no fastCheck property, add it with our default numRuns
-  if (!propOptions.fastCheck) {
-    return {
-      ...propOptions,
-      fastCheck: { numRuns: 100 },
-    }
-  }
-
-  // If fastCheck exists but no numRuns, add our default
-  if (propOptions.fastCheck && !propOptions.fastCheck.numRuns) {
-    return {
-      ...propOptions,
-      fastCheck: {
-        ...propOptions.fastCheck,
-        numRuns: 100,
-      },
-    }
-  }
-
-  // If everything is properly structured, pass through
-  return propOptions
-}
-
-/**
- * Equivalent to Vitest.prop but provides enhanced context including shrinking progress visibility
- *
- * This function enhances the standard property-based testing by providing clear information about
- * whether FastCheck is in the initial testing phase or the shrinking phase, solving the confusion
- * where tests show "Run 26/6" when FastCheck's shrinking algorithm is active.
- *
- * TODO: allow for upper timelimit instead of / additional to `numRuns`
- *
- * TODO: Upstream to Effect
- */
-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]>
-        }>
-      }),
-) => {
-  const normalizedPropOptions = normalizePropOptions(propOptions)
-  const numRuns = normalizedPropOptions.fastCheck?.numRuns ?? 100
-  let runIndex = 0
-  let shrinkAttempts = 0
-  let totalExecutions = 0
-
-  return api.prop(
-    name,
-    arbitraries,
-    (properties, ctx) => {
-      if (ctx.signal.aborted) {
-        return ctx.skip('Test aborted')
-      }
-
-      totalExecutions++
-      const isInShrinkingPhase = runIndex >= numRuns
-
-      if (isInShrinkingPhase) {
-        shrinkAttempts++
-      }
-
-      const enhancedContext: EnhancedTestContext = isInShrinkingPhase
-        ? {
-            _tag: 'shrinking',
-            numRuns,
-            runIndex: runIndex++,
-            shrinkAttempt: shrinkAttempts,
-            totalExecutions,
-          }
-        : {
-            _tag: 'initial',
-            numRuns,
-            runIndex: runIndex++,
-            totalExecutions,
-          }
-
-      return test(properties, ctx, enhancedContext)
-    },
-    normalizedPropOptions,
-  )
-}

package/src/wrangler/WranglerDevServer.test.ts

@@ -1,133 +0,0 @@
-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'
-
-const testTimeout = 60_000
-
-const WranglerDevServerTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
-  WranglerDevServerService.Default({
-    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> = {}) =>
-      Vitest.makeWithTestCtx({
-        timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
-      })
-
-    Vitest.scopedLive('should start wrangler dev server and return port', (test) =>
-      Effect.gen(function* () {
-        const server = yield* WranglerDevServerService
-
-        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) =>
-      Effect.andThen(getFreePort, (port) =>
-        Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
-
-          expect(server.port).toBe(port)
-          expect(server.url).toBe(`http://127.0.0.1:${port}`)
-        }).pipe(withBasicTest({ preferredPort: port })(test)),
-      ),
-    )
-  })
-
-  Vitest.describe('Error Handling', () => {
-    const withErrorTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
-      Vitest.makeWithTestCtx({
-        timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
-      })
-
-    Vitest.scopedLive('should handle missing wrangler.toml but should timeout', (test) =>
-      Effect.gen(function* () {
-        const error = yield* WranglerDevServerService.pipe(
-          Effect.provide(
-            WranglerDevServerTest({
-              cwd: '/tmp',
-              wranglerConfigPath: '/dev/null',
-              connectTimeout: '500 millis',
-            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
-          ),
-          Effect.flip,
-        )
-
-        expect(error).toBeInstanceOf(WranglerDevServerError)
-      }).pipe(Vitest.withTestCtx(test)),
-    )
-
-    Vitest.scopedLive('should handle invalid working directory', (test) =>
-      Effect.gen(function* () {
-        const result = yield* WranglerDevServerService.pipe(
-          Effect.provide(
-            WranglerDevServerTest({
-              cwd: '/completely/nonexistent/directory',
-            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
-          ),
-          Effect.either,
-        )
-
-        expect(result._tag).toBe('Left')
-        if (result._tag === 'Left') {
-          expect(result.left).toBeInstanceOf(WranglerDevServerError)
-        }
-      }).pipe(Vitest.withTestCtx(test)),
-    )
-
-    Vitest.scopedLive('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(
-          // Override the timeout for this test to be shorter
-          Effect.timeout('5 seconds'),
-          Effect.either,
-        )
-
-        // This might succeed or fail depending on actual wrangler behavior
-        // The main point is testing timeout functionality
-        expect(['Left', 'Right']).toContain(result._tag)
-      }).pipe(withErrorTest()(test)),
-    )
-  })
-
-  Vitest.describe('Service Pattern', () => {
-    const withServiceTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
-      Vitest.makeWithTestCtx({
-        timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
-      })
-
-    Vitest.scopedLive('should work with service pattern', (test) =>
-      Effect.gen(function* () {
-        const server = yield* WranglerDevServerService
-
-        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) =>
-      Effect.andThen(getFreePort, (port) =>
-        Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
-
-          expect(server.port).toBe(port)
-          expect(server.url).toBe(`http://127.0.0.1:${port}`)
-        }).pipe(withServiceTest({ preferredPort: port })(test)),
-      ),
-    )
-  })
-})

package/src/wrangler/WranglerDevServer.ts

@@ -1,180 +0,0 @@
-import * as path from 'node:path'
-import * as Toml from '@iarna/toml'
-import { IS_CI } from '@livestore/utils'
-import { Cause, Duration, Effect, FileSystem, HttpClient, Schedule, Schema } from '@livestore/utils/effect'
-import { getFreePort } from '@livestore/utils/node'
-import * as wrangler from 'wrangler'
-
-/**
- * Error type for WranglerDevServer operations
- */
-export class WranglerDevServerError extends Schema.TaggedError<WranglerDevServerError>()('WranglerDevServerError', {
-  cause: Schema.Unknown,
-  message: Schema.String,
-  port: Schema.Number,
-}) {}
-
-/**
- * WranglerDevServer instance interface
- */
-export interface WranglerDevServer {
-  readonly port: number
-  readonly url: string
-  // readonly processId: number
-}
-
-/**
- * Configuration for starting WranglerDevServer
- */
-export interface StartWranglerDevServerArgs {
-  wranglerConfigPath?: string
-  cwd: string
-  /** The port to try first. The dev server may bind a different port if unavailable. */
-  preferredPort?: number
-  /** @default false */
-  showLogs?: boolean
-  inspectorPort?: number
-  connectTimeout?: Duration.DurationInput
-}
-
-/**
- * WranglerDevServer as an Effect.Service.
- *
- * This service provides the WranglerDevServer properties and can be accessed
- * directly to get port and url.
- *
- * TODO: Allow for config to be passed in via code instead of `wrangler.toml` file
- * (would need to be placed in temporary file as wrangler only accepts files as config)
- */
-export class WranglerDevServerService extends Effect.Service<WranglerDevServerService>()('WranglerDevServerService', {
-  scoped: (args: StartWranglerDevServerArgs) =>
-    Effect.gen(function* () {
-      const showLogs = args.showLogs ?? false
-
-      // Allocate preferred port (Wrangler may bind a different one if unavailable)
-      const preferredPort =
-        args.preferredPort ??
-        (yield* getFreePort.pipe(
-          Effect.mapError(
-            (cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 }),
-          ),
-        ))
-
-      yield* Effect.annotateCurrentSpan({ preferredPort })
-
-      const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
-
-      const fs = yield* FileSystem.FileSystem
-      const configContent = yield* fs.readFileString(configPath)
-      const parsedConfig = yield* Effect.try(() => Toml.parse(configContent)).pipe(
-        Effect.andThen(Schema.decodeUnknown(Schema.Struct({ main: Schema.String }))),
-        Effect.mapError(
-          (error) => new WranglerDevServerError({ cause: error, message: 'Failed to parse wrangler config', port: -1 }),
-        ),
-      )
-      const resolvedMainPath = yield* Effect.try(() => path.resolve(args.cwd, parsedConfig.main))
-
-      const devServer = yield* Effect.promise(() =>
-        wrangler.unstable_dev(resolvedMainPath, {
-          config: configPath,
-          port: preferredPort,
-          inspectorPort: args.inspectorPort ?? 0,
-          persistTo: path.join(args.cwd, '.wrangler/state'),
-          logLevel: showLogs ? 'debug' : 'none',
-          experimental: {
-            disableExperimentalWarning: true,
-          },
-        }),
-      )
-
-      yield* Effect.addFinalizer(
-        Effect.fn(
-          function* (exit) {
-            if (exit._tag === 'Failure' && Cause.isInterruptedOnly(exit.cause) === false) {
-              yield* Effect.logError('Closing wrangler dev server on failure', exit.cause)
-            }
-
-            yield* Effect.tryPromise(async () => {
-              await devServer.stop()
-              // TODO investigate whether we need to wait until exit (see workers-sdk repo/talk to Cloudflare team)
-              // await devServer.waitUntilExit()
-            })
-          },
-          Effect.timeout('5 seconds'),
-          Effect.orDie,
-          Effect.tapCauseLogPretty,
-          Effect.withSpan('WranglerDevServerService:stopDevServer'),
-        ),
-      )
-
-      const actualPort = devServer.port
-      const actualHost = devServer.address
-      const url = `http://${actualHost}:${actualPort}`
-
-      // Use longer timeout in CI environments to account for slower startup times
-      const defaultTimeout = Duration.seconds(IS_CI ? 30 : 5)
-
-      yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: args.connectTimeout ?? defaultTimeout })
-
-      if (showLogs) {
-        yield* Effect.logDebug(
-          `Wrangler dev server ready and accepting connections on port ${actualPort} (preferred: ${preferredPort})`,
-        )
-      }
-
-      return {
-        port: actualPort,
-        url,
-      } satisfies WranglerDevServer
-    }).pipe(
-      Effect.mapError(
-        (error) =>
-          new WranglerDevServerError({ cause: error, message: 'Failed to start wrangler dev server', port: -1 }),
-      ),
-      Effect.withSpan('WranglerDevServerService', {
-        attributes: { preferredPort: args.preferredPort ?? 'auto', cwd: args.cwd },
-      }),
-    ),
-}) {}
-
-/**
- * Verifies the server is actually accepting HTTP connections by making a test request
- */
-const verifyHttpConnectivity = ({
-  url,
-  showLogs,
-  connectTimeout,
-}: {
-  url: string
-  showLogs: boolean
-  connectTimeout: Duration.DurationInput
-}): Effect.Effect<void, WranglerDevServerError, HttpClient.HttpClient> =>
-  Effect.gen(function* () {
-    const client = yield* HttpClient.HttpClient
-
-    if (showLogs) {
-      yield* Effect.logDebug(`Verifying HTTP connectivity to ${url}`)
-    }
-
-    // Try to connect with retries using exponential backoff
-    yield* client.get(url).pipe(
-      Effect.retryOrElse(
-        Schedule.exponential('50 millis', 2).pipe(
-          Schedule.jittered,
-          Schedule.intersect(Schedule.elapsed.pipe(Schedule.whileOutput(Duration.lessThanOrEqualTo(connectTimeout)))),
-          Schedule.compose(Schedule.count),
-        ),
-        (error, attemptCount) =>
-          Effect.fail(
-            new WranglerDevServerError({
-              cause: error,
-              message: `Failed to establish HTTP connection to Wrangler server at ${url} after ${attemptCount} attempts (timeout: ${Duration.toMillis(connectTimeout)}ms)`,
-              port: 0,
-            }),
-          ),
-      ),
-      Effect.tap(() => (showLogs ? Effect.logDebug(`HTTP connectivity verified for ${url}`) : Effect.void)),
-      Effect.asVoid,
-      Effect.withSpan('verifyHttpConnectivity'),
-    )
-  })

package/src/wrangler/fixtures/cf-worker.ts

@@ -1,11 +0,0 @@
-export default {
-  async fetch(_request: Request): Promise<Response> {
-    return new Response('Hello from Wrangler Dev Server test worker!')
-  },
-}
-
-export class TestDO {
-  async fetch(_request: Request): Promise<Response> {
-    return new Response('Hello from Test Durable Object!')
-  }
-}

package/src/wrangler/fixtures/wrangler.toml

@@ -1,11 +0,0 @@
-name = "wrangler-dev-server-test"
-main = "./cf-worker.ts"
-compatibility_date = "2024-05-12"
-
-[[durable_objects.bindings]]
-name = "TEST_DO"
-class_name = "TestDO"
-
-[[migrations]]
-tag = "v1"
-new_sqlite_classes = ["TestDO"]

package/src/wrangler/mod.ts

@@ -1,6 +0,0 @@
-export {
-  type StartWranglerDevServerArgs,
-  type WranglerDevServer,
-  WranglerDevServerError,
-  WranglerDevServerService,
-} from './WranglerDevServer.ts'