effect-start 0.25.0 → 0.26.0

package/dist/experimental/EncryptedCookies.js

@@ -1,328 +0,0 @@
-import * as Cookies from "../Cookies.js"
-import * as Config from "effect/Config"
-import * as Context from "effect/Context"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Layer from "effect/Layer"
-
-export class EncryptedCookiesError extends Data.TaggedError("EncryptedCookiesError") {}
-
-export class EncryptedCookies extends Context.Tag("EncryptedCookies")() {}
-
-export function layer(options) {
-  return Layer.effect(
-    EncryptedCookies,
-    Effect.gen(function* () {
-      const keyMaterial = yield* deriveKeyMaterial(options.secret)
-
-      // Pre-derive both keys once
-      const encryptKey = yield* deriveKey(keyMaterial, ["encrypt"])
-      const decryptKey = yield* deriveKey(keyMaterial, ["decrypt"])
-
-      return EncryptedCookies.of({
-        encrypt: (value) => encryptWithDerivedKey(value, encryptKey),
-        decrypt: (encryptedValue) => decryptWithDerivedKey(encryptedValue, decryptKey),
-        encryptCookie: (cookie) => encryptCookieWithDerivedKey(cookie, encryptKey),
-        decryptCookie: (cookie) => decryptCookieWithDerivedKey(cookie, decryptKey),
-      })
-    }),
-  )
-}
-
-export function layerConfig(name = "SECRET_KEY_BASE") {
-  return Effect.gen(function* () {
-    const secret = yield* Config.nonEmptyString(name).pipe(
-      Effect.flatMap((value) => {
-        return value.length < 40 ? Effect.fail(new Error("ba")) : Effect.succeed(value)
-      }),
-      Effect.catchAll((err) => {
-        return Effect.dieMessage("SECRET_KEY_BASE must be at least 40 characters")
-      }),
-    )
-
-    return layer({ secret })
-  }).pipe(Layer.unwrapEffect)
-}
-
-function encodeToBase64Segments(
-  ciphertext,
-  iv,
-  authTag,
-) {
-  return [base64urlEncode(ciphertext), base64urlEncode(iv), base64urlEncode(authTag)].join(".")
-}
-
-function base64urlEncode(data) {
-  const base64 = btoa(String.fromCharCode(...data))
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
-}
-
-function decodeFromBase64Segments(
-  segments,
-) {
-  return Effect.gen(function* () {
-    const [ciphertextB64, ivB64, authTagB64] = segments
-
-    const ciphertext = yield* Effect.try({
-      try: () => base64urlDecode(ciphertextB64),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    const iv = yield* Effect.try({
-      try: () => base64urlDecode(ivB64),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    const authTag = yield* Effect.try({
-      try: () => base64urlDecode(authTagB64),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    return { ciphertext, iv, authTag }
-  })
-}
-
-function base64urlDecode(data) {
-  // Convert base64url back to standard base64
-  let base64 = data.replace(/-/g, "+").replace(/_/g, "/")
-
-  // Add padding if needed
-  while (base64.length % 4) {
-    base64 += "="
-  }
-
-  return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0))
-}
-
-/**
- * Encrypts cookie value using the SECRET_KEY_BASE.
- */
-function encryptWithDerivedKey(
-  value,
-  derivedKey,
-) {
-  return Effect.gen(function* () {
-    if (value === null || value === undefined) {
-      return yield* Effect.fail(
-        new EncryptedCookiesError({
-          cause: "Cannot encrypt empty value",
-        }),
-      )
-    }
-
-    const iv = crypto.getRandomValues(new Uint8Array(12))
-    const data = new TextEncoder().encode(JSON.stringify(value))
-
-    const encrypted = yield* Effect.tryPromise({
-      try: () => crypto.subtle.encrypt({ name: "AES-GCM", iv }, derivedKey, data),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    const encryptedArray = new Uint8Array(encrypted)
-    const authTagLength = 16
-    const ciphertext = encryptedArray.slice(0, -authTagLength)
-    const authTag = encryptedArray.slice(-authTagLength)
-
-    return encodeToBase64Segments(ciphertext, iv, authTag)
-  })
-}
-
-export function encrypt(
-  value,
-  options,
-) {
-  return Effect.gen(function* () {
-    if ("key" in options) {
-      return yield* encryptWithDerivedKey(value, options.key)
-    }
-
-    const keyMaterial = yield* deriveKeyMaterial(options.secret)
-    const derivedKey = yield* deriveKey(keyMaterial, ["encrypt"])
-    return yield* encryptWithDerivedKey(value, derivedKey)
-  })
-}
-
-function decryptWithDerivedKey(
-  encryptedValue,
-  derivedKey,
-) {
-  return Effect.gen(function* () {
-    if (!encryptedValue || encryptedValue === null || encryptedValue === undefined) {
-      return yield* Effect.fail(
-        new EncryptedCookiesError({
-          cause: "Cannot decrypt null, undefined, or empty value",
-        }),
-      )
-    }
-
-    const segments = encryptedValue.split(".")
-    if (segments.length !== 3) {
-      return yield* Effect.fail(
-        new EncryptedCookiesError({
-          cause: "Invalid encrypted cookie format",
-        }),
-      )
-    }
-
-    const { ciphertext, iv, authTag } = yield* decodeFromBase64Segments(segments)
-
-    const encryptedData = new Uint8Array(ciphertext.length + authTag.length)
-    encryptedData.set(ciphertext)
-    encryptedData.set(authTag, ciphertext.length)
-
-    const decrypted = yield* Effect.tryPromise({
-      try: () =>
-        crypto.subtle.decrypt({ name: "AES-GCM", iv: iv.slice(0) }, derivedKey, encryptedData),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    const jsonString = new TextDecoder().decode(decrypted)
-
-    return yield* Effect.try({
-      try: () => JSON.parse(jsonString),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-  })
-}
-
-function encryptCookieWithDerivedKey(
-  cookie,
-  derivedKey,
-) {
-  return Effect.gen(function* () {
-    const encryptedValue = yield* encryptWithDerivedKey(cookie.value, derivedKey).pipe(
-      Effect.mapError(
-        (error) =>
-          new EncryptedCookiesError({
-            cause: error.cause,
-            cookie,
-          }),
-      ),
-    )
-    return Cookies.unsafeMakeCookie(cookie.name, encryptedValue, cookie.options)
-  })
-}
-function decryptCookieWithDerivedKey(
-  cookie,
-  derivedKey,
-) {
-  return Effect.gen(function* () {
-    const decryptedValue = yield* decryptWithDerivedKey(cookie.value, derivedKey).pipe(
-      Effect.mapError(
-        (error) =>
-          new EncryptedCookiesError({
-            cause: error.cause,
-            cookie,
-          }),
-      ),
-    )
-    return Cookies.unsafeMakeCookie(cookie.name, JSON.stringify(decryptedValue), cookie.options)
-  })
-}
-
-export function encryptCookie(
-  cookie,
-  options,
-) {
-  return Effect.gen(function* () {
-    if ("key" in options) {
-      return yield* encryptCookieWithDerivedKey(cookie, options.key)
-    }
-
-    const encryptedValue = yield* encrypt(cookie.value, {
-      secret: options.secret,
-    }).pipe(
-      Effect.mapError(
-        (error) =>
-          new EncryptedCookiesError({
-            cause: error.cause,
-            cookie,
-          }),
-      ),
-    )
-    return Cookies.unsafeMakeCookie(cookie.name, encryptedValue, cookie.options)
-  })
-}
-
-export function decryptCookie(
-  cookie,
-  options,
-) {
-  return Effect.gen(function* () {
-    if ("key" in options) {
-      return yield* decryptCookieWithDerivedKey(cookie, options.key)
-    }
-
-    const decryptedValue = yield* decrypt(cookie.value, {
-      secret: options.secret,
-    }).pipe(
-      Effect.mapError(
-        (error) =>
-          new EncryptedCookiesError({
-            cause: error.cause,
-            cookie,
-          }),
-      ),
-    )
-    return Cookies.unsafeMakeCookie(cookie.name, JSON.stringify(decryptedValue), cookie.options)
-  })
-}
-
-export function decrypt(
-  encryptedValue,
-  options,
-) {
-  return Effect.gen(function* () {
-    if ("key" in options) {
-      return yield* decryptWithDerivedKey(encryptedValue, options.key)
-    }
-
-    const keyMaterial = yield* deriveKeyMaterial(options.secret)
-    const derivedKey = yield* deriveKey(keyMaterial, ["decrypt"])
-    return yield* decryptWithDerivedKey(encryptedValue, derivedKey)
-  })
-}
-
-function deriveKeyMaterial(secret) {
-  return Effect.gen(function* () {
-    const encoder = new TextEncoder()
-
-    const keyMaterial = yield* Effect.tryPromise({
-      try: () =>
-        crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HKDF" }, false, [
-          "deriveKey",
-        ]),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    return keyMaterial
-  })
-}
-
-function deriveKey(
-  keyMaterial,
-  usage,
-) {
-  return Effect.gen(function* () {
-    const encoder = new TextEncoder()
-
-    const key = yield* Effect.tryPromise({
-      try: () =>
-        crypto.subtle.deriveKey(
-          {
-            name: "HKDF",
-            salt: encoder.encode("cookie-encryption"),
-            info: encoder.encode("aes-256-gcm"),
-            hash: "SHA-256",
-          },
-          keyMaterial,
-          { name: "AES-GCM", length: 256 },
-          false,
-          usage,
-        ),
-      catch: (error) => new EncryptedCookiesError({ cause: error }),
-    })
-
-    return key
-  })
-}

package/dist/experimental/index.js

@@ -1 +0,0 @@
-export * as EncryptedCookies from "./EncryptedCookies.js"

package/dist/hyper/Hyper.js

@@ -1,28 +0,0 @@
-import * as Context from "effect/Context"
-import * as Fiber from "effect/Fiber"
-import * as Option from "effect/Option"
-
-export class Hyper extends Context.Tag("Hyper")() {}
-
-const NoChildren = Object.freeze([])
-
-export function h(type, props) {
-  return {
-    type,
-    props: {
-      ...props,
-      children: props.children ?? NoChildren,
-    },
-  }
-}
-
-export function unsafeUse(tag) {
-  const currentFiber = Option.getOrThrow(Fiber.getCurrentFiber())
-  const context = currentFiber.currentContext
-
-  return Context.unsafeGet(context, tag)
-}
-
-export function isGenericJsxObject(value) {
-  return typeof value === "object" && value !== null && "type" in value && "props" in value
-}

package/dist/hyper/HyperHtml.js

@@ -1,165 +0,0 @@
-/**
- * Renders Hyper JSX nodes to HTML.
- *
- * Effect Start comes with {@link Hyper} and {@link JsxRuntime} to enable
- * JSX support. The advantage of using JSX over HTML strings or templates
- * is type safety and better editor support.
- *
- * JSX nodes are compatible with React's and Solid's.
-
- * You can enable JSX support by updating `tsconfig.json`:
- *
- * {
- *   compilerOptions: {
- *     jsx: "react-jsx",
- *     jsxImportSource: "effect-start" | "react" | "praect" // etc.
- *   }
- * }
- */
-
-const EMPTY_TAGS = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "command",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "keygen",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr",
-]
-
-let esc = (str) => String(str).replace(/[&<>"']/g, (s) => `&${map[s]};`)
-let escSQ = (str) => String(str).replace(/[&<>']/g, (s) => `&${map[s]};`)
-let map = {
-  "&": "amp",
-  "<": "lt",
-  ">": "gt",
-  '"': "quot",
-  "'": "#39",
-}
-
-const RAW_TEXT_TAGS = ["script", "style"]
-
-export function renderToString(
-  node,
-  hooks,
-) {
-  const stack = [node]
-  let result = ""
-
-  while (stack.length > 0) {
-    const current = stack.pop()
-
-    if (typeof current === "string") {
-      if (current.startsWith("<") && current.endsWith(">")) {
-        // This is a closing tag, don't escape it
-        result += current
-      } else {
-        result += esc(current)
-      }
-      continue
-    }
-
-    if (typeof current === "number") {
-      result += esc(current)
-      continue
-    }
-
-    if (typeof current === "boolean") {
-      // React-like behavior: booleans render nothing
-      continue
-    }
-
-    if (current === null || current === undefined) {
-      // React-like behavior: null/undefined render nothing
-      continue
-    }
-
-    if (Array.isArray(current)) {
-      // Handle arrays by pushing all items to stack in reverse order
-      for (let i = current.length - 1; i >= 0; i--) {
-        stack.push(current[i])
-      }
-      continue
-    }
-
-    if (current && typeof current === "object" && current.type) {
-      hooks?.onNode?.(current)
-
-      if (typeof current.type === "function") {
-        const componentResult = current.type(current.props)
-        if (componentResult != null) {
-          stack.push(componentResult)
-        }
-        continue
-      }
-
-      const { type, props } = current
-      result += `<${type}`
-
-      for (const key in props) {
-        if (
-          key !== "children" &&
-          key !== "innerHTML" && // Solid-specific
-          key !== "dangerouslySetInnerHTML" && // React-specific
-          props[key] !== false &&
-          props[key] != null
-        ) {
-          if (props[key] === true) {
-            result += ` ${esc(key)}`
-          } else {
-            const resolvedKey = key === "className" ? "class" : key
-            const value = props[key]
-
-            if (key.startsWith("data-") && typeof value === "function") {
-              result += ` ${esc(resolvedKey)}="${esc(value.toString())}"`
-            } else if (key.startsWith("data-") && typeof value === "object") {
-              result += ` ${esc(resolvedKey)}='${escSQ(JSON.stringify(value))}'`
-            } else {
-              result += ` ${esc(resolvedKey)}="${esc(value)}"`
-            }
-          }
-        }
-      }
-
-      result += ">"
-
-      if (!EMPTY_TAGS.includes(type)) {
-        stack.push(`</${type}>`)
-
-        const html = props.dangerouslySetInnerHTML?.__html ?? props.innerHTML
-
-        if (html) {
-          result += html
-        } else {
-          const children = props.children
-
-          if (type === "script" && typeof children === "function") {
-            result += `(${children.toString()})(window)`
-          } else if (RAW_TEXT_TAGS.includes(type) && children != null) {
-            result += Array.isArray(children) ? children.join("") : children
-          } else if (Array.isArray(children)) {
-            for (let i = children.length - 1; i >= 0; i--) {
-              stack.push(children[i])
-            }
-          } else if (children != null) {
-            stack.push(children)
-          }
-        }
-      }
-    } else if (current && typeof current === "object") {
-      // Handle objects without type property - convert to string or ignore
-      // This prevents [object Object] from appearing
-      continue
-    }
-  }
-  return result
-}

package/dist/hyper/HyperNode.js

@@ -1,13 +0,0 @@
-export const TypeId = Symbol.for("effect-start/HyperNode")
-
-const NoChildren = Object.freeze([])
-
-export function make(type, props) {
-  return {
-    type,
-    props: {
-      ...props,
-      children: props.children ?? NoChildren,
-    },
-  }
-}

package/dist/hyper/HyperRoute.js

@@ -1,45 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as Entity from "../Entity.js"
-import * as Route from "../Route.js"
-import * as HyperHtml from "./HyperHtml.js"
-
-function renderValue(
-  value,
-) {
-  if (Entity.isEntity(value)) {
-    return Entity.make(HyperHtml.renderToString(value.body), {
-      status: value.status,
-      url: value.url,
-      headers: value.headers,
-    })
-  }
-  return HyperHtml.renderToString(value)
-}
-
-function normalizeToEffect(
-  handler,
-  context,
-  next,
-) {
-  if (Effect.isEffect(handler)) {
-    return handler
-  }
-  if (typeof handler === "function") {
-    const result = (handler)(context, next)
-    if (Effect.isEffect(result)) {
-      return result
-    }
-    return Effect.gen(function* () {
-      return yield* result
-    })
-  }
-  return Effect.succeed(handler)
-}
-
-export function html(
-  handler,
-) {
-  return Route.html((context, next) =>
-    Effect.map(normalizeToEffect(handler, context, next), renderValue),
-  )
-}

package/dist/hyper/html.js

@@ -1,30 +0,0 @@
-const HtmlStringSymbol = Symbol.for("HtmlString")
-
-const makeHtmlString = (value) => ({
-  [HtmlStringSymbol]: true,
-  value,
-})
-
-const isHtmlString = (value) =>
-  typeof value === "object" && value !== null && HtmlStringSymbol in value
-
-const resolveValue = (value) => {
-  if (value === null || value === undefined || value === false || value === true) return ""
-  if (isHtmlString(value)) return value.value
-  if (Array.isArray(value)) return (value).map(resolveValue).join("")
-  if (typeof value === "function") return value.toString()
-  if (typeof value === "object") return JSON.stringify(value)
-  if (typeof value === "string") return value
-  return String(value)
-}
-
-export const html = (strings, ...values) => {
-  let result = strings[0]
-  for (let i = 0; i < values.length; i++) {
-    result += resolveValue(values[i])
-    result += strings[i + 1]
-  }
-  return makeHtmlString(result)
-}
-
-html.raw = (value) => makeHtmlString(value)

package/dist/hyper/index.js

@@ -1,5 +0,0 @@
-export * as Hyper from "./Hyper.js"
-export { html } from "./html.js"
-export * as HyperHtml from "./HyperHtml.js"
-export * as HyperNode from "./HyperNode.js"
-export * as HyperRoute from "./HyperRoute.js"

package/dist/hyper/jsx-runtime.js

@@ -1,14 +0,0 @@
-import * as HyperNode from "./HyperNode.js"
-
-function Fragment(props) {
-  return props.children
-}
-
-function jsx(
-  type,
-  props,
-) {
-  return HyperNode.make(type, props)
-}
-
-export { Fragment, jsx, jsx as jsxDEV, jsx as jsxs }

package/dist/index.js

@@ -1,8 +0,0 @@
-export * as Bundle from "./bundler/Bundle.js"
-export * as Development from "./Development.js"
-export * as Entity from "./Entity.js"
-export * as FileRouter from "./FileRouter.js"
-export * as Route from "./Route.js"
-export * as Start from "./Start.js"
-export * as System from "./System.js"
-export * as Unique from "./Unique.js"