miniflare 0.0.0-e55f489db → 0.0.0-e5ae13ade

package/dist/src/workers/assets/router.worker.js

@@ -7720,6 +7720,181 @@ var require_index_cjs = __commonJS({
   }
 });
 
+// ../workers-shared/utils/responses.ts
+var OkResponse = class _OkResponse extends Response {
+  static {
+    this.status = 200;
+  }
+  constructor(body, init) {
+    super(body, {
+      ...init,
+      status: _OkResponse.status
+    });
+  }
+}, NotFoundResponse = class _NotFoundResponse extends Response {
+  static {
+    this.status = 404;
+  }
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: _NotFoundResponse.status,
+      statusText: "Not Found"
+    });
+  }
+};
+var MethodNotAllowedResponse = class _MethodNotAllowedResponse extends Response {
+  static {
+    this.status = 405;
+  }
+  constructor(...[body, init]) {
+    super(body, {
+      ...init,
+      status: _MethodNotAllowedResponse.status,
+      statusText: "Method Not Allowed"
+    });
+  }
+}, InternalServerErrorResponse = class _InternalServerErrorResponse extends Response {
+  static {
+    this.status = 500;
+  }
+  constructor(err, init) {
+    super(null, {
+      ...init,
+      status: _InternalServerErrorResponse.status
+    });
+  }
+}, NotModifiedResponse = class _NotModifiedResponse extends Response {
+  static {
+    this.status = 304;
+  }
+  constructor(...[_body, init]) {
+    super(null, {
+      ...init,
+      status: _NotModifiedResponse.status,
+      statusText: "Not Modified"
+    });
+  }
+}, MovedPermanentlyResponse = class _MovedPermanentlyResponse extends Response {
+  static {
+    this.status = 301;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _MovedPermanentlyResponse.status,
+      statusText: "Moved Permanently",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+}, FoundResponse = class _FoundResponse extends Response {
+  static {
+    this.status = 302;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _FoundResponse.status,
+      statusText: "Found",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+}, SeeOtherResponse = class _SeeOtherResponse extends Response {
+  static {
+    this.status = 303;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _SeeOtherResponse.status,
+      statusText: "See Other",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+}, TemporaryRedirectResponse = class _TemporaryRedirectResponse extends Response {
+  static {
+    this.status = 307;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _TemporaryRedirectResponse.status,
+      statusText: "Temporary Redirect",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+}, PermanentRedirectResponse = class _PermanentRedirectResponse extends Response {
+  static {
+    this.status = 308;
+  }
+  constructor(location, init) {
+    super(null, {
+      ...init,
+      status: _PermanentRedirectResponse.status,
+      statusText: "Permanent Redirect",
+      headers: {
+        ...init?.headers,
+        Location: location
+      }
+    });
+  }
+};
+
+// ../workers-shared/utils/tracing.ts
+function mockJaegerBindingSpan() {
+  return {
+    addLogs: () => {
+    },
+    setTags: () => {
+    },
+    end: () => {
+    },
+    isRecording: !0
+  };
+}
+function mockJaegerBinding() {
+  return {
+    enterSpan: (_, span, ...args) => span(mockJaegerBindingSpan(), ...args),
+    getSpanContext: () => ({
+      traceId: "test-trace",
+      spanId: "test-span",
+      parentSpanId: "test-parent-span",
+      traceFlags: 0
+    }),
+    runWithSpanContext: (_, callback, ...args) => callback(...args),
+    traceId: "test-trace",
+    spanId: "test-span",
+    parentSpanId: "test-parent-span",
+    cfTraceIdHeader: "test-trace:test-span:0"
+  };
+}
+
+// ../workers-shared/asset-worker/src/utils/rules-engine.ts
+var ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g, escapeRegex = (str) => str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+var generateGlobOnlyRuleRegExp = (rule) => (rule = rule.split("*").map(escapeRegex).join(".*"), rule = "^" + rule + "$", RegExp(rule));
+var generateStaticRoutingRuleMatcher = (rules) => ({ request }) => {
+  let { pathname } = new URL(request.url);
+  for (let rule of rules)
+    try {
+      if (generateGlobOnlyRuleRegExp(rule).test(pathname))
+        return !0;
+    } catch {
+    }
+  return !1;
+};
+
 // ../workers-shared/utils/performance.ts
 var PerformanceTimer = class {
   constructor(performanceTimer) {
@@ -7771,35 +7946,6 @@ function setupSentry(request, context, dsn, clientId, clientSecret, coloMetadata
   return coloMetadata && (sentry.setTag("colo", coloMetadata.coloId), sentry.setTag("metal", coloMetadata.metalId)), accountId && scriptId && (sentry.setTag("accountId", accountId), sentry.setTag("scriptId", scriptId)), sentry.setUser({ id: accountId?.toString() }), sentry;
 }
 
-// ../workers-shared/utils/tracing.ts
-function mockJaegerBindingSpan() {
-  return {
-    addLogs: () => {
-    },
-    setTags: () => {
-    },
-    end: () => {
-    },
-    isRecording: !0
-  };
-}
-function mockJaegerBinding() {
-  return {
-    enterSpan: (_, span, ...args) => span(mockJaegerBindingSpan(), ...args),
-    getSpanContext: () => ({
-      traceId: "test-trace",
-      spanId: "test-span",
-      parentSpanId: "test-parent-span",
-      traceFlags: 0
-    }),
-    runWithSpanContext: (_, callback, ...args) => callback(...args),
-    traceId: "test-trace",
-    spanId: "test-span",
-    parentSpanId: "test-parent-span",
-    cfTraceIdHeader: "test-trace:test-span:0"
-  };
-}
-
 // ../workers-shared/router-worker/src/analytics.ts
 var Analytics = class {
   constructor(readyAnalytics) {
@@ -7827,7 +7973,9 @@ var Analytics = class {
         // double3
         this.data.coloTier ?? -1,
         // double4
-        this.data.userWorkerAhead === void 0 ? -1 : Number(this.data.userWorkerAhead)
+        this.data.userWorkerAhead === void 0 ? -1 : Number(this.data.userWorkerAhead),
+        this.data.staticRoutingDecision ?? 0 /* NOT_PROVIDED */
+        // double6
       ],
       blobs: [
         this.data.hostname?.substring(0, 256),
@@ -7851,7 +7999,11 @@ var applyConfigurationDefaults = (configuration) => ({
   has_user_worker: configuration?.has_user_worker ?? !1,
   account_id: configuration?.account_id ?? -1,
   script_id: configuration?.script_id ?? -1,
-  debug: configuration?.debug ?? !1
+  debug: configuration?.debug ?? !1,
+  static_routing: configuration?.static_routing ?? {
+    version: 1,
+    include: []
+  }
 });
 
 // ../workers-shared/router-worker/src/index.ts
@@ -7870,7 +8022,7 @@ var src_default = {
         env.CONFIG?.account_id,
         env.CONFIG?.script_id
       );
-      let config = applyConfigurationDefaults(env.CONFIG), url = new URL(request.url);
+      let hasStaticRouting = env.CONFIG.static_routing !== void 0, config = applyConfigurationDefaults(env.CONFIG), url = new URL(request.url);
       env.COLO_METADATA && env.VERSION_METADATA && env.CONFIG && analytics.setData({
         accountId: env.CONFIG.account_id,
         scriptId: env.CONFIG.script_id,
@@ -7883,6 +8035,42 @@ var src_default = {
         userWorkerAhead: config.invoke_user_worker_ahead_of_assets
       });
       let maybeSecondRequest = request.clone();
+      if (config.static_routing) {
+        if (generateStaticRoutingRuleMatcher(
+          config.static_routing.exclude ?? []
+        )({
+          request
+        }))
+          return analytics.setData({
+            dispatchtype: "asset" /* ASSETS */,
+            staticRoutingDecision: 2 /* EXCLUDE */
+          }), await env.JAEGER.enterSpan("dispatch_assets", async (span) => (span.setTags({
+            hasUserWorker: config.has_user_worker,
+            asset: "static_routing",
+            dispatchType: "asset" /* ASSETS */
+          }), env.ASSET_WORKER.fetch(maybeSecondRequest)));
+        if (generateStaticRoutingRuleMatcher(
+          config.static_routing.include
+        )({
+          request
+        })) {
+          if (!config.has_user_worker)
+            throw new Error(
+              "Fetch for user worker without having a user worker binding"
+            );
+          return analytics.setData({
+            dispatchtype: "worker" /* WORKER */,
+            staticRoutingDecision: 3 /* INCLUDE */
+          }), await env.JAEGER.enterSpan("dispatch_worker", async (span) => (span.setTags({
+            hasUserWorker: !0,
+            asset: "static_routing",
+            dispatchType: "worker" /* WORKER */
+          }), userWorkerInvocation = !0, env.USER_WORKER.fetch(maybeSecondRequest)));
+        }
+        analytics.setData({
+          staticRoutingDecision: hasStaticRouting ? 1 /* NOT_ROUTED */ : 0 /* NOT_PROVIDED */
+        });
+      }
       if (config.invoke_user_worker_ahead_of_assets) {
         if (!config.has_user_worker)
           throw new Error(