effect-start 0.14.0 → 0.15.0

package/src/ContentNegotiation.ts

@@ -0,0 +1,535 @@
+/**
+ * RFC 7231 Content Negotiation compatible with Express/Node.js ecosystem.
+ * Based on {@link https://github.com/jshttp/negotiator}
+ */
+
+import type * as Headers from "@effect/platform/Headers"
+
+interface ParsedSpec {
+  value: string
+  q: number
+  s: number
+  o: number
+  i: number
+}
+
+const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/
+const simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/
+const simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/
+const simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/
+
+function parseQuality(params: string | undefined): number {
+  if (!params) return 1
+  const match = params.match(/q\s*=\s*([0-9.]+)/)
+  if (!match) return 1
+  const q = parseFloat(match[1])
+  return isNaN(q) ? 1 : Math.min(Math.max(q, 0), 1)
+}
+
+function splitMediaTypeParams(
+  params: string,
+): { params: Record<string, string>; q: number } {
+  const result: Record<string, string> = {}
+  let q = 1
+
+  const parts = params.split(";")
+  for (const part of parts) {
+    const trimmed = part.trim()
+    const eqIndex = trimmed.indexOf("=")
+    if (eqIndex === -1) continue
+
+    const key = trimmed.slice(0, eqIndex).trim().toLowerCase()
+    let value = trimmed.slice(eqIndex + 1).trim()
+
+    if (value.startsWith("\"") && value.endsWith("\"")) {
+      value = value.slice(1, -1)
+    }
+
+    if (key === "q") {
+      q = parseFloat(value)
+      if (isNaN(q)) q = 1
+      q = Math.min(Math.max(q, 0), 1)
+    } else {
+      result[key] = value
+    }
+  }
+
+  return { params: result, q }
+}
+
+function parseAccept(
+  accept: string,
+): Array<
+  {
+    type: string
+    subtype: string
+    params: Record<string, string>
+    q: number
+    o: number
+  }
+> {
+  const specs: Array<{
+    type: string
+    subtype: string
+    params: Record<string, string>
+    q: number
+    o: number
+  }> = []
+  const parts = accept.split(",")
+
+  for (let o = 0; o < parts.length; o++) {
+    const part = parts[o].trim()
+    if (!part) continue
+
+    const match = simpleMediaTypeRegExp.exec(part)
+    if (!match) continue
+
+    const type = match[1].toLowerCase()
+    const subtype = match[2].toLowerCase()
+    const { params, q } = match[3]
+      ? splitMediaTypeParams(match[3])
+      : { params: {}, q: 1 }
+
+    if (q > 0) {
+      specs.push({ type, subtype, params, q, o })
+    }
+  }
+
+  return specs
+}
+
+function specifyMediaType(
+  type: string,
+  subtype: string,
+  params: Record<string, string>,
+  spec: {
+    type: string
+    subtype: string
+    params: Record<string, string>
+    q: number
+    o: number
+  },
+): { q: number; s: number; o: number } | null {
+  let s = 0
+
+  if (spec.type === type) {
+    s |= 4
+  } else if (spec.type !== "*") {
+    return null
+  }
+
+  if (spec.subtype === subtype) {
+    s |= 2
+  } else if (spec.subtype !== "*") {
+    return null
+  }
+
+  const specParams = Object.keys(spec.params)
+  if (specParams.length > 0) {
+    if (
+      specParams.every(
+        (key) =>
+          spec.params[key].toLowerCase() === (params[key] || "").toLowerCase(),
+      )
+    ) {
+      s |= 1
+    } else {
+      return null
+    }
+  }
+
+  return { q: spec.q, s, o: spec.o }
+}
+
+function getMediaTypePriority(
+  mediaType: string,
+  accepted: Array<
+    {
+      type: string
+      subtype: string
+      params: Record<string, string>
+      q: number
+      o: number
+    }
+  >,
+  index: number,
+): ParsedSpec {
+  let best: { q: number; s: number; o: number } | null = null
+
+  const match = simpleMediaTypeRegExp.exec(mediaType)
+  if (!match) {
+    return { value: mediaType, q: 0, s: 0, o: -1, i: index }
+  }
+
+  const type = match[1].toLowerCase()
+  const subtype = match[2].toLowerCase()
+  const { params } = match[3]
+    ? splitMediaTypeParams(match[3])
+    : { params: {} }
+
+  for (const spec of accepted) {
+    const result = specifyMediaType(type, subtype, params, spec)
+    if (
+      result
+      && (best === null
+        || result.s > best.s
+        || (result.s === best.s && result.q > best.q)
+        || (result.s === best.s && result.q === best.q && result.o < best.o))
+    ) {
+      best = result
+    }
+  }
+
+  return {
+    value: mediaType,
+    q: best?.q ?? 0,
+    s: best?.s ?? 0,
+    o: best?.o ?? -1,
+    i: index,
+  }
+}
+
+function parseAcceptLanguage(
+  accept: string,
+): Array<{ prefix: string; suffix: string | undefined; q: number; o: number }> {
+  const specs: Array<{
+    prefix: string
+    suffix: string | undefined
+    q: number
+    o: number
+  }> = []
+  const parts = accept.split(",")
+
+  for (let o = 0; o < parts.length; o++) {
+    const part = parts[o].trim()
+    if (!part) continue
+
+    const match = simpleLanguageRegExp.exec(part)
+    if (!match) continue
+
+    const prefix = match[1].toLowerCase()
+    const suffix = match[2]?.toLowerCase()
+    const q = parseQuality(match[3])
+
+    if (q > 0) {
+      specs.push({ prefix, suffix, q, o })
+    }
+  }
+
+  return specs
+}
+
+function specifyLanguage(
+  language: string,
+  spec: { prefix: string; suffix: string | undefined; q: number; o: number },
+): { q: number; s: number; o: number } | null {
+  const match = simpleLanguageRegExp.exec(language)
+  if (!match) return null
+
+  const prefix = match[1].toLowerCase()
+  const suffix = match[2]?.toLowerCase()
+
+  if (spec.prefix === "*") {
+    return { q: spec.q, s: 0, o: spec.o }
+  }
+
+  if (spec.prefix !== prefix) {
+    return null
+  }
+
+  if (spec.suffix === undefined) {
+    return { q: spec.q, s: suffix ? 2 : 4, o: spec.o }
+  }
+
+  if (spec.suffix === suffix) {
+    return { q: spec.q, s: 4, o: spec.o }
+  }
+
+  return null
+}
+
+function getLanguagePriority(
+  language: string,
+  accepted: Array<
+    { prefix: string; suffix: string | undefined; q: number; o: number }
+  >,
+  index: number,
+): ParsedSpec {
+  let best: { q: number; s: number; o: number } | null = null
+
+  for (const spec of accepted) {
+    const result = specifyLanguage(language, spec)
+    if (
+      result
+      && (best === null
+        || result.s > best.s
+        || (result.s === best.s && result.q > best.q)
+        || (result.s === best.s && result.q === best.q && result.o < best.o))
+    ) {
+      best = result
+    }
+  }
+
+  return {
+    value: language,
+    q: best?.q ?? 0,
+    s: best?.s ?? 0,
+    o: best?.o ?? -1,
+    i: index,
+  }
+}
+
+function parseAcceptEncoding(
+  accept: string,
+): Array<{ encoding: string; q: number; o: number }> {
+  const specs: Array<{ encoding: string; q: number; o: number }> = []
+  const parts = accept.split(",")
+  let hasIdentity = false
+
+  for (let o = 0; o < parts.length; o++) {
+    const part = parts[o].trim()
+    if (!part) continue
+
+    const match = simpleEncodingRegExp.exec(part)
+    if (!match) continue
+
+    const encoding = match[1].toLowerCase()
+    const q = parseQuality(match[2])
+
+    if (encoding === "identity") hasIdentity = true
+    if (encoding === "*") hasIdentity = true
+
+    if (q > 0) {
+      specs.push({ encoding, q, o })
+    }
+  }
+
+  if (!hasIdentity) {
+    specs.push({ encoding: "identity", q: 0.0001, o: specs.length })
+  }
+
+  return specs
+}
+
+function specifyEncoding(
+  encoding: string,
+  spec: { encoding: string; q: number; o: number },
+): { q: number; s: number; o: number } | null {
+  const e = encoding.toLowerCase()
+  const s = spec.encoding
+
+  if (s === "*" || s === e) {
+    return { q: spec.q, s: s === e ? 1 : 0, o: spec.o }
+  }
+
+  return null
+}
+
+function getEncodingPriority(
+  encoding: string,
+  accepted: Array<{ encoding: string; q: number; o: number }>,
+  index: number,
+): ParsedSpec {
+  let best: { q: number; s: number; o: number } | null = null
+
+  for (const spec of accepted) {
+    const result = specifyEncoding(encoding, spec)
+    if (
+      result
+      && (best === null
+        || result.s > best.s
+        || (result.s === best.s && result.q > best.q)
+        || (result.s === best.s && result.q === best.q && result.o < best.o))
+    ) {
+      best = result
+    }
+  }
+
+  return {
+    value: encoding,
+    q: best?.q ?? 0,
+    s: best?.s ?? 0,
+    o: best?.o ?? -1,
+    i: index,
+  }
+}
+
+function parseAcceptCharset(
+  accept: string,
+): Array<{ charset: string; q: number; o: number }> {
+  const specs: Array<{ charset: string; q: number; o: number }> = []
+  const parts = accept.split(",")
+
+  for (let o = 0; o < parts.length; o++) {
+    const part = parts[o].trim()
+    if (!part) continue
+
+    const match = simpleCharsetRegExp.exec(part)
+    if (!match) continue
+
+    const charset = match[1].toLowerCase()
+    const q = parseQuality(match[2])
+
+    if (q > 0) {
+      specs.push({ charset, q, o })
+    }
+  }
+
+  return specs
+}
+
+function specifyCharset(
+  charset: string,
+  spec: { charset: string; q: number; o: number },
+): { q: number; s: number; o: number } | null {
+  const c = charset.toLowerCase()
+  const s = spec.charset
+
+  if (s === "*" || s === c) {
+    return { q: spec.q, s: s === c ? 1 : 0, o: spec.o }
+  }
+
+  return null
+}
+
+function getCharsetPriority(
+  charset: string,
+  accepted: Array<{ charset: string; q: number; o: number }>,
+  index: number,
+): ParsedSpec {
+  let best: { q: number; s: number; o: number } | null = null
+
+  for (const spec of accepted) {
+    const result = specifyCharset(charset, spec)
+    if (
+      result
+      && (best === null
+        || result.s > best.s
+        || (result.s === best.s && result.q > best.q)
+        || (result.s === best.s && result.q === best.q && result.o < best.o))
+    ) {
+      best = result
+    }
+  }
+
+  return {
+    value: charset,
+    q: best?.q ?? 0,
+    s: best?.s ?? 0,
+    o: best?.o ?? -1,
+    i: index,
+  }
+}
+
+function compareSpecs(a: ParsedSpec, b: ParsedSpec): number {
+  return (
+    b.q - a.q
+    || b.s - a.s
+    || a.o - b.o
+    || a.i - b.i
+  )
+}
+
+export function media(accept: string, available?: string[]): string[] {
+  const parsed = parseAccept(accept)
+  if (parsed.length === 0) {
+    return []
+  }
+
+  if (!available) {
+    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) =>
+      `${p.type}/${p.subtype}`
+    )
+  }
+
+  const priorities = available.map((t, i) => getMediaTypePriority(t, parsed, i))
+  const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs)
+
+  return sorted.map((p) => p.value)
+}
+
+export function language(accept: string, available?: string[]): string[] {
+  const parsed = parseAcceptLanguage(accept)
+  if (parsed.length === 0) {
+    return []
+  }
+
+  if (!available) {
+    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) =>
+      p.suffix ? `${p.prefix}-${p.suffix}` : p.prefix
+    )
+  }
+
+  const priorities = available.map((l, i) => getLanguagePriority(l, parsed, i))
+  const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs)
+
+  return sorted.map((p) => p.value)
+}
+
+export function encoding(accept: string, available?: string[]): string[] {
+  const parsed = parseAcceptEncoding(accept)
+  if (parsed.length === 0) {
+    return []
+  }
+
+  if (!available) {
+    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => p.encoding)
+  }
+
+  const priorities = available.map((e, i) => getEncodingPriority(e, parsed, i))
+  const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs)
+
+  return sorted.map((p) => p.value)
+}
+
+export function charset(accept: string, available?: string[]): string[] {
+  const parsed = parseAcceptCharset(accept)
+  if (parsed.length === 0) {
+    return []
+  }
+
+  if (!available) {
+    return parsed.sort((a, b) => b.q - a.q || a.o - b.o).map((p) => p.charset)
+  }
+
+  const priorities = available.map((c, i) => getCharsetPriority(c, parsed, i))
+  const sorted = priorities.filter((p) => p.q > 0).sort(compareSpecs)
+
+  return sorted.map((p) => p.value)
+}
+
+export function headerMedia(
+  headers: Headers.Headers,
+  available?: string[],
+): string[] {
+  const accept = headers["accept"]
+  if (!accept) return []
+  return media(accept, available)
+}
+
+export function headerLanguage(
+  headers: Headers.Headers,
+  available?: string[],
+): string[] {
+  const accept = headers["accept-language"]
+  if (!accept) return []
+  return language(accept, available)
+}
+
+export function headerEncoding(
+  headers: Headers.Headers,
+  available?: string[],
+): string[] {
+  const accept = headers["accept-encoding"]
+  if (!accept) return []
+  return encoding(accept, available)
+}
+
+export function headerCharset(
+  headers: Headers.Headers,
+  available?: string[],
+): string[] {
+  const accept = headers["accept-charset"]
+  if (!accept) return []
+  return charset(accept, available)
+}

package/src/FileRouter.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import type { PlatformError } from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
 import * as Array from "effect/Array"
@@ -12,11 +13,9 @@ import * as NUrl from "node:url"
 import * as FileRouterCodegen from "./FileRouterCodegen.ts"
 import * as FileRouterPattern from "./FileRouterPattern.ts"
 import * as FileSystemExtra from "./FileSystemExtra.ts"
-import * as Route from "./Route.ts"
-import * as Router from "./Router.ts"
 
 export type RouteModule = {
-  default: Route.RouteSet.Default
+  default: RouteSet.RouteSet.Default
 }
 
 export type LazyRoute = {
@@ -187,7 +186,9 @@ export function fromManifest(
   manifest: Manifest,
 ): Effect.Effect<Router.Router.Any> {
   return Effect.gen(function*() {
-    const loadedEntries = yield* Effect.forEach(
+    const mounts: Record<`/${string}`, RouteSet.RouteSet.Default> = {}
+
+    yield* Effect.forEach(
       manifest.routes,
       (lazyRoute) =>
         Effect.gen(function*() {
@@ -199,19 +200,22 @@ export function fromManifest(
             )
             : []
 
-          const layers = layerModules
-            .map((m: any) => m.default)
-            .filter(Route.isRouteLayer)
+          // Start with the route from the route module
+          let mergedRouteSet: RouteSet.RouteSet.Default = routeModule.default
 
-          return {
-            path: lazyRoute.path,
-            route: routeModule.default,
-            layers,
+          // Concatenate each layer's routes into the routeSet
+          for (const m of layerModules) {
+            const layerRouteSet = (m as any).default
+            if (RouteSet.isRouteSet(layerRouteSet)) {
+              mergedRouteSet = Route.merge(layerRouteSet, mergedRouteSet)
+            }
           }
+
+          mounts[lazyRoute.path] = mergedRouteSet
         }),
     )
 
-    return Router.make(loadedEntries, [])
+    return Router.make(mounts, RouteSet.make())
   })
 }