@webiny/api-graphql 0.0.0-unstable.0156a4c312

package/engine/GraphQLEngine.d.ts

@@ -0,0 +1,23 @@
+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";
+declare class GraphQLEngineImpl implements GraphQLEngineAbstraction.Interface {
+    private composer;
+    private container;
+    private schemaCache;
+    constructor(composer: IGraphQLSchemaComposer, container: Container, schemaCache: GraphQLSchemaCache.Interface | undefined);
+    execute(body: any): Promise<any>;
+    /**
+     * 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 & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGraphQLEngine>;
+};
+export {};

package/engine/GraphQLEngine.js

@@ -0,0 +1,81 @@
+import { graphql } from "graphql";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { mergeResolvers } from "@graphql-tools/merge";
+import { RequestContainer } from "@webiny/event-handler-core";
+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, schemaCache){
+        this.composer = composer;
+        this.container = container;
+        this.schemaCache = schemaCache;
+    }
+    async execute(body) {
+        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 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;
+        return graphql({
+            schema,
+            source: query,
+            rootValue: {},
+            contextValue: ctx,
+            variableValues: variables ?? void 0,
+            operationName: operationName ?? void 0
+        });
+    }
+}
+const GraphQLEngine_GraphQLEngine = GraphQLEngine.createImplementation({
+    implementation: GraphQLEngineImpl,
+    dependencies: [
+        GraphQLSchemaComposer,
+        RequestContainer,
+        [
+            GraphQLSchemaCache,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { GraphQLEngine_GraphQLEngine as GraphQLEngine };
+
+//# sourceMappingURL=GraphQLEngine.js.map

package/engine/GraphQLEngine.js.map

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

@@ -0,0 +1,4 @@
+export declare const GraphQLEngineFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/engine/GraphQLEngineFeature.js

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

package/engine/GraphQLEngineFeature.js.map

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

@@ -0,0 +1,24 @@
+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 HttpRouteHandler.Interface {
+    private engine;
+    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

@@ -0,0 +1,38 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
+import { GraphQLEngine } from "./abstractions.js";
+class GraphQLRouteImpl {
+    constructor(engine){
+        this.engine = engine;
+    }
+    async handle(request) {
+        const result = await this.engine.execute(request.body);
+        return {
+            statusCode: 200,
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: result
+        };
+    }
+}
+const GraphQLRoute = HttpRouteHandler.createImplementation({
+    implementation: GraphQLRouteImpl,
+    dependencies: [
+        GraphQLEngine
+    ]
+});
+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

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

@@ -0,0 +1,36 @@
+import type { GraphQLSchema } from "graphql";
+export interface IGraphQLEngine {
+    execute(body: any): Promise<any>;
+}
+export declare const GraphQLEngine: import("@webiny/di").Abstraction<IGraphQLEngine>;
+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

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

package/engine/abstractions.js.map

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

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

package/engine/index.js

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

package/errors.d.ts

@@ -0,0 +1,4 @@
+import WebinyError from "@webiny/error";
+export declare class NotFoundError extends WebinyError {
+    constructor(message?: string);
+}

package/errors.js

@@ -0,0 +1,9 @@
+import error from "@webiny/error";
+class NotFoundError extends error {
+    constructor(message = "Not found."){
+        super(message, "NOT_FOUND");
+    }
+}
+export { NotFoundError };
+
+//# sourceMappingURL=errors.js.map

package/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sources":["../src/errors.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\n\nexport class NotFoundError extends WebinyError {\n    constructor(message = \"Not found.\") {\n        super(message, \"NOT_FOUND\");\n    }\n}\n"],"names":["NotFoundError","WebinyError","message"],"mappings":";AAEO,MAAMA,sBAAsBC;IAC/B,YAAYC,UAAU,YAAY,CAAE;QAChC,KAAK,CAACA,SAAS;IACnB;AACJ"}

package/exports/api/graphql.d.ts

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

@@ -0,0 +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.d.ts

@@ -0,0 +1,17 @@
+import type { GraphQLSchemaBuilder as Abstraction } from "./abstractions.js";
+import type { IGraphQLSchema } from "../../graphql/abstractions.public.js";
+import type { ResolverDecorator } from "../../types.js";
+export declare class GraphQLSchemaBuilder implements Abstraction.Interface {
+    private readonly typeDefsArray;
+    private readonly resolvers;
+    private readonly resolverDecorators;
+    addTypeDefs(typeDefs: string): this;
+    addResolver<TArgs = any>(config: Abstraction.Config<TArgs>): this;
+    addLegacyResolvers(resolvers: Record<string, any>, prefix?: string): this;
+    /**
+     * @internal This method needs revisiting, to align with DI concepts.
+     */
+    addResolverDecorator(path: string, decorator: ResolverDecorator): this;
+    build(): IGraphQLSchema;
+    private setResolverAtPath;
+}

package/features/GraphQLSchemaBuilder/GraphQLSchemaBuilder.js

@@ -0,0 +1,72 @@
+class GraphQLSchemaBuilder {
+    addTypeDefs(typeDefs) {
+        this.typeDefsArray.push(typeDefs);
+        return this;
+    }
+    addResolver(config) {
+        const { path, dependencies = [], resolver } = config;
+        const pathParts = path.split(".");
+        const graphqlResolver = (parent, args, context, info)=>{
+            const resolvedDeps = dependencies.map((dep)=>{
+                const [abstraction, options] = Array.isArray(dep) ? dep : [
+                    dep,
+                    void 0
+                ];
+                return options?.multiple ? context.container.resolveAll(abstraction) : context.container.resolve(abstraction);
+            });
+            const actualResolver = resolver(...resolvedDeps);
+            return actualResolver({
+                parent,
+                args,
+                context,
+                info
+            });
+        };
+        this.setResolverAtPath(pathParts, graphqlResolver);
+        return this;
+    }
+    addLegacyResolvers(resolvers, prefix = "") {
+        for (const [key, value] of Object.entries(resolvers)){
+            const path = prefix ? `${prefix}.${key}` : key;
+            if ("function" == typeof value) {
+                const fn = value;
+                this.addResolver({
+                    path,
+                    dependencies: [],
+                    resolver: ()=>({ parent, args, context, info })=>fn(parent, args, context, info)
+                });
+            } else if ("object" == typeof value && null !== value) this.addLegacyResolvers(value, path);
+        }
+        return this;
+    }
+    addResolverDecorator(path, decorator) {
+        if (!this.resolverDecorators[path]) this.resolverDecorators[path] = [];
+        this.resolverDecorators[path].push(decorator);
+        return this;
+    }
+    build() {
+        return {
+            typeDefs: this.typeDefsArray.join("\n"),
+            resolvers: this.resolvers,
+            resolverDecorators: this.resolverDecorators
+        };
+    }
+    setResolverAtPath(pathParts, resolver) {
+        let current = this.resolvers;
+        for(let i = 0; i < pathParts.length - 1; i++){
+            const part = pathParts[i];
+            if (!current[part]) current[part] = {};
+            current = current[part];
+        }
+        const finalKey = pathParts[pathParts.length - 1];
+        current[finalKey] = resolver;
+    }
+    constructor(){
+        this.typeDefsArray = [];
+        this.resolvers = {};
+        this.resolverDecorators = {};
+    }
+}
+export { GraphQLSchemaBuilder };
+
+//# sourceMappingURL=GraphQLSchemaBuilder.js.map