effect-start 0.25.0 → 0.27.0

package/dist/FileRouter.js

@@ -1,204 +0,0 @@
-import * as FileSystem from "./FileSystem.js"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Function from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Stream from "effect/Stream"
-import * as NPath from "node:path"
-import * as NUrl from "node:url"
-import * as Development from "./Development.js"
-import * as FilePathPattern from "./FilePathPattern.js"
-import * as FileRouterCodegen from "./FileRouterCodegen.js"
-import * as NodeUtils from "./node/NodeUtils.js"
-import * as Route from "./Route.js"
-import * as RouteTree from "./RouteTree.js"
-
-export class FileRouterError extends Data.TaggedError("FileRouterError") {}
-
-/**
- * Routes sorted by depth, with rest parameters at the end.
- * - layer.tsx
- * - users/route.tsx
- * - users/[userId]/route.tsx
- * - [[rest]]/route.tsx
- */
-
-const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/
-
-export function parseRoute(path) {
-  const segs = FilePathPattern.segments(path)
-
-  const lastSeg = segs.at(-1)
-  const handleMatch =
-    lastSeg?._tag === "LiteralSegment" && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/)
-  const handle = handleMatch ? (handleMatch[1]) : null
-
-  if (!handle) {
-    return null
-  }
-
-  const pathSegments = segs.slice(0, -1)
-
-  const validated = FilePathPattern.validate(FilePathPattern.format(pathSegments))
-  if (Either.isLeft(validated)) {
-    return null
-  }
-
-  const restIndex = pathSegments.findIndex((seg) => seg._tag === "RestSegment")
-  if (restIndex !== -1 && restIndex !== pathSegments.length - 1) {
-    return null
-  }
-
-  const routePathSegments = pathSegments.filter((seg) => seg._tag !== "GroupSegment")
-  const routePath = FilePathPattern.format(routePathSegments)
-
-  return {
-    handle,
-    modulePath: `/${path}`,
-    routePath,
-    segments: pathSegments,
-  }
-}
-
-function importModule(load) {
-  return Effect.tryPromise({
-    try: () => load(),
-    catch: (cause) => new FileRouterError({ reason: "Import", cause }),
-  })
-}
-
-/**
- * Generates a tree file that references all routes.
- */
-export function layer(
-  loadOrOptions,
-) {
-  const options =
-    typeof loadOrOptions === "function"
-      ? {
-          load: loadOrOptions,
-          path: NPath.join(NodeUtils.getEntrypoint(), "routes"),
-        }
-      : loadOrOptions
-  let treePath = options.path
-  if (treePath.startsWith("file://")) {
-    treePath = NUrl.fileURLToPath(treePath)
-  }
-  if (NPath.extname(treePath) === "") {
-    treePath = NPath.join(treePath, "server.gen.ts")
-  }
-
-  const routesPath = NPath.dirname(treePath)
-  const treeFilename = NPath.basename(treePath)
-  const relativeRoutesPath = NPath.relative(process.cwd(), routesPath)
-
-  return Layer.scoped(
-    Route.Routes,
-    Effect.gen(function* () {
-      // Generate routes file before loading
-      yield* FileRouterCodegen.update(routesPath, treeFilename)
-
-      // Load and build route tree
-      const m = yield* importModule(options.load)
-      const routeTree = yield* fromFileRoutes(m.default)
-
-      // Watch for changes (only when Development service is available)
-      yield* Function.pipe(
-        Development.stream(),
-        Stream.filter((e) => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)),
-        Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)),
-        Effect.fork,
-      )
-
-      return routeTree
-    }),
-  )
-}
-
-export function fromFileRoutes(fileRoutes) {
-  return Effect.gen(function* () {
-    const mounts = {}
-
-    for (const [path, loaders] of Object.entries(fileRoutes)) {
-      const modules = yield* Effect.forEach(loaders, (loader) => Effect.promise(() => loader()))
-
-      const allRoutes = []
-
-      for (const m of modules) {
-        if (Route.isRouteSet(m.default)) {
-          for (const route of m.default) {
-            ;(allRoutes).push(route)
-          }
-        }
-      }
-
-      mounts[path] = allRoutes
-    }
-
-    return RouteTree.make(mounts)
-  })
-}
-
-export function walkRoutesDirectory(
-  dir,
-) {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const files = yield* fs.readDirectory(dir, { recursive: true })
-
-    return yield* getFileRoutes(files)
-  })
-}
-
-export function getFileRoutes(
-  paths,
-) {
-  return Effect.gen(function* () {
-    const routes = paths
-      .map((f) => f.match(ROUTE_PATH_REGEX))
-      .filter(Boolean)
-      .map((v) => {
-        const path = v[0]
-        try {
-          return parseRoute(path)
-        } catch {
-          return null
-        }
-      })
-      .filter((route) => route !== null)
-      .toSorted((a, b) => {
-        const aDepth = a.segments.length
-        const bDepth = b.segments.length
-        const aHasRest = a.segments.some((seg) => seg._tag === "RestSegment")
-        const bHasRest = b.segments.some((seg) => seg._tag === "RestSegment")
-
-        return (
-          // rest is a dominant factor (routes with rest come last)
-          (+aHasRest - +bHasRest) * 1000 +
-          // depth is reversed for rest
-          (aDepth - bDepth) * (1 - 2 * +aHasRest) +
-          // lexicographic comparison as tiebreaker
-          a.modulePath.localeCompare(b.modulePath) * 0.001
-        )
-      })
-
-    // Detect conflicting routes at the same path
-    const routesByPath = new Map()
-    for (const route of routes) {
-      const existing = routesByPath.get(route.routePath) || []
-      existing.push(route)
-      routesByPath.set(route.routePath, existing)
-    }
-
-    for (const [path, pathRoutes] of routesByPath) {
-      const routeHandles = pathRoutes.filter((h) => h.handle === "route")
-
-      if (routeHandles.length > 1) {
-        yield* new FileRouterError({ reason: "Conflict", path })
-      }
-    }
-
-    return routes
-  })
-}

package/dist/FileRouterCodegen.js

@@ -1,298 +0,0 @@
-import * as FileSystem from "./FileSystem.js"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Schema from "effect/Schema"
-import * as NPath from "node:path"
-import * as FilePathPattern from "./FilePathPattern.js"
-import * as FileRouter from "./FileRouter.js"
-import * as SchemaExtra from "./SchemaExtra.js"
-
-export function validateRouteModule(module) {
-  if (typeof module !== "object" || module === null) {
-    return false
-  }
-
-  if (!("default" in module)) {
-    return false
-  }
-
-  // TODO: verify we're exporting a proper shape
-  return true
-}
-
-export function generatePathParamsSchema(
-  segments,
-) {
-  const fields = {}
-
-  for (const segment of segments) {
-    if (segment._tag === "ParamSegment") {
-      fields[segment.name] = Schema.String
-    } else if (segment._tag === "RestSegment") {
-      fields[segment.name] = Schema.optional(Schema.String)
-    }
-  }
-
-  if (Object.keys(fields).length === 0) {
-    return null
-  }
-
-  return Schema.Struct(fields)
-}
-
-/**
- * Validates all route modules in the given route handles.
- */
-
-export function validateRouteModules(
-  path,
-  routes,
-) {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const routeHandles = routes.filter((h) => h.handle === "route")
-
-    for (const handle of routeHandles) {
-      const routeModulePath = NPath.resolve(path, handle.modulePath)
-      const expectedSchema = generatePathParamsSchema(handle.segments)
-
-      const fileExists = yield* fs
-        .exists(routeModulePath)
-        .pipe(Effect.catchAll(() => Effect.succeed(false)))
-      if (!fileExists) {
-        continue
-      }
-
-      const module = yield* Effect.tryPromise({
-        try: () => import(routeModulePath),
-        catch: (cause) =>
-          new FileRouter.FileRouterError({
-            reason: "Import",
-            cause,
-            path: routeModulePath,
-          }),
-      })
-
-      if (!validateRouteModule(module)) {
-        yield* Effect.logWarning(`Route module ${routeModulePath} should export default Route`)
-        continue
-      }
-
-      const routeSet = module.default
-      // extract user schema
-      const userSchema = undefined
-
-      if (expectedSchema && userSchema && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
-        const relativeFilePath = NPath.relative(process.cwd(), routeModulePath)
-        yield* Effect.logError(
-          `Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${SchemaExtra.formatSchemaCode(
-            expectedSchema,
-          )})`,
-        )
-      }
-    }
-  })
-}
-
-export function generateCode(fileRoutes) {
-  // Group routes by path to find layers
-  const routesByPath = new Map()
-
-  for (const fileRoute of fileRoutes) {
-    const existing = routesByPath.get(fileRoute.routePath) || { layers: [] }
-    if (fileRoute.handle === "route") {
-      existing.route = fileRoute
-    } else if (fileRoute.handle === "layer") {
-      existing.layers.push(fileRoute)
-    }
-    routesByPath.set(fileRoute.routePath, existing)
-  }
-
-  // Helper to check if layer's path is an ancestor of route's path
-  const layerMatchesRoute = (layer, route) => {
-    const layerDir = layer.modulePath.replace(/\/(layer)\.(tsx?|jsx?)$/, "")
-    if (layerDir === "/") return true
-    return route.modulePath.startsWith(layerDir + "/")
-  }
-
-  // Build entries for each route path
-  const entries = []
-
-  for (const [path, { route }] of routesByPath) {
-    if (!route) continue
-
-    // Collect all parent layers that match the route's groups
-    const allLayers = []
-    let currentPath = path
-
-    while (true) {
-      const pathData = routesByPath.get(currentPath)
-      if (pathData?.layers) {
-        const matchingLayers = pathData.layers.filter((layer) => layerMatchesRoute(layer, route))
-        allLayers.unshift(...matchingLayers)
-      }
-
-      if (currentPath === "/") break
-
-      const parentPath = currentPath.substring(0, currentPath.lastIndexOf("/"))
-      currentPath = parentPath || "/"
-    }
-
-    // Convert file-style path to colon-style PathPattern
-    const pathPatternResult = FilePathPattern.toPathPattern(path)
-    if (Either.isLeft(pathPatternResult)) {
-      continue
-    }
-    const pathPattern = pathPatternResult.right
-
-    // Order: route first, then layers from innermost to outermost
-    const loaders = [
-      `() => import(".${route.modulePath}")`,
-      ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
-    ]
-
-    entries.push({ path: pathPattern, loaders })
-  }
-
-  // No routes found - don't create file
-  if (entries.length === 0) {
-    return null
-  }
-
-  const routeEntries = entries
-    .map(({ path, loaders }) => {
-      const loadersCode = loaders.join(",\n    ")
-      return `  "${path}": [\n    ${loadersCode},\n  ]`
-    })
-    .join(",\n")
-
-  return `/**
- * Auto-generated by effect-start.
- */
-
-export default {
-${routeEntries},
-} satisfies import("effect-start/FileRouter").FileRoutes
-`
-}
-
-/**
- * Updates the tree file only if the generated content differs from the existing file.
- * This prevents infinite loops when watching for file changes.
- */
-export function update(
-  routesPath,
-  treePath = "server.gen.ts",
-) {
-  return Effect.gen(function* () {
-    treePath = NPath.resolve(routesPath, treePath)
-
-    const fs = yield* FileSystem.FileSystem
-    const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
-      Effect.mapError(
-        (cause) =>
-          new FileRouter.FileRouterError({
-            reason: "FileSystem",
-            cause,
-            path: routesPath,
-          }),
-      ),
-    )
-    const fileRoutes = yield* FileRouter.getFileRoutes(files)
-
-    // Validate route modules
-    yield* validateRouteModules(routesPath, fileRoutes)
-
-    const newCode = generateCode(fileRoutes)
-
-    // Check if file exists (ok to fail - means file doesn't exist)
-    const existingCode = yield* fs
-      .readFileString(treePath)
-      .pipe(Effect.catchAll(() => Effect.succeed(null)))
-
-    // No routes found
-    if (newCode === null) {
-      // If gen file exists, write empty export
-      if (existingCode !== null) {
-        const emptyCode = "export default {}\n"
-        if (existingCode !== emptyCode) {
-          yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`)
-          yield* fs.writeFileString(treePath, emptyCode).pipe(
-            Effect.mapError(
-              (cause) =>
-                new FileRouter.FileRouterError({
-                  reason: "FileSystem",
-                  cause,
-                  path: treePath,
-                }),
-            ),
-          )
-        }
-      }
-      return
-    }
-
-    // Write if content differs
-    if (existingCode !== newCode) {
-      yield* Effect.logDebug(`Updating file routes tree: ${treePath}`)
-      yield* fs.writeFileString(treePath, newCode).pipe(
-        Effect.mapError(
-          (cause) =>
-            new FileRouter.FileRouterError({
-              reason: "FileSystem",
-              cause,
-              path: treePath,
-            }),
-        ),
-      )
-    } else {
-      yield* Effect.logDebug(`File routes tree unchanged: ${treePath}`)
-    }
-  })
-}
-
-export function dump(
-  routesPath,
-  treePath = "server.gen.ts",
-) {
-  return Effect.gen(function* () {
-    treePath = NPath.resolve(routesPath, treePath)
-
-    const fs = yield* FileSystem.FileSystem
-    const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
-      Effect.mapError(
-        (cause) =>
-          new FileRouter.FileRouterError({
-            reason: "FileSystem",
-            cause,
-            path: routesPath,
-          }),
-      ),
-    )
-    const fileRoutes = yield* FileRouter.getFileRoutes(files)
-
-    // Validate route modules
-    yield* validateRouteModules(routesPath, fileRoutes)
-
-    const code = generateCode(fileRoutes)
-
-    // No routes found - don't create file
-    if (code === null) {
-      yield* Effect.logDebug(`No routes found, skipping: ${treePath}`)
-      return
-    }
-
-    yield* Effect.logDebug(`Generating file routes tree: ${treePath}`)
-
-    yield* fs.writeFileString(treePath, code).pipe(
-      Effect.mapError(
-        (cause) =>
-          new FileRouter.FileRouterError({
-            reason: "FileSystem",
-            cause,
-            path: treePath,
-          }),
-      ),
-    )
-  })
-}

package/dist/FileSystem.js

@@ -1,132 +0,0 @@
-/*
- * Adapted from @effect/platform
- */
-import * as Brand from "effect/Brand"
-import * as Channel from "effect/Channel"
-import * as Chunk from "effect/Chunk"
-import * as Context from "effect/Context"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as Option from "effect/Option"
-import * as Sink from "effect/Sink"
-import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.js"
-
-export const FileSystem = Context.GenericTag(
-  "@effect/platform/FileSystem",
-)
-
-export const Size = (bytes) =>
-  typeof bytes === "bigint" ? (bytes) : (BigInt(bytes))
-
-export const FileTypeId = Symbol.for("@effect/platform/FileSystem/File")
-
-export const FileDescriptor = Brand.nominal()
-
-export const WatchEventCreate =
-  Data.tagged("Create")
-
-export const WatchEventUpdate =
-  Data.tagged("Update")
-
-export const WatchEventRemove =
-  Data.tagged("Remove")
-
-export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")() {}
-
-export const make = (
-  impl,
-) => {
-  return FileSystem.of({
-    ...impl,
-    exists: (path) =>
-      Function.pipe(
-        impl.access(path),
-        Effect.as(true),
-        Effect.catchTag("SystemError", (e) =>
-          e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e),
-        ),
-      ),
-    readFileString: (path, encoding) =>
-      Effect.tryMap(impl.readFile(path), {
-        try: (_) => new TextDecoder(encoding).decode(_),
-        catch: (cause) =>
-          new PlatformError.BadArgument({
-            module: "FileSystem",
-            method: "readFileString",
-            description: "invalid encoding",
-            cause,
-          }),
-      }),
-    stream: (path, options) =>
-      Function.pipe(
-        impl.open(path, { flag: "r" }),
-        options?.offset
-          ? Effect.tap((file) => file.seek(options.offset, "start"))
-          : Function.identity,
-        Effect.map((file) => fileStream(file, options)),
-        Stream.unwrapScoped,
-      ),
-    sink: (path, options) =>
-      Function.pipe(
-        impl.open(path, { flag: "w", ...options }),
-        Effect.map((file) => Sink.forEach((_) => file.writeAll(_))),
-        Sink.unwrapScoped,
-      ),
-    writeFileString: (path, data, options) =>
-      Effect.flatMap(
-        Effect.try({
-          try: () => new TextEncoder().encode(data),
-          catch: (cause) =>
-            new PlatformError.BadArgument({
-              module: "FileSystem",
-              method: "writeFileString",
-              description: "could not encode string",
-              cause,
-            }),
-        }),
-        (_) => impl.writeFile(path, _, options),
-      ),
-  })
-}
-
-const fileStream = (
-  file,
-  {
-    bufferSize = 16,
-    bytesToRead: bytesToRead_,
-    chunkSize: chunkSize_ = Size(64 * 1024),
-  } = {},
-) => {
-  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
-  const chunkSize = Size(chunkSize_)
-
-  function loop(
-    totalBytesRead,
-  ) {
-    if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
-      return Channel.void
-    }
-
-    const toRead =
-      bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize
-        ? bytesToRead - totalBytesRead
-        : chunkSize
-
-    return Channel.flatMap(
-      file.readAlloc(toRead),
-      Option.match({
-        onNone: () => Channel.void,
-        onSome: (buf) =>
-          Channel.flatMap(Channel.write(Chunk.of(buf)), () =>
-            loop(totalBytesRead + BigInt(buf.length)),
-          ),
-      }),
-    )
-  }
-
-  return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
-    capacity: bufferSize,
-  })
-}