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

package/lib/graphql.js

@@ -1,1005 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Core, DomainService, DomainServiceParameters, Route, WebdaError } 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 {
-    constructor(params) {
-        super({ ...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);
-    }
-}
-/**
- * Implement a GraphQL service
- *
- * It will expose all your exposed models as GraphQL types
- * Dynamically generate the schema
- *
- * @WebdaModda
- */
-export class GraphQLService extends DomainService {
-    loadParameters(params) {
-        return new GraphQLParameters(params);
-    }
-    /**
-     *
-     * @param prop
-     * @param definitions
-     * @returns
-     */
-    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" };
-    }
-    /**
-     *
-     * @param schema
-     * @param defaultName
-     * @returns
-     */
-    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 (let i in schema.properties) {
-                let 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 };
-    }
-    /**
-     * Add the GraphQL schema results
-     * @param type
-     * @returns
-     */
-    getGraphQLQueryResult(type) {
-        var _a;
-        const name = `${type.name}QueryResult`;
-        (_a = this.modelsMap)[name] ?? (_a[name] = new GraphQLObjectType({
-            fields: {
-                results: {
-                    type: new GraphQLList(type)
-                },
-                continuationToken: {
-                    type: GraphQLString
-                }
-            },
-            name
-        }));
-        return this.modelsMap[name];
-    }
-    /**
-     *
-     * @param schema
-     * @param defaultName
-     * @param webdaGraph
-     * @returns
-     */
-    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) => {
-                            let src = link.type === "LINKS_MAP" ? Object.values(source[link.attribute]) : source[link.attribute];
-                            return (await Promise.all(src.map(i => this.loadModelInstance(i, this.getWebda().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) => {
-                        let 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) => {
-                        let res = await source[query.attribute].query(WebdaQL.unsanitize(args.query || ""), context);
-                        this.countOperation(context, res.results.length);
-                        return res;
-                    }
-                };
-            });
-        }
-        for (let i in schema.properties) {
-            // Was initiated by the known graph
-            if (fields[i] || skipFields.includes(i) || (schema.properties[i].readOnly && input)) {
-                continue;
-            }
-            let prop = this.getGraphQLSchemaFromSchema(this.getJsonSchemaDefinition(schema.properties[i], schema.definitions), `${defaultName}_${i}`, input);
-            if (!prop) {
-                continue;
-            }
-            fields[i] = prop;
-        }
-        return fields;
-    }
-    /**
-     * Load model with filter on attributes
-     * @param knownFieldsOrId
-     * @param model
-     * @param context
-     * @param info
-     * @returns
-     */
-    async loadModelInstance(knownFieldsOrId, model, context, info, filter) {
-        let 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 (let 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);
-        let 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;
-    }
-    /**
-     * Count the number of operations done with graphql
-     * @param context
-     */
-    countOperation(context, increment = 1) {
-        let 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;
-        }
-    }
-    resolve() {
-        super.resolve();
-        // Set-up ws server
-        this.wss = new WebSocketServer({ noServer: true });
-        this.getWebda().on("Webda.Init.Http", (http) => {
-            http.on("upgrade", (req, socket, head) => {
-                if (req.url === this.parameters.url) {
-                    (async () => {
-                        req.webdaContext ?? (req.webdaContext = await Core.get().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();
-        const graph = this.app.getGraph();
-        this.modelsMap = {};
-        for (let i in models) {
-            const model = models[i];
-            // Not exposed
-            if (!model.Expose || !this.parameters.isIncluded(model.getIdentifier())) {
-                continue;
-            }
-            const schema = model.getSchema();
-            if (!schema) {
-                continue;
-            }
-            let name = this.app.getShortId(i).replace("/", "_");
-            this.log("INFO", "Add GraphQL type", name);
-            this.modelsMap[i] = new GraphQLObjectType({
-                fields: () => this.getGraphQLFieldsFromSchema(schema, name, graph[i]),
-                name
-            });
-            let input = new GraphQLInputObjectType({
-                fields: this.getGraphQLFieldsFromSchema(schema, name + "Input", graph[i], true),
-                name: name + "Input"
-            });
-            if (!model.Expose.restrict.create) {
-                mutations[`create${name}`] = {
-                    type: this.modelsMap[i],
-                    args: {
-                        [name]: { type: input }
-                    },
-                    resolve: async (_, args, context) => {
-                        let object = new model().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 (!model.Expose.restrict.update) {
-                mutations[`update${name}`] = {
-                    type: this.modelsMap[i],
-                    args: {
-                        [name]: { type: input },
-                        uuid: {
-                            type: GraphQLString
-                        }
-                    },
-                    resolve: async (_, args, context) => {
-                        let 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 (!model.Expose.restrict.delete) {
-                mutations[`delete${name}`] = {
-                    type: new GraphQLObjectType({ name: `delete${name}`, fields: { success: { type: GraphQLBoolean } } }),
-                    args: {
-                        uuid: {
-                            type: GraphQLString
-                        }
-                    },
-                    resolve: async (_, args, context) => {
-                        let 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
-            let plural = this.transformName(this.app.getModelPlural(i).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 || ""), true, context);
-                },
-                subscribe: async (_source, args, context) => {
-                    this.log("DEBUG", "Subscription called on", args);
-                    return this.registerAsyncIteratorQuery(model, plural, WebdaQL.unsanitize(args.query || ""), context);
-                }
-            };
-            /**
-             * Subscription for a specific object
-             */
-            subscriptions[this.transformName(i.split("/").pop())] = {
-                type: this.modelsMap[i],
-                args: {
-                    [model.getUuidField()]: {
-                        type: GraphQLString
-                    }
-                },
-                subscribe: async (_source, args, context) => {
-                    this.log("DEBUG", "Subscription called on", args);
-                    return this.registerAsyncIterator(model, args[model.getUuidField()], context);
-                }
-            };
-            const events = model.getClientEvents();
-            const modelEvents = events
-                .filter(e => typeof e !== "string" && e.global)
-                .map((e) => e.name);
-            const instanceEvents = events
-                .filter(e => typeof e === "string" || !e.global)
-                .map(e => (typeof e === "string" ? e : e.name));
-            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) => {
-                        let subscribedEvents = this.getSubscribedEvents(info);
-                        this.log("DEBUG", "Subscription called on", model, args[model.getUuidField()], 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: {
-                        [model.getUuidField()]: {
-                            type: GraphQLString
-                        }
-                    },
-                    subscribe: async (_source, args, context, info) => {
-                        let subscribedEvents = this.getSubscribedEvents(info);
-                        this.log("DEBUG", "Subscription called on", model, args[model.getUuidField()], subscribedEvents);
-                        return this.registerAsyncEventIterator(model, args[model.getUuidField()], subscribedEvents, context, this.transformName(i.split("/").pop()) + "Events");
-                    }
-                };
-            }
-            /**
-             * Query for a specific object
-             */
-            rootFields[this.transformName(i.split("/").pop())] = {
-                type: this.modelsMap[i],
-                args: {
-                    [model.getUuidField()]: {
-                        type: GraphQLString
-                    }
-                },
-                resolve: async (_source, args, context, _info) => {
-                    this.countOperation(context);
-                    return this.loadModelInstance(args[model.getUuidField()] || "", model, context);
-                }
-            };
-        }
-        // Expose the current user under me
-        if (this.parameters.exposeMe) {
-            const userGraph = this.app.completeNamespace(this.parameters.userModel);
-            let model = this.app.getModel(this.parameters.userModel);
-            if (this.modelsMap[userGraph] && model.Expose && model.Expose.restrict.get !== true) {
-                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();
-                        return this.registerAsyncIterator(user.__class, context.getCurrentUserId(), context, "Me");
-                    }
-                };
-                const events = model.getClientEvents();
-                const instanceEvents = events
-                    .filter(e => typeof e === "string" || !e.global)
-                    .map(e => (typeof e === "string" ? e : e.name));
-                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();
-                            return this.registerAsyncEventIterator(user.__class, 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 = this.getWebda().getServices();
-        for (let 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 (let 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) => {
-                    let iterators = {};
-                    let p = [];
-                    // Check if know all fields already
-                    for (let 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);
-    }
-    /**
-     * Return the events to subscribe to
-     * @param info
-     * @returns
-     */
-    getSubscribedEvents(info) {
-        return (info.fieldNodes[0].selectionSet?.selections || [])
-            .filter(node => node.kind === "Field" && node.name.value !== "latestEventTime")
-            .map(n => n.name.value);
-    }
-    /**
-     *
-     * @param model
-     * @param arg1
-     * @param context
-     * @returns
-     */
-    async registerAsyncIteratorQuery(model, plural, query, context) {
-        let result = await model.query(query, true, context);
-        let queryInfo = new WebdaQL.QueryValidator(query);
-        const updatedCallback = async (evt) => {
-            this.log("INFO", "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));
-            return {
-                continuationToken: result.continuationToken,
-                results: await Promise.all(result.results.map(r => (r.getUuid() === evt.object_id ? model.ref(evt.object_id).get() : r)))
-            };
-        };
-        const events = {
-            "Store.Updated": updatedCallback,
-            // Deleted is different as we need to return null
-            "Store.Deleted": async (evt) => {
-                if (!result.results.find(e => evt.object_id === e.getUuid()))
-                    return;
-                result = await model.query(query, true, context);
-                return result;
-            },
-            "Store.Saved": 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, true, context);
-                    return result;
-                }
-                return;
-            },
-            "Store.PatchUpdated": updatedCallback,
-            "Store.PartialUpdated": updatedCallback
-        };
-        return new EventIterator(model.store(), events, plural, result).iterate();
-    }
-    /**
-     *
-     * @param model
-     * @param uuid
-     * @param context
-     * @returns
-     */
-    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 = {
-            "Store.Updated": updatedCallback,
-            // Deleted is different as we need to return null
-            "Store.Deleted": evt => {
-                if (evt.object_id !== uuid)
-                    return;
-                return null;
-            },
-            "Store.PatchUpdated": updatedCallback,
-            "Store.PartialUpdated": updatedCallback
-        };
-        let 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"
-                }
-            });
-        }
-        return new EventIterator(model.store(), events, identifier || model.getIdentifier(), modelInstance).iterate();
-    }
-    /**
-     *
-     * @param model
-     * @param uuid
-     * @param context
-     * @returns
-     */
-    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 = {};
-        let modelInstance = uuid !== null ? await model.ref(uuid).get() : undefined;
-        events
-            .filter(e => model.authorizeClientEvent(e, context, modelInstance))
-            .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"
-                }
-            });
-        }
-        return new EventIterator(model.store(), eventsMap, identifier, { logout: { evt: "nok?" } }).iterate();
-    }
-    /**
-     *
-     * @param rootFields
-     * @param mutation
-     * @returns
-     */
-    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 _a;
-        await super.init();
-        // If not define then fallback to debug mode
-        (_a = this.parameters).exposeGraphiQL ?? (_a.exposeGraphiQL = this.getWebda().isDebug());
-        this.app = this.getWebda().getApplication();
-        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;
-    }
-    handleModel(model, name, context) {
-        //throw new Error("Method not implemented.");
-        return true;
-    }
-    /**
-     * Serve schema and graphqli
-     * @params ctx
-     */
-    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")));
-        }
-    }
-    /**
-     * Endpoint for the GraphQL schema
-     * @param ctx
-     * @returns
-     */
-    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);
-    }
-}
-__decorate([
-    Route(".", ["GET"], { hidden: true })
-], GraphQLService.prototype, "schemaRoute", null);
-__decorate([
-    Route(".", ["POST"], {
-        post: {
-            summary: "GraphQL endpoint",
-            requestBody: {
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            properties: {
-                                query: {
-                                    type: "string"
-                                },
-                                variables: {
-                                    type: "object"
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    })
-], GraphQLService.prototype, "endpoint", null);
-//# sourceMappingURL=graphql.js.map