effect-start 0.25.0 → 0.26.0

package/dist/RouteSchema.js

@@ -1,271 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Schema from "effect/Schema"
-import * as Entity from "./Entity.js"
-import * as Http from "./Http.js"
-import * as PathPattern from "./PathPattern.js"
-import * as Route from "./Route.js"
-import * as RouteHook from "./RouteHook.js"
-
-export const RequestBodyError = (
-  reason,
-  cause,
-) => ({ _tag: "RequestBodyError", reason, cause })
-
-export const File = Schema.TaggedStruct("File", {
-  key: Schema.String,
-  name: Schema.String,
-  contentType: Schema.String,
-  content: Schema.Uint8ArrayFromSelf,
-})
-
-export function schemaHeaders(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) =>
-    Effect.map(decode(Http.mapHeaders(ctx.request.headers)), (parsed) => ({
-      context: {
-        headers: {
-          ...ctx.headers,
-          ...parsed,
-        },
-      },
-    })),
-  )
-}
-
-export function schemaCookies(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) =>
-    Effect.map(decode(Http.parseCookies(ctx.request.headers.get("cookie"))), (parsed) => ({
-      context: {
-        cookies: {
-          ...ctx.cookies,
-          ...parsed,
-        },
-      },
-    })),
-  )
-}
-
-export function schemaSearchParams(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) => {
-    const url = new URL(ctx.request.url)
-    return Effect.map(decode(Http.mapUrlSearchParams(url.searchParams)), (parsed) => ({
-      context: {
-        searchParams: {
-          ...ctx.searchParams,
-          ...parsed,
-        },
-      },
-    }))
-  })
-}
-
-export function schemaPathParams(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) => {
-    const url = new URL(ctx.request.url)
-    const pattern = ctx.path ?? "/"
-    const params = PathPattern.match(pattern, url.pathname) ?? {}
-    return Effect.map(decode(params), (parsed) => ({
-      context: {
-        pathParams: {
-          ...ctx.pathParams,
-          ...parsed,
-        },
-      },
-    }))
-  })
-}
-
-export function schemaBodyJson(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) =>
-    Effect.gen(function* () {
-      const json = yield* Effect.tryPromise({
-        try: () => ctx.request.json(),
-        catch: (error) => RequestBodyError("JsonError", error),
-      })
-      const parsed = yield* decode(json)
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
-    }),
-  )
-}
-
-export function schemaBodyUrlParams(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) =>
-    Effect.gen(function* () {
-      const text = yield* Effect.tryPromise({
-        try: () => ctx.request.text(),
-        catch: (error) => RequestBodyError("UrlParamsError", error),
-      })
-      const params = new URLSearchParams(text)
-      const parsed = yield* decode(Http.mapUrlSearchParams(params))
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
-    }),
-  )
-}
-
-export function schemaBodyMultipart(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) =>
-    Effect.gen(function* () {
-      const record = yield* Effect.tryPromise({
-        try: () => Http.parseFormData(ctx.request),
-        catch: (error) => RequestBodyError("MultipartError", error),
-      })
-      const parsed = yield* decode(record)
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
-    }),
-  )
-}
-
-export function schemaBodyForm(
-  fields,
-) {
-  const decode = Schema.decodeUnknown(fields)
-  return RouteHook.filter((ctx) =>
-    Effect.gen(function* () {
-      const contentType = ctx.request.headers.get("content-type") ?? ""
-
-      if (contentType.includes("application/x-www-form-urlencoded")) {
-        const text = yield* Effect.tryPromise({
-          try: () => ctx.request.text(),
-          catch: (error) => RequestBodyError("UrlParamsError", error),
-        })
-        const params = new URLSearchParams(text)
-        const record = Http.mapUrlSearchParams(params)
-        const parsed = yield* decode(record)
-        return {
-          context: {
-            body: {
-              ...ctx.body,
-              ...parsed,
-            },
-          },
-        }
-      }
-
-      const record = yield* Effect.tryPromise({
-        try: () => Http.parseFormData(ctx.request),
-        catch: (error) => RequestBodyError("FormDataError", error),
-      })
-      const parsed = yield* decode(record)
-      return {
-        context: {
-          body: {
-            ...ctx.body,
-            ...parsed,
-          },
-        },
-      }
-    }),
-  )
-}
-
-/**
- * Intercepts typed errors from downstream handlers, encodes them through the
- * schema, and returns a JSON response with the given status code.
- *
- * Without `schemaError`, handler errors fall through to global catch during
- * execution of request. `schemaError` short circuts error handling by
- * return an error response immedietly.
- *
- * TODO: store the errors in runtime to enable generating OpenAPI and other
- * goodies.
- */
-export function schemaError(
-  schema,
-  options,
-) {
-  const status = options?.status ?? (schema).status
-  if (typeof status !== "number") {
-    throw new Error(
-      "schemaError: status is required either via options or as a static property on the schema",
-    )
-  }
-  const encode = Schema.encode(schema)
-  const is = Schema.is(schema)
-  return function (
-    self,
-  ) {
-    const route = Route.make((_context, next) =>
-      Entity.resolve(next()).pipe(
-        Effect.catchIf(is, (error) =>
-          Effect.map(Effect.orDie(encode(error)), (encoded) => Entity.make(encoded, { status })),
-        ),
-      ),
-    )
-
-    const items = [
-      ...Route.items(self),
-      route,
-    ]
-
-    return Route.set(items, Route.descriptor(self))
-  }
-}
-
-export function schemaSuccess(
-  schema,
-) {
-  const encode = Schema.encodeUnknown(schema)
-  return function (
-    self,
-  ) {
-    const route = Route.make((_context, next) =>
-      Effect.flatMap(Entity.resolve(next()), (entity) =>
-        Effect.map(encode(entity.body), (encoded) =>
-          Entity.make(encoded, {
-            status: entity.status,
-            headers: entity.headers,
-            url: entity.url,
-          }),
-        ),
-      ),
-    )
-
-    const items = [
-      ...Route.items(self),
-      route,
-    ]
-
-    return Route.set(items, Route.descriptor(self))
-  }
-}

package/dist/RouteSse.js

@@ -1,94 +0,0 @@
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Schedule from "effect/Schedule"
-import * as Stream from "effect/Stream"
-import * as Entity from "./Entity.js"
-import * as Route from "./Route.js"
-import * as StreamExtra from "./StreamExtra.js"
-
-const HEARTBEAT_INTERVAL = Duration.seconds(5)
-const HEARTBEAT = ": <3\n\n"
-
-function isTaggedEvent(event) {
-  return Object.hasOwn(event, "_tag") && typeof event["_tag"] === "string"
-}
-
-function formatSseEvent(event) {
-  if (isTaggedEvent(event)) {
-    const json = JSON.stringify(event)
-    return `event: ${event._tag}\ndata: ${json}\n\n`
-  }
-
-  const e = event
-  let result = ""
-  if (e.event) {
-    result += `event: ${e.event}\n`
-  }
-  if (typeof e.data === "string") {
-    for (const line of e.data.split("\n")) {
-      result += `data: ${line}\n`
-    }
-  }
-  if (e.retry !== undefined) {
-    result += `retry: ${e.retry}\n`
-  }
-  if (result === "") {
-    return ""
-  }
-  return result + "\n"
-}
-
-export function sse(handler) {
-  return function (self) {
-    const sseHandler = (ctx, _next) => {
-      const getStream = () => {
-        if (typeof handler === "function") {
-          const result = (handler)(ctx, _next)
-          if (StreamExtra.isStream(result)) {
-            return Effect.succeed(result)
-          }
-          if (Effect.isEffect(result)) {
-            return result
-          }
-          return Effect.gen(function* () {
-            return yield* result
-          })
-        }
-        if (StreamExtra.isStream(handler)) {
-          return Effect.succeed(handler)
-        }
-        if (Effect.isEffect(handler)) {
-          return handler
-        }
-        return Effect.succeed(Stream.empty)
-      }
-
-      return Effect.map(getStream(), (eventStream) => {
-        const formattedStream = Stream.map(eventStream, formatSseEvent)
-        const heartbeat = Stream.repeat(
-          Stream.succeed(HEARTBEAT),
-          Schedule.spaced(HEARTBEAT_INTERVAL),
-        ).pipe(Stream.drop(1))
-        const merged = Stream.merge(formattedStream, heartbeat, {
-          haltStrategy: "left",
-        })
-        return Entity.make(merged, {
-          headers: {
-            "content-type": "text/event-stream",
-            "cache-control": "no-cache",
-            connection: "keep-alive",
-          },
-        })
-      })
-    }
-
-    const route = Route.make(
-      sseHandler,
-      { format: "text" },
-    )
-
-    const items = [...Route.items(self), route]
-
-    return Route.set(items, Route.descriptor(self))
-  }
-}

package/dist/RouteTree.js

@@ -1,119 +0,0 @@
-import * as Predicate from "effect/Predicate"
-import * as PathPattern from "./PathPattern.js"
-import * as Route from "./Route.js"
-
-const TypeId = Symbol.for("effect-start/RouteTree")
-const RouteTreeRoutes = Symbol()
-
-const LayerKey = "*"
-
-function routes(tree) {
-  return tree[RouteTreeRoutes]
-}
-
-// segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
-function sortScore(path) {
-  const segments = path.split("/")
-  const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"))
-  const maxPriority = Math.max(
-    ...segments.map((s) =>
-      !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1,
-    ),
-    0,
-  )
-
-  return greedyIdx === -1
-    ? // non-greedy: sort by depth, then by max segment priority
-      (segments.length << 16) + (maxPriority << 8)
-    : // greedy: sort after non-greedy, by greedy position (later = first), then priority
-      (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8)
-}
-
-function sortRoutes(input) {
-  const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b))
-  const sorted = {}
-  for (const key of keys) {
-    sorted[key] = input[key]
-  }
-  return sorted
-}
-
-export function make(
-  input,
-) {
-  const layerRoutes = [...(input[LayerKey] ?? [])]
-  const merged = {}
-
-  function flatten(map, prefix, layers) {
-    for (const key of Object.keys(map)) {
-      if (key === LayerKey) continue
-      const path = key
-      const entry = map[path]
-      const fullPath = `${prefix}${path}`
-
-      if (isRouteTree(entry)) {
-        flatten(routes(entry), fullPath, layers)
-      } else {
-        merged[fullPath] = [...layers, ...(entry)]
-      }
-    }
-  }
-
-  flatten(input, "", layerRoutes)
-
-  return {
-    [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(merged),
-  }
-}
-
-function* flattenRoutes(
-  path,
-  routes,
-) {
-  for (const route of routes) {
-    const descriptor = {
-      ...route[Route.RouteDescriptor],
-      path,
-    }
-    yield Route.make(route.handler, descriptor)
-  }
-}
-
-export function* walk(tree) {
-  const _routes = routes(tree)
-
-  for (const path of Object.keys(_routes)) {
-    yield* flattenRoutes(path, _routes[path])
-  }
-}
-
-export function merge(a, b) {
-  const combined = { ...routes(a) }
-  for (const [path, items] of Object.entries(routes(b))) {
-    const key = path
-    combined[key] = combined[key] ? [...combined[key], ...items] : items
-  }
-  return {
-    [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(combined),
-  }
-}
-
-export function isRouteTree(input) {
-  return Predicate.hasProperty(input, TypeId)
-}
-
-export function lookup(tree, method, path) {
-  for (const route of walk(tree)) {
-    const descriptor = Route.descriptor(route)
-
-    if (descriptor.method !== "*" && descriptor.method !== method) continue
-
-    const params = PathPattern.match(descriptor.path, path)
-    if (params !== null) {
-      return { route, params }
-    }
-  }
-  return null
-}

package/dist/RouteTrie.js

@@ -1,179 +0,0 @@
-import * as PathPattern from "./PathPattern.js"
-import * as Route from "./Route.js"
-
-function createNode() {
-  return {
-    children: {},
-    paramChild: null,
-    paramName: null,
-    requiredWildcardChild: null,
-    requiredWildcardName: null,
-    optionalWildcardChild: null,
-    optionalWildcardName: null,
-    routes: [],
-  }
-}
-
-function insertRoute(node, segments, route) {
-  if (segments.length === 0) {
-    node.routes.push(route)
-    return
-  }
-
-  const segment = segments[0]
-  const rest = segments.slice(1)
-
-  if (segment.startsWith(":")) {
-    const name = segment.slice(1)
-
-    if (name.endsWith("+")) {
-      if (!node.requiredWildcardChild) {
-        node.requiredWildcardChild = createNode()
-      }
-      node.requiredWildcardChild.requiredWildcardName = name.slice(0, -1)
-      node.requiredWildcardChild.routes.push(route)
-    } else if (name.endsWith("*")) {
-      if (!node.optionalWildcardChild) {
-        node.optionalWildcardChild = createNode()
-      }
-      node.optionalWildcardChild.optionalWildcardName = name.slice(0, -1)
-      node.optionalWildcardChild.routes.push(route)
-    } else if (name.endsWith("?")) {
-      if (!node.paramChild) {
-        node.paramChild = createNode()
-      }
-      node.paramChild.paramName = name.slice(0, -1)
-      insertRoute(node.paramChild, rest, route)
-      insertRoute(node, rest, route)
-    } else {
-      if (!node.paramChild) {
-        node.paramChild = createNode()
-      }
-      node.paramChild.paramName = name
-      insertRoute(node.paramChild, rest, route)
-    }
-  } else {
-    if (!node.children[segment]) {
-      node.children[segment] = createNode()
-    }
-    insertRoute(node.children[segment], rest, route)
-  }
-}
-
-function collectRoutes(
-  items,
-  parentPath,
-  parentMethod,
-) {
-  const results = []
-
-  for (const item of items) {
-    const desc = Route.descriptor(item)
-    const currentPath = typeof desc?.path === "string" ? parentPath + desc.path : parentPath
-    const currentMethod = desc?.method ?? parentMethod
-
-    if (Route.isRoute(item)) {
-      if (currentPath !== "") {
-        results.push({
-          route: item,
-          method: currentMethod,
-          path: currentPath,
-        })
-      }
-    } else {
-      const nestedItems = Route.items(item)
-      results.push(...collectRoutes(nestedItems, currentPath, currentMethod))
-    }
-  }
-
-  return results
-}
-
-export function make(set) {
-  const methods = {}
-  const collected = collectRoutes(Route.items(set), "", "*")
-
-  for (const { route, method, path } of collected) {
-    if (!methods[method]) {
-      methods[method] = createNode()
-    }
-    const result = PathPattern.validate(path)
-    if (!result.ok) {
-      throw new Error(result.error)
-    }
-    insertRoute(methods[method], result.segments, route)
-  }
-
-  return { methods }
-}
-
-function lookupNode(
-  node,
-  segments,
-  params,
-) {
-  const results = []
-
-  if (segments.length === 0) {
-    for (const route of node.routes) {
-      results.push({ route, params })
-    }
-    if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-      for (const route of node.optionalWildcardChild.routes) {
-        results.push({ route, params })
-      }
-    }
-    return results
-  }
-
-  const segment = segments[0]
-  const rest = segments.slice(1)
-
-  if (node.children[segment]) {
-    results.push(...lookupNode(node.children[segment], rest, params))
-  }
-
-  if (node.paramChild && node.paramChild.paramName) {
-    const newParams = { ...params, [node.paramChild.paramName]: segment }
-    results.push(...lookupNode(node.paramChild, rest, newParams))
-  }
-
-  if (node.requiredWildcardChild && node.requiredWildcardChild.requiredWildcardName) {
-    const wildcardValue = segments.join("/")
-    const newParams = {
-      ...params,
-      [node.requiredWildcardChild.requiredWildcardName]: wildcardValue,
-    }
-    for (const route of node.requiredWildcardChild.routes) {
-      results.push({ route, params: newParams })
-    }
-  }
-
-  if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-    const wildcardValue = segments.join("/")
-    const newParams = {
-      ...params,
-      [node.optionalWildcardChild.optionalWildcardName]: wildcardValue,
-    }
-    for (const route of node.optionalWildcardChild.routes) {
-      results.push({ route, params: newParams })
-    }
-  }
-
-  return results
-}
-
-export function lookup(trie, method, path) {
-  const segments = path.split("/").filter(Boolean)
-  const results = []
-
-  if (trie.methods[method]) {
-    results.push(...lookupNode(trie.methods[method], segments, {}))
-  }
-
-  if (method !== "*" && trie.methods["*"]) {
-    results.push(...lookupNode(trie.methods["*"], segments, {}))
-  }
-
-  return results
-}