@livestore/utils-dev 0.4.0-dev.5 → 0.4.0-dev.7

package/src/node-vitest/Vitest.ts

@@ -1,7 +1,18 @@
 import * as inspector from 'node:inspector'
 import type * as Vitest from '@effect/vitest'
 import { IS_CI } from '@livestore/utils'
-import { type Cause, Duration, Effect, identity, Layer, type OtelTracer, type Scope } from '@livestore/utils/effect'
+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'
 
@@ -9,12 +20,17 @@ export * from '@effect/vitest'
 
 export const DEBUGGER_ACTIVE = Boolean(process.env.DEBUGGER_ACTIVE ?? inspector.url() !== undefined)
 
-export const makeWithTestCtx =
-  <R1 = never, E1 = never>(ctxParams: WithTestCtxParams<R1, E1>) =>
-  (testContext: Vitest.TestContext) =>
+export const makeWithTestCtx: <R1, E1>(
+  ctxParams: WithTestCtxParams<R1, E1>,
+) => (
+  testContext: Vitest.TestContext,
+) => <A, E>(
+  self: Effect.Effect<A, E, Scope.Scope | NoInfer<R1> | OtelTracer.OtelTracer>,
+) => Effect.Effect<A, E1 | Cause.TimeoutException | E, Scope.Scope> =
+  (ctxParams) => (testContext: Vitest.TestContext) =>
     withTestCtx(testContext, ctxParams)
 
-export type WithTestCtxParams<R1 = never, E1 = never> = {
+export type WithTestCtxParams<R1, E1> = {
   suffix?: string
   makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
   timeout?: Duration.DurationInput
@@ -62,3 +78,149 @@ export const withTestCtx =
       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/node/vitest-docker-compose-setup.ts

@@ -1,182 +0,0 @@
-import { spawn } from 'node:child_process'
-import path from 'node:path'
-import { Effect, UnknownError } from '@livestore/utils/effect'
-import { cmd } from './cmd.ts'
-
-export const startDockerComposeServices = (args: StartDockerComposeServicesArgs) =>
-  Effect.tryPromise({
-    try: () => startDockerComposeServicesPromise(args),
-    catch: (error) => UnknownError.make({ cause: new Error(`Failed to start Docker Compose: ${error}`) }),
-  }).pipe(Effect.withSpan('startDockerComposeServices'))
-
-type StartDockerComposeServicesArgs = {
-  composeFilePath?: string
-  cwd: string
-  serviceName?: string
-  waitForLog?: string
-  env?: Record<string, string>
-  healthCheck?: {
-    url: string // URL template with ${port} placeholder
-    expectedStatus?: number // default 200
-    maxAttempts?: number // default 30
-    delayMs?: number // default 1000
-  }
-  /** @default false */
-  forwardLogs?: boolean
-}
-
-export const pullDockerComposeImages = ({
-  cwd,
-  composeFilePath,
-}: Pick<StartDockerComposeServicesArgs, 'composeFilePath' | 'cwd'>) =>
-  Effect.gen(function* () {
-    const resolvedComposeFilePath = path.resolve(composeFilePath ?? path.join(cwd, 'docker-compose.yml'))
-    yield* cmd(['docker', 'compose', '-f', resolvedComposeFilePath, 'pull'], { cwd })
-  }).pipe(Effect.withSpan('pullDockerComposeImages'))
-
-/**
- * Starts Docker Compose services for testing with automatic cleanup.
- * Automatically allocates a free port and passes it as EXPOSED_PORT environment variable.
- *
- * @param composeFilePath - Path to docker-compose.yml file (defaults to `${cwd}/docker-compose.yml`)
- * @param cwd - Working directory for Docker Compose commands
- * @param env - Environment variables to pass to the Docker Compose commands (useful for passing ports)
- * @param serviceName - Optional specific service to start (omit to start all)
- * @param waitForLog - Log pattern to wait for before considering services ready
- * @param healthCheck - Health check configuration for waiting until service is ready
- */
-// TODO refactor implementation with Effect
-// TODO add test for this
-export const startDockerComposeServicesPromise = async ({
-  composeFilePath,
-  cwd,
-  serviceName,
-  waitForLog,
-  healthCheck,
-  env,
-  forwardLogs = false,
-}: StartDockerComposeServicesArgs) => {
-  let dockerComposeProcess: ReturnType<typeof spawn> | undefined
-
-  const setup = async () => {
-    const resolvedComposeFilePath = path.resolve(composeFilePath ?? path.join(cwd, 'docker-compose.yml'))
-
-    // Build the docker compose command arguments
-    const composeArgs = ['compose', '-f', resolvedComposeFilePath, 'up']
-
-    // Add service name if specified
-    if (serviceName) {
-      composeArgs.push(serviceName)
-    }
-
-    dockerComposeProcess = spawn('docker', composeArgs, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      cwd,
-      env: { ...process.env, ...env },
-    })
-
-    dockerComposeProcess.stdout?.setEncoding('utf8')
-    dockerComposeProcess.stderr?.setEncoding('utf8')
-
-    if (forwardLogs) {
-      dockerComposeProcess.stdout?.on('data', (data: string) => {
-        console.log(data)
-      })
-
-      dockerComposeProcess.stderr?.on('data', (data: string) => {
-        console.error(data)
-      })
-    }
-
-    // Wait for the service to be ready
-    if (healthCheck) {
-      // Use health check approach
-      const maxAttempts = healthCheck.maxAttempts ?? 30
-      const delayMs = healthCheck.delayMs ?? 1000
-      const expectedStatus = healthCheck.expectedStatus ?? 200
-      const healthUrl = healthCheck.url
-
-      console.log(`Waiting for health check at ${healthUrl}...`)
-
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-          const response = await fetch(healthUrl)
-          if (response.status === expectedStatus) {
-            console.log(`Health check passed after ${attempt} attempts`)
-            break
-          }
-          console.log(`Health check attempt ${attempt}/${maxAttempts}: status ${response.status}`)
-        } catch (error) {
-          console.log(
-            `Health check attempt ${attempt}/${maxAttempts}: ${error instanceof Error ? error.message : 'failed'}`,
-          )
-        }
-
-        if (attempt === maxAttempts) {
-          throw new Error(`Health check failed after ${maxAttempts} attempts at ${healthUrl}`)
-        }
-
-        await new Promise((resolve) => setTimeout(resolve, delayMs))
-      }
-    } else if (waitForLog) {
-      // Fallback to log-based waiting
-      await new Promise<void>((resolve) => {
-        const onData = (data: string) => {
-          if (data.includes(waitForLog)) {
-            dockerComposeProcess?.stdout?.off('data', onData)
-            resolve()
-          }
-        }
-        dockerComposeProcess?.stdout?.on('data', onData)
-        dockerComposeProcess?.stderr?.on('data', onData)
-      })
-    } else {
-      // No wait condition, just give it a moment to start
-      await new Promise((resolve) => setTimeout(resolve, 2000))
-    }
-
-    console.log(`Docker Compose services ready${serviceName ? ` (${serviceName})` : ''}`)
-  }
-
-  const stopDockerComposeServices = async () => {
-    if (dockerComposeProcess) {
-      console.log('Stopping Docker Compose services...')
-
-      const resolvedComposeFilePath = path.resolve(composeFilePath ?? path.join(cwd, 'docker-compose.yml'))
-
-      // Use docker compose down to properly stop and clean up
-      const downProcess = spawn('docker', ['compose', '-f', resolvedComposeFilePath, 'down'], {
-        stdio: 'inherit',
-        cwd,
-      })
-
-      await new Promise<void>((resolve) => {
-        downProcess.on('close', () => {
-          resolve()
-        })
-      })
-
-      dockerComposeProcess.kill('SIGTERM')
-      dockerComposeProcess = undefined
-    }
-  }
-
-  process.on('exit', () => {
-    stopDockerComposeServices()
-  })
-  process.on('SIGINT', () => {
-    stopDockerComposeServices()
-  })
-  process.on('SIGTERM', () => {
-    stopDockerComposeServices()
-  })
-
-  // try {
-  //   const { afterAll } = await import('vitest')
-  //   afterAll(async () => {
-  //     await stopDockerComposeServices()
-  //   })
-  // } catch {}
-
-  await setup()
-}

package/src/node/vitest-wrangler-setup.ts

@@ -1,132 +0,0 @@
-import { spawn } from 'node:child_process'
-import net from 'node:net'
-import path from 'node:path'
-import { Effect, UnknownError } from '@livestore/utils/effect'
-
-export type StartWranglerDevServerArgs = {
-  wranglerConfigPath?: string
-  cwd: string
-  port?: number
-}
-
-export const startWranglerDevServer = (args: StartWranglerDevServerArgs) =>
-  Effect.tryPromise({
-    try: (abortSignal) => startWranglerDevServerPromise({ ...args, abortSignal }),
-    catch: (error) => UnknownError.make({ cause: new Error(`Failed to start Wrangler: ${error}`) }),
-  }).pipe(Effect.withSpan('startWranglerDevServer'))
-
-// TODO refactor implementation with Effect
-// TODO add test for this
-// TODO allow for config to be passed in via code instead of `wrangler.toml` file
-// TODO fix zombie workerd processes causing high CPU usage - see https://github.com/livestorejs/livestore/issues/568
-/**
- * Starts a Wrangler dev server for testing with automatic cleanup.
- *
- * @param wranglerConfigPath - Path to wrangler.toml file (defaults to `${cwd}/wrangler.toml`)
- * @param cwd - Working directory for Wrangler commands
- * @returns Object with allocated port for the dev server
- */
-export const startWranglerDevServerPromise = async ({
-  wranglerConfigPath,
-  abortSignal,
-  cwd,
-  port: inputPort,
-}: {
-  wranglerConfigPath?: string
-  abortSignal?: AbortSignal
-  cwd: string
-  port?: number
-}) => {
-  let wranglerProcess: ReturnType<typeof spawn> | undefined
-
-  const getFreePort = (): Promise<number> => {
-    return new Promise((resolve, reject) => {
-      const server = net.createServer()
-      server.listen(0, () => {
-        const port = (server.address() as net.AddressInfo)?.port
-        server.close(() => {
-          if (port) {
-            resolve(port)
-          } else {
-            reject(new Error('Could not get port'))
-          }
-        })
-      })
-      server.on('error', reject)
-    })
-  }
-
-  const setup = async () => {
-    const syncPort = inputPort ?? (await getFreePort())
-
-    const resolvedWranglerConfigPath = path.resolve(wranglerConfigPath ?? path.join(cwd, 'wrangler.toml'))
-
-    wranglerProcess = spawn(
-      'bunx',
-      ['wrangler', 'dev', '--port', syncPort.toString(), '--config', resolvedWranglerConfigPath],
-      {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        cwd,
-        env: {
-          ...process.env,
-          // NODE_OPTIONS: '--inspect --inspect-port=9233',
-        },
-        signal: abortSignal,
-      },
-    )
-
-    wranglerProcess.stdout?.setEncoding('utf8')
-    wranglerProcess.stderr?.setEncoding('utf8')
-
-    wranglerProcess.stdout?.on('data', (data: string) => {
-      // console.log(`[wrangler] ${data}`)
-      console.log(data)
-    })
-
-    wranglerProcess.stderr?.on('data', (data: string) => {
-      // console.error(`[wrangler] ${data}`)
-      console.error(data)
-    })
-
-    await new Promise<void>((resolve) => {
-      const onData = (data: string) => {
-        if (data.includes('Ready on')) {
-          wranglerProcess?.stdout?.off('data', onData)
-          resolve()
-        }
-      }
-      wranglerProcess?.stdout?.on('data', onData)
-    })
-
-    console.log(`Wrangler dev server ready on port ${syncPort}`)
-
-    // Wait longer for the Cloudflare Workers runtime to fully initialize
-    // console.log('Waiting for Cloudflare Workers runtime to fully initialize...')
-    // await new Promise(resolve => setTimeout(resolve, 10000))
-
-    return { port: syncPort }
-  }
-
-  const killWranglerProcess = () => {
-    if (wranglerProcess) {
-      console.log('Killing wrangler process...')
-      wranglerProcess.kill('SIGTERM')
-      wranglerProcess = undefined
-    }
-  }
-
-  process.on('exit', killWranglerProcess)
-  process.on('SIGINT', killWranglerProcess)
-  process.on('SIGTERM', killWranglerProcess)
-
-  try {
-    const { afterAll } = await import('vitest')
-    afterAll(() => {
-      killWranglerProcess()
-    })
-  } catch {}
-
-  const { port } = await setup()
-
-  return { port, kill: killWranglerProcess }
-}