effect-start 0.23.0 → 0.25.0

package/dist/Fetch.js

@@ -0,0 +1,192 @@
+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,86 +1,97 @@
-import * as Either from "effect/Either";
+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 });
-        }
+  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;
+  }
+
+  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);
+  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 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 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 = 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}` : "/"));
+  }
+
+  const joined = pathParts.join("/")
+  return Either.right((joined ? `/${joined}` : "/"))
 }