@livestore/utils-dev 0.0.0-snapshot-1c345a0e6695466bdc7c4483444e7b3513620261 → 0.0.0-snapshot-92c31f56117b4fd377b66f55163ed565795c5e4c

package/src/node-vitest/Vitest.ts

@@ -0,0 +1,221 @@
+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 =
+  <R1 = never, E1 = never>(ctxParams: WithTestCtxParams<R1, E1>) =>
+  (testContext: Vitest.TestContext) =>
+    withTestCtx(testContext, ctxParams)
+
+export type WithTestCtxParams<R1 = never, E1 = never> = {
+  suffix?: string
+  makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
+  timeout?: Duration.DurationInput
+  forceOtel?: boolean
+}
+
+export const withTestCtx =
+  <R1 = never, E1 = never>(
+    testContext: Vitest.TestContext,
+    {
+      suffix,
+      makeLayer,
+      timeout = IS_CI ? 60_000 : 10_000,
+      forceOtel = false,
+    }: {
+      suffix?: string
+      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
+      timeout?: Duration.DurationInput
+      forceOtel?: boolean
+    } = {},
+  ) =>
+  <A, E>(
+    self: Effect.Effect<A, E, Scope.Scope | OtelTracer.OtelTracer | R1>,
+  ): Effect.Effect<A, E | Cause.TimeoutException | E1, Scope.Scope> => {
+    const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix ? `:${suffix}` : ''}`
+    const layer = makeLayer?.(testContext)
+
+    const otelLayer =
+      DEBUGGER_ACTIVE || forceOtel
+        ? OtelLiveHttp({ rootSpanName: spanName, serviceName: 'vitest-runner', skipLogUrl: false })
+        : OtelLiveDummy
+
+    const combinedLayer = (layer ?? Layer.empty).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/node-vitest/mod.ts

@@ -1 +1,3 @@
-export * as Vitest from '@effect/vitest'
+import './global.ts'
+
+export * as Vitest from './Vitest.ts'

package/dist/node-vitest/polyfill.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=polyfill.d.ts.map

package/dist/node-vitest/polyfill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../src/node-vitest/polyfill.ts"],"names":[],"mappings":""}

package/dist/node-vitest/polyfill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"polyfill.js","sourceRoot":"","sources":["../../src/node-vitest/polyfill.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC,KAAK,GAAG,IAAI,CAAA"}