effect-start 0.20.1 → 0.22.0

package/src/Cookies.ts

@@ -0,0 +1,408 @@
+/*
+ * Minimal Cookies management adapted from @effect/platform
+ * We'll aim for full compatbility when it stabilizes.
+ */
+import * as Duration from "effect/Duration"
+import * as Inspectable from "effect/Inspectable"
+import * as Option from "effect/Option"
+import * as Pipeable from "effect/Pipeable"
+import * as Predicate from "effect/Predicate"
+import type * as Types from "effect/Types"
+
+export const TypeId: unique symbol = Symbol.for("effect-start/Cookies")
+
+export type TypeId = typeof TypeId
+
+export const isCookies = (u: unknown): u is Cookies => Predicate.hasProperty(u, TypeId)
+
+export interface Cookies extends Pipeable.Pipeable, Inspectable.Inspectable {
+  readonly [TypeId]: TypeId
+  readonly cookies: Record<string, Cookie>
+}
+
+export const CookieTypeId: unique symbol = Symbol.for("effect-start/Cookies/Cookie")
+
+export type CookieTypeId = typeof CookieTypeId
+
+export interface Cookie extends Inspectable.Inspectable {
+  readonly [CookieTypeId]: CookieTypeId
+  readonly name: string
+  readonly value: string
+  readonly valueEncoded: string
+  readonly options?:
+    | {
+        readonly domain?: string | undefined
+        readonly expires?: Date | undefined
+        readonly maxAge?: Duration.DurationInput | undefined
+        readonly path?: string | undefined
+        readonly priority?: "low" | "medium" | "high" | undefined
+        readonly httpOnly?: boolean | undefined
+        readonly secure?: boolean | undefined
+        readonly partitioned?: boolean | undefined
+        readonly sameSite?:
+          // send with top-level navigations and GET requests from third-party sites
+          | "lax"
+          // only send with same-site requests
+          | "strict"
+          // send with all requests (requires Secure)
+          | "none"
+          | undefined
+      }
+    | undefined
+}
+
+const CookiesProto: Omit<Cookies, "cookies"> = {
+  [TypeId]: TypeId,
+  ...Inspectable.BaseProto,
+  toJSON(this: Cookies) {
+    return {
+      _id: "effect-start/Cookies",
+      cookies: Object.fromEntries(Object.entries(this.cookies).map(([k, v]) => [k, v.toJSON()])),
+    }
+  },
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+}
+
+const CookieProto = {
+  [CookieTypeId]: CookieTypeId,
+  ...Inspectable.BaseProto,
+  toJSON(this: Cookie) {
+    return {
+      _id: "effect-start/Cookies/Cookie",
+      name: this.name,
+      value: this.value,
+      options: this.options,
+    }
+  },
+}
+
+const makeCookiesFromRecord = (cookies: Record<string, Cookie>): Cookies => {
+  const self = Object.create(CookiesProto)
+  self.cookies = cookies
+  return self
+}
+
+const cookieFromParts = (
+  name: string,
+  value: string,
+  valueEncoded: string,
+  options?: Cookie["options"],
+): Cookie =>
+  Object.assign(Object.create(CookieProto), {
+    name,
+    value,
+    valueEncoded,
+    options,
+  })
+
+export const empty: Cookies = makeCookiesFromRecord({})
+
+export const fromIterable = (cookies: Iterable<Cookie>): Cookies => {
+  const record: Record<string, Cookie> = {}
+  for (const cookie of cookies) {
+    record[cookie.name] = cookie
+  }
+  return makeCookiesFromRecord(record)
+}
+
+export const fromSetCookie = (headers: Iterable<string> | string): Cookies => {
+  const arrayHeaders = typeof headers === "string" ? [headers] : headers
+  const cookies: Array<Cookie> = []
+  for (const header of arrayHeaders) {
+    const cookie = parseSetCookie(header.trim())
+    if (Option.isSome(cookie)) {
+      cookies.push(cookie.value)
+    }
+  }
+  return fromIterable(cookies)
+}
+
+export const unsafeMakeCookie = (
+  name: string,
+  value: string,
+  options?: Cookie["options"] | undefined,
+): Cookie => cookieFromParts(name, value, encodeURIComponent(value), options)
+
+export const isEmpty = (self: Cookies): boolean => {
+  for (const _ in self.cookies) return false
+  return true
+}
+
+export const get = (self: Cookies, name: string): Option.Option<Cookie> =>
+  name in self.cookies ? Option.some(self.cookies[name]) : Option.none()
+
+export const getValue = (self: Cookies, name: string): Option.Option<string> =>
+  Option.map(get(self, name), (cookie) => cookie.value)
+
+export const setCookie = (self: Cookies, cookie: Cookie): Cookies =>
+  makeCookiesFromRecord({ ...self.cookies, [cookie.name]: cookie })
+
+export const unsafeSet = (
+  self: Cookies,
+  name: string,
+  value: string,
+  options?: Cookie["options"],
+): Cookies => setCookie(self, unsafeMakeCookie(name, value, options))
+
+export const unsafeSetAll = (
+  self: Cookies,
+  cookies: Iterable<readonly [name: string, value: string, options?: Cookie["options"]]>,
+): Cookies => {
+  const record: Record<string, Cookie> = { ...self.cookies }
+  for (const [name, value, options] of cookies) {
+    record[name] = unsafeMakeCookie(name, value, options)
+  }
+  return makeCookiesFromRecord(record)
+}
+
+export const remove = (self: Cookies, name: string): Cookies => {
+  const { [name]: _, ...rest } = self.cookies
+  return makeCookiesFromRecord(rest)
+}
+
+export const merge = (self: Cookies, that: Cookies): Cookies =>
+  makeCookiesFromRecord({ ...self.cookies, ...that.cookies })
+
+export function serializeCookie(self: Cookie): string {
+  let str = self.name + "=" + self.valueEncoded
+
+  if (self.options === undefined) {
+    return str
+  }
+  const options = self.options
+
+  if (options.maxAge !== undefined) {
+    const maxAge = Duration.toSeconds(options.maxAge)
+    str += "; Max-Age=" + Math.trunc(maxAge)
+  }
+
+  if (options.domain !== undefined) {
+    str += "; Domain=" + options.domain
+  }
+
+  if (options.path !== undefined) {
+    str += "; Path=" + options.path
+  }
+
+  if (options.priority !== undefined) {
+    switch (options.priority) {
+      case "low":
+        str += "; Priority=Low"
+        break
+      case "medium":
+        str += "; Priority=Medium"
+        break
+      case "high":
+        str += "; Priority=High"
+        break
+    }
+  }
+
+  if (options.expires !== undefined) {
+    str += "; Expires=" + options.expires.toUTCString()
+  }
+
+  if (options.httpOnly) {
+    str += "; HttpOnly"
+  }
+
+  if (options.secure) {
+    str += "; Secure"
+  }
+
+  if (options.partitioned) {
+    str += "; Partitioned"
+  }
+
+  if (options.sameSite !== undefined) {
+    switch (options.sameSite) {
+      case "lax":
+        str += "; SameSite=Lax"
+        break
+      case "strict":
+        str += "; SameSite=Strict"
+        break
+      case "none":
+        str += "; SameSite=None"
+        break
+    }
+  }
+
+  return str
+}
+
+export const toCookieHeader = (self: Cookies): string =>
+  Object.values(self.cookies)
+    .map((cookie) => `${cookie.name}=${cookie.valueEncoded}`)
+    .join("; ")
+
+export const toRecord = (self: Cookies): Record<string, string> => {
+  const record: Record<string, string> = {}
+  for (const cookie of Object.values(self.cookies)) {
+    record[cookie.name] = cookie.value
+  }
+  return record
+}
+
+export const toSetCookieHeaders = (self: Cookies): Array<string> =>
+  Object.values(self.cookies).map(serializeCookie)
+
+export function parseHeader(header: string): Record<string, string> {
+  const result: Record<string, string> = {}
+
+  const strLen = header.length
+  let pos = 0
+  let terminatorPos = 0
+
+  while (true) {
+    if (terminatorPos === strLen) break
+    terminatorPos = header.indexOf(";", pos)
+    if (terminatorPos === -1) terminatorPos = strLen
+
+    let eqIdx = header.indexOf("=", pos)
+    if (eqIdx === -1) break
+    if (eqIdx > terminatorPos) {
+      pos = terminatorPos + 1
+      continue
+    }
+
+    const key = header.substring(pos, eqIdx++).trim()
+    if (result[key] === undefined) {
+      const val =
+        header.charCodeAt(eqIdx) === 0x22
+          ? header.substring(eqIdx + 1, terminatorPos - 1).trim()
+          : header.substring(eqIdx, terminatorPos).trim()
+
+      result[key] = !(val.indexOf("%") === -1) ? tryDecodeURIComponent(val) : val
+    }
+
+    pos = terminatorPos + 1
+  }
+
+  return result
+}
+
+// eslint-disable-next-line no-control-regex
+const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/
+
+function parseSetCookie(header: string): Option.Option<Cookie> {
+  const parts = header
+    .split(";")
+    .map((_) => _.trim())
+    .filter((_) => _ !== "")
+  if (parts.length === 0) {
+    return Option.none()
+  }
+
+  const firstEqual = parts[0].indexOf("=")
+  if (firstEqual === -1) {
+    return Option.none()
+  }
+  const name = parts[0].slice(0, firstEqual)
+  if (!fieldContentRegExp.test(name)) {
+    return Option.none()
+  }
+
+  const valueEncoded = parts[0].slice(firstEqual + 1)
+  const value = tryDecodeURIComponent(valueEncoded)
+
+  if (parts.length === 1) {
+    return Option.some(cookieFromParts(name, value, valueEncoded))
+  }
+
+  const options: Types.Mutable<Cookie["options"]> = {}
+
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i]
+    const equalIndex = part.indexOf("=")
+    const key = equalIndex === -1 ? part : part.slice(0, equalIndex).trim()
+    const value = equalIndex === -1 ? undefined : part.slice(equalIndex + 1).trim()
+
+    switch (key.toLowerCase()) {
+      case "domain": {
+        if (value === undefined) break
+        const domain = value.trim().replace(/^\./, "")
+        if (domain) options.domain = domain
+        break
+      }
+      case "expires": {
+        if (value === undefined) break
+        const date = new Date(value)
+        if (!isNaN(date.getTime())) options.expires = date
+        break
+      }
+      case "max-age": {
+        if (value === undefined) break
+        const maxAge = parseInt(value, 10)
+        if (!isNaN(maxAge)) options.maxAge = Duration.seconds(maxAge)
+        break
+      }
+      case "path": {
+        if (value === undefined) break
+        if (value[0] === "/") options.path = value
+        break
+      }
+      case "priority": {
+        if (value === undefined) break
+        switch (value.toLowerCase()) {
+          case "low":
+            options.priority = "low"
+            break
+          case "medium":
+            options.priority = "medium"
+            break
+          case "high":
+            options.priority = "high"
+            break
+        }
+        break
+      }
+      case "httponly": {
+        options.httpOnly = true
+        break
+      }
+      case "secure": {
+        options.secure = true
+        break
+      }
+      case "partitioned": {
+        options.partitioned = true
+        break
+      }
+      case "samesite": {
+        if (value === undefined) break
+        switch (value.toLowerCase()) {
+          case "lax":
+            options.sameSite = "lax"
+            break
+          case "strict":
+            options.sameSite = "strict"
+            break
+          case "none":
+            options.sameSite = "none"
+            break
+        }
+        break
+      }
+    }
+  }
+
+  return Option.some(
+    cookieFromParts(
+      name,
+      value,
+      valueEncoded,
+      Object.keys(options).length > 0 ? options : undefined,
+    ),
+  )
+}
+
+const tryDecodeURIComponent = (str: string): string => {
+  try {
+    return decodeURIComponent(str)
+  } catch {
+    return str
+  }
+}

package/src/Development.ts

@@ -1,4 +1,4 @@
-import * as FileSystem from "@effect/platform/FileSystem"
+import * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
@@ -7,21 +7,18 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as PubSub from "effect/PubSub"
 import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.ts"
+import type * as PlatformError from "./PlatformError.ts"
 
 export type DevelopmentEvent =
   | FileSystem.WatchEvent
   | {
-    readonly _tag: "Reload"
-  }
+      readonly _tag: "Reload"
+    }
 
-const devState = GlobalValue.globalValue(
-  Symbol.for("effect-start/Development"),
-  () => ({
-    count: 0,
-    pubsub: null as PubSub.PubSub<DevelopmentEvent> | null,
-  }),
-)
+const devState = GlobalValue.globalValue(Symbol.for("effect-start/Development"), () => ({
+  count: 0,
+  pubsub: null as PubSub.PubSub<DevelopmentEvent> | null,
+}))
 
 /** @internal */
 export const _resetForTesting = () => {
@@ -48,25 +45,18 @@ export const filterDirectory = (event: FileSystem.WatchEvent): boolean => {
   return event.path.endsWith("/")
 }
 
-export const watchSource = (
-  opts?: {
-    path?: string
-    recursive?: boolean
-    filter?: (event: FileSystem.WatchEvent) => boolean
-  },
-): Stream.Stream<
-  FileSystem.WatchEvent,
-  PlatformError.PlatformError,
-  FileSystem.FileSystem
-> => {
+export const watchSource = (opts?: {
+  path?: string
+  recursive?: boolean
+  filter?: (event: FileSystem.WatchEvent) => boolean
+}): Stream.Stream<FileSystem.WatchEvent, PlatformError.PlatformError, FileSystem.FileSystem> => {
   const baseDir = opts?.path ?? process.cwd()
   const customFilter = opts?.filter
 
   return Function.pipe(
     Stream.unwrap(
-      Effect.map(
-        FileSystem.FileSystem,
-        fs => fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
+      Effect.map(FileSystem.FileSystem, (fs) =>
+        fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
       ),
     ),
     customFilter ? Stream.filter(customFilter) : Function.identity,
@@ -80,44 +70,39 @@ export const watchSource = (
   )
 }
 
-export const watch = (
-  opts?: {
-    path?: string
-    recursive?: boolean
-    filter?: (event: FileSystem.WatchEvent) => boolean
-  },
-) =>
-  Effect
-    .gen(function*() {
-      devState.count++
-
-      if (devState.count === 1) {
-        const pubsub = yield* PubSub.unbounded<DevelopmentEvent>()
-        devState.pubsub = pubsub
-
-        yield* Function.pipe(
-          watchSource({
-            path: opts?.path,
-            recursive: opts?.recursive,
-            filter: opts?.filter ?? filterSourceFiles,
-          }),
-          Stream.runForEach((event) => PubSub.publish(pubsub, event)),
-          Effect.fork,
-        )
-      } else {
-        yield* PubSub.publish(devState.pubsub!, { _tag: "Reload" })
-      }
-
-      return { events: devState.pubsub! } satisfies DevelopmentService
-    })
-
-export const layerWatch = (
-  opts?: {
-    path?: string
-    recursive?: boolean
-    filter?: (event: FileSystem.WatchEvent) => boolean
-  },
-) => Layer.scoped(Development, watch(opts))
+export const watch = (opts?: {
+  path?: string
+  recursive?: boolean
+  filter?: (event: FileSystem.WatchEvent) => boolean
+}) =>
+  Effect.gen(function* () {
+    devState.count++
+
+    if (devState.count === 1) {
+      const pubsub = yield* PubSub.unbounded<DevelopmentEvent>()
+      devState.pubsub = pubsub
+
+      yield* Function.pipe(
+        watchSource({
+          path: opts?.path,
+          recursive: opts?.recursive,
+          filter: opts?.filter ?? filterSourceFiles,
+        }),
+        Stream.runForEach((event) => PubSub.publish(pubsub, event)),
+        Effect.fork,
+      )
+    } else {
+      yield* PubSub.publish(devState.pubsub!, { _tag: "Reload" })
+    }
+
+    return { events: devState.pubsub! } satisfies DevelopmentService
+  })
+
+export const layerWatch = (opts?: {
+  path?: string
+  recursive?: boolean
+  filter?: (event: FileSystem.WatchEvent) => boolean
+}) => Layer.scoped(Development, watch(opts))
 
 export const stream = (): Stream.Stream<DevelopmentEvent> =>
   Stream.unwrap(