effect-start 0.14.0 → 0.16.0

package/src/FileHttpRouter.ts

@@ -1,194 +0,0 @@
-// @ts-nocheck
-import * as HttpApp from "@effect/platform/HttpApp"
-import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as HttpUtils from "./HttpUtils.ts"
-import * as Route from "./Route.ts"
-import * as Router from "./Router.ts"
-import * as RouteRender from "./RouteRender.ts"
-import * as RouterPattern from "./RouterPattern.ts"
-
-/**
- * Combines Effect error channel from a record of effects.
- */
-type RecordEffectError<A> = A extends Record<string, any> ? Exclude<
-    {
-      [K in keyof A]: A[K] extends Effect.Effect<any, infer E, any> ? E
-        : never
-    }[keyof A],
-    undefined
-  >
-  : never
-
-/**
- * Combines Effect requirement channel from a record of effects.
- */
-type RecordEffectRequirements<A> = A extends Record<string, any> ? Exclude<
-    {
-      [K in keyof A]: A[K] extends Effect.Effect<any, any, infer R> ? R
-        : never
-    }[keyof A],
-    undefined
-  >
-  : never
-
-/**
- * Infers the HttpRouter type from an array of ServerRoutes
- */
-export type HttpRouterFromServerRoutes<
-  Routes extends ReadonlyArray<Router.ServerRoute>,
-> = HttpRouter.HttpRouter<
-  (Routes extends ReadonlyArray<infer Route>
-    ? Route extends Router.ServerRoute
-      ? RecordEffectError<Awaited<ReturnType<Route["load"]>>>
-    : never
-    : never),
-  Exclude<
-    Routes extends ReadonlyArray<infer Route>
-      ? Route extends Router.ServerRoute
-        ? RecordEffectRequirements<Awaited<ReturnType<Route["load"]>>>
-      : never
-      : never,
-    // exclude HttpServerRequest since HttpRouter already has it
-    HttpServerRequest.HttpServerRequest
-  >
->
-
-/**
- * Find layer routes that match a given route's method and media type.
- */
-function findMatchingLayerRoutes(
-  route: Route.Route.Default,
-  layers: Route.RouteLayer[],
-): Route.Route.Default[] {
-  const matchingRoutes: Route.Route.Default[] = []
-
-  for (const layer of layers) {
-    for (const layerRoute of layer.set) {
-      if (Route.matches(layerRoute, route)) {
-        matchingRoutes.push(layerRoute)
-      }
-    }
-  }
-
-  return matchingRoutes
-}
-
-/**
- * Wrap an inner route with a layer route.
- * Returns a new route that, when executed, provides next() to call the inner route.
- */
-function wrapWithLayerRoute(
-  innerRoute: Route.Route.Default,
-  layerRoute: Route.Route.Default,
-): Route.Route.Default {
-  const handler: Route.RouteHandler = (context) => {
-    const innerNext = () => innerRoute.handler(context)
-
-    const contextWithNext: Route.RouteContext = {
-      ...context,
-      next: innerNext,
-    }
-
-    return layerRoute.handler(contextWithNext)
-  }
-
-  return Route.make({
-    method: layerRoute.method,
-    media: layerRoute.media,
-    handler,
-    schemas: {},
-  })
-}
-
-/**
- * Makes a HttpRouter from file-based routes.
- */
-
-export function make<
-  Routes extends ReadonlyArray<Router.ServerRoute>,
->(
-  routes: Routes,
-): Effect.Effect<HttpRouterFromServerRoutes<Routes>> {
-  return Effect.gen(function*() {
-    const routesWithModules = yield* Effect.forEach(
-      routes,
-      (route) =>
-        Effect.gen(function*() {
-          const module = yield* Effect.tryPromise(() => route.load()).pipe(
-            Effect.orDie,
-          )
-
-          const layerModules = route.layers
-            ? yield* Effect.forEach(
-              route.layers,
-              (layerLoad) =>
-                Effect.tryPromise(() => layerLoad()).pipe(Effect.orDie),
-            )
-            : []
-
-          const layers = layerModules
-            .map((mod: any) => mod.default)
-            .filter(Route.isRouteLayer)
-
-          return {
-            path: route.path,
-            routeSet: module.default,
-            layers,
-          }
-        }),
-    )
-
-    let router: HttpRouter.HttpRouter<any, any> = HttpRouter.empty
-
-    for (const { path, routeSet, layers } of routesWithModules) {
-      for (const route of routeSet.set) {
-        const matchingLayerRoutes = findMatchingLayerRoutes(route, layers)
-
-        let wrappedRoute = route
-        // Reverse so first layer in array becomes outermost wrapper.
-        // Example: [outerLayer, innerLayer] wraps as outer(inner(route))
-        for (const layerRoute of matchingLayerRoutes.reverse()) {
-          wrappedRoute = wrapWithLayerRoute(wrappedRoute, layerRoute)
-        }
-
-        const wrappedHandler: HttpApp.Default = Effect.gen(function*() {
-          const request = yield* HttpServerRequest.HttpServerRequest
-
-          const context: Route.RouteContext = {
-            request,
-            get url() {
-              return HttpUtils.makeUrlFromRequest(request)
-            },
-            slots: {},
-            next: () => Effect.void,
-          }
-
-          return yield* RouteRender.render(wrappedRoute, context)
-        })
-
-        const allMiddleware = layers
-          .map((layer) => layer.httpMiddleware)
-          .filter((m): m is Route.HttpMiddlewareFunction => m !== undefined)
-
-        let finalHandler = wrappedHandler
-        for (const middleware of allMiddleware) {
-          finalHandler = middleware(finalHandler)
-        }
-
-        for (const pattern of RouterPattern.toEffect(path)) {
-          router = HttpRouter.route(route.method)(
-            pattern,
-            finalHandler as any,
-          )(router)
-        }
-      }
-    }
-
-    return router as HttpRouterFromServerRoutes<Routes>
-  })
-}

package/src/Hyper.ts

@@ -1,194 +0,0 @@
-import * as HttpApp from "@effect/platform/HttpApp"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Effectable from "effect/Effectable"
-import * as Fiber from "effect/Fiber"
-import * as Function from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as Pipeable from "effect/Pipeable"
-import { YieldWrap } from "effect/Utils"
-import * as HyperHtml from "./HyperHtml.ts"
-import type { JSX } from "./jsx.d.ts"
-import { HyperHooks } from "./x/datastar/index.ts"
-
-const TypeId = Symbol.for("~hyper/TypeId")
-const LayoutTypeId = Symbol.for("~hyper/LayoutTypeId")
-
-type Elements = JSX.IntrinsicElements
-
-type Children = JSX.Children
-
-export type {
-  Children,
-  Elements,
-  JSX,
-}
-
-export class Hyper extends Context.Tag("Hyper")<Hyper, {
-  hooks: typeof HyperHooks | undefined
-}>() {}
-
-export function layer(opts: {
-  hooks: typeof HyperHooks
-}) {
-  return Layer.sync(Hyper, () => {
-    return {
-      hooks: opts.hooks,
-    }
-  })
-}
-
-/**
- * Accepts Effect that returns a HyperNode
- * to a HttpApp.
- * TODO: Implement Hyper.page that returns Hyper.Element
- */
-export function handle<E, R>(
-  handler: Effect.Effect<
-    JSX.Children | HttpServerResponse.HttpServerResponse,
-    E,
-    R
-  >,
-): HttpApp.Default<E, R>
-export function handle(
-  handler: () => Generator<
-    never,
-    JSX.Children | HttpServerResponse.HttpServerResponse,
-    any
-  >,
-): HttpApp.Default<never, never>
-export function handle<Eff extends YieldWrap<Effect.Effect<any, any, any>>>(
-  handler: () => Generator<
-    Eff,
-    JSX.Children | HttpServerResponse.HttpServerResponse,
-    any
-  >,
-): HttpApp.Default<
-  [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
-    : never,
-  [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
-    : never
->
-export function handle(
-  handler:
-    | Effect.Effect<
-      JSX.Children | HttpServerResponse.HttpServerResponse,
-      any,
-      any
-    >
-    | (() => Generator<
-      YieldWrap<Effect.Effect<any, any, any>>,
-      JSX.Children | HttpServerResponse.HttpServerResponse,
-      any
-    >),
-): HttpApp.Default<any, any> {
-  return Effect.gen(function*() {
-    const hyper = yield* Effect.serviceOption(Hyper).pipe(
-      Effect.andThen(Option.getOrNull),
-    )
-    const effect = isGenerator(handler) ? Effect.gen(handler) : handler
-    const value = yield* effect
-
-    if (HttpServerResponse.isServerResponse(value)) {
-      return value
-    }
-
-    const html = HyperHtml.renderToString(value, hyper?.hooks)
-
-    return yield* HttpServerResponse.html`${html}`
-  })
-}
-
-function isGenerator<A, E, R>(
-  handler: any,
-): handler is () => Generator<YieldWrap<Effect.Effect<A, E, R>>, any, any> {
-  return typeof handler === "function"
-    && handler.constructor?.name === "GeneratorFunction"
-}
-
-const NoChildren: ReadonlyArray<never> = Object.freeze([])
-
-type Primitive = string | number | boolean | null | undefined
-
-export type HyperType = string | HyperComponent
-
-export type HyperProps = {
-  [key: string]:
-    | Primitive
-    | ReadonlyArray<Primitive>
-    | HyperNode
-    | HyperNode[]
-    | null
-    | undefined
-}
-
-export type HyperComponent = (
-  props: HyperProps,
-) => HyperNode | Primitive
-
-export interface HyperNode {
-  type: HyperType
-  props: HyperProps
-}
-
-export function h(
-  type: HyperType,
-  props: HyperProps,
-): HyperNode {
-  return {
-    type,
-    props: {
-      ...props,
-      children: props.children ?? NoChildren,
-    },
-  }
-}
-
-export function unsafeUse<Value>(tag: Context.Tag<any, Value>) {
-  const currentFiber = Option.getOrThrow(
-    Fiber.getCurrentFiber(),
-  )
-  const context = currentFiber.currentContext
-
-  return Context.unsafeGet(context, tag)
-}
-
-export interface Layout<in out Provides, in out Requires>
-  extends Layer.Layer<Provides, never, Requires>
-{
-  readonly [TypeId]: typeof LayoutTypeId
-}
-
-export function layout<Provides, Requires>(
-  handler:
-    | Effect.Effect<
-      JSX.Children | HttpServerResponse.HttpServerResponse,
-      any,
-      any
-    >
-    | (() => Generator<
-      YieldWrap<Effect.Effect<any, any, any>>,
-      JSX.Children | HttpServerResponse.HttpServerResponse,
-      any
-    >),
-):
-  & Layout<Provides, Requires>
-  & {
-    handler: any
-  }
-{
-  return {
-    [TypeId]: LayoutTypeId,
-    [Layer.LayerTypeId]: {
-      _ROut: Function.identity,
-      _E: Function.identity,
-      _RIn: Function.identity,
-    },
-    handler,
-    pipe() {
-      return Pipeable.pipeArguments(this, arguments)
-    },
-  }
-}