effect-start 0.28.0 → 0.30.0

package/src/Start.ts

@@ -9,26 +9,14 @@ import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
-import type * as ChildProcess from "./ChildProcess.ts"
+import type * as ChildProcess from "./_ChildProcess.ts"
 import * as MutableRef from "effect/MutableRef"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
 import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.ts"
 import * as PlatformRuntime from "./PlatformRuntime.ts"
-import * as StartApp from "./StartApp.ts"
-
-export function layer<
-  Layers extends [Layer.Layer<never, any, any>, ...Array<Layer.Layer<never, any, any>>],
->(
-  ...layers: Layers
-): Layer.Layer<
-  { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-> {
-  return Layer.mergeAll(...layers)
-}
+import * as StartApp from "./_StartApp.ts"
 
 /**
  * Bundles layers together, wiring their dependencies automatically.
@@ -96,18 +84,6 @@ type OrderedPack<
     ]
   : []
 
-/**
- * Like `pack`, but accepts layers in any order.
- *
- * ```ts
- * // These all produce the same result:
- * Start.build(LoggerLive, DatabaseLive, UserRepoLive)
- * Start.build(UserRepoLive, DatabaseLive, LoggerLive)
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
 type BuildSuccess<Layers extends readonly Layer.Layer.Any[]> = {
   [K in keyof Layers]: Layer.Layer.Success<Layers[K]>
 }[number]
@@ -121,6 +97,18 @@ type BuildContext<Layers extends readonly Layer.Layer.Any[]> = Exclude<
   { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
 >
 
+/**
+ * Like `pack`, but accepts layers in any order.
+ *
+ * ```ts
+ * // These all produce the same result:
+ * Start.build(LoggerLive, DatabaseLive, UserRepoLive)
+ * Start.build(UserRepoLive, DatabaseLive, LoggerLive)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
 export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
   ...layers: Layers
 ): Layer.Layer<BuildSuccess<Layers>, BuildError<Layers>, BuildContext<Layers>> {
@@ -170,26 +158,19 @@ export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<L
   )
 }
 
-export type PlatformServices =
-  | BunServer.BunServer
-  | FileSystem.FileSystem
-  | ChildProcess.ChildProcessSpawner
-  | StartApp.StartApp
-
-export const Live: Layer.Layer<
-  Exclude<PlatformServices, BunServer.BunServer>,
-  never,
-  never
-> = Layer.mergeAll(
-  NodeFileSystem.layer,
-  BunChildProcessSpawner.layer,
-  Layer.effect(
-    StartApp.StartApp,
-    Deferred.make<BunServer.BunServer>().pipe(Effect.map((server) => ({ server }))),
-  ),
-)
-
-export function serve<ROut, E, RIn extends PlatformServices>(
+export function layerDev() {
+  return Layer.mergeAll(NodeFileSystem.layer, BunChildProcessSpawner.layer)
+}
+
+export function serve<
+  ROut,
+  E,
+  RIn extends
+    | BunServer.BunServer
+    | FileSystem.FileSystem
+    | ChildProcess.ChildProcessSpawner
+    | StartApp.StartApp,
+>(
   load: () => Promise<{
     default: Layer.Layer<ROut, E, RIn>
   }>,
@@ -201,7 +182,18 @@ export function serve<ROut, E, RIn extends PlatformServices>(
     Layer.unwrapEffect,
   )
 
-  const appLayerResolved = Function.pipe(appLayer, Layer.provideMerge(Live))
+  const appLayerResolved = Function.pipe(
+    appLayer,
+    Layer.provideMerge(
+      Layer.mergeAll(
+        layerDev(),
+        Layer.effect(
+          StartApp.StartApp,
+          Deferred.make<BunServer.BunServer>().pipe(Effect.map((server) => ({ server }))),
+        ),
+      ),
+    ),
+  )
 
   const composed = Function.pipe(
     BunServer.layerStart(),

package/src/System.ts

@@ -1,75 +1,51 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
-import * as NNet from "node:net"
+import * as ChildProcess from "./_ChildProcess.ts"
 
-import * as ChildProcess from "./ChildProcess.ts"
-import * as PlatformError from "./PlatformError.ts"
+export type Spawner = ChildProcess.ChildProcessSpawner
 
-export const cwd: Effect.Effect<string> = Effect.sync(() => process.cwd())
+export type SystemErrorReason =
+  | "AlreadyExists"
+  | "BadArgument"
+  | "BadResource"
+  | "Busy"
+  | "InvalidData"
+  | "NotFound"
+  | "PermissionDenied"
+  | "TimedOut"
+  | "UnexpectedEof"
+  | "Unknown"
+  | "WouldBlock"
+  | "WriteZero"
 
-export const randomFreePort: Effect.Effect<number, PlatformError.SystemError> = Effect.async<
-  number,
-  PlatformError.SystemError
->((resume) => {
-  const server = NNet.createServer()
-  server.unref()
-  server.on("error", (err) =>
-    resume(
-      Effect.fail(
-        new PlatformError.SystemError({
-          reason: "Unknown",
-          module: "System",
-          method: "randomFreePort",
-          description: err.message,
-          cause: err,
-        }),
-      ),
-    ),
-  )
-  server.listen(0, "127.0.0.1", () => {
-    const address = server.address()
-    if (!address || typeof address === "string") {
-      server.close(() =>
-        resume(
-          Effect.fail(
-            new PlatformError.SystemError({
-              reason: "Unknown",
-              module: "System",
-              method: "randomFreePort",
-              description: "Failed to allocate a free port",
-            }),
-          ),
-        ),
-      )
-      return
-    }
-    const port = address.port
-    server.close((err) => {
-      if (err) {
-        resume(
-          Effect.fail(
-            new PlatformError.SystemError({
-              reason: "Unknown",
-              module: "System",
-              method: "randomFreePort",
-              description: err.message,
-              cause: err,
-            }),
-          ),
-        )
-        return
-      }
-      resume(Effect.succeed(port))
-    })
-  })
-})
+export class SystemError extends Data.TaggedError("SystemError")<{
+  reason: SystemErrorReason
+  module: string
+  method: string
+  description?: string | undefined
+  syscall?: string | undefined
+  pathOrDescriptor?: string | number | undefined
+  cause?: unknown
+}> {
+  get message(): string {
+    return `${this.reason}: ${this.module}.${this.method}${
+      this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
+    }${this.description ? `: ${this.description}` : ""}`
+  }
+}
+
+export const cwd: Effect.Effect<string> = Effect.sync(() => process.cwd())
 
-export const which = (name: string): Effect.Effect<string, PlatformError.SystemError> =>
+export const which = (name: string): Effect.Effect<string, SystemError> =>
   Effect.flatMap(
     Effect.try({
       try: () => Bun.which(name),
       catch: (err) =>
-        new PlatformError.SystemError({
+        new SystemError({
           reason: "Unknown",
           module: "System",
           method: "which",
@@ -80,7 +56,7 @@ export const which = (name: string): Effect.Effect<string, PlatformError.SystemE
     (path) =>
       path === null
         ? Effect.fail(
-            new PlatformError.SystemError({
+            new SystemError({
               reason: "NotFound",
               module: "System",
               method: "which",
@@ -91,10 +67,10 @@ export const which = (name: string): Effect.Effect<string, PlatformError.SystemE
   )
 
 export const spawn = (
-  cmd: readonly [string, ...Array<string>],
+  cmd: [string, ...Array<string>] | string[],
   options?: ChildProcess.Command.Options,
 ): Effect.Effect<
   ChildProcess.ChildProcessHandle,
-  PlatformError.PlatformError,
+  SystemError,
   ChildProcess.ChildProcessSpawner | Scope.Scope
 > => ChildProcess.spawn(ChildProcess.make(cmd, options))

package/src/{ChildProcess.ts → _ChildProcess.ts}

@@ -13,16 +13,14 @@ import type * as Sink from "effect/Sink"
 import type * as Stream from "effect/Stream"
 import * as Utils from "effect/Utils"
 
-import type * as PlatformError from "./PlatformError.ts"
+import type * as System from "./System.ts"
 
-const TypeId: unique symbol = Symbol.for("effect-start/ChildProcess/Command")
-
-type TypeId = typeof TypeId
+const TypeId = "~effect-start/ChildProcess/Command" as const
 
 type Stdio = "pipe" | "inherit" | "ignore"
 
 export interface Command extends Pipeable.Pipeable {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly cmd: readonly [string, ...Array<string>]
   readonly cwd?: string
   readonly env?: Record<string, string>
@@ -31,11 +29,7 @@ export interface Command extends Pipeable.Pipeable {
   readonly stderr?: Stdio
   readonly detached?: boolean
   [Symbol.iterator](): Effect.EffectGenerator<
-    Effect.Effect<
-      ChildProcessHandle,
-      PlatformError.PlatformError,
-      ChildProcessSpawner | Scope.Scope
-    >
+    Effect.Effect<ChildProcessHandle, System.SystemError, ChildProcessSpawner | Scope.Scope>
   >
 }
 
@@ -63,7 +57,7 @@ const CommandProto = {
 export const isCommand = (u: unknown): u is Command => Predicate.hasProperty(u, TypeId)
 
 export const make = (
-  cmd: readonly [string, ...Array<string>],
+  cmd: [string, ...Array<string>] | string[],
   options?: Command.Options,
 ): Command =>
   Object.assign(Object.create(CommandProto), {
@@ -116,12 +110,12 @@ export interface KillOptions {
 
 export interface ChildProcessHandle {
   readonly pid: number
-  readonly exitCode: Effect.Effect<number, PlatformError.PlatformError>
-  readonly isRunning: Effect.Effect<boolean, PlatformError.PlatformError>
-  readonly kill: (options?: KillOptions) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly stdin: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
-  readonly stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError>
-  readonly stderr: Stream.Stream<Uint8Array, PlatformError.PlatformError>
+  readonly exitCode: Effect.Effect<number, System.SystemError>
+  readonly isRunning: Effect.Effect<boolean, System.SystemError>
+  readonly kill: (options?: KillOptions) => Effect.Effect<void, System.SystemError>
+  readonly stdin: Sink.Sink<void, Uint8Array, never, System.SystemError>
+  readonly stdout: Stream.Stream<Uint8Array, System.SystemError>
+  readonly stderr: Stream.Stream<Uint8Array, System.SystemError>
 }
 
 export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessSpawner")<
@@ -129,14 +123,11 @@ export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessS
   {
     readonly spawn: (
       command: Command,
-    ) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>
+    ) => Effect.Effect<ChildProcessHandle, System.SystemError, Scope.Scope>
   }
 >() {}
 
 export const spawn = (
   command: Command,
-): Effect.Effect<
-  ChildProcessHandle,
-  PlatformError.PlatformError,
-  ChildProcessSpawner | Scope.Scope
-> => Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command))
+): Effect.Effect<ChildProcessHandle, System.SystemError, ChildProcessSpawner | Scope.Scope> =>
+  Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command))

package/src/{Docker.ts → _Docker.ts}

@@ -5,7 +5,7 @@ import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
 import * as Stream from "effect/Stream"
 
-import type * as ChildProcess from "./ChildProcess.ts"
+import type * as ChildProcess from "./_ChildProcess.ts"
 import * as System from "./System.ts"
 
 export class DockerError extends Data.TaggedError("DockerError")<{

package/src/{Http.ts → _Http.ts}

@@ -1,5 +1,3 @@
-import * as Values from "./Values.ts"
-
 export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS"
 
 type Respondable = Response | Promise<Response>
@@ -8,32 +6,6 @@ export type WebHandler = (request: Request) => Respondable
 
 export type WebMiddleware = (request: Request, next: WebHandler) => Respondable
 
-export function fetch(
-  handler: WebHandler,
-  init: Omit<RequestInit, "body"> &
-    ({ url: string } | { path: `/${string}` }) & {
-      body?: RequestInit["body"] | Record<string, unknown>
-    },
-): Promise<Response> {
-  const url = "path" in init ? `http://localhost${init.path}` : init.url
-
-  const isPlain = Values.isPlainObject(init.body)
-
-  const headers = new Headers(init.headers)
-  if (isPlain && !headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json")
-  }
-
-  const body = isPlain ? JSON.stringify(init.body) : init.body
-
-  const request = new Request(url, {
-    ...init,
-    headers,
-    body: body as BodyInit,
-  })
-  return Promise.resolve(handler(request))
-}
-
 export function createAbortableRequest(
   init: Omit<RequestInit, "signal"> & ({ url: string } | { path: `/${string}` }),
 ): { request: Request; abort: () => void } {

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)",