effect-start 0.28.0 → 0.29.0

package/src/{PathPattern.ts → _PathPattern.ts}

@@ -1,3 +1,5 @@
+import * as Either from "effect/Either"
+
 export type PathPattern = `/${string}`
 
 export type Segments<Path extends string> = Path extends `/${infer Rest}`
@@ -26,6 +28,16 @@ export type Params<T extends string> = string extends T
 
 export type ValidateResult = { ok: true; segments: Array<string> } | { ok: false; error: string }
 
+export type PathPatternError = {
+  _tag: "PathPatternError"
+  pattern: string
+  message: string
+}
+
+function isValidFileParamName(name: string): boolean {
+  return name.length > 0 && /^[a-zA-Z0-9_]+$/.test(name)
+}
+
 function isValidSegment(segment: string): boolean {
   if (segment.startsWith(":")) {
     const rest = segment.slice(1)
@@ -51,6 +63,99 @@ export function validate(path: string): ValidateResult {
   return { ok: true, segments }
 }
 
+export function fromFilePath(filePath: string): Either.Either<PathPattern, PathPatternError> {
+  const parts = filePath.split("/").filter(Boolean)
+  const pathParts: Array<string> = []
+  let sawRest = false
+
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index]
+
+    if (/^\(\w+\)$/.test(part)) {
+      continue
+    }
+
+    if (part.startsWith("[[") && part.endsWith("]]")) {
+      const name = part.slice(2, -2)
+      if (!isValidFileParamName(name)) {
+        return Either.left({
+          _tag: "PathPatternError",
+          pattern: filePath,
+          message: `Invalid segment: "${part}"`,
+        })
+      }
+      if (index !== parts.length - 1) {
+        return Either.left({
+          _tag: "PathPatternError",
+          pattern: filePath,
+          message: "Rest segment must be the last segment",
+        })
+      }
+      pathParts.push(`:${name}*`)
+      sawRest = true
+      continue
+    }
+
+    if (part.startsWith("[") && part.endsWith("]")) {
+      const name = part.slice(1, -1)
+      if (!isValidFileParamName(name)) {
+        return Either.left({
+          _tag: "PathPatternError",
+          pattern: filePath,
+          message: `Invalid segment: "${part}"`,
+        })
+      }
+      if (sawRest) {
+        return Either.left({
+          _tag: "PathPatternError",
+          pattern: filePath,
+          message: "Rest segment must be the last segment",
+        })
+      }
+      pathParts.push(`:${name}`)
+      continue
+    }
+
+    if (/^[\p{L}\p{N}._~-]+$/u.test(part)) {
+      if (sawRest) {
+        return Either.left({
+          _tag: "PathPatternError",
+          pattern: filePath,
+          message: "Rest segment must be the last segment",
+        })
+      }
+      pathParts.push(part)
+      continue
+    }
+
+    return Either.left({
+      _tag: "PathPatternError",
+      pattern: filePath,
+      message: `Invalid segment: "${part}"`,
+    })
+  }
+
+  const path = (pathParts.length > 0 ? `/${pathParts.join("/")}` : "/") as PathPattern
+  return Either.right(path)
+}
+
+export function params(path: string): Array<{ name: string; optional: boolean }> {
+  const segments = path.split("/").filter(Boolean)
+  const result: Array<{ name: string; optional: boolean }> = []
+
+  for (const segment of segments) {
+    if (!segment.startsWith(":")) {
+      continue
+    }
+
+    const modifier = getModifier(segment)
+    const name = getParamName(segment)
+    result.push({ name, optional: modifier === "?" || modifier === "*" })
+  }
+
+  return result
+}
+
 export function match(pattern: string, path: string): Record<string, string> | null {
   const patternSegments = pattern.split("/").filter(Boolean)
   const pathSegments = path.split("/").filter(Boolean)

package/src/{SchemaExtra.ts → _SchemaExtra.ts}

@@ -1,8 +1,7 @@
-import * as Function from "effect/Function"
 import type * as Schema from "effect/Schema"
 import * as SchemaAST from "effect/SchemaAST"
 
-export function getBaseSchemaAST(schema: Schema.Schema.Any): SchemaAST.AST {
+function getBaseSchemaAST(schema: Schema.Schema.Any): SchemaAST.AST {
   let current = schema.ast
 
   while (SchemaAST.isRefinement(current) || SchemaAST.isTransformation(current)) {
@@ -12,7 +11,7 @@ export function getBaseSchemaAST(schema: Schema.Schema.Any): SchemaAST.AST {
   return current
 }
 
-export function isOptional(schema: Schema.Schema.Any): boolean {
+function isOptional(schema: Schema.Schema.Any): boolean {
   const ast = schema.ast
 
   if (ast._tag === "Union") {
@@ -71,7 +70,7 @@ export function schemaEqual(
   return true
 }
 
-export function getSchemaTypeName(schema: Schema.Schema.Any): string {
+function getSchemaTypeName(schema: Schema.Schema.Any): string {
   const baseAST = getBaseSchemaAST(schema)
   switch (baseAST._tag) {
     case "StringKeyword":

package/src/bun/BunChildProcessSpawner.ts

@@ -3,8 +3,8 @@ import * as Layer from "effect/Layer"
 import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
 import type * as BunTypes from "bun"
-import * as ChildProcess from "../ChildProcess.ts"
-import * as PlatformError from "../PlatformError.ts"
+import * as ChildProcess from "../_ChildProcess.ts"
+import * as System from "../System.ts"
 
 export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succeed(
   ChildProcess.ChildProcessSpawner,
@@ -22,7 +22,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
               detached: command.detached,
             }),
           catch: (err) =>
-            new PlatformError.SystemError({
+            new System.SystemError({
               reason: "Unknown",
               module: "ChildProcess",
               method: "spawn",
@@ -45,7 +45,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
           exitCode: Effect.tryPromise({
             try: () => proc.exited,
             catch: (err) =>
-              new PlatformError.SystemError({
+              new System.SystemError({
                 reason: "Unknown",
                 module: "ChildProcess",
                 method: "exitCode",
@@ -57,7 +57,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
           isRunning: Effect.try({
             try: () => !proc.killed && proc.exitCode === null,
             catch: (err) =>
-              new PlatformError.SystemError({
+              new System.SystemError({
                 reason: "BadResource",
                 module: "ChildProcess",
                 method: "isRunning",
@@ -72,7 +72,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
                 proc.kill(options?.killSignal)
               },
               catch: (err) =>
-                new PlatformError.SystemError({
+                new System.SystemError({
                   reason: "BadResource",
                   module: "ChildProcess",
                   method: "kill",
@@ -88,7 +88,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
                 sink.write(chunk)
               },
               catch: (err) =>
-                new PlatformError.SystemError({
+                new System.SystemError({
                   reason: "Unknown",
                   module: "ChildProcess",
                   method: "fromWritable(stdin)",
@@ -108,7 +108,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
           stdout: Stream.fromReadableStream(
             () => proc.stdout as ReadableStream<Uint8Array>,
             (err) =>
-              new PlatformError.SystemError({
+              new System.SystemError({
                 reason: "Unknown",
                 module: "ChildProcess",
                 method: "fromReadable(stdout)",
@@ -120,7 +120,7 @@ export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succee
           stderr: Stream.fromReadableStream(
             () => proc.stderr as ReadableStream<Uint8Array>,
             (err) =>
-              new PlatformError.SystemError({
+              new System.SystemError({
                 reason: "Unknown",
                 module: "ChildProcess",
                 method: "fromReadable(stderr)",

package/src/bun/BunRoute.ts

@@ -1,12 +1,12 @@
 import type * as Bun from "bun"
-import * as Array from "effect/Array"
 import * as Data from "effect/Data"
+import * as Either from "effect/Either"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Entity from "../Entity.ts"
-import * as FilePathPattern from "../FilePathPattern.ts"
 import * as Hyper from "../hyper/Hyper.ts"
 import * as HyperHtml from "../hyper/HyperHtml.ts"
+import * as PathPattern from "../_PathPattern.ts"
 import * as Route from "../Route.ts"
 import * as Unique from "../Unique.ts"
 import * as BunServer from "./BunServer.ts"
@@ -180,16 +180,13 @@ export type BunRoutes = Record<string, BunServerRouteHandler>
  */
 
 export function validateBunPattern(pattern: string): Option.Option<BunRouteError> {
-  const segs = FilePathPattern.segments(pattern)
-
-  const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment")
-
-  if (Option.isSome(invalid)) {
+  const parsed = PathPattern.fromFilePath(pattern)
+  if (Either.isLeft(parsed)) {
     return Option.some(
       new BunRouteError({
         reason: "UnsupportedPattern",
         pattern,
-        message: `Pattern "${pattern}" contains invalid segment.`,
+        message: parsed.left.message,
       }),
     )
   }

package/src/bun/BunServer.ts

@@ -11,11 +11,11 @@ import * as Runtime from "effect/Runtime"
 import type * as Scope from "effect/Scope"
 import * as NOs from "node:os"
 import * as NPath from "node:path"
-import * as PathPattern from "../PathPattern.ts"
+import * as PathPattern from "../_PathPattern.ts"
 import * as PlatformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
 import * as RouteHttp from "../RouteHttp.ts"
-import * as StartApp from "../StartApp.ts"
+import * as StartApp from "../_StartApp.ts"
 import type * as RouteMount from "../RouteMount.ts"
 import * as RouteTree from "../RouteTree.ts"
 import * as BunRoute from "./BunRoute.ts"
@@ -112,7 +112,7 @@ export const make = (
           ws.data.closeDeferred,
           Socket.defaultCloseCodeIsError(code)
             ? Exit.fail(
-                new Socket.SocketCloseError({
+                new Socket.SocketError({
                   reason: "Close",
                   code,
                   closeReason,

package/src/bundler/BundleRoute.ts

@@ -3,10 +3,10 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Entity from "../Entity.ts"
-import * as PathPattern from "../PathPattern.ts"
+import * as PathPattern from "../_PathPattern.ts"
 import * as Route from "../Route.ts"
 import * as RouteTree from "../RouteTree.ts"
-import * as Values from "../Values.ts"
+import * as Values from "../_Values.ts"
 import * as Bundle from "./Bundle.ts"
 
 /**

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")
+}