effect-start 0.22.1 → 0.23.0

package/src/Values.ts

@@ -66,6 +66,13 @@ export type Simplify<T> = {
   ? { [K in keyof U]: U[K] }
   : never
 
+export const firstValue = <T>(record: Record<string, T>): T | undefined => {
+  for (const key in record) {
+    return record[key]
+  }
+  return undefined
+}
+
 export const concatBytes = (a: Uint8Array, b: Uint8Array): Uint8Array => {
   const result = new Uint8Array(a.byteLength + b.byteLength)
   result.set(a)

package/src/bun/BunChildProcessSpawner.ts

@@ -0,0 +1,143 @@
+import * as Effect from "effect/Effect"
+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"
+
+const toCmd = (command: ChildProcess.Command): ReadonlyArray<string> => [
+  command.command,
+  ...command.args,
+]
+
+export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succeed(
+  ChildProcess.ChildProcessSpawner,
+  {
+    spawn: (command) =>
+      Effect.gen(function* () {
+        const cmd = toCmd(command)
+
+        const proc = yield* Effect.try({
+          try: () =>
+            Bun.spawn(cmd as Array<string>, {
+              cwd: command.cwd,
+              env: command.env,
+              stdin: command.stdin ?? "ignore",
+              stdout: command.stdout ?? "pipe",
+              stderr: command.stderr ?? "pipe",
+              detached: command.detached,
+            }),
+          catch: (err) =>
+            new PlatformError.SystemError({
+              reason: "Unknown",
+              module: "ChildProcess",
+              method: "spawn",
+              description: err instanceof Error ? err.message : "Failed to spawn process",
+              cause: err,
+            }),
+        })
+
+        yield* Effect.addFinalizer(() =>
+          Effect.sync(() => {
+            if (!proc.killed) {
+              proc.kill()
+            }
+          }),
+        )
+
+        const handle: ChildProcess.ChildProcessHandle = {
+          pid: proc.pid,
+
+          exitCode: Effect.tryPromise({
+            try: () => proc.exited,
+            catch: (err) =>
+              new PlatformError.SystemError({
+                reason: "Unknown",
+                module: "ChildProcess",
+                method: "exitCode",
+                description: "Process exited unexpectedly",
+                cause: err,
+              }),
+          }),
+
+          isRunning: Effect.try({
+            try: () => !proc.killed && proc.exitCode === null,
+            catch: (err) =>
+              new PlatformError.SystemError({
+                reason: "BadResource",
+                module: "ChildProcess",
+                method: "isRunning",
+                description: err instanceof Error ? err.message : "Failed to check process status",
+                cause: err,
+              }),
+          }),
+
+          kill: (options) =>
+            Effect.try({
+              try: () => {
+                proc.kill(options?.killSignal)
+              },
+              catch: (err) =>
+                new PlatformError.SystemError({
+                  reason: "BadResource",
+                  module: "ChildProcess",
+                  method: "kill",
+                  description: err instanceof Error ? err.message : "Failed to kill process",
+                  cause: err,
+                }),
+            }),
+
+          stdin: Sink.forEach((chunk: Uint8Array) =>
+            Effect.try({
+              try: () => {
+                const sink = proc.stdin as unknown as BunTypes.FileSink
+                sink.write(chunk)
+              },
+              catch: (err) =>
+                new PlatformError.SystemError({
+                  reason: "Unknown",
+                  module: "ChildProcess",
+                  method: "fromWritable(stdin)",
+                  description: "Failed to write to stdin",
+                  cause: err,
+                }),
+            }),
+          ).pipe(
+            Sink.ensuring(
+              Effect.promise(async () => {
+                const sink = proc.stdin as unknown as BunTypes.FileSink
+                await sink.end()
+              }),
+            ),
+          ),
+
+          stdout: Stream.fromReadableStream(
+            () => proc.stdout as ReadableStream<Uint8Array>,
+            (err) =>
+              new PlatformError.SystemError({
+                reason: "Unknown",
+                module: "ChildProcess",
+                method: "fromReadable(stdout)",
+                description: "Failed to read stdout stream",
+                cause: err,
+              }),
+          ),
+
+          stderr: Stream.fromReadableStream(
+            () => proc.stderr as ReadableStream<Uint8Array>,
+            (err) =>
+              new PlatformError.SystemError({
+                reason: "Unknown",
+                module: "ChildProcess",
+                method: "fromReadable(stderr)",
+                description: "Failed to read stderr stream",
+                cause: err,
+              }),
+          ),
+        }
+
+        return handle
+      }),
+  },
+)

package/src/bun/BunRoute.ts

@@ -34,9 +34,12 @@ export function descriptors(
   return undefined
 }
 
-export function htmlBundle(load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>) {
+type HTMLBundleModule = Bun.HTMLBundle | { default: Bun.HTMLBundle }
+
+export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModule>) {
   const bunPrefix = `/.BunRoute-${Unique.token(10)}`
-  const bunLoad = () => load().then((mod) => ("default" in mod ? mod.default : mod))
+  const bunLoad = () =>
+    Promise.resolve(load()).then((mod) => ("default" in mod ? mod.default : mod))
   const descriptors = { bunPrefix, bunLoad, format: "html" as const }
 
   return function <D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple>(

package/src/bun/BunServer.ts

@@ -10,6 +10,7 @@ import * as Option from "effect/Option"
 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 PlataformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
@@ -191,7 +192,11 @@ function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.Rout
       const bunDescriptors = BunRoute.descriptors(route)
       if (bunDescriptors) {
         const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
-        bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
+        if (htmlBundle.files) {
+          registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes)
+        } else {
+          bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
+        }
       }
 
       const path = Route.descriptor(route).path
@@ -211,6 +216,22 @@ function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.Rout
   })
 }
 
+function registerPrebuiltBundle(prefix: string, bundle: any, bunRoutes: BunRoute.BunRoutes) {
+  const mainDir = NPath.dirname(Bun.main)
+  const indexPath = NPath.resolve(mainDir, bundle.index)
+
+  bunRoutes[`${prefix}/*`] = () =>
+    new Response(Bun.file(indexPath), { headers: { "content-type": "text/html;charset=utf-8" } })
+
+  for (const file of bundle.files ?? []) {
+    if (file.loader === "html") continue
+    const absPath = NPath.resolve(mainDir, file.path)
+    const basename = NPath.basename(file.path)
+    bunRoutes[`/${basename}`] = () =>
+      new Response(Bun.file(absPath), { headers: file.headers ?? {} })
+  }
+}
+
 function getLocalIp(): string | undefined {
   return Object.values(NOs.networkInterfaces())
     .flatMap((addresses) => addresses ?? [])

package/src/bun/index.ts

@@ -1,3 +1,4 @@
+export * as BunChildProcessSpawner from "./BunChildProcessSpawner.ts"
 export * as BunBundle from "./BunBundle.ts"
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
 export * as BunRoute from "./BunRoute.ts"

package/src/bundler/BundleRoute.ts

@@ -0,0 +1,66 @@
+import type * as Context from "effect/Context"
+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 Route from "../Route.ts"
+import * as RouteTree from "../RouteTree.ts"
+import * as Values from "../Values.ts"
+import * as Bundle from "./Bundle.ts"
+
+/**
+ * Creates a GET route that serves bundle artifacts.
+ * Mount at a path with a wildcard param (any name works).
+ *
+ * ```ts
+ * RouteTree.make({
+ *   "/_bundle/:path+": BundleRoute.make(Bundle.ClientBundle),
+ * })
+ * ```
+ */
+export const make = <Tag extends Context.Tag<any, Bundle.BundleContext>>(tag: Tag) =>
+  Route.get(
+    Route.render(function* (ctx) {
+      const bundle = yield* tag
+      const url = new URL(ctx.request.url)
+      const mountPath = (ctx as unknown as { path?: string }).path ?? "/"
+      const params = PathPattern.match(mountPath, url.pathname)
+      const artifactPath = params ? Values.firstValue(params) : undefined
+      if (!artifactPath) {
+        return Entity.make(new Uint8Array(0), { status: 404 })
+      }
+      const blob = bundle.getArtifact(artifactPath)
+      if (!blob) {
+        return Entity.make(new Uint8Array(0), { status: 404 })
+      }
+      const bytes = new Uint8Array(yield* Effect.promise(() => blob.arrayBuffer()))
+      return Entity.make(bytes, {
+        headers: {
+          "content-type": blob.type || "application/octet-stream",
+          "cache-control": "public, max-age=31536000, immutable",
+        },
+      })
+    }),
+  )
+
+export const client = () => make(Bundle.ClientBundle)
+
+export const layer = (options?: {
+  bundle?: Context.Tag<any, Bundle.BundleContext>
+  path?: PathPattern.PathPattern
+}) =>
+  Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Effect.serviceOption(Route.Routes).pipe(
+        Effect.andThen(Option.getOrUndefined),
+      )
+      const path = options?.path ?? "/_bundle/:path+"
+      const bundleTree = Route.tree({
+        [path]: make(options?.bundle ?? Bundle.ClientBundle),
+      })
+      if (!existing) return bundleTree
+      return RouteTree.merge(existing, bundleTree)
+    }),
+  )

package/src/console/Console.ts

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Route from "../Route.ts"
+import * as RouteTree from "../RouteTree.ts"
+import * as ConsoleErrors from "./ConsoleErrors.ts"
+import * as ConsoleLogger from "./ConsoleLogger.ts"
+import * as ConsoleMetrics from "./ConsoleMetrics.ts"
+import * as ConsoleProcess from "./ConsoleProcess.ts"
+import * as ConsoleStore from "./ConsoleStore.ts"
+import * as ConsoleTracer from "./ConsoleTracer.ts"
+import consoleRoutes from "./routes/tree.ts"
+
+export { ConsoleStore } from "./ConsoleStore.ts"
+
+export function layer(
+  options?: ConsoleStore.ConsoleStoreOptions,
+): Layer.Layer<ConsoleStore.ConsoleStore> {
+  const store = ConsoleStore.layer(options)
+  return Layer.mergeAll(
+    ConsoleTracer.layer,
+    ConsoleLogger.layer,
+    ConsoleMetrics.layer,
+    ConsoleErrors.layer,
+    ConsoleProcess.layer,
+  ).pipe(Layer.provideMerge(store))
+}
+
+export function routeLayer(
+  prefix: string,
+): Layer.Layer<Route.Routes, never, Route.Routes | ConsoleStore.ConsoleStore> {
+  return Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Route.Routes
+      ConsoleStore.store.prefix = prefix
+      const tree = Route.tree({
+        [prefix as "/"]: consoleRoutes,
+      })
+      return RouteTree.merge(existing, tree)
+    }),
+  )
+}

package/src/console/ConsoleErrors.ts

@@ -0,0 +1,213 @@
+import * as Cause from "effect/Cause"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberId from "effect/FiberId"
+import * as FiberRef from "effect/FiberRef"
+import * as HashMap from "effect/HashMap"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as PubSub from "effect/PubSub"
+import type * as Context from "effect/Context"
+import type * as Fiber from "effect/Fiber"
+import * as Supervisor from "effect/Supervisor"
+import * as ConsoleStore from "./ConsoleStore.ts"
+
+let errorId = 0
+
+function safeSerialize(value: unknown, depth = 0): unknown {
+  if (depth > 4) return "<deep>"
+  if (value === null || value === undefined) return value
+  if (typeof value === "bigint") return `${value}n`
+  if (typeof value === "function") return undefined
+  if (typeof value === "symbol") return value.toString()
+  if (typeof value !== "object") return value
+  if (value instanceof Date) return value.toISOString()
+  if (value instanceof Error) return value.message
+  if (Array.isArray(value)) return value.slice(0, 20).map((v) => safeSerialize(v, depth + 1))
+  const proto = Object.getPrototypeOf(value)
+  if (proto !== null && proto !== Object.prototype) {
+    if (typeof (value as any)._tag === "string") {
+      return serializeTaggedObject(value as Record<string, unknown>, depth)
+    }
+    return `<${proto.constructor?.name ?? "object"}>`
+  }
+  return serializePlainObject(value as Record<string, unknown>, depth)
+}
+
+function serializePlainObject(
+  obj: Record<string, unknown>,
+  depth: number,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  let count = 0
+  for (const [k, v] of Object.entries(obj)) {
+    if (count >= 20) break
+    if (typeof v === "function") continue
+    const serialized = safeSerialize(v, depth + 1)
+    if (serialized !== undefined) {
+      out[k] = serialized
+      count++
+    }
+  }
+  return out
+}
+
+function serializeTaggedObject(
+  obj: Record<string, unknown>,
+  depth: number,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = { _tag: obj._tag }
+  let count = 0
+  for (const [k, v] of Object.entries(obj)) {
+    if (count >= 20) break
+    if (k === "_tag") continue
+    if (typeof v === "function") continue
+    if (k === "stack" || k === "name") continue
+    const serialized = safeSerialize(v, depth + 1)
+    if (serialized !== undefined) {
+      out[k] = serialized
+      count++
+    }
+  }
+  return out
+}
+
+function extractTag(error: unknown): string | undefined {
+  if (
+    error !== null &&
+    typeof error === "object" &&
+    "_tag" in error &&
+    typeof (error as any)._tag === "string"
+  ) {
+    return (error as any)._tag
+  }
+  return undefined
+}
+
+function extractMessage(error: unknown): string {
+  if (error instanceof Error) return error.message
+  if (typeof error === "string") return error
+  const tag = extractTag(error)
+  if (tag) return tag
+  try {
+    return String(error)
+  } catch {
+    return "<unknown>"
+  }
+}
+
+function extractProperties(error: unknown): Record<string, unknown> {
+  if (error === null || error === undefined || typeof error !== "object") return {}
+  const out: Record<string, unknown> = {}
+  let count = 0
+  for (const [k, v] of Object.entries(error)) {
+    if (count >= 20) break
+    if (k === "_tag" || k === "stack" || k === "name") continue
+    if (typeof v === "function") continue
+    const serialized = safeSerialize(v, 0)
+    if (serialized !== undefined) {
+      out[k] = serialized
+      count++
+    }
+  }
+  return out
+}
+
+const spanSymbol = Symbol.for("effect/SpanAnnotation")
+
+function extractSpanName(error: unknown): string | undefined {
+  if (error !== null && typeof error === "object" && spanSymbol in error) {
+    const span = (error as any)[spanSymbol]
+    return typeof span?.name === "string" ? span.name : undefined
+  }
+  return undefined
+}
+
+function extractDetails(cause: Cause.Cause<unknown>): Array<ConsoleStore.ConsoleErrorDetail> {
+  const details: Array<ConsoleStore.ConsoleErrorDetail> = []
+
+  const failures = Chunk.toArray(Cause.failures(cause))
+  for (const error of failures) {
+    details.push({
+      kind: "fail",
+      tag: extractTag(error),
+      message: extractMessage(error),
+      properties: extractProperties(error),
+      span: extractSpanName(error),
+    })
+  }
+
+  const defects = Chunk.toArray(Cause.defects(cause))
+  for (const defect of defects) {
+    details.push({
+      kind: "die",
+      tag: extractTag(defect),
+      message: extractMessage(defect),
+      properties: extractProperties(defect),
+      span: extractSpanName(defect),
+    })
+  }
+
+  return details
+}
+
+function make(store: ConsoleStore.ConsoleStoreShape): Supervisor.Supervisor<void> {
+  return new (class extends Supervisor.AbstractSupervisor<void> {
+    value = Effect.void
+
+    onStart<A, E, R>(
+      _context: Context.Context<R>,
+      _effect: Effect.Effect<A, E, R>,
+      parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
+      fiber: Fiber.RuntimeFiber<A, E>,
+    ) {
+      const childId = FiberId.threadName(fiber.id())
+      if (Option.isSome(parent)) {
+        const parentId = FiberId.threadName(parent.value.id())
+        if (childId !== parentId) {
+          store.fiberParents.set(childId, parentId)
+        }
+      }
+
+      const span = fiber.currentSpan
+      const annotations: Record<string, unknown> = {}
+      const spanAnnotations = fiber.getFiberRef(FiberRef.currentTracerSpanAnnotations)
+      HashMap.forEach(spanAnnotations, (value, key) => {
+        annotations[key] = value
+      })
+      const logAnnotations = fiber.getFiberRef(FiberRef.currentLogAnnotations)
+      HashMap.forEach(logAnnotations, (value, key) => {
+        annotations[key] = value
+      })
+
+      store.fiberContexts.set(childId, {
+        spanName: span?._tag === "Span" ? span.name : undefined,
+        traceId: span ? span.traceId : undefined,
+        annotations,
+      })
+    }
+
+    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>) {
+      if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+        const error: ConsoleStore.ConsoleError = {
+          id: String(++errorId),
+          date: new Date(),
+          fiberId: FiberId.threadName(fiber.id()),
+          interrupted: Cause.isInterrupted(exit.cause),
+          prettyPrint: Cause.pretty(exit.cause, { renderErrorCause: true }),
+          details: extractDetails(exit.cause),
+        }
+        store.errors.push(error)
+        Effect.runSync(PubSub.publish(store.events, { _tag: "Error", error }))
+      }
+    }
+  })()
+}
+
+export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore
+    return Supervisor.addSupervisor(make(store))
+  }),
+)

package/src/console/ConsoleLogger.ts

@@ -0,0 +1,56 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
+import * as FiberRef from "effect/FiberRef"
+import * as HashMap from "effect/HashMap"
+import * as HashSet from "effect/HashSet"
+import * as Layer from "effect/Layer"
+import * as List from "effect/List"
+import * as Logger from "effect/Logger"
+import * as PubSub from "effect/PubSub"
+import * as ConsoleStore from "./ConsoleStore.ts"
+
+let logId = 0
+
+export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore
+
+    const logger = Logger.make(
+      ({ message, logLevel, cause, fiberId, spans, annotations, date }) => {
+        const levelMap: Record<string, ConsoleStore.ConsoleLog["level"]> = {
+          Debug: "DEBUG",
+          Info: "INFO",
+          Warning: "WARNING",
+          Error: "ERROR",
+          Fatal: "FATAL",
+        }
+        const level = levelMap[logLevel._tag] ?? "INFO"
+        const causeStr = !Cause.isEmpty(cause)
+          ? Cause.pretty(cause, { renderErrorCause: true })
+          : undefined
+        const spanNames: Array<string> = []
+        List.forEach(spans, (s) => spanNames.push(s.label))
+        const ann: Record<string, unknown> = {}
+        HashMap.forEach(annotations, (v, k) => {
+          ann[k] = v
+        })
+
+        const log: ConsoleStore.ConsoleLog = {
+          id: String(++logId),
+          date,
+          level,
+          message: String(message),
+          fiberId: FiberId.threadName(fiberId),
+          cause: causeStr,
+          spans: spanNames,
+          annotations: ann,
+        }
+        store.logs.push(log)
+        Effect.runSync(PubSub.publish(store.events, { _tag: "Log", log }))
+      },
+    )
+
+    yield* FiberRef.update(FiberRef.currentLoggers, (loggers) => HashSet.add(loggers, logger))
+  }),
+)

package/src/console/ConsoleMetrics.ts

@@ -0,0 +1,72 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Metric from "effect/Metric"
+import * as MetricKeyType from "effect/MetricKeyType"
+import * as PubSub from "effect/PubSub"
+import * as Schedule from "effect/Schedule"
+import * as ConsoleStore from "./ConsoleStore.ts"
+
+export const layer: Layer.Layer<never, never, ConsoleStore.ConsoleStore> = Layer.scopedDiscard(
+  Effect.gen(function* () {
+    const store = yield* ConsoleStore.ConsoleStore
+
+    yield* Effect.forkScoped(
+      Effect.schedule(
+        Effect.sync(() => {
+          const pairs = Metric.unsafeSnapshot()
+          const snapshots: Array<ConsoleStore.ConsoleMetricSnapshot> = []
+
+          for (const pair of pairs) {
+            const key = pair.metricKey
+            const state = pair.metricState as any
+            let type: ConsoleStore.ConsoleMetricSnapshot["type"] = "counter"
+            let value: unknown = 0
+
+            if (MetricKeyType.CounterKeyTypeTypeId in key.keyType) {
+              type = "counter"
+              value = state.count
+            } else if (MetricKeyType.GaugeKeyTypeTypeId in key.keyType) {
+              type = "gauge"
+              value = state.value
+            } else if (MetricKeyType.HistogramKeyTypeTypeId in key.keyType) {
+              type = "histogram"
+              value = {
+                buckets: state.buckets,
+                count: state.count,
+                sum: state.sum,
+                min: state.min,
+                max: state.max,
+              }
+            } else if (MetricKeyType.FrequencyKeyTypeTypeId in key.keyType) {
+              type = "frequency"
+              value = Object.fromEntries(state.occurrences)
+            } else if (MetricKeyType.SummaryKeyTypeTypeId in key.keyType) {
+              type = "summary"
+              value = {
+                quantiles: state.quantiles,
+                count: state.count,
+                sum: state.sum,
+                min: state.min,
+                max: state.max,
+              }
+            }
+
+            snapshots.push({
+              name: key.name,
+              type,
+              value,
+              tags: key.tags.map((t: any) => ({ key: t.key, value: t.value })),
+              timestamp: Date.now(),
+            })
+          }
+
+          store.metrics = snapshots
+          Effect.runSync(
+            PubSub.publish(store.events, { _tag: "MetricsSnapshot", metrics: snapshots }),
+          )
+        }),
+        Schedule.spaced("2 seconds"),
+      ),
+    )
+  }),
+)