@appwarden/middleware 1.0.18 → 1.1.0

package/chunk-WVVSYKJM.js

@@ -0,0 +1,525 @@
+// src/constants.ts
+var LOCKDOWN_TEST_EXPIRY_MS = 5 * 60 * 1e3;
+var removedHeaders = ["X-Powered-By", "Server"];
+var errors = { badCacheConnection: "BAD_CACHE_CONNECTION" };
+var globalErrors = [errors.badCacheConnection];
+var APPWARDEN_TEST_ROUTE = "_appwarden/test";
+var APPWARDEN_CACHE_KEY = "appwarden-lock";
+
+// src/utils/is-cache-url.ts
+var getEdgeConfigId = (value = "") => isValidCacheUrl.edgeConfig(value) ? new URL(value).pathname.replace("/", "") : void 0;
+var isCacheUrl = {
+  edgeConfig: (value = "") => value.includes("edge-config.vercel.com"),
+  upstash: (value = "") => value.includes(".upstash.io")
+};
+var isValidCacheUrl = {
+  edgeConfig: (value = "") => {
+    try {
+      const url = new URL(value);
+      return url.hostname === "edge-config.vercel.com" && url.pathname.startsWith("/ecfg_") && url.searchParams.has("token");
+    } catch (error) {
+      return false;
+    }
+  },
+  upstash: (value = "") => {
+    try {
+      const url = new URL(value);
+      return ["redis:", "rediss:"].includes(url.protocol) && url.hostname.endsWith("upstash.io") && url.password;
+    } catch (error) {
+      return false;
+    }
+  }
+};
+
+// src/schemas/use-content-security-policy.ts
+import { z as z8 } from "zod";
+
+// src/types/csp.ts
+import { z } from "zod";
+var stringySchema = z.union([z.array(z.string()), z.string(), z.boolean()]);
+var ContentSecurityPolicySchema = z.object({
+  "default-src": stringySchema.optional(),
+  "script-src": stringySchema.optional(),
+  "style-src": stringySchema.optional(),
+  "img-src": stringySchema.optional(),
+  "connect-src": stringySchema.optional(),
+  "font-src": stringySchema.optional(),
+  "object-src": stringySchema.optional(),
+  "media-src": stringySchema.optional(),
+  "frame-src": stringySchema.optional(),
+  sandbox: stringySchema.optional(),
+  "report-uri": stringySchema.optional(),
+  "child-src": stringySchema.optional(),
+  "form-action": stringySchema.optional(),
+  "frame-ancestors": stringySchema.optional(),
+  "plugin-types": stringySchema.optional(),
+  "base-uri": stringySchema.optional(),
+  "report-to": stringySchema.optional(),
+  "worker-src": stringySchema.optional(),
+  "manifest-src": stringySchema.optional(),
+  "prefetch-src": stringySchema.optional(),
+  "navigate-to": stringySchema.optional(),
+  "require-sri-for": stringySchema.optional(),
+  "block-all-mixed-content": stringySchema.optional(),
+  "upgrade-insecure-requests": stringySchema.optional(),
+  "trusted-types": stringySchema.optional(),
+  "require-trusted-types-for": stringySchema.optional()
+});
+
+// src/types/middleware.ts
+import { z as z2 } from "zod";
+var MiddlewareNextSchema = z2.union([
+  z2.void(),
+  z2.null(),
+  z2.promise(z2.union([z2.void(), z2.null()]))
+]);
+
+// src/utils/debug.ts
+var debug = (...msg) => {
+  if (true) {
+    console.log(...msg);
+  }
+};
+
+// src/utils/errors.ts
+var errorsMap = {
+  mode: '`CSP_MODE` must be one of "disabled", "report-only", or "enforced"',
+  directives: {
+    ["DirectivesRequired" /* DirectivesRequired */]: '`CSP_DIRECTIVES` must be provided when `CSP_MODE` is "report-only" or "enforced"',
+    ["DirectivesBadParse" /* DirectivesBadParse */]: "Failed to parse `CSP_DIRECTIVES`. Is it a valid JSON string?"
+  },
+  appwardenApiToken: "Please provide a valid `appwardenApiToken`. Learn more at https://appwarden.com/docs/api-tokens."
+};
+var getErrors = (error) => {
+  const matches = [];
+  const errors2 = [...Object.entries(error.flatten().fieldErrors)];
+  for (const issue of error.issues) {
+    errors2.push(
+      ...Object.entries(
+        "returnTypeError" in issue ? issue.returnTypeError.flatten().fieldErrors : {}
+      )
+    );
+  }
+  for (const [field, maybeSchemaErrorKey] of errors2) {
+    let match = errorsMap[field];
+    if (match) {
+      if (match instanceof Object) {
+        if (maybeSchemaErrorKey) {
+          match = match[maybeSchemaErrorKey[0]];
+        }
+      }
+      matches.push(match);
+    }
+  }
+  return matches;
+};
+
+// src/utils/memory-cache.ts
+var MemoryCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(options) {
+    this.maxSize = options.maxSize;
+  }
+  get(key) {
+    let item;
+    if (this.cache.has(key)) {
+      item = this.cache.get(key);
+      this.cache.delete(key);
+      this.cache.set(key, item);
+    }
+    return item;
+  }
+  put(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(key, value);
+  }
+  getValues() {
+    return this.cache;
+  }
+  // the default value will be expired here
+  static isExpired = (lockValue) => {
+    if (!lockValue) {
+      return true;
+    }
+    return Date.now() > lockValue.lastCheck + 3e4;
+  };
+  static isTestExpired = (lockValue) => {
+    if (!lockValue) {
+      return true;
+    }
+    return Date.now() > lockValue.isLockedTest + LOCKDOWN_TEST_EXPIRY_MS;
+  };
+};
+
+// src/utils/print-message.ts
+var addSlashes = (str) => str.replace(/[\\"'`]/g, "\\$&").replace(/\u0000/g, "\\0");
+var printMessage = (message) => `[@appwarden/middleware] ${addSlashes(message)}`;
+
+// src/utils/vercel/delete-edge-value.ts
+var deleteEdgeValue = async ({
+  keyName,
+  provider,
+  cacheUrl,
+  vercelApiToken
+}) => {
+  try {
+    switch (provider) {
+      case "edge-config": {
+        const edgeConfigId = getEdgeConfigId(cacheUrl);
+        if (!edgeConfigId) {
+          throw new Error("Failed to parse `edgeConfigId`");
+        }
+        const res = await fetch(
+          `https://api.vercel.com/v1/edge-config/${edgeConfigId}/items`,
+          {
+            method: "PATCH",
+            headers: {
+              Authorization: `Bearer ${vercelApiToken}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              items: [
+                {
+                  key: keyName,
+                  operation: "delete"
+                }
+              ]
+            })
+          }
+        );
+        if (res.status !== 200) {
+          let response = void 0;
+          try {
+            response = await res.json();
+          } catch (error) {
+          }
+          throw new Error(
+            `api.vercel.com/v1/edge-config responded with ${res.status} - ${res.statusText}${response?.error?.message ? ` - ${response?.error?.message}` : ""}`
+          );
+        }
+        break;
+      }
+      case "upstash": {
+        const { hostname, password } = new URL(cacheUrl);
+        const { Redis } = await import("@upstash/redis");
+        const redis = new Redis({ url: `https://${hostname}`, token: password });
+        await redis.del(keyName);
+        break;
+      }
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  } catch (e) {
+    const message = "Failed to delete edge value";
+    console.error(
+      printMessage(e instanceof Error ? `${message} - ${e.message}` : message)
+    );
+  }
+};
+
+// src/schemas/cloudflare.ts
+import { z as z5 } from "zod";
+
+// src/schemas/use-appwarden.ts
+import { z as z4 } from "zod";
+
+// src/schemas/helpers.ts
+import { z as z3 } from "zod";
+var BoolOrStringSchema = z3.union([z3.string(), z3.boolean()]).optional();
+var BooleanSchema = BoolOrStringSchema.transform((val) => {
+  if (val === "true" || val === true) {
+    return true;
+  } else if (val === "false" || val === false) {
+    return false;
+  }
+  throw new Error("Invalid value");
+});
+var LockValue = z3.object({
+  isLocked: z3.number(),
+  isLockedTest: z3.number(),
+  lastCheck: z3.number(),
+  code: z3.string()
+});
+
+// src/schemas/use-appwarden.ts
+var UseAppwardenInputSchema = z4.object({
+  debug: BooleanSchema.default(false),
+  lockPageSlug: z4.string(),
+  appwardenApiToken: z4.string().refine((val) => !!val, { path: ["appwardenApiToken"] })
+});
+
+// src/schemas/cloudflare.ts
+var ConfigFnInputSchema = z5.function().args(z5.custom()).returns(
+  UseAppwardenInputSchema.extend({
+    middleware: z5.object({ before: z5.custom().array().default([]) }).default({})
+  })
+);
+
+// src/schemas/nextjs.ts
+import { z as z6 } from "zod";
+var NextJsConfigFnOutputSchema = z6.function().args(z6.custom()).returns(UseAppwardenInputSchema);
+
+// src/schemas/vercel.ts
+import { z as z7 } from "zod";
+var BaseNextJsConfigSchema = z7.object({
+  cacheUrl: z7.string(),
+  appwardenApiToken: z7.string(),
+  vercelApiToken: z7.string().optional(),
+  lockPageSlug: z7.string().default("").transform((val) => val.replace(/^\/?/, "/"))
+});
+var AppwardenConfigSchema = BaseNextJsConfigSchema.refine(
+  (data) => isCacheUrl.edgeConfig(data.cacheUrl) || isCacheUrl.upstash(data.cacheUrl),
+  {
+    message: printMessage(
+      "Provided `cacheUrl` is not recognized. Please provide a Vercel Edge Config or Upstash KV url."
+    ),
+    path: ["cacheUrl"]
+  }
+).refine(
+  (data) => isCacheUrl.edgeConfig(data.cacheUrl) ? isValidCacheUrl.edgeConfig(data.cacheUrl) : true,
+  {
+    message: printMessage(
+      "Provided Vercel Edge Config `cacheUrl` is not valid. Please provide a valid Vercel Edge Config url."
+    ),
+    path: ["cacheUrl"]
+  }
+).refine(
+  (data) => isCacheUrl.upstash(data.cacheUrl) ? isValidCacheUrl.upstash(data.cacheUrl) : true,
+  {
+    message: printMessage(
+      "Provided Upstash KV `cacheUrl` is not valid. Please provide a valid Upstash KV url."
+    ),
+    path: ["cacheUrl"]
+  }
+).refine(
+  (data) => isCacheUrl.edgeConfig(data.cacheUrl) ? !!data.vercelApiToken : true,
+  {
+    message: printMessage(
+      "The `vercelApiToken` option is required when using Vercel Edge Config"
+    ),
+    path: ["vercelApiToken"]
+  }
+).refine((data) => !!data.appwardenApiToken, {
+  message: printMessage(
+    "Please provide a valid `appwardenApiToken`. Learn more at https://appwarden.com/docs/api-tokens."
+  ),
+  path: ["appwardenApiToken"]
+});
+
+// src/utils/vercel/get-lock-value.ts
+var getLockValue = async (context) => {
+  try {
+    let shouldDeleteEdgeValue = false;
+    let serializedValue, lockValue = {
+      isLocked: 0,
+      isLockedTest: 0,
+      lastCheck: 0,
+      code: ""
+    };
+    switch (context.provider) {
+      case "edge-config": {
+        const { createClient } = await import("@vercel/edge-config");
+        const edgeConfig = createClient(context.cacheUrl);
+        serializedValue = await edgeConfig.get(
+          context.keyName
+        );
+        break;
+      }
+      case "upstash": {
+        const { hostname, password } = new URL(context.cacheUrl);
+        const { Redis } = await import("@upstash/redis");
+        const redis = new Redis({
+          url: `https://${hostname}`,
+          token: password
+        });
+        const redisValue = await redis.get(
+          context.keyName
+        );
+        serializedValue = redisValue === null ? void 0 : redisValue;
+        break;
+      }
+      default:
+        throw new Error(`Unsupported provider: ${context.provider}`);
+    }
+    if (!serializedValue) {
+      return { lockValue: void 0 };
+    }
+    try {
+      lockValue = LockValue.parse(
+        typeof serializedValue === "string" ? JSON.parse(serializedValue) : serializedValue
+      );
+    } catch (error) {
+      console.error(
+        printMessage(
+          `Failed to parse ${context.keyName} from edge cache - ${error}`
+        )
+      );
+      shouldDeleteEdgeValue = true;
+    }
+    return { lockValue, shouldDeleteEdgeValue };
+  } catch (e) {
+    const message = "Failed to retrieve edge value";
+    console.error(
+      printMessage(e instanceof Error ? `${message} - ${e.message}` : message)
+    );
+    if (e instanceof Error) {
+      if (e.message.includes("Invalid connection string provided")) {
+        throw new Error(errors.badCacheConnection);
+      }
+    }
+    return { lockValue: void 0 };
+  }
+};
+
+// src/utils/vercel/sync-edge-value.ts
+var APIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "APIError";
+  }
+};
+var syncEdgeValue = async (context) => {
+  debug(`syncing with api`);
+  try {
+    const response = await fetch(new URL("/v1/status/check", "https://bot-gateway.appwarden.io"), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        service: "vercel",
+        cacheUrl: context.cacheUrl,
+        fqdn: context.requestUrl.hostname,
+        vercelApiToken: context.vercelApiToken ?? "",
+        appwardenApiToken: context.appwardenApiToken
+      })
+    });
+    if (response.status !== 200) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+    if (response.headers.get("content-type")?.includes("application/json")) {
+      const result = await response.json();
+      if (result.error) {
+        throw new APIError(result.error.message);
+      }
+    }
+  } catch (e) {
+    const message = "Failed to fetch from check endpoint";
+    console.error(
+      printMessage(
+        e instanceof APIError ? e.message : e instanceof Error ? `${message} - ${e.message}` : message
+      )
+    );
+  }
+};
+
+// src/utils/handle-vercel-request.ts
+var handleVercelRequest = async (context, options) => {
+  let cachedLockValue = context.memoryCache.get(context.keyName);
+  const shouldRecheck = MemoryCache.isExpired(cachedLockValue);
+  if (shouldRecheck) {
+    const { lockValue, shouldDeleteEdgeValue } = await getLockValue(context);
+    if (lockValue) {
+      context.memoryCache.put(context.keyName, lockValue);
+    }
+    if (shouldDeleteEdgeValue) {
+      await deleteEdgeValue(context);
+    }
+    cachedLockValue = lockValue;
+  }
+  if (cachedLockValue?.isLocked || context.requestUrl.pathname === APPWARDEN_TEST_ROUTE && !MemoryCache.isTestExpired(cachedLockValue)) {
+    options.onLocked();
+  }
+  return cachedLockValue;
+};
+
+// src/utils/middleware.ts
+var usePipeline = (...initMiddlewares) => {
+  const stack = [...initMiddlewares];
+  const execute = async (context) => {
+    const runner = async (prevIndex, index) => {
+      if (index === prevIndex) {
+        throw new Error("next() called multiple times");
+      }
+      if (index >= stack.length) {
+        return;
+      }
+      const middleware = stack[index];
+      const next = async () => runner(index, index + 1);
+      await middleware(context, next);
+    };
+    await runner(-1, 0);
+  };
+  return {
+    execute
+  };
+};
+
+// src/utils/render-lock-page.ts
+var renderLockPage = (context) => fetch(new URL(context.lockPageSlug, context.requestUrl.origin), {
+  headers: {
+    // no browser caching, otherwise we need to hard refresh to disable lock screen
+    "Cache-Control": "no-store"
+  }
+});
+
+// src/schemas/use-content-security-policy.ts
+var CSPDirectivesSchema = z8.union([
+  z8.string(),
+  ContentSecurityPolicySchema
+]);
+var CSPModeSchema = z8.literal("disabled").or(z8.literal("report-only")).or(z8.literal("enforced")).optional().default("disabled");
+var UseCSPInputSchema = z8.object({
+  mode: CSPModeSchema,
+  directives: CSPDirectivesSchema.optional().refine(
+    (val) => {
+      try {
+        if (typeof val === "string") {
+          JSON.parse(val);
+        }
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    { message: "DirectivesBadParse" /* DirectivesBadParse */ }
+  ).transform(
+    (val) => typeof val === "string" ? JSON.parse(val) : val
+  )
+}).refine(
+  (values) => (
+    // validate that directives are provided when the mode is "report-only" or "enforced"
+    ["report-only", "enforced"].includes(values.mode) && values.directives
+  ),
+  { path: ["directives"], message: "DirectivesRequired" /* DirectivesRequired */ }
+);
+
+export {
+  LOCKDOWN_TEST_EXPIRY_MS,
+  removedHeaders,
+  globalErrors,
+  APPWARDEN_TEST_ROUTE,
+  APPWARDEN_CACHE_KEY,
+  debug,
+  getErrors,
+  MemoryCache,
+  getEdgeConfigId,
+  isCacheUrl,
+  isValidCacheUrl,
+  printMessage,
+  LockValue,
+  ConfigFnInputSchema,
+  CSPDirectivesSchema,
+  CSPModeSchema,
+  UseCSPInputSchema,
+  BaseNextJsConfigSchema,
+  AppwardenConfigSchema,
+  syncEdgeValue,
+  handleVercelRequest,
+  usePipeline,
+  renderLockPage
+};

package/cloudflare.d.ts

@@ -1,7 +1,6 @@
-import { B as Bindings } from './cloudflare-hVS30fDq.js';
+import { M as Middleware, B as Bindings } from './use-content-security-policy-DBWKjDEH.js';
+export { u as useContentSecurityPolicy } from './use-content-security-policy-DBWKjDEH.js';
 import { z } from 'zod';
-import { M as Middleware } from './use-content-security-policy-BtEGGIeu.js';
-export { u as useContentSecurityPolicy } from './use-content-security-policy-BtEGGIeu.js';
 
 declare const ConfigFnInputSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<{
     env: CloudflareEnv;
@@ -11,10 +10,10 @@ declare const ConfigFnInputSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<{
     env: CloudflareEnv;
     cf: Record<string, unknown>;
     ctx: unknown;
-}>], z.ZodUnknown>, z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+}>], z.ZodUnknown>, z.ZodObject<z.objectUtil.extendShape<{
     debug: z.ZodDefault<z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, boolean, string | boolean | undefined>>;
-    appwardenApiToken: z.ZodEffects<z.ZodString, string, string>;
     lockPageSlug: z.ZodString;
+    appwardenApiToken: z.ZodEffects<z.ZodString, string, string>;
 }, {
     middleware: z.ZodDefault<z.ZodObject<{
         before: z.ZodDefault<z.ZodArray<z.ZodType<Middleware, z.ZodTypeDef, Middleware>, "many">>;
@@ -23,15 +22,13 @@ declare const ConfigFnInputSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<{
     }, {
         before?: Middleware[] | undefined;
     }>>;
-}>, {
-    debug: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
 }>, "strip", z.ZodTypeAny, {
+    debug: boolean;
     lockPageSlug: string;
     appwardenApiToken: string;
     middleware: {
         before: Middleware[];
     };
-    debug?: string | boolean | undefined;
 }, {
     lockPageSlug: string;
     appwardenApiToken: string;
@@ -40,8 +37,8 @@ declare const ConfigFnInputSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<{
         before?: Middleware[] | undefined;
     } | undefined;
 }>>;
-type CloudflareConfigInputFnType = z.infer<typeof ConfigFnInputSchema>;
+type CloudflareConfigType = ReturnType<z.infer<typeof ConfigFnInputSchema>>;
 
-declare const withAppwardenOnCloudflare: (inputFn: CloudflareConfigInputFnType) => ExportedHandlerFetchHandler<Bindings>;
+declare const withAppwarden: (inputFn: CloudflareConfigType) => ExportedHandlerFetchHandler<Bindings>;
 
-export { withAppwardenOnCloudflare };
+export { withAppwarden };

package/cloudflare.js

@@ -1,13 +1,61 @@
 import {
-  appwardenOnCloudflare
-} from "./chunk-JXIVUR6E.js";
-import {
+  insertErrorLogs,
+  useAppwarden,
   useContentSecurityPolicy
-} from "./chunk-C7APN7T6.js";
+} from "./chunk-BHCQJZWE.js";
+import {
+  ConfigFnInputSchema,
+  usePipeline
+} from "./chunk-WVVSYKJM.js";
+
+// src/runners/appwarden-on-cloudflare.ts
+import { ZodError } from "zod";
+
+// src/middlewares/use-fetch-origin.ts
+var useFetchOrigin = () => async (context, next) => {
+  context.response = await fetch(
+    new Request(context.request, {
+      ...context.request,
+      redirect: "follow"
+    })
+  );
+  await next();
+};
+
+// src/runners/appwarden-on-cloudflare.ts
+var appwardenOnCloudflare = (inputFn) => async (request, env, ctx) => {
+  ctx.passThroughOnException();
+  const context = {
+    request,
+    hostname: new URL(request.url).host,
+    response: new Response("Unhandled response"),
+    // https://developers.cloudflare.com/workers/observability/errors/#illegal-invocation-errors
+    waitUntil: (fn) => ctx.waitUntil(fn)
+  };
+  const parsedInput = ConfigFnInputSchema.safeParse(inputFn);
+  if (!parsedInput.success) {
+    return insertErrorLogs(context, parsedInput.error);
+  }
+  try {
+    const input = parsedInput.data({ env, ctx, cf: {} });
+    const pipeline = [
+      ...input.middleware.before,
+      useAppwarden(input),
+      useFetchOrigin()
+    ];
+    await usePipeline(...pipeline).execute(context);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      return insertErrorLogs(context, error);
+    }
+    throw error;
+  }
+  return context.response;
+};
 
 // src/bundles/cloudflare.ts
-var withAppwardenOnCloudflare = appwardenOnCloudflare;
+var withAppwarden = appwardenOnCloudflare;
 export {
   useContentSecurityPolicy,
-  withAppwardenOnCloudflare
+  withAppwarden
 };

package/index.d.ts

@@ -1,8 +1,18 @@
-export { B as Bindings } from './cloudflare-hVS30fDq.js';
-export { C as CSPDirectivesSchema, a as CSPEnforcedSchema, M as Middleware, u as useContentSecurityPolicy } from './use-content-security-policy-BtEGGIeu.js';
+export { B as Bindings, C as CSPDirectivesSchema, a as CSPModeSchema, M as Middleware, u as useContentSecurityPolicy } from './use-content-security-policy-DBWKjDEH.js';
 import { z } from 'zod';
 
 declare const LOCKDOWN_TEST_EXPIRY_MS: number;
+declare const APPWARDEN_CACHE_KEY: "appwarden-lock";
+
+declare const getEdgeConfigId: (value?: string) => string | undefined;
+declare const isCacheUrl: {
+    edgeConfig: (value?: string) => boolean;
+    upstash: (value?: string) => boolean;
+};
+declare const isValidCacheUrl: {
+    edgeConfig: (value?: string) => boolean;
+    upstash: (value?: string) => string | false;
+};
 
 declare const LockValue: z.ZodObject<{
     isLocked: z.ZodNumber;
@@ -10,16 +20,16 @@ declare const LockValue: z.ZodObject<{
     lastCheck: z.ZodNumber;
     code: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    code: string;
     isLocked: number;
     isLockedTest: number;
     lastCheck: number;
-    code: string;
 }, {
+    code: string;
     isLocked: number;
     isLockedTest: number;
     lastCheck: number;
-    code: string;
 }>;
 type LockValueType = z.infer<typeof LockValue>;
 
-export { LOCKDOWN_TEST_EXPIRY_MS, type LockValueType };
+export { APPWARDEN_CACHE_KEY, LOCKDOWN_TEST_EXPIRY_MS, type LockValueType, getEdgeConfigId, isCacheUrl, isValidCacheUrl };