@getstrata/core 2.0.2 → 2.0.4

package/dist/entries/tracing/tracingMiddleware.js

@@ -355,50 +355,133 @@ async function resolveSafeOutboundTarget(rawUrl, options = {}) {
 
 // ../../src/core/security/safeFetch.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+function untilAborted(work, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function preserveResponseMetadata(response, original) {
+  Object.defineProperties(response, {
+    url: { value: original.url },
+    redirected: { value: original.redirected },
+    type: { value: original.type }
+  });
+  const clone = response.clone.bind(response);
+  response.clone = () => preserveResponseMetadata(clone(), original);
+  return response;
+}
+function withBodyDeadline(response, signal, release) {
+  if (!response.body) {
+    release();
+    return response;
+  }
+  const reader = response.body.getReader();
+  let stopped = false;
+  let bodyController;
+  const stop = (reason, errorBody) => {
+    if (stopped)
+      return;
+    stopped = true;
+    release();
+    signal.removeEventListener("abort", onAbort);
+    if (errorBody)
+      bodyController.error(reason);
+    reader.cancel(reason).catch(() => {}).finally(() => reader.releaseLock());
+  };
+  const onAbort = () => stop(signal.reason, true);
+  const body = new ReadableStream({
+    start(controller) {
+      bodyController = controller;
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    },
+    async pull(controller) {
+      try {
+        const result = await untilAborted(reader.read(), signal);
+        if (stopped)
+          return;
+        if (result.done) {
+          stopped = true;
+          release();
+          signal.removeEventListener("abort", onAbort);
+          reader.releaseLock();
+          controller.close();
+        } else {
+          controller.enqueue(result.value);
+        }
+      } catch (error) {
+        stop(error, true);
+      }
+    },
+    cancel(reason) {
+      stop(reason, false);
+    }
+  }, { highWaterMark: 0 });
+  return preserveResponseMetadata(new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  }), response);
+}
 async function safeFetch(input, init = {}, options = {}) {
+  init.signal?.throwIfAborted();
   const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError("safeFetch timeoutMs must be a positive finite number.");
+  }
   const maxRedirects = options.maxRedirects ?? 0;
-  const resolveDns = options.resolveDns ?? true;
   const urlOptions = {
     allowHttp: options.allowHttp,
-    resolveDns,
+    resolveDns: options.resolveDns ?? true,
     allowPrivate: options.allowPrivate
   };
   const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const forwardAbort = () => controller.abort(init.signal?.reason);
+  init.signal?.addEventListener("abort", forwardAbort, { once: true });
+  const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+  const release = () => {
+    clearTimeout(timeout);
+    init.signal?.removeEventListener("abort", forwardAbort);
+  };
   try {
-    let current = await resolveSafeOutboundTarget(input, urlOptions);
+    let current = await untilAborted(resolveSafeOutboundTarget(input, urlOptions), controller.signal);
     let redirectCount = 0;
     while (true) {
+      controller.signal.throwIfAborted();
       const address = current.addresses[0];
       const fetchUrl = address ? pinUrlToAddress(current.url, address).toString() : current.url.toString();
       const headers = new Headers(init.headers);
-      if (address && !headers.has("host")) {
+      if (address && !headers.has("host"))
         headers.set("Host", current.url.host);
-      }
       const fetchInit = {
         ...init,
         headers,
         signal: controller.signal,
         redirect: "manual"
       };
-      if (address) {
+      if (address)
         fetchInit.tls = { serverName: current.url.hostname };
-      }
-      const response = await fetch(fetchUrl, fetchInit);
+      const response = await untilAborted(fetch(fetchUrl, fetchInit), controller.signal);
       if (response.status >= 300 && response.status < 400) {
         const location = response.headers.get("location");
-        if (!location || redirectCount >= maxRedirects) {
-          return response;
+        if (location && redirectCount < maxRedirects) {
+          if (response.body)
+            await untilAborted(response.body.cancel(), controller.signal);
+          current = await untilAborted(resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions), controller.signal);
+          redirectCount++;
+          continue;
         }
-        current = await resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions);
-        redirectCount += 1;
-        continue;
       }
-      return response;
+      return withBodyDeadline(response, controller.signal, release);
     }
-  } finally {
-    clearTimeout(timeout);
+  } catch (error) {
+    controller.abort(error);
+    release();
+    throw error;
   }
 }
 

package/dist/framework/public-api.d.ts

@@ -64,7 +64,7 @@ export { loadSeedersFromDirectory, runSeedersFromDirectory, } from "../core/data
 export type { Seeder, SeederDatabase } from "../core/database/seeders/types.ts";
 export { createSqliteConnection } from "../core/database/sqliteConnection.ts";
 export { defineTable } from "../core/database/table.ts";
-export { requestTransactionRollback, runInTransaction } from "../core/database/transaction.ts";
+export { hasActiveTransaction, requestTransactionRollback, runInTransaction, } from "../core/database/transaction.ts";
 export type { QueryJoin, QueryJoinOn, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, } from "../core/database/types.ts";
 export type { WhereNode } from "../core/database/whereBuilder.ts";
 export { WhereBuilder } from "../core/database/whereBuilder.ts";
@@ -72,6 +72,8 @@ export { BadRequestError, ConflictError, ForbiddenError, HttpError, InternalServ
 export type { EventListener } from "../core/events/eventBus.ts";
 export { EventBus, eventBus, readSharedEventBus } from "../core/events/eventBus.ts";
 export { dispatchModelEvent, modelEventName, runWithDeferredModelEvents, } from "../core/events/index.ts";
+export type { DurableEvent, DurableListener, SqlOutboxOptions, } from "../core/events/outbox/index.ts";
+export { createOutboxMigration, SqlOutbox } from "../core/events/outbox/index.ts";
 export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades/index.ts";
 export { createBodySizeLimitMiddleware } from "../core/http/bodySizeLimitMiddleware.ts";
 export { readClientIp, trustForwardedFor } from "../core/http/clientIp.ts";