effect-start 0.15.0 → 0.17.0

package/src/RouteTree.ts

@@ -6,21 +6,31 @@ import * as RouteMount from "./RouteMount.ts"
 const TypeId: unique symbol = Symbol.for("effect-start/RouteTree")
 const RouteTreeRoutes: unique symbol = Symbol()
 
+type MethodRoute = Route.Route.With<{ method: string }>
+
+export type RouteTuple = Iterable<MethodRoute>
+
+export type LayerRoute = Iterable<Route.Route.With<{ method: "*" }>>
+
+type LayerKey = "*"
+const LayerKey: LayerKey = "*"
+
+export type InputRouteMap = {
+  [LayerKey]?: LayerRoute
+} & {
+  [path: PathPattern.PathPattern]: RouteTuple | RouteTree
+}
+
 export type RouteMap = {
-  [path: PathPattern.PathPattern]: Iterable<
-    Route.Route.With<{
-      method: RouteMount.RouteMount.Method
-      format?: string
-    }>
-  >
+  [path: PathPattern.PathPattern]: Route.Route.Tuple
 }
 
 export type Routes<
-  T extends RouteTree<any>,
+  T extends RouteTree,
 > = T[typeof RouteTreeRoutes]
 
 export interface RouteTree<
-  Routes extends RouteMap = {},
+  Routes extends RouteMap = RouteMap,
 > {
   [TypeId]: typeof TypeId
   [RouteTreeRoutes]: Routes
@@ -74,19 +84,78 @@ function sortRoutes(input: RouteMap): RouteMap {
   return sorted
 }
 
+type PrefixKeys<T, Prefix extends string> = {
+  [K in keyof T as K extends string ? `${Prefix}${K}` : never]: T[K]
+}
+
+type InferItems<T> = T extends Route.RouteSet.Data<any, any, infer M> ? M
+  : []
+
+type LayerItems<T extends InputRouteMap> = "*" extends keyof T
+  ? InferItems<T["*"]>
+  : []
+
+type FlattenRouteMap<T extends InputRouteMap> =
+  & {
+    [K in Exclude<keyof T, "*"> as T[K] extends RouteTree ? never : K]: [
+      ...LayerItems<T>,
+      ...InferItems<T[K]>,
+    ]
+  }
+  & UnionToIntersection<FlattenNested<T, Exclude<keyof T, "*">, LayerItems<T>>>
+
+type FlattenNested<
+  T,
+  K,
+  L extends Route.Route.Tuple,
+> = K extends keyof T
+  ? T[K] extends RouteTree<infer R>
+    ? PrefixKeys<PrependLayers<R, L>, K & string>
+  : {}
+  : {}
+
+type PrependLayers<T extends RouteMap, L extends Route.Route.Tuple> = {
+  [K in keyof T]: T[K] extends Route.Route.Tuple ? [...L, ...T[K]] : never
+}
+
+type UnionToIntersection<U> = (
+  U extends any ? (x: U) => void : never
+) extends (x: infer I) => void ? I
+  : never
+
 export function make<
-  const Routes extends RouteMap,
+  const Routes extends InputRouteMap,
 >(
-  routes: Routes,
-): RouteTree<
-  {
-    [K in keyof Routes]: Route.RouteSet.Infer<Routes[K]>
+  input: Routes,
+): RouteTree<FlattenRouteMap<Routes>> {
+  const layerRoutes = [...(input[LayerKey] ?? [])]
+  const merged: RouteMap = {}
+
+  function flatten(
+    map: InputRouteMap,
+    prefix: string,
+    layers: MethodRoute[],
+  ): void {
+    for (const key of Object.keys(map)) {
+      if (key === LayerKey) continue
+      const path = key as PathPattern.PathPattern
+      const entry = map[path]
+      const fullPath = `${prefix}${path}` as PathPattern.PathPattern
+
+      if (isRouteTree(entry)) {
+        flatten(routes(entry), fullPath, layers)
+      } else {
+        merged[fullPath] = [...layers, ...(entry as RouteTuple)]
+      }
+    }
   }
-> {
+
+  flatten(input, "", layerRoutes)
+
   return {
     [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(routes),
-  } as RouteTree<{ [K in keyof Routes]: Route.RouteSet.Infer<Routes[K]> }>
+    [RouteTreeRoutes]: sortRoutes(merged),
+  } as RouteTree<FlattenRouteMap<Routes>>
 }
 
 export type WalkDescriptor = {
@@ -94,44 +163,29 @@ export type WalkDescriptor = {
   method: string
 } & Route.RouteDescriptor.Any
 
-function* flattenItems(
+function* flattenRoutes(
   path: PathPattern.PathPattern,
-  items: Route.Route.Tuple,
-  parentDescriptor: { method: string } & Route.RouteDescriptor.Any,
+  routes: Iterable<MethodRoute>,
 ): Generator<RouteMount.MountedRoute> {
-  for (const item of items) {
-    if (Route.isRoute(item)) {
-      const mergedDescriptor = {
-        ...parentDescriptor,
-        ...Route.descriptor(item),
-        path,
-      }
-      yield Route.make(
-        // handler receives mergedDescriptor (which includes path) at runtime
-        item.handler as any,
-        mergedDescriptor,
-      ) as RouteMount.MountedRoute
-    } else if (Route.isRouteSet(item)) {
-      const mergedDescriptor = {
-        ...parentDescriptor,
-        ...Route.descriptor(item),
-      }
-      yield* flattenItems(path, Route.items(item), mergedDescriptor)
+  for (const route of routes) {
+    const descriptor = {
+      ...route[Route.RouteDescriptor],
+      path,
     }
+    yield Route.make(
+      route.handler as any,
+      descriptor,
+    ) as RouteMount.MountedRoute
   }
 }
 
 export function* walk(
   tree: RouteTree,
 ): Generator<RouteMount.MountedRoute> {
-  const _routes = routes(tree)
+  const _routes = routes(tree) as RouteMap
+
   for (const path of Object.keys(_routes) as PathPattern.PathPattern[]) {
-    const routeSet = _routes[path]
-    yield* flattenItems(
-      path,
-      Route.items(routeSet),
-      Route.descriptor(routeSet),
-    )
+    yield* flattenRoutes(path, _routes[path])
   }
 }
 

package/src/StreamExtra.ts

@@ -4,11 +4,31 @@ import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
 import * as Predicate from "effect/Predicate"
 import * as Runtime from "effect/Runtime"
-import * as Stream from "effect/Stream"
 import {
   runForEachChunk,
   StreamTypeId,
 } from "effect/Stream"
+import type * as Stream from "effect/Stream"
+
+export const isStream = (
+  u: unknown,
+): u is Stream.Stream<unknown, unknown, unknown> =>
+  Predicate.hasProperty(u, StreamTypeId)
+
+export type IsStream<T> = T extends Stream.Stream<infer _A, infer _E, infer _R>
+  ? true
+  : false
+
+export type Chunk<T> = T extends Stream.Stream<infer A, infer _E, infer _R> ? A
+  : never
+
+export type StreamError<T> = T extends
+  Stream.Stream<infer _A, infer E, infer _R> ? E
+  : never
+
+export type Context<T> = T extends Stream.Stream<infer _A, infer _E, infer R>
+  ? R
+  : never
 
 /**
  * Patched version of original Stream.toReadableStreamRuntime (v3.14.4) to

package/src/Values.test.ts

@@ -0,0 +1,263 @@
+import * as test from "bun:test"
+import * as Values from "./Values.ts"
+
+test.describe("isPlainObject", () => {
+  test.it("returns true for plain objects", () => {
+    test
+      .expect(Values.isPlainObject({}))
+      .toBe(true)
+
+    test
+      .expect(Values.isPlainObject({ a: 1, b: 2 }))
+      .toBe(true)
+
+    test
+      .expect(Values.isPlainObject({ nested: { value: true } }))
+      .toBe(true)
+  })
+
+  test.it("returns false for null", () => {
+    test
+      .expect(Values.isPlainObject(null))
+      .toBe(false)
+  })
+
+  test.it("returns false for primitives", () => {
+    test
+      .expect(Values.isPlainObject("string"))
+      .toBe(false)
+
+    test
+      .expect(Values.isPlainObject(42))
+      .toBe(false)
+
+    test
+      .expect(Values.isPlainObject(true))
+      .toBe(false)
+
+    test
+      .expect(Values.isPlainObject(undefined))
+      .toBe(false)
+  })
+
+  test.it("returns false for ArrayBuffer", () => {
+    test
+      .expect(Values.isPlainObject(new ArrayBuffer(8)))
+      .toBe(false)
+  })
+
+  test.it("returns false for ArrayBufferView (Uint8Array)", () => {
+    test
+      .expect(Values.isPlainObject(new Uint8Array([1, 2, 3])))
+      .toBe(false)
+  })
+
+  test.it("returns false for Blob", () => {
+    test
+      .expect(Values.isPlainObject(new Blob(["test"])))
+      .toBe(false)
+  })
+
+  test.it("returns false for FormData", () => {
+    test
+      .expect(Values.isPlainObject(new FormData()))
+      .toBe(false)
+  })
+
+  test.it("returns false for URLSearchParams", () => {
+    test
+      .expect(Values.isPlainObject(new URLSearchParams()))
+      .toBe(false)
+  })
+
+  test.it("returns false for ReadableStream", () => {
+    test
+      .expect(Values.isPlainObject(new ReadableStream()))
+      .toBe(false)
+  })
+
+  test.it("returns false for arrays", () => {
+    test
+      .expect(Values.isPlainObject([]))
+      .toBe(false)
+
+    test
+      .expect(Values.isPlainObject([1, 2, 3]))
+      .toBe(false)
+  })
+
+  test.it("returns false for functions", () => {
+    test
+      .expect(Values.isPlainObject(() => {}))
+      .toBe(false)
+
+    test
+      .expect(Values.isPlainObject(function() {}))
+      .toBe(false)
+  })
+
+  test.it("returns false for class instances", () => {
+    class MyClass {
+      value = 42
+    }
+
+    test
+      .expect(Values.isPlainObject(new MyClass()))
+      .toBe(false)
+  })
+
+  test.it("returns false for Date", () => {
+    test
+      .expect(Values.isPlainObject(new Date()))
+      .toBe(false)
+  })
+
+  test.it("returns false for Map", () => {
+    test
+      .expect(Values.isPlainObject(new Map()))
+      .toBe(false)
+  })
+
+  test.it("returns false for Set", () => {
+    test
+      .expect(Values.isPlainObject(new Set()))
+      .toBe(false)
+  })
+
+  test.it("returns false for RegExp", () => {
+    test
+      .expect(Values.isPlainObject(/test/))
+      .toBe(false)
+  })
+
+  test.it("returns false for Error", () => {
+    test
+      .expect(Values.isPlainObject(new Error("test")))
+      .toBe(false)
+  })
+
+  test.it("returns false for Promise", () => {
+    test
+      .expect(Values.isPlainObject(Promise.resolve()))
+      .toBe(false)
+  })
+
+  test.it("returns true for Object.create(null)", () => {
+    test
+      .expect(Values.isPlainObject(Object.create(null)))
+      .toBe(true)
+  })
+})
+
+test.describe("IsPlainObject", () => {
+  test.it("returns true for plain objects", () => {
+    test
+      .expectTypeOf<Values.IsPlainObject<{ a: number }>>()
+      .toEqualTypeOf<true>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<{ a: number; b: string }>>()
+      .toEqualTypeOf<true>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<{}>>()
+      .toEqualTypeOf<true>()
+  })
+
+  test.it("returns false for functions", () => {
+    test
+      .expectTypeOf<Values.IsPlainObject<() => void>>()
+      .toEqualTypeOf<false>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<(a: number) => string>>()
+      .toEqualTypeOf<false>()
+  })
+
+  test.it("returns false for built-in classes", () => {
+    test
+      .expectTypeOf<Values.IsPlainObject<Request>>()
+      .toEqualTypeOf<false>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<Response>>()
+      .toEqualTypeOf<false>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<Date>>()
+      .toEqualTypeOf<false>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<Map<string, number>>>()
+      .toEqualTypeOf<false>()
+  })
+
+  test.it("returns false for primitives", () => {
+    test
+      .expectTypeOf<Values.IsPlainObject<string>>()
+      .toEqualTypeOf<false>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<number>>()
+      .toEqualTypeOf<false>()
+
+    test
+      .expectTypeOf<Values.IsPlainObject<boolean>>()
+      .toEqualTypeOf<false>()
+  })
+})
+
+test.describe("Simplify", () => {
+  test.it("expands nested plain objects", () => {
+    type Input = {
+      readonly a: { readonly x: number }
+      readonly b: string
+    }
+
+    test
+      .expectTypeOf<Values.Simplify<Input>>()
+      .toEqualTypeOf<{
+        a: { x: number }
+        b: string
+      }>()
+  })
+
+  test.it("preserves Request type", () => {
+    type Input = {
+      request: Request
+      data: { value: number }
+    }
+
+    type Result = Values.Simplify<Input>
+
+    test
+      .expectTypeOf<Result["request"]>()
+      .toEqualTypeOf<Request>()
+
+    test
+      .expectTypeOf<Result["data"]>()
+      .toEqualTypeOf<{ value: number }>()
+  })
+
+  test.it("preserves other built-in types", () => {
+    type Input = {
+      date: Date
+      map: Map<string, number>
+      response: Response
+    }
+
+    type Result = Values.Simplify<Input>
+
+    test
+      .expectTypeOf<Result["date"]>()
+      .toEqualTypeOf<Date>()
+
+    test
+      .expectTypeOf<Result["map"]>()
+      .toEqualTypeOf<Map<string, number>>()
+
+    test
+      .expectTypeOf<Result["response"]>()
+      .toEqualTypeOf<Response>()
+  })
+})

package/src/Values.ts

@@ -4,13 +4,75 @@ type JsonPrimitives =
   | boolean
   | null
 
+export type JsonObject = {
+  [key: string]:
+    | Json
+    // undefined won't be included in JSON objects but this will allow
+    // to use Json type in functions that return object of multiple shapes
+    | undefined
+}
+
 export type Json =
   | JsonPrimitives
   | Json[]
-  | {
-    [key: string]:
-      | Json
-      // undefined won't be included in JSON objects but this will allow
-      // to use Json type in functions that return object of multiple shapes
-      | undefined
+  | JsonObject
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") {
+    return false
   }
+
+  // Check for built-in types and web APIs
+  if (
+    ArrayBuffer.isView(value)
+    || value instanceof ArrayBuffer
+    || value instanceof Blob
+    || value instanceof FormData
+    || value instanceof URLSearchParams
+    || value instanceof ReadableStream
+    || value instanceof Date
+    || value instanceof Map
+    || value instanceof Set
+    || value instanceof RegExp
+    || value instanceof Error
+    || value instanceof Promise
+    || Array.isArray(value)
+  ) {
+    return false
+  }
+
+  // Check if it's a plain object (Object.prototype or null prototype)
+  const proto = Object.getPrototypeOf(value)
+  return proto === null || proto === Object.prototype
+}
+
+/**
+ * Type helper that returns `true` if type T has any method properties,
+ * otherwise returns `never`.
+ *
+ * Used internally by IsPlainObject to distinguish plain objects from
+ * class instances or objects with methods.
+ */
+type HasMethod<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? true : never
+}[keyof T]
+
+export type IsPlainObject<T> = T extends object ? T extends Function ? false
+  : HasMethod<T> extends never ? true
+  : false
+  : false
+
+export type Simplify<T> = {
+  -readonly [K in keyof T]: IsPlainObject<T[K]> extends true
+    ? { -readonly [P in keyof T[K]]: T[K][P] }
+    : T[K]
+} extends infer U ? { [K in keyof U]: U[K] } : never
+
+export const concatBytes = (a: Uint8Array, b: Uint8Array): Uint8Array => {
+  const result = new Uint8Array(a.byteLength + b.byteLength)
+  result.set(a)
+  result.set(b, a.byteLength)
+  return result
+}

package/src/bun/BunBundle.ts

@@ -9,10 +9,7 @@ import {
   Iterable,
   Layer,
   pipe,
-  PubSub,
   Record,
-  Stream,
-  SynchronizedRef,
 } from "effect"
 import * as NPath from "node:path"
 import type {
@@ -20,7 +17,6 @@ import type {
   BundleManifest,
 } from "../bundler/Bundle.ts"
 import * as Bundle from "../bundler/Bundle.ts"
-import * as FileSystemExtra from "../FileSystemExtra.ts"
 import { BunImportTrackerPlugin } from "./index.ts"
 
 export type BuildOptions = Omit<
@@ -125,75 +121,6 @@ export function layer<T>(
   return Layer.effect(tag, build(config))
 }
 
-export function layerDev<T>(
-  tag: Context.Tag<T, BundleContext>,
-  config: BuildOptions,
-) {
-  return Layer.scoped(
-    tag,
-    Effect.gen(function*() {
-      const loadRefKey = "_loadRef"
-      const sharedBundle = yield* build(config)
-
-      const loadRef = yield* SynchronizedRef.make(null)
-      sharedBundle[loadRefKey] = loadRef
-      sharedBundle.events = yield* PubSub.unbounded<Bundle.BundleEvent>()
-
-      yield* Effect.fork(
-        pipe(
-          FileSystemExtra.watchSource({
-            filter: FileSystemExtra.filterSourceFiles,
-          }),
-          Stream.map(v =>
-            ({
-              _tag: "Change",
-              path: v.path,
-            }) as Bundle.BundleEvent
-          ),
-          Stream.onError(err =>
-            Effect.logError("Error while watching files", err)
-          ),
-          Stream.runForEach((v) =>
-            pipe(
-              Effect.gen(function*() {
-                yield* Effect.logDebug("Updating bundle: " + tag.key)
-
-                const newBundle = yield* build(config)
-
-                Object.assign(sharedBundle, newBundle)
-
-                // Clean old loaded bundle
-                yield* SynchronizedRef.update(loadRef, () => null)
-
-                // publish event after the built
-                if (sharedBundle.events) {
-                  yield* PubSub.publish(sharedBundle.events, v)
-                }
-              }),
-              Effect.catchAll(err =>
-                Effect.gen(function*() {
-                  yield* Effect.logError(
-                    "Error while updating bundle",
-                    err,
-                  )
-                  if (sharedBundle.events) {
-                    yield* PubSub.publish(sharedBundle.events, {
-                      _tag: "BuildError",
-                      error: String(err),
-                    })
-                  }
-                })
-              ),
-            )
-          ),
-        ),
-      )
-
-      return sharedBundle
-    }),
-  )
-}
-
 /**
  * Finds common path prefix across provided paths.
  */

package/src/bun/BunHttpServer.ts

@@ -201,17 +201,33 @@ export function layerRoutes(
   return Layer.effectDiscard(
     Effect.gen(function*() {
       const bunServer = yield* BunHttpServer
-      const routes: BunRoute.BunRoutes = {}
-      for (const [path, handler] of RouteHttp.walkHandles(tree)) {
+      const runtime = yield* Effect.runtime<BunHttpServer>()
+      const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
+
+      const bunRoutes: BunRoute.BunRoutes = {}
+      const pathGroups = new Map<string, RouteMount.MountedRoute[]>()
+
+      for (const route of RouteTree.walk(tree)) {
+        const bunDescriptors = BunRoute.descriptors(route)
+        if (bunDescriptors) {
+          const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
+          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)) {
-          routes[bunPath] = handler
+          bunRoutes[bunPath] = handler
         }
       }
 
-      // TODO: think how can we define routes upfront rather
-      // than add them after startup?
-      // now that we have Rooutes.Route thats should be possible
-      bunServer.addRoutes(routes)
+      bunServer.addRoutes(bunRoutes)
     }),
   )
 }