effect 4.0.6 → 4.1.0

package/src/sql/MigratorFileSystem.ts

@@ -0,0 +1,71 @@
+/**
+ * Loads SQL migrations by reading a directory.
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Effect from "../Effect.ts"
+import { FileSystem } from "../FileSystem.ts"
+import * as Option from "../Option.ts"
+import { Path } from "../Path.ts"
+import { type Loader, MigrationError, type ResolvedMigration } from "./Migrator.ts"
+
+// Kept out of `Migrator.ts` and the `effect/sql` barrel: Metro rejects the
+// non-literal `import()` below in any module it bundles.
+
+/**
+ * Creates a migration loader that reads a directory with `FileSystem`, imports
+ * files named `<id>_<name>.js`, `<id>_<name>.ts`,
+ * `<id>_<name>.mjs`, or `<id>_<name>.mts`, and sorts migrations by id.
+ *
+ * **Details**
+ *
+ * Requires a `Path` service appropriate for the migration directory's path
+ * syntax. On Windows, prefer a platform-aware implementation such as
+ * `NodePath.layer`; the core `Path.layer` uses POSIX semantics and does not
+ * preserve Windows drive-letter paths.
+ *
+ * @stability unstable
+ * @category loaders
+ * @since 4.0.0
+ */
+export const fromFileSystem: (directory: string) => Loader<FileSystem | Path> = Effect.fnUntraced(function*(directory) {
+  const Fs = yield* FileSystem
+  const path = yield* Path
+  const files = yield* Effect.mapError(
+    Fs.readDirectory(directory),
+    (cause) =>
+      new MigrationError({
+        kind: "Failed",
+        cause,
+        message: "Failed to read migrations directory"
+      })
+  )
+  return files
+    .map((file) => Option.fromNullishOr(file.match(/^(?:.*\/)?(\d+)_([^.]+)\.(js|ts|mjs|mts)$/)))
+    .flatMap(
+      Option.match({
+        onNone: () => [],
+        onSome: ([basename, id, name]): ReadonlyArray<ResolvedMigration> =>
+          [
+            [
+              Number(id),
+              name,
+              // `import` needs a file URL: on Windows an absolute path such as
+              // `D:\migrations\1_init.ts` is rejected by the ESM loader. `orDie` keeps the
+              // failure a defect so `loadMigration` reports it as an import error.
+              Effect.flatMap(Effect.orDie(path.toFileUrl(path.join(directory, basename))), (url) =>
+                Effect.promise(
+                  () =>
+                    import(
+                      /* @vite-ignore */
+                      /* webpackIgnore: true */
+                      url.href
+                    )
+                ))
+            ]
+          ] as const
+      })
+    )
+    .sort(([a], [b]) => a - b);
+})

package/src/sql/SqlClient.ts

@@ -15,12 +15,12 @@ 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"
 import { type KeysInput, Reactivity } from "../reactivity/Reactivity.ts"
 import type { ReadonlyRecord } from "../Record.ts"
-import { UnhandledLogLevel } from "../References.ts"
 import * as Scope from "../Scope.ts"
 import * as Semaphore from "../Semaphore.ts"
 import * as Stream from "../Stream.ts"
@@ -87,8 +87,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 +135,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>
 
@@ -430,13 +429,7 @@ export const makeSqliteAcquirers = <C extends Connection.Connection>(options: {
     })
   })
 
-  const lease = Effect.uninterruptibleMask((restore) =>
-    Effect.flatMap(Effect.scope, (scope) =>
-      restore(semaphore.take(1)).pipe(
-        Effect.andThen(Scope.addFinalizer(scope, semaphore.release(1))),
-        Effect.andThen(available)
-      ))
-  )
+  const lease = Effect.uninterruptibleMask((restore) => Effect.andThen(restore(semaphore.takeScoped(1)), available))
 
   return {
     acquirer: lease,
@@ -488,14 +481,7 @@ interface AfterCommitBuffer {
 const afterCommitBuffers = new WeakMap<object, AfterCommitBuffer>()
 
 const runAfterCommit = <R>(effect: Effect.Effect<void, never, R>): Effect.Effect<void, never, R> =>
-  Effect.catchCause(effect, (cause) =>
-    Effect.withFiber((fiber) => {
-      const unhandledLogLevel = fiber.getRef(UnhandledLogLevel)
-      if (unhandledLogLevel) {
-        return Effect.logWithLevel(unhandledLogLevel)("Unhandled error in SqlClient.afterCommit callback", cause)
-      }
-      return Effect.void
-    }))
+  Effect.ignoreCause(effect, { log: "Unhandled", message: "Unhandled error in SqlClient.afterCommit callback" })
 
 const makeAfterCommit =
   (transactionService: Context.Key<any, any>) =>
@@ -525,6 +511,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 +604,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

@@ -11,6 +11,7 @@
  * @stability unstable
  * @since 4.0.0
  */
+import type * as Arr from "../Array.ts"
 import { Clock } from "../Clock.ts"
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
@@ -278,7 +279,7 @@ export const arrayHelper = (value: ReadonlyArray<unknown | Fragment>): ArrayHelp
  */
 export interface RecordInsertHelper {
   readonly _tag: "RecordInsertHelper"
-  readonly value: ReadonlyArray<Record<string, unknown>>
+  readonly value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
   /**
    * @internal
    */
@@ -305,7 +306,7 @@ const RecordInsertHelperProto = {
  * @since 4.0.0
  */
 export const recordInsertHelper = (
-  value: ReadonlyArray<Record<string, unknown>>
+  value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
 ): RecordInsertHelper =>
   Object.assign(Object.create(RecordInsertHelperProto), {
     value,
@@ -322,7 +323,7 @@ export const recordInsertHelper = (
  */
 export interface RecordUpdateHelper {
   readonly _tag: "RecordUpdateHelper"
-  readonly value: ReadonlyArray<Record<string, unknown>>
+  readonly value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
   readonly alias: string
   /**
    * @internal
@@ -345,7 +346,7 @@ const RecordUpdateHelperProto = {
  * @since 4.0.0
  */
 export const recordUpdateHelper = (
-  value: ReadonlyArray<Record<string, unknown>>,
+  value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>,
   alias: string
 ): RecordUpdateHelper =>
   Object.assign(Object.create(RecordUpdateHelperProto), {
@@ -502,7 +503,7 @@ export interface Constructor {
 
   readonly insert: {
     (
-      value: ReadonlyArray<Record<string, unknown>>
+      value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>
     ): RecordInsertHelper
     (value: Record<string, unknown>): RecordInsertHelper
   }
@@ -519,9 +520,12 @@ 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>>,
+    value: Arr.NonEmptyReadonlyArray<Record<string, unknown>>,
     alias: string
   ) => RecordUpdateHelper
 
@@ -628,7 +632,7 @@ export const make = (
       in: in_,
       insert(value: any) {
         return recordInsertHelper(
-          Array.isArray(value) ? value : [value]
+          Array.isArray(value) ? value as Arr.NonEmptyArray<Record<string, unknown>> : [value]
         )
       },
       update(value: any, omit: any) {
@@ -838,6 +842,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 +953,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 +1109,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 +1243,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 +1269,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 +1290,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 +1711,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/sql/index.ts

@@ -3,7 +3,7 @@
  * @since 4.0.0
  */
 
-// @barrel: Auto-generated exports. Do not edit manually.
+// @barrel(!(MigratorFileSystem).ts): Auto-generated exports. Do not edit manually.
 
 /**
  * @stability unstable

package/src/testing/index.ts

@@ -17,12 +17,6 @@ export * as TestClock from "./TestClock.ts"
  */
 export * as TestConsole from "./TestConsole.ts"
 
-/**
- * @stability unstable
- * @since 4.0.0
- */
-export * as TestCrypto from "./TestCrypto.ts"
-
 /**
  * @stability unstable
  * @since 4.0.0

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/internal/crypto.ts

@@ -1,17 +1,21 @@
+import * as Digest from "../../crypto/Digest.ts"
+import { webCryptoDigest } from "../../crypto/internal/digest.ts"
+import { WebCrypto } from "../../crypto/WebCrypto.ts"
 import * as Effect from "../../Effect.ts"
+import * as Hex from "../../encoding/Hex.ts"
+
+const encoder = new TextEncoder()
 
 /**
+ * Execution ids and idempotency keys are persisted, so they keep the first 16
+ * bytes of the SHA-256 digest as 32 hex characters.
+ *
  * @internal
  */
-export const makeHashDigest = (original: string) =>
-  Effect.map(
-    Effect.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(original))),
-    (buffer) => {
-      const data = new Uint8Array(buffer)
-      let hexString = ""
-      for (let i = 0; i < 16; i++) {
-        hexString += data[i].toString(16).padStart(2, "0")
-      }
-      return hexString
-    }
+export const makeHashDigest = (original: string): Effect.Effect<string> =>
+  WebCrypto.use((crypto) =>
+    Effect.map(
+      webCryptoDigest(crypto, Digest.sha256, encoder.encode(original)),
+      (bytes) => Hex.encode(bytes).slice(0, 32)
+    )
   )