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

package/src/lib/form/form.queries.ts

@@ -0,0 +1,72 @@
+import { Args, Int, Query, Resolver } from '@nestjs/graphql';
+import { BPMAuthenticated } from '../bpm-auth';
+import { FormDefinitionEntity } from './form-definition.entity';
+import { FormDefinitionVersionEntity } from './form-definition-version.entity';
+import { FormService } from './form.service';
+import { LintFormSchemaInput } from './dto/form-definition.input';
+import { FormDefinitionListStatusEnum } from './form.enums';
+import { FormSchemaLintResultObject } from './form-schema-lint.object';
+
+@Resolver()
+@BPMAuthenticated()
+export class FormQueries {
+  constructor(private readonly formService: FormService) {}
+
+  @Query(() => [FormDefinitionEntity])
+  async formDefinitions(
+    @Args('page', { nullable: true, type: () => Int })
+    page?: number | null,
+    @Args('pageSize', { nullable: true, type: () => Int })
+    pageSize?: number | null,
+    @Args('status', {
+      nullable: true,
+      type: () => FormDefinitionListStatusEnum,
+    })
+    status?: FormDefinitionListStatusEnum | null,
+  ): Promise<readonly FormDefinitionEntity[]> {
+    return this.formService.listFormDefinitions({
+      page: page ?? undefined,
+      pageSize: pageSize ?? undefined,
+      status: status ?? undefined,
+    });
+  }
+
+  @Query(() => Int)
+  async formDefinitionCount(
+    @Args('status', {
+      nullable: true,
+      type: () => FormDefinitionListStatusEnum,
+    })
+    status?: FormDefinitionListStatusEnum | null,
+  ): Promise<number> {
+    return this.formService.countFormDefinitions(status ?? undefined);
+  }
+
+  @Query(() => FormDefinitionEntity)
+  async formDefinition(
+    @Args('id', { type: () => String }) id: string,
+  ): Promise<FormDefinitionEntity> {
+    return this.formService.getFormDefinition(id);
+  }
+
+  @Query(() => [FormDefinitionVersionEntity])
+  async formDefinitionVersions(
+    @Args('formDefinitionId', { type: () => String }) formDefinitionId: string,
+  ): Promise<readonly FormDefinitionVersionEntity[]> {
+    return this.formService.listFormDefinitionVersions(formDefinitionId);
+  }
+
+  @Query(() => FormDefinitionVersionEntity)
+  async formDefinitionVersion(
+    @Args('id', { type: () => String }) id: string,
+  ): Promise<FormDefinitionVersionEntity> {
+    return this.formService.getFormDefinitionVersion(id);
+  }
+
+  @Query(() => FormSchemaLintResultObject)
+  lintFormSchema(
+    @Args('input') input: LintFormSchemaInput,
+  ): FormSchemaLintResultObject {
+    return this.formService.lintFormSchema(input);
+  }
+}

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

@@ -0,0 +1,371 @@
+import { EntityManager, ObjectLiteral, Repository } from 'typeorm';
+import { FormDefinitionEntity } from './form-definition.entity';
+import { FormDefinitionVersionEntity } from './form-definition-version.entity';
+import {
+  FormDefinitionListStatusEnum,
+  FormDefinitionVersionStatusEnum,
+} from './form.enums';
+import { FormService } from './form.service';
+
+describe('FormService', () => {
+  it('applies backend pagination when listing form definitions and counts active records', async (): Promise<void> => {
+    const forms = Array.from({ length: 13 }, (_, index) =>
+      createFormDefinition(`form-${index + 1}`),
+    );
+    const find = jest.fn(
+      ({
+        skip = 0,
+        take = 10,
+      }: {
+        readonly skip?: number;
+        readonly take?: number;
+      }): Promise<readonly FormDefinitionEntity[]> =>
+        Promise.resolve(forms.slice(skip, skip + take)),
+    );
+    const count = jest.fn((): Promise<number> => Promise.resolve(forms.length));
+    const service = new FormService(
+      {
+        count,
+        find,
+      } as unknown as Repository<FormDefinitionEntity>,
+      createRepository<FormDefinitionVersionEntity>(),
+    );
+
+    const pageTwo = await service.listFormDefinitions({
+      page: 2,
+      pageSize: 5,
+    });
+    const totalCount = await service.countFormDefinitions();
+
+    expect(find).toHaveBeenCalledWith(
+      expect.objectContaining({ skip: 5, take: 5 }),
+    );
+    expect(pageTwo.map((form) => form.id)).toEqual([
+      'form-6',
+      'form-7',
+      'form-8',
+      'form-9',
+      'form-10',
+    ]);
+    expect(totalCount).toBe(13);
+  });
+
+  it('filters form definitions by derived publication status', async (): Promise<void> => {
+    const find = jest.fn(
+      (): Promise<readonly FormDefinitionEntity[]> => Promise.resolve([]),
+    );
+    const count = jest.fn((): Promise<number> => Promise.resolve(0));
+    const service = new FormService(
+      {
+        count,
+        find,
+      } as unknown as Repository<FormDefinitionEntity>,
+      createRepository<FormDefinitionVersionEntity>(),
+    );
+
+    await service.listFormDefinitions({
+      status: FormDefinitionListStatusEnum.PUBLISHED,
+    });
+    await service.countFormDefinitions(FormDefinitionListStatusEnum.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('hydrates current version summary when listing form definitions', async (): Promise<void> => {
+    const publishedForm = Object.assign(createFormDefinition('form-1'), {
+      currentVersionId: 'version-1',
+    });
+    const find = jest.fn(
+      (): Promise<readonly FormDefinitionEntity[]> =>
+        Promise.resolve([publishedForm]),
+    );
+    const versionCreatedAt = new Date('2026-05-10T01:00:00.000Z');
+    const versionPublishedAt = new Date('2026-05-10T02:00:00.000Z');
+    const findBy = jest.fn(
+      (): Promise<readonly FormDefinitionVersionEntity[]> =>
+        Promise.resolve([
+          Object.assign(new FormDefinitionVersionEntity(), {
+            createdAt: versionCreatedAt,
+            id: 'version-1',
+            publishedAt: versionPublishedAt,
+            version: 3,
+          }),
+        ]),
+    );
+    const service = new FormService(
+      {
+        find,
+      } as unknown as Repository<FormDefinitionEntity>,
+      {
+        findBy,
+      } as unknown as Repository<FormDefinitionVersionEntity>,
+    );
+
+    const definitions = await service.listFormDefinitions();
+
+    expect(definitions[0]).toMatchObject({
+      currentVersionCreatedAt: versionCreatedAt,
+      currentVersionNumber: 3,
+      currentVersionPublishedAt: versionPublishedAt,
+    });
+    expect(findBy).toHaveBeenCalledWith({
+      id: expect.any(Object),
+    });
+  });
+
+  describe('publishFormDefinitionContent', () => {
+    const changedSchemaJson = JSON.stringify({
+      fields: [
+        { fieldKey: 'text_1', label: '姓名', required: false, type: 'text' },
+      ],
+      schemaVersion: 1,
+    });
+
+    it('publishes a brand-new version when published content changed', async (): Promise<void> => {
+      const definition = Object.assign(createFormDefinition('def-1'), {
+        currentVersionId: 'version-1',
+      });
+      const currentVersion = createVersion({
+        id: 'version-1',
+        status: FormDefinitionVersionStatusEnum.PUBLISHED,
+      });
+      const versionRepository = createVersionRepository({
+        currentVersion,
+        maxVersion: 1,
+      });
+      const service = new FormService(
+        createRepository<FormDefinitionEntity>(),
+        createRepository<FormDefinitionVersionEntity>(),
+      );
+
+      const published = await service.publishFormDefinitionContent(
+        {
+          formDefinitionId: 'def-1',
+          schemaJson: changedSchemaJson,
+          uiSchemaJson: null,
+        },
+        'member-1',
+        createManager(createDefinitionRepository(definition), versionRepository),
+      );
+
+      expect(published.status).toBe(FormDefinitionVersionStatusEnum.PUBLISHED);
+      expect(published.version).toBe(2);
+      expect(published.publishedByMemberId).toBe('member-1');
+      expect(versionRepository.update).toHaveBeenCalledWith(
+        { id: 'version-1' },
+        expect.objectContaining({
+          status: FormDefinitionVersionStatusEnum.ARCHIVED,
+        }),
+      );
+      expect(definition.currentVersionId).toBe(published.id);
+    });
+
+    it('returns the current version untouched when content is identical', async (): Promise<void> => {
+      const definition = Object.assign(createFormDefinition('def-1'), {
+        currentVersionId: 'version-1',
+      });
+      const currentVersion = createVersion({
+        id: 'version-1',
+        schema: JSON.parse(changedSchemaJson) as Record<string, unknown>,
+        status: FormDefinitionVersionStatusEnum.PUBLISHED,
+      });
+      const versionRepository = createVersionRepository({
+        currentVersion,
+        maxVersion: 1,
+      });
+      const service = new FormService(
+        createRepository<FormDefinitionEntity>(),
+        createRepository<FormDefinitionVersionEntity>(),
+      );
+
+      const published = await service.publishFormDefinitionContent(
+        {
+          formDefinitionId: 'def-1',
+          schemaJson: changedSchemaJson,
+          uiSchemaJson: null,
+        },
+        'member-1',
+        createManager(createDefinitionRepository(definition), versionRepository),
+      );
+
+      expect(published).toBe(currentVersion);
+      expect(versionRepository.save).not.toHaveBeenCalled();
+      expect(versionRepository.update).not.toHaveBeenCalled();
+    });
+
+    it('updates and publishes the pre-publish draft in place', async (): Promise<void> => {
+      const definition = createFormDefinition('def-1');
+      const draft = createVersion({
+        id: 'version-1',
+        status: FormDefinitionVersionStatusEnum.DRAFT,
+      });
+      const versionRepository = createVersionRepository({
+        draft,
+        maxVersion: 1,
+      });
+      const service = new FormService(
+        createRepository<FormDefinitionEntity>(),
+        createRepository<FormDefinitionVersionEntity>(),
+      );
+
+      const published = await service.publishFormDefinitionContent(
+        {
+          formDefinitionId: 'def-1',
+          schemaJson: changedSchemaJson,
+          uiSchemaJson: null,
+        },
+        'member-1',
+        createManager(createDefinitionRepository(definition), versionRepository),
+      );
+
+      expect(published.id).toBe('version-1');
+      expect(published.version).toBe(1);
+      expect(published.status).toBe(FormDefinitionVersionStatusEnum.PUBLISHED);
+      expect(JSON.stringify(published.schema)).toBe(changedSchemaJson);
+      expect(versionRepository.update).not.toHaveBeenCalled();
+      expect(definition.currentVersionId).toBe('version-1');
+    });
+  });
+});
+
+function createFormDefinition(id: string): FormDefinitionEntity {
+  return Object.assign(new FormDefinitionEntity(), {
+    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 createRepository<TEntity extends ObjectLiteral>(): Repository<TEntity> {
+  return {} as Repository<TEntity>;
+}
+
+function createVersion(overrides: {
+  readonly id: string;
+  readonly schema?: Record<string, unknown>;
+  readonly status: FormDefinitionVersionStatusEnum;
+}): FormDefinitionVersionEntity {
+  return Object.assign(new FormDefinitionVersionEntity(), {
+    archivedAt: null,
+    formDefinitionId: 'def-1',
+    id: overrides.id,
+    publishedAt: null,
+    publishedByMemberId: null,
+    schema: overrides.schema ?? { fields: [], schemaVersion: 1 },
+    status: overrides.status,
+    uiSchema: { layout: [], schemaVersion: 1 },
+    version: 1,
+  });
+}
+
+function createDefinitionRepository(
+  definition: FormDefinitionEntity,
+): Repository<FormDefinitionEntity> {
+  return {
+    findOne: jest.fn(
+      (): Promise<FormDefinitionEntity> => Promise.resolve(definition),
+    ),
+    merge: (
+      target: FormDefinitionEntity,
+      source: Partial<FormDefinitionEntity>,
+    ): FormDefinitionEntity => Object.assign(target, source),
+    save: jest.fn(
+      (entity: FormDefinitionEntity): Promise<FormDefinitionEntity> =>
+        Promise.resolve(entity),
+    ),
+  } as unknown as Repository<FormDefinitionEntity>;
+}
+
+function createVersionRepository(options: {
+  readonly currentVersion?: FormDefinitionVersionEntity;
+  readonly draft?: FormDefinitionVersionEntity;
+  readonly maxVersion: number;
+}): Repository<FormDefinitionVersionEntity> {
+  const versionsById = new Map(
+    [options.currentVersion, options.draft]
+      .filter(
+        (version): version is FormDefinitionVersionEntity =>
+          version !== undefined,
+      )
+      .map((version) => [version.id, version]),
+  );
+
+  return {
+    create: (
+      data: Partial<FormDefinitionVersionEntity>,
+    ): FormDefinitionVersionEntity =>
+      Object.assign(new FormDefinitionVersionEntity(), data),
+    createQueryBuilder: (): unknown => {
+      const builder = {
+        getRawOne: (): Promise<{ readonly maxVersion: number }> =>
+          Promise.resolve({ maxVersion: options.maxVersion }),
+        select: (): unknown => builder,
+        where: (): unknown => builder,
+      };
+
+      return builder;
+    },
+    findOne: jest.fn(
+      ({
+        where,
+      }: {
+        readonly where: { readonly id?: string };
+      }): Promise<FormDefinitionVersionEntity | null> =>
+        Promise.resolve(
+          where.id !== undefined
+            ? (versionsById.get(where.id) ?? null)
+            : (options.draft ?? null),
+        ),
+    ),
+    merge: (
+      target: FormDefinitionVersionEntity,
+      source: Partial<FormDefinitionVersionEntity>,
+    ): FormDefinitionVersionEntity => Object.assign(target, source),
+    save: jest.fn(
+      (
+        entity: FormDefinitionVersionEntity,
+      ): Promise<FormDefinitionVersionEntity> => {
+        const saved = entity.id
+          ? entity
+          : Object.assign(entity, { id: `version-${versionsById.size + 1}` });
+
+        versionsById.set(saved.id, saved);
+
+        return Promise.resolve(saved);
+      },
+    ),
+    update: jest.fn((): Promise<void> => Promise.resolve()),
+  } as unknown as Repository<FormDefinitionVersionEntity>;
+}
+
+function createManager(
+  definitionRepository: Repository<FormDefinitionEntity>,
+  versionRepository: Repository<FormDefinitionVersionEntity>,
+): EntityManager {
+  return {
+    getRepository: (entity: unknown): unknown =>
+      entity === FormDefinitionEntity
+        ? definitionRepository
+        : versionRepository,
+  } as unknown as EntityManager;
+}