effect-start 0.20.1 → 0.22.0

package/README.md

@@ -14,10 +14,7 @@ by checking out `examples/` directory.
 It exports a layer that applies configuration and changes the behavior of the server:
 
 ```typescript
-import {
-  FileRouter,
-  Start,
-} from "effect-start"
+import { FileRouter, Start } from "effect-start"
 
 export default Start.layer(
   FileRouter.layer({

package/dist/Cookies.js

@@ -0,0 +1,392 @@
+/*
+ * 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"
+
+export const TypeId = Symbol.for(
+  "effect-start/Cookies",
+)
+
+export const isCookies = (u) =>
+  Predicate.hasProperty(u, TypeId)
+
+export const CookieTypeId = Symbol.for(
+  "effect-start/Cookies/Cookie",
+)
+
+const CookiesProto = {
+  [TypeId]: TypeId,
+  ...Inspectable.BaseProto,
+  toJSON() {
+    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() {
+    return {
+      _id: "effect-start/Cookies/Cookie",
+      name: this.name,
+      value: this.value,
+      options: this.options,
+    }
+  },
+}
+
+const makeCookiesFromRecord = (
+  cookies,
+) => {
+  const self = Object.create(CookiesProto)
+  self.cookies = cookies
+  return self
+}
+
+const cookieFromParts = (
+  name,
+  value,
+  valueEncoded,
+  options,
+) =>
+  Object.assign(Object.create(CookieProto), {
+    name,
+    value,
+    valueEncoded,
+    options,
+  })
+
+export const empty = makeCookiesFromRecord({})
+
+export const fromIterable = (cookies) => {
+  const record = {}
+  for (const cookie of cookies) {
+    record[cookie.name] = cookie
+  }
+  return makeCookiesFromRecord(record)
+}
+
+export const fromSetCookie = (
+  headers,
+) => {
+  const arrayHeaders = typeof headers === "string" ? [headers] : headers
+  const cookies = []
+  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,
+  value,
+  options,
+) => cookieFromParts(name, value, encodeURIComponent(value), options)
+
+export const isEmpty = (self) => {
+  for (const _ in self.cookies) return false
+  return true
+}
+
+export const get = (
+  self,
+  name,
+) =>
+  name in self.cookies ? Option.some(self.cookies[name]) : Option.none()
+
+export const getValue = (
+  self,
+  name,
+) =>
+  Option.map(get(self, name), (cookie) => cookie.value)
+
+export const setCookie = (self, cookie) =>
+  makeCookiesFromRecord({ ...self.cookies, [cookie.name]: cookie })
+
+export const unsafeSet = (
+  self,
+  name,
+  value,
+  options,
+) => setCookie(self, unsafeMakeCookie(name, value, options))
+
+export const unsafeSetAll = (
+  self,
+  cookies,
+) => {
+  const record = { ...self.cookies }
+  for (const [name, value, options] of cookies) {
+    record[name] = unsafeMakeCookie(name, value, options)
+  }
+  return makeCookiesFromRecord(record)
+}
+
+export const remove = (self, name) => {
+  const { [name]: _, ...rest } = self.cookies
+  return makeCookiesFromRecord(rest)
+}
+
+export const merge = (self, that) =>
+  makeCookiesFromRecord({ ...self.cookies, ...that.cookies })
+
+export function serializeCookie(self) {
+  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) =>
+  Object
+    .values(self.cookies)
+    .map((cookie) => `${cookie.name}=${cookie.valueEncoded}`)
+    .join("; ")
+
+export const toRecord = (self) => {
+  const record = {}
+  for (const cookie of Object.values(self.cookies)) {
+    record[cookie.name] = cookie.value
+  }
+  return record
+}
+
+export const toSetCookieHeaders = (self) =>
+  Object.values(self.cookies).map(serializeCookie)
+
+export function parseHeader(header) {
+  const result = {}
+
+  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) {
+  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 = {}
+
+  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) => {
+  try {
+    return decodeURIComponent(str)
+  } catch {
+    return str
+  }
+}

package/dist/FileSystem.js

@@ -0,0 +1,131 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Brand from "effect/Brand"
+import * as Channel from "effect/Channel"
+import * as Chunk from "effect/Chunk"
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as Option from "effect/Option"
+import * as Sink from "effect/Sink"
+import * as Stream from "effect/Stream"
+import * as PlatformError from "./PlatformError.js"
+
+export const FileSystem = Context.GenericTag(
+  "@effect/platform/FileSystem",
+)
+
+export const Size = (bytes) =>
+  typeof bytes === "bigint" ? bytes : BigInt(bytes)
+
+export const FileTypeId = Symbol.for("@effect/platform/FileSystem/File")
+
+export const FileDescriptor = Brand.nominal()
+
+export const WatchEventCreate = Data.tagged(
+  "Create",
+)
+
+export const WatchEventUpdate = Data.tagged(
+  "Update",
+)
+
+export const WatchEventRemove = Data.tagged(
+  "Remove",
+)
+
+export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")() {}
+
+export const make = (
+  impl,
+) => {
+  return FileSystem.of({
+    ...impl,
+    exists: (path) =>
+      Function.pipe(
+        impl.access(path),
+        Effect.as(true),
+        Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e)),
+      ),
+    readFileString: (path, encoding) =>
+      Effect.tryMap(impl.readFile(path), {
+        try: (_) => new TextDecoder(encoding).decode(_),
+        catch: (cause) =>
+          new PlatformError.BadArgument({
+            module: "FileSystem",
+            method: "readFileString",
+            description: "invalid encoding",
+            cause,
+          }),
+      }),
+    stream: (path, options) =>
+      Function.pipe(
+        impl.open(path, { flag: "r" }),
+        options?.offset
+          ? Effect.tap((file) => file.seek(options.offset, "start"))
+          : Function.identity,
+        Effect.map((file) => fileStream(file, options)),
+        Stream.unwrapScoped,
+      ),
+    sink: (path, options) =>
+      Function.pipe(
+        impl.open(path, { flag: "w", ...options }),
+        Effect.map((file) => Sink.forEach((_) => file.writeAll(_))),
+        Sink.unwrapScoped,
+      ),
+    writeFileString: (path, data, options) =>
+      Effect.flatMap(
+        Effect.try({
+          try: () => new TextEncoder().encode(data),
+          catch: (cause) =>
+            new PlatformError.BadArgument({
+              module: "FileSystem",
+              method: "writeFileString",
+              description: "could not encode string",
+              cause,
+            }),
+        }),
+        (_) => impl.writeFile(path, _, options),
+      ),
+  })
+}
+
+const fileStream = (file, {
+  bufferSize = 16,
+  bytesToRead: bytesToRead_,
+  chunkSize: chunkSize_ = Size(64 * 1024),
+} = {}) => {
+  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
+  const chunkSize = Size(chunkSize_)
+
+  function loop(
+    totalBytesRead,
+  ) {
+    if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
+      return Channel.void
+    }
+
+    const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
+      ? bytesToRead - totalBytesRead
+      : chunkSize
+
+    return Channel.flatMap(
+      file.readAlloc(toRead),
+      Option.match({
+        onNone: () => Channel.void,
+        onSome: (buf) =>
+          Channel.flatMap(
+            Channel.write(Chunk.of(buf)),
+            () => loop(totalBytesRead + BigInt(buf.length)),
+          ),
+      }),
+    )
+  }
+
+  return Stream.bufferChunks(
+    Stream.fromChannel(loop(BigInt(0))),
+    { capacity: bufferSize },
+  )
+}

package/dist/Socket.js

@@ -0,0 +1,37 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Predicate from "effect/Predicate"
+import * as PlatformError from "./PlatformError.js"
+
+export const SocketErrorTypeId = Symbol.for("@effect/platform/Socket/SocketError")
+
+export const isSocketError = (u) =>
+  Predicate.hasProperty(u, SocketErrorTypeId)
+
+export class SocketGenericError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError") {
+  get message() {
+    return `An error occurred during ${this.reason}`
+  }
+}
+
+export class SocketCloseError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError") {
+  static is(u) {
+    return isSocketError(u) && u.reason === "Close"
+  }
+
+  static isClean(isClean) {
+    return function(u) {
+      return SocketCloseError.is(u) && isClean(u.code)
+    }
+  }
+
+  get message() {
+    if (this.closeReason) {
+      return `${this.reason}: ${this.code}: ${this.closeReason}`
+    }
+    return `${this.reason}: ${this.code}`
+  }
+}
+
+export const defaultCloseCodeIsError = (code) => code !== 1000 && code !== 1006