@effect/platform 0.79.3 → 0.80.0

package/src/Ndjson.ts

@@ -0,0 +1,493 @@
+/**
+ * @since 1.0.0
+ */
+import { TypeIdError } from "@effect/platform/Error"
+import type * as Cause from "effect/Cause"
+import * as Channel from "effect/Channel"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import { dual, identity } from "effect/Function"
+import type { ParseError } from "effect/ParseResult"
+import type * as Schema from "effect/Schema"
+import * as ChannelSchema from "./ChannelSchema.js"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const ErrorTypeId: unique symbol = Symbol.for("@effect/platform/Ndjson/NdjsonError")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type NdjsonErrorTypeId = typeof ErrorTypeId
+
+const encoder = new TextEncoder()
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class NdjsonError extends TypeIdError(ErrorTypeId, "NdjsonError")<{
+  readonly reason: "Pack" | "Unpack"
+  readonly cause: unknown
+}> {
+  get message() {
+    return this.reason
+  }
+}
+
+/**
+ * Represents a set of options which can be used to control how the newline
+ * delimited JSON is handled.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface NdjsonOptions {
+  /**
+   * Whether or not the newline delimited JSON parser should ignore empty lines.
+   *
+   * Defaults to `false`.
+   *
+   * From the [newline delimited JSON spec](https://github.com/ndjson/ndjson-spec):
+   * ```text
+   * The parser MAY silently ignore empty lines, e.g. \n\n. This behavior MUST
+   * be documented and SHOULD be configurable by the user of the parser.
+   * ```
+   *
+   * @since 1.0.0
+   */
+  readonly ignoreEmptyLines?: boolean
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const packString = <IE = never, Done = unknown>(): Channel.Channel<
+  Chunk.Chunk<string>,
+  Chunk.Chunk<unknown>,
+  IE | NdjsonError,
+  IE,
+  Done,
+  Done
+> => {
+  const loop: Channel.Channel<
+    Chunk.Chunk<string>,
+    Chunk.Chunk<unknown>,
+    IE | NdjsonError,
+    IE,
+    Done,
+    Done
+  > = Channel.readWithCause({
+    onInput: (input: Chunk.Chunk<unknown>) =>
+      Channel.zipRight(
+        Channel.flatMap(
+          Effect.try({
+            try: () => Chunk.of(Chunk.toReadonlyArray(input).map((_) => JSON.stringify(_)).join("\n") + "\n"),
+            catch: (cause) => new NdjsonError({ reason: "Pack", cause })
+          }),
+          Channel.write
+        ),
+        loop
+      ),
+    onFailure: Channel.failCause,
+    onDone: Channel.succeed
+  })
+  return loop
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const pack = <IE = never, Done = unknown>(): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<unknown>,
+  IE | NdjsonError,
+  IE,
+  Done,
+  Done
+> => Channel.mapOut(packString(), Chunk.map((_) => encoder.encode(_)))
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const packSchema = <A, I, R>(
+  schema: Schema.Schema<A, I, R>
+) =>
+<IE = never, Done = unknown>(): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<A>,
+  IE | NdjsonError | ParseError,
+  IE,
+  Done,
+  Done,
+  R
+> => Channel.pipeTo(ChannelSchema.encode(schema)(), pack())
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const packSchemaString = <A, I, R>(
+  schema: Schema.Schema<A, I, R>
+) =>
+<IE = never, Done = unknown>(): Channel.Channel<
+  Chunk.Chunk<string>,
+  Chunk.Chunk<A>,
+  IE | NdjsonError | ParseError,
+  IE,
+  Done,
+  Done,
+  R
+> => Channel.pipeTo(ChannelSchema.encode(schema)(), packString())
+
+const filterEmpty = Chunk.filter<string>((line) => line.length > 0)
+const filterEmptyChannel = <IE, Done>() => {
+  const loop: Channel.Channel<
+    Chunk.Chunk<string>,
+    Chunk.Chunk<string>,
+    IE,
+    IE,
+    Done,
+    Done,
+    never
+  > = Channel.readWithCause({
+    onInput(input: Chunk.Chunk<string>) {
+      const filtered = filterEmpty(input)
+      return Channel.zipRight(Chunk.isEmpty(filtered) ? Channel.void : Channel.write(filtered), loop)
+    },
+    onFailure(cause: Cause.Cause<IE>) {
+      return Channel.failCause(cause)
+    },
+    onDone(done: Done) {
+      return Channel.succeed(done)
+    }
+  })
+  return loop
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const unpackString = <IE = never, Done = unknown>(options?: NdjsonOptions): Channel.Channel<
+  Chunk.Chunk<unknown>,
+  Chunk.Chunk<string>,
+  IE | NdjsonError,
+  IE,
+  Done,
+  Done
+> => {
+  const lines = Channel.splitLines<IE, Done>().pipe(
+    options?.ignoreEmptyLines === true ?
+      Channel.pipeTo(filterEmptyChannel()) :
+      identity
+  )
+  return Channel.mapOutEffect(lines, (chunk) =>
+    Effect.try({
+      try: () => Chunk.map(chunk, (_) => JSON.parse(_)),
+      catch: (cause) => new NdjsonError({ reason: "Unpack", cause })
+    }))
+}
+
+const decodeString = <IE, Done>() => {
+  const decoder = new TextDecoder()
+  const loop: Channel.Channel<
+    Chunk.Chunk<string>,
+    Chunk.Chunk<Uint8Array>,
+    IE,
+    IE,
+    Done,
+    Done,
+    never
+  > = Channel.readWithCause({
+    onInput: (input) =>
+      Channel.zipRight(
+        Channel.write(Chunk.map(input, (_) => decoder.decode(_))),
+        loop
+      ),
+    onFailure: Channel.failCause,
+    onDone: Channel.succeed
+  })
+  return loop
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const unpack = <IE = never, Done = unknown>(options?: NdjsonOptions): Channel.Channel<
+  Chunk.Chunk<unknown>,
+  Chunk.Chunk<Uint8Array>,
+  IE | NdjsonError,
+  IE,
+  Done,
+  Done
+> => {
+  return Channel.pipeTo(decodeString(), unpackString(options))
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const unpackSchema = <A, I, R>(
+  schema: Schema.Schema<A, I, R>
+) =>
+<IE = never, Done = unknown>(options?: NdjsonOptions): Channel.Channel<
+  Chunk.Chunk<A>,
+  Chunk.Chunk<Uint8Array>,
+  NdjsonError | ParseError | IE,
+  IE,
+  Done,
+  Done,
+  R
+> => Channel.pipeTo(unpack(options), ChannelSchema.decodeUnknown(schema)())
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const unpackSchemaString = <A, I, R>(
+  schema: Schema.Schema<A, I, R>
+) =>
+<IE = never, Done = unknown>(options?: NdjsonOptions): Channel.Channel<
+  Chunk.Chunk<A>,
+  Chunk.Chunk<string>,
+  NdjsonError | ParseError | IE,
+  IE,
+  Done,
+  Done,
+  R
+> => Channel.pipeTo(unpackString(options), ChannelSchema.decodeUnknown(schema)())
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const duplex: {
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  (options?: NdjsonOptions): <R, IE, OE, OutDone, InDone>(
+    self: Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, OE, IE | NdjsonError, OutDone, InDone, R>
+  ) => Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, NdjsonError | OE, IE, OutDone, InDone, R>
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  <R, IE, OE, OutDone, InDone>(
+    self: Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, OE, IE | NdjsonError, OutDone, InDone, R>,
+    options?: NdjsonOptions
+  ): Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, NdjsonError | OE, IE, OutDone, InDone, R>
+} = dual((args) => Channel.isChannel(args[0]), <R, IE, OE, OutDone, InDone>(
+  self: Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, OE, IE | NdjsonError, OutDone, InDone, R>,
+  options?: NdjsonOptions
+): Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, NdjsonError | OE, IE, OutDone, InDone, R> =>
+  Channel.pipeTo(
+    Channel.pipeTo(pack(), self),
+    unpack(options)
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const duplexString: {
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  (options?: NdjsonOptions): <R, IE, OE, OutDone, InDone>(
+    self: Channel.Channel<Chunk.Chunk<string>, Chunk.Chunk<string>, OE, IE | NdjsonError, OutDone, InDone, R>
+  ) => Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, NdjsonError | OE, IE, OutDone, InDone, R>
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  <R, IE, OE, OutDone, InDone>(
+    self: Channel.Channel<Chunk.Chunk<string>, Chunk.Chunk<string>, OE, IE | NdjsonError, OutDone, InDone, R>,
+    options?: NdjsonOptions
+  ): Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, NdjsonError | OE, IE, OutDone, InDone, R>
+} = dual((args) => Channel.isChannel(args[0]), <R, IE, OE, OutDone, InDone>(
+  self: Channel.Channel<Chunk.Chunk<string>, Chunk.Chunk<string>, OE, IE | NdjsonError, OutDone, InDone, R>,
+  options?: NdjsonOptions
+): Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, NdjsonError | OE, IE, OutDone, InDone, R> =>
+  Channel.pipeTo(
+    Channel.pipeTo(packString(), self),
+    unpackString(options)
+  ))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const duplexSchema: {
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  <IA, II, IR, OA, OI, OR>(
+    options: Partial<NdjsonOptions> & {
+      readonly inputSchema: Schema.Schema<IA, II, IR>
+      readonly outputSchema: Schema.Schema<OA, OI, OR>
+    }
+  ): <R, InErr, OutErr, OutDone, InDone>(
+    self: Channel.Channel<
+      Chunk.Chunk<Uint8Array>,
+      Chunk.Chunk<Uint8Array>,
+      OutErr,
+      NdjsonError | ParseError | InErr,
+      OutDone,
+      InDone,
+      R
+    >
+  ) => Channel.Channel<
+    Chunk.Chunk<OA>,
+    Chunk.Chunk<IA>,
+    NdjsonError | ParseError | OutErr,
+    InErr,
+    OutDone,
+    InDone,
+    R | IR | OR
+  >
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  <R, InErr, OutErr, OutDone, InDone, IA, II, IR, OA, OI, OR>(
+    self: Channel.Channel<
+      Chunk.Chunk<Uint8Array>,
+      Chunk.Chunk<Uint8Array>,
+      OutErr,
+      NdjsonError | ParseError | InErr,
+      OutDone,
+      InDone,
+      R
+    >,
+    options: Partial<NdjsonOptions> & {
+      readonly inputSchema: Schema.Schema<IA, II, IR>
+      readonly outputSchema: Schema.Schema<OA, OI, OR>
+    }
+  ): Channel.Channel<
+    Chunk.Chunk<OA>,
+    Chunk.Chunk<IA>,
+    NdjsonError | ParseError | OutErr,
+    InErr,
+    OutDone,
+    InDone,
+    R | IR | OR
+  >
+} = dual(2, <R, InErr, OutErr, OutDone, InDone, IA, II, IR, OA, OI, OR>(
+  self: Channel.Channel<
+    Chunk.Chunk<Uint8Array>,
+    Chunk.Chunk<Uint8Array>,
+    OutErr,
+    NdjsonError | ParseError | InErr,
+    OutDone,
+    InDone,
+    R
+  >,
+  options: Partial<NdjsonOptions> & {
+    readonly inputSchema: Schema.Schema<IA, II, IR>
+    readonly outputSchema: Schema.Schema<OA, OI, OR>
+  }
+): Channel.Channel<
+  Chunk.Chunk<OA>,
+  Chunk.Chunk<IA>,
+  NdjsonError | ParseError | OutErr,
+  InErr,
+  OutDone,
+  InDone,
+  R | IR | OR
+> => ChannelSchema.duplexUnknown(duplex(self, options), options))
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const duplexSchemaString: {
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  <IA, II, IR, OA, OI, OR>(
+    options: Partial<NdjsonOptions> & {
+      readonly inputSchema: Schema.Schema<IA, II, IR>
+      readonly outputSchema: Schema.Schema<OA, OI, OR>
+    }
+  ): <R, InErr, OutErr, OutDone, InDone>(
+    self: Channel.Channel<
+      Chunk.Chunk<string>,
+      Chunk.Chunk<string>,
+      OutErr,
+      NdjsonError | ParseError | InErr,
+      OutDone,
+      InDone,
+      R
+    >
+  ) => Channel.Channel<
+    Chunk.Chunk<OA>,
+    Chunk.Chunk<IA>,
+    NdjsonError | ParseError | OutErr,
+    InErr,
+    OutDone,
+    InDone,
+    R | IR | OR
+  >
+  /**
+   * @since 1.0.0
+   * @category combinators
+   */
+  <R, InErr, OutErr, OutDone, InDone, IA, II, IR, OA, OI, OR>(
+    self: Channel.Channel<
+      Chunk.Chunk<string>,
+      Chunk.Chunk<string>,
+      OutErr,
+      NdjsonError | ParseError | InErr,
+      OutDone,
+      InDone,
+      R
+    >,
+    options: Partial<NdjsonOptions> & {
+      readonly inputSchema: Schema.Schema<IA, II, IR>
+      readonly outputSchema: Schema.Schema<OA, OI, OR>
+    }
+  ): Channel.Channel<
+    Chunk.Chunk<OA>,
+    Chunk.Chunk<IA>,
+    NdjsonError | ParseError | OutErr,
+    InErr,
+    OutDone,
+    InDone,
+    R | IR | OR
+  >
+} = dual(2, <R, InErr, OutErr, OutDone, InDone, IA, II, IR, OA, OI, OR>(
+  self: Channel.Channel<
+    Chunk.Chunk<string>,
+    Chunk.Chunk<string>,
+    OutErr,
+    NdjsonError | ParseError | InErr,
+    OutDone,
+    InDone,
+    R
+  >,
+  options: Partial<NdjsonOptions> & {
+    readonly inputSchema: Schema.Schema<IA, II, IR>
+    readonly outputSchema: Schema.Schema<OA, OI, OR>
+  }
+): Channel.Channel<
+  Chunk.Chunk<OA>,
+  Chunk.Chunk<IA>,
+  NdjsonError | ParseError | OutErr,
+  InErr,
+  OutDone,
+  InDone,
+  R | IR | OR
+> => ChannelSchema.duplexUnknown(duplexString(self, options), options))

package/src/SocketServer.ts

@@ -0,0 +1,79 @@
+/**
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import type * as Effect from "effect/Effect"
+import type * as Socket from "./Socket.js"
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export class SocketServer extends Context.Tag("@effect/platform/SocketServer")<
+  SocketServer,
+  {
+    readonly address: Address
+    readonly run: <R, E, _>(
+      handler: (socket: Socket.Socket) => Effect.Effect<_, E, R>
+    ) => Effect.Effect<never, SocketServerError, R>
+  }
+>() {}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export const ErrorTypeId: unique symbol = Symbol.for("@effect/platform/SocketServer/SocketServerError")
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export type ErrorTypeId = typeof ErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class SocketServerError extends Data.TaggedError("SocketServerError")<{
+  readonly reason: "Open" | "Unknown"
+  readonly cause: unknown
+}> {
+  /**
+   * @since 1.0.0
+   */
+  readonly [ErrorTypeId]: ErrorTypeId = ErrorTypeId
+
+  /**
+   * @since 1.0.0
+   */
+  get message(): string {
+    return this.reason
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Address = UnixAddress | TcpAddress
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface TcpAddress {
+  readonly _tag: "TcpAddress"
+  readonly hostname: string
+  readonly port: number
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface UnixAddress {
+  readonly _tag: "UnixAddress"
+  readonly path: string
+}

package/src/Transferable.ts

@@ -17,8 +17,8 @@ export interface CollectorService {
   readonly unsafeAddAll: (_: Iterable<globalThis.Transferable>) => void
   readonly read: Effect.Effect<Array<globalThis.Transferable>>
   readonly unsafeRead: () => Array<globalThis.Transferable>
-  readonly unsafeClear: () => void
-  readonly clear: Effect.Effect<void>
+  readonly unsafeClear: () => Array<globalThis.Transferable>
+  readonly clear: Effect.Effect<Array<globalThis.Transferable>>
 }
 
 /**
@@ -35,15 +35,16 @@ export class Collector extends Context.Tag("@effect/platform/Transferable/Collec
  * @category constructors
  */
 export const unsafeMakeCollector = (): CollectorService => {
-  const tranferables: Array<globalThis.Transferable> = []
+  let tranferables: Array<globalThis.Transferable> = []
   const unsafeAddAll = (transfers: Iterable<globalThis.Transferable>): void => {
-    for (const transfer of transfers) {
-      tranferables.push(transfer)
-    }
+    // eslint-disable-next-line no-restricted-syntax
+    tranferables.push(...transfers)
   }
   const unsafeRead = (): Array<globalThis.Transferable> => tranferables
-  const unsafeClear = (): void => {
-    tranferables.length = 0
+  const unsafeClear = (): Array<globalThis.Transferable> => {
+    const prev = tranferables
+    tranferables = []
+    return prev
   }
   return Collector.of({
     unsafeAddAll,

package/src/Url.ts

@@ -194,9 +194,9 @@ export const mutate: {
 })
 
 /** @internal */
-const immutableURLSetter = <P extends keyof URL>(property: P): {
-  (value: URL[P]): (url: URL) => URL
-  (url: URL, value: URL[P]): URL
+const immutableURLSetter = <P extends keyof URL, A = never>(property: P): {
+  (value: URL[P] | A): (url: URL) => URL
+  (url: URL, value: URL[P] | A): URL
 } =>
   dual(2, (url: URL, value: URL[P]) =>
     mutate(url, (url) => {
@@ -354,14 +354,14 @@ export const setPort: {
    * @since 1.0.0
    * @category Setters
    */
-  (port: string): (url: URL) => URL
+  (port: string | number): (url: URL) => URL
   /**
    * Updates the port of the URL.
    *
    * @since 1.0.0
    * @category Setters
    */
-  (url: URL, port: string): URL
+  (url: URL, port: string | number): URL
 } = immutableURLSetter("port")
 
 /**

package/src/UrlParams.ts

@@ -21,7 +21,7 @@ export interface UrlParams extends ReadonlyArray<readonly [string, string]> {}
  * @category models
  */
 export type Input =
-  | Readonly<Record<string, Coercible | ReadonlyArray<Coercible>>>
+  | CoercibleRecord
   | Iterable<readonly [string, Coercible]>
   | URLSearchParams
 
@@ -31,13 +31,35 @@ export type Input =
  */
 export type Coercible = string | number | bigint | boolean | null | undefined
 
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface CoercibleRecord {
+  readonly [key: string]: Coercible | ReadonlyArray<Coercible> | CoercibleRecord
+}
+
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const fromInput = (input: Input): UrlParams => {
+  const parsed = fromInputNested(input)
+  const out: Array<[string, string]> = []
+  for (let i = 0; i < parsed.length; i++) {
+    if (Array.isArray(parsed[i][0])) {
+      const [keys, value] = parsed[i] as [Array<string>, string]
+      out.push([`${keys[0]}[${keys.slice(1).join("][")}]`, value])
+    } else {
+      out.push(parsed[i] as [string, string])
+    }
+  }
+  return out
+}
+
+const fromInputNested = (input: Input): Array<[string | Array<string>, any]> => {
   const entries = Symbol.iterator in input ? Arr.fromIterable(input) : Object.entries(input)
-  const out: Array<readonly [string, string]> = []
+  const out: Array<[string | Array<string>, string]> = []
   for (const [key, value] of entries) {
     if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
@@ -45,6 +67,11 @@ export const fromInput = (input: Input): UrlParams => {
           out.push([key, String(value[i])])
         }
       }
+    } else if (typeof value === "object") {
+      const nested = fromInputNested(value as CoercibleRecord)
+      for (const [k, v] of nested) {
+        out.push([[key, ...(typeof k === "string" ? [k] : k)], v])
+      }
     } else if (value !== undefined) {
       out.push([key, String(value)])
     }