effect-start 0.27.0 → 0.29.0

package/src/cli/Argument.ts

@@ -0,0 +1,45 @@
+import type * as Redacted from "effect/Redacted"
+import * as Param from "./Param.ts"
+import * as Primitive from "./Primitive.ts"
+
+export interface Argument<A> extends Param.Param<"argument", A> {}
+
+const argMake = Param.makeConstructor("argument")
+
+export const string = (name: string): Argument<string> => argMake(name, Primitive.string)
+export const integer = (name: string): Argument<number> => argMake(name, Primitive.integer)
+export const float = (name: string): Argument<number> => argMake(name, Primitive.float)
+export const date = (name: string): Argument<Date> => argMake(name, Primitive.date)
+export const redacted = (name: string): Argument<Redacted.Redacted<string>> =>
+  argMake(name, Primitive.redacted)
+export const choice = <const C extends ReadonlyArray<string>>(
+  name: string,
+  choices: C,
+): Argument<C[number]> =>
+  Param.makeSingleParam({
+    kind: "argument",
+    name,
+    primitiveType: Primitive.choice(choices.map((v) => [v, v] as const)),
+  })
+export const choiceWithValue = <const C extends ReadonlyArray<readonly [string, any]>>(
+  name: string,
+  choices: C,
+): Argument<C[number][1]> =>
+  Param.makeSingleParam({ kind: "argument", name, primitiveType: Primitive.choice(choices) })
+export const none: Argument<never> = Param.makeSingleParam({
+  kind: "argument",
+  name: "__none__",
+  primitiveType: Primitive.none,
+}) as Argument<never>
+
+const combinators = Param.makeParamCombinators("argument")
+export const optional = combinators.optional
+export const withDefault = combinators.withDefault
+export const withDescription = combinators.withDescription
+export const withMetavar = combinators.withMetavar
+export const map = combinators.map
+export const mapEffect = combinators.mapEffect
+export const variadic = combinators.variadic
+export const filter = combinators.filter
+export const withSchema = combinators.withSchema
+export const orElse = combinators.orElse

package/src/cli/CliError.ts

@@ -0,0 +1,68 @@
+import * as Predicate from "effect/Predicate"
+
+const CliErrorTypeId = "~effect-start/Cli/CliError"
+
+export const isCliError = (u: unknown): u is CliError => Predicate.hasProperty(u, CliErrorTypeId)
+
+export type CliErrorReason =
+  | "UnrecognizedOption"
+  | "DuplicateOption"
+  | "MissingOption"
+  | "MissingArgument"
+  | "InvalidValue"
+  | "UnknownSubcommand"
+  | "ShowHelp"
+  | "UserError"
+
+const suggestText = (suggestions: ReadonlyArray<string>) =>
+  suggestions.length > 0 ? `\n\n  Did you mean this?\n    ${suggestions.join("\n    ")}` : ""
+
+const formatMessage = (reason: CliErrorReason, props: Record<string, any>): string => {
+  switch (reason) {
+    case "UnrecognizedOption": {
+      const base = props.command
+        ? `Unrecognized flag: ${props.option} in command ${props.command.join(" ")}`
+        : `Unrecognized flag: ${props.option}`
+      return base + suggestText(props.suggestions ?? [])
+    }
+    case "DuplicateOption":
+      return `Duplicate flag "${props.option}" in parent "${props.parentCommand}" and subcommand "${props.childCommand}".`
+    case "MissingOption":
+      return `Missing required flag: --${props.option}`
+    case "MissingArgument":
+      return `Missing required argument: ${props.argument}`
+    case "InvalidValue":
+      return props.kind === "argument"
+        ? `Invalid value for argument <${props.option}>: "${props.value}". Expected: ${props.expected}`
+        : `Invalid value for flag --${props.option}: "${props.value}". Expected: ${props.expected}`
+    case "UnknownSubcommand": {
+      const base = props.parent
+        ? `Unknown subcommand "${props.subcommand}" for "${props.parent.join(" ")}"`
+        : `Unknown subcommand "${props.subcommand}"`
+      return base + suggestText(props.suggestions ?? [])
+    }
+    case "ShowHelp":
+      return "Help requested"
+    case "UserError":
+      return String(props.cause)
+  }
+}
+
+export class CliError {
+  readonly _tag = "CliError"
+  readonly [CliErrorTypeId] = CliErrorTypeId
+  readonly reason: CliErrorReason
+  constructor(props: { reason: CliErrorReason } & Record<string, any>) {
+    this.reason = props.reason
+    Object.assign(this, props)
+  }
+  get message(): string {
+    return formatMessage(this.reason, this as any)
+  }
+}
+
+export const formatErrors = (errors: ReadonlyArray<CliError>): string => {
+  if (errors.length === 0) return ""
+  if (errors.length === 1) return `\nERROR\n  ${errors[0].message}`
+  return `\nERRORS\n` + errors.map((e) => `  ${e.message}`).join("\n")
+}