@tsed/formio 8.0.1 → 8.0.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/formio",
   "description": "Formio package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "keywords": [
     "Formio",
     "Ts.ED",
@@ -17,6 +17,7 @@
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -31,17 +32,17 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/formio-types": "8.0.1",
-    "@tsed/normalize-path": "8.0.1",
+    "@tsed/formio-types": "8.0.2",
+    "@tsed/normalize-path": "8.0.2",
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/mongoose": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/mongoose": "8.0.2",
+    "@tsed/platform-http": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "@types/async": "3.2.24",
     "eslint": "9.12.0",
     "express": "^4.21.0",
@@ -52,7 +53,7 @@
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/platform-http": "8.0.1",
+    "@tsed/platform-http": "8.0.2",
     "express": "^4.17.1",
     "formio": ">=2.0.0",
     "lodash": "^4.17.21",

package/src/FormioModule.spec.ts

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,71 @@
+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;
+  }
+}