effect 4.0.0-beta.97 → 4.0.0-beta.99

package/src/unstable/cli/Param.ts

@@ -2898,9 +2898,19 @@ export const getUnderlyingSingleOrThrow = <Kind extends ParamKind, A>(
  */
 export const getParamMetadata = <Kind extends ParamKind, A>(
   param: Param<Kind, A>
-): { isOptional: boolean; isVariadic: boolean } => {
+): {
+  readonly isOptional: boolean
+  readonly isVariadic: boolean
+  readonly variadicMin: Option.Option<number>
+  readonly variadicMax: Option.Option<number>
+} => {
   return matchParam(param, {
-    Single: () => ({ isOptional: false, isVariadic: false }),
+    Single: () => ({
+      isOptional: false,
+      isVariadic: false,
+      variadicMin: Option.none(),
+      variadicMax: Option.none()
+    }),
     Map: (mapped) => getParamMetadata(mapped.param),
     Transform: (mapped) => getParamMetadata(mapped.param),
     Optional: (optional) => ({
@@ -2909,7 +2919,9 @@ export const getParamMetadata = <Kind extends ParamKind, A>(
     }),
     Variadic: (variadic) => ({
       ...getParamMetadata(variadic.param),
-      isVariadic: true
+      isVariadic: true,
+      variadicMin: variadic.min,
+      variadicMax: variadic.max
     })
   })
 }

package/src/unstable/cli/index.ts

@@ -9,6 +9,11 @@
  */
 export * as Argument from "./Argument.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as CliConfig from "./CliConfig.ts"
+
 /**
  * @since 4.0.0
  */

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

@@ -57,6 +57,9 @@ export const red = `${ESC}31m`
 /** @internal */
 export const green = `${ESC}32m`
 
+/** @internal */
+export const magenta = `${ESC}35m`
+
 /** @internal */
 export const white = `${ESC}37m`
 

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

@@ -391,6 +391,18 @@ const invalidNegatedFlagValue = (
     kind: "flag"
   })
 
+const missingFlagValue = (spec: FlagParam): CliError.InvalidValue => {
+  const choices = Primitive.getChoiceKeys(spec.primitiveType)
+  return new CliError.InvalidValue({
+    option: spec.name,
+    value: "",
+    expected: choices === undefined
+      ? spec.typeName ?? Primitive.getTypeName(spec.primitiveType)
+      : choices.join(" | "),
+    kind: "flag"
+  })
+}
+
 /**
  * Checks whether a token is a boolean literal value.
  * Recognizes: true/false, yes/no, on/off, 1/0
@@ -497,8 +509,8 @@ const consumeFlagValueWithTokens = (
   }
 
   return {
-    _tag: "Value",
-    value: undefined,
+    _tag: "Error",
+    error: missingFlagValue(spec),
     tokens: []
   }
 }

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

@@ -0,0 +1,283 @@
+import * as Console from "../../../Console.ts"
+import * as Effect from "../../../Effect.ts"
+import * as Option from "../../../Option.ts"
+import * as Redacted from "../../../Redacted.ts"
+import type * as Terminal from "../../../Terminal.ts"
+import type * as CliError from "../CliError.ts"
+import type * as Command from "../Command.ts"
+import * as Param from "../Param.ts"
+import * as Primitive from "../Primitive.ts"
+import * as Prompt from "../Prompt.ts"
+import * as Ansi from "./ansi.ts"
+import { toImpl } from "./command.ts"
+
+export interface Options {
+  readonly commandPath?: ReadonlyArray<string> | undefined
+  readonly prefix?: ReadonlyArray<string> | undefined
+}
+
+export const run: (
+  command: Command.Command.Any,
+  options?: Options
+) => Effect.Effect<Array<string>, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+  function*(command, options) {
+    const commandPath = options?.commandPath ?? [command.name]
+    const selected = getCommandAtPath(command, commandPath)
+    const commandLine = [...(options?.prefix ?? commandPath)]
+    yield* logCurrentCommand(commandLine)
+    yield* promptCommand(selected, commandLine, selected === command ? "ROOT" : selected.name)
+    return commandLine
+  }
+)
+
+const getCommandAtPath = (
+  command: Command.Command.Any,
+  commandPath: ReadonlyArray<string>
+): Command.Command.Any => {
+  let current = command
+  for (const name of commandPath.slice(1)) {
+    const child = current.subcommands
+      .flatMap((group) => group.commands)
+      .find((candidate) => candidate.name === name || candidate.alias === name)
+    if (child === undefined) {
+      break
+    }
+    current = child
+  }
+  return current
+}
+
+const promptCommand: (
+  command: Command.Command.Any,
+  commandLine: Array<string>,
+  sectionName: string
+) => Effect.Effect<void, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+  function*(command, commandLine, sectionName) {
+    const impl = toImpl(command)
+    const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.hidden))
+    const config = visibleSubcommands.length === 0 ? impl.config : impl.contextConfig
+
+    if (config.flags.length > 0) {
+      yield* Console.log(renderSection(sectionName, "FLAGS"))
+      for (const param of config.flags) {
+        commandLine.push(...yield* promptParam(param))
+      }
+      if (config.arguments.length > 0 || visibleSubcommands.length > 0) {
+        yield* logCurrentCommand(commandLine)
+      }
+    }
+
+    if (config.arguments.length > 0) {
+      yield* Console.log(renderSection(sectionName, "ARGUMENTS"))
+      for (const param of config.arguments) {
+        commandLine.push(...yield* promptParam(param))
+      }
+      if (visibleSubcommands.length > 0) {
+        yield* logCurrentCommand(commandLine)
+      }
+    }
+
+    if (visibleSubcommands.length === 0) {
+      return
+    }
+
+    const child = yield* Prompt.run(Prompt.select({
+      message: "Command",
+      choices: visibleSubcommands.map((command) => ({
+        title: command.name,
+        value: command,
+        ...(command.shortDescription !== undefined
+          ? { description: command.shortDescription }
+          : command.description !== undefined
+          ? { description: command.description }
+          : {})
+      }))
+    }))
+    yield* Console.log()
+    commandLine.push(child.name)
+    if (hasWizardSteps(child)) {
+      yield* logCurrentCommand(commandLine)
+    }
+    yield* promptCommand(child, commandLine, child.name)
+  }
+)
+
+const hasWizardSteps = (command: Command.Command.Any): boolean => {
+  const hasVisibleSubcommands = command.subcommands.some((group) => group.commands.some((child) => !child.hidden))
+  return hasVisibleSubcommands || toImpl(command).config.orderedParams.length > 0
+}
+
+const promptParam: (
+  param: Param.Any
+) => Effect.Effect<Array<string>, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+  function*(param) {
+    const single = Param.getUnderlyingSingleOrThrow(param)
+    const metadata = Param.getParamMetadata(param)
+
+    if (metadata.isOptional) {
+      const include = yield* Prompt.run(Prompt.confirm({
+        message: `Set ${renderParamLabel(single)}?`,
+        initial: false
+      }))
+      if (!include) {
+        yield* Console.log()
+        return []
+      }
+    }
+
+    const count = !metadata.isVariadic
+      ? 1
+      : yield* Prompt.run(Prompt.integer({
+        message: `${renderParamLabel(single)} count`,
+        default: Option.getOrElse(metadata.variadicMin, () => 0),
+        min: Option.getOrElse(metadata.variadicMin, () => 0),
+        ...(Option.isSome(metadata.variadicMax) ? { max: metadata.variadicMax.value } : {})
+      }))
+    const values: Array<string> = []
+    for (let i = 0; i < count; i++) {
+      values.push(yield* promptSingle(single))
+    }
+
+    const parsed = single.kind === Param.flagKind
+      ? {
+        flags: { [single.name]: values },
+        arguments: []
+      }
+      : {
+        flags: {},
+        arguments: values
+      }
+    yield* param.parse(parsed)
+    yield* Console.log()
+
+    if (single.kind === Param.argumentKind) {
+      return values
+    }
+    return values.flatMap((value) => [`--${single.name}`, value])
+  }
+)
+
+const promptSingle = (
+  single: Param.Single<Param.ParamKind, unknown>
+): Effect.Effect<string, Terminal.QuitError, Command.Environment> => {
+  const message = renderParamMessage(single)
+  switch (single.primitiveType._tag) {
+    case "Boolean":
+      return Effect.map(
+        Prompt.run(Prompt.confirm({
+          message,
+          label: {
+            confirm: "true",
+            deny: "false"
+          },
+          placeholder: {
+            defaultConfirm: "(T/f)",
+            defaultDeny: "(t/F)"
+          }
+        })),
+        String
+      )
+    case "Choice": {
+      const choices = Primitive.getChoiceKeys(single.primitiveType) ?? []
+      return Prompt.run(Prompt.select({
+        message,
+        choices: choices.map((choice) => ({ title: choice, value: choice }))
+      }))
+    }
+    case "Date":
+      return Effect.map(Prompt.run(Prompt.date({ message })), (date) => date.toISOString())
+    case "Float":
+      return Effect.map(Prompt.run(Prompt.float({ message })), String)
+    case "Integer":
+      return Effect.map(Prompt.run(Prompt.integer({ message })), String)
+    case "Redacted":
+      return Effect.map(Prompt.run(Prompt.password({ message })), Redacted.value)
+    default:
+      return Prompt.run(Prompt.text({ message }))
+  }
+}
+
+const formatName = (single: Param.Single<Param.ParamKind, unknown>): string =>
+  single.kind === Param.flagKind ? `--${single.name}` : single.name
+
+const renderParamMessage = (single: Param.Single<Param.ParamKind, unknown>): string => renderParamLabel(single)
+
+const renderParamLabel = (single: Param.Single<Param.ParamKind, unknown>): string => {
+  const description = Option.getOrUndefined(single.description)?.trim()
+  const label = single.kind === Param.flagKind && description !== undefined && description.length <= 32
+    ? description
+    : humanize(single.name)
+  return single.kind === Param.flagKind ? `${label} (${formatName(single)})` : label
+}
+
+const humanize = (name: string): string => {
+  const words = name.split(/[-_]+/).filter((word) => word.length > 0)
+  if (words.length === 0) return name
+  return [words[0][0].toUpperCase() + words[0].slice(1), ...words.slice(1)].join(" ")
+}
+
+const logCurrentCommand = (commandLine: ReadonlyArray<string>): Effect.Effect<void> =>
+  Console.log(renderCommandBlock("Current command", commandLine, Ansi.magenta))
+
+const renderSection = (commandName: string, section: string): string =>
+  `${Ansi.annotate(commandName.toUpperCase(), Ansi.bold, Ansi.cyanBright)} ${Ansi.annotate("·", Ansi.blackBright)} ${
+    Ansi.annotate(section, Ansi.bold, Ansi.white)
+  }`
+
+export const renderIntroduction = (name: string, version: string, summary: string | undefined): string => {
+  const title = `${Ansi.annotate(name, Ansi.bold, Ansi.cyanBright)} ${Ansi.annotate(`v${version}`, Ansi.white)} ${
+    Ansi.annotate("· Command wizard", Ansi.bold, Ansi.white)
+  }`
+  return [
+    title,
+    ...(summary === undefined || summary.length === 0 ? [] : [summary]),
+    Ansi.annotate("Build a command interactively. Press Ctrl+C to cancel.", Ansi.blackBright),
+    ""
+  ].join("\n")
+}
+
+export const renderCompletion = (commandLine: ReadonlyArray<string>): string =>
+  renderCommandBlock("Command ready", commandLine, Ansi.cyanBright, Ansi.green)
+
+export const renderQuit = (): string => `\n${Ansi.annotate("Wizard cancelled.", Ansi.red)}`
+
+const renderCommandBlock = (
+  label: string,
+  commandLine: ReadonlyArray<string>,
+  commandColor: string,
+  labelColor: string = Ansi.white
+): string => {
+  const lines = wrapCommand(commandLine)
+  return [
+    Ansi.annotate(label, Ansi.bold, labelColor),
+    ...lines.map((line) => Ansi.annotate(line, commandColor)),
+    ""
+  ].join("\n")
+}
+
+const wrapCommand = (commandLine: ReadonlyArray<string>): Array<string> => {
+  const width = 88
+  const firstIndent = "  $ "
+  const continuationIndent = "    "
+  const args = commandLine.map(formatShellArg)
+  const lines: Array<string> = []
+  let current = firstIndent
+
+  for (const arg of args) {
+    const separator = current === firstIndent || current === continuationIndent ? "" : " "
+    if (current.length + separator.length + arg.length > width && current !== firstIndent) {
+      lines.push(`${current} \\`)
+      current = `${continuationIndent}${arg}`
+    } else {
+      current += `${separator}${arg}`
+    }
+  }
+
+  if (current !== firstIndent) {
+    lines.push(current)
+  }
+  return lines
+}
+
+const formatShellArg = (arg: string): string =>
+  /^[A-Za-z0-9_./:@%+=,-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'"'"'`)}'`

package/src/unstable/cluster/EntityProxyServer.ts

@@ -34,27 +34,25 @@ import type { Sharding } from "./Sharding.ts"
  */
 export const layerHttpApi = <
   ApiId extends string,
-  Groups extends HttpApiGroup.Any,
-  Name extends HttpApiGroup.Name<Groups>,
+  Groups extends HttpApiGroup.Constraint,
+  Identifier extends HttpApiGroup.Identifier<Groups>,
   Type extends string,
   Rpcs extends Rpc.Any
 >(
   api: HttpApi.HttpApi<ApiId, Groups>,
-  name: Name,
+  identifier: Identifier,
   entity: Entity.Entity<Type, Rpcs>
-): Layer.Layer<HttpApiGroup.ApiGroup<ApiId, Name>, never, Sharding | Rpc.ServicesServer<Rpcs>> =>
+): Layer.Layer<HttpApiGroup.Service<ApiId, Identifier>, never, Sharding | Rpc.ServicesServer<Rpcs>> =>
   HttpApiBuilder.group(
     api,
-    name,
-    Effect.fnUntraced(function*(handlers_) {
+    identifier,
+    Effect.fnUntraced(function*(handlers: any) {
       const client = yield* entity.client
-      let handlers = handlers_
-      for (const parentRpc_ of entity.protocol.requests.values()) {
-        const parentRpc = parentRpc_ as any as Rpc.AnyWithProps
+      for (const parentRpc of entity.protocol.requests.values()) {
         handlers = handlers
           .handle(
-            parentRpc._tag as any,
-            (({ params, payload }: { params: { entityId: string }; payload: any }) =>
+            parentRpc._tag,
+            ({ params, payload }: { params: { entityId: string }; payload: any }) =>
               (client(params.entityId) as any as Record<string, (p: any) => Effect.Effect<any>>)[parentRpc._tag](
                 payload
               ).pipe(
@@ -65,11 +63,11 @@ export const layerHttpApi = <
                   entityId: params.entityId,
                   method: parentRpc._tag
                 })
-              )) as any
+              )
           )
           .handle(
-            `${parentRpc._tag}Discard` as any,
-            (({ params, payload }: { params: { entityId: string }; payload: any }) =>
+            `${parentRpc._tag}Discard`,
+            ({ params, payload }: { params: { entityId: string }; payload: any }) =>
               (client(params.entityId) as any as Record<string, (p: any, o: {}) => Effect.Effect<any>>)[parentRpc._tag](
                 payload,
                 { discard: true }
@@ -81,10 +79,10 @@ export const layerHttpApi = <
                   entityId: params.entityId,
                   method: `${parentRpc._tag}Discard`
                 })
-              )) as any
-          ) as any
+              )
+          )
       }
-      return handlers as HttpApiBuilder.Handlers<never, never>
+      return handlers as HttpApiBuilder.Handlers<never>
     })
   )
 

package/src/unstable/cluster/RunnerStorage.ts

@@ -220,7 +220,7 @@ export const makeMemory = Effect.gen(function*() {
     setRunnerHealth: () => Effect.void,
     acquire: (_address, shardIds) => {
       acquired = Array.from(shardIds)
-      return Effect.succeed(Array.from(shardIds))
+      return Effect.succeed(acquired)
     },
     refresh: () => Effect.sync(() => acquired),
     release: () => Effect.void,

package/src/unstable/cluster/internal/entityManager.ts

@@ -207,15 +207,21 @@ export const make = Effect.fnUntraced(function*<
                   (isShuttingDown || isUninterruptibleForServer(request.message.annotations))
                 ) {
                   if (!isShuttingDown) {
-                    return server.write(0, {
-                      ...request.message.envelope,
-                      id: request.message.envelope.requestId as any,
-                      tag: request.message.envelope.tag as any,
-                      payload: new Request({
+                    return server.write(
+                      0,
+                      {
                         ...request.message.envelope,
-                        lastSentChunk: request.lastSentChunk
-                      } as any) as any
-                    }).pipe(
+                        id: request.message.envelope.requestId as any,
+                        tag: request.message.envelope.tag as any,
+                        payload: new Request({
+                          ...request.message.envelope,
+                          lastSentChunk: request.lastSentChunk
+                        } as any) as any
+                      },
+                      Context.get(request.rpc.annotations, WithTransaction)
+                        ? { onRequest: options.storage.withTransaction }
+                        : undefined
+                    ).pipe(
                       Effect.forkIn(scope)
                     )
                   }
@@ -295,16 +301,22 @@ export const make = Effect.fnUntraced(function*<
           for (const id of defectRequestIds) {
             const request = activeRequests.get(id)
             if (!request) continue
-            const { lastSentChunk, message } = request
-            yield* server.write(0, {
-              ...message.envelope,
-              id: message.envelope.requestId as any,
-              tag: message.envelope.tag as any,
-              payload: new Request({
+            const { lastSentChunk, message, rpc } = request
+            yield* server.write(
+              0,
+              {
                 ...message.envelope,
-                lastSentChunk
-              } as any) as any
-            })
+                id: message.envelope.requestId as any,
+                tag: message.envelope.tag as any,
+                payload: new Request({
+                  ...message.envelope,
+                  lastSentChunk
+                } as any) as any
+              },
+              Context.get(rpc.annotations, WithTransaction)
+                ? { onRequest: options.storage.withTransaction }
+                : undefined
+            )
           }
           defectRequestIds.clear()
         }
@@ -341,11 +353,11 @@ export const make = Effect.fnUntraced(function*<
     const state: EntityState = {
       scope,
       address,
-      write(clientId, message) {
+      write(clientId, message, writeOptions) {
         if (writeRef.state.current._tag !== "Acquired") {
-          return Effect.flatMap(writeRef.await, (write) => write(clientId, message))
+          return Effect.flatMap(writeRef.await, (write) => write(clientId, message, writeOptions))
         }
-        return writeRef.state.current.value(clientId, message)
+        return writeRef.state.current.value(clientId, message, writeOptions)
       },
       activeRequests,
       lastActiveCheck: clock.currentTimeMillisUnsafe(),
@@ -472,21 +484,23 @@ export const make = Effect.fnUntraced(function*<
                 })
               }
               server.activeRequests.set(message.envelope.requestId, entry)
-              let write = server.write(0, {
-                ...message.envelope,
-                id: message.envelope.requestId as any,
-                payload: new Request({
+              return server.write(
+                0,
+                {
                   ...message.envelope,
-                  lastSentChunk: Option.filter(
-                    message.lastSentReply,
-                    (reply): reply is Reply.Chunk<R> => reply._tag === "Chunk"
-                  )
-                })
-              })
-              if (Context.get(message.annotations, WithTransaction)) {
-                write = options.storage.withTransaction(write)
-              }
-              return write
+                  id: message.envelope.requestId as any,
+                  payload: new Request({
+                    ...message.envelope,
+                    lastSentChunk: Option.filter(
+                      message.lastSentReply,
+                      (reply): reply is Reply.Chunk<R> => reply._tag === "Chunk"
+                    )
+                  })
+                },
+                Context.get(message.annotations, WithTransaction)
+                  ? { onRequest: options.storage.withTransaction }
+                  : undefined
+              )
             }
             case "IncomingEnvelope": {
               const entry = server.activeRequests.get(message.envelope.requestId)

package/src/unstable/http/Multipart.ts

@@ -452,7 +452,9 @@ export const makeChannel = <IE>(headers: Record<string, string>): Channel.Channe
           exit = Option.some(Exit.fail(convertError(error_)))
         },
         onDone() {
-          exit = Option.some(Exit.fail(Cause.Done()))
+          if (Option.isNone(exit)) {
+            exit = Option.some(Exit.fail(Cause.Done()))
+          }
         }
       })