effect 4.0.4 → 4.0.6

package/src/rpc/RpcServer.ts

@@ -12,6 +12,7 @@
  * @since 4.0.0
  */
 import type { NonEmptyReadonlyArray } from "../Array.ts"
+import * as Bytes from "../Bytes.ts"
 import * as Cause from "../Cause.ts"
 import * as Context from "../Context.ts"
 import * as Deferred from "../Deferred.ts"
@@ -513,14 +514,16 @@ const rpcCodecs = (codecFor: RpcSerialization.CodecFor, rpc: Rpc.AnyWithProps):
   let codecs = shared ? sharedRpcCodecs.get(rpc) : undefined
   if (codecs === undefined) {
     const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
+    const parseOptions = Context.get(rpc.annotations, Rpc.ParseOptions)
     codecs = {
-      decode: Schema.decodeUnknownEffect(codecFor(rpc.payloadSchema)) as any,
+      decode: Schema.decodeUnknownEffect(codecFor(rpc.payloadSchema), parseOptions) as any,
       encodeChunk: Schema.encodeUnknownEffect(
         codecFor(
           Schema.NonEmptyArray(Option.isSome(streamSchemas) ? streamSchemas.value.success : Schema.Any)
-        )
+        ),
+        parseOptions
       ) as any,
-      encodeExit: Schema.encodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any))) as any
+      encodeExit: Schema.encodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any)), parseOptions) as any
     }
     if (shared) sharedRpcCodecs.set(rpc, codecs)
   }
@@ -1246,8 +1249,9 @@ export const makeProtocolWithHttpEffect: (
 
     yield* writeRequest(id, constEof)
 
+    // Allow request aborts during response waits without unmasking response construction.
     if (!includesFraming) {
-      const responses = yield* Queue.collect(queue)
+      const responses = yield* Effect.interruptible(Queue.collect(queue))
       // Notification-only batches encode without a response body.
       const encoded = parser.encode(responses)
       return HttpServerResponse.text(encoded === undefined ? "" : encoded as string, {
@@ -1255,12 +1259,12 @@ export const makeProtocolWithHttpEffect: (
       })
     }
 
-    const initialChunk = yield* Pull.catchDone(
+    const initialChunk = yield* Effect.interruptible(Pull.catchDone(
       Queue.takeAll(queue as Queue.Dequeue<Uint8Array, Cause.Done>),
       () => Effect.succeed([])
-    )
+    ))
     if (queue.state._tag === "Done") {
-      return HttpServerResponse.uint8Array(mergeUint8Arrays(initialChunk), {
+      return HttpServerResponse.uint8Array(initialChunk.length === 1 ? initialChunk[0] : Bytes.concat(initialChunk), {
         contentType: serialization.contentType
       })
     }
@@ -1302,19 +1306,6 @@ export const makeProtocolWithHttpEffect: (
   return { protocol, httpEffect } as const
 })
 
-const mergeUint8Arrays = (arrays: ReadonlyArray<Uint8Array>) => {
-  if (arrays.length === 0) return new Uint8Array(0)
-  if (arrays.length === 1) return arrays[0]
-  const length = arrays.reduce((acc, arr) => acc + arr.length, 0)
-  const result = new Uint8Array(length)
-  let offset = 0
-  for (const arr of arrays) {
-    result.set(arr, offset)
-    offset += arr.length
-  }
-  return result
-}
-
 /**
  * Creates an HTTP server `Protocol` and registers its request handler as a POST
  * route on the current `HttpRouter`.

package/src/schema/VariantSchema.ts

@@ -241,9 +241,9 @@ const extract: {
     if (options?.isDefault === true && Schema.isSchema(self)) {
       return self as any
     }
-    const cache = options?.isDefault === true
-      ? self[defaultCacheSymbol] ?? (self[defaultCacheSymbol] = Object.create(null))
-      : self[cacheSymbol] ?? (self[cacheSymbol] = Object.create(null))
+    // own caches only, so extended classes never reuse their parent's variants
+    const cacheKey = options?.isDefault === true ? defaultCacheSymbol : cacheSymbol
+    const cache = Object.hasOwn(self, cacheKey) ? self[cacheKey]! : (self[cacheKey] = Object.create(null))
     if (Object.hasOwn(cache, variant)) {
       return cache[variant] as any
     }
@@ -298,8 +298,11 @@ export interface Class<
   Fields extends Struct.Fields,
   S extends Schema.Top & {
     readonly fields: Schema.Struct.Fields
-  }
-> extends Schema.Class<Self, S, {}>, Struct<Struct_.Simplify<Fields>> {
+  },
+  Variants extends string = never,
+  Default extends string = never,
+  Inherited = {}
+> extends Schema.Class<Self, S, Inherited>, Struct<Struct_.Simplify<Fields>> {
   readonly "Type": Self
   readonly "Encoded": S["Encoded"]
   readonly "DecodingServices": S["DecodingServices"]
@@ -313,7 +316,7 @@ export interface Class<
     options?: {
       readonly disableChecks?: boolean
     } | undefined
-  ): S["Type"]
+  ): S["Type"] & Inherited
 
   make<Args extends Array<any>, X>(
     this: { new(...args: Args): X },
@@ -321,8 +324,57 @@ export interface Class<
   ): X
 
   readonly fields: S["fields"]
+
+  /**
+   * Returns a function that creates a variant schema subclass with this
+   * class's fields plus additional fields, regenerating every variant schema
+   * from the merged fields.
+   *
+   * **Gotchas**
+   *
+   * Fields with the same name replace inherited fields in every variant. A
+   * replacement that omits an inherited field from the default variant does
+   * not remove it from the class schema; the caller must ensure replacements
+   * preserve the base class contract.
+   */
+  readonly extend:
+    & (<Extended = never, Static = {}, Brand = {}>(
+      identifier: string
+    ) => {
+      <const NewFields extends Struct.Fields>(
+        fields: NewFields & Struct.Validate<NewFields, Variants>,
+        annotations?:
+          | Schema.Annotations.Declaration<
+            Extended,
+            readonly [Schema.Struct<ExtractFields<Default, Struct_.Assign<Fields, NewFields>, true>>]
+          >
+          | undefined
+      ): ExtendedClass<Extended, Static, Self & Brand, Struct_.Assign<Fields, NewFields>, Variants, Default>
+      <Extension extends Schema.Struct<Schema.Struct.Fields>>(
+        schema: Extension,
+        annotations?:
+          | Schema.Annotations.Declaration<
+            Extended,
+            readonly [Schema.Struct<ExtractFields<Default, Struct_.Assign<Fields, Extension["fields"]>, true>>]
+          >
+          | undefined
+      ): ExtendedClass<Extended, Static, Self & Brand, Struct_.Assign<Fields, Extension["fields"]>, Variants, Default>
+    })
+    & Schema.Class<Self, S, Inherited>["extend"]
 }
 
+type ExtendedClass<
+  Self,
+  Static,
+  Inherited,
+  Fields extends Struct.Fields,
+  Variants extends string,
+  Default extends string
+> = [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>(...)`" :
+  & Class<Self, Fields, Schema.Struct<ExtractFields<Default, Fields, true>>, Variants, Default, Inherited>
+  & { readonly [V in Variants]: Extract<V, Struct<Fields>> }
+  & Pick<Static, Exclude<keyof Static, keyof Class<any, any, any> | Variants>>
+
 type MissingSelfGeneric<Params extends string = ""> =
   `Missing \`Self\` generic - use \`class Self extends Class<Self>()(${Params}{ ... })\``
 
@@ -444,7 +496,9 @@ export const make = <
       & Class<
         Self,
         Fields,
-        Schema.Struct<ExtractFields<Default, Fields, true>>
+        Schema.Struct<ExtractFields<Default, Fields, true>>,
+        Variants[number],
+        Default
       >
       & {
         readonly [V in Variants[number]]: Extract<V, Struct<Fields>>
@@ -470,24 +524,34 @@ export const make = <
         readonly [Schema.Struct<ExtractFields<Default, typeof fields, true>>]
       >
     ) {
-      const variantStruct = Struct(fields)
-      const schema = extract(variantStruct, options.defaultVariant, {
-        isDefault: true
-      })
-      const SClass = Schema.Class as any
-      class Base extends SClass(identifier)(schema.fields, annotations) {
-        static [TypeId] = fields
+      return makeClass(fields, (defaultFields) => (Schema.Class as any)(identifier)(defaultFields, annotations))
+    }
+  }
+  function makeClass(fields: Struct.Fields, makeSchemaClass: (defaultFields: Schema.Struct.Fields) => any) {
+    const struct = Struct(fields)
+    const SchemaClass = makeSchemaClass(extract(struct, options.defaultVariant, { isDefault: true }).fields)
+    class Base extends SchemaClass {
+      static [TypeId] = fields
+      static extend(identifier: string) {
+        const extend = super.extend(identifier)
+        return (
+          extension: Struct.Fields | Schema.Struct<Schema.Struct.Fields>,
+          annotations?: Schema.Annotations.Declaration<any, readonly [any]>
+        ) =>
+          Schema.isSchema(extension)
+            ? makeClass({ ...fields, ...extension.fields as Struct.Fields }, () => extend(extension, annotations))
+            : makeClass({ ...fields, ...extension }, (defaultFields) => extend(defaultFields, annotations))
       }
-      for (const variant of options.variants) {
-        Object.defineProperty(Base, variant, {
-          value: extract(variantStruct, variant).annotate({
-            id: `${identifier}.${variant}`,
-            title: `${identifier}.${variant}`
-          })
+    }
+    for (const variant of options.variants) {
+      Object.defineProperty(Base, variant, {
+        value: extract(struct, variant).annotate({
+          id: `${SchemaClass.identifier}.${variant}`,
+          title: `${SchemaClass.identifier}.${variant}`
         })
-      }
-      return Base
+      })
     }
+    return Base
   }
   function FieldOnly<const Keys extends ReadonlyArray<Variants[number]>>(keys: Keys) {
     return function<S extends Schema.Top>(schema: S) {

package/src/socket/Socket.ts

@@ -245,7 +245,17 @@ export const readerBytes = (
  *
  * **Details**
  *
- * The `TextDecoder` is created once per acquisition.
+ * Each acquisition has its own streaming decoder. Characters may span binary
+ * frames and pulls; each frame produces one string, possibly empty. A string
+ * frame flushes incomplete characters as U+FFFD before its text. Close code 1000
+ * flushes remaining text once before propagating the close error; other failures
+ * do not flush.
+ *
+ * **Gotchas**
+ *
+ * Binary WebSocket messages share decoder state: incomplete characters carry
+ * into the next binary frame, and BOM handling resets only after a flush. Use
+ * `readerBytes` and decode each frame separately for per-message decoding.
  *
  * @stability unstable
  * @category combinators
@@ -261,14 +271,31 @@ export const readerString = (
 > =>
   Effect.map(self.reader, ({ pull }) => {
     const decoder = new TextDecoder(encoding)
+    const streamOptions = { stream: true }
+    let needsFlush = false
     return Effect.map(pull, (chunk) => {
       const out = new Array<string>(chunk.length)
       for (let i = 0; i < chunk.length; i++) {
         const item = chunk[i]
-        out[i] = typeof item === "string" ? item : decoder.decode(item)
+        if (typeof item === "string") {
+          out[i] = needsFlush ? decoder.decode() + item : item
+          needsFlush = false
+        } else {
+          out[i] = decoder.decode(item, streamOptions)
+          needsFlush = true
+        }
       }
       return out as unknown as NonEmptyReadonlyArray<string>
-    })
+    }).pipe(
+      Effect.catch((error) => {
+        if (needsFlush && error.reason._tag === "SocketCloseError" && error.reason.code === 1000) {
+          needsFlush = false
+          const last = decoder.decode()
+          if (last.length > 0) return Effect.succeed([last] as const)
+        }
+        return Effect.fail(error)
+      })
+    )
   })
 
 const CloseEventTypeId = "~effect/socket/Socket/CloseEvent"
@@ -642,6 +669,10 @@ export const toChannel = <IE = never>(
  * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
  * frames with the optional text encoding.
  *
+ * **Details**
+ *
+ * Uses `readerString` for decoding and close handling.
+ *
  * @stability unstable
  * @category combinators
  * @since 4.0.0
@@ -651,6 +682,10 @@ export const toChannelString: {
    * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
    * frames with the optional text encoding.
    *
+   * **Details**
+   *
+   * Uses `readerString` for decoding and close handling.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
@@ -666,6 +701,10 @@ export const toChannelString: {
    * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
    * frames with the optional text encoding.
    *
+   * **Details**
+   *
+   * Uses `readerString` for decoding and close handling.
+   *
    * @stability unstable
    * @category combinators
    * @since 4.0.0
@@ -686,23 +725,7 @@ export const toChannelString: {
   void,
   NonEmptyReadonlyArray<Uint8Array | string | CloseEvent>,
   IE
-> => toChannelWithReader</**
- * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
- * frames with the optional text encoding.
- *
- * @stability unstable
- * @category combinators
- * @since 4.0.0
- */
-string, /**
- * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
- * frames with the optional text encoding.
- *
- * @stability unstable
- * @category combinators
- * @since 4.0.0
- */
-IE>(self, readerString(self, encoding)))
+> => toChannelWithReader<string, IE>(self, readerString(self, encoding)))
 
 /**
  * Creates a `Socket` to binary `Channel` adapter with a fixed upstream error
@@ -1076,6 +1099,8 @@ export const fromWebSocket = <RO, WS extends WebSocketLike>(
           // resume a pull blocked in another fiber before detaching
           fail(closeError(1006))
           ws.removeEventListener("message", onMessage)
+          // Keep late errors handled when release aborts a pending ws handshake.
+          ws.addEventListener("error", constVoid)
           ws.removeEventListener("error", onError)
           ws.removeEventListener("close", onClose)
           // let the close handshake proceed once nothing is pulling

package/src/sql/Migrator.ts

@@ -139,6 +139,14 @@ export const make = <RD = never>({
   name VARCHAR(255) NOT NULL,
   PRIMARY KEY (migration_id)
 )`,
+      clickhouse: () =>
+        // sqlite's `PRIMARY KEY NOT NULL` is a syntax error here
+        sql`CREATE TABLE IF NOT EXISTS ${sql(table)} (
+  migration_id Int32,
+  created_at DateTime DEFAULT now(),
+  name String
+) ENGINE = MergeTree
+ORDER BY migration_id`,
       pg: () =>
         Effect.flatMap(
           migrationsTableExists(sql, table),
@@ -223,14 +231,12 @@ export const make = <RD = never>({
       name: string,
       effect: Effect.Effect<unknown, unknown, Client.SqlClient>
     ) =>
-      Effect.catch(effect, (error: unknown) =>
-        Effect.die(
-          new MigrationError({
-            cause: error,
-            kind: "Failed",
-            message: `Migration "${id}_${name}" failed`
-          })
-        ))
+      Effect.mapError(effect, (error) =>
+        new MigrationError({
+          cause: error,
+          kind: "Failed",
+          message: `Migration "${id}_${name}" failed`
+        }))
 
     // === run
 
@@ -319,7 +325,11 @@ export const make = <RD = never>({
     yield* ensureMigrationsTable
 
     const completed = yield* pipe(
-      sql.withTransaction(run),
+      sql.onDialectOrElse({
+        // BEGIN is still experimental on clickhouse
+        clickhouse: () => run,
+        orElse: () => sql.withTransaction(run)
+      }),
       Effect.catchTag("MigrationError", (_) =>
         _.kind === "Locked"
           ? Effect.as(Effect.logDebug(_.message), [])