@webiny/api-graphql 0.0.0-unstable.0d717d18dd → 0.0.0-unstable.5387e5f7c8

package/engine/GraphQLEngine.d.ts

@@ -1,18 +1,20 @@
 import { Container } from "@webiny/di";
 import { GraphQLEngine as GraphQLEngineAbstraction } from "./abstractions.js";
+import { GraphQLSchemaCache } from "./abstractions.js";
 import type { IGraphQLSchemaComposer } from "../features/GraphQLSchemaBuilder/abstractions.js";
-import type { IGraphQLContextEnhancer } from "./GraphQLContextEnhancer.js";
-import type { IGraphQLContextualSchema } from "./GraphQLContextualSchema.js";
 declare class GraphQLEngineImpl implements GraphQLEngineAbstraction.Interface {
     private composer;
     private container;
-    private enhancers;
-    private contextualSchemas;
-    constructor(composer: IGraphQLSchemaComposer, container: Container, enhancers: IGraphQLContextEnhancer[], contextualSchemas: IGraphQLContextualSchema[]);
+    private schemaCache;
+    constructor(composer: IGraphQLSchemaComposer, container: Container, schemaCache: GraphQLSchemaCache.Interface | undefined);
     execute(body: any): Promise<any>;
-    private buildContext;
-    private buildContextualSchemas;
-    private buildSchema;
+    /**
+     * The same composer output always builds the same executable schema, so with a cache in the
+     * root container it's built once and reused. When every schema factory has a schema key, the key
+     * comes from those and the factories only run on a cache miss. Otherwise they run on every
+     * request, and the key comes from what they produced.
+     */
+    private resolveSchema;
     private executeOne;
 }
 export declare const GraphQLEngine: typeof GraphQLEngineImpl & {

package/engine/GraphQLEngine.js

@@ -1,63 +1,55 @@
 import { graphql } from "graphql";
-import { makeExecutableSchema, mergeSchemas } from "@graphql-tools/schema";
+import { makeExecutableSchema } from "@graphql-tools/schema";
 import { mergeResolvers } from "@graphql-tools/merge";
 import { RequestContainer } from "@webiny/event-handler-core";
-import { GraphQLEngine } from "./abstractions.js";
-import { GraphQLContextEnhancer } from "./GraphQLContextEnhancer.js";
-import { GraphQLContextualSchema } from "./GraphQLContextualSchema.js";
+import { GraphQLEngine, GraphQLSchemaCache } from "./abstractions.js";
+import { createSchemaCacheKey } from "./createSchemaCacheKey.js";
 import { GraphQLSchemaComposer } from "../features/GraphQLSchemaBuilder/abstractions.js";
 import { ResolverDecoration } from "../ResolverDecoration.js";
 import { createRequestBody } from "../createRequestBody.js";
+const buildStaticSchema = (schemaConfig)=>{
+    const resolverDecoration = new ResolverDecoration();
+    if (schemaConfig.resolverDecorators) resolverDecoration.addDecorators(schemaConfig.resolverDecorators);
+    const typeDefs = `type Query\ntype Mutation\n${schemaConfig.typeDefs ?? ""}`;
+    const resolvers = mergeResolvers([
+        schemaConfig.resolvers ?? {}
+    ]);
+    return makeExecutableSchema({
+        typeDefs,
+        resolvers: resolverDecoration.decorateResolvers(resolvers),
+        assumeValidSDL: true,
+        inheritResolversFromInterfaces: true,
+        updateResolversInPlace: true
+    });
+};
+const composeAndBuild = async (composer)=>{
+    const schemaConfig = await composer.build();
+    return buildStaticSchema(schemaConfig);
+};
 class GraphQLEngineImpl {
-    constructor(composer, container, enhancers, contextualSchemas){
+    constructor(composer, container, schemaCache){
         this.composer = composer;
         this.container = container;
-        this.enhancers = enhancers;
-        this.contextualSchemas = contextualSchemas;
+        this.schemaCache = schemaCache;
     }
     async execute(body) {
-        const ctx = await this.buildContext();
-        const extraSchemas = await this.buildContextualSchemas(ctx);
-        const schemaConfig = await this.composer.build(ctx);
-        const resolverDecoration = new ResolverDecoration();
-        if (schemaConfig.resolverDecorators) resolverDecoration.addDecorators(schemaConfig.resolverDecorators);
-        const typeDefs = `type Query\ntype Mutation\n${schemaConfig.typeDefs ?? ""}`;
-        const staticSchema = makeExecutableSchema({
-            typeDefs,
-            resolvers: resolverDecoration.decorateResolvers(mergeResolvers([
-                schemaConfig.resolvers ?? {}
-            ])),
-            assumeValidSDL: true,
-            inheritResolversFromInterfaces: true
-        });
-        const schema = await this.buildSchema(staticSchema, extraSchemas);
+        const ctx = {
+            container: this.container
+        };
+        const schema = await this.resolveSchema();
         const parsed = createRequestBody(body);
         if (!Array.isArray(parsed)) return this.executeOne(parsed, schema, ctx);
         const results = [];
         for (const b of parsed)results.push(await this.executeOne(b, schema, ctx));
         return results;
     }
-    async buildContext() {
-        const ctx = {
-            container: this.container
-        };
-        for (const enhancer of this.enhancers)await enhancer.enhance(ctx);
-        return ctx;
-    }
-    async buildContextualSchemas(ctx) {
-        if (0 === this.contextualSchemas.length) return [];
-        const schemas = [];
-        for (const s of this.contextualSchemas)schemas.push(await s.build(ctx));
-        return schemas;
-    }
-    async buildSchema(staticSchema, extraSchemas) {
-        if (0 === extraSchemas.length) return staticSchema;
-        return mergeSchemas({
-            schemas: [
-                staticSchema,
-                ...extraSchemas
-            ]
-        });
+    async resolveSchema() {
+        if (!this.schemaCache) return composeAndBuild(this.composer);
+        const factoriesKey = await this.composer.getSchemaKey();
+        if (factoriesKey) return this.schemaCache.getOrBuild(`factories:${factoriesKey}`, ()=>composeAndBuild(this.composer));
+        const schemaConfig = await this.composer.build();
+        const contentKey = createSchemaCacheKey(schemaConfig);
+        return this.schemaCache.getOrBuild(`content:${contentKey}`, async ()=>buildStaticSchema(schemaConfig));
     }
     async executeOne(body, schema, ctx) {
         const { query, variables, operationName } = body;
@@ -77,15 +69,9 @@ const GraphQLEngine_GraphQLEngine = GraphQLEngine.createImplementation({
         GraphQLSchemaComposer,
         RequestContainer,
         [
-            GraphQLContextEnhancer,
-            {
-                multiple: true
-            }
-        ],
-        [
-            GraphQLContextualSchema,
+            GraphQLSchemaCache,
             {
-                multiple: true
+                optional: true
             }
         ]
     ]

package/engine/GraphQLEngine.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine/GraphQLEngine.js","sources":["../../src/engine/GraphQLEngine.ts"],"sourcesContent":["import { graphql } from \"graphql\";\nimport { makeExecutableSchema, mergeSchemas } from \"@graphql-tools/schema\";\nimport { mergeResolvers } from \"@graphql-tools/merge\";\nimport { Container } from \"@webiny/di\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport { GraphQLEngine as GraphQLEngineAbstraction } from \"./abstractions.js\";\nimport { GraphQLContextEnhancer } from \"./GraphQLContextEnhancer.js\";\nimport { GraphQLContextualSchema } from \"./GraphQLContextualSchema.js\";\nimport { GraphQLSchemaComposer } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\nimport { ResolverDecoration } from \"~/ResolverDecoration.js\";\nimport { createRequestBody } from \"~/createRequestBody.js\";\nimport type { IGraphQLSchemaComposer } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\nimport type { IGraphQLContextEnhancer } from \"./GraphQLContextEnhancer.js\";\nimport type { IGraphQLContextualSchema } from \"./GraphQLContextualSchema.js\";\nimport type { GraphQLRequestBody } from \"~/types.js\";\nimport type { GraphQLSchema } from \"graphql\";\n\nclass GraphQLEngineImpl implements GraphQLEngineAbstraction.Interface {\n    constructor(\n        private composer: IGraphQLSchemaComposer,\n        private container: Container,\n        private enhancers: IGraphQLContextEnhancer[],\n        private contextualSchemas: IGraphQLContextualSchema[]\n    ) {}\n\n    async execute(body: any): Promise<any> {\n        // Build context first — enhancers may be async (e.g. CMS storage init)\n        const ctx = await this.buildContext();\n\n        // NOTE: the post-auth RequestContextInitializers (CMS facade, FileModel, ...) are run once\n        // per request by the HTTP layer (RequestContextInitializerDecorator in event-handler-core),\n        // before the router dispatches — so they cover every route, not just GraphQL. Their side-\n        // effects are container registrations, which persist and are resolvable here.\n\n        // Run contextual schemas BEFORE composer.build() so that any CoreGraphQLSchemaFactory\n        // registrations they make (e.g. ACO folder schema plugins) are picked up by GraphQLSchemaComposer.\n        const extraSchemas = await this.buildContextualSchemas(ctx);\n\n        const schemaConfig = await this.composer.build(ctx);\n\n        const resolverDecoration = new ResolverDecoration();\n        if (schemaConfig.resolverDecorators) {\n            resolverDecoration.addDecorators(schemaConfig.resolverDecorators);\n        }\n\n        // Always provide base root types so that `extend type Query/Mutation` works without\n        // requiring callers to define them. With assumeValidSDL:true, empty base types are\n        // allowed at build time; graphql() then returns schema-validation errors at execution\n        // time (e.g. \"Type Query must define one or more fields.\") when no fields are registered.\n        const typeDefs = `type Query\\ntype Mutation\\n${schemaConfig.typeDefs ?? \"\"}`;\n        const staticSchema = makeExecutableSchema({\n            typeDefs,\n            resolvers: resolverDecoration.decorateResolvers(\n                mergeResolvers([schemaConfig.resolvers ?? {}])\n            ),\n            assumeValidSDL: true,\n            inheritResolversFromInterfaces: true\n        });\n\n        const schema = await this.buildSchema(staticSchema, extraSchemas);\n        const parsed = createRequestBody(body);\n\n        if (!Array.isArray(parsed)) {\n            return this.executeOne(parsed, schema, ctx);\n        }\n        // Run sequentially so per-request state (e.g. ctx.debug.logs) is scoped per query.\n        const results = [];\n        for (const b of parsed) {\n            results.push(await this.executeOne(b, schema, ctx));\n        }\n        return results;\n    }\n\n    private async buildContext(): Promise<Record<string, any>> {\n        const ctx: Record<string, any> = { container: this.container };\n        for (const enhancer of this.enhancers) {\n            await enhancer.enhance(ctx);\n        }\n        return ctx;\n    }\n\n    private async buildContextualSchemas(ctx: Record<string, any>): Promise<GraphQLSchema[]> {\n        if (this.contextualSchemas.length === 0) {\n            return [];\n        }\n        // Sequential — schemas may have ordering dependencies (e.g. Aco needs ctx.cms from HeadlessCms).\n        const schemas: GraphQLSchema[] = [];\n        for (const s of this.contextualSchemas) {\n            schemas.push(await s.build(ctx));\n        }\n        return schemas;\n    }\n\n    private async buildSchema(\n        staticSchema: GraphQLSchema,\n        extraSchemas: GraphQLSchema[]\n    ): Promise<GraphQLSchema> {\n        if (extraSchemas.length === 0) {\n            return staticSchema;\n        }\n        return mergeSchemas({ schemas: [staticSchema, ...extraSchemas] });\n    }\n\n    private async executeOne(\n        body: GraphQLRequestBody,\n        schema: GraphQLSchema,\n        ctx: Record<string, any>\n    ): Promise<any> {\n        const { query, variables, operationName } = body;\n\n        return graphql({\n            schema,\n            source: query,\n            rootValue: {},\n            contextValue: ctx,\n            variableValues: variables ?? undefined,\n            operationName: operationName ?? undefined\n        });\n    }\n}\n\nexport const GraphQLEngine = GraphQLEngineAbstraction.createImplementation({\n    implementation: GraphQLEngineImpl,\n    dependencies: [\n        GraphQLSchemaComposer,\n        RequestContainer,\n        [GraphQLContextEnhancer, { multiple: true }],\n        [GraphQLContextualSchema, { multiple: true }]\n    ]\n});\n"],"names":["GraphQLEngineImpl","composer","container","enhancers","contextualSchemas","body","ctx","extraSchemas","schemaConfig","resolverDecoration","ResolverDecoration","typeDefs","staticSchema","makeExecutableSchema","mergeResolvers","schema","parsed","createRequestBody","Array","results","b","enhancer","schemas","s","mergeSchemas","query","variables","operationName","graphql","undefined","GraphQLEngine","GraphQLEngineAbstraction","GraphQLSchemaComposer","RequestContainer","GraphQLContextEnhancer","GraphQLContextualSchema"],"mappings":";;;;;;;;;;AAiBA,MAAMA;IACF,YACYC,QAAgC,EAChCC,SAAoB,EACpBC,SAAoC,EACpCC,iBAA6C,CACvD;aAJUH,QAAQ,GAARA;aACAC,SAAS,GAATA;aACAC,SAAS,GAATA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAM,QAAQC,IAAS,EAAgB;QAEnC,MAAMC,MAAM,MAAM,IAAI,CAAC,YAAY;QASnC,MAAMC,eAAe,MAAM,IAAI,CAAC,sBAAsB,CAACD;QAEvD,MAAME,eAAe,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAACF;QAE/C,MAAMG,qBAAqB,IAAIC;QAC/B,IAAIF,aAAa,kBAAkB,EAC/BC,mBAAmB,aAAa,CAACD,aAAa,kBAAkB;QAOpE,MAAMG,WAAW,CAAC,2BAA2B,EAAEH,aAAa,QAAQ,IAAI,IAAI;QAC5E,MAAMI,eAAeC,qBAAqB;YACtCF;YACA,WAAWF,mBAAmB,iBAAiB,CAC3CK,eAAe;gBAACN,aAAa,SAAS,IAAI,CAAC;aAAE;YAEjD,gBAAgB;YAChB,gCAAgC;QACpC;QAEA,MAAMO,SAAS,MAAM,IAAI,CAAC,WAAW,CAACH,cAAcL;QACpD,MAAMS,SAASC,kBAAkBZ;QAEjC,IAAI,CAACa,MAAM,OAAO,CAACF,SACf,OAAO,IAAI,CAAC,UAAU,CAACA,QAAQD,QAAQT;QAG3C,MAAMa,UAAU,EAAE;QAClB,KAAK,MAAMC,KAAKJ,OACZG,QAAQ,IAAI,CAAC,MAAM,IAAI,CAAC,UAAU,CAACC,GAAGL,QAAQT;QAElD,OAAOa;IACX;IAEA,MAAc,eAA6C;QACvD,MAAMb,MAA2B;YAAE,WAAW,IAAI,CAAC,SAAS;QAAC;QAC7D,KAAK,MAAMe,YAAY,IAAI,CAAC,SAAS,CACjC,MAAMA,SAAS,OAAO,CAACf;QAE3B,OAAOA;IACX;IAEA,MAAc,uBAAuBA,GAAwB,EAA4B;QACrF,IAAI,AAAkC,MAAlC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAC7B,OAAO,EAAE;QAGb,MAAMgB,UAA2B,EAAE;QACnC,KAAK,MAAMC,KAAK,IAAI,CAAC,iBAAiB,CAClCD,QAAQ,IAAI,CAAC,MAAMC,EAAE,KAAK,CAACjB;QAE/B,OAAOgB;IACX;IAEA,MAAc,YACVV,YAA2B,EAC3BL,YAA6B,EACP;QACtB,IAAIA,AAAwB,MAAxBA,aAAa,MAAM,EACnB,OAAOK;QAEX,OAAOY,aAAa;YAAE,SAAS;gBAACZ;mBAAiBL;aAAa;QAAC;IACnE;IAEA,MAAc,WACVF,IAAwB,EACxBU,MAAqB,EACrBT,GAAwB,EACZ;QACZ,MAAM,EAAEmB,KAAK,EAAEC,SAAS,EAAEC,aAAa,EAAE,GAAGtB;QAE5C,OAAOuB,QAAQ;YACXb;YACA,QAAQU;YACR,WAAW,CAAC;YACZ,cAAcnB;YACd,gBAAgBoB,aAAaG;YAC7B,eAAeF,iBAAiBE;QACpC;IACJ;AACJ;AAEO,MAAMC,8BAAgBC,cAAAA,oBAA6C,CAAC;IACvE,gBAAgB/B;IAChB,cAAc;QACVgC;QACAC;QACA;YAACC;YAAwB;gBAAE,UAAU;YAAK;SAAE;QAC5C;YAACC;YAAyB;gBAAE,UAAU;YAAK;SAAE;KAChD;AACL"}
+{"version":3,"file":"engine/GraphQLEngine.js","sources":["../../src/engine/GraphQLEngine.ts"],"sourcesContent":["import { graphql } from \"graphql\";\nimport { makeExecutableSchema } from \"@graphql-tools/schema\";\nimport { mergeResolvers } from \"@graphql-tools/merge\";\nimport { Container } from \"@webiny/di\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport { GraphQLEngine as GraphQLEngineAbstraction } from \"./abstractions.js\";\nimport { GraphQLSchemaCache } from \"./abstractions.js\";\nimport { createSchemaCacheKey } from \"./createSchemaCacheKey.js\";\nimport { GraphQLSchemaComposer } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\nimport { ResolverDecoration } from \"~/ResolverDecoration.js\";\nimport { createRequestBody } from \"~/createRequestBody.js\";\nimport type { IGraphQLSchemaComposer } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\nimport type { GraphQLRequestBody } from \"~/types.js\";\nimport type { GraphQLSchema } from \"graphql\";\n\nconst buildStaticSchema = (schemaConfig: IGraphQLSchema): GraphQLSchema => {\n    const resolverDecoration = new ResolverDecoration();\n    if (schemaConfig.resolverDecorators) {\n        resolverDecoration.addDecorators(schemaConfig.resolverDecorators);\n    }\n\n    // Always provide base root types so that `extend type Query/Mutation` works without\n    // requiring callers to define them. With assumeValidSDL:true, empty base types are\n    // allowed at build time; graphql() then returns schema-validation errors at execution\n    // time (e.g. \"Type Query must define one or more fields.\") when no fields are registered.\n    const typeDefs = `type Query\\ntype Mutation\\n${schemaConfig.typeDefs ?? \"\"}`;\n    const resolvers = mergeResolvers([schemaConfig.resolvers ?? {}]);\n\n    return makeExecutableSchema({\n        typeDefs,\n        resolvers: resolverDecoration.decorateResolvers(resolvers),\n        assumeValidSDL: true,\n        inheritResolversFromInterfaces: true,\n        // The schema built from typeDefs above is new and nothing else holds it, so resolvers go\n        // onto it directly. Without this, graphql-tools rebuilds the whole schema to attach them,\n        // which was about half of the schema build on a cold Lambda.\n        updateResolversInPlace: true\n    });\n};\n\nconst composeAndBuild = async (composer: IGraphQLSchemaComposer): Promise<GraphQLSchema> => {\n    const schemaConfig = await composer.build();\n    return buildStaticSchema(schemaConfig);\n};\n\nclass GraphQLEngineImpl implements GraphQLEngineAbstraction.Interface {\n    constructor(\n        private composer: IGraphQLSchemaComposer,\n        private container: Container,\n        private schemaCache: GraphQLSchemaCache.Interface | undefined\n    ) {}\n\n    async execute(body: any): Promise<any> {\n        const ctx: Record<string, any> = { container: this.container };\n        const schema = await this.resolveSchema();\n        const parsed = createRequestBody(body);\n\n        if (!Array.isArray(parsed)) {\n            return this.executeOne(parsed, schema, ctx);\n        }\n        // Run sequentially so per-request state (e.g. ctx.debug.logs) is scoped per query.\n        const results = [];\n        for (const b of parsed) {\n            results.push(await this.executeOne(b, schema, ctx));\n        }\n        return results;\n    }\n\n    /**\n     * The same composer output always builds the same executable schema, so with a cache in the\n     * root container it's built once and reused. When every schema factory has a schema key, the key\n     * comes from those and the factories only run on a cache miss. Otherwise they run on every\n     * request, and the key comes from what they produced.\n     */\n    private async resolveSchema(): Promise<GraphQLSchema> {\n        if (!this.schemaCache) {\n            return composeAndBuild(this.composer);\n        }\n\n        const factoriesKey = await this.composer.getSchemaKey();\n        if (factoriesKey) {\n            return this.schemaCache.getOrBuild(`factories:${factoriesKey}`, () => {\n                return composeAndBuild(this.composer);\n            });\n        }\n\n        const schemaConfig = await this.composer.build();\n        const contentKey = createSchemaCacheKey(schemaConfig);\n        return this.schemaCache.getOrBuild(`content:${contentKey}`, async () => {\n            return buildStaticSchema(schemaConfig);\n        });\n    }\n\n    private async executeOne(\n        body: GraphQLRequestBody,\n        schema: GraphQLSchema,\n        ctx: Record<string, any>\n    ): Promise<any> {\n        const { query, variables, operationName } = body;\n\n        return graphql({\n            schema,\n            source: query,\n            rootValue: {},\n            contextValue: ctx,\n            variableValues: variables ?? undefined,\n            operationName: operationName ?? undefined\n        });\n    }\n}\n\nexport const GraphQLEngine = GraphQLEngineAbstraction.createImplementation({\n    implementation: GraphQLEngineImpl,\n    dependencies: [\n        GraphQLSchemaComposer,\n        RequestContainer,\n        [GraphQLSchemaCache, { optional: true }]\n    ]\n});\n"],"names":["buildStaticSchema","schemaConfig","resolverDecoration","ResolverDecoration","typeDefs","resolvers","mergeResolvers","makeExecutableSchema","composeAndBuild","composer","GraphQLEngineImpl","container","schemaCache","body","ctx","schema","parsed","createRequestBody","Array","results","b","factoriesKey","contentKey","createSchemaCacheKey","query","variables","operationName","graphql","undefined","GraphQLEngine","GraphQLEngineAbstraction","GraphQLSchemaComposer","RequestContainer","GraphQLSchemaCache"],"mappings":";;;;;;;;;AAgBA,MAAMA,oBAAoB,CAACC;IACvB,MAAMC,qBAAqB,IAAIC;IAC/B,IAAIF,aAAa,kBAAkB,EAC/BC,mBAAmB,aAAa,CAACD,aAAa,kBAAkB;IAOpE,MAAMG,WAAW,CAAC,2BAA2B,EAAEH,aAAa,QAAQ,IAAI,IAAI;IAC5E,MAAMI,YAAYC,eAAe;QAACL,aAAa,SAAS,IAAI,CAAC;KAAE;IAE/D,OAAOM,qBAAqB;QACxBH;QACA,WAAWF,mBAAmB,iBAAiB,CAACG;QAChD,gBAAgB;QAChB,gCAAgC;QAIhC,wBAAwB;IAC5B;AACJ;AAEA,MAAMG,kBAAkB,OAAOC;IAC3B,MAAMR,eAAe,MAAMQ,SAAS,KAAK;IACzC,OAAOT,kBAAkBC;AAC7B;AAEA,MAAMS;IACF,YACYD,QAAgC,EAChCE,SAAoB,EACpBC,WAAqD,CAC/D;aAHUH,QAAQ,GAARA;aACAE,SAAS,GAATA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QAAQC,IAAS,EAAgB;QACnC,MAAMC,MAA2B;YAAE,WAAW,IAAI,CAAC,SAAS;QAAC;QAC7D,MAAMC,SAAS,MAAM,IAAI,CAAC,aAAa;QACvC,MAAMC,SAASC,kBAAkBJ;QAEjC,IAAI,CAACK,MAAM,OAAO,CAACF,SACf,OAAO,IAAI,CAAC,UAAU,CAACA,QAAQD,QAAQD;QAG3C,MAAMK,UAAU,EAAE;QAClB,KAAK,MAAMC,KAAKJ,OACZG,QAAQ,IAAI,CAAC,MAAM,IAAI,CAAC,UAAU,CAACC,GAAGL,QAAQD;QAElD,OAAOK;IACX;IAQA,MAAc,gBAAwC;QAClD,IAAI,CAAC,IAAI,CAAC,WAAW,EACjB,OAAOX,gBAAgB,IAAI,CAAC,QAAQ;QAGxC,MAAMa,eAAe,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY;QACrD,IAAIA,cACA,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,UAAU,EAAEA,cAAc,EAAE,IACrDb,gBAAgB,IAAI,CAAC,QAAQ;QAI5C,MAAMP,eAAe,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK;QAC9C,MAAMqB,aAAaC,qBAAqBtB;QACxC,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAEqB,YAAY,EAAE,UACjDtB,kBAAkBC;IAEjC;IAEA,MAAc,WACVY,IAAwB,EACxBE,MAAqB,EACrBD,GAAwB,EACZ;QACZ,MAAM,EAAEU,KAAK,EAAEC,SAAS,EAAEC,aAAa,EAAE,GAAGb;QAE5C,OAAOc,QAAQ;YACXZ;YACA,QAAQS;YACR,WAAW,CAAC;YACZ,cAAcV;YACd,gBAAgBW,aAAaG;YAC7B,eAAeF,iBAAiBE;QACpC;IACJ;AACJ;AAEO,MAAMC,8BAAgBC,cAAAA,oBAA6C,CAAC;IACvE,gBAAgBpB;IAChB,cAAc;QACVqB;QACAC;QACA;YAACC;YAAoB;gBAAE,UAAU;YAAK;SAAE;KAC3C;AACL"}

package/engine/GraphQLEngineFeature.js

@@ -1,13 +1,13 @@
 import { createFeature } from "@webiny/feature/api";
 import { GraphQLSchemaComposerFeature } from "../features/GraphQLSchemaBuilder/feature.js";
 import { GraphQLEngine } from "./GraphQLEngine.js";
-import { GraphQLRoute } from "./GraphQLRoute.js";
+import { GraphQLRouteDefinition } from "./GraphQLRoute.js";
 const GraphQLEngineFeature = createFeature({
     name: "GraphQLEngine",
     register (container) {
         GraphQLSchemaComposerFeature.register(container);
         container.register(GraphQLEngine);
-        container.register(GraphQLRoute);
+        container.register(GraphQLRouteDefinition);
     }
 });
 export { GraphQLEngineFeature };

package/engine/GraphQLEngineFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine/GraphQLEngineFeature.js","sources":["../../src/engine/GraphQLEngineFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GraphQLSchemaComposerFeature } from \"~/features/GraphQLSchemaBuilder/feature.js\";\nimport { GraphQLEngine } from \"./GraphQLEngine.js\";\nimport { GraphQLRoute } from \"./GraphQLRoute.js\";\n\nexport const GraphQLEngineFeature = createFeature({\n    name: \"GraphQLEngine\",\n    register(container) {\n        GraphQLSchemaComposerFeature.register(container);\n        container.register(GraphQLEngine);\n        container.register(GraphQLRoute);\n    }\n});\n"],"names":["GraphQLEngineFeature","createFeature","container","GraphQLSchemaComposerFeature","GraphQLEngine","GraphQLRoute"],"mappings":";;;;AAKO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdC,6BAA6B,QAAQ,CAACD;QACtCA,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;IACvB;AACJ"}
+{"version":3,"file":"engine/GraphQLEngineFeature.js","sources":["../../src/engine/GraphQLEngineFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\n\nimport { GraphQLSchemaComposerFeature } from \"~/features/GraphQLSchemaBuilder/feature.js\";\nimport { GraphQLEngine } from \"./GraphQLEngine.js\";\nimport { GraphQLRouteDefinition } from \"./GraphQLRoute.js\";\n\nexport const GraphQLEngineFeature = createFeature({\n    name: \"GraphQLEngine\",\n    register(container) {\n        GraphQLSchemaComposerFeature.register(container);\n        container.register(GraphQLEngine);\n        container.register(GraphQLRouteDefinition);\n    }\n});\n"],"names":["GraphQLEngineFeature","createFeature","container","GraphQLSchemaComposerFeature","GraphQLEngine","GraphQLRouteDefinition"],"mappings":";;;;AAMO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdC,6BAA6B,QAAQ,CAACD;QACtCA,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;IACvB;AACJ"}

package/engine/GraphQLRoute.d.ts

@@ -1,14 +1,24 @@
-import { HttpRoute } from "@webiny/event-handler-core";
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
 import type { IHttpRequest, IHttpResponse } from "@webiny/event-handler-core";
 import type { IGraphQLEngine } from "./abstractions.js";
-declare class GraphQLRouteImpl implements HttpRoute.Interface {
+declare class GraphQLRouteImpl implements HttpRouteHandler.Interface {
     private engine;
-    readonly method = "POST";
-    readonly path = "/graphql";
     constructor(engine: IGraphQLEngine);
     handle(request: IHttpRequest): Promise<IHttpResponse>;
 }
 export declare const GraphQLRoute: typeof GraphQLRouteImpl & {
     __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
 };
+declare class GraphQLRouteDefinitionImpl implements HttpRouteDefinition.Interface {
+    readonly name = "graphql";
+    readonly method = "POST";
+    readonly path = "/graphql";
+    readonly handler: typeof GraphQLRouteImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+    };
+}
+/** What the router matches on. Zero dependencies, so building it costs nothing. */
+export declare const GraphQLRouteDefinition: typeof GraphQLRouteDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRouteDefinition>;
+};
 export {};

package/engine/GraphQLRoute.js

@@ -1,10 +1,8 @@
-import { HttpRoute } from "@webiny/event-handler-core";
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
 import { GraphQLEngine } from "./abstractions.js";
 class GraphQLRouteImpl {
     constructor(engine){
         this.engine = engine;
-        this.method = "POST";
-        this.path = "/graphql";
     }
     async handle(request) {
         const result = await this.engine.execute(request.body);
@@ -17,12 +15,24 @@ class GraphQLRouteImpl {
         };
     }
 }
-const GraphQLRoute = HttpRoute.createImplementation({
+const GraphQLRoute = HttpRouteHandler.createImplementation({
     implementation: GraphQLRouteImpl,
     dependencies: [
         GraphQLEngine
     ]
 });
-export { GraphQLRoute };
+class GraphQLRouteDefinitionImpl {
+    constructor(){
+        this.name = "graphql";
+        this.method = "POST";
+        this.path = "/graphql";
+        this.handler = GraphQLRoute;
+    }
+}
+const GraphQLRouteDefinition = HttpRouteDefinition.createImplementation({
+    implementation: GraphQLRouteDefinitionImpl,
+    dependencies: []
+});
+export { GraphQLRoute, GraphQLRouteDefinition };
 
 //# sourceMappingURL=GraphQLRoute.js.map

package/engine/GraphQLRoute.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine/GraphQLRoute.js","sources":["../../src/engine/GraphQLRoute.ts"],"sourcesContent":["import { HttpRoute } from \"@webiny/event-handler-core\";\nimport { GraphQLEngine } from \"./abstractions.js\";\nimport type { IHttpRequest, IHttpResponse } from \"@webiny/event-handler-core\";\nimport type { IGraphQLEngine } from \"./abstractions.js\";\n\nclass GraphQLRouteImpl implements HttpRoute.Interface {\n    readonly method = \"POST\";\n    readonly path = \"/graphql\";\n\n    constructor(private engine: IGraphQLEngine) {}\n\n    async handle(request: IHttpRequest): Promise<IHttpResponse> {\n        const result = await this.engine.execute(request.body);\n        return {\n            statusCode: 200,\n            headers: { \"Content-Type\": \"application/json\" },\n            body: result\n        };\n    }\n}\n\nexport const GraphQLRoute = HttpRoute.createImplementation({\n    implementation: GraphQLRouteImpl,\n    dependencies: [GraphQLEngine]\n});\n"],"names":["GraphQLRouteImpl","engine","request","result","GraphQLRoute","HttpRoute","GraphQLEngine"],"mappings":";;AAKA,MAAMA;IAIF,YAAoBC,MAAsB,CAAE;aAAxBA,MAAM,GAANA;aAHX,MAAM,GAAG;aACT,IAAI,GAAG;IAE6B;IAE7C,MAAM,OAAOC,OAAqB,EAA0B;QACxD,MAAMC,SAAS,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAACD,QAAQ,IAAI;QACrD,OAAO;YACH,YAAY;YACZ,SAAS;gBAAE,gBAAgB;YAAmB;YAC9C,MAAMC;QACV;IACJ;AACJ;AAEO,MAAMC,eAAeC,UAAU,oBAAoB,CAAC;IACvD,gBAAgBL;IAChB,cAAc;QAACM;KAAc;AACjC"}
+{"version":3,"file":"engine/GraphQLRoute.js","sources":["../../src/engine/GraphQLRoute.ts"],"sourcesContent":["import { HttpRouteDefinition, HttpRouteHandler } from \"@webiny/event-handler-core\";\nimport { GraphQLEngine } from \"./abstractions.js\";\nimport type { IHttpRequest, IHttpResponse } from \"@webiny/event-handler-core\";\nimport type { IGraphQLEngine } from \"./abstractions.js\";\n\nclass GraphQLRouteImpl implements HttpRouteHandler.Interface {\n    constructor(private engine: IGraphQLEngine) {}\n\n    async handle(request: IHttpRequest): Promise<IHttpResponse> {\n        const result = await this.engine.execute(request.body);\n        return {\n            statusCode: 200,\n            headers: { \"Content-Type\": \"application/json\" },\n            body: result\n        };\n    }\n}\n\nexport const GraphQLRoute = HttpRouteHandler.createImplementation({\n    implementation: GraphQLRouteImpl,\n    dependencies: [GraphQLEngine]\n});\n\nclass GraphQLRouteDefinitionImpl implements HttpRouteDefinition.Interface {\n    readonly name = \"graphql\";\n    readonly method = \"POST\";\n    readonly path = \"/graphql\";\n    readonly handler = GraphQLRoute;\n}\n\n/** What the router matches on. Zero dependencies, so building it costs nothing. */\nexport const GraphQLRouteDefinition = HttpRouteDefinition.createImplementation({\n    implementation: GraphQLRouteDefinitionImpl,\n    dependencies: []\n});\n"],"names":["GraphQLRouteImpl","engine","request","result","GraphQLRoute","HttpRouteHandler","GraphQLEngine","GraphQLRouteDefinitionImpl","GraphQLRouteDefinition","HttpRouteDefinition"],"mappings":";;AAKA,MAAMA;IACF,YAAoBC,MAAsB,CAAE;aAAxBA,MAAM,GAANA;IAAyB;IAE7C,MAAM,OAAOC,OAAqB,EAA0B;QACxD,MAAMC,SAAS,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAACD,QAAQ,IAAI;QACrD,OAAO;YACH,YAAY;YACZ,SAAS;gBAAE,gBAAgB;YAAmB;YAC9C,MAAMC;QACV;IACJ;AACJ;AAEO,MAAMC,eAAeC,iBAAiB,oBAAoB,CAAC;IAC9D,gBAAgBL;IAChB,cAAc;QAACM;KAAc;AACjC;AAEA,MAAMC;;aACO,IAAI,GAAG;aACP,MAAM,GAAG;aACT,IAAI,GAAG;aACP,OAAO,GAAGH;;AACvB;AAGO,MAAMI,yBAAyBC,oBAAoB,oBAAoB,CAAC;IAC3E,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/engine/GraphQLSchemaCacheFeature.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Register in the ROOT container. The request container registers the GraphQL engine again on every
+ * request, so a cache registered there would start empty each time.
+ */
+export declare const GraphQLSchemaCacheFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/engine/GraphQLSchemaCacheFeature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { MemoryGraphQLSchemaCache } from "./MemoryGraphQLSchemaCache.js";
+const GraphQLSchemaCacheFeature = createFeature({
+    name: "GraphQLSchemaCache",
+    register (container) {
+        container.register(MemoryGraphQLSchemaCache).inSingletonScope();
+    }
+});
+export { GraphQLSchemaCacheFeature };
+
+//# sourceMappingURL=GraphQLSchemaCacheFeature.js.map

package/engine/GraphQLSchemaCacheFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine/GraphQLSchemaCacheFeature.js","sources":["../../src/engine/GraphQLSchemaCacheFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { MemoryGraphQLSchemaCache } from \"./MemoryGraphQLSchemaCache.js\";\n\n/**\n * Register in the ROOT container. The request container registers the GraphQL engine again on every\n * request, so a cache registered there would start empty each time.\n */\nexport const GraphQLSchemaCacheFeature = createFeature({\n    name: \"GraphQLSchemaCache\",\n    register(container) {\n        container.register(MemoryGraphQLSchemaCache).inSingletonScope();\n    }\n});\n"],"names":["GraphQLSchemaCacheFeature","createFeature","container","MemoryGraphQLSchemaCache"],"mappings":";;AAOO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,0BAA0B,gBAAgB;IACjE;AACJ"}

package/engine/GraphQLSchemaKeyVerificationFeature.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Register in the ROOT container of test handlers, next to GraphQLSchemaCacheFeature. Every request
+ * then also runs each keyed factory on its own and checks its output against its schema key, so a
+ * factory whose key misses a dependency fails the tests instead of serving a stale schema.
+ */
+export declare const GraphQLSchemaKeyVerificationFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/engine/GraphQLSchemaKeyVerificationFeature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { MemoryGraphQLSchemaKeyVerification } from "./MemoryGraphQLSchemaKeyVerification.js";
+const GraphQLSchemaKeyVerificationFeature = createFeature({
+    name: "GraphQLSchemaKeyVerification",
+    register (container) {
+        container.register(MemoryGraphQLSchemaKeyVerification).inSingletonScope();
+    }
+});
+export { GraphQLSchemaKeyVerificationFeature };
+
+//# sourceMappingURL=GraphQLSchemaKeyVerificationFeature.js.map

package/engine/GraphQLSchemaKeyVerificationFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine/GraphQLSchemaKeyVerificationFeature.js","sources":["../../src/engine/GraphQLSchemaKeyVerificationFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { MemoryGraphQLSchemaKeyVerification } from \"./MemoryGraphQLSchemaKeyVerification.js\";\n\n/**\n * Register in the ROOT container of test handlers, next to GraphQLSchemaCacheFeature. Every request\n * then also runs each keyed factory on its own and checks its output against its schema key, so a\n * factory whose key misses a dependency fails the tests instead of serving a stale schema.\n */\nexport const GraphQLSchemaKeyVerificationFeature = createFeature({\n    name: \"GraphQLSchemaKeyVerification\",\n    register(container) {\n        container.register(MemoryGraphQLSchemaKeyVerification).inSingletonScope();\n    }\n});\n"],"names":["GraphQLSchemaKeyVerificationFeature","createFeature","container","MemoryGraphQLSchemaKeyVerification"],"mappings":";;AAQO,MAAMA,sCAAsCC,cAAc;IAC7D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,oCAAoC,gBAAgB;IAC3E;AACJ"}

package/engine/MemoryGraphQLSchemaCache.d.ts

@@ -0,0 +1,15 @@
+import type { GraphQLSchema } from "graphql";
+import { GraphQLSchemaCache as Abstraction } from "./abstractions.js";
+/**
+ * Keeps the most recently used schemas in memory, dropping the least recently used one once it holds
+ * `MAX_ENTRIES`. It stores the build itself, so concurrent requests for a missing key share one
+ * build, and a failed build is forgotten.
+ */
+declare class MemoryGraphQLSchemaCacheImpl implements Abstraction.Interface {
+    private readonly schemas;
+    getOrBuild(key: string, build: () => Promise<GraphQLSchema>): Promise<GraphQLSchema>;
+}
+export declare const MemoryGraphQLSchemaCache: typeof MemoryGraphQLSchemaCacheImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGraphQLSchemaCache>;
+};
+export {};

package/engine/MemoryGraphQLSchemaCache.js

@@ -0,0 +1,32 @@
+import { GraphQLSchemaCache } from "./abstractions.js";
+const MAX_ENTRIES = 10;
+class MemoryGraphQLSchemaCacheImpl {
+    getOrBuild(key, build) {
+        const cached = this.schemas.get(key);
+        if (cached) {
+            this.schemas.delete(key);
+            this.schemas.set(key, cached);
+            return cached;
+        }
+        const schema = build().catch((error)=>{
+            if (this.schemas.get(key) === schema) this.schemas.delete(key);
+            throw error;
+        });
+        this.schemas.set(key, schema);
+        if (this.schemas.size > MAX_ENTRIES) {
+            const oldestKey = this.schemas.keys().next().value;
+            this.schemas.delete(oldestKey);
+        }
+        return schema;
+    }
+    constructor(){
+        this.schemas = new Map();
+    }
+}
+const MemoryGraphQLSchemaCache = GraphQLSchemaCache.createImplementation({
+    implementation: MemoryGraphQLSchemaCacheImpl,
+    dependencies: []
+});
+export { MemoryGraphQLSchemaCache };
+
+//# sourceMappingURL=MemoryGraphQLSchemaCache.js.map

package/engine/MemoryGraphQLSchemaCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine/MemoryGraphQLSchemaCache.js","sources":["../../src/engine/MemoryGraphQLSchemaCache.ts"],"sourcesContent":["import type { GraphQLSchema } from \"graphql\";\nimport { GraphQLSchemaCache as Abstraction } from \"./abstractions.js\";\n\n/*\n * A built schema is several megabytes. Tenants with the same models produce the same key and share\n * one entry, so a handful of entries covers the usual case without letting a process that serves\n * many differently shaped tenants grow without bound.\n */\nconst MAX_ENTRIES = 10;\n\n/**\n * Keeps the most recently used schemas in memory, dropping the least recently used one once it holds\n * `MAX_ENTRIES`. It stores the build itself, so concurrent requests for a missing key share one\n * build, and a failed build is forgotten.\n */\nclass MemoryGraphQLSchemaCacheImpl implements Abstraction.Interface {\n    private readonly schemas = new Map<string, Promise<GraphQLSchema>>();\n\n    public getOrBuild(key: string, build: () => Promise<GraphQLSchema>): Promise<GraphQLSchema> {\n        const cached = this.schemas.get(key);\n        if (cached) {\n            // Re-insert, so the map's insertion order doubles as the recently-used order.\n            this.schemas.delete(key);\n            this.schemas.set(key, cached);\n            return cached;\n        }\n\n        const schema = build().catch(error => {\n            if (this.schemas.get(key) === schema) {\n                this.schemas.delete(key);\n            }\n            throw error;\n        });\n        this.schemas.set(key, schema);\n\n        if (this.schemas.size > MAX_ENTRIES) {\n            const oldestKey = this.schemas.keys().next().value as string;\n            this.schemas.delete(oldestKey);\n        }\n\n        return schema;\n    }\n}\n\nexport const MemoryGraphQLSchemaCache = Abstraction.createImplementation({\n    implementation: MemoryGraphQLSchemaCacheImpl,\n    dependencies: []\n});\n"],"names":["MAX_ENTRIES","MemoryGraphQLSchemaCacheImpl","key","build","cached","schema","error","oldestKey","Map","MemoryGraphQLSchemaCache","Abstraction"],"mappings":";AAQA,MAAMA,cAAc;AAOpB,MAAMC;IAGK,WAAWC,GAAW,EAAEC,KAAmC,EAA0B;QACxF,MAAMC,SAAS,IAAI,CAAC,OAAO,CAAC,GAAG,CAACF;QAChC,IAAIE,QAAQ;YAER,IAAI,CAAC,OAAO,CAAC,MAAM,CAACF;YACpB,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA,KAAKE;YACtB,OAAOA;QACX;QAEA,MAAMC,SAASF,QAAQ,KAAK,CAACG,CAAAA;YACzB,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAACJ,SAASG,QAC1B,IAAI,CAAC,OAAO,CAAC,MAAM,CAACH;YAExB,MAAMI;QACV;QACA,IAAI,CAAC,OAAO,CAAC,GAAG,CAACJ,KAAKG;QAEtB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,GAAGL,aAAa;YACjC,MAAMO,YAAY,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,GAAG,KAAK;YAClD,IAAI,CAAC,OAAO,CAAC,MAAM,CAACA;QACxB;QAEA,OAAOF;IACX;;aAzBiB,OAAO,GAAG,IAAIG;;AA0BnC;AAEO,MAAMC,2BAA2BC,mBAAAA,oBAAgC,CAAC;IACrE,gBAAgBT;IAChB,cAAc,EAAE;AACpB"}

package/engine/MemoryGraphQLSchemaKeyVerification.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLSchemaKeyVerification as Abstraction } from "./abstractions.js";
+/**
+ * Remembers the output each factory produced under each schema key, and throws when the same factory
+ * produces something else under a key it used before.
+ */
+declare class MemoryGraphQLSchemaKeyVerificationImpl implements Abstraction.Interface {
+    private readonly outputs;
+    check(params: Abstraction.Check): void;
+}
+export declare const MemoryGraphQLSchemaKeyVerification: typeof MemoryGraphQLSchemaKeyVerificationImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGraphQLSchemaKeyVerification>;
+};
+export {};

package/engine/MemoryGraphQLSchemaKeyVerification.js

@@ -0,0 +1,23 @@
+import { GraphQLSchemaKeyVerification } from "./abstractions.js";
+class MemoryGraphQLSchemaKeyVerificationImpl {
+    check(params) {
+        const { factory, key, output } = params;
+        const id = JSON.stringify([
+            factory,
+            key
+        ]);
+        const previous = this.outputs.get(id);
+        if (void 0 === previous) return void this.outputs.set(id, output);
+        if (previous !== output) throw new Error(`GraphQL schema factory "${factory}" produced a different schema under the same schema key "${key}". Its getSchemaKey() is missing something its output depends on.`);
+    }
+    constructor(){
+        this.outputs = new Map();
+    }
+}
+const MemoryGraphQLSchemaKeyVerification = GraphQLSchemaKeyVerification.createImplementation({
+    implementation: MemoryGraphQLSchemaKeyVerificationImpl,
+    dependencies: []
+});
+export { MemoryGraphQLSchemaKeyVerification };
+
+//# sourceMappingURL=MemoryGraphQLSchemaKeyVerification.js.map

package/engine/MemoryGraphQLSchemaKeyVerification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine/MemoryGraphQLSchemaKeyVerification.js","sources":["../../src/engine/MemoryGraphQLSchemaKeyVerification.ts"],"sourcesContent":["import { GraphQLSchemaKeyVerification as Abstraction } from \"./abstractions.js\";\n\n/**\n * Remembers the output each factory produced under each schema key, and throws when the same factory\n * produces something else under a key it used before.\n */\nclass MemoryGraphQLSchemaKeyVerificationImpl implements Abstraction.Interface {\n    private readonly outputs = new Map<string, string>();\n\n    public check(params: Abstraction.Check): void {\n        const { factory, key, output } = params;\n        const id = JSON.stringify([factory, key]);\n        const previous = this.outputs.get(id);\n\n        if (previous === undefined) {\n            this.outputs.set(id, output);\n            return;\n        }\n\n        if (previous !== output) {\n            throw new Error(\n                `GraphQL schema factory \"${factory}\" produced a different schema under the same schema key \"${key}\". Its getSchemaKey() is missing something its output depends on.`\n            );\n        }\n    }\n}\n\nexport const MemoryGraphQLSchemaKeyVerification = Abstraction.createImplementation({\n    implementation: MemoryGraphQLSchemaKeyVerificationImpl,\n    dependencies: []\n});\n"],"names":["MemoryGraphQLSchemaKeyVerificationImpl","params","factory","key","output","id","JSON","previous","undefined","Error","Map","MemoryGraphQLSchemaKeyVerification","Abstraction"],"mappings":";AAMA,MAAMA;IAGK,MAAMC,MAAyB,EAAQ;QAC1C,MAAM,EAAEC,OAAO,EAAEC,GAAG,EAAEC,MAAM,EAAE,GAAGH;QACjC,MAAMI,KAAKC,KAAK,SAAS,CAAC;YAACJ;YAASC;SAAI;QACxC,MAAMI,WAAW,IAAI,CAAC,OAAO,CAAC,GAAG,CAACF;QAElC,IAAIE,AAAaC,WAAbD,UAAwB,YACxB,IAAI,CAAC,OAAO,CAAC,GAAG,CAACF,IAAID;QAIzB,IAAIG,aAAaH,QACb,MAAM,IAAIK,MACN,CAAC,wBAAwB,EAAEP,QAAQ,yDAAyD,EAAEC,IAAI,iEAAiE,CAAC;IAGhL;;aAjBiB,OAAO,GAAG,IAAIO;;AAkBnC;AAEO,MAAMC,qCAAqCC,6BAAAA,oBAAgC,CAAC;IAC/E,gBAAgBZ;IAChB,cAAc,EAAE;AACpB"}

package/engine/abstractions.d.ts

@@ -1,3 +1,4 @@
+import type { GraphQLSchema } from "graphql";
 export interface IGraphQLEngine {
     execute(body: any): Promise<any>;
 }
@@ -5,3 +6,31 @@ export declare const GraphQLEngine: import("@webiny/di").Abstraction<IGraphQLEng
 export declare namespace GraphQLEngine {
     type Interface = IGraphQLEngine;
 }
+/**
+ * GraphQLSchemaCache - Keeps built executable schemas across requests, keyed by what they were built
+ * from. Register it in the root container, so it lives as long as the handler.
+ */
+export interface IGraphQLSchemaCache {
+    getOrBuild(key: string, build: () => Promise<GraphQLSchema>): Promise<GraphQLSchema>;
+}
+export declare const GraphQLSchemaCache: import("@webiny/di").Abstraction<IGraphQLSchemaCache>;
+export declare namespace GraphQLSchemaCache {
+    type Interface = IGraphQLSchemaCache;
+}
+export interface IGraphQLSchemaKeyCheck {
+    factory: string;
+    key: string;
+    output: string;
+}
+export interface IGraphQLSchemaKeyVerification {
+    check(params: IGraphQLSchemaKeyCheck): void;
+}
+/**
+ * GraphQLSchemaKeyVerification - Fails when a schema factory produces different output under the same
+ * schema key, which would serve a stale schema. Register it in the root container of test handlers.
+ */
+export declare const GraphQLSchemaKeyVerification: import("@webiny/di").Abstraction<IGraphQLSchemaKeyVerification>;
+export declare namespace GraphQLSchemaKeyVerification {
+    type Interface = IGraphQLSchemaKeyVerification;
+    type Check = IGraphQLSchemaKeyCheck;
+}

package/engine/abstractions.js

@@ -1,5 +1,7 @@
 import { createAbstraction } from "@webiny/feature/api";
 const GraphQLEngine = createAbstraction("GraphQLEngine");
-export { GraphQLEngine };
+const GraphQLSchemaCache = createAbstraction("GraphQLSchemaCache");
+const GraphQLSchemaKeyVerification = createAbstraction("GraphQLSchemaKeyVerification");
+export { GraphQLEngine, GraphQLSchemaCache, GraphQLSchemaKeyVerification };
 
 //# sourceMappingURL=abstractions.js.map

package/engine/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine/abstractions.js","sources":["../../src/engine/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IGraphQLEngine {\n    execute(body: any): Promise<any>;\n}\n\nexport const GraphQLEngine = createAbstraction<IGraphQLEngine>(\"GraphQLEngine\");\n\nexport namespace GraphQLEngine {\n    export type Interface = IGraphQLEngine;\n}\n"],"names":["GraphQLEngine","createAbstraction"],"mappings":";AAMO,MAAMA,gBAAgBC,kBAAkC"}
+{"version":3,"file":"engine/abstractions.js","sources":["../../src/engine/abstractions.ts"],"sourcesContent":["import type { GraphQLSchema } from \"graphql\";\nimport { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IGraphQLEngine {\n    execute(body: any): Promise<any>;\n}\n\nexport const GraphQLEngine = createAbstraction<IGraphQLEngine>(\"GraphQLEngine\");\n\nexport namespace GraphQLEngine {\n    export type Interface = IGraphQLEngine;\n}\n\n/**\n * GraphQLSchemaCache - Keeps built executable schemas across requests, keyed by what they were built\n * from. Register it in the root container, so it lives as long as the handler.\n */\nexport interface IGraphQLSchemaCache {\n    getOrBuild(key: string, build: () => Promise<GraphQLSchema>): Promise<GraphQLSchema>;\n}\n\nexport const GraphQLSchemaCache = createAbstraction<IGraphQLSchemaCache>(\"GraphQLSchemaCache\");\n\nexport namespace GraphQLSchemaCache {\n    export type Interface = IGraphQLSchemaCache;\n}\n\nexport interface IGraphQLSchemaKeyCheck {\n    factory: string;\n    key: string;\n    output: string;\n}\n\nexport interface IGraphQLSchemaKeyVerification {\n    check(params: IGraphQLSchemaKeyCheck): void;\n}\n\n/**\n * GraphQLSchemaKeyVerification - Fails when a schema factory produces different output under the same\n * schema key, which would serve a stale schema. Register it in the root container of test handlers.\n */\nexport const GraphQLSchemaKeyVerification = createAbstraction<IGraphQLSchemaKeyVerification>(\n    \"GraphQLSchemaKeyVerification\"\n);\n\nexport namespace GraphQLSchemaKeyVerification {\n    export type Interface = IGraphQLSchemaKeyVerification;\n    export type Check = IGraphQLSchemaKeyCheck;\n}\n"],"names":["GraphQLEngine","createAbstraction","GraphQLSchemaCache","GraphQLSchemaKeyVerification"],"mappings":";AAOO,MAAMA,gBAAgBC,kBAAkC;AAcxD,MAAMC,qBAAqBD,kBAAuC;AAoBlE,MAAME,+BAA+BF,kBACxC"}

package/engine/createSchemaCacheKey.d.ts

@@ -0,0 +1,8 @@
+import type { IGraphQLSchema } from "../graphql/abstractions.public.js";
+/**
+ * The key identifies what an executable schema is built from: the type definitions, which paths
+ * have a resolver, and how many decorators each path has. Resolver functions themselves can't be
+ * compared, but every one of them resolves its dependencies when it runs, so two requests that
+ * produce the same key produce schemas that behave the same.
+ */
+export declare const createSchemaCacheKey: (schema: IGraphQLSchema) => string;

package/engine/createSchemaCacheKey.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+const collectResolverPaths = (resolvers, prefix, paths)=>{
+    for (const [key, value] of Object.entries(resolvers)){
+        const path = prefix ? `${prefix}.${key}` : key;
+        if ("function" == typeof value) paths.push(path);
+        else if (value && "object" == typeof value) collectResolverPaths(value, path, paths);
+    }
+};
+const createSchemaCacheKey = (schema)=>{
+    const resolverPaths = [];
+    collectResolverPaths(schema.resolvers ?? {}, "", resolverPaths);
+    const decoratorPaths = Object.entries(schema.resolverDecorators ?? {}).map(([path, decorators])=>`${path}:${decorators.length}`);
+    const hash = createHash("sha1");
+    hash.update(String(schema.typeDefs ?? ""));
+    hash.update("\n#resolvers\n");
+    hash.update(resolverPaths.sort().join("\n"));
+    hash.update("\n#decorators\n");
+    hash.update(decoratorPaths.sort().join("\n"));
+    return hash.digest("hex");
+};
+export { createSchemaCacheKey };
+
+//# sourceMappingURL=createSchemaCacheKey.js.map

package/engine/createSchemaCacheKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine/createSchemaCacheKey.js","sources":["../../src/engine/createSchemaCacheKey.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\n\nconst collectResolverPaths = (resolvers: Record<string, any>, prefix: string, paths: string[]) => {\n    for (const [key, value] of Object.entries(resolvers)) {\n        const path = prefix ? `${prefix}.${key}` : key;\n        if (typeof value === \"function\") {\n            paths.push(path);\n        } else if (value && typeof value === \"object\") {\n            collectResolverPaths(value, path, paths);\n        }\n    }\n};\n\n/**\n * The key identifies what an executable schema is built from: the type definitions, which paths\n * have a resolver, and how many decorators each path has. Resolver functions themselves can't be\n * compared, but every one of them resolves its dependencies when it runs, so two requests that\n * produce the same key produce schemas that behave the same.\n */\nexport const createSchemaCacheKey = (schema: IGraphQLSchema): string => {\n    const resolverPaths: string[] = [];\n    collectResolverPaths(schema.resolvers ?? {}, \"\", resolverPaths);\n\n    const decoratorPaths = Object.entries(schema.resolverDecorators ?? {}).map(\n        ([path, decorators]) => `${path}:${decorators.length}`\n    );\n\n    const hash = createHash(\"sha1\");\n    hash.update(String(schema.typeDefs ?? \"\"));\n    hash.update(\"\\n#resolvers\\n\");\n    hash.update(resolverPaths.sort().join(\"\\n\"));\n    hash.update(\"\\n#decorators\\n\");\n    hash.update(decoratorPaths.sort().join(\"\\n\"));\n\n    return hash.digest(\"hex\");\n};\n"],"names":["collectResolverPaths","resolvers","prefix","paths","key","value","Object","path","createSchemaCacheKey","schema","resolverPaths","decoratorPaths","decorators","hash","createHash","String"],"mappings":";AAGA,MAAMA,uBAAuB,CAACC,WAAgCC,QAAgBC;IAC1E,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAO,OAAO,CAACL,WAAY;QAClD,MAAMM,OAAOL,SAAS,GAAGA,OAAO,CAAC,EAAEE,KAAK,GAAGA;QAC3C,IAAI,AAAiB,cAAjB,OAAOC,OACPF,MAAM,IAAI,CAACI;aACR,IAAIF,SAAS,AAAiB,YAAjB,OAAOA,OACvBL,qBAAqBK,OAAOE,MAAMJ;IAE1C;AACJ;AAQO,MAAMK,uBAAuB,CAACC;IACjC,MAAMC,gBAA0B,EAAE;IAClCV,qBAAqBS,OAAO,SAAS,IAAI,CAAC,GAAG,IAAIC;IAEjD,MAAMC,iBAAiBL,OAAO,OAAO,CAACG,OAAO,kBAAkB,IAAI,CAAC,GAAG,GAAG,CACtE,CAAC,CAACF,MAAMK,WAAW,GAAK,GAAGL,KAAK,CAAC,EAAEK,WAAW,MAAM,EAAE;IAG1D,MAAMC,OAAOC,WAAW;IACxBD,KAAK,MAAM,CAACE,OAAON,OAAO,QAAQ,IAAI;IACtCI,KAAK,MAAM,CAAC;IACZA,KAAK,MAAM,CAACH,cAAc,IAAI,GAAG,IAAI,CAAC;IACtCG,KAAK,MAAM,CAAC;IACZA,KAAK,MAAM,CAACF,eAAe,IAAI,GAAG,IAAI,CAAC;IAEvC,OAAOE,KAAK,MAAM,CAAC;AACvB"}

package/engine/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./abstractions.js";
-export * from "./GraphQLContextEnhancer.js";
-export * from "./GraphQLContextualSchema.js";
 export * from "./GraphQLRoute.js";
 export * from "./GraphQLEngineFeature.js";
+export * from "./GraphQLSchemaCacheFeature.js";
+export * from "./GraphQLSchemaKeyVerificationFeature.js";

package/engine/index.js

@@ -1,5 +1,5 @@
 export * from "./abstractions.js";
-export * from "./GraphQLContextEnhancer.js";
-export * from "./GraphQLContextualSchema.js";
 export * from "./GraphQLRoute.js";
 export * from "./GraphQLEngineFeature.js";
+export * from "./GraphQLSchemaCacheFeature.js";
+export * from "./GraphQLSchemaKeyVerificationFeature.js";

package/exports/api/graphql.d.ts

@@ -1,2 +1,3 @@
 export { GraphQLSchemaFactory } from "../../graphql/abstractions.js";
+export { staticSchemaKey } from "../../graphql/staticSchemaKey.js";
 export { ErrorResponse, ListResponse, Response, NotFoundResponse, ListErrorResponse } from "../../responses.js";

package/exports/api/graphql.js

@@ -1,2 +1,3 @@
 export { GraphQLSchemaFactory } from "../../graphql/abstractions.js";
+export { staticSchemaKey } from "../../graphql/staticSchemaKey.js";
 export { ErrorResponse, ListErrorResponse, ListResponse, NotFoundResponse, Response } from "../../responses.js";

package/features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.js

@@ -8,10 +8,11 @@ class GraphQLSchemaBuilder {
         const pathParts = path.split(".");
         const graphqlResolver = (parent, args, context, info)=>{
             const resolvedDeps = dependencies.map((dep)=>{
-                const [abstraction] = Array.isArray(dep) ? dep : [
-                    dep
+                const [abstraction, options] = Array.isArray(dep) ? dep : [
+                    dep,
+                    void 0
                 ];
-                return context.container.resolve(abstraction);
+                return options?.multiple ? context.container.resolveAll(abstraction) : context.container.resolve(abstraction);
             });
             const actualResolver = resolver(...resolvedDeps);
             return actualResolver({

package/features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.js","sources":["../../../src/features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.ts"],"sourcesContent":["import type { GraphQLSchemaBuilder as Abstraction } from \"./abstractions.js\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\nimport type { ResolverDecorator, ResolverDecorators, Resolvers } from \"~/types.js\";\nimport type { Dependency } from \"@webiny/di\";\n\nexport class GraphQLSchemaBuilder implements Abstraction.Interface {\n    private readonly typeDefsArray: string[] = [];\n    private readonly resolvers: Resolvers<any> = {};\n    private readonly resolverDecorators: ResolverDecorators = {};\n\n    addTypeDefs(typeDefs: string): this {\n        this.typeDefsArray.push(typeDefs);\n        return this;\n    }\n\n    addResolver<TArgs = any>(config: Abstraction.Config<TArgs>): this {\n        const { path, dependencies = [], resolver } = config;\n\n        const pathParts = path.split(\".\");\n\n        const graphqlResolver = (parent: any, args: TArgs, context: any, info: any) => {\n            const resolvedDeps = dependencies.map((dep: Dependency) => {\n                const [abstraction] = Array.isArray(dep) ? dep : [dep];\n                return context.container.resolve(abstraction);\n            });\n\n            const actualResolver = resolver(...resolvedDeps);\n\n            return actualResolver({ parent, args, context, info });\n        };\n\n        this.setResolverAtPath(pathParts, graphqlResolver);\n\n        return this;\n    }\n\n    addLegacyResolvers(resolvers: Record<string, any>, prefix = \"\"): this {\n        for (const [key, value] of Object.entries(resolvers)) {\n            const path = prefix ? `${prefix}.${key}` : key;\n            if (typeof value === \"function\") {\n                const fn = value;\n                this.addResolver({\n                    path,\n                    dependencies: [],\n                    resolver:\n                        () =>\n                        ({ parent, args, context, info }: any) =>\n                            fn(parent, args, context, info)\n                });\n            } else if (typeof value === \"object\" && value !== null) {\n                this.addLegacyResolvers(value, path);\n            }\n        }\n        return this;\n    }\n\n    /**\n     * @internal This method needs revisiting, to align with DI concepts.\n     */\n    addResolverDecorator(path: string, decorator: ResolverDecorator): this {\n        if (!this.resolverDecorators[path]) {\n            this.resolverDecorators[path] = [];\n        }\n        this.resolverDecorators[path].push(decorator);\n        return this;\n    }\n\n    build(): IGraphQLSchema {\n        return {\n            typeDefs: this.typeDefsArray.join(\"\\n\"),\n            resolvers: this.resolvers,\n            resolverDecorators: this.resolverDecorators\n        };\n    }\n\n    private setResolverAtPath(pathParts: string[], resolver: any): void {\n        let current: any = this.resolvers;\n\n        for (let i = 0; i < pathParts.length - 1; i++) {\n            const part = pathParts[i];\n            if (!current[part]) {\n                current[part] = {};\n            }\n            current = current[part];\n        }\n\n        const finalKey = pathParts[pathParts.length - 1];\n        current[finalKey] = resolver;\n    }\n}\n"],"names":["GraphQLSchemaBuilder","typeDefs","config","path","dependencies","resolver","pathParts","graphqlResolver","parent","args","context","info","resolvedDeps","dep","abstraction","Array","actualResolver","resolvers","prefix","key","value","Object","fn","decorator","current","i","part","finalKey"],"mappings":"AAKO,MAAMA;IAKT,YAAYC,QAAgB,EAAQ;QAChC,IAAI,CAAC,aAAa,CAAC,IAAI,CAACA;QACxB,OAAO,IAAI;IACf;IAEA,YAAyBC,MAAiC,EAAQ;QAC9D,MAAM,EAAEC,IAAI,EAAEC,eAAe,EAAE,EAAEC,QAAQ,EAAE,GAAGH;QAE9C,MAAMI,YAAYH,KAAK,KAAK,CAAC;QAE7B,MAAMI,kBAAkB,CAACC,QAAaC,MAAaC,SAAcC;YAC7D,MAAMC,eAAeR,aAAa,GAAG,CAAC,CAACS;gBACnC,MAAM,CAACC,YAAY,GAAGC,MAAM,OAAO,CAACF,OAAOA,MAAM;oBAACA;iBAAI;gBACtD,OAAOH,QAAQ,SAAS,CAAC,OAAO,CAACI;YACrC;YAEA,MAAME,iBAAiBX,YAAYO;YAEnC,OAAOI,eAAe;gBAAER;gBAAQC;gBAAMC;gBAASC;YAAK;QACxD;QAEA,IAAI,CAAC,iBAAiB,CAACL,WAAWC;QAElC,OAAO,IAAI;IACf;IAEA,mBAAmBU,SAA8B,EAAEC,SAAS,EAAE,EAAQ;QAClE,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAO,OAAO,CAACJ,WAAY;YAClD,MAAMd,OAAOe,SAAS,GAAGA,OAAO,CAAC,EAAEC,KAAK,GAAGA;YAC3C,IAAI,AAAiB,cAAjB,OAAOC,OAAsB;gBAC7B,MAAME,KAAKF;gBACX,IAAI,CAAC,WAAW,CAAC;oBACbjB;oBACA,cAAc,EAAE;oBAChB,UACI,IACA,CAAC,EAAEK,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAEC,IAAI,EAAO,GACjCW,GAAGd,QAAQC,MAAMC,SAASC;gBACtC;YACJ,OAAO,IAAI,AAAiB,YAAjB,OAAOS,SAAsBA,AAAU,SAAVA,OACpC,IAAI,CAAC,kBAAkB,CAACA,OAAOjB;QAEvC;QACA,OAAO,IAAI;IACf;IAKA,qBAAqBA,IAAY,EAAEoB,SAA4B,EAAQ;QACnE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAACpB,KAAK,EAC9B,IAAI,CAAC,kBAAkB,CAACA,KAAK,GAAG,EAAE;QAEtC,IAAI,CAAC,kBAAkB,CAACA,KAAK,CAAC,IAAI,CAACoB;QACnC,OAAO,IAAI;IACf;IAEA,QAAwB;QACpB,OAAO;YACH,UAAU,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAClC,WAAW,IAAI,CAAC,SAAS;YACzB,oBAAoB,IAAI,CAAC,kBAAkB;QAC/C;IACJ;IAEQ,kBAAkBjB,SAAmB,EAAED,QAAa,EAAQ;QAChE,IAAImB,UAAe,IAAI,CAAC,SAAS;QAEjC,IAAK,IAAIC,IAAI,GAAGA,IAAInB,UAAU,MAAM,GAAG,GAAGmB,IAAK;YAC3C,MAAMC,OAAOpB,SAAS,CAACmB,EAAE;YACzB,IAAI,CAACD,OAAO,CAACE,KAAK,EACdF,OAAO,CAACE,KAAK,GAAG,CAAC;YAErBF,UAAUA,OAAO,CAACE,KAAK;QAC3B;QAEA,MAAMC,WAAWrB,SAAS,CAACA,UAAU,MAAM,GAAG,EAAE;QAChDkB,OAAO,CAACG,SAAS,GAAGtB;IACxB;;aAlFiB,aAAa,GAAa,EAAE;aAC5B,SAAS,GAAmB,CAAC;aAC7B,kBAAkB,GAAuB,CAAC;;AAiF/D"}
+{"version":3,"file":"features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.js","sources":["../../../src/features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.ts"],"sourcesContent":["import type { GraphQLSchemaBuilder as Abstraction } from \"./abstractions.js\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\nimport type { ResolverDecorator, ResolverDecorators, Resolvers } from \"~/types.js\";\nimport type { Dependency } from \"@webiny/di\";\n\nexport class GraphQLSchemaBuilder implements Abstraction.Interface {\n    private readonly typeDefsArray: string[] = [];\n    private readonly resolvers: Resolvers<any> = {};\n    private readonly resolverDecorators: ResolverDecorators = {};\n\n    addTypeDefs(typeDefs: string): this {\n        this.typeDefsArray.push(typeDefs);\n        return this;\n    }\n\n    addResolver<TArgs = any>(config: Abstraction.Config<TArgs>): this {\n        const { path, dependencies = [], resolver } = config;\n\n        const pathParts = path.split(\".\");\n\n        const graphqlResolver = (parent: any, args: TArgs, context: any, info: any) => {\n            const resolvedDeps = dependencies.map((dep: Dependency) => {\n                /*\n                 * `Dependency` allows `[abstraction, { multiple: true }]`, same as anywhere else in\n                 * the container. This used to destructure the tuple, throw the options away and\n                 * always single-resolve, so a resolver asking for every implementation of an\n                 * abstraction received one object and failed on `.map`.\n                 */\n                const [abstraction, options] = Array.isArray(dep) ? dep : [dep, undefined];\n\n                return options?.multiple\n                    ? context.container.resolveAll(abstraction)\n                    : context.container.resolve(abstraction);\n            });\n\n            const actualResolver = resolver(...resolvedDeps);\n\n            return actualResolver({ parent, args, context, info });\n        };\n\n        this.setResolverAtPath(pathParts, graphqlResolver);\n\n        return this;\n    }\n\n    addLegacyResolvers(resolvers: Record<string, any>, prefix = \"\"): this {\n        for (const [key, value] of Object.entries(resolvers)) {\n            const path = prefix ? `${prefix}.${key}` : key;\n            if (typeof value === \"function\") {\n                const fn = value;\n                this.addResolver({\n                    path,\n                    dependencies: [],\n                    resolver:\n                        () =>\n                        ({ parent, args, context, info }: any) =>\n                            fn(parent, args, context, info)\n                });\n            } else if (typeof value === \"object\" && value !== null) {\n                this.addLegacyResolvers(value, path);\n            }\n        }\n        return this;\n    }\n\n    /**\n     * @internal This method needs revisiting, to align with DI concepts.\n     */\n    addResolverDecorator(path: string, decorator: ResolverDecorator): this {\n        if (!this.resolverDecorators[path]) {\n            this.resolverDecorators[path] = [];\n        }\n        this.resolverDecorators[path].push(decorator);\n        return this;\n    }\n\n    build(): IGraphQLSchema {\n        return {\n            typeDefs: this.typeDefsArray.join(\"\\n\"),\n            resolvers: this.resolvers,\n            resolverDecorators: this.resolverDecorators\n        };\n    }\n\n    private setResolverAtPath(pathParts: string[], resolver: any): void {\n        let current: any = this.resolvers;\n\n        for (let i = 0; i < pathParts.length - 1; i++) {\n            const part = pathParts[i];\n            if (!current[part]) {\n                current[part] = {};\n            }\n            current = current[part];\n        }\n\n        const finalKey = pathParts[pathParts.length - 1];\n        current[finalKey] = resolver;\n    }\n}\n"],"names":["GraphQLSchemaBuilder","typeDefs","config","path","dependencies","resolver","pathParts","graphqlResolver","parent","args","context","info","resolvedDeps","dep","abstraction","options","Array","undefined","actualResolver","resolvers","prefix","key","value","Object","fn","decorator","current","i","part","finalKey"],"mappings":"AAKO,MAAMA;IAKT,YAAYC,QAAgB,EAAQ;QAChC,IAAI,CAAC,aAAa,CAAC,IAAI,CAACA;QACxB,OAAO,IAAI;IACf;IAEA,YAAyBC,MAAiC,EAAQ;QAC9D,MAAM,EAAEC,IAAI,EAAEC,eAAe,EAAE,EAAEC,QAAQ,EAAE,GAAGH;QAE9C,MAAMI,YAAYH,KAAK,KAAK,CAAC;QAE7B,MAAMI,kBAAkB,CAACC,QAAaC,MAAaC,SAAcC;YAC7D,MAAMC,eAAeR,aAAa,GAAG,CAAC,CAACS;gBAOnC,MAAM,CAACC,aAAaC,QAAQ,GAAGC,MAAM,OAAO,CAACH,OAAOA,MAAM;oBAACA;oBAAKI;iBAAU;gBAE1E,OAAOF,SAAS,WACVL,QAAQ,SAAS,CAAC,UAAU,CAACI,eAC7BJ,QAAQ,SAAS,CAAC,OAAO,CAACI;YACpC;YAEA,MAAMI,iBAAiBb,YAAYO;YAEnC,OAAOM,eAAe;gBAAEV;gBAAQC;gBAAMC;gBAASC;YAAK;QACxD;QAEA,IAAI,CAAC,iBAAiB,CAACL,WAAWC;QAElC,OAAO,IAAI;IACf;IAEA,mBAAmBY,SAA8B,EAAEC,SAAS,EAAE,EAAQ;QAClE,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAO,OAAO,CAACJ,WAAY;YAClD,MAAMhB,OAAOiB,SAAS,GAAGA,OAAO,CAAC,EAAEC,KAAK,GAAGA;YAC3C,IAAI,AAAiB,cAAjB,OAAOC,OAAsB;gBAC7B,MAAME,KAAKF;gBACX,IAAI,CAAC,WAAW,CAAC;oBACbnB;oBACA,cAAc,EAAE;oBAChB,UACI,IACA,CAAC,EAAEK,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAEC,IAAI,EAAO,GACjCa,GAAGhB,QAAQC,MAAMC,SAASC;gBACtC;YACJ,OAAO,IAAI,AAAiB,YAAjB,OAAOW,SAAsBA,AAAU,SAAVA,OACpC,IAAI,CAAC,kBAAkB,CAACA,OAAOnB;QAEvC;QACA,OAAO,IAAI;IACf;IAKA,qBAAqBA,IAAY,EAAEsB,SAA4B,EAAQ;QACnE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAACtB,KAAK,EAC9B,IAAI,CAAC,kBAAkB,CAACA,KAAK,GAAG,EAAE;QAEtC,IAAI,CAAC,kBAAkB,CAACA,KAAK,CAAC,IAAI,CAACsB;QACnC,OAAO,IAAI;IACf;IAEA,QAAwB;QACpB,OAAO;YACH,UAAU,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YAClC,WAAW,IAAI,CAAC,SAAS;YACzB,oBAAoB,IAAI,CAAC,kBAAkB;QAC/C;IACJ;IAEQ,kBAAkBnB,SAAmB,EAAED,QAAa,EAAQ;QAChE,IAAIqB,UAAe,IAAI,CAAC,SAAS;QAEjC,IAAK,IAAIC,IAAI,GAAGA,IAAIrB,UAAU,MAAM,GAAG,GAAGqB,IAAK;YAC3C,MAAMC,OAAOtB,SAAS,CAACqB,EAAE;YACzB,IAAI,CAACD,OAAO,CAACE,KAAK,EACdF,OAAO,CAACE,KAAK,GAAG,CAAC;YAErBF,UAAUA,OAAO,CAACE,KAAK;QAC3B;QAEA,MAAMC,WAAWvB,SAAS,CAACA,UAAU,MAAM,GAAG,EAAE;QAChDoB,OAAO,CAACG,SAAS,GAAGxB;IACxB;;aA3FiB,aAAa,GAAa,EAAE;aAC5B,SAAS,GAAmB,CAAC;aAC7B,kBAAkB,GAAuB,CAAC;;AA0F/D"}

package/features/GraphQLSchemaBuilder/GraphQLSchemaComposer.d.ts

@@ -1,10 +1,14 @@
 import { Container } from "@webiny/di";
 import { GraphQLSchemaComposer as Abstraction } from "./abstractions.js";
+import { GraphQLSchemaKeyVerification } from "../../engine/abstractions.js";
 import type { IGraphQLSchema } from "../../graphql/abstractions.public.js";
 declare class GraphQLSchemaComposerImpl implements Abstraction.Interface {
     private container;
-    constructor(container: Container);
-    build(ctx?: Record<string, any>): Promise<IGraphQLSchema>;
+    private verification;
+    constructor(container: Container, verification: GraphQLSchemaKeyVerification.Interface | undefined);
+    build(): Promise<IGraphQLSchema>;
+    getSchemaKey(): Promise<string | null>;
+    private getFactories;
 }
 export declare const GraphQLSchemaComposer: typeof GraphQLSchemaComposerImpl & {
     __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGraphQLSchemaComposer>;

package/features/GraphQLSchemaBuilder/GraphQLSchemaComposer.js

@@ -1,24 +1,68 @@
+import { createHash } from "node:crypto";
 import { RequestContainer } from "@webiny/event-handler-core";
 import { GraphQLSchemaComposer } from "./abstractions.js";
 import { CoreGraphQLSchemaFactory, GraphQLSchemaFactory } from "../../graphql/abstractions.js";
+import { GraphQLSchemaKeyVerification } from "../../engine/abstractions.js";
+import { createSchemaCacheKey } from "../../engine/createSchemaCacheKey.js";
 import { GraphQLSchemaBuilder } from "./GraphQLSchemaBuilder.js";
+function isKeyed(factory) {
+    return "function" == typeof factory.getSchemaKey;
+}
+async function getFactoryOutput(factory) {
+    const builder = new GraphQLSchemaBuilder();
+    await factory.execute(builder);
+    const schema = builder.build();
+    return createSchemaCacheKey(schema);
+}
+async function verifyKeys(verification, factories, keys) {
+    for(let i = 0; i < factories.length; i++){
+        const output = await getFactoryOutput(factories[i]);
+        verification.check({
+            factory: factories[i].constructor.name,
+            key: keys[i],
+            output
+        });
+    }
+}
 class GraphQLSchemaComposerImpl {
-    constructor(container){
+    constructor(container, verification){
         this.container = container;
+        this.verification = verification;
     }
-    async build(ctx) {
+    async build() {
         const builder = new GraphQLSchemaBuilder();
+        for (const factory of this.getFactories())await factory.execute(builder);
+        return builder.build();
+    }
+    async getSchemaKey() {
+        const factories = this.getFactories();
+        if (!factories.every(isKeyed)) return null;
+        const pendingKeys = factories.map((factory)=>factory.getSchemaKey());
+        const keys = await Promise.all(pendingKeys);
+        if (this.verification) await verifyKeys(this.verification, factories, keys);
+        const hash = createHash("sha1");
+        hash.update(keys.join("\n"));
+        return hash.digest("hex");
+    }
+    getFactories() {
         const coreSchemas = this.container.resolveAll(CoreGraphQLSchemaFactory);
         const userSchemas = this.container.resolveAll(GraphQLSchemaFactory);
-        for (const factory of coreSchemas)await factory.execute(builder, ctx);
-        for (const factory of userSchemas)await factory.execute(builder);
-        return builder.build();
+        return [
+            ...coreSchemas,
+            ...userSchemas
+        ];
     }
 }
 const GraphQLSchemaComposer_GraphQLSchemaComposer = GraphQLSchemaComposer.createImplementation({
     implementation: GraphQLSchemaComposerImpl,
     dependencies: [
-        RequestContainer
+        RequestContainer,
+        [
+            GraphQLSchemaKeyVerification,
+            {
+                optional: true
+            }
+        ]
     ]
 });
 export { GraphQLSchemaComposer_GraphQLSchemaComposer as GraphQLSchemaComposer };

package/features/GraphQLSchemaBuilder/GraphQLSchemaComposer.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/GraphQLSchemaBuilder/GraphQLSchemaComposer.js","sources":["../../../src/features/GraphQLSchemaBuilder/GraphQLSchemaComposer.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport { GraphQLSchemaComposer as Abstraction } from \"./abstractions.js\";\nimport { GraphQLSchemaFactory, CoreGraphQLSchemaFactory } from \"~/graphql/abstractions.js\";\nimport { GraphQLSchemaBuilder } from \"./GraphQLSchemaBuilder.js\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\n\nclass GraphQLSchemaComposerImpl implements Abstraction.Interface {\n    constructor(private container: Container) {}\n\n    async build(ctx?: Record<string, any>): Promise<IGraphQLSchema> {\n        const builder = new GraphQLSchemaBuilder();\n\n        // Resolve lazily so factories registered during enhance() (e.g. by extensions) are included.\n        const coreSchemas = this.container.resolveAll(CoreGraphQLSchemaFactory);\n        const userSchemas = this.container.resolveAll(GraphQLSchemaFactory);\n\n        for (const factory of coreSchemas) {\n            await factory.execute(builder, ctx);\n        }\n\n        for (const factory of userSchemas) {\n            await factory.execute(builder);\n        }\n\n        return builder.build();\n    }\n}\n\nexport const GraphQLSchemaComposer = Abstraction.createImplementation({\n    implementation: GraphQLSchemaComposerImpl,\n    dependencies: [RequestContainer]\n});\n"],"names":["GraphQLSchemaComposerImpl","container","ctx","builder","GraphQLSchemaBuilder","coreSchemas","CoreGraphQLSchemaFactory","userSchemas","GraphQLSchemaFactory","factory","GraphQLSchemaComposer","Abstraction","RequestContainer"],"mappings":";;;;AAOA,MAAMA;IACF,YAAoBC,SAAoB,CAAE;aAAtBA,SAAS,GAATA;IAAuB;IAE3C,MAAM,MAAMC,GAAyB,EAA2B;QAC5D,MAAMC,UAAU,IAAIC;QAGpB,MAAMC,cAAc,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC;QAC9C,MAAMC,cAAc,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC;QAE9C,KAAK,MAAMC,WAAWJ,YAClB,MAAMI,QAAQ,OAAO,CAACN,SAASD;QAGnC,KAAK,MAAMO,WAAWF,YAClB,MAAME,QAAQ,OAAO,CAACN;QAG1B,OAAOA,QAAQ,KAAK;IACxB;AACJ;AAEO,MAAMO,8CAAwBC,sBAAAA,oBAAgC,CAAC;IAClE,gBAAgBX;IAChB,cAAc;QAACY;KAAiB;AACpC"}
+{"version":3,"file":"features/GraphQLSchemaBuilder/GraphQLSchemaComposer.js","sources":["../../../src/features/GraphQLSchemaBuilder/GraphQLSchemaComposer.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { Container } from \"@webiny/di\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport { GraphQLSchemaComposer as Abstraction } from \"./abstractions.js\";\nimport { GraphQLSchemaFactory, CoreGraphQLSchemaFactory } from \"~/graphql/abstractions.js\";\nimport { GraphQLSchemaKeyVerification } from \"~/engine/abstractions.js\";\nimport { createSchemaCacheKey } from \"~/engine/createSchemaCacheKey.js\";\nimport { GraphQLSchemaBuilder } from \"./GraphQLSchemaBuilder.js\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\n\ntype SchemaFactory = CoreGraphQLSchemaFactory.Interface | GraphQLSchemaFactory.Interface;\n\ntype KeyedSchemaFactory = SchemaFactory & {\n    getSchemaKey(): string | Promise<string>;\n};\n\nfunction isKeyed(factory: SchemaFactory): factory is KeyedSchemaFactory {\n    return typeof factory.getSchemaKey === \"function\";\n}\n\n// The output of one factory on its own, reduced to the same key the engine uses for a full schema.\nasync function getFactoryOutput(factory: SchemaFactory): Promise<string> {\n    const builder = new GraphQLSchemaBuilder();\n    await factory.execute(builder);\n    const schema = builder.build();\n    return createSchemaCacheKey(schema);\n}\n\n// Runs each factory on its own and checks its output against its schema key.\nasync function verifyKeys(\n    verification: GraphQLSchemaKeyVerification.Interface,\n    factories: SchemaFactory[],\n    keys: string[]\n): Promise<void> {\n    for (let i = 0; i < factories.length; i++) {\n        const output = await getFactoryOutput(factories[i]);\n        verification.check({\n            factory: factories[i].constructor.name,\n            key: keys[i],\n            output\n        });\n    }\n}\n\nclass GraphQLSchemaComposerImpl implements Abstraction.Interface {\n    constructor(\n        private container: Container,\n        private verification: GraphQLSchemaKeyVerification.Interface | undefined\n    ) {}\n\n    async build(): Promise<IGraphQLSchema> {\n        const builder = new GraphQLSchemaBuilder();\n\n        for (const factory of this.getFactories()) {\n            await factory.execute(builder);\n        }\n\n        return builder.build();\n    }\n\n    async getSchemaKey(): Promise<string | null> {\n        const factories = this.getFactories();\n        if (!factories.every(isKeyed)) {\n            return null;\n        }\n\n        const pendingKeys = factories.map(factory => factory.getSchemaKey());\n        const keys = await Promise.all(pendingKeys);\n\n        if (this.verification) {\n            await verifyKeys(this.verification, factories, keys);\n        }\n\n        const hash = createHash(\"sha1\");\n        hash.update(keys.join(\"\\n\"));\n        return hash.digest(\"hex\");\n    }\n\n    private getFactories(): SchemaFactory[] {\n        const coreSchemas = this.container.resolveAll(CoreGraphQLSchemaFactory);\n        const userSchemas = this.container.resolveAll(GraphQLSchemaFactory);\n        return [...coreSchemas, ...userSchemas];\n    }\n}\n\nexport const GraphQLSchemaComposer = Abstraction.createImplementation({\n    implementation: GraphQLSchemaComposerImpl,\n    dependencies: [RequestContainer, [GraphQLSchemaKeyVerification, { optional: true }]]\n});\n"],"names":["isKeyed","factory","getFactoryOutput","builder","GraphQLSchemaBuilder","schema","createSchemaCacheKey","verifyKeys","verification","factories","keys","i","output","GraphQLSchemaComposerImpl","container","pendingKeys","Promise","hash","createHash","coreSchemas","CoreGraphQLSchemaFactory","userSchemas","GraphQLSchemaFactory","GraphQLSchemaComposer","Abstraction","RequestContainer","GraphQLSchemaKeyVerification"],"mappings":";;;;;;;AAgBA,SAASA,QAAQC,OAAsB;IACnC,OAAO,AAAgC,cAAhC,OAAOA,QAAQ,YAAY;AACtC;AAGA,eAAeC,iBAAiBD,OAAsB;IAClD,MAAME,UAAU,IAAIC;IACpB,MAAMH,QAAQ,OAAO,CAACE;IACtB,MAAME,SAASF,QAAQ,KAAK;IAC5B,OAAOG,qBAAqBD;AAChC;AAGA,eAAeE,WACXC,YAAoD,EACpDC,SAA0B,EAC1BC,IAAc;IAEd,IAAK,IAAIC,IAAI,GAAGA,IAAIF,UAAU,MAAM,EAAEE,IAAK;QACvC,MAAMC,SAAS,MAAMV,iBAAiBO,SAAS,CAACE,EAAE;QAClDH,aAAa,KAAK,CAAC;YACf,SAASC,SAAS,CAACE,EAAE,CAAC,WAAW,CAAC,IAAI;YACtC,KAAKD,IAAI,CAACC,EAAE;YACZC;QACJ;IACJ;AACJ;AAEA,MAAMC;IACF,YACYC,SAAoB,EACpBN,YAAgE,CAC1E;aAFUM,SAAS,GAATA;aACAN,YAAY,GAAZA;IACT;IAEH,MAAM,QAAiC;QACnC,MAAML,UAAU,IAAIC;QAEpB,KAAK,MAAMH,WAAW,IAAI,CAAC,YAAY,GACnC,MAAMA,QAAQ,OAAO,CAACE;QAG1B,OAAOA,QAAQ,KAAK;IACxB;IAEA,MAAM,eAAuC;QACzC,MAAMM,YAAY,IAAI,CAAC,YAAY;QACnC,IAAI,CAACA,UAAU,KAAK,CAACT,UACjB,OAAO;QAGX,MAAMe,cAAcN,UAAU,GAAG,CAACR,CAAAA,UAAWA,QAAQ,YAAY;QACjE,MAAMS,OAAO,MAAMM,QAAQ,GAAG,CAACD;QAE/B,IAAI,IAAI,CAAC,YAAY,EACjB,MAAMR,WAAW,IAAI,CAAC,YAAY,EAAEE,WAAWC;QAGnD,MAAMO,OAAOC,WAAW;QACxBD,KAAK,MAAM,CAACP,KAAK,IAAI,CAAC;QACtB,OAAOO,KAAK,MAAM,CAAC;IACvB;IAEQ,eAAgC;QACpC,MAAME,cAAc,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC;QAC9C,MAAMC,cAAc,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC;QAC9C,OAAO;eAAIH;eAAgBE;SAAY;IAC3C;AACJ;AAEO,MAAME,8CAAwBC,sBAAAA,oBAAgC,CAAC;IAClE,gBAAgBX;IAChB,cAAc;QAACY;QAAkB;YAACC;YAA8B;gBAAE,UAAU;YAAK;SAAE;KAAC;AACxF"}

package/features/GraphQLSchemaBuilder/abstractions.d.ts

@@ -31,7 +31,12 @@ export declare namespace GraphQLSchemaBuilder {
     type Config<TArgs = any> = ResolverConfig<TArgs>;
 }
 export interface IGraphQLSchemaComposer {
-    build(ctx?: Record<string, any>): Promise<IGraphQLSchema>;
+    build(): Promise<IGraphQLSchema>;
+    /**
+     * Combines every factory's schema key. Returns null when any factory has no key, because its
+     * output can then only be known by running it.
+     */
+    getSchemaKey(): Promise<string | null>;
 }
 export declare const GraphQLSchemaComposer: import("@webiny/di").Abstraction<IGraphQLSchemaComposer>;
 export declare namespace GraphQLSchemaComposer {

package/features/GraphQLSchemaBuilder/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/GraphQLSchemaBuilder/abstractions.js","sources":["../../../src/features/GraphQLSchemaBuilder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ResolverDecorator, TypeDefs } from \"~/types.js\";\nimport type { Dependency } from \"@webiny/di\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\n\nexport interface ResolverConfig<TArgs = any, TParent = any> {\n    path: string;\n    dependencies?: Dependency[];\n    resolver: (\n        ...resolvedDeps: any[]\n    ) => (params: { parent: TParent; args: TArgs; context: any; info: any }) => any;\n}\n\nexport interface IGraphQLSchemaBuilder {\n    addTypeDefs(typeDefs: TypeDefs): this;\n    addResolver<TArgs = any, TParent = any>(config: ResolverConfig<TArgs, TParent>): this;\n    /**\n     * Bridge for legacy (parent, args, ctx, info) resolver objects.\n     * Walks a nested resolvers map and registers each leaf as an addResolver() call.\n     */\n    addLegacyResolvers(resolvers: Record<string, any>, prefix?: string): this;\n    /**\n     * @internal This method needs revisiting, to align with DI concepts.\n     */\n    addResolverDecorator(path: string, decorator: ResolverDecorator): this;\n    build(): IGraphQLSchema;\n}\n\nexport const GraphQLSchemaBuilder =\n    createAbstraction<IGraphQLSchemaBuilder>(\"GraphQLSchemaBuilder\");\n\nexport namespace GraphQLSchemaBuilder {\n    export type Interface = IGraphQLSchemaBuilder;\n    export type Config<TArgs = any> = ResolverConfig<TArgs>;\n}\n\nexport interface IGraphQLSchemaComposer {\n    build(ctx?: Record<string, any>): Promise<IGraphQLSchema>;\n}\n\nexport const GraphQLSchemaComposer =\n    createAbstraction<IGraphQLSchemaComposer>(\"GraphQLSchemaComposer\");\n\nexport namespace GraphQLSchemaComposer {\n    export type Interface = IGraphQLSchemaComposer;\n}\n"],"names":["GraphQLSchemaBuilder","createAbstraction","GraphQLSchemaComposer"],"mappings":";AA4BO,MAAMA,uBACTC,kBAAyC;AAWtC,MAAMC,wBACTD,kBAA0C"}
+{"version":3,"file":"features/GraphQLSchemaBuilder/abstractions.js","sources":["../../../src/features/GraphQLSchemaBuilder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ResolverDecorator, TypeDefs } from \"~/types.js\";\nimport type { Dependency } from \"@webiny/di\";\nimport type { IGraphQLSchema } from \"~/graphql/abstractions.public.js\";\n\nexport interface ResolverConfig<TArgs = any, TParent = any> {\n    path: string;\n    dependencies?: Dependency[];\n    resolver: (\n        ...resolvedDeps: any[]\n    ) => (params: { parent: TParent; args: TArgs; context: any; info: any }) => any;\n}\n\nexport interface IGraphQLSchemaBuilder {\n    addTypeDefs(typeDefs: TypeDefs): this;\n    addResolver<TArgs = any, TParent = any>(config: ResolverConfig<TArgs, TParent>): this;\n    /**\n     * Bridge for legacy (parent, args, ctx, info) resolver objects.\n     * Walks a nested resolvers map and registers each leaf as an addResolver() call.\n     */\n    addLegacyResolvers(resolvers: Record<string, any>, prefix?: string): this;\n    /**\n     * @internal This method needs revisiting, to align with DI concepts.\n     */\n    addResolverDecorator(path: string, decorator: ResolverDecorator): this;\n    build(): IGraphQLSchema;\n}\n\nexport const GraphQLSchemaBuilder =\n    createAbstraction<IGraphQLSchemaBuilder>(\"GraphQLSchemaBuilder\");\n\nexport namespace GraphQLSchemaBuilder {\n    export type Interface = IGraphQLSchemaBuilder;\n    export type Config<TArgs = any> = ResolverConfig<TArgs>;\n}\n\nexport interface IGraphQLSchemaComposer {\n    build(): Promise<IGraphQLSchema>;\n    /**\n     * Combines every factory's schema key. Returns null when any factory has no key, because its\n     * output can then only be known by running it.\n     */\n    getSchemaKey(): Promise<string | null>;\n}\n\nexport const GraphQLSchemaComposer =\n    createAbstraction<IGraphQLSchemaComposer>(\"GraphQLSchemaComposer\");\n\nexport namespace GraphQLSchemaComposer {\n    export type Interface = IGraphQLSchemaComposer;\n}\n"],"names":["GraphQLSchemaBuilder","createAbstraction","GraphQLSchemaComposer"],"mappings":";AA4BO,MAAMA,uBACTC,kBAAyC;AAgBtC,MAAMC,wBACTD,kBAA0C"}

package/graphql/abstractions.core.d.ts

@@ -1,11 +1,13 @@
 import type { GraphQLSchemaBuilder } from "../features/GraphQLSchemaBuilder/abstractions.js";
-/**
- * Internal — ctx is a legacy bridge, not exposed to public implementors.
- * TODO: remove ctx? once all registerLegacyPluginsViaGqlContextEnhancer callers are migrated —
- * at that point GraphQLSchemaComposer no longer needs to thread ctx through to schema factories.
- */
 export interface ICoreGraphQLSchemaFactory {
-    execute(builder: GraphQLSchemaBuilder.Interface, ctx?: Record<string, any>): Promise<GraphQLSchemaBuilder.Interface>;
+    execute(builder: GraphQLSchemaBuilder.Interface): Promise<GraphQLSchemaBuilder.Interface>;
+    /**
+     * Returns what this factory's type definitions and resolver paths depend on: the same key must
+     * always mean the same output. When every factory has one, the GraphQL engine runs the factories
+     * only if no schema is cached under the combined key yet. Leave it out and the factories run on
+     * every request. Use `staticSchemaKey()` for a factory whose output never changes.
+     */
+    getSchemaKey?(): string | Promise<string>;
 }
 export declare const CoreGraphQLSchemaFactory: import("@webiny/di").Abstraction<ICoreGraphQLSchemaFactory>;
 export declare namespace CoreGraphQLSchemaFactory {

package/graphql/abstractions.core.js.map

@@ -1 +1 @@
-{"version":3,"file":"graphql/abstractions.core.js","sources":["../../src/graphql/abstractions.core.ts"],"sourcesContent":["/**\n * This file contains abstraction for use by the core Webiny team, or anyone contributing to the webiny-js repository.\n */\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type { GraphQLSchemaBuilder } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\n\n/**\n * Internal — ctx is a legacy bridge, not exposed to public implementors.\n * TODO: remove ctx? once all registerLegacyPluginsViaGqlContextEnhancer callers are migrated —\n * at that point GraphQLSchemaComposer no longer needs to thread ctx through to schema factories.\n */\nexport interface ICoreGraphQLSchemaFactory {\n    execute(\n        builder: GraphQLSchemaBuilder.Interface,\n        ctx?: Record<string, any>\n    ): Promise<GraphQLSchemaBuilder.Interface>;\n}\n\nexport const CoreGraphQLSchemaFactory = createAbstraction<ICoreGraphQLSchemaFactory>(\n    \"CoreGraphQLSchemaFactory\"\n);\nexport namespace CoreGraphQLSchemaFactory {\n    export type Interface = ICoreGraphQLSchemaFactory;\n    export type SchemaBuilder = GraphQLSchemaBuilder.Interface;\n    export type Return = Promise<GraphQLSchemaBuilder.Interface>;\n}\n"],"names":["CoreGraphQLSchemaFactory","createAbstraction"],"mappings":";AAkBO,MAAMA,2BAA2BC,kBACpC"}
+{"version":3,"file":"graphql/abstractions.core.js","sources":["../../src/graphql/abstractions.core.ts"],"sourcesContent":["/**\n * This file contains abstraction for use by the core Webiny team, or anyone contributing to the webiny-js repository.\n */\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type { GraphQLSchemaBuilder } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\n\nexport interface ICoreGraphQLSchemaFactory {\n    execute(builder: GraphQLSchemaBuilder.Interface): Promise<GraphQLSchemaBuilder.Interface>;\n    /**\n     * Returns what this factory's type definitions and resolver paths depend on: the same key must\n     * always mean the same output. When every factory has one, the GraphQL engine runs the factories\n     * only if no schema is cached under the combined key yet. Leave it out and the factories run on\n     * every request. Use `staticSchemaKey()` for a factory whose output never changes.\n     */\n    getSchemaKey?(): string | Promise<string>;\n}\n\nexport const CoreGraphQLSchemaFactory = createAbstraction<ICoreGraphQLSchemaFactory>(\n    \"CoreGraphQLSchemaFactory\"\n);\nexport namespace CoreGraphQLSchemaFactory {\n    export type Interface = ICoreGraphQLSchemaFactory;\n    export type SchemaBuilder = GraphQLSchemaBuilder.Interface;\n    export type Return = Promise<GraphQLSchemaBuilder.Interface>;\n}\n"],"names":["CoreGraphQLSchemaFactory","createAbstraction"],"mappings":";AAiBO,MAAMA,2BAA2BC,kBACpC"}

package/graphql/abstractions.public.d.ts

@@ -8,6 +8,13 @@ export interface IGraphQLSchema {
 /** Define custom GraphQL schema extensions. */
 export interface IGraphQLSchemaFactory {
     execute(builder: GraphQLSchemaBuilder.Interface): Promise<GraphQLSchemaBuilder.Interface>;
+    /**
+     * Returns what this factory's type definitions and resolver paths depend on: the same key must
+     * always mean the same output. When every factory has one, the GraphQL engine runs the factories
+     * only if no schema is cached under the combined key yet. Leave it out and the factories run on
+     * every request. Use `staticSchemaKey()` for a factory whose output never changes.
+     */
+    getSchemaKey?(): string | Promise<string>;
 }
 /** Define custom GraphQL schema extensions. */
 export declare const GraphQLSchemaFactory: import("@webiny/di").Abstraction<IGraphQLSchemaFactory>;

package/graphql/abstractions.public.js.map

@@ -1 +1 @@
-{"version":3,"file":"graphql/abstractions.public.js","sources":["../../src/graphql/abstractions.public.ts"],"sourcesContent":["/**\n * This file contains abstraction for use by third party developers.\n */\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    Resolvers as IResolvers,\n    TypeDefs as ITypeDefs,\n    ResolverDecorators as IResolverDecorators\n} from \"~/types.js\";\nimport type { GraphQLSchemaBuilder } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\n\nexport interface IGraphQLSchema {\n    typeDefs?: ITypeDefs;\n    resolvers?: IResolvers<any>;\n    resolverDecorators?: IResolverDecorators;\n}\n\n/** Define custom GraphQL schema extensions. */\nexport interface IGraphQLSchemaFactory {\n    execute(builder: GraphQLSchemaBuilder.Interface): Promise<GraphQLSchemaBuilder.Interface>;\n}\n\n/** Define custom GraphQL schema extensions. */\nexport const GraphQLSchemaFactory =\n    createAbstraction<IGraphQLSchemaFactory>(\"GraphQLSchemaFactory\");\n\nexport namespace GraphQLSchemaFactory {\n    export type Interface = IGraphQLSchemaFactory;\n    export type SchemaBuilder = GraphQLSchemaBuilder.Interface;\n    export type Return = Promise<GraphQLSchemaBuilder.Interface>;\n}\n"],"names":["GraphQLSchemaFactory","createAbstraction"],"mappings":";AAuBO,MAAMA,uBACTC,kBAAyC"}
+{"version":3,"file":"graphql/abstractions.public.js","sources":["../../src/graphql/abstractions.public.ts"],"sourcesContent":["/**\n * This file contains abstraction for use by third party developers.\n */\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    Resolvers as IResolvers,\n    TypeDefs as ITypeDefs,\n    ResolverDecorators as IResolverDecorators\n} from \"~/types.js\";\nimport type { GraphQLSchemaBuilder } from \"~/features/GraphQLSchemaBuilder/abstractions.js\";\n\nexport interface IGraphQLSchema {\n    typeDefs?: ITypeDefs;\n    resolvers?: IResolvers<any>;\n    resolverDecorators?: IResolverDecorators;\n}\n\n/** Define custom GraphQL schema extensions. */\nexport interface IGraphQLSchemaFactory {\n    execute(builder: GraphQLSchemaBuilder.Interface): Promise<GraphQLSchemaBuilder.Interface>;\n    /**\n     * Returns what this factory's type definitions and resolver paths depend on: the same key must\n     * always mean the same output. When every factory has one, the GraphQL engine runs the factories\n     * only if no schema is cached under the combined key yet. Leave it out and the factories run on\n     * every request. Use `staticSchemaKey()` for a factory whose output never changes.\n     */\n    getSchemaKey?(): string | Promise<string>;\n}\n\n/** Define custom GraphQL schema extensions. */\nexport const GraphQLSchemaFactory =\n    createAbstraction<IGraphQLSchemaFactory>(\"GraphQLSchemaFactory\");\n\nexport namespace GraphQLSchemaFactory {\n    export type Interface = IGraphQLSchemaFactory;\n    export type SchemaBuilder = GraphQLSchemaBuilder.Interface;\n    export type Return = Promise<GraphQLSchemaBuilder.Interface>;\n}\n"],"names":["GraphQLSchemaFactory","createAbstraction"],"mappings":";AA8BO,MAAMA,uBACTC,kBAAyC"}

package/graphql/staticSchemaKey.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Schema key for a factory whose type definitions and resolver paths never change. The id only has
+ * to be unique among factories.
+ */
+export declare const staticSchemaKey: (id: string) => () => string;

package/graphql/staticSchemaKey.js

@@ -0,0 +1,4 @@
+const staticSchemaKey = (id)=>()=>`static:${id}`;
+export { staticSchemaKey };
+
+//# sourceMappingURL=staticSchemaKey.js.map

package/graphql/staticSchemaKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/staticSchemaKey.js","sources":["../../src/graphql/staticSchemaKey.ts"],"sourcesContent":["/**\n * Schema key for a factory whose type definitions and resolver paths never change. The id only has\n * to be unique among factories.\n */\nexport const staticSchemaKey = (id: string) => {\n    return (): string => `static:${id}`;\n};\n"],"names":["staticSchemaKey","id"],"mappings":"AAIO,MAAMA,kBAAkB,CAACC,KACrB,IAAc,CAAC,OAAO,EAAEA,IAAI"}

package/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./errors.js";
-export { registerLegacyPluginsViaGqlContextEnhancer } from "./registerLegacyPluginsViaGqlContextEnhancer.js";
 export * from "./responses.js";
 export * from "./utils/index.js";
 export * from "./plugins/index.js";
@@ -8,5 +7,6 @@ export * from "./processRequestBody.js";
 export * from "./createResolverDecorator.js";
 export * from "./ResolverDecoration.js";
 export * from "./engine/index.js";
+export * from "./graphql/staticSchemaKey.js";
 export default _default;
 declare function _default(): never[];

package/index.js

@@ -7,8 +7,8 @@ export * from "./processRequestBody.js";
 export * from "./createResolverDecorator.js";
 export * from "./ResolverDecoration.js";
 export * from "./engine/index.js";
+export * from "./graphql/staticSchemaKey.js";
 const src = ()=>[];
-export { registerLegacyPluginsViaGqlContextEnhancer } from "./registerLegacyPluginsViaGqlContextEnhancer.js";
 export default src;
 
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["export * from \"./errors.js\";\nexport { registerLegacyPluginsViaGqlContextEnhancer } from \"./registerLegacyPluginsViaGqlContextEnhancer.js\";\nexport * from \"./responses.js\";\nexport * from \"./utils/index.js\";\nexport * from \"./plugins/index.js\";\nexport * from \"./createRequestBody.js\";\nexport * from \"./processRequestBody.js\";\nexport * from \"./createResolverDecorator.js\";\nexport * from \"./ResolverDecoration.js\";\nexport * from \"./engine/index.js\";\n\n// Backward-compat stub — the Fastify GraphQL route was replaced by GraphQLRoute\n// registered via GraphQLEngineFeature. This default export is a no-op.\nexport default () => [];\n"],"names":[],"mappings":";;;;;;;;;AAaA,YAAgB,IAAK,EAAC"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["export * from \"./errors.js\";\nexport * from \"./responses.js\";\nexport * from \"./utils/index.js\";\nexport * from \"./plugins/index.js\";\nexport * from \"./createRequestBody.js\";\nexport * from \"./processRequestBody.js\";\nexport * from \"./createResolverDecorator.js\";\nexport * from \"./ResolverDecoration.js\";\nexport * from \"./engine/index.js\";\nexport * from \"./graphql/staticSchemaKey.js\";\n\n// Backward-compat stub — the Fastify GraphQL route was replaced by GraphQLRoute\n// registered via GraphQLEngineFeature. This default export is a no-op.\nexport default () => [];\n"],"names":[],"mappings":";;;;;;;;;;AAaA,YAAgB,IAAK,EAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/api-graphql",
-	"version": "0.0.0-unstable.0d717d18dd",
+	"version": "0.0.0-unstable.5387e5f7c8",
 	"type": "module",
 	"exports": {
 		".": "./index.js",
@@ -18,27 +18,26 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@graphql-tools/merge": "9.2.2",
-		"@graphql-tools/resolvers-composition": "7.0.35",
-		"@graphql-tools/schema": "10.0.38",
-		"@graphql-tools/utils": "11.2.2",
-		"@webiny/api": "0.0.0-unstable.0d717d18dd",
-		"@webiny/di": "1.0.2",
-		"@webiny/error": "0.0.0-unstable.0d717d18dd",
-		"@webiny/event-handler-core": "0.0.0-unstable.0d717d18dd",
-		"@webiny/feature": "0.0.0-unstable.0d717d18dd",
-		"@webiny/handler": "0.0.0-unstable.0d717d18dd",
-		"@webiny/plugins": "0.0.0-unstable.0d717d18dd",
-		"@webiny/utils": "0.0.0-unstable.0d717d18dd",
+		"@graphql-tools/merge": "9.2.3",
+		"@graphql-tools/resolvers-composition": "7.0.36",
+		"@graphql-tools/schema": "10.1.0",
+		"@graphql-tools/utils": "12.0.0",
+		"@webiny/api": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/di": "2.0.0",
+		"@webiny/error": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/event-handler-core": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/feature": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/plugins": "0.0.0-unstable.5387e5f7c8",
+		"@webiny/utils": "0.0.0-unstable.5387e5f7c8",
 		"graphql": "16.14.2",
-		"graphql-scalars": "1.25.0",
+		"graphql-scalars": "2.0.0",
 		"zod": "4.4.3"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "0.0.0-unstable.0d717d18dd",
+		"@webiny/build-tools": "0.0.0-unstable.5387e5f7c8",
 		"rimraf": "6.1.3",
 		"typescript": "7.0.2",
-		"vitest": "4.1.10"
+		"vitest": "4.1.11"
 	},
 	"publishConfig": {
 		"access": "public"

package/engine/GraphQLContextEnhancer.d.ts

@@ -1,12 +0,0 @@
-/**
- * Allows packages to add properties to the GraphQL resolver contextValue.
- * Register implementations to make things like `context.security`, `context.tenancy`
- * available to resolvers alongside the base `context.container`.
- */
-export interface IGraphQLContextEnhancer {
-    enhance(ctx: Record<string, any>): void | Promise<void>;
-}
-export declare const GraphQLContextEnhancer: import("@webiny/di").Abstraction<IGraphQLContextEnhancer>;
-export declare namespace GraphQLContextEnhancer {
-    type Interface = IGraphQLContextEnhancer;
-}

package/engine/GraphQLContextEnhancer.js

@@ -1,5 +0,0 @@
-import { createAbstraction } from "@webiny/feature/api";
-const GraphQLContextEnhancer = createAbstraction("GraphQLContextEnhancer");
-export { GraphQLContextEnhancer };
-
-//# sourceMappingURL=GraphQLContextEnhancer.js.map

package/engine/GraphQLContextEnhancer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine/GraphQLContextEnhancer.js","sources":["../../src/engine/GraphQLContextEnhancer.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\n/**\n * Allows packages to add properties to the GraphQL resolver contextValue.\n * Register implementations to make things like `context.security`, `context.tenancy`\n * available to resolvers alongside the base `context.container`.\n */\nexport interface IGraphQLContextEnhancer {\n    enhance(ctx: Record<string, any>): void | Promise<void>;\n}\n\nexport const GraphQLContextEnhancer =\n    createAbstraction<IGraphQLContextEnhancer>(\"GraphQLContextEnhancer\");\n\nexport namespace GraphQLContextEnhancer {\n    export type Interface = IGraphQLContextEnhancer;\n}\n"],"names":["GraphQLContextEnhancer","createAbstraction"],"mappings":";AAWO,MAAMA,yBACTC,kBAA2C"}

package/engine/GraphQLContextualSchema.d.ts

@@ -1,14 +0,0 @@
-import type { GraphQLSchema } from "graphql";
-/**
- * A schema that is built after context enhancement — use when schema content depends on
- * runtime data (e.g. CMS content models fetched from the database).
- *
- * Registered schemas are merged with the static schema from GraphQLSchemaComposer.
- */
-export interface IGraphQLContextualSchema {
-    build(ctx: Record<string, any>): Promise<GraphQLSchema>;
-}
-export declare const GraphQLContextualSchema: import("@webiny/di").Abstraction<IGraphQLContextualSchema>;
-export declare namespace GraphQLContextualSchema {
-    type Interface = IGraphQLContextualSchema;
-}

package/engine/GraphQLContextualSchema.js

@@ -1,5 +0,0 @@
-import { createAbstraction } from "@webiny/feature/api";
-const GraphQLContextualSchema = createAbstraction("GraphQLContextualSchema");
-export { GraphQLContextualSchema };
-
-//# sourceMappingURL=GraphQLContextualSchema.js.map

package/engine/GraphQLContextualSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine/GraphQLContextualSchema.js","sources":["../../src/engine/GraphQLContextualSchema.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GraphQLSchema } from \"graphql\";\n\n/**\n * A schema that is built after context enhancement — use when schema content depends on\n * runtime data (e.g. CMS content models fetched from the database).\n *\n * Registered schemas are merged with the static schema from GraphQLSchemaComposer.\n */\nexport interface IGraphQLContextualSchema {\n    build(ctx: Record<string, any>): Promise<GraphQLSchema>;\n}\n\nexport const GraphQLContextualSchema =\n    createAbstraction<IGraphQLContextualSchema>(\"GraphQLContextualSchema\");\n\nexport namespace GraphQLContextualSchema {\n    export type Interface = IGraphQLContextualSchema;\n}\n"],"names":["GraphQLContextualSchema","createAbstraction"],"mappings":";AAaO,MAAMA,0BACTC,kBAA4C"}

package/registerLegacyPluginsViaGqlContextEnhancer.d.ts

@@ -1,12 +0,0 @@
-import type { Container } from "@webiny/di";
-/**
- * Escape hatch for legacy plugin-based code that hasn't been migrated to createFeature() yet.
- *
- * Accepts any plugin array (same shape as the old createHandler({ plugins: [...] })) and
- * applies them via a GraphQLContextEnhancer so they still receive the context object.
- *
- * Usage in createLambdaHandler request callback:
- *   registerLegacyPluginsViaGqlContextEnhancer(container, extensions());
- *   registerLegacyPluginsViaGqlContextEnhancer(container, [myPlugin(), anotherPlugin()]);
- */
-export declare function registerLegacyPluginsViaGqlContextEnhancer(container: Container, plugins: any | any[]): void;

package/registerLegacyPluginsViaGqlContextEnhancer.js

@@ -1,21 +0,0 @@
-import { PluginsContainer } from "@webiny/plugins";
-import { GraphQLContextEnhancer } from "./engine/index.js";
-function registerLegacyPluginsViaGqlContextEnhancer(container, plugins) {
-    const flat = [
-        plugins
-    ].flat(1 / 0).filter(Boolean);
-    let initialized = false;
-    const enhancer = {
-        async enhance (ctx) {
-            if (initialized) return;
-            initialized = true;
-            if (!ctx.plugins) ctx.plugins = new PluginsContainer([]);
-            for (const plugin of flat)if ("function" == typeof plugin.apply) await plugin.apply(ctx);
-            else if (ctx.plugins) ctx.plugins.register(plugin);
-        }
-    };
-    container.registerInstance(GraphQLContextEnhancer, enhancer);
-}
-export { registerLegacyPluginsViaGqlContextEnhancer };
-
-//# sourceMappingURL=registerLegacyPluginsViaGqlContextEnhancer.js.map

package/registerLegacyPluginsViaGqlContextEnhancer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerLegacyPluginsViaGqlContextEnhancer.js","sources":["../src/registerLegacyPluginsViaGqlContextEnhancer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { PluginsContainer } from \"@webiny/plugins\";\nimport { GraphQLContextEnhancer } from \"./engine/index.js\";\nimport type { IGraphQLContextEnhancer } from \"./engine/index.js\";\n\n/**\n * Escape hatch for legacy plugin-based code that hasn't been migrated to createFeature() yet.\n *\n * Accepts any plugin array (same shape as the old createHandler({ plugins: [...] })) and\n * applies them via a GraphQLContextEnhancer so they still receive the context object.\n *\n * Usage in createLambdaHandler request callback:\n *   registerLegacyPluginsViaGqlContextEnhancer(container, extensions());\n *   registerLegacyPluginsViaGqlContextEnhancer(container, [myPlugin(), anotherPlugin()]);\n */\nexport function registerLegacyPluginsViaGqlContextEnhancer(\n    container: Container,\n    plugins: any | any[]\n): void {\n    const flat = [plugins].flat(Infinity as 1).filter(Boolean);\n    let initialized = false;\n\n    const enhancer: IGraphQLContextEnhancer = {\n        async enhance(ctx: Record<string, any>): Promise<void> {\n            if (initialized) {\n                return;\n            }\n            initialized = true;\n\n            // Legacy plugins assume ctx.plugins exists (they call ctx.plugins.register() directly).\n            // Mirror the contract of the old createHandler which always initialised PluginsContainer.\n            if (!ctx.plugins) {\n                ctx.plugins = new PluginsContainer([]);\n            }\n\n            for (const plugin of flat) {\n                if (typeof plugin.apply === \"function\") {\n                    await plugin.apply(ctx);\n                } else if (ctx.plugins) {\n                    ctx.plugins.register(plugin);\n                }\n            }\n        }\n    };\n\n    container.registerInstance(GraphQLContextEnhancer, enhancer);\n}\n"],"names":["registerLegacyPluginsViaGqlContextEnhancer","container","plugins","flat","Infinity","Boolean","initialized","enhancer","ctx","PluginsContainer","plugin","GraphQLContextEnhancer"],"mappings":";;AAeO,SAASA,2CACZC,SAAoB,EACpBC,OAAoB;IAEpB,MAAMC,OAAO;QAACD;KAAQ,CAAC,IAAI,CAACE,OAAe,MAAM,CAACC;IAClD,IAAIC,cAAc;IAElB,MAAMC,WAAoC;QACtC,MAAM,SAAQC,GAAwB;YAClC,IAAIF,aACA;YAEJA,cAAc;YAId,IAAI,CAACE,IAAI,OAAO,EACZA,IAAI,OAAO,GAAG,IAAIC,iBAAiB,EAAE;YAGzC,KAAK,MAAMC,UAAUP,KACjB,IAAI,AAAwB,cAAxB,OAAOO,OAAO,KAAK,EACnB,MAAMA,OAAO,KAAK,CAACF;iBAChB,IAAIA,IAAI,OAAO,EAClBA,IAAI,OAAO,CAAC,QAAQ,CAACE;QAGjC;IACJ;IAEAT,UAAU,gBAAgB,CAACU,wBAAwBJ;AACvD"}