@effect-gql/persisted-queries 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Nick Fisher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/config.d.ts

@@ -0,0 +1,106 @@
+import { Config, Layer } from "effect";
+import type { PersistedQueryStore } from "./store";
+import type { MakeGraphQLRouterOptions } from "@effect-gql/core/server";
+/**
+ * Operating mode for persisted queries.
+ *
+ * - `"apq"`: Automatic Persisted Queries - clients can register queries at runtime
+ * - `"safelist"`: Only pre-registered queries are allowed (security mode)
+ */
+export type PersistedQueryMode = "apq" | "safelist";
+/**
+ * Hash algorithm used for query hashing.
+ * Must match what clients use - Apollo clients use SHA-256.
+ */
+export type HashAlgorithm = "sha256" | "sha512";
+/**
+ * Configuration for the persisted queries feature.
+ */
+export interface PersistedQueriesConfig {
+    /**
+     * Operating mode.
+     *
+     * - `"apq"`: Automatic Persisted Queries - clients can register queries at runtime.
+     *   Unknown hashes trigger PERSISTED_QUERY_NOT_FOUND, prompting clients to retry with query.
+     *
+     * - `"safelist"`: Only pre-registered queries are allowed.
+     *   Unknown hashes return PERSISTED_QUERY_NOT_ALLOWED error.
+     *   Use with `makeSafelistStore()` for production security.
+     *
+     * Default: `"apq"`
+     */
+    readonly mode?: PersistedQueryMode;
+    /**
+     * Layer providing the PersistedQueryStore service.
+     *
+     * Defaults to in-memory LRU store with 1000 entries.
+     * Use `makeMemoryStore()` for custom size or `makeSafelistStore()` for safelist mode.
+     *
+     * @example
+     * ```typescript
+     * // Custom memory store
+     * store: makeMemoryStore({ maxSize: 5000 })
+     *
+     * // Safelist store
+     * store: makeSafelistStore({ "hash1": "query {...}", "hash2": "query {...}" })
+     * ```
+     */
+    readonly store?: Layer.Layer<PersistedQueryStore>;
+    /**
+     * Whether to support GET requests with query parameters.
+     *
+     * When enabled, the router accepts:
+     * ```
+     * GET /graphql?extensions={"persistedQuery":{"version":1,"sha256Hash":"..."}}&variables={...}&operationName=...
+     * ```
+     *
+     * This enables CDN caching since the same hash always maps to the same URL.
+     *
+     * Default: `true`
+     */
+    readonly enableGet?: boolean;
+    /**
+     * Validate that the provided query matches its hash when storing.
+     *
+     * This prevents hash collision attacks where a malicious client could
+     * register a different query under someone else's hash.
+     *
+     * Has a slight performance overhead for computing the hash.
+     *
+     * Default: `true`
+     */
+    readonly validateHash?: boolean;
+    /**
+     * Hash algorithm to use for validation.
+     * Must match what clients use - Apollo clients use SHA-256.
+     *
+     * Default: `"sha256"`
+     */
+    readonly hashAlgorithm?: HashAlgorithm;
+}
+/**
+ * Options for the persisted queries router.
+ *
+ * Extends the standard GraphQL router options with persisted query configuration.
+ */
+export interface PersistedQueriesRouterOptions extends MakeGraphQLRouterOptions, PersistedQueriesConfig {
+}
+/**
+ * Effect Config for loading persisted queries settings from environment variables.
+ *
+ * Environment variables:
+ * - `PERSISTED_QUERIES_MODE`: `"apq"` | `"safelist"` (default: `"apq"`)
+ * - `PERSISTED_QUERIES_ENABLE_GET`: boolean (default: `true`)
+ * - `PERSISTED_QUERIES_VALIDATE_HASH`: boolean (default: `true`)
+ *
+ * Note: The store must still be provided programmatically.
+ *
+ * @example
+ * ```typescript
+ * import { PersistedQueriesConfigFromEnv } from "@effect-gql/persisted-queries"
+ *
+ * const config = yield* Config.unwrap(PersistedQueriesConfigFromEnv)
+ * ```
+ */
+export declare const PersistedQueriesConfigFromEnv: Config.Config<Omit<PersistedQueriesConfig, "store">>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAClD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,UAAU,CAAA;AAEnD;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE/C;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAA;IAElC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAA;IAEjD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAE5B;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;IAE/B;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAA;CACvC;AAED;;;;GAIG;AACH,MAAM,WAAW,6BACf,SAAQ,wBAAwB,EAAE,sBAAsB;CAAG;AAE7D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE,OAAO,CAAC,CAQ3F,CAAA"}

package/dist/config.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistedQueriesConfigFromEnv = void 0;
+const effect_1 = require("effect");
+/**
+ * Effect Config for loading persisted queries settings from environment variables.
+ *
+ * Environment variables:
+ * - `PERSISTED_QUERIES_MODE`: `"apq"` | `"safelist"` (default: `"apq"`)
+ * - `PERSISTED_QUERIES_ENABLE_GET`: boolean (default: `true`)
+ * - `PERSISTED_QUERIES_VALIDATE_HASH`: boolean (default: `true`)
+ *
+ * Note: The store must still be provided programmatically.
+ *
+ * @example
+ * ```typescript
+ * import { PersistedQueriesConfigFromEnv } from "@effect-gql/persisted-queries"
+ *
+ * const config = yield* Config.unwrap(PersistedQueriesConfigFromEnv)
+ * ```
+ */
+exports.PersistedQueriesConfigFromEnv = effect_1.Config.all({
+    mode: effect_1.Config.literal("apq", "safelist")("PERSISTED_QUERIES_MODE").pipe(effect_1.Config.withDefault("apq")),
+    enableGet: effect_1.Config.boolean("PERSISTED_QUERIES_ENABLE_GET").pipe(effect_1.Config.withDefault(true)),
+    validateHash: effect_1.Config.boolean("PERSISTED_QUERIES_VALIDATE_HASH").pipe(effect_1.Config.withDefault(true)),
+});
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAAA,mCAAsC;AAgGtC;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,6BAA6B,GACxC,eAAM,CAAC,GAAG,CAAC;IACT,IAAI,EAAE,eAAM,CAAC,OAAO,CAClB,KAAK,EACL,UAAU,CACX,CAAC,wBAAwB,CAAC,CAAC,IAAI,CAAC,eAAM,CAAC,WAAW,CAAC,KAAc,CAAC,CAAC;IACpE,SAAS,EAAE,eAAM,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC,IAAI,CAAC,eAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACxF,YAAY,EAAE,eAAM,CAAC,OAAO,CAAC,iCAAiC,CAAC,CAAC,IAAI,CAAC,eAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;CAC/F,CAAC,CAAA"}

package/dist/errors.d.ts

@@ -0,0 +1,77 @@
+/**
+ * GraphQL error format for APQ responses.
+ * Compatible with Apollo Client's error handling.
+ */
+export interface PersistedQueryGraphQLError {
+    readonly message: string;
+    readonly extensions: {
+        readonly code: string;
+        readonly [key: string]: unknown;
+    };
+}
+declare const PersistedQueryNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PersistedQueryNotFoundError";
+} & Readonly<A>;
+/**
+ * Error returned when a persisted query hash is not found in the store
+ * and no query body was provided.
+ *
+ * Apollo clients recognize this error and automatically retry with the full query.
+ * This is the expected flow for Automatic Persisted Queries (APQ).
+ */
+export declare class PersistedQueryNotFoundError extends PersistedQueryNotFoundError_base<{
+    readonly hash: string;
+}> {
+    /**
+     * Convert to GraphQL error format compatible with Apollo protocol.
+     */
+    toGraphQLError(): PersistedQueryGraphQLError;
+}
+declare const PersistedQueryVersionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PersistedQueryVersionError";
+} & Readonly<A>;
+/**
+ * Error returned when the persisted query protocol version is not supported.
+ *
+ * Currently only version 1 is supported, which uses SHA-256 hashing.
+ */
+export declare class PersistedQueryVersionError extends PersistedQueryVersionError_base<{
+    readonly version: number;
+}> {
+    toGraphQLError(): PersistedQueryGraphQLError;
+}
+declare const PersistedQueryHashMismatchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PersistedQueryHashMismatchError";
+} & Readonly<A>;
+/**
+ * Error returned when the provided query doesn't match its hash.
+ *
+ * This can indicate a client bug or a potential hash collision attack.
+ * Hash validation is enabled by default and can be disabled if needed.
+ */
+export declare class PersistedQueryHashMismatchError extends PersistedQueryHashMismatchError_base<{
+    readonly providedHash: string;
+    readonly computedHash: string;
+}> {
+    toGraphQLError(): PersistedQueryGraphQLError;
+}
+declare const PersistedQueryNotAllowedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PersistedQueryNotAllowedError";
+} & Readonly<A>;
+/**
+ * Error returned when trying to execute a query that is not in the safelist.
+ *
+ * In safelist mode, only pre-registered queries are allowed.
+ * This error is returned when a client tries to register a new query.
+ */
+export declare class PersistedQueryNotAllowedError extends PersistedQueryNotAllowedError_base<{
+    readonly hash: string;
+}> {
+    toGraphQLError(): PersistedQueryGraphQLError;
+}
+/**
+ * Union type of all APQ-related errors
+ */
+export type PersistedQueryError = PersistedQueryNotFoundError | PersistedQueryVersionError | PersistedQueryHashMismatchError | PersistedQueryNotAllowedError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE;QACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;QACrB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAChC,CAAA;CACF;;;;AAED;;;;;;GAMG;AACH,qBAAa,2BAA4B,SAAQ,iCAAgD;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA;;OAEG;IACH,cAAc,IAAI,0BAA0B;CAQ7C;;;;AAED;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,gCAA+C;IAC7F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB,CAAC;IACA,cAAc,IAAI,0BAA0B;CAS7C;;;;AAED;;;;;GAKG;AACH,qBAAa,+BAAgC,SAAQ,qCAEnD;IACA,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAC9B,CAAC;IACA,cAAc,IAAI,0BAA0B;CAQ7C;;;;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,mCAEjD;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA,cAAc,IAAI,0BAA0B;CAQ7C;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B,2BAA2B,GAC3B,0BAA0B,GAC1B,+BAA+B,GAC/B,6BAA6B,CAAA"}

package/dist/errors.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistedQueryNotAllowedError = exports.PersistedQueryHashMismatchError = exports.PersistedQueryVersionError = exports.PersistedQueryNotFoundError = void 0;
+const effect_1 = require("effect");
+/**
+ * Error returned when a persisted query hash is not found in the store
+ * and no query body was provided.
+ *
+ * Apollo clients recognize this error and automatically retry with the full query.
+ * This is the expected flow for Automatic Persisted Queries (APQ).
+ */
+class PersistedQueryNotFoundError extends effect_1.Data.TaggedError("PersistedQueryNotFoundError") {
+    /**
+     * Convert to GraphQL error format compatible with Apollo protocol.
+     */
+    toGraphQLError() {
+        return {
+            message: "PersistedQueryNotFound",
+            extensions: {
+                code: "PERSISTED_QUERY_NOT_FOUND",
+            },
+        };
+    }
+}
+exports.PersistedQueryNotFoundError = PersistedQueryNotFoundError;
+/**
+ * Error returned when the persisted query protocol version is not supported.
+ *
+ * Currently only version 1 is supported, which uses SHA-256 hashing.
+ */
+class PersistedQueryVersionError extends effect_1.Data.TaggedError("PersistedQueryVersionError") {
+    toGraphQLError() {
+        return {
+            message: `Unsupported persisted query version: ${this.version}`,
+            extensions: {
+                code: "PERSISTED_QUERY_VERSION_NOT_SUPPORTED",
+                version: this.version,
+            },
+        };
+    }
+}
+exports.PersistedQueryVersionError = PersistedQueryVersionError;
+/**
+ * Error returned when the provided query doesn't match its hash.
+ *
+ * This can indicate a client bug or a potential hash collision attack.
+ * Hash validation is enabled by default and can be disabled if needed.
+ */
+class PersistedQueryHashMismatchError extends effect_1.Data.TaggedError("PersistedQueryHashMismatchError") {
+    toGraphQLError() {
+        return {
+            message: "Query hash does not match provided hash",
+            extensions: {
+                code: "PERSISTED_QUERY_HASH_MISMATCH",
+            },
+        };
+    }
+}
+exports.PersistedQueryHashMismatchError = PersistedQueryHashMismatchError;
+/**
+ * Error returned when trying to execute a query that is not in the safelist.
+ *
+ * In safelist mode, only pre-registered queries are allowed.
+ * This error is returned when a client tries to register a new query.
+ */
+class PersistedQueryNotAllowedError extends effect_1.Data.TaggedError("PersistedQueryNotAllowedError") {
+    toGraphQLError() {
+        return {
+            message: "Query not in safelist",
+            extensions: {
+                code: "PERSISTED_QUERY_NOT_ALLOWED",
+            },
+        };
+    }
+}
+exports.PersistedQueryNotAllowedError = PersistedQueryNotAllowedError;
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAAA,mCAA6B;AAc7B;;;;;;GAMG;AACH,MAAa,2BAA4B,SAAQ,aAAI,CAAC,WAAW,CAAC,6BAA6B,CAE7F;IACA;;OAEG;IACH,cAAc;QACZ,OAAO;YACL,OAAO,EAAE,wBAAwB;YACjC,UAAU,EAAE;gBACV,IAAI,EAAE,2BAA2B;aAClC;SACF,CAAA;IACH,CAAC;CACF;AAdD,kEAcC;AAED;;;;GAIG;AACH,MAAa,0BAA2B,SAAQ,aAAI,CAAC,WAAW,CAAC,4BAA4B,CAE3F;IACA,cAAc;QACZ,OAAO;YACL,OAAO,EAAE,wCAAwC,IAAI,CAAC,OAAO,EAAE;YAC/D,UAAU,EAAE;gBACV,IAAI,EAAE,uCAAuC;gBAC7C,OAAO,EAAE,IAAI,CAAC,OAAO;aACtB;SACF,CAAA;IACH,CAAC;CACF;AAZD,gEAYC;AAED;;;;;GAKG;AACH,MAAa,+BAAgC,SAAQ,aAAI,CAAC,WAAW,CACnE,iCAAiC,CAIjC;IACA,cAAc;QACZ,OAAO;YACL,OAAO,EAAE,yCAAyC;YAClD,UAAU,EAAE;gBACV,IAAI,EAAE,+BAA+B;aACtC;SACF,CAAA;IACH,CAAC;CACF;AAdD,0EAcC;AAED;;;;;GAKG;AACH,MAAa,6BAA8B,SAAQ,aAAI,CAAC,WAAW,CACjE,+BAA+B,CAG/B;IACA,cAAc;QACZ,OAAO;YACL,OAAO,EAAE,uBAAuB;YAChC,UAAU,EAAE;gBACV,IAAI,EAAE,6BAA6B;aACpC;SACF,CAAA;IACH,CAAC;CACF;AAbD,sEAaC"}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @effect-gql/persisted-queries
+ *
+ * Apollo Persisted Queries support for Effect GraphQL.
+ *
+ * Supports both Automatic Persisted Queries (APQ) mode for runtime registration
+ * and Safelist mode for pre-registered query allowlisting.
+ *
+ * ## Quick Start
+ *
+ * @example APQ Mode (runtime registration)
+ * ```typescript
+ * import { makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
+ *
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   mode: "apq",
+ *   enableGet: true, // Enable CDN caching
+ *   graphiql: { path: "/graphiql" },
+ * })
+ * ```
+ *
+ * @example Safelist Mode (pre-registered queries only)
+ * ```typescript
+ * import { makePersistedQueriesRouter, makeSafelistStore } from "@effect-gql/persisted-queries"
+ *
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   mode: "safelist",
+ *   store: makeSafelistStore({
+ *     "ecf4edb46db40b5132295c0291d62fb65d6759a9eedfa4d5d612dd5ec54a6b38": "query GetUser($id: ID!) { user(id: $id) { name email } }",
+ *     "a1b2c3d4...": "query GetPosts { posts { title } }",
+ *   }),
+ * })
+ * ```
+ *
+ * @example Custom Store Size
+ * ```typescript
+ * import { makePersistedQueriesRouter, makeMemoryStore } from "@effect-gql/persisted-queries"
+ *
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   store: makeMemoryStore({ maxSize: 5000 }),
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { makePersistedQueriesRouter } from "./persisted-queries-router";
+export { PersistedQueryStore } from "./store";
+export type { PersistedQueryStore as PersistedQueryStoreInterface } from "./store";
+export { makeMemoryStore, makeSafelistStore } from "./memory-store";
+export type { MemoryStoreConfig } from "./memory-store";
+export type { PersistedQueriesConfig, PersistedQueriesRouterOptions, PersistedQueryMode, HashAlgorithm, } from "./config";
+export { PersistedQueriesConfigFromEnv } from "./config";
+export { PersistedQueryNotFoundError, PersistedQueryVersionError, PersistedQueryHashMismatchError, PersistedQueryNotAllowedError, type PersistedQueryError, type PersistedQueryGraphQLError, } from "./errors";
+export { computeHash, parsePersistedQueryExtension, parseGetRequestBody } from "./utils";
+export type { PersistedQueryExtension, GraphQLRequestBody } from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;AAGvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAC7C,YAAY,EAAE,mBAAmB,IAAI,4BAA4B,EAAE,MAAM,SAAS,CAAA;AAClF,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AACnE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAGvD,YAAY,EACV,sBAAsB,EACtB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,GACd,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAGxD,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,EAC1B,+BAA+B,EAC/B,6BAA6B,EAC7B,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,GAChC,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AACxF,YAAY,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * @effect-gql/persisted-queries
+ *
+ * Apollo Persisted Queries support for Effect GraphQL.
+ *
+ * Supports both Automatic Persisted Queries (APQ) mode for runtime registration
+ * and Safelist mode for pre-registered query allowlisting.
+ *
+ * ## Quick Start
+ *
+ * @example APQ Mode (runtime registration)
+ * ```typescript
+ * import { makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
+ *
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   mode: "apq",
+ *   enableGet: true, // Enable CDN caching
+ *   graphiql: { path: "/graphiql" },
+ * })
+ * ```
+ *
+ * @example Safelist Mode (pre-registered queries only)
+ * ```typescript
+ * import { makePersistedQueriesRouter, makeSafelistStore } from "@effect-gql/persisted-queries"
+ *
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   mode: "safelist",
+ *   store: makeSafelistStore({
+ *     "ecf4edb46db40b5132295c0291d62fb65d6759a9eedfa4d5d612dd5ec54a6b38": "query GetUser($id: ID!) { user(id: $id) { name email } }",
+ *     "a1b2c3d4...": "query GetPosts { posts { title } }",
+ *   }),
+ * })
+ * ```
+ *
+ * @example Custom Store Size
+ * ```typescript
+ * import { makePersistedQueriesRouter, makeMemoryStore } from "@effect-gql/persisted-queries"
+ *
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   store: makeMemoryStore({ maxSize: 5000 }),
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGetRequestBody = exports.parsePersistedQueryExtension = exports.computeHash = exports.PersistedQueryNotAllowedError = exports.PersistedQueryHashMismatchError = exports.PersistedQueryVersionError = exports.PersistedQueryNotFoundError = exports.PersistedQueriesConfigFromEnv = exports.makeSafelistStore = exports.makeMemoryStore = exports.PersistedQueryStore = exports.makePersistedQueriesRouter = void 0;
+// Router
+var persisted_queries_router_1 = require("./persisted-queries-router");
+Object.defineProperty(exports, "makePersistedQueriesRouter", { enumerable: true, get: function () { return persisted_queries_router_1.makePersistedQueriesRouter; } });
+// Store interface and implementations
+var store_1 = require("./store");
+Object.defineProperty(exports, "PersistedQueryStore", { enumerable: true, get: function () { return store_1.PersistedQueryStore; } });
+var memory_store_1 = require("./memory-store");
+Object.defineProperty(exports, "makeMemoryStore", { enumerable: true, get: function () { return memory_store_1.makeMemoryStore; } });
+Object.defineProperty(exports, "makeSafelistStore", { enumerable: true, get: function () { return memory_store_1.makeSafelistStore; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "PersistedQueriesConfigFromEnv", { enumerable: true, get: function () { return config_1.PersistedQueriesConfigFromEnv; } });
+// Errors
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "PersistedQueryNotFoundError", { enumerable: true, get: function () { return errors_1.PersistedQueryNotFoundError; } });
+Object.defineProperty(exports, "PersistedQueryVersionError", { enumerable: true, get: function () { return errors_1.PersistedQueryVersionError; } });
+Object.defineProperty(exports, "PersistedQueryHashMismatchError", { enumerable: true, get: function () { return errors_1.PersistedQueryHashMismatchError; } });
+Object.defineProperty(exports, "PersistedQueryNotAllowedError", { enumerable: true, get: function () { return errors_1.PersistedQueryNotAllowedError; } });
+// Utilities
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "computeHash", { enumerable: true, get: function () { return utils_1.computeHash; } });
+Object.defineProperty(exports, "parsePersistedQueryExtension", { enumerable: true, get: function () { return utils_1.parsePersistedQueryExtension; } });
+Object.defineProperty(exports, "parseGetRequestBody", { enumerable: true, get: function () { return utils_1.parseGetRequestBody; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;;;AAEH,SAAS;AACT,uEAAuE;AAA9D,sIAAA,0BAA0B,OAAA;AAEnC,sCAAsC;AACtC,iCAA6C;AAApC,4GAAA,mBAAmB,OAAA;AAE5B,+CAAmE;AAA1D,+GAAA,eAAe,OAAA;AAAE,iHAAA,iBAAiB,OAAA;AAU3C,mCAAwD;AAA/C,uHAAA,6BAA6B,OAAA;AAEtC,SAAS;AACT,mCAOiB;AANf,qHAAA,2BAA2B,OAAA;AAC3B,oHAAA,0BAA0B,OAAA;AAC1B,yHAAA,+BAA+B,OAAA;AAC/B,uHAAA,6BAA6B,OAAA;AAK/B,YAAY;AACZ,iCAAwF;AAA/E,oGAAA,WAAW,OAAA;AAAE,qHAAA,4BAA4B,OAAA;AAAE,4GAAA,mBAAmB,OAAA"}

package/dist/memory-store.d.ts

@@ -0,0 +1,67 @@
+import { Layer } from "effect";
+import { PersistedQueryStore } from "./store";
+/**
+ * Configuration for the in-memory LRU store
+ */
+export interface MemoryStoreConfig {
+    /**
+     * Maximum number of queries to cache.
+     * When exceeded, least recently used queries are evicted.
+     * Default: 1000
+     */
+    readonly maxSize?: number;
+}
+/**
+ * Create an in-memory LRU (Least Recently Used) store for persisted queries.
+ *
+ * This implementation uses Map's natural insertion order for O(1) LRU operations:
+ * - get: O(1) - delete and re-insert to move to end (most recently used)
+ * - set: O(1) - insert at end, evict from front if needed
+ * - eviction: O(1) - delete first entry (least recently used)
+ *
+ * This is the default store implementation suitable for single-instance servers.
+ * For multi-instance deployments, consider using a shared store like Redis.
+ *
+ * @param config - Optional configuration for cache size
+ * @returns A Layer providing the PersistedQueryStore service
+ *
+ * @example
+ * ```typescript
+ * import { makeMemoryStore, makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
+ *
+ * // Default store with 1000 entry limit
+ * const router1 = makePersistedQueriesRouter(schema, serviceLayer)
+ *
+ * // Custom store with larger cache
+ * const router2 = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   store: makeMemoryStore({ maxSize: 5000 })
+ * })
+ * ```
+ */
+export declare const makeMemoryStore: (config?: MemoryStoreConfig) => Layer.Layer<PersistedQueryStore>;
+/**
+ * Create a pre-populated safelist store.
+ *
+ * This store only allows queries that were provided at creation time.
+ * Any attempt to store new queries is silently ignored.
+ * Use this for production security where you want to allowlist specific operations.
+ *
+ * @param queries - Record mapping SHA-256 hashes to query strings
+ * @returns A Layer providing the PersistedQueryStore service
+ *
+ * @example
+ * ```typescript
+ * import { makeSafelistStore, makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
+ *
+ * // Pre-register allowed queries
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   mode: "safelist",
+ *   store: makeSafelistStore({
+ *     "ecf4edb46db40b5132295c0291d62fb65d6759a9eedfa4d5d612dd5ec54a6b38": "query GetUser($id: ID!) { user(id: $id) { name email } }",
+ *     "a1b2c3d4...": "query GetPosts { posts { title } }",
+ *   }),
+ * })
+ * ```
+ */
+export declare const makeSafelistStore: (queries: Record<string, string>) => Layer.Layer<PersistedQueryStore>;
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../src/memory-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAU,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAE7C;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAQ,iBAAsB,KAC7B,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAgDjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC9B,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAY/B,CAAA"}

package/dist/memory-store.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSafelistStore = exports.makeMemoryStore = void 0;
+const effect_1 = require("effect");
+const store_1 = require("./store");
+/**
+ * Create an in-memory LRU (Least Recently Used) store for persisted queries.
+ *
+ * This implementation uses Map's natural insertion order for O(1) LRU operations:
+ * - get: O(1) - delete and re-insert to move to end (most recently used)
+ * - set: O(1) - insert at end, evict from front if needed
+ * - eviction: O(1) - delete first entry (least recently used)
+ *
+ * This is the default store implementation suitable for single-instance servers.
+ * For multi-instance deployments, consider using a shared store like Redis.
+ *
+ * @param config - Optional configuration for cache size
+ * @returns A Layer providing the PersistedQueryStore service
+ *
+ * @example
+ * ```typescript
+ * import { makeMemoryStore, makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
+ *
+ * // Default store with 1000 entry limit
+ * const router1 = makePersistedQueriesRouter(schema, serviceLayer)
+ *
+ * // Custom store with larger cache
+ * const router2 = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   store: makeMemoryStore({ maxSize: 5000 })
+ * })
+ * ```
+ */
+const makeMemoryStore = (config = {}) => {
+    const maxSize = config.maxSize ?? 1000;
+    // Map maintains insertion order - we use this for O(1) LRU
+    // First entry = least recently used, last entry = most recently used
+    const cache = new Map();
+    // Move entry to end (most recently used) by deleting and re-inserting
+    const touch = (hash, query) => {
+        cache.delete(hash);
+        cache.set(hash, query);
+    };
+    // Evict oldest entry (first in Map) if over capacity - O(1)
+    const evictIfNeeded = () => {
+        if (cache.size <= maxSize)
+            return;
+        // Map.keys().next() gives us the first (oldest) key in O(1)
+        const oldestKey = cache.keys().next().value;
+        if (oldestKey !== undefined) {
+            cache.delete(oldestKey);
+        }
+    };
+    return effect_1.Layer.succeed(store_1.PersistedQueryStore, store_1.PersistedQueryStore.of({
+        get: (hash) => effect_1.Effect.sync(() => {
+            const query = cache.get(hash);
+            if (query === undefined) {
+                return effect_1.Option.none();
+            }
+            // Move to end (most recently used)
+            touch(hash, query);
+            return effect_1.Option.some(query);
+        }),
+        set: (hash, query) => effect_1.Effect.sync(() => {
+            // If key exists, delete first to ensure it moves to end
+            cache.delete(hash);
+            cache.set(hash, query);
+            evictIfNeeded();
+        }),
+        has: (hash) => effect_1.Effect.sync(() => cache.has(hash)),
+    }));
+};
+exports.makeMemoryStore = makeMemoryStore;
+/**
+ * Create a pre-populated safelist store.
+ *
+ * This store only allows queries that were provided at creation time.
+ * Any attempt to store new queries is silently ignored.
+ * Use this for production security where you want to allowlist specific operations.
+ *
+ * @param queries - Record mapping SHA-256 hashes to query strings
+ * @returns A Layer providing the PersistedQueryStore service
+ *
+ * @example
+ * ```typescript
+ * import { makeSafelistStore, makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
+ *
+ * // Pre-register allowed queries
+ * const router = makePersistedQueriesRouter(schema, serviceLayer, {
+ *   mode: "safelist",
+ *   store: makeSafelistStore({
+ *     "ecf4edb46db40b5132295c0291d62fb65d6759a9eedfa4d5d612dd5ec54a6b38": "query GetUser($id: ID!) { user(id: $id) { name email } }",
+ *     "a1b2c3d4...": "query GetPosts { posts { title } }",
+ *   }),
+ * })
+ * ```
+ */
+const makeSafelistStore = (queries) => effect_1.Layer.succeed(store_1.PersistedQueryStore, store_1.PersistedQueryStore.of({
+    get: (hash) => effect_1.Effect.succeed(queries[hash] !== undefined ? effect_1.Option.some(queries[hash]) : effect_1.Option.none()),
+    // No-op for safelist mode - queries cannot be added at runtime
+    set: () => effect_1.Effect.void,
+    has: (hash) => effect_1.Effect.succeed(queries[hash] !== undefined),
+}));
+exports.makeSafelistStore = makeSafelistStore;
+//# sourceMappingURL=memory-store.js.map

package/dist/memory-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.js","sourceRoot":"","sources":["../src/memory-store.ts"],"names":[],"mappings":";;;AAAA,mCAA8C;AAC9C,mCAA6C;AAc7C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACI,MAAM,eAAe,GAAG,CAC7B,SAA4B,EAAE,EACI,EAAE;IACpC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,IAAI,CAAA;IAEtC,2DAA2D;IAC3D,qEAAqE;IACrE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAA;IAEvC,sEAAsE;IACtE,MAAM,KAAK,GAAG,CAAC,IAAY,EAAE,KAAa,EAAQ,EAAE;QAClD,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAClB,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IACxB,CAAC,CAAA;IAED,4DAA4D;IAC5D,MAAM,aAAa,GAAG,GAAS,EAAE;QAC/B,IAAI,KAAK,CAAC,IAAI,IAAI,OAAO;YAAE,OAAM;QACjC,4DAA4D;QAC5D,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAA;QAC3C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;QACzB,CAAC;IACH,CAAC,CAAA;IAED,OAAO,cAAK,CAAC,OAAO,CAClB,2BAAmB,EACnB,2BAAmB,CAAC,EAAE,CAAC;QACrB,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CACZ,eAAM,CAAC,IAAI,CAAC,GAAG,EAAE;YACf,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAC7B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,OAAO,eAAM,CAAC,IAAI,EAAU,CAAA;YAC9B,CAAC;YACD,mCAAmC;YACnC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;YAClB,OAAO,eAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC,CAAC;QAEJ,GAAG,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CACnB,eAAM,CAAC,IAAI,CAAC,GAAG,EAAE;YACf,wDAAwD;YACxD,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YAClB,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;YACtB,aAAa,EAAE,CAAA;QACjB,CAAC,CAAC;QAEJ,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,eAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;KAClD,CAAC,CACH,CAAA;AACH,CAAC,CAAA;AAlDY,QAAA,eAAe,mBAkD3B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,OAA+B,EACG,EAAE,CACpC,cAAK,CAAC,OAAO,CACX,2BAAmB,EACnB,2BAAmB,CAAC,EAAE,CAAC;IACrB,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CACZ,eAAM,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,eAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,eAAM,CAAC,IAAI,EAAE,CAAC;IAE1F,+DAA+D;IAC/D,GAAG,EAAE,GAAG,EAAE,CAAC,eAAM,CAAC,IAAI;IAEtB,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,eAAM,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC;CAC3D,CAAC,CACH,CAAA;AAdU,QAAA,iBAAiB,qBAc3B"}