effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/cli/Param.ts

@@ -139,6 +139,17 @@ export interface ParsedArgs {
   readonly arguments: ReadonlyArray<string>
 }
 
+/**
+ * Represents a fallback prompt that can either be provided directly or
+ * computed effectfully when the parameter is missing.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export type FallbackPrompt<A> =
+  | Prompt.Prompt<A>
+  | Effect.Effect<Prompt.Prompt<A>, CliError.CliError, Environment>
+
 /**
  * @since 4.0.0
  * @category models
@@ -147,7 +158,7 @@ export interface Single<Kind extends ParamKind, out A> extends Param<Kind, A> {
   readonly _tag: "Single"
   readonly kind: Kind
   readonly name: string
-  readonly description: string | undefined
+  readonly description: Option.Option<string>
   readonly aliases: ReadonlyArray<string>
   readonly primitiveType: Primitive.Primitive<A>
   readonly typeName?: string | undefined
@@ -193,8 +204,8 @@ export interface Variadic<Kind extends ParamKind, A> extends Param<Kind, Readonl
   readonly _tag: "Variadic"
   readonly kind: Kind
   readonly param: Param<Kind, A>
-  readonly min: number | undefined
-  readonly max: number | undefined
+  readonly min: Option.Option<number>
+  readonly max: Option.Option<number>
 }
 
 const Proto = {
@@ -268,7 +279,7 @@ export const makeSingle = <const Kind extends ParamKind, A>(params: {
   readonly name: string
   readonly primitiveType: Primitive.Primitive<A>
   readonly typeName?: string | undefined
-  readonly description?: string | undefined
+  readonly description?: Option.Option<string> | undefined
   readonly aliases?: ReadonlyArray<string> | undefined
 }): Single<Kind, A> => {
   const parse: Parse<A> = (args) =>
@@ -278,7 +289,7 @@ export const makeSingle = <const Kind extends ParamKind, A>(params: {
   return Object.assign(Object.create(Proto), {
     _tag: "Single",
     ...params,
-    description: params.description,
+    description: params.description ?? Option.none(),
     aliases: params.aliases ?? [],
     parse
   })
@@ -734,7 +745,7 @@ export const fileParse = <Kind extends ParamKind>(
  * const configSchema = Schema.Struct({
  *   port: Schema.Number,
  *   host: Schema.String
- * }).pipe(Schema.fromJsonString)
+ * })
  *
  * const config = Param.fileSchema(Param.flagKind, "config", configSchema, {
  *   format: "json"
@@ -754,7 +765,7 @@ export const fileParse = <Kind extends ParamKind>(
 export const fileSchema = <Kind extends ParamKind, A>(
   kind: Kind,
   name: string,
-  schema: Schema.Codec<A, string>,
+  schema: Schema.Decoder<A>,
   options?: Primitive.FileSchemaOptions | undefined
 ): Param<Kind, A> =>
   makeSingle({
@@ -851,7 +862,7 @@ const FLAG_DASH_REGEXP = /^-+/
  *
  * const force = Param.boolean(Param.flagKind, "force").pipe(
  *   Param.withAlias("-f"),
- *   Param.withAlias("--no-prompt")
+ *   Param.withAlias("-F")
  * )
  *
  * // Also works on composed params:
@@ -882,7 +893,7 @@ export const withAlias: {
    *
    * const force = Param.boolean(Param.flagKind, "force").pipe(
    *   Param.withAlias("-f"),
-   *   Param.withAlias("--no-prompt")
+   *   Param.withAlias("-F")
    * )
    *
    * // Also works on composed params:
@@ -913,7 +924,7 @@ export const withAlias: {
    *
    * const force = Param.boolean(Param.flagKind, "force").pipe(
    *   Param.withAlias("-f"),
-   *   Param.withAlias("--no-prompt")
+   *   Param.withAlias("-F")
    * )
    *
    * // Also works on composed params:
@@ -1005,7 +1016,7 @@ export const withDescription: {
   return transformSingle(self, <X>(single: Single<Kind, X>) =>
     makeSingle({
       ...single,
-      description
+      description: Option.some(description)
     }))
 })
 
@@ -1307,8 +1318,6 @@ export const mapTryCatch: {
  * ```ts
  * import * as Param from "effect/unstable/cli/Param"
  *
- * // @internal - this module is not exported publicly
- *
  * // Create an optional port option
  * // - When not provided: returns Option.none()
  * // - When provided: returns Option.some(parsedValue)
@@ -1321,15 +1330,29 @@ export const mapTryCatch: {
 export const optional = <Kind extends ParamKind, A>(
   param: Param<Kind, A>
 ): Param<Kind, Option.Option<A>> => {
-  const parse: Parse<Option.Option<A>> = (args) =>
-    param.parse(args).pipe(
-      Effect.map(
-        ([leftover, value]) => [leftover, Option.some(value)] as const
-      ),
+  const parse: Parse<Option.Option<A>> = Effect.fnUntraced(function*(args) {
+    const single = getUnderlyingSingleOrThrow(param)
+
+    // Handle boolean params that are explicitly marked as optional (i.e. the
+    // end user wants to return `Option.none()` instead of `false` when the
+    // flag (or its negated variant) are not present on the command line
+    if (
+      isFlagParam(single) &&
+      Primitive.isBoolean(single.primitiveType) &&
+      ![single.name, ...single.aliases].some((name) => (args.flags[name] ?? []).length > 0)
+    ) {
+      return [args.arguments, Option.none()] as const
+    }
+
+    return yield* param.parse(args).pipe(
+      Effect.map(([leftover, value]) => [leftover, Option.some(value)] as const),
       // Catch both MissingOption (for flags) and MissingArgument (for positional arguments)
-      Effect.catchTag("MissingOption", () => Effect.succeed([args.arguments, Option.none()] as const)),
-      Effect.catchTag("MissingArgument", () => Effect.succeed([args.arguments, Option.none()] as const))
+      Effect.catchTags({
+        MissingOption: () => Effect.succeed([args.arguments, Option.none()] as const),
+        MissingArgument: () => Effect.succeed([args.arguments, Option.none()] as const)
+      })
     )
+  })
   return Object.assign(Object.create(Proto), {
     _tag: "Optional",
     kind: param.kind,
@@ -1512,20 +1535,20 @@ export const withFallbackPrompt: {
    * @since 4.0.0
    * @category combinators
    */
-  <B>(prompt: Prompt.Prompt<B>): <Kind extends ParamKind, A>(self: Param<Kind, A>) => Param<Kind, A | B>
+  <B>(prompt: FallbackPrompt<B>): <Kind extends ParamKind, A>(self: Param<Kind, A>) => Param<Kind, A | B>
   /**
    * Adds a fallback prompt that is shown when a required parameter is missing.
    *
    * @since 4.0.0
    * @category combinators
    */
-  <Kind extends ParamKind, A, B>(self: Param<Kind, A>, prompt: Prompt.Prompt<B>): Param<Kind, A | B>
+  <Kind extends ParamKind, A, B>(self: Param<Kind, A>, prompt: FallbackPrompt<B>): Param<Kind, A | B>
 } = dual(2, <Kind extends ParamKind, A, B>(
   self: Param<Kind, A>,
-  prompt: Prompt.Prompt<B>
+  prompt: FallbackPrompt<B>
 ): Param<Kind, A | B> => {
   const runPrompt = (error: CliError.MissingOption | CliError.MissingArgument, args: ParsedArgs) =>
-    Prompt.run(prompt).pipe(
+    Effect.flatMap(Prompt.isPrompt(prompt) ? Effect.succeed(prompt) : prompt, Prompt.run).pipe(
       Effect.map((value) => [args.arguments, value as A | B] as const),
       Effect.catchTag("QuitError", () => Effect.fail(error))
     )
@@ -1603,8 +1626,8 @@ export const variadic = <Kind extends ParamKind, A>(
     _tag: "Variadic",
     kind: self.kind,
     param: self,
-    min: options?.min,
-    max: options?.max,
+    min: Option.fromUndefinedOr(options?.min),
+    max: Option.fromUndefinedOr(options?.max),
     parse
   })
 }
@@ -2587,7 +2610,11 @@ const transformSingle = <Kind extends ParamKind, A>(
     Map: (mapped) => map(transformSingle(mapped.param, f), mapped.f),
     Transform: (mapped) => transform(transformSingle(mapped.param, f), mapped.f),
     Optional: (p) => optional(transformSingle(p.param, f)) as Param<Kind, A>,
-    Variadic: (p) => variadic(transformSingle(p.param, f), { min: p.min, max: p.max }) as Param<Kind, A>
+    Variadic: (p) =>
+      variadic(transformSingle(p.param, f), {
+        min: Option.getOrUndefined(p.min),
+        max: Option.getOrUndefined(p.max)
+      }) as Param<Kind, A>
   })
 }
 

package/src/unstable/cli/Primitive.ts

@@ -575,7 +575,7 @@ export type FileSchemaOptions = Struct.Simplify<
  * @category constructors
  */
 export const fileSchema = <A>(
-  schema: Schema.Codec<A, string>,
+  schema: Schema.Decoder<A>,
   options?: FileSchemaOptions | undefined
 ): Primitive<A> => {
   const decode = Schema.decodeUnknownEffect(schema)
@@ -645,7 +645,7 @@ export const keyValuePair: Primitive<Record<string, string>> = makePrimitive(
  *
  * const program = Effect.gen(function*() {
  *   // This will always fail - useful for boolean flags
- *   const result = yield* Primitive.none.parse("any-value")
+ *   return yield* Primitive.none.parse("any-value")
  * })
  *
  * // The above effect will fail with "This option does not accept values"