effect-start 0.20.1 → 0.22.0

package/src/Entity.ts

@@ -24,10 +24,7 @@ export type Headers = {
   [header: string]: string | null | undefined
 }
 
-export interface Entity<
-  T = unknown,
-  E = never,
-> extends Pipeable.Pipeable {
+export interface Entity<T = unknown, E = never> extends Pipeable.Pipeable {
   readonly [TypeId]: TypeId
   readonly body: T
   readonly headers: Headers
@@ -39,18 +36,21 @@ export interface Entity<
    */
   readonly url: string | undefined
   readonly status: number | undefined
-  readonly text: T extends string ? Effect.Effect<T, ParseResult.ParseError | E>
+  readonly text: T extends string
+    ? Effect.Effect<T, ParseResult.ParseError | E>
     : Effect.Effect<string, ParseResult.ParseError | E>
-  readonly json: [T] extends [Effect.Effect<infer A, any, any>] ? Effect.Effect<
-      A extends string | Uint8Array | ArrayBuffer ? unknown : A,
-      ParseResult.ParseError | E
-    >
+  readonly json: [T] extends [Effect.Effect<infer A, any, any>]
+    ? Effect.Effect<
+        A extends string | Uint8Array | ArrayBuffer ? unknown : A,
+        ParseResult.ParseError | E
+      >
     : [T] extends [Stream.Stream<any, any, any>]
       ? Effect.Effect<unknown, ParseResult.ParseError | E>
-    : [T] extends [string | Uint8Array | ArrayBuffer]
-      ? Effect.Effect<unknown, ParseResult.ParseError | E>
-    : [T] extends [Values.Json] ? Effect.Effect<T, ParseResult.ParseError | E>
-    : Effect.Effect<unknown, ParseResult.ParseError | E>
+      : [T] extends [string | Uint8Array | ArrayBuffer]
+        ? Effect.Effect<unknown, ParseResult.ParseError | E>
+        : [T] extends [Values.Json]
+          ? Effect.Effect<T, ParseResult.ParseError | E>
+          : Effect.Effect<unknown, ParseResult.ParseError | E>
   readonly bytes: Effect.Effect<Uint8Array, ParseResult.ParseError | E>
   readonly stream: T extends Stream.Stream<infer A, infer E1, any>
     ? Stream.Stream<A, ParseResult.ParseError | E | E1>
@@ -82,9 +82,7 @@ function getText(
 ): Effect.Effect<string, ParseResult.ParseError | unknown> {
   const v = self.body
   if (StreamExtra.isStream(v)) {
-    return Stream.mkString(
-      Stream.decodeText(v as Stream.Stream<Uint8Array, unknown, never>),
-    )
+    return Stream.mkString(Stream.decodeText(v as Stream.Stream<Uint8Array, unknown, never>))
   }
   if (Effect.isEffect(v)) {
     return Effect.flatMap(
@@ -201,63 +199,53 @@ function getBytes(
 function getStream<A, E1, E2>(
   self: Entity<Stream.Stream<A, E1, never>, E2>,
 ): Stream.Stream<A, ParseResult.ParseError | E1 | E2>
-function getStream<T, E>(
-  self: Entity<T, E>,
-): Stream.Stream<Uint8Array, ParseResult.ParseError | E>
-function getStream(
-  self: Entity<unknown, unknown>,
-): Stream.Stream<unknown, unknown> {
+function getStream<T, E>(self: Entity<T, E>): Stream.Stream<Uint8Array, ParseResult.ParseError | E>
+function getStream(self: Entity<unknown, unknown>): Stream.Stream<unknown, unknown> {
   const v = self.body
   if (StreamExtra.isStream(v)) {
     return v as Stream.Stream<unknown, unknown, never>
   }
   if (Effect.isEffect(v)) {
     return Stream.unwrap(
-      Effect.map(
-        v as Effect.Effect<unknown, unknown, never>,
-        (inner) => {
-          if (isEntity(inner)) {
-            return inner.stream
-          }
-          return Stream.fromEffect(getBytes(make(inner)))
-        },
-      ),
+      Effect.map(v as Effect.Effect<unknown, unknown, never>, (inner) => {
+        if (isEntity(inner)) {
+          return inner.stream
+        }
+        return Stream.fromEffect(getBytes(make(inner)))
+      }),
     )
   }
   return Stream.fromEffect(getBytes(self))
 }
 
-const Proto: Proto = Object.defineProperties(
-  Object.create(null),
-  {
-    [TypeId]: { value: TypeId },
-    pipe: {
-      value: function(this: Entity) {
-        return Pipeable.pipeArguments(this, arguments)
-      },
+const Proto: Proto = Object.defineProperties(Object.create(null), {
+  [TypeId]: { value: TypeId },
+  pipe: {
+    value: function (this: Entity) {
+      return Pipeable.pipeArguments(this, arguments)
     },
-    text: {
-      get(this: Entity<unknown, unknown>) {
-        return getText(this)
-      },
+  },
+  text: {
+    get(this: Entity<unknown, unknown>) {
+      return getText(this)
     },
-    json: {
-      get(this: Entity<unknown, unknown>) {
-        return getJson(this)
-      },
+  },
+  json: {
+    get(this: Entity<unknown, unknown>) {
+      return getJson(this)
     },
-    bytes: {
-      get(this: Entity<unknown, unknown>) {
-        return getBytes(this)
-      },
+  },
+  bytes: {
+    get(this: Entity<unknown, unknown>) {
+      return getBytes(this)
     },
-    stream: {
-      get(this: Entity<unknown, unknown>) {
-        return getStream(this)
-      },
+  },
+  stream: {
+    get(this: Entity<unknown, unknown>) {
+      return getStream(this)
     },
   },
-)
+})
 
 export function isEntity(input: unknown): input is Entity {
   return Predicate.hasProperty(input, TypeId)
@@ -278,42 +266,30 @@ export function make<A extends Uint8Array | string, E>(
   options?: Options,
 ): Entity<Stream.Stream<A, E, never>, E>
 export function make<T>(body: T, options?: Options): Entity<T, never>
-export function make(
-  body: unknown,
-  options?: Options,
-): Entity<unknown, unknown> {
-  return Object.assign(
-    Object.create(Proto),
-    {
-      body,
-      headers: options?.headers ?? {},
-      url: options?.url,
-      status: options?.status,
-    },
-  )
+export function make(body: unknown, options?: Options): Entity<unknown, unknown> {
+  return Object.assign(Object.create(Proto), {
+    body,
+    headers: options?.headers ?? {},
+    url: options?.url,
+    status: options?.status,
+  })
 }
 
-export function effect<A, E, R>(
-  body: Effect.Effect<Entity<A> | A, E, R>,
-): Entity<A, E> {
+export function effect<A, E, R>(body: Effect.Effect<Entity<A> | A, E, R>): Entity<A, E> {
   return make(body) as unknown as Entity<A, E>
 }
 
-export function resolve<A, E>(
-  entity: Entity<A, E>,
-): Effect.Effect<Entity<A, E>, E, never> {
+export function resolve<A, E>(entity: Entity<A, E>): Effect.Effect<Entity<A, E>, E, never> {
   const body = entity.body
   if (Effect.isEffect(body)) {
-    return Effect.map(
-      body as Effect.Effect<Entity<A> | A, E, never>,
-      (inner) =>
-        isEntity(inner)
-          ? inner as Entity<A, E>
-          : make(inner as A, {
+    return Effect.map(body as Effect.Effect<Entity<A> | A, E, never>, (inner) =>
+      isEntity(inner)
+        ? (inner as Entity<A, E>)
+        : (make(inner as A, {
             status: entity.status,
             headers: entity.headers,
             url: entity.url,
-          }) as Entity<A, E>,
+          }) as Entity<A, E>),
     )
   }
   return Effect.succeed(entity)
@@ -349,10 +325,7 @@ export function length(self: Entity): number | undefined {
   return undefined
 }
 
-function mismatch(
-  expected: Schema.Schema.Any,
-  actual: unknown,
-): ParseResult.ParseError {
+function mismatch(expected: Schema.Schema.Any, actual: unknown): ParseResult.ParseError {
   return new ParseResult.ParseError({
     issue: new ParseResult.Type(expected.ast, actual),
   })

package/src/FilePathPattern.ts

@@ -10,9 +10,9 @@ export type Segment =
   | { _tag: "LiteralSegment"; value: string }
   | { _tag: "InvalidSegment"; value: string }
 
-export function segments(pattern: string): Segment[] {
+export function segments(pattern: string): Array<Segment> {
   const parts = pattern.split("/").filter(Boolean)
-  const result: Segment[] = []
+  const result: Array<Segment> = []
 
   for (const part of parts) {
     if (/^\(\w+\)$/.test(part)) {
@@ -37,7 +37,7 @@ export type ValidationError = {
   message: string
 }
 
-export type ValidationResult = Either.Either<Segment[], ValidationError>
+export type ValidationResult = Either.Either<Array<Segment>, ValidationError>
 
 export function validate(pattern: string): ValidationResult {
   const segs = segments(pattern)
@@ -63,7 +63,7 @@ export function validate(pattern: string): ValidationResult {
   return Either.right(segs)
 }
 
-export function format(segs: Segment[]): `/${string}` {
+export function format(segs: Array<Segment>): `/${string}` {
   const parts = segs.map((seg) => {
     switch (seg._tag) {
       case "GroupSegment":
@@ -92,7 +92,7 @@ export function toPathPattern(
   }
 
   const segs = result.right
-  const pathParts: string[] = []
+  const pathParts: Array<string> = []
 
   for (const seg of segs) {
     switch (seg._tag) {

package/src/FileRouter.ts

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem"
+import * as FileSystem from "./FileSystem.ts"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
@@ -17,10 +17,7 @@ import * as Route from "./Route.ts"
 import * as RouteTree from "./RouteTree.ts"
 
 export class FileRouterError extends Data.TaggedError("FileRouterError")<{
-  reason:
-    | "Import"
-    | "Conflict"
-    | "FileSystem"
+  reason: "Import" | "Conflict" | "FileSystem"
   cause?: unknown
   path?: string
 }> {}
@@ -32,23 +29,18 @@ export type RouteModule = {
 export type LazyRouteModule = () => Promise<RouteModule>
 
 export type FileRoutes = {
-  [path: PathPattern.PathPattern]: [
-    LazyRouteModule,
-    ...LazyRouteModule[],
-  ]
+  [path: PathPattern.PathPattern]: [LazyRouteModule, ...LazyRouteModule[]]
 }
 
 export type Segment = FilePathPattern.Segment
 
 export type FileRoute = {
-  handle:
-    | "route"
-    | "layer"
+  handle: "route" | "layer"
   // eg. `/about/route.tsx`, `/users/[userId]/route.tsx`, `/(admin)/users/route.tsx`
   modulePath: `/${string}`
   // eg. `/about`, `/users/[userId]`, `/users` (groups stripped)
   routePath: `/${string}`
-  segments: Segment[]
+  segments: Array<Segment>
 }
 
 /**
@@ -58,19 +50,17 @@ export type FileRoute = {
  * - users/[userId]/route.tsx
  * - [[rest]]/route.tsx
  */
-export type OrderedFileRoutes = FileRoute[]
+export type OrderedFileRoutes = Array<FileRoute>
 
 const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/
 
-export function parseRoute(
-  path: string,
-): FileRoute | null {
+export function parseRoute(path: string): FileRoute | null {
   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] as "route" | "layer" : null
+  const handleMatch =
+    lastSeg?._tag === "LiteralSegment" && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/)
+  const handle = handleMatch ? (handleMatch[1] as "route" | "layer") : null
 
   if (!handle) {
     return null
@@ -78,9 +68,7 @@ export function parseRoute(
 
   const pathSegments = segs.slice(0, -1)
 
-  const validated = FilePathPattern.validate(
-    FilePathPattern.format(pathSegments),
-  )
+  const validated = FilePathPattern.validate(FilePathPattern.format(pathSegments))
   if (Either.isLeft(validated)) {
     return null
   }
@@ -90,9 +78,7 @@ export function parseRoute(
     return null
   }
 
-  const routePathSegments = pathSegments.filter(
-    (seg) => seg._tag !== "GroupSegment",
-  )
+  const routePathSegments = pathSegments.filter((seg) => seg._tag !== "GroupSegment")
   const routePath = FilePathPattern.format(routePathSegments)
 
   return {
@@ -103,9 +89,7 @@ export function parseRoute(
   }
 }
 
-function importModule<T>(
-  load: () => Promise<T>,
-): Effect.Effect<T, FileRouterError> {
+function importModule<T>(load: () => Promise<T>): Effect.Effect<T, FileRouterError> {
   return Effect.tryPromise({
     try: () => load(),
     catch: (cause) => new FileRouterError({ reason: "Import", cause }),
@@ -127,12 +111,13 @@ export function layer(
     | (() => Promise<{ default: FileRoutes }>)
     | { load: () => Promise<{ default: FileRoutes }>; path: string },
 ) {
-  const options = typeof loadOrOptions === "function"
-    ? {
-      load: loadOrOptions,
-      path: NPath.join(NodeUtils.getEntrypoint(), "routes"),
-    }
-    : 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)
@@ -147,7 +132,7 @@ export function layer(
 
   return Layer.scoped(
     Route.Routes,
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       // Generate routes file before loading
       yield* FileRouterCodegen.update(routesPath, treeFilename)
 
@@ -158,12 +143,8 @@ export function layer(
       // 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)
-        ),
+        Stream.filter((e) => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)),
+        Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)),
         Effect.fork,
       )
 
@@ -172,25 +153,19 @@ export function layer(
   )
 }
 
-export function fromFileRoutes(
-  fileRoutes: FileRoutes,
-): Effect.Effect<RouteTree.RouteTree> {
-  return Effect.gen(function*() {
+export function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.RouteTree> {
+  return Effect.gen(function* () {
     const mounts: RouteTree.InputRouteMap = {}
 
     for (const [path, loaders] of Object.entries(fileRoutes)) {
-      const modules = yield* Effect.forEach(
-        loaders,
-        (loader) => Effect.promise(() => loader()),
-      )
+      const modules = yield* Effect.forEach(loaders, (loader) => Effect.promise(() => loader()))
 
-      const allRoutes: RouteTree.RouteTuple =
-        [] as unknown as RouteTree.RouteTuple
+      const allRoutes: RouteTree.RouteTuple = [] as unknown as RouteTree.RouteTuple
 
       for (const m of modules) {
         if (Route.isRouteSet(m.default)) {
           for (const route of m.default) {
-            ;(allRoutes as any[]).push(route)
+            ;(allRoutes as Array<any>).push(route)
           }
         }
       }
@@ -209,7 +184,7 @@ export function walkRoutesDirectory(
   PlatformError.PlatformError | FileRouterError,
   FileSystem.FileSystem
 > {
-  return Effect.gen(function*() {
+  return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem
     const files = yield* fs.readDirectory(dir, { recursive: true })
 
@@ -218,13 +193,13 @@ export function walkRoutesDirectory(
 }
 
 export function getFileRoutes(
-  paths: string[],
+  paths: Array<string>,
 ): Effect.Effect<OrderedFileRoutes, FileRouterError> {
-  return Effect.gen(function*() {
+  return Effect.gen(function* () {
     const routes = paths
-      .map(f => f.match(ROUTE_PATH_REGEX))
+      .map((f) => f.match(ROUTE_PATH_REGEX))
       .filter(Boolean)
-      .map(v => {
+      .map((v) => {
         const path = v![0]
         try {
           return parseRoute(path)
@@ -241,16 +216,16 @@ export function getFileRoutes(
 
         return (
           // rest is a dominant factor (routes with rest come last)
-          (+aHasRest - +bHasRest) * 1000
+          (+aHasRest - +bHasRest) * 1000 +
           // depth is reversed for rest
-          + (aDepth - bDepth) * (1 - 2 * +aHasRest)
+          (aDepth - bDepth) * (1 - 2 * +aHasRest) +
           // lexicographic comparison as tiebreaker
-          + a.modulePath.localeCompare(b.modulePath) * 0.001
+          a.modulePath.localeCompare(b.modulePath) * 0.001
         )
       })
 
     // Detect conflicting routes at the same path
-    const routesByPath = new Map<string, FileRoute[]>()
+    const routesByPath = new Map<string, Array<FileRoute>>()
     for (const route of routes) {
       const existing = routesByPath.get(route.routePath) || []
       existing.push(route)
@@ -258,7 +233,7 @@ export function getFileRoutes(
     }
 
     for (const [path, pathRoutes] of routesByPath) {
-      const routeHandles = pathRoutes.filter(h => h.handle === "route")
+      const routeHandles = pathRoutes.filter((h) => h.handle === "route")
 
       if (routeHandles.length > 1) {
         yield* new FileRouterError({ reason: "Conflict", path })