@tsed/formio 8.0.1 → 8.0.2

package/src/services/FormioHooksService.ts

@@ -0,0 +1,91 @@
+import {Inject, Injectable, InjectorService} from "@tsed/di";
+import {Request} from "express";
+import {promisify} from "util";
+
+import {FormioHooks} from "../domain/FormioHooks.js";
+import {FormioService} from "./FormioService.js";
+
+@Injectable()
+export class FormioHooksService {
+  @Inject()
+  protected injector: InjectorService;
+
+  @Inject(FormioService)
+  protected formio: FormioService;
+
+  get settings(): (req: Request, cb: Function) => void {
+    return this.formio.hook.settings;
+  }
+
+  get invoke() {
+    return this.formio.hook.invoke;
+  }
+
+  get alter(): (event: string, ...args: any[]) => any {
+    return this.formio.hook.alter;
+  }
+
+  get alterAsync(): (event: string, ...args: any[]) => Promise<any> {
+    return promisify(this.alter);
+  }
+
+  getHooks(): FormioHooks {
+    return {
+      alter: this.getHooksProvider("alter"),
+      on: this.getHooksProvider("on")
+    };
+  }
+
+  protected getProviders(type: "alter" | "on") {
+    return this.injector.getProviders(`formio:${type}`);
+  }
+
+  protected getHooksProvider(type: "alter" | "on") {
+    return this.bindHooks(type, this.createHooks(type));
+  }
+
+  protected bindHooks(type: "alter" | "on", hooks: Record<string, Function[]>) {
+    return Object.entries(hooks).reduce((newHooks, [key, pool]) => {
+      const wrap = (input: any, ...args: any[]): any => {
+        let last: any;
+
+        for (const fn of pool) {
+          const result = fn(input, ...args);
+
+          if (type === "alter") {
+            input = result;
+          } else {
+            last = result;
+          }
+        }
+
+        return type === "alter" ? input : last;
+      };
+
+      return {
+        ...newHooks,
+        [key]: wrap
+      };
+    }, {});
+  }
+
+  private createHooks(type: "alter" | "on") {
+    return this.getProviders(type).reduce<Record<string, Function[]>>((hooks, provider) => {
+      const instance = this.injector.invoke<any>(provider.token);
+      const name = provider.store.get(`formio:${type}:name`);
+      const pool: Function[] = hooks[name] || [];
+
+      const hook = (...args: any[]) =>
+        instance[type === "alter" ? "transform" : "on"](
+          ...args.map((input: any) => {
+            return input && input.$ctx ? input.$ctx : input;
+          })
+        );
+
+      return {
+        ...hooks,
+        [name]: ([] as Function[]).concat(pool, hook)
+      };
+    }, {});
+  }
+}

package/src/services/FormioInstaller.spec.ts

@@ -0,0 +1,146 @@
+import {faker} from "@faker-js/faker";
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {FormioInstaller} from "./FormioInstaller.js";
+import {FormioService} from "./FormioService.js";
+
+async function createFormioInstallerFixture(options: any = {}) {
+  const {
+    count = 1,
+    errorCount = null,
+    submission = {
+      _id: "id",
+      data: {}
+    },
+    errorSubmission = null
+  } = options;
+
+  const collections = {
+    estimatedDocumentCount: vi.fn().mockImplementation((cb) => {
+      cb(errorCount, count);
+    })
+  };
+  const formioService = {
+    db: {
+      collection: vi.fn().mockReturnValue(collections)
+    },
+    formio: {},
+    encrypt: vi.fn().mockResolvedValue("hash"),
+    resources: {
+      submission: {
+        model: {
+          create: vi.fn().mockImplementation((_, cb) => {
+            cb(errorSubmission, submission);
+          })
+        }
+      }
+    },
+    importTemplate: vi.fn().mockImplementation((o) => o)
+  };
+  const service = await PlatformTest.invoke<FormioInstaller>(FormioInstaller, [
+    {
+      token: FormioService,
+      use: formioService
+    }
+  ]);
+
+  return {service, formioService, collections};
+}
+
+describe("FormioImporter", () => {
+  beforeEach(PlatformTest.create);
+  afterEach(PlatformTest.reset);
+
+  describe("createRootUser()", () => {
+    it("should create the user root", async () => {
+      const {service, formioService} = await createFormioInstallerFixture({count: 1});
+      const template = {
+        resources: {
+          admin: {
+            _id: faker.string.uuid()
+          }
+        },
+        roles: {
+          administrator: {
+            _id: faker.string.uuid()
+          }
+        }
+      };
+
+      const user = {
+        email: faker.internet.email(),
+        password: faker.internet.password({length: 12})
+      };
+
+      expect(await service.createRootUser(user, template as any)).toEqual({
+        _id: "id",
+        data: {}
+      });
+      expect(formioService.resources.submission.model.create).toHaveBeenCalledWith(
+        {
+          data: {email: user.email, password: "hash"},
+          form: template.resources.admin._id,
+          roles: [template.roles.administrator._id]
+        },
+        expect.any(Function)
+      );
+    });
+    it("should throw error", async () => {
+      const {service} = await createFormioInstallerFixture({errorSubmission: new Error("message")});
+      const template = {
+        resources: {
+          admin: {
+            _id: faker.string.uuid()
+          }
+        },
+        roles: {
+          administrator: {
+            _id: faker.string.uuid()
+          }
+        }
+      };
+
+      const user = {
+        email: faker.internet.email(),
+        password: faker.internet.password({length: 12})
+      };
+
+      let actualError: any;
+      try {
+        await service.createRootUser(user, template as any);
+      } catch (er) {
+        actualError = er;
+      }
+      expect(actualError.message).toEqual("message");
+    });
+  });
+  describe("install()", () => {
+    it("should install database", async () => {
+      const {service, formioService} = await createFormioInstallerFixture({count: 1});
+      const template = {
+        resources: {
+          admin: {
+            _id: faker.string.uuid()
+          }
+        },
+        roles: {
+          administrator: {
+            _id: faker.string.uuid()
+          }
+        }
+      };
+
+      const user = {
+        email: faker.internet.email(),
+        password: faker.internet.password({length: 12})
+      };
+
+      vi.spyOn(service, "createRootUser");
+
+      await service.install(template as any, user);
+
+      expect(formioService.importTemplate).toHaveBeenCalledWith(template);
+      expect(service.createRootUser).toHaveBeenCalledWith(user, template);
+    });
+  });
+});

package/src/services/FormioInstaller.ts

@@ -0,0 +1,46 @@
+import {Inject, Injectable} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+
+import {FormioSubmission} from "../domain/FormioModels.js";
+import {FormioTemplate} from "../domain/FormioTemplate.js";
+import {FormioDatabase} from "./FormioDatabase.js";
+
+@Injectable()
+export class FormioInstaller extends FormioDatabase {
+  @Inject()
+  protected logger: Logger;
+
+  async install(template: FormioTemplate, root: any) {
+    this.logger.info("Install formio template...");
+    template = await this.formio.importTemplate(template);
+
+    if (root) {
+      this.logger.info("Create root user...");
+      await this.createRootUser(root, template);
+    }
+  }
+
+  async createRootUser<User = unknown>(user: {email: string; password: string}, template: FormioTemplate): Promise<FormioSubmission<User>> {
+    const hash = await this.formio.encrypt(user.password);
+
+    return new Promise((resolve, reject) => {
+      this.formio.resources.submission.model.create(
+        {
+          form: template.resources.admin._id,
+          data: {
+            email: user.email,
+            password: hash
+          },
+          roles: [template.roles?.administrator._id].filter(Boolean)
+        },
+        (err: unknown, item: any) => {
+          if (err) {
+            return reject(err);
+          }
+
+          resolve(item);
+        }
+      );
+    });
+  }
+}

package/src/services/FormioRepository.spec.ts

@@ -0,0 +1,114 @@
+import {Injectable} from "@tsed/di";
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {FormioDatabase} from "./FormioDatabase.js";
+import {FormioRepository} from "./FormioRepository.js";
+
+@Injectable()
+class PackagesRepository extends FormioRepository {
+  formName = "package";
+}
+
+describe("FormioRepository", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+
+  describe("saveSubmission()", () => {
+    it("should create submission", async () => {
+      const database = {
+        formModel: {
+          findOne: vi.fn().mockResolvedValue({
+            _id: "id"
+          })
+        },
+        saveSubmission: vi.fn().mockImplementation((o) => o)
+      };
+
+      const service = await PlatformTest.invoke<PackagesRepository>(PackagesRepository, [
+        {
+          token: FormioDatabase,
+          use: database
+        }
+      ]);
+
+      const result = await service.saveSubmission({
+        data: {
+          label: "label"
+        }
+      });
+
+      expect(result).toEqual({
+        data: {
+          label: "label"
+        },
+        form: "id"
+      });
+      expect(database.saveSubmission).toHaveBeenCalledWith({
+        data: {
+          label: "label"
+        },
+        form: "id"
+      });
+    });
+  });
+  describe("getSubmissions()", () => {
+    it("should get all saved submissions", async () => {
+      const database = {
+        formModel: {
+          findOne: vi.fn().mockResolvedValue({
+            _id: "id"
+          })
+        },
+        getSubmissions: vi.fn().mockResolvedValue([])
+      };
+
+      const service = await PlatformTest.invoke<PackagesRepository>(PackagesRepository, [
+        {
+          token: FormioDatabase,
+          use: database
+        }
+      ]);
+
+      const submissions = await service.getSubmissions();
+
+      expect(submissions).toEqual([]);
+      expect(database.formModel.findOne).toHaveBeenCalledWith({
+        name: {
+          $eq: "package"
+        }
+      });
+      expect(database.getSubmissions).toHaveBeenCalledWith({form: "id"});
+    });
+  });
+  describe("findOneSubmission()", () => {
+    it("should find on submission", async () => {
+      const database = {
+        formModel: {
+          findOne: vi.fn().mockResolvedValue({
+            _id: "id"
+          })
+        },
+        submissionModel: {
+          findOne: vi.fn().mockResolvedValue({_id: "id"})
+        }
+      };
+
+      const service = await PlatformTest.invoke<PackagesRepository>(PackagesRepository, [
+        {
+          token: FormioDatabase,
+          use: database
+        }
+      ]);
+
+      const submission = await service.findOneSubmission({});
+
+      expect(submission).toEqual({_id: "id"});
+      expect(database.formModel.findOne).toHaveBeenCalledWith({
+        name: {
+          $eq: "package"
+        }
+      });
+      expect(database.submissionModel.findOne).toHaveBeenCalledWith({deleted: null, form: "id"});
+    });
+  });
+});

package/src/services/FormioRepository.ts

@@ -0,0 +1,49 @@
+import {Inject} from "@tsed/di";
+import {MongooseDocument, MongooseModel} from "@tsed/mongoose";
+import type {FilterQuery} from "mongoose";
+
+import {FormioSubmission} from "../domain/FormioModels.js";
+import {FormioDatabase} from "./FormioDatabase.js";
+
+export abstract class FormioRepository<SubmissionData = any> {
+  @Inject()
+  protected formioDatabase: FormioDatabase;
+
+  protected abstract formName: string;
+
+  private formId: string;
+
+  async getFormId() {
+    if (!this.formId) {
+      const form = await this.formioDatabase.formModel.findOne({name: {$eq: this.formName}});
+
+      if (form) {
+        this.formId = form._id;
+      }
+    }
+
+    return this.formId;
+  }
+
+  async saveSubmission(submission: Omit<Partial<FormioSubmission<SubmissionData>>, "form"> & {form?: any}) {
+    return this.formioDatabase.saveSubmission<SubmissionData>({
+      ...submission,
+      form: submission.form || (await this.getFormId())
+    });
+  }
+
+  async getSubmissions(query: FilterQuery<MongooseModel<FormioSubmission<SubmissionData>>> = {}) {
+    return this.formioDatabase.getSubmissions<SubmissionData>({
+      ...query,
+      form: await this.getFormId()
+    });
+  }
+
+  async findOneSubmission(query: any): Promise<MongooseDocument<FormioSubmission<SubmissionData>> | undefined> {
+    return this.formioDatabase.submissionModel.findOne({
+      form: await this.getFormId(),
+      deleted: null,
+      ...query
+    }) as any;
+  }
+}