effect 4.0.6 → 4.0.7

package/src/sql/Migrator.ts

@@ -98,7 +98,8 @@ export class MigrationError extends Data.TaggedError("MigrationError")<{
 /**
  * Creates a migrator that ensures the migrations table exists, runs pending
  * migrations in a transaction, and optionally dumps the schema after successful
- * migrations.
+ * migrations. ClickHouse runs without a transaction and records each migration
+ * only after it succeeds.
  *
  * @stability unstable
  * @category constructors
@@ -240,6 +241,12 @@ ORDER BY migration_id`,
 
     // === run
 
+    // BEGIN is still experimental on clickhouse
+    const transactional = sql.onDialectOrElse({
+      clickhouse: () => false,
+      orElse: () => true
+    })
+
     const run = Effect.gen(function*() {
       yield* sql.onDialectOrElse({
         pg: () => sql`LOCK TABLE ${sql(table)} IN ACCESS EXCLUSIVE MODE`,
@@ -279,7 +286,8 @@ ORDER BY migration_id`,
         ])
       }
 
-      if (required.length > 0) {
+      // rows recorded up front are only rolled back inside a transaction
+      if (transactional && required.length > 0) {
         yield* pipe(
           insertMigrations(required.map(([id, name]) => [id, name])),
           Effect.mapError((error): MigrationError | SqlError =>
@@ -298,6 +306,7 @@ ORDER BY migration_id`,
         ([id, name, effect]) =>
           Effect.logDebug(`Running migration`).pipe(
             Effect.flatMap(() => runMigration(id, name, effect)),
+            Effect.andThen(transactional ? Effect.void : insertMigrations([[id, name]])),
             Effect.annotateLogs("migration_id", String(id)),
             Effect.annotateLogs("migration_name", name),
             Effect.withSpan(`Migrator ${id}_${name}`)
@@ -325,11 +334,7 @@ ORDER BY migration_id`,
     yield* ensureMigrationsTable
 
     const completed = yield* pipe(
-      sql.onDialectOrElse({
-        // BEGIN is still experimental on clickhouse
-        clickhouse: () => run,
-        orElse: () => sql.withTransaction(run)
-      }),
+      transactional ? sql.withTransaction(run) : run,
       Effect.catchTag("MigrationError", (_) =>
         _.kind === "Locked"
           ? Effect.as(Effect.logDebug(_.message), [])

package/src/sql/SqlClient.ts

@@ -15,6 +15,7 @@ import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
 import { identity } from "../Function.ts"
+import { CurrentTransactionService } from "../internal/sql.ts"
 import * as Option from "../Option.ts"
 import { hasProperty } from "../Predicate.ts"
 import type * as Queue from "../Queue.ts"
@@ -87,8 +88,7 @@ export interface SqlClient extends Constructor {
    * enclosing `Reactivity.withBatch`. Only the `Reactivity` service read from
    * the transaction's context defers, and a fiber that outlives the
    * transaction can't defer through it, as with `afterCommit`. Transactions
-   * that don't go through `makeWithTransaction`, such as those of
-   * `@effect/sql-sqlite-do`, invalidate immediately.
+   * that don't go through `makeWithTransaction` invalidate immediately.
    */
   readonly withTransaction: <R, E, A>(
     self: Effect.Effect<A, E, R>
@@ -136,8 +136,8 @@ export interface SqlClient extends Constructor {
    * long-running work.
    * Registering after the transaction has ended is a defect.
    *
-   * Transactions that don't go through `makeWithTransaction`, such as those
-   * of `@effect/sql-sqlite-do`, run callbacks immediately.
+   * Transactions that don't go through `makeWithTransaction` run callbacks
+   * immediately.
    */
   readonly afterCommit: <R>(effect: Effect.Effect<void, never, R>) => Effect.Effect<void, never, R>
 
@@ -525,6 +525,12 @@ const makeAfterCommit =
  * failure or interruption. Releases nested savepoints when `releaseSavepoint`
  * is provided.
  *
+ * **Details**
+ *
+ * Transactions started this way are also recognized by `SqlResolver` when the
+ * caller's context has no `SqlClient`, so their requests don't share a batch
+ * with requests outside the transaction.
+ *
  * @stability unstable
  * @category transactions
  * @since 4.0.0
@@ -612,6 +618,7 @@ export const makeWithTransaction = <I, S>(options: {
                         restore(effect),
                         services.pipe(
                           Context.add(options.transactionService, level),
+                          Context.add(CurrentTransactionService, options.transactionService),
                           reactivity ? Context.add(Reactivity, deferInvalidations(reactivity)) : identity,
                           Context.add(transactionSemaphore, Semaphore.makeUnsafe(1)),
                           Context.add(Tracer.ParentSpan, span)

package/src/sql/SqlResolver.ts

@@ -8,6 +8,10 @@
  * grouped, id-based, and side-effect-only resolver constructors, and keeps
  * batches separated by the active SQL transaction connection.
  *
+ * The active transaction is found through the `SqlClient` in each request's
+ * context, and otherwise through the innermost transaction started with
+ * `SqlClient.makeWithTransaction`.
+ *
  * Only the transaction connection separates batches. Other differences in
  * caller services do not: `execute` and result decoding are provided with the
  * first entry's context, while request encoding uses each entry's own context.
@@ -27,6 +31,7 @@ import * as Effect from "../Effect.ts"
 import * as Equal from "../Equal.ts"
 import * as Exit from "../Exit.ts"
 import * as Hash from "../Hash.ts"
+import { CurrentTransactionService } from "../internal/sql.ts"
 import * as MutableHashMap from "../MutableHashMap.ts"
 import * as Option from "../Option.ts"
 import * as Request from "../Request.ts"
@@ -146,7 +151,7 @@ export const ordered = <Req extends Schema.Constraint, Res extends Schema.Constr
       E | ResultLengthMismatch,
       Req["EncodingServices"] | Res["DecodingServices"] | R
     >,
-    SqlClient.TransactionConnection.Service | undefined
+    object | undefined
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
@@ -204,7 +209,7 @@ export const grouped = <Req extends Schema.Constraint, Res extends Schema.Constr
       E | Schema.SchemaError | Cause.NoSuchElementError,
       Req["EncodingServices"] | Res["DecodingServices"] | R
     >,
-    SqlClient.TransactionConnection.Service | undefined
+    object | undefined
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
@@ -274,7 +279,7 @@ export const findById = <Id extends Schema.Constraint, Res extends Schema.Constr
       E | Schema.SchemaError | Cause.NoSuchElementError,
       Id["EncodingServices"] | Res["DecodingServices"] | R
     >,
-    SqlClient.TransactionConnection.Service | undefined
+    object | undefined
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
@@ -328,7 +333,7 @@ const void_ = <Req extends Schema.Constraint, _, E, R>(
       E | Schema.SchemaError,
       Req["EncodingServices"] | R
     >,
-    SqlClient.TransactionConnection.Service | undefined
+    object | undefined
   >({
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
@@ -429,10 +434,19 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
   return [inputs, byIdMap] as const
 }
 
-function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection.Service | undefined {
+function transactionKey<A>(entry: Request.Entry<A>): object | undefined {
+  // The transaction of the request's `SqlClient`, and the innermost transaction
+  // started with `SqlClient.makeWithTransaction` by any client.
   const client = Context.getOrUndefined(entry.context, SqlClient.SqlClient)
-  if (!client) return undefined
-  const conn = Context.getOrUndefined(entry.context, client.transactionService)
-  if (!conn) return undefined
-  return Equal.byReferenceUnsafe(conn)
+  const clientTransaction = client && Context.getOrUndefined(entry.context, client.transactionService)
+  const currentService = Context.get(entry.context, CurrentTransactionService)
+  const currentTransaction = currentService && Context.getOrUndefined(entry.context, currentService)
+  if (clientTransaction === undefined || clientTransaction === currentTransaction) {
+    return currentTransaction && Equal.byReferenceUnsafe(currentTransaction)
+  }
+  if (currentTransaction === undefined) {
+    return Equal.byReferenceUnsafe(clientTransaction)
+  }
+  // Two different transactions are active, so neither identifies the request on its own.
+  return [Equal.byReferenceUnsafe(clientTransaction), Equal.byReferenceUnsafe(currentTransaction)]
 }

package/src/sql/Statement.ts

@@ -519,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>>,
@@ -838,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,
@@ -945,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
@@ -1088,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"
@@ -1222,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)
@@ -1248,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)) {
@@ -1267,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)) {
@@ -1686,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/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.