effect 4.0.5 → 4.0.7

package/src/sql/Statement.ts

@@ -115,7 +115,9 @@ export const CurrentTransformer = Context.Reference<Transformer | undefined>("ef
 
 /**
  * Parents driver spans under the statement span for every client in the current scope,
- * including acquisition and stream pulls. Defaults to `false`; ignored when tracing is disabled.
+ * including acquisition and stream pulls, and records how long each statement
+ * waited for a connection as `db.client.connection.wait_time_ms`. Defaults to
+ * `false`; ignored when tracing is disabled.
  *
  * @stability unstable
  * @category services
@@ -517,6 +519,9 @@ export interface Constructor {
    * **Gotchas**
    *
    * Not supported in sqlite.
+   *
+   * The alias is escaped as an identifier and is not passed through name
+   * transforms.
    */
   readonly updateValues: (
     value: ReadonlyArray<Record<string, unknown>>,
@@ -836,6 +841,10 @@ export type CompilerOptions<C extends Custom<any, any, any, any> = any> = {
   readonly dialect: Dialect
   readonly placeholder: (index: number, value: unknown) => string
   readonly onIdentifier: (value: string, withoutTransform: boolean) => string
+  /**
+   * Renders `updateValues`. The `alias` is already escaped with
+   * `onIdentifier(alias, true)` and must be inserted as is.
+   */
   readonly onRecordUpdate: (
     placeholders: string,
     alias: string,
@@ -943,6 +952,19 @@ const CompilerProto = {
         }
 
         case "ArrayHelper": {
+          if (segment.value.length === 0) {
+            const inKeyword = emptyInKeyword.exec(sql)
+            if (inKeyword === null || isInLineComment(sql, inKeyword.index)) {
+              sql += "()"
+            } else if (this.dialect === "pg") {
+              // an empty subquery is typed as text in postgres, so compare with an
+              // empty array, which takes the type of the left operand instead
+              sql = sql.slice(0, inKeyword.index) + (inKeyword[1] ? "<> ALL('{}')" : "= ANY('{}')")
+            } else {
+              sql += "(SELECT NULL WHERE 1=0)"
+            }
+            break
+          }
           sql += `(${placeholders(segment.value)})`
           binds.push.apply(binds, segment.value as any)
           break
@@ -1086,7 +1108,7 @@ const CompilerProto = {
           }
           const [s, b] = opts.onRecordUpdate(
             placeholders,
-            segment.alias,
+            opts.onIdentifier(segment.alias, true),
             generateColumns(keys, opts.onIdentifier, withoutTransform),
             values,
             typeof segment.returningIdentifier === "string"
@@ -1220,7 +1242,7 @@ export const defaultTransforms = (
 ) => {
   const transformValue = (value: any) => {
     if (Array.isArray(value)) {
-      if (value.length === 0 || value[0].constructor !== Object) {
+      if (value.length === 0 || value[0]?.constructor !== Object) {
         return value
       }
       return array(value)
@@ -1246,6 +1268,8 @@ export const defaultTransforms = (
       const row = rows[i]
       if (Array.isArray(row)) {
         newRows[i] = transformArrayNested(row) as any
+      } else if (row === null || typeof row !== "object") {
+        newRows[i] = row
       } else {
         const obj: any = {}
         for (const [key, value] of Object.entries(row)) {
@@ -1265,6 +1289,8 @@ export const defaultTransforms = (
       const row = rows[i]
       if (Array.isArray(row)) {
         newRows[i] = transformArray(row) as any
+      } else if (row === null || typeof row !== "object") {
+        newRows[i] = row
       } else {
         const obj: any = {}
         for (const [key, value] of Object.entries(row)) {
@@ -1328,6 +1354,7 @@ export const spanName = (spanAttributes: ReadonlyArray<readonly [string, unknown
 // internal
 
 const ATTR_DB_QUERY_TEXT = "db.query.text"
+const ATTR_DB_CLIENT_CONNECTION_WAIT_TIME = "db.client.connection.wait_time_ms"
 const ATTR_SQL_METHOD = "effect.sql.method"
 
 // the last value wins, matching the order the attributes are applied to spans
@@ -1435,12 +1462,19 @@ const StatementProto: Omit<
       }
       span.attribute(ATTR_SQL_METHOD, operation)
       span.attribute(ATTR_DB_QUERY_TEXT, sql)
+      const propagate = fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled)
+      const clock = propagate ? waitClock(fiber) : undefined
+      const run = clock === undefined
+        ? (connection: Connection) => f(connection, sql, params)
+        : (connection: Connection) =>
+          Effect.suspend(() => {
+            recordConnectionWait(span, clock)
+            return f(connection, sql, params)
+          })
       const execute = this.borrower === undefined
-        ? Effect.scoped(Effect.flatMap(this.acquirer, (_) => f(_, sql, params)))
-        : this.borrower((connection: Connection) => f(connection, sql, params))
-      return fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled)
-        ? Effect.provideService(execute, Tracer.ParentSpan, span)
-        : execute
+        ? Effect.scoped(Effect.flatMap(this.acquirer, run))
+        : this.borrower(run)
+      return propagate ? Effect.provideService(execute, Tracer.ParentSpan, span) : execute
     })
   },
 
@@ -1472,8 +1506,13 @@ const StatementProto: Omit<
           }
           span.attribute(ATTR_SQL_METHOD, "executeStream")
           span.attribute(ATTR_DB_QUERY_TEXT, sql)
-          const acquire = Effect.map(self.acquirer, (_) => _.executeStream(sql, params, self.transformRows))
-          return fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled)
+          const propagate = fiber.cache.tracerEnabled && fiber.getRef(SpanPropagationEnabled)
+          const clock = propagate ? waitClock(fiber) : undefined
+          const acquire = Effect.map(self.acquirer, (connection) => {
+            if (clock !== undefined) recordConnectionWait(span, clock)
+            return connection.executeStream(sql, params, self.transformRows)
+          })
+          return propagate
             ? Effect.succeed(Stream.provideService(Stream.unwrap(acquire), Tracer.ParentSpan, span))
             : acquire
         })
@@ -1540,6 +1579,18 @@ const StatementProto: Omit<
   }
 }
 
+// Without span timing, the span has no start time to measure from.
+const waitClock = (fiber: Fiber.Fiber<unknown, unknown>): Clock | undefined =>
+  fiber.getRef(TracerTimingEnabled) ? fiber.getRef(Clock) : undefined
+
+// Measured from the statement span's start to the connection hand-off, so it
+// also covers compiling the statement and any `CurrentTransformer` run first.
+const recordConnectionWait = (span: Tracer.Span, clock: Clock): void =>
+  span.attribute(
+    ATTR_DB_CLIENT_CONNECTION_WAIT_TIME,
+    Number(clock.currentTimeNanosUnsafe() - span.status.startTime) / 1e6
+  )
+
 const withStatement = <A, X, E, R>(
   self: StatementImpl<A>,
   span: Tracer.Span,
@@ -1659,3 +1710,7 @@ function in_(): Fragment | ArrayHelper {
 }
 
 const neverFragment = fragment([literal("1=0")])
+
+const emptyInKeyword = /\b(NOT\s+)?IN\s*$/i
+
+const isInLineComment = (sql: string, index: number) => sql.lastIndexOf("--", index) > sql.lastIndexOf("\n", index)

package/src/testing/TestClock.ts

@@ -13,6 +13,7 @@
  */
 import * as Arr from "../Array.ts"
 import * as Clock from "../Clock.ts"
+import * as Console from "../Console.ts"
 import * as Context from "../Context.ts"
 import * as Data from "../Data.ts"
 import * as Duration from "../Duration.ts"
@@ -286,6 +287,7 @@ const makeWithScheduler = Effect.fnUntraced(function*(
   }> = []
   const currentClock = yield* Clock.clockWith(Effect.succeed)
   const liveClock = liveClocks.get(currentClock) ?? currentClock
+  const liveConsole = yield* Console.Console
   const warningSemaphore = yield* Semaphore.make(1)
   const parentScheduler = yield* Scheduler.Scheduler
 
@@ -322,6 +324,7 @@ const makeWithScheduler = Effect.fnUntraced(function*(
     Effect.suspend(() => {
       if (warningState._tag === "Start") {
         return Effect.logWarning(warningMessage).pipe(
+          Effect.provideService(Console.Console, liveConsole),
           Effect.delay(config.warningDelay),
           withLive,
           Effect.forkChild,
@@ -447,7 +450,7 @@ const makeWithScheduler = Effect.fnUntraced(function*(
       }).pipe(
         Effect.timeoutOrElse({
           duration: config.warningDelay,
-          orElse: () => Effect.logWarning(busyWarningMessage)
+          orElse: () => Effect.provideService(Effect.logWarning(busyWarningMessage), Console.Console, liveConsole)
         }),
         withLive,
         Effect.andThen(Effect.yieldNow)

package/src/testing/TestSchema.ts

@@ -15,7 +15,6 @@
  * @since 4.0.0
  */
 import * as assert from "node:assert"
-import { isDeepStrictEqual } from "node:util"
 import * as Arbitrary from "../Arbitrary.ts"
 import * as Cause from "../Cause.ts"
 import type * as Context from "../Context.ts"
@@ -242,7 +241,7 @@ export class Asserts<S extends Schema.Constraint> {
     }
   }
   /**
-   * Runs a property-based test that encodes arbitrary values and then decodes them, asserting the decoded value equals the original.
+   * Runs a property-based test that encodes arbitrary values and then decodes them, asserting the decoded value is equivalent to the original.
    *
    * **When to use**
    *
@@ -254,6 +253,9 @@ export class Asserts<S extends Schema.Constraint> {
    * The native Schema arbitrary generates values matching the schema's `Type`. The assertion fails with the minimized
    * shrunk input and replay token if any generated value does not round-trip.
    *
+   * Uses {@link Schema.toEquivalence}, including custom equivalence annotations,
+   * to compare each decoded value with the original.
+   *
    * **Example** (Verifying round trips)
    *
    * ```ts import.meta.vitest
@@ -284,6 +286,9 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Details**
    *
+   * Uses {@link Schema.toEquivalence}, including custom equivalence annotations,
+   * to compare each decoded value with the original.
+   *
    * Assertion mismatches are defects containing the shrunk input and replay token.
    * Schema defects and interruption propagate without becoming assertion failures.
    *
@@ -310,6 +315,7 @@ export class Asserts<S extends Schema.Constraint> {
     return Effect.suspend(() => {
       const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
       const encodeEffect = SchemaParser.encodeEffect(this.schema)
+      const equivalence = Schema.toEquivalence(this.schema as unknown as Schema.Schema<S["Type"]>)
       const arbitrary = Arbitrary.schema(this.schema)
       return Arbitrary.checkEffect(
         arbitrary,
@@ -317,7 +323,7 @@ export class Asserts<S extends Schema.Constraint> {
           Effect.suspend(() => encodeEffect(value)).pipe(
             Effect.flatMapEager((encoded) => decodeUnknownEffect(encoded)),
             schemaResult,
-            Effect.mapEager((result) => isDeepStrictEqual(result, Result.succeed(value)))
+            Effect.mapEager((result) => Result.isSuccess(result) && equivalence(result.success, value))
           ),
         options
       ).pipe(Effect.mapEager(assertPropertyPassed))

package/src/workflow/DurableDeferred.ts

@@ -347,6 +347,7 @@ const recordHeld = Effect.fnUntraced(function*<A, E, R>(
 ): Effect.fn.Return<A, E, R | WorkflowEngine | WorkflowInstance> {
   const engine = yield* EngineTag
   const instance = yield* InstanceTag
+  let parked: Cause.Cause<unknown> | undefined
   const exit = yield* Workflow.wrapActivityResult(
     Effect.gen(function*() {
       if (checkCache) {
@@ -374,11 +375,13 @@ const recordHeld = Effect.fnUntraced(function*<A, E, R>(
         Effect.forkChild({ startImmediately: true })
       )
       return yield* Effect.onInterrupt(Fiber.await(fiber), () => Fiber.interrupt(fiber)).pipe(
-        Effect.map((exit) =>
-          local.suspended && Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)
-            ? Option.none()
-            : Option.some(exit)
-        ),
+        Effect.map((exit) => {
+          if (local.suspended && Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) {
+            parked = exit.cause
+            return Option.none()
+          }
+          return Option.some(exit)
+        }),
         // The waits are over once the body has a result. Otherwise every branch
         // parked, or an enclosing race interrupted the body, and the waits move
         // to the enclosing owner, if any, to be released when that race settles.
@@ -398,11 +401,25 @@ const recordHeld = Effect.fnUntraced(function*<A, E, R>(
     Option.isNone
   )
   if (Option.isNone(exit)) {
-    return yield* Workflow.suspend(instance)
+    return yield* suspendWith(instance, parked!)
   }
   return yield* exit.value
 })
 
+/**
+ * Suspends like `Workflow.suspend`, keeping the annotations of the interrupts
+ * that stopped the branches. A branch can stop on an engine interrupt, such as
+ * a runner shutdown abandoning an activity, rather than on a durable wait. The
+ * engine must still see that interrupt to replay the run instead of storing it
+ * as suspended.
+ */
+const suspendWith = (instance: WorkflowInstance["Service"], cause: Cause.Cause<unknown>): Effect.Effect<never> =>
+  Effect.interruptible(Effect.callback<never>(() => {
+    instance.suspended = true
+    const fiber = Fiber.getCurrent()!
+    fiber.interruptUnsafe(fiber.id, Context.omit(Cause.StackTrace)(Cause.annotations(cause)))
+  }))
+
 /**
  * Runs effects as a durable race, returning a previously persisted result when
  * present or completing a named deferred with the first result.

package/src/workflow/WorkflowEngine.ts

@@ -745,11 +745,16 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
       readonly parent: string | undefined
       instance: WorkflowInstance["Service"]
       interrupted: boolean
+      interruptedUnsafe: boolean
       // The strongest wake requested while a run was still finishing.
       resumeRequested: WakeMode | undefined
       fiber: Fiber.Fiber<Workflow.Result<unknown, unknown>> | undefined
       // Completed once a run succeeds with `Complete`, after which it cannot resume.
       readonly done: Deferred.Deferred<void>
+      // Parent of every run's scope. Scopes of runs that suspended stay open
+      // under it, so their finalizers and resources last until the execution
+      // finishes.
+      readonly scope: Scope.Closeable
     }
     const executions = new Map<string, ExecutionState>()
 
@@ -784,15 +789,23 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
       }
 
       const entry = workflows.get(state.instance.workflow._tag)!
-      const instance = WorkflowInstance.initial(
-        state.instance.workflow,
-        state.instance.executionId,
-        { scope: state.instance.scope }
-      )
+      // Like the cluster engine, each run gets a fresh scope, so replays rebuild
+      // compensations instead of registering them again.
+      const instance = WorkflowInstance.initial(state.instance.workflow, state.instance.executionId, {
+        scope: Scope.forkUnsafe(state.scope)
+      })
       state.instance = instance
       state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(
-        Effect.onExit(() => {
-          if (!state.interrupted) {
+        Effect.onExit((exit) => {
+          // Safe interrupts take effect only when the run would suspend;
+          // unsafe interrupts must also survive a replay that completes normally.
+          if (
+            !state.interrupted ||
+            (!state.interruptedUnsafe &&
+              !instance.suspended &&
+              !instance.abandoned &&
+              !(Context.get(instance.workflow.annotations, Workflow.SuspendOnFailure) && Exit.isFailure(exit)))
+          ) {
             return Effect.void
           }
           instance.interrupted = true
@@ -809,9 +822,15 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
           return Effect.forkIn(resume(state.parent, "automatic"), scope)
         }),
         Effect.onExit((exit) => {
-          return Exit.isSuccess(exit) && exit.value._tag === "Complete"
-            ? Deferred.succeed(state.done, void 0)
-            : Effect.void
+          if (Exit.isSuccess(exit) && exit.value._tag === "Suspended") return Effect.void
+          // The final run's scope closes with the real exit. Closing the parent
+          // then closes earlier scopes in reverse order with `Exit.void`, so their
+          // superseded compensations are skipped, which means their finalizers
+          // also observe success rather than the outcome.
+          return Effect.andThen(
+            Scope.close(state.scope, Exit.void),
+            Exit.isSuccess(exit) && exit.value._tag === "Complete" ? Deferred.succeed(state.done, void 0) : Effect.void
+          )
         }),
         Effect.forkIn(entry.scope)
       )
@@ -842,9 +861,11 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
             execute: entry.execute,
             instance: WorkflowInstance.initial(workflow, options.executionId),
             interrupted: false,
+            interruptedUnsafe: false,
             resumeRequested: undefined,
             fiber: undefined,
             done: Deferred.makeUnsafe(),
+            scope: Scope.makeUnsafe(),
             parent: options.detached ? undefined : options.parent?.executionId
           }
           executions.set(options.executionId, state)
@@ -875,9 +896,12 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
         const state = executions.get(executionId)
         if (!state) return
         state.interrupted = true
+        state.interruptedUnsafe = true
         if (state.fiber) {
           yield* Fiber.interrupt(state.fiber)
         }
+        // Replay after hard interruption to record a terminal workflow result.
+        yield* resume(executionId, "explicit")
       }),
       resume(_workflow, executionId) {
         return resume(executionId, "explicit")

package/dist/http/internal/preResponseHandler.d.ts

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

package/dist/http/internal/preResponseHandler.d.ts.map

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

package/dist/http/internal/preResponseHandler.js

@@ -1,14 +0,0 @@
-import * as Effect from "../../Effect.js";
-/**
- * @internal
- */
-export const requestPreResponseHandlers = /*#__PURE__*/new WeakMap();
-/**
- * @internal
- */
-export const appendPreResponseHandlerUnsafe = (request, handler) => {
-  const prev = requestPreResponseHandlers.get(request.source);
-  const next = prev ? (request, response) => Effect.flatMap(prev(request, response), response => handler(request, response)) : handler;
-  requestPreResponseHandlers.set(request.source, next);
-};
-//# sourceMappingURL=preResponseHandler.js.map

package/dist/http/internal/preResponseHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"preResponseHandler.js","names":[],"sources":["../../../src/http/internal/preResponseHandler.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,iBAAiB;AAIzC;;;AAGA,OAAO,MAAM,0BAA0B,gBAAG,IAAI,OAAO,EAA8B;AAEnF;;;AAGA,OAAO,MAAM,8BAA8B,GAAG,CAAC,OAA0B,EAAE,OAA2B,KAAU;EAC9G,MAAM,IAAI,GAAG,0BAA0B,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;EAC3D,MAAM,IAAI,GAAuB,IAAI,GACnC,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAG,QAAQ,IAAK,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,GACtG,OAAO;EACX,0BAA0B,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC;AACtD,CAAC","ignoreList":[]}

package/src/http/internal/preResponseHandler.ts

@@ -1,19 +0,0 @@
-import * as Effect from "../../Effect.ts"
-import type { PreResponseHandler } from "../HttpEffect.ts"
-import type { HttpServerRequest } from "../HttpServerRequest.ts"
-
-/**
- * @internal
- */
-export const requestPreResponseHandlers = new WeakMap<object, PreResponseHandler>()
-
-/**
- * @internal
- */
-export const appendPreResponseHandlerUnsafe = (request: HttpServerRequest, handler: PreResponseHandler): void => {
-  const prev = requestPreResponseHandlers.get(request.source)
-  const next: PreResponseHandler = prev ?
-    (request, response) => Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    : handler
-  requestPreResponseHandlers.set(request.source, next)
-}