effect-start 0.25.0 → 0.26.0

package/dist/Entity.js

@@ -1,289 +0,0 @@
-import * as Effect from "effect/Effect"
-import * as ParseResult from "effect/ParseResult"
-import * as Pipeable from "effect/Pipeable"
-import * as Predicate from "effect/Predicate"
-import * as Schema from "effect/Schema"
-import * as Stream from "effect/Stream"
-import * as StreamExtra from "./StreamExtra.js"
-import * as Values from "./Values.js"
-
-export const TypeId = Symbol.for("effect-start/Entity")
-
-const textDecoder = new TextDecoder()
-const textEncoder = new TextEncoder()
-
-function isBinary(v) {
-  return v instanceof Uint8Array || v instanceof ArrayBuffer
-}
-
-/**
- * Header keys are guaranteed to be lowercase.
- */
-
-function parseJson(s) {
-  try {
-    return Effect.succeed(JSON.parse(s))
-  } catch (e) {
-    return Effect.fail(
-      new ParseResult.ParseError({
-        issue: new ParseResult.Type(
-          Schema.Unknown.ast,
-          s,
-          e instanceof Error ? e.message : "Failed to parse JSON",
-        ),
-      }),
-    )
-  }
-}
-
-function getText(
-  self,
-) {
-  const v = self.body
-  if (StreamExtra.isStream(v)) {
-    return Stream.mkString(Stream.decodeText(v))
-  }
-  if (Effect.isEffect(v)) {
-    return Effect.flatMap(
-      v,
-      (inner) => {
-        if (isEntity(inner)) {
-          return inner.text
-        }
-        if (typeof inner === "string") {
-          return Effect.succeed(inner)
-        }
-        if (isBinary(inner)) {
-          return Effect.succeed(textDecoder.decode(inner))
-        }
-        return Effect.fail(mismatch(Schema.String, inner))
-      },
-    )
-  }
-  if (typeof v === "string") {
-    return Effect.succeed(v)
-  }
-  if (isBinary(v)) {
-    return Effect.succeed(textDecoder.decode(v))
-  }
-  return Effect.fail(mismatch(Schema.String, v))
-}
-
-function getJson(
-  self,
-) {
-  const v = self.body
-  if (StreamExtra.isStream(v)) {
-    return Effect.flatMap(getText(self), parseJson)
-  }
-  if (Effect.isEffect(v)) {
-    return Effect.flatMap(
-      v,
-      (inner) => {
-        if (isEntity(inner)) {
-          return inner.json
-        }
-        if (typeof inner === "object" && inner !== null && !isBinary(inner)) {
-          return Effect.succeed(inner)
-        }
-        if (typeof inner === "string") {
-          return parseJson(inner)
-        }
-        if (isBinary(inner)) {
-          return parseJson(textDecoder.decode(inner))
-        }
-        return Effect.fail(mismatch(Schema.Unknown, inner))
-      },
-    )
-  }
-  if (typeof v === "object" && v !== null && !isBinary(v)) {
-    return Effect.succeed(v)
-  }
-  if (typeof v === "string") {
-    return parseJson(v)
-  }
-  if (isBinary(v)) {
-    return parseJson(textDecoder.decode(v))
-  }
-  return Effect.fail(mismatch(Schema.Unknown, v))
-}
-
-function getBytes(
-  self,
-) {
-  const v = self.body
-  if (StreamExtra.isStream(v)) {
-    return Stream.runFold(
-      v,
-      new Uint8Array(0),
-      Values.concatBytes,
-    )
-  }
-  if (Effect.isEffect(v)) {
-    return Effect.flatMap(
-      v,
-      (inner) => {
-        if (isEntity(inner)) {
-          return inner.bytes
-        }
-        if (inner instanceof Uint8Array) {
-          return Effect.succeed(inner)
-        }
-        if (inner instanceof ArrayBuffer) {
-          return Effect.succeed(new Uint8Array(inner))
-        }
-        if (typeof inner === "string") {
-          return Effect.succeed(textEncoder.encode(inner))
-        }
-        return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, inner))
-      },
-    )
-  }
-  if (v instanceof Uint8Array) {
-    return Effect.succeed(v)
-  }
-  if (v instanceof ArrayBuffer) {
-    return Effect.succeed(new Uint8Array(v))
-  }
-  if (typeof v === "string") {
-    return Effect.succeed(textEncoder.encode(v))
-  }
-  // Allows entity.stream to work when body is a JSON object
-  if (typeof v === "object" && v !== null && !isBinary(v)) {
-    return Effect.succeed(textEncoder.encode(JSON.stringify(v)))
-  }
-  return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, v))
-}
-
-function getStream(self) {
-  const v = self.body
-  if (StreamExtra.isStream(v)) {
-    return v
-  }
-  if (Effect.isEffect(v)) {
-    return Stream.unwrap(
-      Effect.map(v, (inner) => {
-        if (isEntity(inner)) {
-          return inner.stream
-        }
-        return Stream.fromEffect(getBytes(make(inner)))
-      }),
-    )
-  }
-  return Stream.fromEffect(getBytes(self))
-}
-
-const Proto = Object.defineProperties(Object.create(null), {
-  [TypeId]: { value: TypeId },
-  pipe: {
-    value: function () {
-      return Pipeable.pipeArguments(this, arguments)
-    },
-  },
-  text: {
-    get() {
-      return getText(this)
-    },
-  },
-  json: {
-    get() {
-      return getJson(this)
-    },
-  },
-  bytes: {
-    get() {
-      return getBytes(this)
-    },
-  },
-  stream: {
-    get() {
-      return getStream(this)
-    },
-  },
-})
-
-export function isEntity(input) {
-  return Predicate.hasProperty(input, TypeId)
-}
-
-export function make(body, options) {
-  return Object.assign(Object.create(Proto), {
-    body,
-    headers: options?.headers ?? {},
-    url: options?.url,
-    status: options?.status,
-  })
-}
-
-export function effect(body) {
-  return make(body)
-}
-
-export function resolve(entity) {
-  const body = entity.body
-  if (Effect.isEffect(body)) {
-    return Effect.map(body, (inner) =>
-      isEntity(inner)
-        ? (inner)
-        : (make(inner, {
-            status: entity.status,
-            headers: entity.headers,
-            url: entity.url,
-          })),
-    )
-  }
-  return Effect.succeed(entity)
-}
-
-export function type(self) {
-  const h = self.headers
-  if (h["content-type"]) {
-    return h["content-type"]
-  }
-  const v = self.body
-  if (typeof v === "string") {
-    return "text/plain"
-  }
-  if (typeof v === "object" && v !== null && !isBinary(v)) {
-    return "application/json"
-  }
-  return "application/octet-stream"
-}
-
-export function length(self) {
-  const h = self.headers
-  if (h["content-length"]) {
-    return parseInt(h["content-length"], 10)
-  }
-  const v = self.body
-  if (typeof v === "string") {
-    return textEncoder.encode(v).byteLength
-  }
-  if (isBinary(v)) {
-    return v.byteLength
-  }
-  return undefined
-}
-
-export function fromResponse(
-  response,
-  request,
-) {
-  return make(
-    Effect.tryPromise({
-      try: () => response.arrayBuffer().then((buf) => new Uint8Array(buf)),
-      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
-    }),
-    {
-      headers: Object.fromEntries(response.headers.entries()),
-      status: response.status,
-      url: response.url || request?.url,
-    },
-  )
-}
-
-function mismatch(expected, actual) {
-  return new ParseResult.ParseError({
-    issue: new ParseResult.Type(expected.ast, actual),
-  })
-}

package/dist/Fetch.js

@@ -1,192 +0,0 @@
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as Schedule from "effect/Schedule"
-import * as Entity from "./Entity.js"
-
-const TypeId = Symbol.for("effect-start/FetchClient")
-
-export class FetchError extends Data.TaggedError("FetchError") {}
-
-const tryFetch = (request) =>
-  Effect.map(
-    Effect.tryPromise({
-      try: () => globalThis.fetch(request),
-      catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
-    }),
-    (response) => Entity.fromResponse(response, request),
-  )
-
-const defaultMiddleware = [tryFetch]
-const noopNext = () => Effect.die("no middleware")
-
-function withTrace(
-  request,
-  effect,
-) {
-  const url = new URL(request.url)
-
-  return Effect.useSpan(
-    `http.client ${request.method}`,
-    { kind: "client", captureStackTrace: false },
-    (span) => {
-      span.attribute("http.request.method", request.method)
-      span.attribute("url.full", url.toString())
-      span.attribute("url.path", url.pathname)
-      const query = url.search.slice(1)
-      if (query !== "") {
-        span.attribute("url.query", query)
-      }
-      span.attribute("url.scheme", url.protocol.slice(0, -1))
-
-      return Effect.flatMap(Effect.exit(Effect.withParentSpan(effect, span)), (exit) => {
-        if (exit._tag === "Success") {
-          span.attribute("http.response.status_code", exit.value.status ?? 0)
-        }
-        return exit
-      })
-    },
-  )
-}
-
-export function fetch(
-  input,
-  init,
-) {
-  const middleware =
-    (this)?.middleware ?? defaultMiddleware
-  return Effect.gen(function* () {
-    const request = new Request(input, init)
-
-    let handler = noopNext
-    for (let i = middleware.length - 1; i >= 0; i--) {
-      const nextHandler = handler
-      handler = ((req) => middleware[i](req, nextHandler))
-    }
-
-    return yield* withTrace(request, handler(request))
-  })
-}
-
-export function get(
-  input,
-  init,
-) {
-  return fetch.call(this, input, { ...init, method: "GET" })
-}
-
-export function post(
-  input,
-  init,
-) {
-  return fetch.call(this, input, { ...init, method: "POST" })
-}
-
-export function use(
-  ...middleware
-) {
-  const base = (this)?.middleware ?? defaultMiddleware
-  const transport = base[base.length - 1]
-  const existing = base.slice(0, -1)
-  return Object.create(ClientProto, {
-    middleware: { value: [...existing, ...middleware, transport] },
-  })
-}
-
-const ClientProto = {
-  [TypeId]: TypeId,
-  middleware: defaultMiddleware,
-  fetch,
-  get,
-  post,
-  use,
-}
-
-export function filterStatus(
-  predicate,
-  options,
-) {
-  return ((_request, next) =>
-    Effect.gen(function* () {
-      const entity = yield* next(_request)
-      const status = entity.status ?? 0
-      if (predicate(status)) {
-        return entity
-      }
-      if (options?.orElse) {
-        return yield* options.orElse(entity)
-      }
-      return yield* Effect.fail(new FetchError({ reason: "Status", response: entity }))
-    }))
-}
-
-export function filterStatusOk(options) {
-  return filterStatus((status) => status >= 200 && status < 300, options)
-}
-
-export function followRedirects(options) {
-  const maxRedirects = options?.maxRedirects ?? 10
-
-  return (request, next) =>
-    Effect.gen(function* () {
-      let currentRequest = new Request(request.url, {
-        ...request,
-        redirect: "manual",
-      })
-      let redirectCount = 0
-
-      while (true) {
-        const entity = yield* next(currentRequest)
-        const status = entity.status ?? 0
-
-        if (status >= 300 && status < 400) {
-          if (redirectCount >= maxRedirects) {
-            return entity
-          }
-
-          const location = entity.headers["location"]
-          if (!location) {
-            return entity
-          }
-
-          redirectCount++
-          const nextUrl = new URL(location, currentRequest.url)
-
-          if (status === 303) {
-            currentRequest = new Request(nextUrl.toString(), {
-              method: "GET",
-              headers: currentRequest.headers,
-              redirect: "manual",
-            })
-          } else {
-            currentRequest = new Request(nextUrl.toString(), {
-              method: currentRequest.method,
-              headers: currentRequest.headers,
-              body: currentRequest.body,
-              redirect: "manual",
-            })
-          }
-        } else {
-          return entity
-        }
-      }
-    })
-}
-
-export function retry(options) {
-  return ((request, next) => {
-    if (options.schedule) {
-      return Effect.retry(
-        Effect.suspend(() => next(request)),
-        options.schedule,
-      )
-    }
-
-    const times = options.times ?? 3
-    const delay = options.delay ?? 1000
-
-    return Effect.retry(
-      Effect.suspend(() => next(request)),
-      Schedule.intersect(Schedule.recurs(times), Schedule.exponential(delay)),
-    )
-  })
-}

package/dist/FilePathPattern.js

@@ -1,97 +0,0 @@
-import * as Either from "effect/Either"
-
-export function segments(pattern) {
-  const parts = pattern.split("/").filter(Boolean)
-  const result = []
-
-  for (const part of parts) {
-    if (/^\(\w+\)$/.test(part)) {
-      result.push({ _tag: "GroupSegment", name: part.slice(1, -1) })
-    } else if (part.startsWith("[[") && part.endsWith("]]")) {
-      result.push({ _tag: "RestSegment", name: part.slice(2, -2) })
-    } else if (part.startsWith("[") && part.endsWith("]")) {
-      result.push({ _tag: "ParamSegment", name: part.slice(1, -1) })
-    } else if (/^[\p{L}\p{N}._~-]+$/u.test(part)) {
-      result.push({ _tag: "LiteralSegment", value: part })
-    } else {
-      result.push({ _tag: "InvalidSegment", value: part })
-    }
-  }
-
-  return result
-}
-
-export function validate(pattern) {
-  const segs = segments(pattern)
-
-  const invalid = segs.find((s) => s._tag === "InvalidSegment")
-  if (invalid) {
-    return Either.left({
-      _tag: "FilePathPatternError",
-      pattern,
-      message: `Invalid segment: "${invalid.value}"`,
-    })
-  }
-
-  const restIndex = segs.findIndex((s) => s._tag === "RestSegment")
-  if (restIndex !== -1 && restIndex !== segs.length - 1) {
-    return Either.left({
-      _tag: "FilePathPatternError",
-      pattern,
-      message: "Rest segment must be the last segment",
-    })
-  }
-
-  return Either.right(segs)
-}
-
-export function format(segs) {
-  const parts = segs.map((seg) => {
-    switch (seg._tag) {
-      case "GroupSegment":
-        return `(${seg.name})`
-      case "RestSegment":
-        return `[[${seg.name}]]`
-      case "ParamSegment":
-        return `[${seg.name}]`
-      case "LiteralSegment":
-        return seg.value
-      case "InvalidSegment":
-        return seg.value
-    }
-  })
-  const joined = parts.join("/")
-  return (joined ? `/${joined}` : "/")
-}
-
-export function toPathPattern(
-  pattern,
-) {
-  const result = validate(pattern)
-
-  if (Either.isLeft(result)) {
-    return Either.left(result.left)
-  }
-
-  const segs = result.right
-  const pathParts = []
-
-  for (const seg of segs) {
-    switch (seg._tag) {
-      case "GroupSegment":
-        continue
-      case "RestSegment":
-        pathParts.push(`:${seg.name}*`)
-        break
-      case "ParamSegment":
-        pathParts.push(`:${seg.name}`)
-        break
-      case "LiteralSegment":
-        pathParts.push(seg.value)
-        break
-    }
-  }
-
-  const joined = pathParts.join("/")
-  return Either.right((joined ? `/${joined}` : "/"))
-}