@tsed/formio 8.11.0 → 8.11.2-rc.1

package/src/components/AlterActions.spec.ts

@@ -1,376 +0,0 @@
-import {BadRequest} from "@tsed/exceptions";
-import {FormioActionInfo, FormioComponent} from "@tsed/formio-types";
-import {PlatformContext} from "@tsed/platform-http";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {Context} from "@tsed/platform-params";
-
-import {Action} from "../decorators/action.js";
-import {ActionCtx} from "../decorators/actionCtx.js";
-import {ActionMethods} from "../domain/FormioAction.js";
-import {FormioActions} from "../domain/FormioActionsIndex.js";
-import {FormioService} from "../services/FormioService.js";
-import {AlterActions} from "./AlterActions.js";
-
-async function getActionsFixture(formio: any) {
-  const ctx = PlatformTest.createRequestContext();
-
-  ctx.getRequest().$ctx = ctx;
-
-  const alterActions = await PlatformTest.invoke<AlterActions>(AlterActions, [
-    {
-      token: FormioService,
-      use: formio
-    }
-  ]);
-  return {ctx, alterActions};
-}
-
-describe("AlterActions", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  it("should create the new actions and return response", async () => {
-    @Action({
-      name: "custom",
-      title: "My custom Action",
-      description: "Custom action description",
-      priority: 0,
-      defaults: {
-        handler: [],
-        method: []
-      }
-    })
-    class CustomAction implements ActionMethods {
-      resolve(@ActionCtx() actionCtx: ActionCtx, @Context() ctx: PlatformContext) {
-        return Promise.resolve(actionCtx);
-      }
-
-      settingsForm() {
-        return Promise.resolve([{} as any]);
-      }
-    }
-
-    const formio = {
-      Action: class Action {}
-    };
-
-    // PlatformTest.injector.forkProvider(CustomAction);
-    PlatformTest.injector.invoke(CustomAction);
-
-    const {ctx, alterActions} = await getActionsFixture(formio);
-
-    let actions: FormioActions = {} as any;
-
-    actions = alterActions.transform(actions);
-
-    const info: FormioActionInfo = await new Promise((resolve) => {
-      actions.custom.info(ctx.getRequest(), ctx.getResponse(), (err, info) => resolve(info));
-    });
-
-    const settings: FormioComponent[] = await new Promise((resolve) => {
-      actions.custom.settingsForm(ctx.getRequest(), ctx.getResponse(), (err, components) => resolve(components));
-    });
-
-    const instance = new actions.custom(info as any, ctx.getRequest(), ctx.getResponse());
-
-    new Promise((resolve) => {
-      instance.resolve(
-        "handler",
-        "method",
-        ctx.getRequest(),
-        ctx.getResponse(),
-        (err: any, result: any) => resolve(result),
-        "setActionItemMessage" as any
-      );
-    });
-
-    await new Promise((r) => setTimeout(r, 200));
-
-    expect(instance).toBeInstanceOf(formio.Action);
-    expect(info).toEqual({
-      defaults: {
-        handler: [],
-        method: []
-      },
-      description: "Custom action description",
-      name: "custom",
-      priority: 0,
-      title: "My custom Action"
-    });
-    expect(settings).toEqual([{}]);
-    expect(ctx.response.raw.data).toEqual({
-      handler: "handler",
-      method: "method",
-      setActionItemMessage: "setActionItemMessage",
-      action: {}
-    });
-  });
-  it("should create the new actions and return response with customInfo", async () => {
-    @Action({
-      name: "custom",
-      title: "My custom Action",
-      description: "Custom action description",
-      priority: 0,
-      defaults: {
-        handler: [],
-        method: []
-      }
-    })
-    class CustomAction implements ActionMethods {
-      resolve(@ActionCtx() actionCtx: ActionCtx, @Context() ctx: PlatformContext) {
-        return Promise.resolve(actionCtx);
-      }
-
-      info(opts: any) {
-        return opts;
-      }
-
-      settingsForm() {
-        return Promise.resolve([{} as any]);
-      }
-    }
-
-    const formio = {
-      Action: class Action {}
-    };
-
-    // PlatformTest.injector.forkProvider(CustomAction);
-    PlatformTest.injector.invoke(CustomAction);
-
-    const {ctx, alterActions} = await getActionsFixture(formio);
-
-    let actions: FormioActions = {} as any;
-
-    actions = alterActions.transform(actions);
-
-    const info: FormioActionInfo = await new Promise((resolve) => {
-      actions.custom.info(ctx.getRequest(), ctx.getResponse(), (err, info) => resolve(info));
-    });
-
-    const settings: FormioComponent[] = await new Promise((resolve) => {
-      actions.custom.settingsForm(ctx.getRequest(), ctx.getResponse(), (err, components) => resolve(components));
-    });
-
-    const instance = new actions.custom(info as any, ctx.getRequest(), ctx.getResponse());
-
-    new Promise((resolve) => {
-      instance.resolve(
-        "handler",
-        "method",
-        ctx.getRequest(),
-        ctx.getResponse(),
-        (err: any, result: any) => resolve(result),
-        "setActionItemMessage" as any
-      );
-    });
-
-    await new Promise((r) => setTimeout(r, 200));
-
-    expect(instance).toBeInstanceOf(formio.Action);
-    expect(info).toEqual({
-      defaults: {
-        handler: [],
-        method: []
-      },
-      description: "Custom action description",
-      name: "custom",
-      priority: 0,
-      title: "My custom Action"
-    });
-    expect(settings).toEqual([{}]);
-    expect(ctx.response.raw.data).toEqual({
-      handler: "handler",
-      method: "method",
-      setActionItemMessage: "setActionItemMessage",
-      action: {}
-    });
-  });
-  it("should create the new actions and call next", async () => {
-    @Action({
-      name: "custom",
-      title: "My custom Action",
-      description: "Custom action description",
-      priority: 0,
-      defaults: {
-        handler: [],
-        method: []
-      }
-    })
-    class CustomAction implements ActionMethods {
-      resolve(@ActionCtx() actionCtx: ActionCtx, @Context() ctx: PlatformContext) {
-        return Promise.resolve();
-      }
-
-      settingsForm() {
-        return Promise.resolve([{} as any]);
-      }
-    }
-
-    const formio = {
-      Action: class Action {}
-    };
-
-    // PlatformTest.injector.forkProvider(CustomAction);
-    PlatformTest.injector.invoke(CustomAction);
-
-    const {ctx, alterActions} = await getActionsFixture(formio);
-
-    let actions: FormioActions = {} as any;
-
-    actions = alterActions.transform(actions);
-
-    const info: FormioActionInfo = await new Promise((resolve) => {
-      actions.custom.info(ctx.getRequest(), ctx.getResponse(), (err, info) => resolve(info));
-    });
-
-    const instance = new actions.custom(info as any, ctx.getRequest(), ctx.getResponse());
-
-    const result = await new Promise((resolve) => {
-      instance.resolve(
-        "handler",
-        "method",
-        ctx.getRequest(),
-        ctx.getResponse(),
-        (err: any, result: any) => resolve(result),
-        "setActionItemMessage" as any
-      );
-    });
-    expect(result).toEqual(undefined);
-  });
-  it("should create the new actions and call next with error", async () => {
-    @Action({
-      name: "custom",
-      title: "My custom Action",
-      description: "Custom action description",
-      priority: 0,
-      defaults: {
-        handler: [],
-        method: []
-      }
-    })
-    class CustomAction implements ActionMethods {
-      resolve(@ActionCtx() actionCtx: ActionCtx, @Context() ctx: PlatformContext) {
-        return Promise.reject(new BadRequest("bad request"));
-      }
-
-      settingsForm() {
-        return Promise.resolve([{} as any]);
-      }
-    }
-
-    const formio = {
-      Action: class Action {}
-    };
-
-    // PlatformTest.injector.forkProvider(CustomAction);
-    PlatformTest.injector.invoke(CustomAction);
-
-    const {ctx, alterActions} = await getActionsFixture(formio);
-
-    let actions: FormioActions = {} as any;
-
-    actions = alterActions.transform(actions);
-
-    const info: FormioActionInfo = await new Promise((resolve) => {
-      actions.custom.info(ctx.getRequest(), ctx.getResponse(), (err, info) => resolve(info));
-    });
-
-    const instance = new actions.custom(info as any, ctx.getRequest(), ctx.getResponse());
-
-    const result: any = await new Promise((resolve) => {
-      instance.resolve(
-        "handler",
-        "method",
-        ctx.getRequest(),
-        ctx.getResponse(),
-        (err: any, result: any) => {
-          return resolve(err);
-        },
-        "setActionItemMessage" as any
-      );
-    });
-    expect(result.message).toEqual("bad request");
-  });
-  it("should create the new actions and call next (with status and headers)", async () => {
-    @Action({
-      name: "custom",
-      title: "My custom Action",
-      description: "Custom action description",
-      priority: 0,
-      defaults: {
-        handler: [],
-        method: []
-      }
-    })
-    class CustomAction implements ActionMethods {
-      resolve(@ActionCtx() actionCtx: ActionCtx, @Context() ctx: PlatformContext) {
-        return Promise.resolve({
-          statusText: "Created",
-          status: 201,
-          headers: {
-            "x-header": "test"
-          },
-          data: {
-            hello: "world"
-          }
-        });
-      }
-
-      settingsForm() {
-        return Promise.resolve([{} as any]);
-      }
-    }
-
-    const formio = {
-      Action: class Action {}
-    };
-
-    // PlatformTest.injector.forkProvider(CustomAction);
-    PlatformTest.injector.invoke(CustomAction);
-
-    const {ctx, alterActions} = await getActionsFixture(formio);
-
-    let actions: FormioActions = {} as any;
-
-    actions = alterActions.transform(actions);
-
-    const info: FormioActionInfo = await new Promise((resolve) => {
-      actions.custom.info(ctx.getRequest(), ctx.getResponse(), (err, info) => resolve(info));
-    });
-
-    const settings: FormioComponent[] = await new Promise((resolve) => {
-      actions.custom.settingsForm(ctx.getRequest(), ctx.getResponse(), (err, components) => resolve(components));
-    });
-
-    const instance = new actions.custom(info as any, ctx.getRequest(), ctx.getResponse());
-
-    new Promise((resolve) => {
-      instance.resolve(
-        "handler",
-        "method",
-        ctx.getRequest(),
-        ctx.getResponse(),
-        (err: any, result: any) => resolve(result),
-        "setActionItemMessage" as any
-      );
-    });
-
-    await new Promise((r) => setTimeout(r, 200));
-
-    expect(instance).toBeInstanceOf(formio.Action);
-    expect(info).toEqual({
-      defaults: {
-        handler: [],
-        method: []
-      },
-      description: "Custom action description",
-      name: "custom",
-      priority: 0,
-      title: "My custom Action"
-    });
-    expect(settings).toEqual([{}]);
-    expect(ctx.response.raw.data).toEqual({
-      hello: "world"
-    });
-  });
-});

package/src/components/AlterActions.ts

@@ -1,136 +0,0 @@
-import {AnyToPromise, AnyToPromiseStatus} from "@tsed/core";
-import {Inject, InjectorService, Provider} from "@tsed/di";
-import {FormioActionInfo} from "@tsed/formio-types";
-import {PlatformContext, setResponseHeaders} from "@tsed/platform-http";
-import {PlatformParams} from "@tsed/platform-params";
-import {PlatformResponseFilter} from "@tsed/platform-response-filter";
-import {EndpointMetadata} from "@tsed/schema";
-
-import {Alter} from "../decorators/alter.js";
-import {AlterHook} from "../domain/AlterHook.js";
-import {SetActionItemMessage} from "../domain/FormioAction.js";
-import {FormioActions} from "../domain/FormioActionsIndex.js";
-import {FormioService} from "../services/FormioService.js";
-
-@Alter("actions")
-export class AlterActions implements AlterHook {
-  @Inject()
-  protected injector: InjectorService;
-
-  @Inject()
-  protected formio: FormioService;
-
-  @Inject()
-  protected params: PlatformParams;
-
-  @Inject()
-  protected responseFilter: PlatformResponseFilter;
-
-  transform(actions: FormioActions): FormioActions {
-    const {Action} = this.formio;
-
-    return this.getActions().reduce((actions, provider) => {
-      const instance = this.injector.invoke<any>(provider.token);
-      const options = provider.store.get<FormioActionInfo>("formio:action");
-      const resolveHandler = this.createHandler(provider, "resolve");
-
-      return {
-        ...actions,
-        [options.name]: class extends Action {
-          static access = options.access;
-
-          static async info(req: any, res: any, next: Function) {
-            let opts = {...options};
-
-            if (instance.info) {
-              opts = await instance.info(opts, req, res);
-            }
-
-            next(null, opts);
-          }
-
-          static async settingsForm(req: any, res: any, next: Function) {
-            next(null, await instance.settingsForm(req, res));
-          }
-
-          resolve(handler: string, method: string, req: any, res: any, next: Function, setActionItemMessage: SetActionItemMessage): void {
-            resolveHandler(this, handler, method, req, res, next, setActionItemMessage);
-          }
-        }
-      };
-    }, actions);
-  }
-
-  protected getActions() {
-    return this.injector.getProviders("formio:action");
-  }
-
-  protected createHandler(provider: Provider, propertyKey: string | symbol) {
-    const compiledHandler = this.params.compileHandler({
-      token: provider.token,
-      propertyKey
-    });
-
-    return async (
-      action: any,
-      handler: string,
-      method: string,
-      req: any,
-      res: any,
-      next: any,
-      setActionItemMessage: SetActionItemMessage
-    ) => {
-      const {$ctx} = req;
-
-      if ($ctx) {
-        $ctx.set("ACTION_CTX", {handler, method, setActionItemMessage, action});
-        $ctx.endpoint = EndpointMetadata.get(provider.useClass, "resolve");
-
-        try {
-          if (await this.onRequest(compiledHandler, $ctx)) {
-            next();
-          }
-        } catch (er) {
-          next(er);
-        }
-      }
-    };
-  }
-
-  private async onRequest(handler: any, $ctx: PlatformContext) {
-    const resolver = new AnyToPromise();
-    const {state, data, status, headers} = await resolver.call(() => handler({$ctx}));
-
-    if (state === AnyToPromiseStatus.RESOLVED) {
-      if (status) {
-        $ctx.response.status(status);
-      }
-
-      if (headers) {
-        $ctx.response.setHeaders(headers);
-      }
-
-      if (data !== undefined) {
-        $ctx.data = data;
-
-        return this.flush($ctx.data, $ctx);
-      }
-
-      return true;
-    }
-  }
-
-  private async flush(data: any, $ctx: PlatformContext) {
-    const {response} = $ctx;
-
-    if (!$ctx.isDone()) {
-      setResponseHeaders($ctx);
-
-      data = await this.responseFilter.transform(data, $ctx as any);
-
-      response.body(data);
-    }
-
-    return response;
-  }
-}

package/src/components/AlterAudit.spec.ts

@@ -1,19 +0,0 @@
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {AlterAudit} from "./AlterAudit.js";
-
-describe("AlterAudit", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  it("should log data", async () => {
-    const ctx = PlatformTest.createRequestContext();
-
-    vi.spyOn(ctx.logger, "info");
-
-    const alterAudit = await PlatformTest.invoke<AlterAudit>(AlterAudit);
-
-    alterAudit.transform(["data"], "event", ctx);
-    expect(ctx.logger.info).toHaveBeenCalledWith({event: "event", info: ["data"]});
-  });
-});

package/src/components/AlterAudit.ts

@@ -1,12 +0,0 @@
-import {DIContext} from "@tsed/di";
-
-import {Alter} from "../decorators/alter.js";
-import {AlterHook} from "../domain/AlterHook.js";
-
-@Alter("audit")
-export class AlterAudit implements AlterHook {
-  transform(info: any[], event: string, ctx: DIContext): boolean {
-    ctx.logger.info({event, info});
-    return false;
-  }
-}

package/src/components/AlterHost.spec.ts

@@ -1,20 +0,0 @@
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {AlterHost} from "./AlterHost.js";
-
-describe("AlterHost", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  it("should transform host", async () => {
-    const ctx = PlatformTest.createRequestContext();
-    ctx.request.raw.headers["host"] = "host";
-    ctx.getRequest().protocol = "https";
-
-    const alterHost = await PlatformTest.invoke<AlterHost>(AlterHost);
-
-    const url = alterHost.transform("/projects", ctx);
-
-    expect(url).toEqual("https://host/projects");
-  });
-});

package/src/components/AlterHost.ts

@@ -1,11 +0,0 @@
-import {PlatformContext} from "@tsed/platform-http";
-
-import {Alter} from "../decorators/alter.js";
-import {AlterHook} from "../domain/AlterHook.js";
-
-@Alter("host")
-export class AlterHost implements AlterHook<string> {
-  transform(baseUrl: string, ctx: PlatformContext) {
-    return `${ctx.request.protocol}://${ctx.request.host}${baseUrl}`;
-  }
-}

package/src/components/AlterLog.spec.ts

@@ -1,19 +0,0 @@
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {AlterLog} from "./AlterLog.js";
-
-describe("AlterLog", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  it("should log data", async () => {
-    const ctx = PlatformTest.createRequestContext();
-
-    vi.spyOn(ctx.logger, "debug");
-
-    const alterLog = await PlatformTest.invoke<AlterLog>(AlterLog);
-
-    alterLog.transform("event", ctx, "data");
-    expect(ctx.logger.debug).toHaveBeenCalledWith({event: "event", info: ["data"]});
-  });
-});

package/src/components/AlterLog.ts

@@ -1,12 +0,0 @@
-import {PlatformContext} from "@tsed/platform-http";
-
-import {Alter} from "../decorators/alter.js";
-import {AlterHook} from "../domain/AlterHook.js";
-
-@Alter("log")
-export class AlterLog implements AlterHook {
-  transform(event: string, ctx: PlatformContext, ...info: any[]): boolean {
-    ctx.logger.debug({event, info});
-    return false;
-  }
-}

package/src/components/AlterSkip.spec.ts

@@ -1,44 +0,0 @@
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {AlterSkip} from "./AlterSkip.js";
-
-describe("AlterSkip", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  it("should transform skip", async () => {
-    const ctx = PlatformTest.createRequestContext();
-
-    const alterSkip = await PlatformTest.invoke<AlterSkip>(AlterSkip);
-
-    ctx.getRequest().originalUrl = "/spec.json";
-
-    const result = alterSkip.transform(false, ctx);
-
-    expect(result).toEqual(true);
-  });
-
-  it("should transform skip and return false", async () => {
-    const ctx = PlatformTest.createRequestContext();
-
-    const alterSkip = await PlatformTest.invoke<AlterSkip>(AlterSkip);
-
-    ctx.getRequest().originalUrl = "/other";
-
-    const result = alterSkip.transform(false, ctx);
-
-    expect(result).toEqual(false);
-  });
-
-  it("should not transform skip", async () => {
-    const ctx = PlatformTest.createRequestContext();
-
-    const alterSkip = await PlatformTest.invoke<AlterSkip>(AlterSkip);
-
-    ctx.getRequest().originalUrl = "/other";
-
-    const result = alterSkip.transform(true, ctx);
-
-    expect(result).toEqual(true);
-  });
-});

package/src/components/AlterSkip.ts

@@ -1,28 +0,0 @@
-import {Constant} from "@tsed/di";
-import {normalizePath} from "@tsed/normalize-path";
-import {PlatformContext} from "@tsed/platform-http";
-
-import {Alter} from "../decorators/alter.js";
-import {AlterHook} from "../domain/AlterHook.js";
-
-@Alter("skip")
-export class AlterSkip implements AlterHook {
-  @Constant("formio.baseUrl", "/")
-  baseUrl: string;
-
-  @Constant("formio.whiteList", ["/spec.json"])
-  whiteList: string[];
-
-  transform(value: any, ctx: PlatformContext): any {
-    if (value) {
-      return true;
-    }
-
-    const {request} = ctx;
-    const url = request.url.split("?")[0];
-
-    return !!this.whiteList.find((entry) => {
-      return normalizePath(this.baseUrl, entry) === url;
-    });
-  }
-}