@webda/core 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/rest/restdomainservice.js

@@ -1,687 +0,0 @@
-import { QueryValidator } from "@webda/ql";
-import { DomainServiceParameters, ModelsOperationsService } from "../services/domainservice.js";
-import { WebdaError } from "../index.js";
-/**
- * Swagger static html
- */
-const SWAGGER_HTML = `
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <link rel="stylesheet" type="text/css" href="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/{{VERSION}}/swagger-ui.css" >
-    <style>
-      .topbar {
-        display: none;
-      }
-    </style>
-  </head>
-
-  <body>
-    <div id="swagger-ui"></div>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/{{VERSION}}/swagger-ui-bundle.js"> </script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/{{VERSION}}/swagger-ui-standalone-preset.js"> </script>
-    <script>
-      const spec = {{OPENAPI}};
-      window.onload = function() {
-        const ui = SwaggerUIBundle({
-          spec: spec,
-          dom_id: '#swagger-ui',
-          deepLinking: true,
-          presets: [
-            SwaggerUIBundle.presets.apis,
-            SwaggerUIStandalonePreset
-          ],
-          plugins: [
-            SwaggerUIBundle.plugins.DownloadUrl
-          ],
-          layout: "StandaloneLayout"
-        })
-     
-        window.ui = ui
-      }
-  </script>
-  </body>
-</html>
-`;
-/**
- *
- */
-export class RESTDomainServiceParameters extends DomainServiceParameters {
-    /**
-     * Set default url to /
-     * @param params
-     */
-    constructor(params) {
-        super(params);
-        this.url ?? (this.url = "/");
-        this.swaggerVersion ?? (this.swaggerVersion = "3.19.5");
-    }
-}
-/**
- * Expose all models via a REST API
- * @WebdaModda
- */
-export class RESTDomainService extends ModelsOperationsService {
-    /**
-     * Override to fallback on isDebug for exposeOpenAPI
-     * @returns
-     */
-    resolve() {
-        var _a;
-        (_a = this.parameters).exposeOpenAPI ?? (_a.exposeOpenAPI = this.getWebda().isDebug());
-        super.resolve();
-        if (this.parameters.exposeOpenAPI) {
-            this.addRoute(".", ["GET"], this.openapi, { hidden: true });
-        }
-        return this;
-    }
-    /**
-     * @override
-     */
-    loadParameters(params) {
-        return new RESTDomainServiceParameters(params);
-    }
-    /**
-     * Handle one model and expose it based on the service
-     * @param model
-     * @param name
-     * @param context
-     * @returns
-     */
-    handleModel(model, name, context) {
-        const depth = context.depth || 0;
-        const relations = model.getRelations();
-        const injectAttribute = relations?.parent?.attribute;
-        const app = this.getWebda().getApplication();
-        // Update prefix
-        const prefix = (context.prefix || (this.parameters.url.endsWith("/") ? this.parameters.url : this.parameters.url + "/")) +
-            this.transformName(name);
-        context.prefix = prefix + `/{pid.${depth}}/`;
-        const shortId = model.getIdentifier(true);
-        const plurial = app.getModelPlural(model.getIdentifier(false));
-        // Register the model url
-        this.getWebda().getRouter().registerModelUrl(app.getModelName(model), prefix);
-        let openapi = {
-            [this.parameters.queryMethod.toLowerCase()]: {
-                tags: [name],
-                summary: `Query ${name}`,
-                operationId: `query${name}`,
-                requestBody: this.parameters.queryMethod === "GET"
-                    ? undefined
-                    : {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    properties: {
-                                        q: {
-                                            type: "string"
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    },
-                parameters: this.parameters.queryMethod === "GET"
-                    ? [
-                        {
-                            name: "q",
-                            in: "query",
-                            description: "Query to execute",
-                            schema: {
-                                type: "string"
-                            }
-                        }
-                    ]
-                    : [],
-                responses: {
-                    "200": {
-                        description: "Operation success",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    properties: {
-                                        continuationToken: {
-                                            type: "string"
-                                        },
-                                        results: {
-                                            type: "array",
-                                            items: {
-                                                $ref: `#/components/schemas/${model.getIdentifier()}`
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    "400": {
-                        description: "Query is invalid"
-                    },
-                    "403": {
-                        description: "You don't have permissions"
-                    }
-                }
-            }
-        };
-        // Add query route
-        if (!model.Expose.restrict.query) {
-            this.addRoute(`${prefix}${this.parameters.queryMethod === "GET" ? "{?q?}" : ""}`, [this.parameters.queryMethod], async (context) => {
-                let queryString = "";
-                const parentId = `pid.${depth - 1}`;
-                if (context.getHttpContext().getMethod() === "PUT") {
-                    queryString = (await context.getInput()).q ?? "";
-                    context.clearInput();
-                }
-                else {
-                    queryString = context.parameter("q", "");
-                }
-                let query;
-                try {
-                    query = new QueryValidator(queryString);
-                }
-                catch (err) {
-                    throw new WebdaError.BadRequest(`Invalid query ${queryString}`);
-                }
-                // Inject parent attribute
-                if (injectAttribute) {
-                    query.merge(`${injectAttribute} = '${context.parameter(parentId)}'`);
-                }
-                context.getParameters().query = query.toString();
-                return this._webda.callOperation(context, `${plurial}.Query`);
-            }, openapi);
-        }
-        openapi = {
-            post: {
-                tags: [name],
-                summary: `Create ${name}`,
-                operationId: `create${name}`,
-                requestBody: {
-                    content: {
-                        "application/json": {
-                            schema: {
-                                $ref: `#/components/schemas/${model.getIdentifier()}`
-                            }
-                        }
-                    }
-                },
-                responses: {
-                    "201": {
-                        description: "Operation success",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: `#/components/schemas/${model.getIdentifier()}`
-                                }
-                            }
-                        }
-                    },
-                    "400": {
-                        description: "Invalid input"
-                    },
-                    "403": {
-                        description: "You don't have permissions"
-                    },
-                    "409": {
-                        description: "Object already exists"
-                    }
-                }
-            }
-        };
-        if (!model.Expose.restrict.create) {
-            this.addRoute(`${prefix}`, ["POST"], async (context) => {
-                // Inject the parent attribute
-                if (injectAttribute) {
-                    (await context.getInput())[injectAttribute] = context.parameter(`pid.${depth - 1}`);
-                }
-                await this._webda.callOperation(context, `${shortId}.Create`);
-                // https://www.rfc-editor.org/rfc/rfc9110#status.201
-                if (context.getResponseHeaders().Location) {
-                    context.writeHead(201, {
-                        Location: `${context.getHttpContext().getAbsoluteUrl()}/${context.getResponseHeaders().Location}`
-                    });
-                }
-            }, openapi);
-        }
-        openapi = {
-            delete: {
-                tags: [name],
-                operationId: `delete${name}`,
-                description: `Delete ${name} if the permissions allow`,
-                summary: `Delete a ${name}`,
-                responses: {
-                    "204": {
-                        description: "Operation success"
-                    },
-                    "403": {
-                        description: "You don't have permissions"
-                    },
-                    "404": {
-                        description: "Unknown object"
-                    }
-                }
-            }
-        };
-        if (!model.Expose.restrict.delete) {
-            this.addRoute(`${prefix}/{uuid}`, ["DELETE"], (context) => this._webda.callOperation(context, `${shortId}.Delete`), openapi);
-        }
-        const openapiInfo = {
-            tags: [name],
-            operationId: `update${name}`,
-            description: `Update ${name} if the permissions allow`,
-            summary: `Update a ${name}`,
-            requestBody: {
-                content: {
-                    "application/json": {
-                        schema: {
-                            $ref: `#/components/schemas/${model.getIdentifier()}`
-                        }
-                    }
-                }
-            },
-            responses: {
-                "204": {
-                    description: "Operation success"
-                },
-                "400": {
-                    description: "Invalid input"
-                },
-                "403": {
-                    description: "You don't have permissions"
-                },
-                "404": {
-                    description: "Unknown object"
-                }
-            }
-        };
-        openapi = {
-            put: openapiInfo,
-            patch: openapiInfo
-        };
-        if (!model.Expose.restrict.update) {
-            this.addRoute(`${prefix}/{uuid}`, ["PUT", "PATCH"], (context) => {
-                if (context.getHttpContext().getMethod() === "PUT") {
-                    return this._webda.callOperation(context, `${shortId}.Update`);
-                }
-                else {
-                    return this._webda.callOperation(context, `${shortId}.Patch`);
-                }
-            }, openapi);
-        }
-        openapi = {
-            get: {
-                tags: [name],
-                description: `Retrieve ${name} model if permissions allow`,
-                summary: `Retrieve a ${name}`,
-                operationId: `get${name}`,
-                responses: {
-                    "200": {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: `#/components/schemas/${model.getIdentifier()}`
-                                }
-                            }
-                        }
-                    },
-                    "400": {
-                        description: "Object is invalid"
-                    },
-                    "403": {
-                        description: "You don't have permissions"
-                    },
-                    "404": {
-                        description: "Unknown object"
-                    }
-                }
-            }
-        };
-        if (!model.Expose.restrict.get) {
-            this.addRoute(`${prefix}/{uuid}`, ["GET"], (context) => this._webda.callOperation(context, `${shortId}.Get`), openapi);
-        }
-        // Add all actions
-        // Actions cannot be restricted as its purpose is to be exposed
-        const actions = model.getActions();
-        Object.keys(actions).forEach(actionName => {
-            const action = actions[actionName];
-            openapi = {
-                ...action.openapi
-            };
-            (action.methods || ["PUT"]).forEach(method => {
-                openapi[method.toLowerCase()] = {
-                    tags: [name],
-                    ...(action.openapi?.[method.toLowerCase()] ?? {})
-                };
-            });
-            if (app.hasSchema(`${model.getIdentifier(false)}.${actionName}.input`)) {
-                Object.keys(openapi)
-                    .filter(k => ["get", "post", "put", "patch", "delete"].includes(k))
-                    .forEach(k => {
-                    openapi[k].requestBody = {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: `#/components/schemas/${model.getIdentifier(false)}.${actionName}.input`
-                                }
-                            }
-                        }
-                    };
-                });
-            }
-            if (app.hasSchema(`${model.getIdentifier(false)}.${actionName}.output`)) {
-                Object.keys(openapi)
-                    .filter(k => ["get", "post", "put", "patch", "delete"].includes(k))
-                    .forEach(k => {
-                    var _a, _b;
-                    (_a = openapi[k]).responses ?? (_a.responses = {});
-                    (_b = openapi[k].responses)["200"] ?? (_b["200"] = {});
-                    openapi[k].responses["200"].content = {
-                        "application/json": {
-                            schema: {
-                                $ref: `#/components/schemas/${model.getIdentifier(false)}.${actionName}.output`
-                            }
-                        }
-                    };
-                });
-            }
-            this.addRoute(action.global ? `${prefix}/${actionName}` : `${prefix}/{uuid}/${actionName}`, action.methods || ["PUT"], async (context) => {
-                const actionOperationName = actionName.substring(0, 1).toUpperCase() + actionName.substring(1);
-                if (injectAttribute) {
-                    context.getParameters()[injectAttribute] = context.parameter(`pid.${depth - 1}`);
-                    context.getParameters()[`pid.${depth - 1}`] = undefined;
-                }
-                await this._webda.callOperation(context, `${shortId}.${actionOperationName}`);
-            }, openapi);
-        });
-        /*
-        Binaries should expose several methods
-        If cardinality is ONE
-        GET to download the binary
-        POST to upload a binary directly
-        PUT to upload a binary with challenge
-        DELETE /{hash} to delete a binary
-        PUT /{hash} to update metadata
-        GET /url to get a signed url
-    
-        If cardinality is MANY
-        GET /{index} to download the binary
-        GET /{index}/url to get a signed url
-        POST to upload a binary directly
-        PUT to upload a binary with challenge
-        DELETE /{index}/{hash} to delete a binary
-        PUT /{index}/{hash} to update metadata
-        */
-        (relations.binaries || []).forEach(binary => {
-            const modelInjector = async (context) => {
-                context.getParameters().model = model.getIdentifier();
-                context.getParameters().property = binary.attribute;
-                let action = "SetMetadata";
-                if (context.getHttpContext().getMethod() === "POST") {
-                    action = "Attach";
-                    const params = context.getParameters();
-                    params["mimetype"] = context.getHttpContext().getUniqueHeader("Content-Type", "application/octet-stream");
-                    params["name"] = context.getHttpContext().getUniqueHeader("X-Filename");
-                    params["size"] = context.getHttpContext().getUniqueHeader("Content-Length");
-                }
-                else if (context.getHttpContext().getMethod() === "DELETE") {
-                    action = "Delete";
-                }
-                const attribute = binary.attribute.substring(0, 1).toUpperCase() + binary.attribute.substring(1);
-                return this._webda.callOperation(context, `${shortId}.${attribute}.${action}`);
-            };
-            const modelInjectorChallenge = async (context) => {
-                const attribute = binary.attribute.substring(0, 1).toUpperCase() + binary.attribute.substring(1);
-                return this._webda.callOperation(context, `${shortId}.${attribute}.AttachChallenge`);
-            };
-            const modelInjectorGet = async (context) => {
-                const attribute = binary.attribute.substring(0, 1).toUpperCase() + binary.attribute.substring(1);
-                if (binary.cardinality === "MANY") {
-                    context.getParameters().index = parseInt(context.parameter("index"));
-                }
-                return this._webda.callOperation(context, `${shortId}.${attribute}.Get${context.getHttpContext().getUrl().endsWith("url") ? "Url" : ""}`);
-            };
-            openapi = {
-                put: {
-                    tags: [name],
-                    summary: `Upload ${binary.attribute} of ${name} after challenge`,
-                    description: `You will need to call the challenge method first to get a signed url to upload the content\nIf the data is already known then done is returned`,
-                    operationId: `upload${name}${binary.attribute}`,
-                    requestBody: {
-                        content: {
-                            "application/octet-stream": {
-                                schema: {
-                                    type: "object",
-                                    required: ["hash", "challenge"],
-                                    properties: {
-                                        hash: {
-                                            type: "string",
-                                            description: "md5(data)"
-                                        },
-                                        challenge: {
-                                            type: "string",
-                                            description: "md5('Webda' + data)"
-                                        },
-                                        size: {
-                                            type: "number",
-                                            description: "Size of the data"
-                                        },
-                                        name: {
-                                            type: "string",
-                                            description: "Name of the file"
-                                        },
-                                        mimetype: {
-                                            type: "string",
-                                            description: "Mimetype of the file"
-                                        },
-                                        metadata: {
-                                            type: "object",
-                                            description: "Metadata to add to the binary"
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    responses: {
-                        "200": {
-                            description: "Operation success",
-                            content: {
-                                "application/octet-stream": {
-                                    schema: {
-                                        type: "object",
-                                        properties: {
-                                            done: {
-                                                type: "boolean"
-                                            },
-                                            url: {
-                                                type: "string"
-                                            },
-                                            method: {
-                                                type: "string"
-                                            },
-                                            md5: {
-                                                type: "string",
-                                                description: "base64 md5 of the data\nThe next request requires Content-MD5 to be added with this one along with Content-Type: 'application/octet-stream'"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Unknown object"
-                        }
-                    }
-                }
-            };
-            this.addRoute(`${prefix}/{uuid}/${binary.attribute}`, ["PUT"], modelInjectorChallenge, openapi);
-            openapi = {
-                post: {
-                    tags: [name],
-                    summary: `Upload ${binary.attribute} of ${name} directly`,
-                    description: `You can upload the content directly to the server\nThis is not the recommended way as it wont be able to optimize network traffic`,
-                    operationId: `upload${name}${binary.attribute}`,
-                    requestBody: {
-                        content: {
-                            "application/octet-stream": {
-                                schema: {
-                                    type: "string",
-                                    format: "binary"
-                                }
-                            }
-                        }
-                    },
-                    responses: {
-                        "204": {
-                            description: ""
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Object does not exist or attachment does not exist"
-                        }
-                    }
-                }
-            };
-            this.addRoute(`${prefix}/{uuid}/${binary.attribute}`, ["POST"], modelInjector, openapi);
-            let rootUrl = `${prefix}/{uuid}/${binary.attribute}`;
-            if (binary.cardinality === "MANY") {
-                rootUrl += "/{index}";
-            }
-            openapi = {
-                get: {
-                    tags: [name],
-                    summary: `Download ${binary.attribute} of ${name}`,
-                    operationId: `download${name}${binary.attribute}`,
-                    responses: {
-                        "200": {
-                            description: "Operation success",
-                            content: {
-                                "application/octet-stream": {
-                                    schema: {
-                                        type: "string",
-                                        format: "binary"
-                                    }
-                                }
-                            }
-                        },
-                        "302": {
-                            description: "Redirect to the binary"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Unknown object"
-                        }
-                    }
-                }
-            };
-            this.addRoute(`${rootUrl}`, ["GET"], modelInjectorGet, openapi);
-            openapi = {
-                delete: {
-                    tags: [name],
-                    summary: `Delete ${binary.attribute} of ${name}`,
-                    responses: {
-                        "204": {
-                            description: ""
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Object does not exist or attachment does not exist"
-                        },
-                        "412": {
-                            description: "Provided hash does not match"
-                        }
-                    }
-                }
-            };
-            this.addRoute(`${rootUrl}/{hash}`, ["DELETE"], modelInjector, openapi);
-            openapi = {
-                put: {
-                    tags: [name],
-                    summary: `Update metadata of ${binary.attribute} of ${name}`,
-                    operationId: `update${name}${binary.attribute}`,
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    type: "object",
-                                    description: "Metadata to add to the binary",
-                                    additionalProperties: true
-                                }
-                            }
-                        }
-                    },
-                    responses: {
-                        "204": {
-                            description: ""
-                        },
-                        "400": {
-                            description: "Invalid input: metadata are limited to 4kb"
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Object does not exist or attachment does not exist"
-                        },
-                        "412": {
-                            description: "Provided hash does not match"
-                        }
-                    }
-                }
-            };
-            this.addRoute(`${rootUrl}/{hash}`, ["PUT"], modelInjector, openapi);
-            openapi = {
-                get: {
-                    tags: [name],
-                    summary: `Get a signed url to download ${binary.attribute} of ${name} with a limited lifetime`,
-                    responses: {
-                        "200": {
-                            description: "Operation success",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        type: "object",
-                                        properties: {
-                                            Location: {
-                                                type: "string",
-                                                description: "Signed url to download the binary"
-                                            },
-                                            Map: {
-                                                $ref: "#/components/schemas/BinaryMap"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        "403": {
-                            description: "You don't have permissions"
-                        },
-                        "404": {
-                            description: "Object does not exist or attachment does not exist"
-                        }
-                    }
-                }
-            };
-            this.addRoute(`${rootUrl}/url`, ["GET"], modelInjectorGet, openapi);
-        });
-        return true;
-    }
-    /**
-     * Serve the openapi with the swagger-ui
-     * @param ctx
-     */
-    async openapi(ctx) {
-        this.openapiContent ?? (this.openapiContent = SWAGGER_HTML.replace(/\{\{VERSION}}/g, this.parameters.swaggerVersion).replace("{{OPENAPI}}", JSON.stringify(this.getWebda().exportOpenAPI(true))));
-        ctx.write(this.openapiContent);
-    }
-}
-//# sourceMappingURL=restdomainservice.js.map