effect-start 0.11.1 → 0.12.0

package/src/FileRouterCodegen.ts

@@ -1,13 +1,18 @@
 import type { PlatformError } from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
 import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Schema from "effect/Schema"
 import * as NPath from "node:path"
 import * as FileRouter from "./FileRouter.ts"
+import * as FileRouterPattern from "./FileRouterPattern.ts"
 import * as Route from "./Route.ts"
+import * as Router from "./Router.ts"
+import * as SchemaExtra from "./SchemaExtra.ts"
 
 export function validateRouteModule(
   module: unknown,
-): boolean {
+): module is FileRouter.RouteModule {
   if (typeof module !== "object" || module === null) {
     return false
   }
@@ -17,37 +22,77 @@ export function validateRouteModule(
   return Route.isRouteSet(module.default)
 }
 
+export function generatePathParamsSchema(
+  segments: ReadonlyArray<FileRouterPattern.Segment>,
+): Schema.Struct<any> | null {
+  const fields: Record<
+    PropertyKey,
+    Schema.Schema.Any | Schema.PropertySignature.All
+  > = {}
+
+  for (const segment of segments) {
+    if (
+      segment._tag === "ParamSegment"
+      || segment._tag === "RestSegment"
+    ) {
+      fields[segment.name] = segment.optional
+        ? Function.pipe(Schema.String, 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(
   routesPath: string,
   handles: FileRouter.OrderedRouteHandles,
-): Effect.Effect<void, never, never> {
+): Effect.Effect<void, PlatformError, FileSystem.FileSystem> {
   return Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
     const routeHandles = handles.filter(h => h.handle === "route")
 
     for (const handle of routeHandles) {
       const routeModulePath = NPath.resolve(routesPath, handle.modulePath)
-      yield* Effect
-        .tryPromise({
-          try: async () => import(routeModulePath),
-          catch: (error) =>
-            Effect.logWarning(
-              `Failed to validate route module ${routeModulePath}: ${error}`,
-            ),
-        })
-        .pipe(
-          Effect.catchAll((logEffect) => logEffect),
-          Effect.tap((module) => {
-            if (!validateRouteModule(module)) {
-              return Effect.logWarning(
-                `Route module ${routeModulePath} should export default Route`,
-              )
-            }
-            return Effect.void
-          }),
+      const expectedSchema = generatePathParamsSchema(handle.segments)
+
+      const fileExists = yield* fs.exists(routeModulePath)
+      if (!fileExists) {
+        continue
+      }
+
+      const module = yield* Effect.promise(() => import(routeModulePath))
+
+      if (!validateRouteModule(module)) {
+        yield* Effect.logWarning(
+          `Route module ${routeModulePath} should export default Route`,
         )
+        continue
+      }
+
+      const routeSet = module.default
+      const userSchema = routeSet.schema?.PathParams
+
+      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)
+          })`,
+        )
+      }
     }
   })
 }
@@ -154,7 +199,7 @@ export const routes = ${routesArray} as const
  */
 export function update(
   routesPath: string,
-  manifestPath = "_manifest.ts",
+  manifestPath = "manifest.ts",
 ): Effect.Effect<void, PlatformError, FileSystem.FileSystem> {
   return Effect.gen(function*() {
     manifestPath = NPath.resolve(routesPath, manifestPath)
@@ -184,7 +229,7 @@ export function update(
 
 export function dump(
   routesPath: string,
-  manifestPath = "_manifest.ts",
+  manifestPath = "manifest.ts",
 ): Effect.Effect<void, PlatformError, FileSystem.FileSystem> {
   return Effect.gen(function*() {
     manifestPath = NPath.resolve(routesPath, manifestPath)

package/src/Route.ts

@@ -48,8 +48,7 @@ type Self =
    */
   | RouteModule
   /**
-   * Called directly from exported function.
-   * Disencouraged but possible.
+   * Called directly from exported function. Don't do it.
    *
    * @example
    * ```ts

package/src/Router.test.ts

@@ -264,11 +264,11 @@ t.describe("Router", () => {
     t.test("infers never for routes without requirements", () => {
       const router = Router.mount("/hello", Route.text("Hello"))
 
-      type RouterError = Router.RouterBuilder.Error<typeof router>
-      type RouterContext = Router.RouterBuilder.Context<typeof router>
+      type RouterError = Router.Router.Error<typeof router>
+      type RouterRequirements = Router.Router.Requirements<typeof router>
 
       const _checkError: RouterError = undefined as never
-      const _checkContext: RouterContext = undefined as never
+      const _checkRequirements: RouterRequirements = undefined as never
 
       t.expect(true).toBe(true)
     })
@@ -283,7 +283,7 @@ t.describe("Router", () => {
         Route.text(Effect.fail(new MyError())),
       )
 
-      type RouterError = Router.RouterBuilder.Error<typeof router>
+      type RouterError = Router.Router.Error<typeof router>
 
       const _checkError: MyError extends RouterError ? true : false = true
 
@@ -306,9 +306,10 @@ t.describe("Router", () => {
         ),
       )
 
-      type RouterContext = Router.RouterBuilder.Context<typeof router>
+      type RouterRequirements = Router.Router.Requirements<typeof router>
 
-      const _checkContext: MyService extends RouterContext ? true : false = true
+      const _checkRequirements: MyService extends RouterRequirements ? true
+        : false = true
 
       t.expect(true).toBe(true)
     })
@@ -325,7 +326,7 @@ t.describe("Router", () => {
         .mount("/a", Route.text(Effect.fail(new ErrorA())))
         .mount("/b", Route.text(Effect.fail(new ErrorB())))
 
-      type RouterError = Router.RouterBuilder.Error<typeof router>
+      type RouterError = Router.Router.Error<typeof router>
 
       const _checkA: ErrorA extends RouterError ? true : false = true
       const _checkB: ErrorB extends RouterError ? true : false = true
@@ -363,54 +364,12 @@ t.describe("Router", () => {
           ),
         )
 
-      type RouterContext = Router.RouterBuilder.Context<typeof router>
+      type RouterRequirements = Router.Router.Requirements<typeof router>
 
-      const _checkA: ServiceA extends RouterContext ? true : false = true
-      const _checkB: ServiceB extends RouterContext ? true : false = true
+      const _checkA: ServiceA extends RouterRequirements ? true : false = true
+      const _checkB: ServiceB extends RouterRequirements ? true : false = true
 
       t.expect(true).toBe(true)
     })
   })
-
-  t.describe("fromManifest", () => {
-    t.test("loads routes from manifest", async () => {
-      const manifest: Router.RouterManifest = {
-        routes: [
-          {
-            path: "/test",
-            load: () => Promise.resolve({ default: Route.text("Test") }),
-          },
-        ],
-      }
-
-      const router = await Effect.runPromise(Router.fromManifest(manifest))
-
-      t.expect(router.entries).toHaveLength(1)
-      t.expect(router.entries[0].path).toBe("/test")
-    })
-
-    t.test("loads layers from manifest", async () => {
-      const layer = Route.layer(
-        Route.html(function*(c) {
-          const inner = yield* c.next()
-          return `<wrap>${inner}</wrap>`
-        }),
-      )
-
-      const manifest: Router.RouterManifest = {
-        routes: [
-          {
-            path: "/test",
-            load: () => Promise.resolve({ default: Route.text("Test") }),
-            layers: [() => Promise.resolve({ default: layer })],
-          },
-        ],
-      }
-
-      const router = await Effect.runPromise(Router.fromManifest(manifest))
-
-      t.expect(router.entries).toHaveLength(1)
-      t.expect(router.entries[0].layers).toHaveLength(1)
-    })
-  })
 })

package/src/Router.ts

@@ -1,12 +1,14 @@
-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 Layer from "effect/Layer"
 import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
-import * as FileRouter from "./FileRouter.ts"
-import * as Route from "./Route"
+import * as Route from "./Route.ts"
+
+type RouterModule = typeof import("./Router.ts")
+
+type Self =
+  | Router.Any
+  | RouterModule
+  | undefined
 
 export type RouterErrorReason =
   | "UnsupportedPattern"
@@ -18,85 +20,26 @@ export class RouterError extends Data.TaggedError("RouterError")<{
   message: string
 }> {}
 
-export type ServerModule = {
-  default: Route.RouteSet.Default
-}
-
-export type LazyRoute = {
-  path: `/${string}`
-  load: () => Promise<ServerModule>
-  layers?: ReadonlyArray<() => Promise<unknown>>
-}
-
-export type RouterManifest = {
-  routes: readonly LazyRoute[]
-  layers?: any[]
-}
-
-export type RouterContext = RouterManifest
-
-export class Router extends Context.Tag("effect-start/Router")<
-  Router,
-  RouterContext
->() {}
-
-export function layer(
-  manifest: RouterManifest,
-): Layer.Layer<Router, never, never> {
-  return Layer.effect(
-    Router,
-    Effect.gen(function*() {
-      return {
-        ...manifest,
-      }
-    }),
-  )
-}
-
-export const layerFiles = FileRouter.layer
-
-export function layerPromise(
-  load: () => Promise<RouterManifest>,
-): Layer.Layer<Router, never, never> {
-  return Layer.unwrapEffect(
-    Effect.gen(function*() {
-      const importedModule = yield* Function.pipe(
-        Effect.promise(() => load()),
-        Effect.orDie,
-      )
-
-      return layer(importedModule)
-    }),
-  )
-}
-
-const RouterBuilderTypeId: unique symbol = Symbol.for(
-  "effect-start/RouterBuilder",
+const TypeId: unique symbol = Symbol.for(
+  "effect-start/Router",
 )
 
-type RouterModule = typeof import("./Router.ts")
-
-type Self =
-  | RouterBuilder<any, any>
-  | RouterModule
-  | undefined
-
 export type RouterEntry = {
   path: `/${string}`
   route: Route.RouteSet.Default
   layers: Route.RouteLayer[]
 }
 
-type RouterBuilderMethods = {
+type Methods = {
   use: typeof use
   mount: typeof mount
 }
 
-export interface RouterBuilder<
+export interface Router<
   out E = never,
   out R = never,
-> extends Pipeable.Pipeable, RouterBuilderMethods {
-  [RouterBuilderTypeId]: typeof RouterBuilderTypeId
+> extends Pipeable.Pipeable, Methods {
+  [TypeId]: typeof TypeId
   readonly entries: readonly RouterEntry[]
   readonly globalLayers: readonly Route.RouteLayer[]
   readonly mounts: Record<`/${string}`, Route.RouteSet.Default>
@@ -104,18 +47,17 @@ export interface RouterBuilder<
   readonly _R: () => R
 }
 
-export namespace RouterBuilder {
-  export type Any = RouterBuilder<any, any>
-
-  export type Error<T> = T extends RouterBuilder<infer E, any> ? E : never
-  export type Context<T> = T extends RouterBuilder<any, infer R> ? R : never
+export namespace Router {
+  export type Any = Router<any, any>
+  export type Error<T> = T extends Router<infer E, any> ? E : never
+  export type Requirements<T> = T extends Router<any, infer R> ? R : never
 }
 
-const RouterBuilderProto: RouterBuilderMethods & {
-  [RouterBuilderTypeId]: typeof RouterBuilderTypeId
+const Proto: Methods & {
+  [TypeId]: typeof TypeId
   pipe: Pipeable.Pipeable["pipe"]
 } = {
-  [RouterBuilderTypeId]: RouterBuilderTypeId,
+  [TypeId]: TypeId,
 
   pipe() {
     return Pipeable.pipeArguments(this, arguments)
@@ -143,17 +85,17 @@ function addRoute<
   RouteE,
   RouteR,
 >(
-  builder: RouterBuilder<E, R>,
+  builder: Router<E, R>,
   path: `/${string}`,
   route: Route.RouteSet.Default,
-): RouterBuilder<E | RouteE, R | RouteR> {
+): Router<E | RouteE, R | RouteR> {
   const existingEntry = builder.entries.find((e) => e.path === path)
   if (existingEntry) {
     const updatedEntry: RouterEntry = {
       ...existingEntry,
       route: Route.merge(existingEntry.route, route),
     }
-    return makeBuilder(
+    return make(
       builder.entries.map((e) => (e.path === path ? updatedEntry : e)),
       builder.globalLayers,
     )
@@ -165,18 +107,17 @@ function addRoute<
     layers: [...builder.globalLayers],
   }
 
-  return makeBuilder([...builder.entries, newEntry], builder.globalLayers)
+  return make([...builder.entries, newEntry], builder.globalLayers)
 }
 
 function addGlobalLayer<E, R>(
-  builder: RouterBuilder<E, R>,
+  builder: Router<E, R>,
   layerRoute: Route.RouteLayer,
-): RouterBuilder<E, R> {
+): Router<E, R> {
   const newGlobalLayers = [...builder.globalLayers, layerRoute]
-  return makeBuilder(builder.entries, newGlobalLayers)
+  return make(builder.entries, newGlobalLayers)
 }
 
-
 function findMatchingLayerRoutes(
   route: Route.Route.Default,
   layers: readonly Route.RouteLayer[],
@@ -244,10 +185,10 @@ function applyLayersToRouteSet(
   } as unknown as Route.RouteSet.Default
 }
 
-function makeBuilder<E, R>(
+export function make<E, R>(
   entries: readonly RouterEntry[],
   globalLayers: readonly Route.RouteLayer[] = [],
-): RouterBuilder<E, R> {
+): Router<E, R> {
   const mounts: Record<`/${string}`, Route.RouteSet.Default> = {}
 
   for (const entry of entries) {
@@ -256,15 +197,18 @@ function makeBuilder<E, R>(
     }
   }
 
-  return Object.assign(Object.create(RouterBuilderProto), {
-    entries,
-    globalLayers,
-    mounts,
-  })
+  return Object.assign(
+    Object.create(Proto),
+    {
+      entries,
+      globalLayers,
+      mounts,
+    },
+  )
 }
 
-export function isRouterBuilder(input: unknown): input is RouterBuilder.Any {
-  return Predicate.hasProperty(input, RouterBuilderTypeId)
+export function isRouter(input: unknown): input is Router.Any {
+  return Predicate.hasProperty(input, TypeId)
 }
 
 export function use<
@@ -272,13 +216,14 @@ export function use<
 >(
   this: S,
   layerRoute: Route.RouteLayer,
-): S extends RouterBuilder<infer E, infer R> ? RouterBuilder<E, R>
-  : RouterBuilder<never, never>
+): S extends Router<infer E, infer R> ? Router<E, R>
+  : Router<never, never>
 {
-  const builder = isRouterBuilder(this)
+  const router = isRouter(this)
     ? this
-    : makeBuilder<never, never>([], [])
-  return addGlobalLayer(builder, layerRoute) as any
+    : make<never, never>([], [])
+
+  return addGlobalLayer(router, layerRoute) as any
 }
 
 export function mount<
@@ -289,49 +234,22 @@ export function mount<
   this: S,
   path: `/${string}`,
   route: Route.RouteSet<Routes, Schemas>,
-): S extends RouterBuilder<infer E, infer R> ? RouterBuilder<
+): S extends Router<infer E, infer R> ? Router<
     E | ExtractRouteSetError<Route.RouteSet<Routes, Schemas>>,
     R | ExtractRouteSetContext<Route.RouteSet<Routes, Schemas>>
   >
-  : RouterBuilder<
+  : Router<
     ExtractRouteSetError<Route.RouteSet<Routes, Schemas>>,
     ExtractRouteSetContext<Route.RouteSet<Routes, Schemas>>
   >
 {
-  const builder = isRouterBuilder(this)
+  const router = isRouter(this)
     ? this
-    : makeBuilder<never, never>([], [])
-  return addRoute(builder, path, route as Route.RouteSet.Default) as any
-}
+    : make<never, never>([], [])
 
-export function fromManifest(
-  manifest: RouterManifest,
-): Effect.Effect<RouterBuilder.Any> {
-  return Effect.gen(function*() {
-    const loadedEntries = yield* Effect.forEach(
-      manifest.routes,
-      (lazyRoute) =>
-        Effect.gen(function*() {
-          const routeModule = yield* Effect.promise(() => lazyRoute.load())
-          const layerModules = lazyRoute.layers
-            ? yield* Effect.forEach(
-              lazyRoute.layers,
-              (loadLayer) => Effect.promise(() => loadLayer()),
-            )
-            : []
-
-          const layers = layerModules
-            .map((m: any) => m.default)
-            .filter(Route.isRouteLayer)
-
-          return {
-            path: lazyRoute.path,
-            route: routeModule.default,
-            layers,
-          }
-        }),
-    )
-
-    return makeBuilder(loadedEntries, [])
-  })
+  return addRoute(
+    router,
+    path,
+    route as Route.RouteSet.Default,
+  ) as any
 }

package/src/SchemaExtra.ts

@@ -0,0 +1,102 @@
+import * as Function from "effect/Function"
+import * as Schema from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
+
+export function getBaseSchemaAST(schema: Schema.Schema.Any): SchemaAST.AST {
+  let current = schema.ast
+
+  while (
+    SchemaAST.isRefinement(current) || SchemaAST.isTransformation(current)
+  ) {
+    current = current.from
+  }
+
+  return current
+}
+
+export function isOptional(schema: Schema.Schema.Any): boolean {
+  const ast = schema.ast
+
+  if (ast._tag === "Union") {
+    return ast.types.some((t: SchemaAST.AST) => t._tag === "UndefinedKeyword")
+  }
+
+  return false
+}
+
+export function schemaEqual(
+  userSchema: Schema.Struct<any> | undefined,
+  expectedSchema: Schema.Struct<any> | null,
+): boolean {
+  if (!userSchema && !expectedSchema) {
+    return true
+  }
+  if (!userSchema || !expectedSchema) {
+    return false
+  }
+
+  const userFields = userSchema.fields
+  const expectedFields = expectedSchema.fields
+
+  const userKeys = Object.keys(userFields).sort()
+  const expectedKeys = Object.keys(expectedFields).sort()
+
+  if (userKeys.length !== expectedKeys.length) {
+    return false
+  }
+
+  for (let i = 0; i < userKeys.length; i++) {
+    if (userKeys[i] !== expectedKeys[i]) {
+      return false
+    }
+  }
+
+  for (const key of userKeys) {
+    const userFieldSchema = userFields[key]
+    const expectedFieldSchema = expectedFields[key]
+
+    const userOptional = isOptional(userFieldSchema)
+    const expectedOptional = isOptional(expectedFieldSchema)
+
+    if (userOptional !== expectedOptional) {
+      return false
+    }
+
+    const userBaseAST = getBaseSchemaAST(userFieldSchema)
+    const expectedBaseAST = getBaseSchemaAST(expectedFieldSchema)
+
+    if (userBaseAST._tag !== expectedBaseAST._tag) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export function getSchemaTypeName(schema: Schema.Schema.Any): string {
+  const baseAST = getBaseSchemaAST(schema)
+  switch (baseAST._tag) {
+    case "StringKeyword":
+      return "Schema.String"
+    case "NumberKeyword":
+      return "Schema.Number"
+    case "BooleanKeyword":
+      return "Schema.Boolean"
+    default:
+      return "Schema.String"
+  }
+}
+
+export function formatSchemaCode(schema: Schema.Struct<any>): string {
+  const fields = schema.fields
+  const fieldStrings: string[] = []
+
+  for (const [key, fieldSchema] of Object.entries(fields)) {
+    const optional = isOptional(fieldSchema)
+    const typeName = getSchemaTypeName(fieldSchema)
+    const fieldStr = optional ? `${key}?: ${typeName}` : `${key}: ${typeName}`
+    fieldStrings.push(fieldStr)
+  }
+
+  return `{ ${fieldStrings.join(", ")} }`
+}

package/src/Start.ts

@@ -67,7 +67,7 @@ export function serve<ROut, E>(
       | HttpClient.HttpClient
       | HttpRouter.Default
       | FileSystem.FileSystem
-      | BunHttpServer.BunServer
+      | BunHttpServer.BunHttpServer
     >
   }>,
 ) {
@@ -79,7 +79,7 @@ export function serve<ROut, E>(
   )
 
   return Function.pipe(
-    BunHttpServer.layerRoutes(),
+    BunHttpServer.layerFileRouter(),
     HttpServer.withLogAddress,
     Layer.provide(appLayer),
     Layer.provide([