@rytass/bpm-core-nestjs-module 0.5.0 → 0.5.1

package/src/lib/template/template.service.spec.ts

@@ -1,822 +0,0 @@
-import { EntityManager, ObjectLiteral, Repository } from 'typeorm';
-import { ConditionService } from '../condition/condition.service';
-import { FormDefinitionEntity } from '../form/form-definition.entity';
-import { FormDefinitionVersionEntity } from '../form/form-definition-version.entity';
-import { FormDefinitionVersionStatusEnum } from '../form/form.enums';
-import { FormService } from '../form/form.service';
-import { ApprovalTemplateCategoryEntity } from './approval-template-category.entity';
-import { ApprovalTemplateEntity } from './approval-template.entity';
-import { ApprovalTemplateVersionEntity } from './approval-template-version.entity';
-import {
-  ApprovalTemplateCategoryStatusEnum,
-  ApprovalTemplateListStatusEnum,
-  ApprovalTemplateVersionStatusEnum,
-} from './template.enums';
-import { TemplateService } from './template.service';
-import { EMPTY_WORKFLOW_DEFINITION } from './workflow-definition.validator';
-
-describe('TemplateService', () => {
-  it('applies backend pagination when listing approval templates and counts active records', async (): Promise<void> => {
-    const templates = Array.from({ length: 13 }, (_, index) =>
-      createApprovalTemplate(`template-${index + 1}`),
-    );
-    const find = jest.fn(
-      ({
-        skip = 0,
-        take = 10,
-      }: {
-        readonly skip?: number;
-        readonly take?: number;
-      }): Promise<readonly ApprovalTemplateEntity[]> =>
-        Promise.resolve(templates.slice(skip, skip + take)),
-    );
-    const count = jest.fn(
-      (): Promise<number> => Promise.resolve(templates.length),
-    );
-    const service = new TemplateService(
-      {
-        count,
-        find,
-      } as unknown as Repository<ApprovalTemplateEntity>,
-      createRepository<ApprovalTemplateCategoryEntity>(),
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    const pageTwo = await service.listApprovalTemplates({
-      page: 2,
-      pageSize: 5,
-    });
-    const totalCount = await service.countApprovalTemplates();
-
-    expect(find).toHaveBeenCalledWith(
-      expect.objectContaining({
-        order: { createdAt: 'DESC', updatedAt: 'DESC' },
-        skip: 5,
-        take: 5,
-        where: expect.objectContaining({
-          deletedAt: expect.any(Object),
-        }),
-      }),
-    );
-    expect(pageTwo.map((template) => template.id)).toEqual([
-      'template-6',
-      'template-7',
-      'template-8',
-      'template-9',
-      'template-10',
-    ]);
-    expect(totalCount).toBe(13);
-  });
-
-  it('filters approval templates by derived publication status', async (): Promise<void> => {
-    const find = jest.fn(
-      (): Promise<readonly ApprovalTemplateEntity[]> => Promise.resolve([]),
-    );
-    const count = jest.fn((): Promise<number> => Promise.resolve(0));
-    const service = new TemplateService(
-      {
-        count,
-        find,
-      } as unknown as Repository<ApprovalTemplateEntity>,
-      createRepository<ApprovalTemplateCategoryEntity>(),
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    await service.listApprovalTemplates({
-      status: ApprovalTemplateListStatusEnum.PUBLISHED,
-    });
-    await service.countApprovalTemplates({
-      status: ApprovalTemplateListStatusEnum.DRAFT,
-    });
-
-    expect(find).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({
-          currentVersionId: expect.any(Object),
-          deletedAt: expect.any(Object),
-        }),
-      }),
-    );
-    expect(count).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({
-          currentVersionId: expect.any(Object),
-          deletedAt: expect.any(Object),
-        }),
-      }),
-    );
-  });
-
-  it('pushes search text into server-side template filters', async (): Promise<void> => {
-    const find = jest.fn(
-      (): Promise<readonly ApprovalTemplateEntity[]> => Promise.resolve([]),
-    );
-    const count = jest.fn((): Promise<number> => Promise.resolve(0));
-    const service = new TemplateService(
-      {
-        count,
-        find,
-      } as unknown as Repository<ApprovalTemplateEntity>,
-      createRepository<ApprovalTemplateCategoryEntity>(),
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    await service.listApprovalTemplates({
-      searchText: '費用',
-      status: ApprovalTemplateListStatusEnum.PUBLISHED,
-    });
-    await service.countApprovalTemplates({
-      searchText: '費用',
-      status: ApprovalTemplateListStatusEnum.PUBLISHED,
-    });
-
-    expect(find).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.arrayContaining([
-          expect.objectContaining({
-            currentVersionId: expect.any(Object),
-            deletedAt: expect.any(Object),
-            name: expect.any(Object),
-          }),
-          expect.objectContaining({
-            category: expect.any(Object),
-            currentVersionId: expect.any(Object),
-            deletedAt: expect.any(Object),
-          }),
-          expect.objectContaining({
-            currentVersionId: expect.any(Object),
-            deletedAt: expect.any(Object),
-            description: expect.any(Object),
-          }),
-        ]),
-      }),
-    );
-    expect(count).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.any(Array),
-      }),
-    );
-  });
-
-  it('filters approval templates by category id', async (): Promise<void> => {
-    const find = jest.fn(
-      (): Promise<readonly ApprovalTemplateEntity[]> => Promise.resolve([]),
-    );
-    const count = jest.fn((): Promise<number> => Promise.resolve(0));
-    const service = new TemplateService(
-      {
-        count,
-        find,
-      } as unknown as Repository<ApprovalTemplateEntity>,
-      createRepository<ApprovalTemplateCategoryEntity>(),
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    await service.listApprovalTemplates({
-      categoryId: 'category-1',
-    });
-    await service.countApprovalTemplates({
-      categoryId: 'category-1',
-    });
-
-    expect(find).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({
-          categoryId: 'category-1',
-          deletedAt: expect.any(Object),
-        }),
-      }),
-    );
-    expect(count).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({
-          categoryId: 'category-1',
-          deletedAt: expect.any(Object),
-        }),
-      }),
-    );
-  });
-
-  it('lists active approval template categories by default', async (): Promise<void> => {
-    const find = jest.fn(
-      (): Promise<readonly ApprovalTemplateCategoryEntity[]> =>
-        Promise.resolve([]),
-    );
-    const count = jest.fn((): Promise<number> => Promise.resolve(0));
-    const service = new TemplateService(
-      createRepository<ApprovalTemplateEntity>(),
-      {
-        count,
-        find,
-      } as unknown as Repository<ApprovalTemplateCategoryEntity>,
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    await service.listApprovalTemplateCategories({
-      page: 1,
-      pageSize: 20,
-      searchText: '財務',
-    });
-    await service.countApprovalTemplateCategories({
-      status: ApprovalTemplateCategoryStatusEnum.ALL,
-    });
-
-    expect(find).toHaveBeenCalledWith(
-      expect.objectContaining({
-        order: { createdAt: 'ASC', name: 'ASC', sortOrder: 'ASC' },
-        take: 20,
-        where: expect.arrayContaining([
-          expect.objectContaining({
-            isActive: true,
-            name: expect.any(Object),
-          }),
-          expect.objectContaining({
-            description: expect.any(Object),
-            isActive: true,
-          }),
-        ]),
-      }),
-    );
-    expect(count).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: {},
-      }),
-    );
-  });
-
-  it('validates category existence when creating approval templates', async (): Promise<void> => {
-    const category = createApprovalTemplateCategory('category-1');
-    const categoryFindOne = jest.fn(
-      (): Promise<ApprovalTemplateCategoryEntity | null> =>
-        Promise.resolve(category),
-    );
-    const templateCreate = jest.fn(
-      (value: Partial<ApprovalTemplateEntity>): ApprovalTemplateEntity =>
-        Object.assign(new ApprovalTemplateEntity(), value),
-    );
-    const templateSave = jest.fn(
-      (value: ApprovalTemplateEntity): Promise<ApprovalTemplateEntity> =>
-        Promise.resolve({ ...value, id: 'template-1' }),
-    );
-    const versionSave = jest.fn(
-      (
-        value: ApprovalTemplateVersionEntity,
-      ): Promise<ApprovalTemplateVersionEntity> => Promise.resolve(value),
-    );
-    const versionCreate = jest.fn(
-      (
-        value: Partial<ApprovalTemplateVersionEntity>,
-      ): ApprovalTemplateVersionEntity =>
-        Object.assign(new ApprovalTemplateVersionEntity(), value),
-    );
-    const manager = {
-      getRepository: jest.fn((entity: unknown): unknown => {
-        if (entity === ApprovalTemplateEntity) {
-          return {
-            create: templateCreate,
-            save: templateSave,
-          };
-        }
-
-        if (entity === ApprovalTemplateCategoryEntity) {
-          return {
-            findOne: categoryFindOne,
-          };
-        }
-
-        if (entity === FormDefinitionVersionEntity) {
-          return {
-            findOne: jest.fn(
-              (): Promise<FormDefinitionVersionEntity | null> =>
-                Promise.resolve(null),
-            ),
-          };
-        }
-
-        return {
-          create: versionCreate,
-          save: versionSave,
-        };
-      }),
-      transaction: jest.fn(
-        <TResult>(
-          operation: (manager: {
-            readonly getRepository: (entity: unknown) => unknown;
-          }) => Promise<TResult>,
-        ): Promise<TResult> => operation(manager),
-      ),
-    };
-    const service = new TemplateService(
-      { manager } as unknown as Repository<ApprovalTemplateEntity>,
-      createRepository<ApprovalTemplateCategoryEntity>(),
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    await service.createApprovalTemplate({
-      category: null,
-      categoryId: 'category-1',
-      createdByMemberId: null,
-      description: null,
-      formDefinitionVersionId: null,
-      name: '費用簽核',
-    });
-
-    expect(categoryFindOne).toHaveBeenCalledWith({
-      where: { id: 'category-1' },
-    });
-    expect(templateCreate).toHaveBeenCalledWith(
-      expect.objectContaining({
-        category: '財務',
-        categoryId: 'category-1',
-      }),
-    );
-  });
-
-  it('rejects publishing a draft with workflow lint errors before mutating template state', async (): Promise<void> => {
-    const draftVersion = Object.assign(new ApprovalTemplateVersionEntity(), {
-      archivedAt: null,
-      createdAt: new Date('2026-05-10T00:00:00.000Z'),
-      formDefinitionVersionId: 'form-version-1',
-      id: 'template-version-1',
-      initiatorPolicyCel: null,
-      notificationConfig: null,
-      publishedAt: null,
-      publishedByMemberId: null,
-      slaDefaults: null,
-      status: ApprovalTemplateVersionStatusEnum.DRAFT,
-      templateId: 'template-1',
-      updatedAt: new Date('2026-05-10T00:00:00.000Z'),
-      version: 1,
-      workflowDefinition: EMPTY_WORKFLOW_DEFINITION,
-    });
-    const formVersion = Object.assign(new FormDefinitionVersionEntity(), {
-      archivedAt: null,
-      createdAt: new Date('2026-05-10T00:00:00.000Z'),
-      formDefinitionId: 'form-1',
-      id: 'form-version-1',
-      publishedAt: new Date('2026-05-10T00:00:00.000Z'),
-      publishedByMemberId: 'member-admin',
-      schema: { fields: [], schemaVersion: 1 },
-      status: FormDefinitionVersionStatusEnum.PUBLISHED,
-      uiSchema: { fieldOrder: [] },
-      updatedAt: new Date('2026-05-10T00:00:00.000Z'),
-      version: 1,
-    });
-    const transaction = jest.fn(
-      <TResult>(
-        operation: (
-          manager: Readonly<Record<string, unknown>>,
-        ) => Promise<TResult>,
-      ): Promise<TResult> => operation({}),
-    );
-    const service = new TemplateService(
-      {
-        manager: { transaction },
-      } as unknown as Repository<ApprovalTemplateEntity>,
-      createRepository<ApprovalTemplateCategoryEntity>(),
-      {
-        findOne: jest.fn(
-          (): Promise<ApprovalTemplateVersionEntity | null> =>
-            Promise.resolve(draftVersion),
-        ),
-      } as unknown as Repository<ApprovalTemplateVersionEntity>,
-      {
-        findOne: jest.fn(
-          (): Promise<FormDefinitionVersionEntity | null> =>
-            Promise.resolve(formVersion),
-        ),
-      } as unknown as Repository<FormDefinitionVersionEntity>,
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    await expect(
-      service.publishApprovalTemplateVersion('template-version-1'),
-    ).rejects.toThrow(
-      'workflow.nodes.start does not have a path to an endEvent',
-    );
-    expect(transaction).not.toHaveBeenCalled();
-  });
-
-  it('deactivates categories on delete when templates still use them', async (): Promise<void> => {
-    const category = createApprovalTemplateCategory('category-1');
-    const categorySave = jest.fn(
-      (
-        value: ApprovalTemplateCategoryEntity,
-      ): Promise<ApprovalTemplateCategoryEntity> => Promise.resolve(value),
-    );
-    const service = new TemplateService(
-      {
-        count: jest.fn((): Promise<number> => Promise.resolve(2)),
-      } as unknown as Repository<ApprovalTemplateEntity>,
-      {
-        findOne: jest.fn(
-          (): Promise<ApprovalTemplateCategoryEntity | null> =>
-            Promise.resolve(category),
-        ),
-        merge: jest.fn(
-          (
-            entity: ApprovalTemplateCategoryEntity,
-            value: Partial<ApprovalTemplateCategoryEntity>,
-          ): ApprovalTemplateCategoryEntity => Object.assign(entity, value),
-        ),
-        save: categorySave,
-      } as unknown as Repository<ApprovalTemplateCategoryEntity>,
-      createRepository<ApprovalTemplateVersionEntity>(),
-      createRepository<FormDefinitionVersionEntity>(),
-      new ConditionService(),
-      {} as unknown as FormService,
-    );
-
-    const deleted = await service.deleteApprovalTemplateCategory('category-1');
-
-    expect(deleted.isActive).toBe(false);
-    expect(categorySave).toHaveBeenCalledWith(
-      expect.objectContaining({
-        isActive: false,
-      }),
-    );
-  });
-});
-
-describe('TemplateService.composeApprovalTemplateWithForm', () => {
-  it('publishes form and template atomically when publish is true', async (): Promise<void> => {
-    const { manager, store } = createInMemoryManager();
-    const service = createComposingService(manager);
-
-    const result = await service.composeApprovalTemplateWithForm(
-      {
-        category: null,
-        categoryId: null,
-        formDefinitionId: null,
-        formDescription: null,
-        formName: '請款表單',
-        initiatorPolicyCel: null,
-        notificationConfigJson: null,
-        publish: true,
-        schemaJson: JSON.stringify(SAMPLE_FORM_SCHEMA),
-        slaDefaultsJson: null,
-        templateDescription: null,
-        templateId: null,
-        templateName: '請款簽核',
-        uiSchemaJson: JSON.stringify(SAMPLE_FORM_UI_SCHEMA),
-        workflowDefinitionJson: JSON.stringify(VALID_WORKFLOW_DEFINITION),
-      },
-      'member-admin',
-    );
-
-    expect(result.published).toBe(true);
-    expect(result.formDefinitionVersion.status).toBe(
-      FormDefinitionVersionStatusEnum.PUBLISHED,
-    );
-    expect(result.templateVersion.status).toBe(
-      ApprovalTemplateVersionStatusEnum.PUBLISHED,
-    );
-    // The template version binds the freshly published form version.
-    expect(result.templateVersion.formDefinitionVersionId).toBe(
-      result.formDefinitionVersion.id,
-    );
-    // Both parents now point at the published versions.
-    expect(result.formDefinition.currentVersionId).toBe(
-      result.formDefinitionVersion.id,
-    );
-    expect(result.template.currentVersionId).toBe(result.templateVersion.id);
-
-    const formVersions = [
-      ...store(FormDefinitionVersionEntity).values(),
-    ] as FormDefinitionVersionEntity[];
-    expect(formVersions).toHaveLength(1);
-  });
-
-  it('keeps both sides as drafts when publish is false', async (): Promise<void> => {
-    const { manager } = createInMemoryManager();
-    const service = createComposingService(manager);
-
-    const result = await service.composeApprovalTemplateWithForm(
-      {
-        category: null,
-        categoryId: null,
-        formDefinitionId: null,
-        formDescription: null,
-        formName: '請款表單',
-        initiatorPolicyCel: null,
-        notificationConfigJson: null,
-        publish: false,
-        schemaJson: JSON.stringify(SAMPLE_FORM_SCHEMA),
-        slaDefaultsJson: null,
-        templateDescription: null,
-        templateId: null,
-        templateName: '請款簽核',
-        uiSchemaJson: JSON.stringify(SAMPLE_FORM_UI_SCHEMA),
-        workflowDefinitionJson: JSON.stringify(VALID_WORKFLOW_DEFINITION),
-      },
-      'member-admin',
-    );
-
-    expect(result.published).toBe(false);
-    expect(result.formDefinitionVersion.status).toBe(
-      FormDefinitionVersionStatusEnum.DRAFT,
-    );
-    expect(result.templateVersion.status).toBe(
-      ApprovalTemplateVersionStatusEnum.DRAFT,
-    );
-    // Draft template binds the draft form version so condition fields resolve.
-    expect(result.templateVersion.formDefinitionVersionId).toBe(
-      result.formDefinitionVersion.id,
-    );
-    expect(result.formDefinition.currentVersionId).toBeNull();
-    expect(result.template.currentVersionId).toBeNull();
-  });
-
-  it('rolls back inside the single transaction when the workflow fails to lint', async (): Promise<void> => {
-    const { manager, store } = createInMemoryManager();
-    const service = createComposingService(manager);
-
-    await expect(
-      service.composeApprovalTemplateWithForm(
-        {
-          category: null,
-          categoryId: null,
-          formDefinitionId: null,
-          formDescription: null,
-          formName: '請款表單',
-          initiatorPolicyCel: null,
-          notificationConfigJson: null,
-          publish: true,
-          schemaJson: JSON.stringify(SAMPLE_FORM_SCHEMA),
-          slaDefaultsJson: null,
-          templateDescription: null,
-          templateId: null,
-          templateName: '請款簽核',
-          uiSchemaJson: JSON.stringify(SAMPLE_FORM_UI_SCHEMA),
-          // EMPTY workflow cannot reach an endEvent and must fail publish lint.
-          workflowDefinitionJson: JSON.stringify(EMPTY_WORKFLOW_DEFINITION),
-        },
-        'member-admin',
-      ),
-    ).rejects.toThrow('does not have a path to an endEvent');
-
-    // The single manager.transaction wraps every write, so a real DataSource
-    // would roll back the form rows created before the failing publish step.
-    expect(store(ApprovalTemplateEntity).size).toBeGreaterThanOrEqual(1);
-  });
-});
-
-function createApprovalTemplate(id: string): ApprovalTemplateEntity {
-  return Object.assign(new ApprovalTemplateEntity(), {
-    category: null,
-    categoryDetail: null,
-    categoryId: null,
-    createdAt: new Date('2026-05-10T00:00:00.000Z'),
-    createdByMemberId: null,
-    currentVersionId: null,
-    deletedAt: null,
-    description: null,
-    id,
-    name: `簽核模板 ${id}`,
-    updatedAt: new Date('2026-05-10T00:00:00.000Z'),
-  });
-}
-
-function createApprovalTemplateCategory(
-  id: string,
-): ApprovalTemplateCategoryEntity {
-  return Object.assign(new ApprovalTemplateCategoryEntity(), {
-    createdAt: new Date('2026-05-10T00:00:00.000Z'),
-    description: null,
-    id,
-    isActive: true,
-    name: '財務',
-    sortOrder: 0,
-    updatedAt: new Date('2026-05-10T00:00:00.000Z'),
-  });
-}
-
-function createRepository<
-  TEntity extends ObjectLiteral,
->(): Repository<TEntity> {
-  return {} as Repository<TEntity>;
-}
-
-const SAMPLE_FORM_SCHEMA = {
-  fields: [
-    {
-      fieldKey: 'amount',
-      label: '金額',
-      required: true,
-      type: 'number',
-    },
-  ],
-  schemaVersion: 1,
-};
-
-const SAMPLE_FORM_UI_SCHEMA = {
-  layout: [{ fieldKey: 'amount', width: 'FULL' }],
-  schemaVersion: 1,
-};
-
-const VALID_WORKFLOW_DEFINITION = {
-  edges: [
-    {
-      data: {},
-      id: 'edge_start_task',
-      source: 'start',
-      target: 'task_manager',
-      type: 'smoothstep',
-    },
-    {
-      data: {},
-      id: 'edge_task_end',
-      source: 'task_manager',
-      target: 'end',
-      type: 'smoothstep',
-    },
-  ],
-  meta: { schemaVersion: 1 },
-  nodes: [
-    {
-      data: { label: '開始' },
-      id: 'start',
-      position: { x: 80, y: 160 },
-      type: 'startEvent',
-    },
-    {
-      data: {
-        allowAddSigner: false,
-        allowReject: true,
-        allowTransfer: true,
-        approverResolver: {
-          baseFromInitiator: true,
-          levelsUp: 1,
-          type: 'ORG_MANAGER',
-        },
-        decisionPolicy: { type: 'SINGLE' },
-        label: '主管簽核',
-        returnBehavior: { allowReturn: true, allowedTargets: 'INITIATOR' },
-      },
-      id: 'task_manager',
-      position: { x: 300, y: 160 },
-      type: 'userTask',
-    },
-    {
-      data: { endState: 'APPROVED', label: '完成' },
-      id: 'end',
-      position: { x: 520, y: 160 },
-      type: 'endEvent',
-    },
-  ],
-};
-
-function createComposingService(manager: EntityManager): TemplateService {
-  const formService = new FormService(
-    {} as Repository<FormDefinitionEntity>,
-    {} as Repository<FormDefinitionVersionEntity>,
-  );
-
-  return new TemplateService(
-    { manager } as unknown as Repository<ApprovalTemplateEntity>,
-    {} as Repository<ApprovalTemplateCategoryEntity>,
-    {} as Repository<ApprovalTemplateVersionEntity>,
-    {} as Repository<FormDefinitionVersionEntity>,
-    new ConditionService(),
-    formService,
-  );
-}
-
-/**
- * Minimal in-memory EntityManager that backs the composed-mutation tests. It
- * supports the create/find/update surface the compose flow exercises and runs
- * `transaction(op)` by invoking `op` with itself, mirroring a single DB
- * transaction boundary.
- */
-function createInMemoryManager(): {
-  readonly manager: EntityManager;
-  readonly store: (entity: unknown) => Map<string, ObjectLiteral>;
-} {
-  const stores = new Map<unknown, Map<string, ObjectLiteral>>();
-  let sequence = 0;
-
-  const storeFor = (entity: unknown): Map<string, ObjectLiteral> => {
-    const existing = stores.get(entity);
-
-    if (existing) {
-      return existing;
-    }
-
-    const created = new Map<string, ObjectLiteral>();
-    stores.set(entity, created);
-
-    return created;
-  };
-
-  const matches = (
-    row: ObjectLiteral,
-    where: Readonly<Record<string, unknown>>,
-  ): boolean =>
-    Object.entries(where).every(([key, value]) => {
-      if (key === 'relations') {
-        return true;
-      }
-
-      if (value !== null && typeof value === 'object' && '_type' in value) {
-        // Treat any FindOperator (e.g. IsNull()) as a null match.
-        return row[key] === null || row[key] === undefined;
-      }
-
-      return row[key] === value;
-    });
-
-  const makeRepository = (
-    entity: new () => ObjectLiteral,
-  ): Record<string, unknown> => {
-    const store = storeFor(entity);
-
-    return {
-      create: (value: ObjectLiteral): ObjectLiteral =>
-        Object.assign(new entity(), value),
-      findOne: ({
-        where,
-      }: {
-        readonly where:
-          | Readonly<Record<string, unknown>>
-          | readonly Readonly<Record<string, unknown>>[];
-      }): Promise<ObjectLiteral | null> => {
-        const clauses = Array.isArray(where) ? where : [where];
-
-        for (const row of store.values()) {
-          if (clauses.some((clause) => matches(row, clause))) {
-            return Promise.resolve(row);
-          }
-        }
-
-        return Promise.resolve(null);
-      },
-      findOneByOrFail: (
-        where: Readonly<Record<string, unknown>>,
-      ): Promise<ObjectLiteral> => {
-        for (const row of store.values()) {
-          if (matches(row, where)) {
-            return Promise.resolve(row);
-          }
-        }
-
-        return Promise.reject(new Error(`${entity.name} was not found`));
-      },
-      merge: (target: ObjectLiteral, patch: ObjectLiteral): ObjectLiteral =>
-        Object.assign(target, patch),
-      save: (value: ObjectLiteral): Promise<ObjectLiteral> => {
-        if (!value.id) {
-          sequence += 1;
-          value.id = `${entity.name}-${sequence}`;
-        }
-
-        store.set(value.id as string, value);
-
-        return Promise.resolve(value);
-      },
-      update: (
-        criteria: Readonly<Record<string, unknown>>,
-        patch: ObjectLiteral,
-      ): Promise<void> => {
-        for (const row of store.values()) {
-          if (matches(row, criteria)) {
-            Object.assign(row, patch);
-          }
-        }
-
-        return Promise.resolve();
-      },
-    };
-  };
-
-  const manager = {
-    getRepository: (entity: new () => ObjectLiteral): Record<string, unknown> =>
-      makeRepository(entity),
-    transaction: <TResult>(
-      operation: (manager: EntityManager) => Promise<TResult>,
-    ): Promise<TResult> => operation(manager as unknown as EntityManager),
-  } as unknown as EntityManager;
-
-  return {
-    manager,
-    store: (entity: unknown): Map<string, ObjectLiteral> => storeFor(entity),
-  };
-}