@tsed/formio 8.11.0 → 8.11.2-rc.1

package/src/services/FormioDatabase.spec.ts

@@ -1,326 +0,0 @@
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {FormioDatabase} from "./FormioDatabase.js";
-import {FormioService} from "./FormioService.js";
-
-async function createServiceFixture() {
-  const formioService = {
-    mongoose: {
-      models: {
-        role: {
-          find: vi.fn().mockResolvedValue([{_id: "role_id", machineName: "role_machine"}])
-        },
-        form: class {
-          static countDocuments = vi.fn();
-          static find = vi.fn().mockResolvedValue([{_id: "form_id", machineName: "form_machine"}]);
-          static findOne = vi.fn().mockReturnThis();
-          static findOneAndUpdate = vi.fn();
-          static updateOne = vi.fn().mockReturnThis();
-          static lean = vi.fn().mockReturnThis();
-          static exec = vi.fn();
-
-          constructor(public ctrOpts: any) {
-            Object.assign(this, ctrOpts);
-          }
-
-          save(): any {}
-
-          toObject() {
-            return this.ctrOpts;
-          }
-        },
-        action: {
-          find: vi.fn().mockResolvedValue([{_id: "action_id", machineName: "action_machine"}])
-        },
-        submission: class {
-          static find = vi.fn().mockResolvedValue([]);
-          static findOneAndUpdate = vi.fn().mockImplementation((o, o1) => ({...o, ...o1}));
-
-          constructor(o: any) {
-            Object.assign(this, {
-              ...o,
-              _id: o._id || "newID"
-            });
-          }
-        },
-        token: {},
-        actionItem: {}
-      }
-    },
-    util: {
-      idToBson: vi.fn()
-    }
-  };
-  const service = await PlatformTest.invoke<FormioDatabase>(FormioDatabase, [
-    {
-      token: FormioService,
-      use: formioService
-    }
-  ]);
-
-  return {service, formioService};
-}
-
-describe("FormioDatabase", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(PlatformTest.reset);
-
-  describe("getFormioMapper()", () => {
-    it("should return the mapper", async () => {
-      const {service, formioService} = await createServiceFixture();
-
-      const mapper = await service.getFormioMapper();
-
-      expect([...mapper.ctxData.forms.entries()]).toEqual([
-        [
-          "form_id",
-          {
-            _id: "form_id",
-            machineName: "form_machine"
-          }
-        ],
-        [
-          "$machineName:form_machine",
-          {
-            _id: "form_id",
-            machineName: "form_machine"
-          }
-        ]
-      ]);
-      expect([...mapper.ctxData.actions.entries()]).toEqual([
-        [
-          "action_id",
-          {
-            _id: "action_id",
-            machineName: "action_machine"
-          }
-        ],
-        [
-          "$machineName:action_machine",
-          {
-            _id: "action_id",
-            machineName: "action_machine"
-          }
-        ]
-      ]);
-      expect([...mapper.ctxData.roles.entries()]).toEqual([
-        [
-          "role_id",
-          {
-            _id: "role_id",
-            machineName: "role_machine"
-          }
-        ],
-        [
-          "$machineName:role_machine",
-          {
-            _id: "role_id",
-            machineName: "role_machine"
-          }
-        ]
-      ]);
-
-      expect(formioService.mongoose.models.form.find).toHaveBeenCalledWith({
-        deleted: {$eq: null}
-      });
-      expect(formioService.mongoose.models.role.find).toHaveBeenCalledWith({
-        deleted: {$eq: null}
-      });
-      expect(formioService.mongoose.models.action.find).toHaveBeenCalledWith({
-        deleted: {$eq: null}
-      });
-    });
-  });
-  describe("hasForm()", () => {
-    it("should return true when database contain forms", async () => {
-      const {service, formioService} = await createServiceFixture();
-      formioService.mongoose.models.form.countDocuments.mockResolvedValue(6);
-
-      expect(await service.hasForms()).toEqual(true);
-    });
-
-    it("should return false when database has no forms", async () => {
-      const {service, formioService} = await createServiceFixture();
-      formioService.mongoose.models.form.countDocuments.mockResolvedValue(0);
-
-      expect(await service.hasForms()).toEqual(false);
-    });
-  });
-  describe("submissionModel()", () => {
-    it("should return the submissionModel", async () => {
-      const {service, formioService} = await createServiceFixture();
-      expect(service.submissionModel).toEqual(formioService.mongoose.models.submission);
-    });
-  });
-  describe("tokenModel()", () => {
-    it("should return the tokenModel", async () => {
-      const {service, formioService} = await createServiceFixture();
-      expect(service.tokenModel).toEqual(formioService.mongoose.models.token);
-    });
-  });
-  describe("actionItemModel()", () => {
-    it("should return the actionItemModel", async () => {
-      const {service, formioService} = await createServiceFixture();
-      expect(service.actionItemModel).toEqual(formioService.mongoose.models.actionItem);
-    });
-  });
-  describe("importFormIfNotExists()", () => {
-    it("should return create the form if not exists", async () => {
-      const {service, formioService} = await createServiceFixture();
-      const onCreate = vi.fn();
-      const form: any = {
-        name: "name"
-      };
-
-      formioService.mongoose.models.form.countDocuments.mockResolvedValue(false);
-      formioService.mongoose.models.form.exec.mockResolvedValue({
-        _id: "id",
-        name: "name"
-      });
-
-      const result = await service.importFormIfNotExists(form, onCreate);
-
-      expect(result).toEqual({
-        _id: "id",
-        name: "name"
-      });
-      expect(onCreate).toHaveBeenCalledTimes(1);
-    });
-    it("should not create form is exists", async () => {
-      const {service, formioService} = await createServiceFixture();
-      const onCreate = vi.fn();
-      const form: any = {
-        name: "name"
-      };
-
-      formioService.mongoose.models.form.countDocuments.mockResolvedValue(true);
-      formioService.mongoose.models.form.exec.mockResolvedValue({
-        _id: "id",
-        name: "name"
-      });
-
-      const result = await service.importFormIfNotExists(form, onCreate);
-
-      expect(result).toEqual({
-        _id: "id",
-        name: "name"
-      });
-    });
-  });
-  describe("getSubmissions()", () => {
-    it("should return submissions", async () => {
-      const {service} = await createServiceFixture();
-
-      const result = await service.getSubmissions();
-
-      expect(result).toEqual([]);
-      expect(service.submissionModel.find).toHaveBeenCalledWith({deleted: {$eq: null}});
-    });
-    it("should return submissions with query", async () => {
-      const {service} = await createServiceFixture();
-
-      const result = await service.getSubmissions({
-        form: "id"
-      });
-
-      expect(result).toEqual([]);
-      expect(service.submissionModel.find).toHaveBeenCalledWith({deleted: {$eq: null}, form: "id"});
-    });
-  });
-  describe("saveSubmissions()", () => {
-    it("should create submission", async () => {
-      const {service} = await createServiceFixture();
-
-      const result = await service.saveSubmission({
-        data: {}
-      });
-
-      expect(result).toEqual({
-        _id: "newID",
-        data: {}
-      });
-      expect(service.submissionModel.findOneAndUpdate).toHaveBeenCalledWith(
-        {_id: "newID"},
-        {_id: "newID", data: {}},
-        {
-          new: true,
-          upsert: true
-        }
-      );
-    });
-    it("should update submission", async () => {
-      const {service} = await createServiceFixture();
-
-      const result = await service.saveSubmission({
-        _id: "id",
-        data: {}
-      });
-
-      expect(result).toEqual({
-        _id: "id",
-        data: {}
-      });
-      expect(service.submissionModel.findOneAndUpdate).toHaveBeenCalledWith(
-        {_id: "id"},
-        {
-          _id: "id",
-          data: {}
-        },
-        {new: true, upsert: true}
-      );
-    });
-  });
-  describe("importSubmission()", () => {
-    it("should import submission", async () => {
-      const {service} = await createServiceFixture();
-
-      vi.spyOn(service, "saveSubmission").mockResolvedValue({} as any);
-
-      const result = await service.importSubmission({
-        _id: "id",
-        data: {}
-      });
-
-      expect(result).toEqual({});
-      expect(service.saveSubmission).toHaveBeenCalledWith({_id: "id", data: {}});
-    });
-  });
-  describe("getForm", () => {
-    it("should return form from id", async () => {
-      const {service, formioService} = await createServiceFixture();
-
-      await service.getForm("605f0d40fe971372e448bcad");
-
-      expect(formioService.mongoose.models.form.findOne).toHaveBeenCalledWith({
-        _id: "605f0d40fe971372e448bcad",
-        deleted: {$eq: null}
-      });
-      expect(formioService.mongoose.models.form.lean).toHaveBeenCalledWith();
-      expect(formioService.mongoose.models.form.exec).toHaveBeenCalledWith();
-    });
-
-    it("should return form from machineName", async () => {
-      const {service, formioService} = await createServiceFixture();
-
-      await service.getForm("name");
-
-      expect(formioService.mongoose.models.form.findOne).toHaveBeenCalledWith({
-        name: {$eq: "name"},
-        deleted: {$eq: null}
-      });
-      expect(formioService.mongoose.models.form.lean).toHaveBeenCalledWith();
-      expect(formioService.mongoose.models.form.exec).toHaveBeenCalledWith();
-    });
-  });
-  describe("idToBson", () => {
-    beforeEach(() => {});
-    it("should convert id", async () => {
-      const {service, formioService} = await createServiceFixture();
-      formioService.util.idToBson.mockReturnValue({bson: "bson"});
-      expect(service.idToBson("id")).toEqual({bson: "bson"});
-      expect(service.idToBson(["id"])).toEqual({$in: [{bson: "bson"}]});
-      expect(service.idToBson({_id: "id"})).toEqual({bson: "bson"});
-      expect(service.idToBson()).toEqual(undefined);
-    });
-  });
-});

package/src/services/FormioDatabase.ts

@@ -1,165 +0,0 @@
-import {isArray, isObject, isString, toMap as tMap} from "@tsed/core";
-import {Inject, Injectable} from "@tsed/di";
-import {FormioAction, FormioActionItem, FormioForm, FormioRole, FormioSubmission, FormioToken} from "@tsed/formio-types";
-import {MongooseDocument, MongooseModel} from "@tsed/mongoose";
-import omit from "lodash/omit.js";
-import type {FilterQuery} from "mongoose";
-
-import {FormioMapper} from "../builder/FormioMapper.js";
-import {isMongoId} from "../utils/isMongoId.js";
-import {FormioService} from "./FormioService.js";
-
-function toMap<T>(list: any[]) {
-  return tMap<string, MongooseDocument<T>>(list, (o: any) => [o._id.toString(), `$machineName:${o.name || o.machineName}`]);
-}
-
-@Injectable()
-export class FormioDatabase {
-  @Inject()
-  protected formio: FormioService;
-
-  get models() {
-    return this.formio.mongoose.models;
-  }
-
-  get roleModel(): MongooseModel<FormioRole> {
-    return this.models.role;
-  }
-
-  get formModel(): MongooseModel<FormioForm> {
-    return this.models.form;
-  }
-
-  get actionModel(): MongooseModel<FormioAction> {
-    return this.models.action;
-  }
-
-  get submissionModel(): MongooseModel<FormioSubmission> {
-    return this.models.submission;
-  }
-
-  get tokenModel(): MongooseModel<FormioToken> {
-    return this.models.token;
-  }
-
-  get actionItemModel(): MongooseModel<FormioActionItem> {
-    return this.models.actionItem;
-  }
-
-  async getFormioMapper(): Promise<FormioMapper> {
-    const [roles, forms, actions] = await Promise.all([
-      this.roleModel.find({
-        deleted: {$eq: null}
-      }),
-      this.formModel.find({
-        deleted: {$eq: null}
-      }),
-      this.actionModel.find({
-        deleted: {$eq: null}
-      })
-    ]);
-
-    return new FormioMapper({
-      forms: toMap<FormioForm>(forms),
-      actions: toMap<FormioAction>(actions),
-      roles: toMap<FormioRole>(roles)
-    });
-  }
-
-  async hasForms(): Promise<boolean> {
-    return (await this.formModel.countDocuments()) > 0;
-  }
-
-  async hasForm(name: string): Promise<boolean> {
-    return !!(await this.formModel.countDocuments({name: {$eq: name}}));
-  }
-
-  getForm(nameOrId: string) {
-    return this.formModel
-      .findOne({
-        deleted: {$eq: null},
-        ...(isMongoId(nameOrId)
-          ? {
-              _id: nameOrId
-            }
-          : {name: {$eq: nameOrId}})
-      })
-      .lean()
-      .exec();
-  }
-
-  /**
-   * Import form previously exported by export tool.
-   * This method transform alias to a real mongoose _id
-   * @param form
-   * @param onCreate
-   */
-  async importFormIfNotExists(form: FormioForm, onCreate?: (form: FormioForm) => any) {
-    if (!(await this.hasForm(form.name))) {
-      const createForm = await this.importForm(form);
-
-      onCreate && (await onCreate(createForm));
-    }
-
-    return this.getForm(form.name);
-  }
-
-  /**
-   * Import form previously exported by export tool.
-   * This method transform alias to a real mongoose _id
-   * @param form
-   */
-  async importForm(form: FormioForm) {
-    const mapper = await this.getFormioMapper();
-
-    return this.saveForm(mapper.mapToImport(form));
-  }
-
-  saveForm(form: FormioForm) {
-    form = new this.formModel(omit(form, ["__v"]) as any);
-
-    return this.formModel.findOneAndUpdate({_id: form._id}, form, {upsert: true, new: true});
-  }
-
-  getSubmissions<Data>(
-    query: FilterQuery<MongooseModel<FormioSubmission<Data>>> = {}
-  ): Promise<MongooseDocument<FormioSubmission<Data>>[]> {
-    return this.submissionModel.find({
-      ...query,
-      deleted: {$eq: null}
-    }) as any;
-  }
-
-  /**
-   * Import submission previously exported by export tool.
-   * This method transform alias to a real mongoose _id
-   * @param submission
-   */
-  async importSubmission<Data = any>(submission: Omit<Partial<FormioSubmission<Data>>, "form"> & {form?: any}) {
-    const mapper = await this.getFormioMapper();
-
-    return this.saveSubmission(mapper.mapToImport(submission));
-  }
-
-  saveSubmission<Data = any>(submission: Partial<FormioSubmission<Data>>) {
-    submission = new this.submissionModel(omit(submission, ["__v"]));
-
-    return this.submissionModel.findOneAndUpdate(
-      {
-        _id: submission._id
-      },
-      submission,
-      {new: true, upsert: true}
-    );
-  }
-
-  idToBson(form?: any) {
-    if (isArray(form)) {
-      return {$in: form.map(this.formio.util.idToBson)};
-    } else if (isObject(form)) {
-      return this.formio.util.idToBson((form as any)._id);
-    } else if (isString(form)) {
-      return this.formio.util.idToBson(form);
-    }
-  }
-}

package/src/services/FormioHooksService.spec.ts

@@ -1,156 +0,0 @@
-import {Store} from "@tsed/core";
-import {Provider} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {FormioHooksService} from "./FormioHooksService.js";
-import {FormioService} from "./FormioService.js";
-
-describe("FormioHooksService", () => {
-  beforeEach(PlatformTest.create);
-  afterEach(PlatformTest.reset);
-
-  it("should wrap multiple 'alter' hooks", async () => {
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService);
-
-    class Alter1 {
-      transform(value: any) {
-        return value + ":1";
-      }
-    }
-
-    class Alter2 {
-      transform(value: any) {
-        return value + ":2";
-      }
-    }
-
-    Store.from(Alter1).set("formio:alter:name", "hookName");
-    Store.from(Alter2).set("formio:alter:name", "hookName");
-
-    vi.spyOn(service as any, "getProviders").mockReturnValue([new Provider(Alter1), new Provider(Alter2)]);
-
-    const hooks: any = service.getHooks();
-
-    expect(hooks.alter.hookName).toBeInstanceOf(Function);
-
-    expect(hooks.alter.hookName("init")).toEqual("init:1:2");
-  });
-  it("should wrap multiple 'alter' hooks with args", async () => {
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService);
-
-    class Alter1 {
-      transform(value: any, ...args: any[]) {
-        return `${value}:1(${args.join(",")})`;
-      }
-    }
-
-    class Alter2 {
-      transform(value: any, ...args: any[]) {
-        return `${value}:2(${args.join(",")})`;
-      }
-    }
-
-    Store.from(Alter1).set("formio:alter:name", "hookName");
-    Store.from(Alter2).set("formio:alter:name", "hookName");
-
-    vi.spyOn(service as any, "getProviders").mockReturnValue([new Provider(Alter1), new Provider(Alter2)]);
-
-    const hooks: any = service.getHooks();
-
-    expect(hooks.alter.hookName).toBeInstanceOf(Function);
-
-    expect(hooks.alter.hookName("init", "hello")).toEqual("init:1(hello):2(hello)");
-  });
-  it("should wrap multiple 'on' hooks", async () => {
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService);
-
-    class On1 {
-      on(value: any) {
-        return value + ":1";
-      }
-    }
-
-    class On2 {
-      on(value: any) {
-        return value + ":2";
-      }
-    }
-
-    Store.from(On1).set("formio:on:name", "hookName");
-    Store.from(On2).set("formio:on:name", "hookName");
-
-    vi.spyOn(service as any, "getProviders").mockReturnValue([new Provider(On1), new Provider(On2)]);
-
-    const hooks: any = service.getHooks();
-
-    expect(hooks.on.hookName).toBeInstanceOf(Function);
-    expect(hooks.on.hookName("init")).toEqual("init:2");
-  });
-  it("should return settings method", async () => {
-    const formio = {
-      hook: {
-        settings: vi.fn()
-      }
-    };
-
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService, [
-      {
-        use: formio,
-        token: FormioService
-      }
-    ]);
-
-    expect(service.settings).toEqual(formio.hook.settings);
-  });
-
-  it("should return invoke method", async () => {
-    const formio = {
-      hook: {
-        invoke: vi.fn()
-      }
-    };
-
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService, [
-      {
-        use: formio,
-        token: FormioService
-      }
-    ]);
-
-    expect(service.invoke).toEqual(formio.hook.invoke);
-  });
-
-  it("should return alter method", async () => {
-    const formio = {
-      hook: {
-        alter: vi.fn()
-      }
-    };
-
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService, [
-      {
-        use: formio,
-        token: FormioService
-      }
-    ]);
-
-    expect(service.alter).toEqual(formio.hook.alter);
-  });
-
-  it("should return alterAsync method", async () => {
-    const formio = {
-      hook: {
-        alter: vi.fn()
-      }
-    };
-
-    const service = await PlatformTest.invoke<FormioHooksService>(FormioHooksService, [
-      {
-        use: formio,
-        token: FormioService
-      }
-    ]);
-
-    expect(typeof service.alterAsync).toEqual("function");
-  });
-});