@zuplo/cli 6.71.20 → 6.71.22

package/node_modules/@zuplo/graphql/out/types/index.d.ts

@@ -1,6 +1,115 @@
 import { InboundPolicyHandler } from "@zuplo/runtime";
 import { OutboundPolicyHandler } from "@zuplo/runtime";
 
+/**
+ * Caches GraphQL query responses at the edge so identical queries are served
+ * without a round-trip to the origin.
+ *
+ * Unlike CDN caching that keys on the raw request body, this policy parses the
+ * GraphQL document and normalizes it before hashing: insignificant whitespace,
+ * field formatting, and fragment layout are collapsed, and variable object
+ * keys are sorted. Two requests that are semantically identical therefore share
+ * a cache entry even when their bodies differ byte-for-byte. There is no query
+ * size or nesting-depth limit.
+ *
+ * Only `query` operations are cached. Mutations, subscriptions, malformed
+ * documents, and non-JSON bodies are forwarded to the origin untouched. Cache
+ * hits and misses are reported on the `x-cache` response header, with a short
+ * key fingerprint on `x-cache-key`.
+ *
+ * To avoid serving one user's data to another, requests carrying an
+ * `authorization` or `cookie` header are not cached by default. Use
+ * `cacheKeyHeaders` to opt into caching them: each listed header's value is
+ * included in the cache key, so distinct credentials get distinct cache entries.
+ *
+ * @title GraphQL Cache
+ * @product api-gateway
+ * @public
+ *
+ * @param request - The incoming ZuploRequest containing the GraphQL query
+ * @param context - The ZuploContext
+ * @param options - Configuration for the cache name, TTL, and header varying
+ * @param policyName - The name of the policy instance
+ * @returns A cached Response on a hit, otherwise the request forwarded to the origin
+ *
+ * @example
+ * ```json
+ * // policies.json - Cache GraphQL query responses for 60 seconds
+ * {
+ *   "name": "graphql-cache",
+ *   "policyType": "graphql-cache-inbound",
+ *   "handler": {
+ *     "export": "GraphQLCacheInboundPolicy",
+ *     "module": "$import(@zuplo/graphql)",
+ *     "options": {
+ *       "cacheName": "graphql-responses",
+ *       "ttlSeconds": 60
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```json
+ * // Cache per-user by varying the key on the Authorization header
+ * {
+ *   "name": "graphql-cache",
+ *   "policyType": "graphql-cache-inbound",
+ *   "handler": {
+ *     "export": "GraphQLCacheInboundPolicy",
+ *     "module": "$import(@zuplo/graphql)",
+ *     "options": {
+ *       "ttlSeconds": 30,
+ *       "cacheKeyHeaders": ["authorization"]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```json
+ * // Apply the cache to a GraphQL route
+ * {
+ *   "paths": {
+ *     "/graphql": {
+ *       "post": {
+ *         "x-zuplo-route": {
+ *           "policies": {
+ *             "inbound": ["graphql-cache"]
+ *           },
+ *           "handler": {
+ *             "export": "urlForwardHandler",
+ *             "module": "$import(@zuplo/runtime)",
+ *             "options": { "baseUrl": "https://api.example.com" }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare const GraphQLCacheInboundPolicy: InboundPolicyHandler<GraphQLCacheInboundPolicyOptions>;
+
+/**
+ * The options for this policy.
+ * @public
+ */
+export declare interface GraphQLCacheInboundPolicyOptions {
+  /**
+   * The name of the cache used to store responses. Routes that share a name share a cache; use distinct names to isolate caches per route or per upstream.
+   */
+  cacheName?: string;
+  /**
+   * How long, in seconds, a cached response is served before it is considered stale and the next request is forwarded to the origin to refresh the entry.
+   */
+  ttlSeconds?: number;
+  /**
+   * Request header names whose values are included in the cache key (matched case-insensitively), and the control for how credentialed requests are cached. Omit this option (the default) and requests carrying an `authorization` or `cookie` header are not cached, to avoid serving one user's response to another. List those headers to cache such requests keyed per value, so each distinct value gets its own entry (a credential header you don't list still blocks caching, so a partial list fails safe). Set it to an empty array `[]` to cache a single response shared across all callers — only do this when the response does not depend on who is calling, as it disables the per-user safety check.
+   */
+  cacheKeyHeaders?: string[];
+}
+
 /**
  * Policy that limits the complexity and depth of GraphQL queries to prevent abuse.
  * Protects your GraphQL API from expensive queries that could cause performance issues

package/node_modules/@zuplo/graphql/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zuplo/graphql",
   "type": "module",
-  "version": "6.71.20",
+  "version": "6.71.22",
   "repository": "https://github.com/zuplo/zuplo",
   "author": "Zuplo, Inc.",
   "exports": {

package/node_modules/@zuplo/openapi-tools/package.json

@@ -2,7 +2,7 @@
   "name": "@zuplo/openapi-tools",
   "type": "module",
   "sideEffects": false,
-  "version": "6.71.20",
+  "version": "6.71.22",
   "description": "Tooling for OpenAPI files",
   "repository": {
     "type": "git",

package/node_modules/@zuplo/otel/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zuplo/otel",
   "type": "module",
-  "version": "6.71.20",
+  "version": "6.71.22",
   "repository": "https://github.com/zuplo/zuplo",
   "author": "Zuplo, Inc.",
   "exports": {