effect 4.0.0-rc.113 → 4.0.0-rc.115

package/src/internal/schema/make.ts

@@ -25,10 +25,15 @@ const SchemaProto = {
 /** @internal */
 export function make<S extends Schema.Constraint>(ast: S["ast"], options?: object): S {
   function Schema() {}
-  const self = Object.defineProperties(
-    Object.setPrototypeOf(Schema, SchemaProto),
-    Object.getOwnPropertyDescriptors({ ...options })
-  )
+  const self = Object.setPrototypeOf(Schema, SchemaProto)
+  if (
+    options &&
+    (Object.hasOwn(options, "name") || Object.hasOwn(options, "length") || Object.hasOwn(options, "__proto__"))
+  ) {
+    Object.defineProperties(self, Object.getOwnPropertyDescriptors({ ...options }))
+  } else {
+    Object.assign(self, options)
+  }
   self.ast = ast
   self.rebuild = (ast: SchemaAST.AST) => make(ast, options)
   self.makeEffect = SchemaParser.makeEffect(self)

package/src/internal/schema/toCodeDocument.ts

@@ -484,7 +484,7 @@ export function toCodeDocument(
             `${element.isOptional ? "Schema.optionalKey(" : ""}${type.runtime}${element.isOptional ? ")" : ""}${
               runtimeAnnotate(element.annotations, "annotateKey")
             }`,
-            `${type.Type}${element.isOptional ? "?" : ""}`
+            element.isOptional ? `(${type.Type})?` : type.Type
           )
         })
         const rest = representation.rest.map((item, index) => recur(item, [...path, "rest", index]))
@@ -516,15 +516,15 @@ export function toCodeDocument(
         const properties = representation.propertySignatures.map((property, index) => {
           const isSymbol = typeof property.name === "symbol"
           const name = isSymbol
-            ? addSymbol(property.name)
+            ? `[${addSymbol(property.name)}]`
             : formatPropertyKey(property.name)
           const type = recur(property.type, [...path, "propertySignatures", index, "type"])
           let runtime = type.runtime
           if (property.isMutable) runtime = `Schema.mutableKey(${runtime})`
           if (property.isOptional) runtime = `Schema.optionalKey(${runtime})`
           runtime += runtimeAnnotate(property.annotations, "annotateKey")
-          const runtimeName = isSymbol ? `[${name}]` : name
-          const typeName = `${property.isMutable ? "" : "readonly "}${runtimeName}${property.isOptional ? "?" : ""}`
+          const runtimeName = property.name === "__proto__" ? `[${name}]` : name
+          const typeName = `${property.isMutable ? "" : "readonly "}${name}${property.isOptional ? "?" : ""}`
           return {
             code: makeCode(`${runtimeName}: ${runtime}`, `${typeName}: ${type.Type}`)
           }

package/src/internal/schema/toEquivalence.ts

@@ -153,8 +153,8 @@ function recur(ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>): Equivalenc
       })
     }
     case "Suspend": {
-      const get = SchemaAST.memoizeThunk(() => recur(ast.thunk(), path))
-      return Equivalence.make((a, b) => get()(a, b))
+      let equivalence: Equivalence.Equivalence<any>
+      return Equivalence.make((a, b) => (equivalence ??= recur(ast.thunk(), path))(a, b))
     }
   }
 }

package/src/internal/schema/toFormatter.ts

@@ -222,8 +222,8 @@ export function toFormatter<T>(ast: SchemaAST.AST, options?: {
         }
       }
       case "Suspend": {
-        const get = SchemaAST.memoizeThunk(() => recur(ast.thunk()))
-        return (value) => get()(value)
+        let formatter: Formatter<any>
+        return (value) => (formatter ??= recur(ast.thunk()))(value)
       }
     }
   }

package/src/unstable/cli/Prompt.ts

@@ -447,9 +447,9 @@ export interface FileOptions extends ThemeOptions {
  */
 export interface SelectOptions<A> extends ThemeOptions {
   /**
-   * The message to display in the prompt.
+   * The prompt message. Omit to display only the choices.
    */
-  readonly message: string
+  readonly message?: string | undefined
   /**
    * The choices to display to the user.
    */
@@ -468,6 +468,10 @@ export interface SelectOptions<A> extends ThemeOptions {
  * @since 4.0.0
  */
 export interface AutoCompleteOptions<A> extends SelectOptions<A> {
+  /**
+   * The required prompt message.
+   */
+  readonly message: string
   /**
    * The label used for the filter display (defaults to "filter").
    */
@@ -2699,7 +2703,9 @@ const handleFileProcess = (options: FileOptionsReq) => {
   })
 }
 
-interface SelectOptionsReq<A> extends OptionsReq<SelectOptions<A>> {}
+interface SelectOptionsReq<A> extends SelectOptions<A> {
+  readonly maxPerPage: number
+}
 interface MultiSelectOptionsReq extends MultiSelectOptions {}
 
 type MultiSelectState = {
@@ -2826,7 +2832,7 @@ const renderMultiSelectNextFrame = Effect.fnUntraced(
     const trailingSymbol = annotateSymbol(figures.pointerSmall, figures.mutedColor)
     const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options)
     const error = renderMultiSelectError(state, figures.pointer, figures)
-    return Ansi.cursorHide + promptMsg + "\n" + choices + error
+    return Ansi.cursorHide + withSelectHeader(promptMsg, choices) + error
   }
 )
 
@@ -2839,7 +2845,7 @@ const renderMultiSelectSubmission = Effect.fnUntraced(
     const selectedText = selectedChoices.join(", ")
     const leadingSymbol = annotateSymbol(figures.tick, figures.successColor)
     const trailingSymbol = annotateSymbol(figures.ellipsis, figures.mutedColor)
-    const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options)
+    const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options) ?? leadingSymbol
     return promptMsg + " " + Ansi.annotate(selectedText, figures.submittedColor) + "\n"
   }
 )
@@ -2901,7 +2907,7 @@ const handleMultiSelectClear = <A>(options: SelectOptionsReq<A>) =>
     const promptText = renderSelectOutput(figures.prefix, figures.pointerSmall, options, { plain: true })
     const choicesText = renderMultiSelectChoices(state, options, figures, { plain: true })
     const errorText = renderMultiSelectError(state, figures.pointer, figures, { plain: true })
-    const clearOutput = clearOutputWithError(`${promptText}\n${choicesText}`, columns, errorText)
+    const clearOutput = clearOutputWithError(withSelectHeader(promptText, choicesText), columns, errorText)
     return clearOutput + clearPrompt
   })
 
@@ -3265,7 +3271,6 @@ type AutoCompleteState = {
   readonly filtered: ReadonlyArray<number>
 }
 
-interface SelectOptionsReq<A> extends OptionsReq<SelectOptions<A>> {}
 interface AutoCompleteOptionsReq<A> extends OptionsReq<AutoCompleteOptions<A>> {}
 
 const filterAutoCompleteChoices = <A>(choices: ReadonlyArray<SelectChoice<A>>, query: string) => {
@@ -3302,7 +3307,13 @@ const renderSelectOutput = <A>(
   trailingSymbol: string,
   options: SelectOptionsReq<A>,
   renderOptions?: RenderOptions | undefined
-) => renderPrompt("", options.message, leadingSymbol, trailingSymbol, renderOptions)
+): string | undefined =>
+  options.message === undefined
+    ? undefined
+    : renderPrompt("", options.message, leadingSymbol, trailingSymbol, renderOptions)
+
+const withSelectHeader = (header: string | undefined, body: string): string =>
+  header === undefined ? body : header + "\n" + body
 
 const renderAutoCompleteFilter = <A>(
   state: AutoCompleteState,
@@ -3464,7 +3475,7 @@ const renderSelectNextFrame = Effect.fnUntraced(function*<A>(state: SelectState,
   const leadingSymbol = annotateSymbol(figures.prefix, figures.primaryColor)
   const trailingSymbol = annotateSymbol(figures.pointerSmall, figures.mutedColor)
   const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options)
-  return Ansi.cursorHide + promptMsg + "\n" + choices
+  return Ansi.cursorHide + withSelectHeader(promptMsg, choices)
 })
 
 const renderAutoCompleteNextFrame = Effect.fnUntraced(function*<A>(
@@ -3484,7 +3495,7 @@ const renderSelectSubmission = Effect.fnUntraced(function*<A>(state: SelectState
   const selected = options.choices[state].title
   const leadingSymbol = annotateSymbol(figures.tick, figures.successColor)
   const trailingSymbol = annotateSymbol(figures.ellipsis, figures.mutedColor)
-  const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options)
+  const promptMsg = renderSelectOutput(leadingSymbol, trailingSymbol, options) ?? leadingSymbol
   return promptMsg + " " + Ansi.annotate(selected, figures.submittedColor) + "\n"
 })
 
@@ -3585,7 +3596,7 @@ const handleSelectClear = <A>(options: SelectOptionsReq<A>) =>
     const clearPrompt = Ansi.eraseLine + Ansi.cursorLeft
     const promptText = renderSelectOutput(figures.prefix, figures.pointerSmall, options, { plain: true })
     const choicesText = renderSelectChoices(state, options, figures, { plain: true })
-    const clearOutput = eraseText(`${promptText}\n${choicesText}`, columns)
+    const clearOutput = eraseText(withSelectHeader(promptText, choicesText), columns)
     return clearOutput + clearPrompt
   })
 

package/src/unstable/cli/internal/command.ts

@@ -234,6 +234,8 @@ export const makeCommand = <const Name extends string, Input, E, R, ContextInput
 
 /**
  * Converts a single flag param into a FlagDoc for help display.
+ *
+ * @internal
  */
 export const toFlagDoc = (
   single: Param.Single<typeof Param.flagKind, unknown>,

package/src/unstable/http/HttpEffect.ts

@@ -317,9 +317,12 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
 {
   const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve")
   const httpApp = toHandled(self, (request, response) => {
-    if (request.method !== "HEAD") response = scopeTransferToStream(response)
+    const withoutBody = request.method === "HEAD"
+    if (!Response.omitsBody(response, withoutBody)) {
+      response = scopeTransferToStream(response)
+    }
     ;(request as any)[resolveSymbol](
-      Response.toWeb(response, { withoutBody: request.method === "HEAD", context })
+      Response.toWeb(response, { withoutBody, context })
     )
     return Effect.void
   }, middleware)

package/src/unstable/http/HttpServerResponse.ts

@@ -14,7 +14,7 @@ import type * as ByteSize from "../../ByteSize.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as ErrorReporter from "../../ErrorReporter.ts"
-import { dual } from "../../Function.ts"
+import { constVoid, dual } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
 import { PipeInspectableProto } from "../../internal/core.ts"
 import * as Option from "../../Option.ts"
@@ -1251,14 +1251,27 @@ export const setStatus: {
     })
 )
 
+/**
+ * Returns whether a response must omit its body because its status is 204, 205,
+ * or 304, or `withoutBody` is true.
+ *
+ * @category predicates
+ * @since 4.0.0
+ */
+export const omitsBody = (response: HttpServerResponse, withoutBody = false): boolean =>
+  withoutBody || response.status === 204 || response.status === 205 || response.status === 304
+
 /**
  * Converts an `HttpServerResponse` to a Web `Response`.
  *
  * **Details**
  *
  * Cookies are appended as `Set-Cookie` headers. Stream bodies are converted using
- * the supplied context, and `withoutBody` can be used for responses such as HEAD
- * responses.
+ * the supplied context.
+ *
+ * Bodies are omitted for statuses 204, 205, and 304, or when `withoutBody` is true
+ * (for example, for HEAD responses). Omitted raw `ReadableStream` bodies are
+ * cancelled without awaiting completion, and cancellation errors are ignored.
  *
  * @category converting
  * @since 4.0.0
@@ -1277,14 +1290,17 @@ export const toWeb = (
       headers.append("set-cookie", header)
     }
   }
-  if (options?.withoutBody) {
+  const body = response.body
+  if (omitsBody(response, options?.withoutBody)) {
+    if (body._tag === "Raw" && isReadableStream(body.body)) {
+      body.body.cancel().catch(constVoid)
+    }
     return new Response(undefined, {
       status: response.status,
       statusText: response.statusText as string,
       headers
     })
   }
-  const body = response.body
   switch (body._tag) {
     case "Empty": {
       return new Response(undefined, {

package/src/unstable/persistence/Persistence.ts

@@ -385,11 +385,6 @@ export const layerBackingSqlMultiTable: Layer.Layer<
           `.unprepared
       })
 
-      const wrapString = sql.onDialectOrElse({
-        mssql: () => (s: string) => `N'${s}'`,
-        orElse: () => (s: string) => `'${s}'`
-      })
-
       return identity<BackingPersistenceStore>({
         get: (key) =>
           sql<
@@ -419,9 +414,9 @@ export const layerBackingSqlMultiTable: Layer.Layer<
               })
             ),
         getMany: (keys) =>
-          sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE id IN (${
-            sql.literal(keys.map(wrapString).join(", "))
-          }) AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared.pipe(
+          sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE ${
+            sql.in("id", keys)
+          } AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared.pipe(
             Effect.mapError((cause) =>
               new PersistenceError({
                 message: `Failed to getMany from backing store`,
@@ -726,11 +721,6 @@ export const layerBackingSql: Layer.Layer<
       `.unprepared
   })
 
-  const wrapString = sql.onDialectOrElse({
-    mssql: () => (s: string) => `N'${s}'`,
-    orElse: () => (s: string) => `'${s}'`
-  })
-
   return BackingPersistence.of({
     make: Effect.fnUntraced(function*(storeId) {
       const clock = yield* Clock.Clock
@@ -764,9 +754,9 @@ export const layerBackingSql: Layer.Layer<
               })
             ),
         getMany: (keys) =>
-          sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE store_id = ${storeId} AND id IN (${
-            sql.literal(keys.map(wrapString).join(", "))
-          }) AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared.pipe(
+          sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE store_id = ${storeId} AND ${
+            sql.in("id", keys)
+          } AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared.pipe(
             Effect.mapError((cause) =>
               new PersistenceError({
                 message: `Failed to getMany from backing store`,