effect-start 0.22.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "license": "MIT",
   "files": [
     "src/",
@@ -32,6 +32,16 @@
       "bun": "./src/testing/index.ts",
       "default": "./dist/testing/index.js"
     },
+    "./console": {
+      "types": "./dist/console/index.d.ts",
+      "bun": "./src/console/index.ts",
+      "default": "./dist/console/index.js"
+    },
+    "./sql/*": {
+      "types": "./dist/sql/*/index.d.ts",
+      "bun": "./src/sql/*/index.ts",
+      "default": "./dist/sql/*/index.js"
+    },
     "./x/*": {
       "types": "./dist/x/*/index.d.ts",
       "bun": "./src/x/*/index.ts",
@@ -42,6 +52,11 @@
       "bun": "./src/x/tailwind/plugin.ts",
       "default": "./dist/x/tailwind/plugin.js"
     },
+    "./System": {
+      "types": "./dist/System.d.ts",
+      "bun": "./src/System.ts",
+      "default": "./dist/System.js"
+    },
     "./Unique": {
       "types": "./dist/Unique.d.ts",
       "bun": "./src/Unique.ts",
@@ -69,12 +84,12 @@
       "default": "./dist/hyper/index.js"
     },
     "./jsx-runtime": {
-      "types": "./dist/hyper/jsx-runtime.d.ts",
+      "types": "./src/hyper/jsx-runtime.ts",
       "bun": "./src/hyper/jsx-runtime.ts",
       "default": "./dist/hyper/jsx-runtime.js"
     },
     "./jsx-dev-runtime": {
-      "types": "./dist/hyper/jsx-runtime.d.ts",
+      "types": "./src/hyper/jsx-runtime.ts",
       "bun": "./src/hyper/jsx-runtime.ts",
       "default": "./dist/hyper/jsx-runtime.js"
     },
@@ -91,23 +106,20 @@
     "format": "bunx oxfmt",
     "lint": "oxlint --import-plugin --tsconfig tsconfig.json src/",
     "test": "bun test ./src/",
+    "test-sql": "bun add --no-save mssql @types/mssql postgres && TEST_SQL=1 bun test ./src/sql/",
     "deploy": "bunx --bun npm publish --access public"
   },
   "devDependencies": {
-    "@effect/language-service": "^0.62.3",
     "@types/bun": "^1.3.4",
-    "@types/react": "^19.2.7",
-    "@types/react-dom": "^19.2.3",
+    "@types/jsdom": "^27.0.0",
     "effect-memfs": "^0.8.0",
-    "expect-type": "^1.3.0",
+    "jsdom": "^28.0.0",
     "oxfmt": "latest",
     "oxlint": "^1.43.0",
     "tailwindcss": "^4.1.18",
-    "ts-namespace-import": "nounder/ts-namespace-import#140c405",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@effect/platform": ">=0.93.0",
-    "effect": ">=3.19.0"
+    "effect": "^3.19.11"
   }
 }

package/src/ChildProcess.ts

@@ -0,0 +1,145 @@
+/**
+ * Adapted from upcomnig Effect 4 aka effect-smol.
+ *
+ * Kept a minimal interface without tempaltes and file descirptor
+ * to keep it compatible if it lands in the core (ie. not in seperate platform package.)
+ */
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Pipeable from "effect/Pipeable"
+import * as Predicate from "effect/Predicate"
+import type * as Scope from "effect/Scope"
+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"
+
+const TypeId: unique symbol = Symbol.for("effect-start/ChildProcess/Command")
+
+type TypeId = typeof TypeId
+
+type Stdio = "pipe" | "inherit" | "ignore"
+
+export interface Command extends Pipeable.Pipeable {
+  readonly [TypeId]: TypeId
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd?: string
+  readonly env?: Record<string, string>
+  readonly stdin?: Stdio
+  readonly stdout?: Stdio
+  readonly stderr?: Stdio
+  readonly detached?: boolean
+  [Symbol.iterator](): Effect.EffectGenerator<
+    Effect.Effect<
+      ChildProcessHandle,
+      PlatformError.PlatformError,
+      ChildProcessSpawner | Scope.Scope
+    >
+  >
+}
+
+export namespace Command {
+  export interface Options {
+    readonly cwd?: string
+    readonly env?: Record<string, string>
+    readonly stdin?: Stdio
+    readonly stdout?: Stdio
+    readonly stderr?: Stdio
+    readonly detached?: boolean
+  }
+}
+
+const CommandProto = {
+  [TypeId]: TypeId,
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+  [Symbol.iterator](this: Command) {
+    return new Utils.SingleShotGen(new Utils.YieldWrap(spawn(this))) as any
+  },
+}
+
+export const isCommand = (u: unknown): u is Command => Predicate.hasProperty(u, TypeId)
+
+export const make = (
+  command: string,
+  args?: ReadonlyArray<string>,
+  options?: Command.Options,
+): Command =>
+  Object.assign(Object.create(CommandProto), {
+    command,
+    args: args ?? [],
+    ...options,
+  })
+
+export type Signal =
+  | "SIGABRT"
+  | "SIGALRM"
+  | "SIGBUS"
+  | "SIGCHLD"
+  | "SIGCONT"
+  | "SIGFPE"
+  | "SIGHUP"
+  | "SIGILL"
+  | "SIGINT"
+  | "SIGIO"
+  | "SIGIOT"
+  | "SIGKILL"
+  | "SIGPIPE"
+  | "SIGPOLL"
+  | "SIGPROF"
+  | "SIGPWR"
+  | "SIGQUIT"
+  | "SIGSEGV"
+  | "SIGSTKFLT"
+  | "SIGSTOP"
+  | "SIGSYS"
+  | "SIGTERM"
+  | "SIGTRAP"
+  | "SIGTSTP"
+  | "SIGTTIN"
+  | "SIGTTOU"
+  | "SIGUNUSED"
+  | "SIGURG"
+  | "SIGUSR1"
+  | "SIGUSR2"
+  | "SIGVTALRM"
+  | "SIGWINCH"
+  | "SIGXCPU"
+  | "SIGXFSZ"
+  | "SIGBREAK"
+  | "SIGLOST"
+  | "SIGINFO"
+
+export interface KillOptions {
+  readonly killSignal?: Signal | undefined
+}
+
+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>
+}
+
+export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessSpawner")<
+  ChildProcessSpawner,
+  {
+    readonly spawn: (
+      command: Command,
+    ) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>
+  }
+>() {}
+
+export const spawn = (
+  command: Command,
+): Effect.Effect<
+  ChildProcessHandle,
+  PlatformError.PlatformError,
+  ChildProcessSpawner | Scope.Scope
+> => Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command))

package/src/PlatformError.ts

@@ -4,7 +4,6 @@
 import type * as Cause from "effect/Cause"
 import * as Data from "effect/Data"
 import * as Predicate from "effect/Predicate"
-import * as Schema from "effect/Schema"
 import type * as Types from "effect/Types"
 
 export const TypeId: unique symbol = Symbol.for("@effect/platform/Error/PlatformError")
@@ -27,24 +26,25 @@ export const TypeIdError = <const TypeId extends symbol, const Tag extends strin
   return Base as any
 }
 
-export const Module = Schema.Literal(
-  "Clipboard",
-  "Command",
-  "FileSystem",
-  "KeyValueStore",
-  "Path",
-  "Stream",
-  "Terminal",
-)
+export type SystemErrorReason =
+  | "AlreadyExists"
+  | "BadResource"
+  | "Busy"
+  | "InvalidData"
+  | "NotFound"
+  | "PermissionDenied"
+  | "TimedOut"
+  | "UnexpectedEof"
+  | "Unknown"
+  | "WouldBlock"
+  | "WriteZero"
 
-export class BadArgument extends Schema.TaggedError<BadArgument>(
-  "@effect/platform/Error/BadArgument",
-)("BadArgument", {
-  module: Module,
-  method: Schema.String,
-  description: Schema.optional(Schema.String),
-  cause: Schema.optional(Schema.Defect),
-}) {
+export class BadArgument extends Data.TaggedError("BadArgument")<{
+  module: string
+  method: string
+  description?: string | undefined
+  cause?: unknown
+}> {
   readonly [TypeId]: typeof TypeId = TypeId
 
   get message(): string {
@@ -52,33 +52,15 @@ export class BadArgument extends Schema.TaggedError<BadArgument>(
   }
 }
 
-export const SystemErrorReason = Schema.Literal(
-  "AlreadyExists",
-  "BadResource",
-  "Busy",
-  "InvalidData",
-  "NotFound",
-  "PermissionDenied",
-  "TimedOut",
-  "UnexpectedEof",
-  "Unknown",
-  "WouldBlock",
-  "WriteZero",
-)
-
-export type SystemErrorReason = typeof SystemErrorReason.Type
-
-export class SystemError extends Schema.TaggedError<SystemError>(
-  "@effect/platform/Error/SystemError",
-)("SystemError", {
-  reason: SystemErrorReason,
-  module: Module,
-  method: Schema.String,
-  description: Schema.optional(Schema.String),
-  syscall: Schema.optional(Schema.String),
-  pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
-  cause: Schema.optional(Schema.Defect),
-}) {
+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
+}> {
   readonly [TypeId]: typeof TypeId = TypeId
 
   get message(): string {
@@ -89,8 +71,3 @@ export class SystemError extends Schema.TaggedError<SystemError>(
 }
 
 export type PlatformError = BadArgument | SystemError
-
-export const PlatformError: Schema.Union<[typeof BadArgument, typeof SystemError]> = Schema.Union(
-  BadArgument,
-  SystemError,
-)

package/src/Route.ts

@@ -221,10 +221,10 @@ export { sse } from "./RouteSse.ts"
 
 export function redirect(
   url: string | URL,
-  status: 301 | 302 | 303 | 307 | 308 = 302,
+  options?: { status?: 301 | 302 | 303 | 307 | 308 },
 ): Entity.Entity<""> {
   return Entity.make("", {
-    status,
+    status: options?.status ?? 302,
     headers: {
       location: url instanceof URL ? url.href : url,
     },

package/src/RouteError.ts

@@ -0,0 +1,76 @@
+import * as Schema from "effect/Schema"
+
+export class BadRequest extends Schema.TaggedError<BadRequest>()("BadRequest", {
+  message: Schema.String,
+}) {
+  static readonly status = 400
+}
+
+export class Unauthorized extends Schema.TaggedError<Unauthorized>()("Unauthorized", {
+  message: Schema.String,
+}) {
+  static readonly status = 401
+}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()("Forbidden", {
+  message: Schema.String,
+}) {
+  static readonly status = 403
+}
+
+export class NotFound extends Schema.TaggedError<NotFound>()("NotFound", {
+  message: Schema.String,
+}) {
+  static readonly status = 404
+}
+
+export class MethodNotAllowed extends Schema.TaggedError<MethodNotAllowed>()("MethodNotAllowed", {
+  message: Schema.String,
+}) {
+  static readonly status = 405
+}
+
+export class Conflict extends Schema.TaggedError<Conflict>()("Conflict", {
+  message: Schema.String,
+}) {
+  static readonly status = 409
+}
+
+export class Gone extends Schema.TaggedError<Gone>()("Gone", {
+  message: Schema.String,
+}) {
+  static readonly status = 410
+}
+
+export class UnprocessableEntity extends Schema.TaggedError<UnprocessableEntity>()(
+  "UnprocessableEntity",
+  { message: Schema.String },
+) {
+  static readonly status = 422
+}
+
+export class TooManyRequests extends Schema.TaggedError<TooManyRequests>()("TooManyRequests", {
+  message: Schema.String,
+}) {
+  static readonly status = 429
+}
+
+export class InternalServerError extends Schema.TaggedError<InternalServerError>()(
+  "InternalServerError",
+  { message: Schema.String },
+) {
+  static readonly status = 500
+}
+
+export class NotImplemented extends Schema.TaggedError<NotImplemented>()("NotImplemented", {
+  message: Schema.String,
+}) {
+  static readonly status = 501
+}
+
+export class ServiceUnavailable extends Schema.TaggedError<ServiceUnavailable>()(
+  "ServiceUnavailable",
+  { message: Schema.String },
+) {
+  static readonly status = 503
+}

package/src/RouteHttp.ts

@@ -200,11 +200,15 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
       const allRoutes = [...wildcards, ...methodRoutes]
       const selectedFormat = determineSelectedFormat(accept, allRoutes)
 
-      const hasSpecificFormatRoutes = allRoutes.some((r) => {
+      const specificFormats = new Set<string>()
+      let hasWildcardFormatRoutes = false
+      for (const r of allRoutes) {
         const format = Route.descriptor(r).format
-        return format && format !== "*"
-      })
-      const hasWildcardFormatRoutes = allRoutes.some((r) => Route.descriptor(r).format === "*")
+        if (format === "*") hasWildcardFormatRoutes = true
+        else if (format) specificFormats.add(format)
+      }
+      const hasSpecificFormatRoutes = specificFormats.size > 0
+      const varyAccept = specificFormats.size > 1
 
       if (selectedFormat === undefined && hasSpecificFormatRoutes && !hasWildcardFormatRoutes) {
         return Promise.resolve(respondError({ status: 406, message: "not acceptable" }))
@@ -272,7 +276,11 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
             return respondError({ status: 406, message: "not acceptable" })
           }
 
-          return yield* toResponse(entity, selectedFormat, runtime)
+          const response = yield* toResponse(entity, selectedFormat, runtime)
+          if (varyAccept) {
+            response.headers.set("vary", "Accept")
+          }
+          return response
         })
 
         if (tracerDisabled) {

package/src/RouteSchema.ts

@@ -2,9 +2,10 @@ import * as Effect from "effect/Effect"
 import type * as ParseResult from "effect/ParseResult"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
+import * as Entity from "./Entity.ts"
 import * as Http from "./Http.ts"
 import * as PathPattern from "./PathPattern.ts"
-import type * as Route from "./Route.ts"
+import * as Route from "./Route.ts"
 import * as RouteHook from "./RouteHook.ts"
 
 export interface RequestBodyError {
@@ -287,3 +288,97 @@ export function schemaBodyForm<
     }),
   )
 }
+
+/**
+ * Intercepts typed errors from downstream handlers, encodes them through the
+ * schema, and returns a JSON response with the given status code.
+ *
+ * Without `schemaError`, handler errors fall through to global catch during
+ * execution of request. `schemaError` short circuts error handling by
+ * return an error response immedietly.
+ *
+ * TODO: store the errors in runtime to enable generating OpenAPI and other
+ * goodies.
+ */
+export function schemaError<A, I, R>(
+  schema: Schema.Schema<A, I, R> & { readonly status: number },
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet.RouteSet<D, SB, P>,
+) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]>
+export function schemaError<A, I, R>(
+  schema: Schema.Schema<A, I, R>,
+  options: { readonly status: number },
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet.RouteSet<D, SB, P>,
+) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]>
+export function schemaError<A, I, R>(
+  schema: Schema.Schema<A, I, R> & { readonly status?: number },
+  options?: { readonly status: number },
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet.RouteSet<D, SB, P>,
+) => Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]> {
+  const status = options?.status ?? (schema as any).status
+  if (typeof status !== "number") {
+    throw new Error(
+      "schemaError: status is required either via options or as a static property on the schema",
+    )
+  }
+  const encode = Schema.encode(schema)
+  const is = Schema.is(schema)
+  return function <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+    self: Route.RouteSet.RouteSet<D, SB, P>,
+  ): Route.RouteSet.RouteSet<D, SB, [...P, Route.Route.Route<{}, {}, unknown, never, R>]> {
+    const route = Route.make<{}, {}, unknown, never, R>((_context, next) =>
+      Entity.resolve(next()).pipe(
+        Effect.catchIf(is, (error) =>
+          Effect.map(Effect.orDie(encode(error)), (encoded) => Entity.make(encoded, { status })),
+        ),
+      ),
+    )
+
+    const items: [...P, Route.Route.Route<{}, {}, unknown, never, R>] = [
+      ...Route.items(self),
+      route,
+    ]
+
+    return Route.set(items, Route.descriptor(self))
+  }
+}
+
+export function schemaSuccess<A, I, R>(
+  schema: Schema.Schema<A, I, R>,
+): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+  self: Route.RouteSet.RouteSet<D, SB, P>,
+) => Route.RouteSet.RouteSet<
+  D,
+  SB,
+  [...P, Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>]
+> {
+  const encode = Schema.encodeUnknown(schema)
+  return function <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(
+    self: Route.RouteSet.RouteSet<D, SB, P>,
+  ): Route.RouteSet.RouteSet<
+    D,
+    SB,
+    [...P, Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>]
+  > {
+    const route = Route.make<{}, {}, I, ParseResult.ParseError, R>((_context, next) =>
+      Effect.flatMap(Entity.resolve(next()), (entity) =>
+        Effect.map(encode(entity.body), (encoded) =>
+          Entity.make(encoded, {
+            status: entity.status,
+            headers: entity.headers,
+            url: entity.url,
+          }),
+        ),
+      ),
+    )
+
+    const items: [...P, Route.Route.Route<{}, {}, I, ParseResult.ParseError, R>] = [
+      ...Route.items(self),
+      route,
+    ]
+
+    return Route.set(items, Route.descriptor(self))
+  }
+}

package/src/RouteTree.ts

@@ -147,6 +147,18 @@ export function* walk(tree: RouteTree): Generator<RouteMount.MountedRoute> {
   }
 }
 
+export function merge(a: RouteTree, b: RouteTree): RouteTree {
+  const combined: RouteMap = { ...routes(a) }
+  for (const [path, items] of Object.entries(routes(b))) {
+    const key = path as PathPattern.PathPattern
+    combined[key] = combined[key] ? [...combined[key], ...items] : items
+  }
+  return {
+    [TypeId]: TypeId,
+    [RouteTreeRoutes]: sortRoutes(combined),
+  } as RouteTree
+}
+
 export function isRouteTree(input: unknown): input is RouteTree {
   return Predicate.hasProperty(input, TypeId)
 }

package/src/Sql.ts

@@ -0,0 +1,51 @@
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import type * as Effect from "effect/Effect"
+import type * as Scope from "effect/Scope"
+
+export class SqlError extends Data.TaggedError("SqlError")<{
+  readonly code: string
+  readonly message: string
+  readonly cause?: unknown
+}> {}
+
+export interface SqlQuery {
+  <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, SqlError>
+
+  readonly unsafe: <T = any>(
+    query: string,
+    values?: Array<unknown>,
+  ) => Effect.Effect<ReadonlyArray<T>, SqlError>
+
+  readonly values: {
+    <T extends Record<string, unknown>>(obj: T | ReadonlyArray<T>): SqlHelper<T>
+    <T extends Record<string, unknown>, K extends keyof T>(
+      obj: T | ReadonlyArray<T>,
+      ...columns: [K, ...Array<K>]
+    ): SqlHelper<Pick<T, K>>
+  }
+}
+
+export interface SqlClient extends SqlQuery {
+  readonly withTransaction: <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, SqlError | E, R>
+
+  readonly reserve: Effect.Effect<SqlQuery, SqlError, Scope.Scope>
+
+  readonly close: (options?: { readonly timeout?: number }) => Effect.Effect<void, SqlError>
+
+  readonly use: <T>(fn: (driver: any) => Promise<T> | T) => Effect.Effect<T, SqlError>
+}
+
+export interface SqlHelper<T> {
+  readonly value: ReadonlyArray<T>
+  readonly columns: ReadonlyArray<keyof T>
+}
+
+export const SqlClient: Context.Tag<SqlClient, SqlClient> = Context.GenericTag<SqlClient>(
+  "effect-start/Sql/SqlClient",
+)