@webda/graphql 4.0.0-beta.2 → 4.0.0-beta.3

package/lib/graphql.service.js

@@ -0,0 +1,1088 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { DomainService, DomainServiceParameters, Route, WebdaError, useApplication, useCore, useCoreEvents, useModelMetadata, useRepository } from "@webda/core";
+import * as WebdaQL from "@webda/ql";
+import { EventIterator, MergedIterator } from "@webda/runtime";
+import { GraphQLBoolean, GraphQLError, GraphQLInputObjectType, GraphQLList, GraphQLObjectType, GraphQLSchema, GraphQLString, printSchema } from "graphql";
+import { createHandler } from "graphql-http";
+import { CloseCode, makeServer } from "graphql-ws";
+import { nextTick } from "process";
+import { WebSocketServer } from "ws";
+import { AnyScalarType } from "./types/any.js";
+import { DateScalar } from "./types/date.js";
+import { GraphQLLong } from "./types/long.js";
+const GraphIQL = `
+<!doctype html>
+<html lang="en">
+  <head>
+    <title>GraphiQL</title>
+    <style>
+      body {
+        height: 100%;
+        margin: 0;
+        width: 100%;
+        overflow: hidden;
+      }
+
+      #graphiql {
+        height: 100vh;
+      }
+    </style>
+    <!--
+      This GraphiQL example depends on Promise and fetch, which are available in
+      modern browsers, but can be "polyfilled" for older browsers.
+      GraphiQL itself depends on React DOM.
+      If you do not want to rely on a CDN, you can host these files locally or
+      include them directly in your favored resource bundler.
+    -->
+    <script
+      crossorigin
+      src="https://unpkg.com/react@18/umd/react.development.js"
+    ></script>
+    <script
+      crossorigin
+      src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"
+    ></script>
+    <!--
+      These two files can be found in the npm module, however you may wish to
+      copy them directly into your environment, or perhaps include them in your
+      favored resource bundler.
+     -->
+    <script
+      src="https://unpkg.com/graphiql/graphiql.min.js"
+      type="application/javascript"
+    ></script>
+    <link rel="stylesheet" href="https://unpkg.com/graphiql/graphiql.min.css" />
+    <!-- 
+      These are imports for the GraphIQL Explorer plugin.
+     -->
+    <script
+      src="https://unpkg.com/@graphiql/plugin-explorer/dist/index.umd.js"
+      crossorigin
+    ></script>
+    <script
+      src="https://unpkg.com/graphql-ws/umd/graphql-ws.min.js"
+      type="application/javascript"
+    ></script>
+    <link
+      rel="stylesheet"
+      href="https://unpkg.com/@graphiql/plugin-explorer/dist/style.css"
+    />
+  </head>
+
+  <body>
+    <div id="graphiql">Loading...</div>
+    <script>
+      const root = ReactDOM.createRoot(document.getElementById('graphiql'));
+      const fetcher = GraphiQL.createFetcher({
+        url: '{{URL}}',
+        subscriptionUrl: '{{WSURL}}',
+        headers: { 'X-GraphiQL-Schema': 'true' },
+      });
+      const explorerPlugin = GraphiQLPluginExplorer.explorerPlugin();
+      root.render(
+        React.createElement(GraphiQL, {
+          fetcher,
+          defaultEditorToolsVisibility: true,
+          plugins: [explorerPlugin],
+        }),
+      );
+    </script>
+  </body>
+</html>
+`;
+/**
+ * Parameters for the GraphQL service
+ */
+export class GraphQLParameters extends DomainServiceParameters {
+    /**
+     * Load parameters with defaults
+     * @param params - raw configuration values
+     * @returns this for chaining
+     */
+    load(params = {}) {
+        super.load({ ...params, nameTransfomer: params.nameTransfomer || "PascalCase" });
+        this.url ?? (this.url = "/graphql");
+        this.maxOperationsPerRequest ?? (this.maxOperationsPerRequest = 10);
+        this.userModel ?? (this.userModel = "User");
+        this.exposeMe ?? (this.exposeMe = true);
+        this.globalSubscription ?? (this.globalSubscription = true);
+        return this;
+    }
+}
+/**
+ * Implement a GraphQL service
+ *
+ * It will expose all your exposed models as GraphQL types
+ * Dynamically generate the schema
+ *
+ * @WebdaModda
+ */
+let GraphQLService = (() => {
+    var _a;
+    let _classSuper = DomainService;
+    let _instanceExtraInitializers = [];
+    let _schemaRoute_decorators;
+    let _endpoint_decorators;
+    return _a = class GraphQLService extends _classSuper {
+            constructor() {
+                super(...arguments);
+                this.schema = __runInitializers(this, _instanceExtraInitializers);
+            }
+            /**
+             * Load and initialize GraphQL service parameters
+             * @param params - raw partial configuration
+             * @returns initialized GraphQLParameters
+             */
+            loadParameters(params) {
+                return new GraphQLParameters().load(params);
+            }
+            /**
+             * Resolve a JSON Schema property by following $ref pointers
+             * @param prop - JSON Schema property that may contain $ref
+             * @param definitions - schema definitions map for resolving references
+             * @returns the resolved JSON Schema (or a null type if unresolvable)
+             */
+            getJsonSchemaDefinition(prop, definitions = {}) {
+                if (prop?.type) {
+                    if (prop.type === "array" && prop.items["$ref"]) {
+                        prop.items = this.getJsonSchemaDefinition(prop.items, definitions);
+                    }
+                    return prop;
+                }
+                while (prop && prop.$ref) {
+                    prop = definitions[decodeURIComponent(prop.$ref.replace("#/definitions/", ""))];
+                }
+                return prop || { type: "null" };
+            }
+            /**
+             * Convert a JSON Schema to a GraphQL type definition
+             * @param schema - JSON Schema to convert
+             * @param defaultName - fallback name for anonymous types
+             * @param input - if true, generate GraphQLInputObjectType instead of GraphQLObjectType
+             * @returns object with the GraphQL type and optional description, or undefined for null types
+             */
+            getGraphQLSchemaFromSchema(schema, defaultName, input) {
+                let type;
+                if (!schema || !schema.type) {
+                    type = AnyScalarType;
+                }
+                else if (schema.type === "string") {
+                    if (schema.format === "date-time") {
+                        type = DateScalar;
+                    }
+                    else {
+                        type = GraphQLString;
+                    }
+                }
+                else if (schema.type === "boolean") {
+                    type = GraphQLBoolean;
+                }
+                else if (schema.type === "array") {
+                    type = new GraphQLList(this.getGraphQLSchemaFromSchema(schema.items, schema.title || defaultName, input)?.type ||
+                        GraphQLString);
+                }
+                else if (schema.type === "integer" || schema.type === "number") {
+                    // Use long to handle 2^52
+                    type = GraphQLLong;
+                }
+                else if (schema.type === "null") {
+                    return undefined;
+                }
+                else if (schema.type === "object") {
+                    const fields = {};
+                    // Map does not fit well with graphql
+                    if (!schema.properties) {
+                        return { type: AnyScalarType, description: "Map" };
+                    }
+                    for (const i in schema.properties) {
+                        const res = this.getGraphQLSchemaFromSchema(this.getJsonSchemaDefinition(schema.properties[i], schema.definitions), `${schema.title || defaultName}_${i}`, input);
+                        if (!res)
+                            continue;
+                        fields[i] = res;
+                    }
+                    if (Object.keys(fields).length === 0) {
+                        this.log("DEBUG", "Return map for", defaultName, "because no fields");
+                        return { type: AnyScalarType, description: "Map" };
+                    }
+                    type = new (input ? GraphQLInputObjectType : GraphQLObjectType)({
+                        fields,
+                        name: schema.title || defaultName
+                    });
+                }
+                return { type, description: schema.description };
+            }
+            /**
+             * Get or create a GraphQL query result wrapper type with results array and continuationToken
+             * @param type - GraphQL object type to wrap in a query result
+             * @returns GraphQL object type with results and continuationToken fields
+             */
+            getGraphQLQueryResult(type) {
+                var _b;
+                const name = `${type.name}QueryResult`;
+                (_b = this.modelsMap)[name] ?? (_b[name] = new GraphQLObjectType({
+                    fields: {
+                        results: {
+                            type: new GraphQLList(type)
+                        },
+                        continuationToken: {
+                            type: GraphQLString
+                        }
+                    },
+                    name
+                }));
+                return this.modelsMap[name];
+            }
+            /**
+             * Build GraphQL field definitions from a JSON Schema, enriching with relation resolvers from the model graph
+             * @param schema - JSON Schema describing the model properties
+             * @param defaultName - fallback name for generated types
+             * @param webdaGraph - model relation graph (links, maps, queries, parent)
+             * @param input - if true, generate input types (skip readonly fields, skip relation resolvers)
+             * @returns map of field names to GraphQL field configs
+             */
+            getGraphQLFieldsFromSchema(schema, defaultName, webdaGraph, input) {
+                const fields = {};
+                const skipFields = [];
+                const attributeFilter = (skip = false) => info => {
+                    if (!this.modelsMap[info.model] && skip) {
+                        skipFields.push(info.attribute);
+                        this.log("INFO", `Skipping field ${info.attribute} as model ${info.model} is not exposed`);
+                    }
+                    return this.modelsMap[info.model];
+                };
+                if (webdaGraph && !input) {
+                    // In graphql parent should not be displayed
+                    if (webdaGraph.parent) {
+                        fields[webdaGraph.parent.attribute] = {
+                            type: this.modelsMap[webdaGraph.parent.model],
+                            resolve: async (source, _args, context, info) => {
+                                this.countOperation(context);
+                                // Check permission and model exists
+                                return this.loadModelInstance(source[webdaGraph.parent.attribute] || "", this.app.getModel(webdaGraph.parent.model), context, info.fieldNodes?.find(node => node.name.value === webdaGraph.parent.attribute));
+                            }
+                        };
+                    }
+                    // Links should probably not be displayed
+                    (webdaGraph.links || []).filter(attributeFilter()).forEach(link => {
+                        if (link.type === "LINK") {
+                            fields[link.attribute] = {
+                                type: this.modelsMap[link.model],
+                                resolve: async (source, _, context, info) => {
+                                    // Check permission and model exists
+                                    return this.loadModelInstance(source[link.attribute] || "", this.app.getModel(link.model), context, info.fieldNodes.find(node => node.name.value === link.attribute));
+                                }
+                            };
+                        }
+                        else {
+                            fields[link.attribute] = {
+                                type: new GraphQLList(this.modelsMap[link.model]),
+                                args: {
+                                    filter: {
+                                        type: GraphQLString
+                                    }
+                                },
+                                resolve: async (source, args, context, info) => {
+                                    const src = link.type === "LINKS_MAP" ? Object.values(source[link.attribute]) : source[link.attribute];
+                                    return (await Promise.all(src.map(i => this.loadModelInstance(i, this.app.getModel(link.model), context, info.fieldNodes.find(node => node.name.value === link.attribute), args.filter ? new WebdaQL.PartialValidator(WebdaQL.unsanitize(args.filter)) : undefined)))).filter(i => i !== null);
+                                }
+                            };
+                        }
+                    });
+                    (webdaGraph.maps || []).filter(attributeFilter()).forEach(map => {
+                        fields[map.attribute] = {
+                            type: new GraphQLList(this.modelsMap[map.model]),
+                            args: {
+                                filter: {
+                                    type: GraphQLString
+                                }
+                            },
+                            resolve: async (source, args, context, info) => {
+                                const modelDefinition = this.app.getModel(map.model);
+                                return (await Promise.all(source[map.attribute].map(i => this.loadModelInstance(i, modelDefinition, context, info.fieldNodes.find(node => node.name.value === map.attribute), args.filter ? new WebdaQL.PartialValidator(WebdaQL.unsanitize(args.filter)) : undefined)))).filter(i => i !== null);
+                            }
+                        };
+                    });
+                    (webdaGraph.queries || []).filter(attributeFilter(true)).forEach(query => {
+                        fields[query.attribute] = {
+                            type: this.getGraphQLQueryResult(this.modelsMap[query.model]),
+                            args: {
+                                query: {
+                                    type: GraphQLString
+                                }
+                            },
+                            resolve: async (source, args, context, info) => {
+                                const res = await source[query.attribute].query(WebdaQL.unsanitize(args.query || ""), context);
+                                this.countOperation(context, res.results.length);
+                                return res;
+                            }
+                        };
+                    });
+                }
+                for (const i in schema.properties) {
+                    // Was initiated by the known graph
+                    if (fields[i] || skipFields.includes(i) || (schema.properties[i].readOnly && input)) {
+                        continue;
+                    }
+                    const prop = this.getGraphQLSchemaFromSchema(this.getJsonSchemaDefinition(schema.properties[i], schema.definitions), `${defaultName}_${i}`, input);
+                    if (!prop) {
+                        continue;
+                    }
+                    fields[i] = prop;
+                }
+                return fields;
+            }
+            /**
+             * Load a model instance, optimizing to skip store reads when all requested fields are already known
+             * @param knownFieldsOrId - UUID string or object with known field values
+             * @param model - model class to load from
+             * @param context - web context for permission checks
+             * @param info - GraphQL field node describing the selection set
+             * @param filter - optional WebdaQL filter to apply to the result
+             * @returns the model instance, or null if filtered out
+             */
+            async loadModelInstance(knownFieldsOrId, model, context, info, filter) {
+                const res = typeof knownFieldsOrId === "string" ? { uuid: knownFieldsOrId } : knownFieldsOrId;
+                if (filter && !filter.eval(res)) {
+                    return null;
+                }
+                let operation = 
+                // Check if we have a valid selection set
+                info === undefined ||
+                    info.selectionSet === undefined ||
+                    info.selectionSet.selections === undefined ||
+                    info.selectionSet.selections.filter(node => node.kind === "Field").length === 0;
+                // Check if know all fields already
+                for (const field of (info?.selectionSet?.selections || []).filter(node => node.kind === "Field")) {
+                    if (res[field.name.value] === undefined) {
+                        operation = true;
+                        break;
+                    }
+                }
+                // We already know the whole answer so no more request needed
+                if (!operation && (!filter || !filter.wasPartialMatch())) {
+                    return res;
+                }
+                // Count the operation then and retrieve the model
+                this.countOperation(context);
+                const modelInstance = await model.ref(res.uuid || "").get();
+                if (!modelInstance) {
+                    throw new GraphQLError("Object not found", {
+                        extensions: {
+                            code: "NOT_FOUND"
+                        }
+                    });
+                }
+                if ((await modelInstance?.canAct?.(context, "get")) !== true) {
+                    throw new GraphQLError("Permission denied", {
+                        extensions: {
+                            code: "PERMISSION_DENIED"
+                        }
+                    });
+                }
+                if (filter && !filter.eval(modelInstance, false)) {
+                    return null;
+                }
+                return modelInstance;
+            }
+            /**
+             * Increment the operation counter and throw if the per-request limit is exceeded
+             * @param context - web context holding the graphql extension with the counter
+             * @param increment - number of operations to add (default 1)
+             */
+            countOperation(context, increment = 1) {
+                const ext = context.getExtension("graphql");
+                if (ext?.count === this.parameters.maxOperationsPerRequest) {
+                    throw new GraphQLError("Too many operations", {
+                        extensions: {
+                            code: "TOO_MANY_OPERATIONS"
+                        }
+                    });
+                }
+                if (ext) {
+                    ext.count ?? (ext.count = 0);
+                    ext.count += increment;
+                }
+            }
+            /**
+             * Set up WebSocket server for GraphQL subscriptions and register upgrade handler
+             * @returns this instance for chaining
+             */
+            resolve() {
+                super.resolve();
+                // Set-up ws server
+                this.wss = new WebSocketServer({ noServer: true });
+                useCoreEvents("Webda.Init.Http", (http) => {
+                    http.on("upgrade", (req, socket, head) => {
+                        if (req.url === this.parameters.url) {
+                            (async () => {
+                                req.webdaContext ?? (req.webdaContext = await useCore().getContextFromRequest(req));
+                                await req.webdaContext.init();
+                                this.wss.handleUpgrade(req, socket, head, ws => {
+                                    this.wss.emit("connection", ws, req);
+                                });
+                            })();
+                        }
+                    });
+                });
+                return this;
+            }
+            /**
+             * Generate GraphQL schema
+             */
+            generateSchema() {
+                const rootFields = {};
+                const mutations = {};
+                const subscriptions = {};
+                const models = this.app.getModels();
+                this.modelsMap = {};
+                for (const i in models) {
+                    const model = models[i];
+                    const metadata = useModelMetadata(model);
+                    if (!metadata)
+                        continue;
+                    // Only expose the "final" version of each model — mirrors the REST
+                    // transport's behavior so that an app-specific override (e.g.
+                    // WebdaSample/User) shadows a framework-provided one (Webda/User)
+                    // instead of both being registered under the same GraphQL type name.
+                    if (!this.app.isFinalModel(metadata.Identifier))
+                        continue;
+                    if (!this.parameters.isIncluded(metadata.Identifier))
+                        continue;
+                    const schema = this.app.getSchema(i);
+                    if (!schema)
+                        continue;
+                    const name = (metadata.ShortName || i.split("/").pop()).replace("/", "_");
+                    this.log("INFO", "Add GraphQL type", name);
+                    const modelGraph = metadata.Relations;
+                    this.modelsMap[i] = new GraphQLObjectType({
+                        fields: () => this.getGraphQLFieldsFromSchema(schema, name, modelGraph),
+                        name
+                    });
+                    const input = new GraphQLInputObjectType({
+                        fields: this.getGraphQLFieldsFromSchema(schema, name + "Input", modelGraph, true),
+                        name: name + "Input"
+                    });
+                    const actionsName = Object.keys(metadata.Actions);
+                    if (!actionsName.includes("create")) {
+                        mutations[`create${name}`] = {
+                            type: this.modelsMap[i],
+                            args: {
+                                [name]: { type: input }
+                            },
+                            resolve: async (_, args, context) => {
+                                const object = new model();
+                                object.load(args[name]);
+                                this.log("INFO", "Create", object, context.getCurrentUserId());
+                                if ((await object.canAct?.(context, "create")) !== true) {
+                                    throw new GraphQLError("Permission denied", {
+                                        extensions: {
+                                            code: "PERMISSION_DENIED"
+                                        }
+                                    });
+                                }
+                                await object.save();
+                                return object;
+                            }
+                        };
+                    }
+                    if (!actionsName.includes("update")) {
+                        mutations[`update${name}`] = {
+                            type: this.modelsMap[i],
+                            args: {
+                                [name]: { type: input },
+                                uuid: {
+                                    type: GraphQLString
+                                }
+                            },
+                            resolve: async (_, args, context) => {
+                                const object = await model.ref(args.uuid).get();
+                                if ((await object?.canAct?.(context, "update")) !== true) {
+                                    throw new GraphQLError("Permission denied", {
+                                        extensions: {
+                                            code: "PERMISSION_DENIED"
+                                        }
+                                    });
+                                }
+                                return object.load(args[name]).save();
+                            }
+                        };
+                    }
+                    // check for actions
+                    if (!actionsName.includes("delete")) {
+                        mutations[`delete${name}`] = {
+                            type: new GraphQLObjectType({ name: `delete${name}`, fields: { success: { type: GraphQLBoolean } } }),
+                            args: {
+                                uuid: {
+                                    type: GraphQLString
+                                }
+                            },
+                            resolve: async (_, args, context) => {
+                                const object = await model.ref(args.uuid).get();
+                                if ((await object?.canAct?.(context, "delete")) !== true) {
+                                    throw new GraphQLError("Permission denied", {
+                                        extensions: {
+                                            code: "PERMISSION_DENIED"
+                                        }
+                                    });
+                                }
+                                await object.delete();
+                                return {
+                                    success: true
+                                };
+                            }
+                        };
+                    }
+                    // Retrieval
+                    const plural = this.transformName(metadata.Plural.split("/").pop());
+                    rootFields[plural] = {
+                        type: this.getGraphQLQueryResult(this.modelsMap[i]),
+                        args: {
+                            query: {
+                                type: GraphQLString,
+                                defaultValue: ""
+                            }
+                        },
+                        resolve: async (_, args, context) => {
+                            return await model.query(WebdaQL.unsanitize(args.query || ""));
+                        },
+                        subscribe: async (_source, args, context) => {
+                            this.log("DEBUG", "Subscription called on", args);
+                            return this.registerAsyncIteratorQuery(model, plural, WebdaQL.unsanitize(args.query || ""), context);
+                        }
+                    };
+                    const uuidField = (metadata.PrimaryKey && metadata.PrimaryKey[0]) || "uuid";
+                    /**
+                     * Subscription for a specific object
+                     */
+                    subscriptions[this.transformName(i.split("/").pop())] = {
+                        type: this.modelsMap[i],
+                        args: {
+                            [uuidField]: {
+                                type: GraphQLString
+                            }
+                        },
+                        subscribe: async (_source, args, context) => {
+                            this.log("DEBUG", "Subscription called on", args);
+                            return this.registerAsyncIterator(model, args[uuidField], context);
+                        }
+                    };
+                    const events = metadata.Events || [];
+                    const modelEvents = events;
+                    const instanceEvents = events;
+                    if (modelEvents.length) {
+                        const eventTypes = {};
+                        modelEvents.forEach(e => {
+                            eventTypes[e] = {
+                                type: AnyScalarType
+                            };
+                        });
+                        eventTypes["latestEventTime"] = { type: GraphQLLong };
+                        /**
+                         * Subscription for all events on a class of objects
+                         */
+                        subscriptions[plural + "Events"] = {
+                            type: new GraphQLObjectType({ fields: eventTypes, name: plural + "Events" }),
+                            subscribe: async (_source, args, context, info) => {
+                                const subscribedEvents = this.getSubscribedEvents(info);
+                                this.log("DEBUG", "Subscription called on", model, args[uuidField], subscribedEvents);
+                                return this.registerAsyncEventIterator(model, null, subscribedEvents, context, plural + "Events");
+                            }
+                        };
+                    }
+                    if (instanceEvents.length) {
+                        const eventTypes = {};
+                        instanceEvents.forEach(e => {
+                            eventTypes[e] = { type: AnyScalarType };
+                        });
+                        eventTypes["latestEventTime"] = { type: GraphQLLong };
+                        /**
+                         * Subscription for event on a specific object
+                         */
+                        subscriptions[this.transformName(i.split("/").pop()) + "Events"] = {
+                            type: new GraphQLObjectType({ fields: eventTypes, name: this.transformName(i.split("/").pop()) + "Events2" }),
+                            args: {
+                                [uuidField]: {
+                                    type: GraphQLString
+                                }
+                            },
+                            subscribe: async (_source, args, context, info) => {
+                                const subscribedEvents = this.getSubscribedEvents(info);
+                                this.log("DEBUG", "Subscription called on", model, args[uuidField], subscribedEvents);
+                                return this.registerAsyncEventIterator(model, args[uuidField], subscribedEvents, context, this.transformName(i.split("/").pop()) + "Events");
+                            }
+                        };
+                    }
+                    /**
+                     * Query for a specific object
+                     */
+                    rootFields[this.transformName(i.split("/").pop())] = {
+                        type: this.modelsMap[i],
+                        args: {
+                            [uuidField]: {
+                                type: GraphQLString
+                            }
+                        },
+                        resolve: async (_source, args, context, _info) => {
+                            this.countOperation(context);
+                            return this.loadModelInstance(args[uuidField] || "", model, context);
+                        }
+                    };
+                }
+                // Expose the current user under me
+                if (this.parameters.exposeMe) {
+                    const userGraph = this.app.completeNamespace(this.parameters.userModel);
+                    const model = this.app.getModel(this.parameters.userModel);
+                    const userMetadata = useModelMetadata(model);
+                    if (this.modelsMap[userGraph] && userMetadata) {
+                        rootFields[this.transformName("Me")] = {
+                            type: this.modelsMap[userGraph],
+                            resolve: async (_, _args, context) => {
+                                this.countOperation(context);
+                                return context.getCurrentUser();
+                            }
+                        };
+                        subscriptions["Me"] = {
+                            type: this.modelsMap[userGraph],
+                            subscribe: async (_source, _args, context) => {
+                                if (!context.getCurrentUserId()) {
+                                    throw new GraphQLError("Permission denied", {
+                                        extensions: {
+                                            code: "PERMISSION_DENIED"
+                                        }
+                                    });
+                                }
+                                const user = await context.getCurrentUser();
+                                const userModelDef = this.app.getModel(this.app.getModelId(user.constructor));
+                                return this.registerAsyncIterator(userModelDef, context.getCurrentUserId(), context, "Me");
+                            }
+                        };
+                        const userEvents = userMetadata.Events || [];
+                        const instanceEvents = userEvents;
+                        if (instanceEvents.length) {
+                            const eventTypes = {};
+                            instanceEvents.forEach(e => {
+                                eventTypes[e] = { type: AnyScalarType };
+                            });
+                            subscriptions["MeEvents"] = {
+                                type: new GraphQLObjectType({ fields: eventTypes, name: "MeEvents" }),
+                                subscribe: async (_source, args, context, info) => {
+                                    if (!context.getCurrentUserId()) {
+                                        throw new GraphQLError("Permission denied", {
+                                            extensions: {
+                                                code: "PERMISSION_DENIED"
+                                            }
+                                        });
+                                    }
+                                    const subscribedEvents = (info.fieldNodes[0].selectionSet?.selections || [])
+                                        .filter(node => node.kind === "Field")
+                                        .map(n => n.name.value);
+                                    const user = await context.getCurrentUser();
+                                    const userModelDef = this.app.getModel(this.app.getModelId(user.constructor));
+                                    return this.registerAsyncEventIterator(userModelDef, context.getCurrentUserId(), subscribedEvents, context, "MeEvents");
+                                }
+                            };
+                        }
+                    }
+                    else {
+                        this.log("WARN", "Cannot expose me, user model is not exposed or get is restricted or type is not unavailable");
+                    }
+                }
+                const services = useCore().getServices();
+                for (const i in services) {
+                    if (services[i]?.getClientEvents === undefined) {
+                        continue;
+                    }
+                    const events = services[i]?.getClientEvents() || [];
+                    if (events.length === 0) {
+                        continue;
+                    }
+                    const fields = {};
+                    events.forEach(e => {
+                        fields[e] = { type: AnyScalarType };
+                    });
+                    const id = `${i}Events`;
+                    subscriptions[id] = {
+                        type: new GraphQLObjectType({
+                            fields,
+                            name: id
+                        }),
+                        subscribe: async (_source, args, context, info) => {
+                            const fieldsMap = {};
+                            (info.fieldNodes[0].selectionSet?.selections || [])
+                                .filter(node => node.kind === "Field")
+                                .map(n => n.name.value)
+                                .forEach(n => (fieldsMap[n] = true));
+                            return new EventIterator(services[i], fieldsMap, id, {}).iterate();
+                        }
+                    };
+                }
+                // Copy the rootFields without resolver
+                for (const i in rootFields) {
+                    subscriptions[i] ?? (subscriptions[i] = { ...rootFields[i], resolve: undefined });
+                }
+                if (this.parameters.globalSubscription) {
+                    // Create global type based on all previous subscriptions
+                    subscriptions["Aggregate"] = {
+                        type: new GraphQLObjectType({
+                            fields: subscriptions,
+                            name: "AggregateSubscriptions"
+                        }),
+                        subscribe: async (_source, args2, context, info) => {
+                            const iterators = {};
+                            const p = [];
+                            // Check if know all fields already
+                            for (const field of (info.fieldNodes[0].selectionSet?.selections || []).filter(node => node.kind === "Field")) {
+                                const name = field.name.value;
+                                const args = {};
+                                field.arguments?.forEach(arg => {
+                                    // @ts-ignore
+                                    args[arg.name.value] = arg.value.value;
+                                });
+                                p.push((async () => {
+                                    iterators[name] = await subscriptions[name].subscribe(_source, args, context, {
+                                        fieldNodes: [field] // Abusing a bit the builder currently
+                                    });
+                                })());
+                            }
+                            await Promise.all(p);
+                            return MergedIterator.iterate({
+                                Aggregate: MergedIterator.iterate(iterators, true, data => {
+                                    return Object.values(data).pop();
+                                })
+                            });
+                        }
+                    };
+                }
+                this.schema = this.getGraphQLSchema(rootFields, mutations, subscriptions);
+            }
+            /**
+             * Extract the list of event names from the GraphQL selection set (excluding latestEventTime)
+             * @param info - GraphQL resolve info containing field selections
+             * @returns array of event name strings the client subscribed to
+             */
+            getSubscribedEvents(info) {
+                return (info.fieldNodes[0].selectionSet?.selections || [])
+                    .filter(node => node.kind === "Field" && node.name.value !== "latestEventTime")
+                    .map(n => n.name.value);
+            }
+            /**
+             * Create an async iterator that streams query results, updating when store events occur
+             * @param model - model class to query
+             * @param plural - plural name used as the iterator prefix key
+             * @param query - WebdaQL query string
+             * @param context - web context for permission checks
+             * @returns async iterator yielding updated query results on store changes
+             */
+            async registerAsyncIteratorQuery(model, plural, query, context) {
+                let result = await model.query(query);
+                const queryInfo = new WebdaQL.QueryValidator(query);
+                const updatedCallback = async (evt) => {
+                    this.log("TRACE", "Event from", evt.emitterId, evt.object_id);
+                    if (!result.results.find(e => evt.object_id === e.getUUID()))
+                        return;
+                    // We rely on the cache of the store to get the full object
+                    // We let the other listeners finish before returning the object
+                    await new Promise(resolve => nextTick(resolve));
+                    result.results = await Promise.all(result.results.map(r => (r.getUUID() === evt.object_id ? model.ref(evt.object_id).get() : r)));
+                    return {
+                        continuationToken: result.continuationToken,
+                        results: result.results
+                    };
+                };
+                const events = {
+                    Updated: updatedCallback,
+                    // Deleted is different as we need to return null
+                    Deleted: async (evt) => {
+                        if (!result.results.find(e => evt.object_id === e.getUUID()))
+                            return;
+                        result = await model.query(query);
+                        return result;
+                    },
+                    Created: async (evt) => {
+                        // If object match the query and is not in the result and can be read by the user
+                        if (queryInfo.eval(evt.object) && !queryInfo.getOffset() && evt.object.canAct(context, "get")) {
+                            // Should check with the order by of the query to see if we need to recompute
+                            result = await model.query(query);
+                            return result;
+                        }
+                        return;
+                    },
+                    Patched: updatedCallback,
+                    PartialUpdated: updatedCallback
+                };
+                // Listen on the model's repository typed events (Created/Updated/...) instead
+                // of the legacy Store.* events.
+                return new EventIterator(useRepository(model), events, plural, result).iterate();
+            }
+            /**
+             * Create an async iterator that streams a single model instance, updating on store events
+             * @param model - model class the instance belongs to
+             * @param uuid - UUID of the specific instance to watch
+             * @param context - web context for permission checks
+             * @param identifier - optional key used as the iterator prefix (defaults to model identifier)
+             * @returns async iterator yielding the updated model on each store change
+             */
+            async registerAsyncIterator(model, uuid, context, identifier) {
+                const updatedCallback = async (evt) => {
+                    this.log("INFO", "Event from", evt.emitterId, evt.object_id);
+                    if (evt.object_id !== uuid)
+                        return;
+                    // We rely on the cache of the store to get the full object
+                    // We let the other listeners finish before returning the object
+                    await new Promise(resolve => nextTick(resolve));
+                    return model.ref(evt.object_id).get();
+                };
+                const events = {
+                    Updated: updatedCallback,
+                    // Deleted is different as we need to return null
+                    Deleted: evt => {
+                        if (evt.object_id !== uuid)
+                            return;
+                        return null;
+                    },
+                    Patched: updatedCallback,
+                    PartialUpdated: updatedCallback
+                };
+                const modelInstance = await model.ref(uuid).get();
+                // Ensure we have the permission to get the object
+                if ((await modelInstance?.canAct?.(context, "get")) !== true) {
+                    throw new GraphQLError("Permission denied", {
+                        extensions: {
+                            code: "PERMISSION_DENIED"
+                        }
+                    });
+                }
+                // Listen on the model's repository typed events instead of legacy Store.* events.
+                return new EventIterator(useRepository(model), events, identifier || useModelMetadata(model)?.Identifier, modelInstance).iterate();
+            }
+            /**
+             * Create an async iterator for raw model events (not full objects), filtered by event name and UUID
+             * @param model - model class to listen on
+             * @param uuid - UUID to filter events for, or null for all instances
+             * @param events - list of event names the client wants to receive
+             * @param context - web context for authorization checks
+             * @param identifier - key used as the iterator prefix
+             * @returns async iterator yielding event payloads with latestEventTime
+             */
+            async registerAsyncEventIterator(model, uuid, events, context, identifier) {
+                const updatedCallback = eventName => async (evt) => {
+                    if (uuid === null || evt.object_id !== uuid)
+                        return;
+                    // We rely on the cache of the store to get the full object
+                    // We let the other listeners finish before returning the object
+                    return { latestEventTime: Date.now(), [eventName]: evt };
+                };
+                const eventsMap = {};
+                const modelInstance = uuid !== null ? await model.ref(uuid).get() : undefined;
+                events
+                    .filter(e => useCore().getModelStore(model)?.authorizeClientEvent?.(e, context) !== false)
+                    .forEach(e => (eventsMap[e] = updatedCallback(e)));
+                // Ensure we have the permission to listen to the object
+                if (Object.keys(eventsMap).length === 0) {
+                    throw new GraphQLError("Permission denied", {
+                        extensions: {
+                            code: "PERMISSION_DENIED"
+                        }
+                    });
+                }
+                // Source events from the model's repository; authorization above still
+                // consults the store via authorizeClientEvent.
+                return new EventIterator(useRepository(model), eventsMap, identifier, {
+                    logout: { evt: "nok?" }
+                }).iterate();
+            }
+            /**
+             * Assemble the final GraphQLSchema from root query fields, mutations, and subscriptions
+             * @param rootFields - top-level query fields
+             * @param mutations - mutation fields
+             * @param subscription - subscription fields
+             * @returns the constructed GraphQLSchema
+             */
+            getGraphQLSchema(rootFields, mutations = {}, subscription = {}) {
+                // Emit Webda.GraphQL.Schema to allow other services to contribute
+                this.emit("Webda.GraphQL.Schema", {
+                    rootFields,
+                    mutations,
+                    subscription
+                });
+                return new GraphQLSchema({
+                    query: new GraphQLObjectType({
+                        name: "Query",
+                        fields: rootFields
+                    }),
+                    types: Object.values(this.modelsMap),
+                    subscription: Object.keys({ ...subscription }).length > 0
+                        ? new GraphQLObjectType({ fields: { ...subscription }, name: "Subscription" })
+                        : null,
+                    mutation: Object.keys(mutations).length > 0 ? new GraphQLObjectType({ fields: mutations, name: "Mutations" }) : null
+                });
+            }
+            /**
+             * @override
+             */
+            async init() {
+                var _b;
+                await super.init();
+                // If not define then fallback to debug mode
+                (_b = this.parameters).exposeGraphiQL ?? (_b.exposeGraphiQL = useCore().isDebug());
+                this.app = useApplication();
+                this.generateSchema();
+                // Generate GraphQL schema
+                this.handler = createHandler({
+                    schema: this.schema,
+                    context: (req, _) => {
+                        return req.context;
+                    }
+                });
+                // Define the mechanism to handle the websocket
+                this.wsHandler = makeServer({
+                    schema: this.schema,
+                    context: async (req) => {
+                        // @ts-ignore
+                        return req.extra?.context || {};
+                    }
+                });
+                this.wss.on("connection", async (socket, request) => {
+                    // a new socket opened, let graphql-ws take over
+                    const closed = this.wsHandler.opened({
+                        protocol: socket.protocol, // will be validated
+                        send: data => new Promise((resolve, reject) => {
+                            socket.send(data, err => (err ? reject(err) : resolve()));
+                        }), // control your data flow by timing the promise resolve
+                        close: (code, reason) => socket.close(code, reason), // there are protocol standard closures
+                        onMessage: cb => socket.on("message", async (event) => {
+                            try {
+                                // wait for the the operation to complete
+                                // - if init message, waits for connect
+                                // - if query/mutation, waits for result
+                                // - if subscription, waits for complete
+                                await cb(event.toString());
+                            }
+                            catch (err) {
+                                // all errors that could be thrown during the
+                                // execution of operations will be caught here
+                                socket.close(CloseCode.InternalServerError, err.message);
+                            }
+                        })
+                    }, 
+                    // pass values to the `extra` field in the context
+                    { socket, request, context: request.webdaContext });
+                    this.log("INFO", "Socket once closed");
+                    // notify server that the socket closed
+                    socket.once("close", (code, reason) => {
+                        this.log("INFO", "Socket closed - clean up Iterators");
+                        closed(code, reason.toString());
+                    });
+                });
+                return this;
+            }
+            /**
+             * Check whether a model should be handled by this service (always returns true)
+             * @param model - model class to check
+             * @param name - display name of the model
+             * @param context - request context
+             * @returns true if the model should be processed
+             */
+            handleModel(model, name, context) {
+                //throw new Error("Method not implemented.");
+                return true;
+            }
+            /**
+             * Serve the GraphQL schema as text or the GraphiQL IDE as HTML
+             * @param ctx - incoming web context
+             */
+            async schemaRoute(ctx) {
+                const httpContext = ctx.getHttpContext();
+                if (!this.parameters.exposeGraphiQL) {
+                    throw new WebdaError.NotFound("GraphiQL not exposed");
+                }
+                if (httpContext.getHeader("X-GraphiQL-Schema") === "true") {
+                    ctx.writeHead(200, { "Content-Type": "application/graphql" });
+                    ctx.write(printSchema(this.schema));
+                }
+                else {
+                    ctx.writeHead(200, { "Content-Type": "text/html" });
+                    ctx.write(GraphIQL.replace("{{URL}}", httpContext.getAbsoluteUrl()).replace("{{WSURL}}", httpContext.getAbsoluteUrl().replace("http", "ws")));
+                }
+            }
+            /**
+             * Handle POST requests to the GraphQL endpoint
+             * @param ctx - incoming web context with the GraphQL query body
+             */
+            async endpoint(ctx) {
+                const httpContext = ctx.getHttpContext();
+                ctx.setExtension("graphql", { count: 0 });
+                const [body, init] = await this.handler({
+                    url: httpContext.getUrl(),
+                    method: httpContext.getMethod(),
+                    headers: httpContext.getHeaders(),
+                    body: await ctx.getInput(),
+                    raw: ctx,
+                    context: ctx
+                });
+                ctx.writeHead(init.status, init.headers);
+                ctx.write(body);
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _schemaRoute_decorators = [Route(".", ["GET"], { hidden: true })];
+            _endpoint_decorators = [Route(".", ["POST"], {
+                    post: {
+                        summary: "GraphQL endpoint",
+                        requestBody: {
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            query: { type: "string" },
+                                            variables: { type: "object" }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                })];
+            __esDecorate(_a, null, _schemaRoute_decorators, { kind: "method", name: "schemaRoute", static: false, private: false, access: { has: obj => "schemaRoute" in obj, get: obj => obj.schemaRoute }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _endpoint_decorators, { kind: "method", name: "endpoint", static: false, private: false, access: { has: obj => "endpoint" in obj, get: obj => obj.endpoint }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { GraphQLService };
+//# sourceMappingURL=graphql.service.js.map