@effect-gql/persisted-queries 0.1.0 → 1.0.0

package/dist/errors.d.ts

@@ -1,77 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,77 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,56 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,71 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,67 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,104 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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"}

package/dist/persisted-queries-router.d.ts

@@ -1,58 +0,0 @@
-import { HttpRouter } from "@effect/platform";
-import { Layer } from "effect";
-import { GraphQLSchema } from "graphql";
-import type { PersistedQueriesRouterOptions } from "./config";
-/**
- * Create a GraphQL router with Apollo Persisted Queries support.
- *
- * This creates a complete GraphQL router that includes:
- * - Apollo Persisted Queries (APQ) support
- * - GET request support for CDN caching
- * - All standard GraphQL router features (validation, execution, extensions)
- *
- * ## Apollo APQ Protocol
- *
- * 1. Client sends request with `extensions.persistedQuery.sha256Hash`
- * 2. If hash found in store, execute the stored query
- * 3. If hash NOT found and query provided (APQ mode), store it and execute
- * 4. If hash NOT found and NO query, return `PERSISTED_QUERY_NOT_FOUND`
- * 5. Client retries with both hash and query
- *
- * ## Modes
- *
- * - **APQ mode** (`mode: "apq"`): Automatic runtime registration.
- *   Unknown queries trigger NOT_FOUND, prompting client retry with full query.
- *
- * - **Safelist mode** (`mode: "safelist"`): Pre-registered queries only.
- *   Unknown queries return NOT_ALLOWED error. Use with `makeSafelistStore()`.
- *
- * @example APQ Mode (default)
- * ```typescript
- * import { makePersistedQueriesRouter } from "@effect-gql/persisted-queries"
- *
- * const router = makePersistedQueriesRouter(schema, serviceLayer, {
- *   mode: "apq",
- *   enableGet: true,
- *   graphiql: { path: "/graphiql" },
- * })
- * ```
- *
- * @example Safelist Mode
- * ```typescript
- * import { makePersistedQueriesRouter, makeSafelistStore } from "@effect-gql/persisted-queries"
- *
- * const router = makePersistedQueriesRouter(schema, serviceLayer, {
- *   mode: "safelist",
- *   store: makeSafelistStore({
- *     "abc123...": "query GetUser($id: ID!) { user(id: $id) { name } }",
- *   }),
- * })
- * ```
- *
- * @param schema - The GraphQL schema
- * @param layer - Effect layer providing services required by resolvers
- * @param options - Router and persisted query configuration
- * @returns An HttpRouter with persisted query support
- */
-export declare const makePersistedQueriesRouter: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: PersistedQueriesRouterOptions) => HttpRouter.HttpRouter<never, never>;
-//# sourceMappingURL=persisted-queries-router.d.ts.map

package/dist/persisted-queries-router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persisted-queries-router.d.ts","sourceRoot":"","sources":["../src/persisted-queries-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyC,MAAM,kBAAkB,CAAA;AACpF,OAAO,EAAU,KAAK,EAAU,MAAM,QAAQ,CAAA;AAC9C,OAAO,EACL,aAAa,EAOd,MAAM,SAAS,CAAA;AAsBhB,OAAO,KAAK,EAAE,6BAA6B,EAAqC,MAAM,UAAU,CAAA;AAchG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,EAC1C,QAAQ,aAAa,EACrB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EACrB,UAAS,6BAAkC,KAC1C,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CA8TpC,CAAA"}