@tsed/formio 8.11.1 → 8.12.0-rc.1

package/src/FormioModule.spec.ts

@@ -1,113 +0,0 @@
-import {faker} from "@faker-js/faker";
-import {PlatformApplication, PlatformRouteDetails} from "@tsed/platform-http";
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {FormioModule} from "./FormioModule.js";
-import {FormioInstaller} from "./services/FormioInstaller.js";
-import {FormioService} from "./services/FormioService.js";
-
-async function createFormioModuleFixture() {
-  const formio = {
-    swagger: vi.fn(),
-    router: vi.fn(),
-    middleware: {
-      restrictRequestTypes: vi.fn()
-    },
-    isInit: vi.fn().mockReturnValue(true),
-    init: vi.fn()
-  };
-
-  const installer = {
-    hasForms: vi.fn().mockReturnValue(false),
-    install: vi.fn()
-  };
-
-  const app = {
-    use: vi.fn(),
-    getRouter: vi.fn().mockReturnThis()
-  };
-
-  const service = await PlatformTest.invoke<FormioModule>(FormioModule, [
-    {
-      token: FormioInstaller,
-      use: installer
-    },
-    {
-      token: FormioService,
-      use: formio
-    },
-    {
-      token: PlatformApplication,
-      use: app
-    }
-  ]);
-
-  return {service, app, installer, formio};
-}
-
-describe("FormioModule", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  describe("$onRoutesInit()", () => {
-    it("should run install template", async () => {
-      const {service, app, installer, formio} = await createFormioModuleFixture();
-
-      const template = {
-        forms: {}
-      };
-      const root = {
-        email: faker.internet.email()
-      };
-
-      PlatformTest.injector.settings.set("formio.template", template);
-      PlatformTest.injector.settings.set("formio.root", root);
-
-      installer.install.mockResolvedValue((service as any).template);
-
-      await service.$onRoutesInit();
-
-      expect(app.use).toHaveBeenCalledWith("/", formio.middleware.restrictRequestTypes, formio.router);
-      expect(installer.install).toHaveBeenCalledWith(template, root);
-    });
-    it("should skip install", async () => {
-      const {service, installer} = await createFormioModuleFixture();
-      PlatformTest.injector.settings.set("formio.template", {});
-
-      await service.$onRoutesInit();
-
-      expect(installer.install).toHaveBeenCalled();
-    });
-  });
-  describe("$logRoutes()", () => {
-    it("should add formio routes", async () => {
-      const {service, formio} = await createFormioModuleFixture();
-      const routes: PlatformRouteDetails[] = [];
-
-      PlatformTest.injector.settings.set("formio.baseUrl", "/projects");
-      PlatformTest.injector.settings.set("formio.root");
-
-      formio.swagger.mockReturnValue({
-        paths: {
-          "/path/to": {
-            get: {
-              operationId: "operationId"
-            }
-          }
-        }
-      });
-
-      const results = await service.$logRoutes(routes);
-
-      expect(results).toEqual([
-        {
-          className: "formio",
-          method: "get",
-          methodClassName: "operationId",
-          name: "operationId",
-          url: "/projects/path/to"
-        }
-      ]);
-    });
-  });
-});

package/src/FormioModule.ts

@@ -1,130 +0,0 @@
-import {deepClone} from "@tsed/core";
-import {Constant, Inject, InjectorService, Module} from "@tsed/di";
-import {normalizePath} from "@tsed/normalize-path";
-import {OnReady, OnRoutesInit, PlatformApplication, PlatformRouteDetails} from "@tsed/platform-http";
-
-import {AlterActions} from "./components/AlterActions.js";
-import {AlterAudit} from "./components/AlterAudit.js";
-import {AlterHost} from "./components/AlterHost.js";
-import {AlterLog} from "./components/AlterLog.js";
-import {AlterSkip} from "./components/AlterSkip.js";
-import {AlterTemplateExportSteps} from "./components/AlterTemplateExportSteps.js";
-import {AlterTemplateImportSteps} from "./components/AlterTemplateImportSteps.js";
-import {FormioConfig} from "./domain/FormioConfig.js";
-import {FormioTemplate} from "./domain/FormioTemplate.js";
-import {FormioAuthService} from "./services/FormioAuthService.js";
-import {FormioHooksService} from "./services/FormioHooksService.js";
-import {FormioInstaller} from "./services/FormioInstaller.js";
-import {FormioService} from "./services/FormioService.js";
-
-@Module({
-  imports: [
-    FormioService,
-    FormioHooksService,
-    FormioAuthService,
-    AlterActions,
-    AlterHost,
-    AlterAudit,
-    AlterLog,
-    AlterSkip,
-    AlterTemplateImportSteps,
-    AlterTemplateExportSteps
-  ]
-})
-export class FormioModule implements OnRoutesInit, OnReady {
-  @Inject()
-  protected formio: FormioService;
-
-  @Inject()
-  protected hooks: FormioHooksService;
-
-  @Inject()
-  protected installer: FormioInstaller;
-
-  @Inject()
-  protected app: PlatformApplication;
-
-  @Inject()
-  protected injector: InjectorService;
-
-  @Constant("formio", {})
-  protected settings: FormioConfig;
-
-  @Constant("formio.baseUrl", "/")
-  protected baseUrl: string;
-
-  @Constant("formio.skipInstall", false)
-  protected skipInstall: boolean;
-
-  @Constant("formio.template")
-  protected template?: FormioTemplate;
-
-  @Constant("formio.root")
-  protected root?: any;
-
-  $onInit() {
-    return this.init(deepClone(this.settings));
-  }
-
-  init(options: FormioConfig) {
-    return this.formio.init(options, this.hooks.getHooks());
-  }
-
-  async $onRoutesInit() {
-    if (this.formio.isInit()) {
-      this.app.use(this.baseUrl, this.formio.middleware.restrictRequestTypes, this.formio.router);
-
-      if (await this.shouldInstall()) {
-        await this.installer.install(this.template!, this.root);
-      }
-    }
-  }
-
-  async $logRoutes(routes: PlatformRouteDetails[]): Promise<PlatformRouteDetails[]> {
-    if (this.formio.isInit()) {
-      const spec = (await this.formio.swagger(
-        {
-          $ctx: {
-            request: {
-              protocol: "http",
-              host: "localhost"
-            }
-          }
-        },
-        this.formio.router
-      )) as any;
-      const {baseUrl} = this;
-
-      Object.entries(spec.paths).forEach(([path, methods]: [string, any]) => {
-        Object.entries(methods).forEach(([method, operation]: [string, any]) => {
-          routes.push({
-            method,
-            name: operation.operationId,
-            url: normalizePath(baseUrl, path.replace(/\/{(.*)}/gi, "/:$1")),
-            className: "formio",
-            methodClassName: operation.operationId
-          });
-        });
-      });
-    }
-
-    return routes;
-  }
-
-  // istanbul ignore next
-  $onReady() {
-    if (this.formio.isInit() && "getBestHost" in this.injector.settings) {
-      const {injector} = this;
-      // @ts-ignore
-      const host = injector.settings.getBestHost();
-      const url = host.toString();
-
-      injector.logger.info(`Form.io API is available on ${url}${this.baseUrl || "/"}`);
-    }
-  }
-
-  protected async shouldInstall() {
-    const hasForms = await this.installer.hasForms();
-    return this.template && !(hasForms || this.skipInstall);
-  }
-}

package/src/builder/FormioMapper.spec.ts

@@ -1,93 +0,0 @@
-import {toMap as tMap} from "@tsed/core";
-import {MongooseDocument} from "@tsed/mongoose";
-
-import {FormioMapper} from "./FormioMapper.js";
-
-function toMap<T>(list: any[]) {
-  return tMap<string, MongooseDocument<T>>(list, (o: any) => [o._id.toString(), `$machineName:${o.machineName}`]);
-}
-
-describe("FormioMapper", () => {
-  it("should map data to import (obj)", () => {
-    const mapper = new FormioMapper({
-      forms: toMap([{_id: "form_id", machineName: "form_machine"}]),
-      actions: toMap([{_id: "action_id", machineName: "action_machine"}]),
-      roles: toMap([{_id: "role_id", machineName: "role_machine"}])
-    });
-    const data = {
-      form: "form_machine",
-      value: 0,
-      notAnId: "id",
-      date: new Date()
-    };
-
-    const result = mapper.mapToImport(data);
-
-    expect(result).toEqual({
-      ...data,
-      form: "form_id"
-    });
-  });
-  it("should map data to import (array)", () => {
-    const mapper = new FormioMapper({
-      forms: toMap([{_id: "form_id", machineName: "form_machine"}]),
-      actions: toMap([{_id: "action_id", machineName: "action_machine"}]),
-      roles: toMap([{_id: "role_id", machineName: "role_machine"}])
-    });
-    const data = {
-      form: "form_machine",
-      value: 0,
-      notAnId: "id",
-      date: new Date()
-    };
-    const result = mapper.mapToImport([data]);
-
-    expect(result).toEqual([
-      {
-        ...data,
-        form: "form_id"
-      }
-    ]);
-  });
-  it("should map data to export (obj)", () => {
-    const mapper = new FormioMapper({
-      forms: toMap([{_id: "form_id", machineName: "form_machine"}]),
-      actions: toMap([{_id: "action_id", machineName: "action_machine"}]),
-      roles: toMap([{_id: "role_id", machineName: "role_machine"}])
-    });
-    const data = {
-      form: "form_id",
-      value: 0,
-      notAnId: "id",
-      date: new Date()
-    };
-
-    const result = mapper.mapToExport(data);
-
-    expect(result).toEqual({
-      ...data,
-      form: "$machineName:form_machine"
-    });
-  });
-  it("should map data to export (array)", () => {
-    const mapper = new FormioMapper({
-      forms: toMap([{_id: "form_id", machineName: "form_machine"}]),
-      actions: toMap([{_id: "action_id", machineName: "action_machine"}]),
-      roles: toMap([{_id: "role_id", machineName: "role_machine"}])
-    });
-    const data = {
-      form: "form_id",
-      value: 0,
-      notAnId: "id",
-      date: new Date()
-    };
-    const result = mapper.mapToExport([data]);
-
-    expect(result).toEqual([
-      {
-        ...data,
-        form: "$machineName:form_machine"
-      }
-    ]);
-  });
-});

package/src/builder/FormioMapper.ts

@@ -1,71 +0,0 @@
-import {FormioCtxMapper} from "../domain/FormioCtxMapper.js";
-
-export class FormioMapper {
-  constructor(readonly ctxData: FormioCtxMapper) {}
-
-  find(key: string) {
-    const store = Object.values(this.ctxData).find((store) => store.get(key));
-
-    return store?.get(key);
-  }
-
-  findId(data: string) {
-    const key = String(data).startsWith("$machineName:") ? String(data) : `$machineName:${String(data)}`;
-    const item = this.find(key);
-
-    return item ? item._id : undefined;
-  }
-
-  findMachineName(data: any) {
-    const key = String(data);
-    const item: any = this.find(key);
-
-    return item ? `$machineName:${item.name || item.machineName}` : undefined;
-  }
-
-  mapToExport(data: any) {
-    return this.mapData(data, this.findMachineName.bind(this));
-  }
-
-  mapToImport(data: any) {
-    return this.mapData(data, this.findId.bind(this));
-  }
-
-  mapData(data: any, resolver: any): any {
-    if (!data) {
-      return data;
-    }
-
-    if (Array.isArray(data)) {
-      return data.map((item) => {
-        return this.mapData(item, resolver);
-      });
-    }
-
-    const key = resolver(data, this.ctxData);
-
-    if (key) {
-      return key;
-    }
-
-    if (typeof data === "object" && !("_bsontype" in data) && !(data instanceof Date)) {
-      const isForm = data.path && data.type;
-      const mapped = Object.entries(data).reduce((obj, [key, value]) => {
-        return {
-          ...obj,
-          [key]: this.mapData(value, resolver)
-        };
-      }, {});
-
-      return isForm
-        ? {
-            ...mapped,
-            name: data.name,
-            machineName: data.machineName || data.name
-          }
-        : mapped;
-    }
-
-    return data;
-  }
-}