feat: add action input validation and openapi definition

packages/async/src/models.ts

@@ -1,4 +1,4 @@
-import { Action, CoreModel, OperationContext, WebContext, WebdaError } from "@webda/core";
+import { Action, Core, CoreModel, OperationContext, WebContext, WebdaError } from "@webda/core";
 import { WorkerLogLevel } from "@webda/workout";
 import * as crypto from "crypto";
 
@@ -125,6 +125,14 @@ export default class AsyncAction extends CoreModel {
     context.write({ ...this, logs: undefined, statusDetails: undefined });
   }
 
+  /**
+   * Return the hook url if empty fallback to the service url
+   * @returns
+   */
+  public getHookUrl(): string {
+    return Core.get().getRouter().getModelUrl(this);
+  }
+
   /**
    *
    * @param body

packages/async/src/services/asyncjobservice.ts

@@ -370,7 +370,9 @@ export default class AsyncJobService<T extends AsyncJobServiceParameters = Async
       JOB_SECRET_KEY: action.__secretKey,
       JOB_ID: action.getUuid(),
       JOB_HOOK:
-        this.parameters.onlyHttpHook || !action.isInternal() ? this.getWebda().getApiUrl(this.parameters.url) : "store", // How to find the absolute url
+        this.parameters.onlyHttpHook || !action.isInternal()
+          ? action.getHookUrl() || this.getWebda().getApiUrl(this.parameters.url)
+          : "store", // How to find the absolute url
       JOB_ORCHESTRATOR: this.getName()
     };
   }

packages/core/src/application.ts

@@ -629,6 +629,14 @@ export class Application {
     return this.baseConfiguration.cachedModules.schemas[type];
   }
 
+  /**
+   * Get schemas
+   * @returns
+   */
+  getSchemas(): { [key: string]: JSONSchema7 } {
+    return this.baseConfiguration.cachedModules.schemas;
+  }
+
   /**
    * Check if a schema exists
    * @param type

packages/core/src/core.ts

@@ -1513,6 +1513,21 @@ export class Core<E extends CoreEvents = CoreEvents> extends events.EventEmitter
       this.application.getConfiguration().openapi || {}
     );
     let models = this.application.getModels();
+    const schemas = this.application.getSchemas();
+    // Copy all input/output from actions
+    for (let i in schemas) {
+      if (!(i.endsWith(".input") || i.endsWith(".output"))) {
+        continue;
+      }
+      // @ts-ignore
+      openapi.components.schemas[i] ??= schemas[i];
+      // Not sure how to test following
+      /* c8 ignore next 3 */
+      for (let j in schemas[i].definitions) {
+        // @ts-ignore
+        openapi.components.schemas[j] ??= schemas[i].definitions[j];
+      }
+    }
     for (let i in models) {
       let model = models[i];
       let desc: JSONSchema7 = {

packages/core/src/models/aclmodel.ts

@@ -1,4 +1,4 @@
-import { ModelAction, OperationContext, Store, User, WebContext, WebdaError } from "../index";
+import { OperationContext, User, WebContext, WebdaError } from "../index";
 import { Action, CoreModel } from "./coremodel";
 
 export type Acl = { [key: string]: string };
@@ -66,7 +66,61 @@ export default class AclModel extends CoreModel {
    * @param ctx
    * @returns
    */
-  @Action({ methods: ["GET", "PUT"] })
+  @Action({
+    methods: ["GET", "PUT"],
+    openapi: {
+      get: {
+        summary: "Get ACLs",
+        responses: {
+          "200": {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    raw: {
+                      type: "object"
+                    },
+                    resolved: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          permission: {
+                            type: "string"
+                          },
+                          actor: {
+                            type: "object"
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      put: {
+        summary: "Update ACLs",
+        requestBody: {
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  raw: {
+                    type: "object"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
   async acl(ctx: WebContext) {
     if (ctx.getHttpContext().getMethod() === "PUT") {
       return this._httpPutAcls(ctx);

packages/core/src/router.spec.ts

@@ -1,5 +1,6 @@
 import { suite, test } from "@testdeck/mocha";
 import * as assert from "assert";
+import { User } from "./models/user";
 import { RouteInfo } from "./router";
 import { WebdaTest } from "./test";
 import { HttpContext } from "./utils/httpcontext";
@@ -197,4 +198,12 @@ class RouterTest extends WebdaTest {
     this.webda.getRouter().removeRoute("/cov", info);
     this.webda.getRouter().getRoutes();
   }
+
+  @test
+  getModelUrl() {
+    let routes = this.webda.getRouter().getRoutes();
+    console.log(routes["/memory/users{?q}"][0].openapi);
+    let url = this.webda.getRouter().getModelUrl(new User());
+    console.log(url);
+  }
 }

packages/core/src/router.ts

@@ -2,6 +2,7 @@ import { JSONSchema7 } from "json-schema";
 import { OpenAPIV3 } from "openapi-types";
 import uriTemplates from "uri-templates";
 import { Core } from "./core";
+import { CoreModel, CoreModelDefinition } from "./models/coremodel";
 import { WebContext } from "./utils/context";
 import { HttpMethodType } from "./utils/httpcontext";
 
@@ -44,6 +45,7 @@ export interface OpenAPIWebdaDefinition extends RecursivePartial<OpenAPIV3.PathI
  * Route Information default information
  */
 export interface RouteInfo {
+  model?: CoreModelDefinition;
   /**
    * HTTP Method to expose
    */
@@ -91,11 +93,33 @@ export class Router {
   protected initiated: boolean = false;
   protected pathMap: { url: string; config: RouteInfo }[];
   protected webda: Core;
+  protected models: Map<string, string> = new Map();
 
   constructor(webda: Core) {
     this.webda = webda;
   }
 
+  /**
+   * Registration of a model
+   * @param model
+   * @param url
+   */
+  registerModelUrl(model: string, url: string) {
+    this.models.set(model, url);
+  }
+
+  /**
+   * Return the route for model
+   * @param model
+   * @returns
+   */
+  getModelUrl(model: string | CoreModel) {
+    if (typeof model !== "string") {
+      model = this.webda.getApplication().getModelName(model);
+    }
+    return this.models.get(model);
+  }
+
   /**
    * Include prefix to the url if not present
    * @param url

packages/core/src/services/binary.ts

@@ -79,6 +79,7 @@ export type BinaryFiles = BinaryFileInfo[];
 
 /**
  * Represent a file to store
+ * @WebdaSchema
  */
 export abstract class BinaryFile<T = any> implements BinaryFileInfo {
   /**

packages/core/src/services/domainservice.spec.ts

@@ -160,22 +160,35 @@ class DomainServiceTest extends WebdaTest {
       },
       context
     });
+    await assert.rejects(
+      () =>
+        this.http({
+          method: "PUT",
+          url: `/classrooms/${result.results[0].uuid}/test`,
+          body: {
+            q: ""
+          },
+          context
+        }),
+      WebdaError.BadRequest
+    );
     await this.http({
       method: "PUT",
       url: `/classrooms/${result.results[0].uuid}/test`,
       body: {
-        q: ""
+        test: "123",
+        id: "123"
       },
       context
-    });
-    await this.http({
-      method: "PUT",
-      url: `/classrooms/${result.results[0].uuid}/hardwares/globalAction`,
-      body: {
-        q: ""
-      },
-      context
-    });
+    }),
+      await this.http({
+        method: "PUT",
+        url: `/classrooms/${result.results[0].uuid}/hardwares/globalAction`,
+        body: {
+          q: ""
+        },
+        context
+      });
     await this.http({
       method: "PUT",
       url: `/hardwares/globalAction`,