@tsed/formio 8.11.1 → 8.11.2-rc.1

package/src/services/FormioHooksService.ts

@@ -1,92 +0,0 @@
-import {promisify} from "node:util";
-
-import {Inject, Injectable, InjectorService} from "@tsed/di";
-import {Request} from "express";
-
-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

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

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

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

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