effect-start 0.25.0 → 0.26.0

package/dist/bun/BunServer.js

@@ -1,285 +0,0 @@
-import * as Socket from "../Socket.js"
-import * as Bun from "bun"
-import * as Config from "effect/Config"
-import * as Context from "effect/Context"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Runtime from "effect/Runtime"
-import * as NOs from "node:os"
-import * as NPath from "node:path"
-import * as PathPattern from "../PathPattern.js"
-import * as PlataformRuntime from "../PlatformRuntime.js"
-import * as Route from "../Route.js"
-import * as RouteHttp from "../RouteHttp.js"
-import * as StartApp from "../StartApp.js"
-import * as RouteTree from "../RouteTree.js"
-import * as BunRoute from "./BunRoute.js"
-
-/**
- * Basically `Omit<Bun.Serve.Options, "fetch" | "error" | "websocket">`
- * TypeScript 5.9 cannot verify discriminated union types used in
- * {@link Bun.serve} so we need to define them explicitly.
- */
-
-export const BunServer = Context.GenericTag("effect-start/BunServer")
-
-export const make = (
-  options,
-  tree,
-) =>
-  Effect.gen(function* () {
-    const port = yield* Config.number("PORT").pipe(
-      Effect.catchTag("ConfigError", () => {
-        return PlataformRuntime.isAgentHarness()
-          ? Effect.succeed(0) // random port
-          : Effect.succeed(3000)
-      }),
-    )
-    const hostFlag = process.argv.includes("--host")
-    const hostname = yield* Config.string("HOST").pipe(
-      Effect.catchTag("ConfigError", () => Effect.succeed(hostFlag ? "0.0.0.0" : undefined)),
-    )
-
-    const handlerStack = [
-      function (_request, _server) {
-        return new Response("not found", { status: 404 })
-      },
-    ]
-
-    const service = BunServer.of({
-      // During the construction we need to create a service imlpementation
-      // first so we can provide it in the runtime that will be used in web
-      // handlers. After we create the runtime, we set it below so it's always
-      // available at runtime.
-      // An alternative approach would be to use Bun.Server.reload but I prefer
-      // to avoid it since it's badly documented and has bunch of bugs.
-      server: undefined,
-      pushHandler(fetch) {
-        handlerStack.push(fetch)
-        reload()
-      },
-      popHandler() {
-        handlerStack.pop()
-        reload()
-      },
-    })
-
-    const runtime = yield* Effect.runtime().pipe(
-      Effect.andThen(Runtime.provideService(BunServer, service)),
-    )
-
-    let currentRoutes = tree ? yield* walkBunRoutes(runtime, tree) : {}
-
-    const websocket = {
-      open(ws) {
-        Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws))
-      },
-      message(ws, message) {
-        ws.data.run(message)
-      },
-      close(ws, code, closeReason) {
-        Deferred.unsafeDone(
-          ws.data.closeDeferred,
-          Socket.defaultCloseCodeIsError(code)
-            ? Exit.fail(
-                new Socket.SocketCloseError({
-                  reason: "Close",
-                  code,
-                  closeReason,
-                }),
-              )
-            : Exit.void,
-        )
-      },
-    }
-
-    const server = Bun.serve({
-      port,
-      hostname,
-      ...options,
-      routes: currentRoutes,
-      fetch: handlerStack[0],
-      websocket,
-    })
-
-    // @ts-expect-error
-    service.server = server
-
-    yield* Effect.addFinalizer(() =>
-      Effect.sync(() => {
-        server.stop()
-      }),
-    )
-
-    const reload = () => {
-      server.reload({
-        fetch: handlerStack[handlerStack.length - 1],
-        routes: currentRoutes,
-        websocket,
-      })
-    }
-
-    const bunServer = BunServer.of({
-      server,
-      pushHandler(fetch) {
-        handlerStack.push(fetch)
-        reload()
-      },
-      popHandler() {
-        handlerStack.pop()
-        reload()
-      },
-    })
-
-    return bunServer
-  })
-
-/**
- * Provides HttpServer using BunServer under the hood.
- */
-export const layer = (options) =>
-  Layer.scoped(BunServer, make(options ?? {}))
-
-export const layerRoutes = (
-  options,
-) =>
-  Layer.scoped(
-    BunServer,
-    Effect.gen(function* () {
-      const routes = yield* Route.Routes
-      return yield* make(options ?? {}, routes)
-    }),
-  )
-
-/**
- * Resolves the Bun server in one place for Start.serve so routes are available:
- * 1) Reuse a user-provided BunServer when one already exists in context.
- * 2) Otherwise create the server from Route.Routes when routes are available.
- * 3) Otherwise create a fallback server with the default 404 handler.
- */
-export const layerStart = (
-  options,
-) =>
-  Layer.scoped(
-    BunServer,
-    Effect.gen(function* () {
-      const app = yield* StartApp.StartApp
-      const existing = yield* Effect.serviceOption(BunServer)
-      if (Option.isSome(existing)) {
-        yield* Deferred.succeed(app.server, existing.value)
-        return existing.value
-      }
-      const routes = yield* Effect.serviceOption(Route.Routes)
-      if (Option.isSome(routes)) {
-        const server = yield* make(options ?? {}, routes.value)
-        yield* Deferred.succeed(app.server, server)
-        return server
-      }
-      const server = yield* make(options ?? {})
-      yield* Deferred.succeed(app.server, server)
-      return server
-    }),
-  )
-
-export const withLogAddress = (layer) =>
-  Layer.effectDiscard(
-    Effect.gen(function* () {
-      const { server } = yield* BunServer
-      const { hostname, port } = server
-      const addr = hostname === "0.0.0.0" ? getLocalIp() : "localhost"
-
-      yield* Effect.log(`Listening on http://${addr}:${port}`)
-    }),
-  ).pipe(Layer.provideMerge(layer))
-
-function walkBunRoutes(runtime, tree) {
-  return Effect.gen(function* () {
-    const bunRoutes = {}
-    const pathGroups = new Map()
-    const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
-
-    for (const route of RouteTree.walk(tree)) {
-      const bunDescriptors = BunRoute.descriptors(route)
-      if (bunDescriptors) {
-        const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
-        if (htmlBundle.files) {
-          registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes)
-        } else {
-          bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
-        }
-      }
-
-      const path = Route.descriptor(route).path
-      const group = pathGroups.get(path) ?? []
-      group.push(route)
-      pathGroups.set(path, group)
-    }
-
-    for (const [path, routes] of pathGroups) {
-      const handler = toWebHandler(routes)
-      for (const bunPath of PathPattern.toBun(path)) {
-        bunRoutes[bunPath] = handler
-      }
-    }
-
-    return bunRoutes
-  })
-}
-
-function registerPrebuiltBundle(prefix, bundle, bunRoutes) {
-  const mainDir = NPath.dirname(Bun.main)
-  const indexPath = NPath.resolve(mainDir, bundle.index)
-
-  const htmlPromise = rewriteRelativeAssetPaths(Bun.file(indexPath).text())
-
-  bunRoutes[`${prefix}/*`] = async () =>
-    new Response(await htmlPromise, { 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 rewriteRelativeAssetPaths(html) {
-  const rewriter = new HTMLRewriter()
-    .on("link[href]", {
-      element(el) {
-        const href = el.getAttribute("href")
-        if (href && isRelativePath(href)) {
-          el.setAttribute("href", "/" + assetBasename(href))
-        }
-      },
-    })
-    .on("script[src]", {
-      element(el) {
-        const src = el.getAttribute("src")
-        if (src && isRelativePath(src)) {
-          el.setAttribute("src", "/" + assetBasename(src))
-        }
-      },
-    })
-
-  return Promise.resolve(html).then((h) => rewriter.transform(new Response(h)).text())
-}
-
-function isRelativePath(path) {
-  return path.startsWith("./") || path.startsWith("../")
-}
-
-function assetBasename(path) {
-  const i = path.lastIndexOf("/")
-  return i === -1 ? path : path.slice(i + 1)
-}
-
-function getLocalIp() {
-  return Object.values(NOs.networkInterfaces())
-    .flatMap((addresses) => addresses ?? [])
-    .find((addr) => addr.family === "IPv4" && !addr.internal)?.address
-}

package/dist/bun/BunVirtualFilesPlugin.js

@@ -1,54 +0,0 @@
-
-
-function loaderFromPath(path) {
-  return path.slice(path.lastIndexOf(".") + 1)
-}
-
-export function make(files) {
-  return {
-    name: "virtual-fs",
-    setup(build) {
-      build.onResolve(
-        {
-          // change the filter so it only works for file namespace
-          filter: /.*/,
-        },
-        (args) => {
-          const resolved = resolvePath(args.path, args.resolveDir)
-          const resolvedFile = files[resolved]
-
-          if (resolvedFile) {
-            return {
-              path: resolved,
-              namespace: "virtual-fs",
-            }
-          }
-          return
-        },
-      )
-
-      build.onLoad(
-        {
-          filter: /.*/,
-          namespace: "virtual-fs",
-        },
-        (args) => {
-          const contents = files[args.path]
-
-          if (!contents) {
-            return undefined
-          }
-
-          return {
-            contents,
-            loader: loaderFromPath(args.path),
-          }
-        },
-      )
-    },
-  }
-}
-
-function resolvePath(path, base = process.cwd()) {
-  return Bun.resolveSync(path, base)
-}

package/dist/bun/_BunEnhancedResolve.js

@@ -1,127 +0,0 @@
-/**
- * Bun adapter for enhanced-resolve
- *
- * This module provides a drop-in replacement for `enhanced-resolve` that uses
- * Bun's built-in resolver. It implements the subset of the enhanced-resolve API
- * used for Tailwind CSS.
- */
-import fs from "node:fs"
-import path from "node:path"
-
-export class CachedInputFileSystem {
-  constructor(_fileSystem, _duration) {}
-}
-
-export const ResolverFactory = {
-  createResolver(options) {
-    const extensions = options.extensions ?? []
-    const mainFields = (options.mainFields ?? []).flatMap((f) => (Array.isArray(f) ? f : [f]))
-    const conditionNames = options.conditionNames ?? []
-
-    return {
-      resolve(
-        _context,
-        basePath,
-        id,
-        _resolveContext,
-        callback,
-      ) {
-        try {
-          const result = resolveSync(id, basePath, {
-            extensions,
-            mainFields,
-            conditionNames,
-          })
-          callback(null, result)
-        } catch (err) {
-          callback(err instanceof Error ? err : new Error(String(err)))
-        }
-      },
-    }
-  },
-}
-
-function resolveSync(
-  id,
-  base,
-  options,
-) {
-  if (id.startsWith(".") || id.startsWith("/")) {
-    for (const ext of ["", ...options.extensions]) {
-      const fullPath = path.resolve(base, id + ext)
-      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
-        return fullPath
-      }
-    }
-    return undefined
-  }
-
-  const packagePath = resolvePackagePath(id, base)
-  if (!packagePath) return undefined
-
-  const packageJsonPath = path.join(packagePath, "package.json")
-  if (!fs.existsSync(packageJsonPath)) return undefined
-
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"))
-
-  for (const field of options.mainFields) {
-    if (typeof packageJson[field] === "string") {
-      const resolved = path.resolve(packagePath, packageJson[field])
-      if (fs.existsSync(resolved)) return resolved
-    }
-  }
-
-  if (packageJson.exports) {
-    const resolved = resolveExports(packageJson.exports, packagePath, options.conditionNames)
-    if (resolved && fs.existsSync(resolved)) return resolved
-  }
-
-  try {
-    return Bun.resolveSync(id, base)
-  } catch {
-    return undefined
-  }
-}
-
-function resolvePackagePath(id, base) {
-  const parts = id.split("/")
-  const packageName = id.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]
-
-  let dir = base
-  while (dir !== path.dirname(dir)) {
-    const candidate = path.join(dir, "node_modules", packageName)
-    if (fs.existsSync(candidate)) return candidate
-    dir = path.dirname(dir)
-  }
-  return undefined
-}
-
-function resolveExports(
-  exports,
-  packagePath,
-  conditionNames,
-) {
-  if (typeof exports === "string") {
-    return path.resolve(packagePath, exports)
-  }
-
-  if (exports && typeof exports === "object" && !Array.isArray(exports)) {
-    const exportsObj = exports
-
-    if ("." in exportsObj) {
-      return resolveExports(exportsObj["."], packagePath, conditionNames)
-    }
-
-    for (const condition of conditionNames) {
-      if (condition in exportsObj) {
-        return resolveExports(exportsObj[condition], packagePath, conditionNames)
-      }
-    }
-
-    if ("default" in exportsObj) {
-      return resolveExports(exportsObj["default"], packagePath, conditionNames)
-    }
-  }
-
-  return undefined
-}

package/dist/bun/index.js

@@ -1,5 +0,0 @@
-export * as BunChildProcessSpawner from "./BunChildProcessSpawner.js"
-export * as BunBundle from "./BunBundle.js"
-export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.js"
-export * as BunRoute from "./BunRoute.js"
-export * as BunServer from "./BunServer.js"

package/dist/bundler/Bundle.js

@@ -1,92 +0,0 @@
-import { Context, Data, Effect, pipe } from "effect"
-import * as Schema from "effect/Schema"
-
-export const BundleEntrypointMetaKey = Symbol.for(
-  "effect-start/BundleEntrypointMetaKey",
-)
-
-/**
- * Generic shape describing a bundle across multiple bundlers
- * (like bun, esbuild & vite)
- */
-export const BundleManifestSchema = Schema.Struct({
-  entrypoints: Schema.Record({
-    key: Schema.String,
-    value: Schema.String,
-  }),
-  artifacts: Schema.Array(
-    Schema.Struct({
-      path: Schema.String,
-      type: Schema.String,
-      size: Schema.Number,
-      hash: pipe(Schema.String, Schema.optional),
-      imports: pipe(
-        Schema.Array(
-          Schema.Struct({
-            path: Schema.String,
-            kind: Schema.Literal(
-              "import-statement",
-              "require-call",
-              "require-resolve",
-              "dynamic-import",
-              "import-rule",
-              "url-token",
-              "internal",
-              "entry-point-run",
-              "entry-point-build",
-            ),
-          }),
-        ),
-        Schema.optional,
-      ),
-    }),
-  ),
-})
-
-const BundleEventChange = Schema.TaggedStruct("Change", {
-  path: Schema.String,
-})
-
-const BundleEventBuildError = Schema.TaggedStruct("BuildError", {
-  error: Schema.String,
-})
-
-export const BundleEvent = Schema.Union(BundleEventChange, BundleEventBuildError)
-
-const IdPrefix = "effect-start/tags/"
-
-/**
- * Passed to bundle effects and within bundle runtime.
- * Used to expose artifacts via HTTP server and properly resolve
- * imports within the bundle.
- */
-
-export class BundleError extends Data.TaggedError("BundleError") {}
-
-export const emptyBundleContext = {
-  entrypoints: {},
-  artifacts: [],
-  resolve: () => null,
-  getArtifact: () => null,
-}
-
-export const handleBundleErrorSilently = (
-  effect,
-) =>
-  pipe(
-    effect,
-    Effect.catchTag("BundleError", (error) =>
-      Effect.gen(function* () {
-        yield* Effect.logError("Bundle build failed", error)
-        return emptyBundleContext
-      }),
-    ),
-  )
-
-export const Tag =
-  (name) =>
-  () =>
-    Context.Tag(`${IdPrefix}${name}`)()
-
-export class ClientBundle extends Tag("ClientBundle")() {}
-export class ServerBundle extends Tag("ServerBundle")() {}