feat: struct type feature config (#5142)

2026-02-11 20:08:37 +00:00 · 2023-12-14 09:50:51 +00:00
parent 2b7f6f8b74
commit 0c2d2f8d16
33 changed files with 1223 additions and 1015 deletions
--- a/packages/backend/server/tests/utils/blobs.ts
+++ b/packages/backend/server/tests/utils/blobs.ts
@@ -0,0 +1,112 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import { gql } from './common';
+
+export async function listBlobs(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+): Promise<string[]> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              listBlobs(workspaceId: "${workspaceId}")
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.listBlobs;
+}
+
+export async function getWorkspaceBlobsSize(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+): Promise<number> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `
+              query {
+                workspace(id: "${workspaceId}") {
+                  blobsSize
+                }
+              }
+            `,
+    })
+    .expect(200);
+  return res.body.data.workspace.blobsSize;
+}
+
+export async function collectAllBlobSizes(
+  app: INestApplication,
+  token: string
+): Promise<number> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `
+              query {
+                collectAllBlobSizes {
+                  size
+                }
+              }
+            `,
+    })
+    .expect(200);
+  return res.body.data.collectAllBlobSizes.size;
+}
+
+export async function checkBlobSize(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  size: number
+): Promise<number> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .send({
+      query: `query checkBlobSize($workspaceId: String!, $size: Float!) {
+          checkBlobSize(workspaceId: $workspaceId, size: $size) {
+            size
+          }
+        }`,
+      variables: { workspaceId, size },
+    })
+    .expect(200);
+  return res.body.data.checkBlobSize.size;
+}
+
+export async function setBlob(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  buffer: Buffer
+): Promise<string> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .field(
+      'operations',
+      JSON.stringify({
+        name: 'setBlob',
+        query: `mutation setBlob($blob: Upload!) {
+              setBlob(workspaceId: "${workspaceId}", blob: $blob)
+            }`,
+        variables: { blob: null },
+      })
+    )
+    .field('map', JSON.stringify({ '0': ['variables.blob'] }))
+    .attach('0', buffer, 'blob.data')
+    .expect(200);
+  return res.body.data.setBlob;
+}
--- a/packages/backend/server/tests/utils/common.ts
+++ b/packages/backend/server/tests/utils/common.ts
@@ -0,0 +1 @@
+export const gql = '/graphql';
--- a/packages/backend/server/tests/utils/index.ts
+++ b/packages/backend/server/tests/utils/index.ts
@@ -0,0 +1,5 @@
+export * from './blobs';
+export * from './invite';
+export * from './user';
+export * from './utils';
+export * from './workspace';
--- a/packages/backend/server/tests/utils/invite.ts
+++ b/packages/backend/server/tests/utils/invite.ts
@@ -0,0 +1,121 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import type { InvitationType } from '../../src/modules/workspaces';
+import { gql } from './common';
+
+export async function inviteUser(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  email: string,
+  permission: string,
+  sendInviteMail = false
+): Promise<string> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              invite(workspaceId: "${workspaceId}", email: "${email}", permission: ${permission}, sendInviteMail: ${sendInviteMail})
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.invite;
+}
+
+export async function acceptInviteById(
+  app: INestApplication,
+  workspaceId: string,
+  inviteId: string,
+  sendAcceptMail = false
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              acceptInviteById(workspaceId: "${workspaceId}", inviteId: "${inviteId}", sendAcceptMail: ${sendAcceptMail})
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.acceptInviteById;
+}
+
+export async function leaveWorkspace(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  sendLeaveMail = false
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              leaveWorkspace(workspaceId: "${workspaceId}", workspaceName: "test workspace", sendLeaveMail: ${sendLeaveMail})
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.leaveWorkspace;
+}
+
+export async function revokeUser(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  userId: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              revoke(workspaceId: "${workspaceId}", userId: "${userId}")
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.revoke;
+}
+
+export async function getInviteInfo(
+  app: INestApplication,
+  token: string,
+  inviteId: string
+): Promise<InvitationType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              getInviteInfo(inviteId: "${inviteId}") {
+                workspace {
+                  id
+                  name
+                  avatar
+                }
+                user {
+                  id
+                  name
+                  avatarUrl
+                }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.getInviteInfo;
+}
--- a/packages/backend/server/tests/utils/user.ts
+++ b/packages/backend/server/tests/utils/user.ts
@@ -0,0 +1,117 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import type { TokenType } from '../../src/modules/auth';
+import type { UserType } from '../../src/modules/users';
+import { gql } from './common';
+
+export async function signUp(
+  app: INestApplication,
+  name: string,
+  email: string,
+  password: string
+): Promise<UserType & { token: TokenType }> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              signUp(name: "${name}", email: "${email}", password: "${password}") {
+                id, name, email, token { token }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.signUp;
+}
+
+export async function currentUser(app: INestApplication, token: string) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              currentUser {
+                id, name, email, emailVerified, avatarUrl, createdAt, hasPassword,
+                token { token }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.currentUser;
+}
+
+export async function sendChangeEmail(
+  app: INestApplication,
+  userToken: string,
+  email: string,
+  callbackUrl: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              sendChangeEmail(email: "${email}", callbackUrl: "${callbackUrl}")
+            }
+          `,
+    })
+    .expect(200);
+
+  return res.body.data.sendChangeEmail;
+}
+
+export async function sendVerifyChangeEmail(
+  app: INestApplication,
+  userToken: string,
+  token: string,
+  email: string,
+  callbackUrl: string
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              sendVerifyChangeEmail(token:"${token}", email: "${email}", callbackUrl: "${callbackUrl}")
+            }
+          `,
+    })
+    .expect(200);
+
+  return res.body.data.sendVerifyChangeEmail;
+}
+
+export async function changeEmail(
+  app: INestApplication,
+  userToken: string,
+  token: string
+): Promise<UserType & { token: TokenType }> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(userToken, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+               changeEmail(token: "${token}") {
+                id
+                name
+                avatarUrl
+                email
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.changeEmail;
+}
--- a/packages/backend/server/tests/utils/utils.ts
+++ b/packages/backend/server/tests/utils/utils.ts
@@ -0,0 +1,82 @@
+import { randomUUID } from 'node:crypto';
+
+import type { DynamicModule, FactoryProvider } from '@nestjs/common';
+import { TestingModule } from '@nestjs/testing';
+import { hashSync } from '@node-rs/argon2';
+import { PrismaClient, type User } from '@prisma/client';
+
+import { RevertCommand, RunCommand } from '../../src/data/commands/run';
+import { StorageProvide } from '../../src/storage';
+
+export async function flushDB() {
+  const client = new PrismaClient();
+  await client.$connect();
+  const result: { tablename: string }[] =
+    await client.$queryRaw`SELECT tablename
+                           FROM pg_catalog.pg_tables
+                           WHERE schemaname != 'pg_catalog'
+                             AND schemaname != 'information_schema'`;
+
+  // remove all table data
+  await client.$executeRawUnsafe(
+    `TRUNCATE TABLE ${result
+      .map(({ tablename }) => tablename)
+      .filter(name => !name.includes('migrations'))
+      .join(', ')}`
+  );
+
+  await client.$disconnect();
+}
+
+export class FakePrisma {
+  fakeUser: User = {
+    id: randomUUID(),
+    name: 'Alex Yang',
+    avatarUrl: '',
+    email: 'alex.yang@example.org',
+    password: hashSync('123456'),
+    emailVerified: new Date(),
+    createdAt: new Date(),
+  };
+
+  get user() {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const prisma = this;
+    return {
+      async findFirst() {
+        return prisma.fakeUser;
+      },
+      async findUnique() {
+        return this.findFirst();
+      },
+      async update() {
+        return this.findFirst();
+      },
+    };
+  }
+}
+
+export class FakeStorageModule {
+  static forRoot(): DynamicModule {
+    const storageProvider: FactoryProvider = {
+      provide: StorageProvide,
+      useFactory: async () => {
+        return null;
+      },
+    };
+
+    return {
+      global: true,
+      module: FakeStorageModule,
+      providers: [storageProvider],
+      exports: [storageProvider],
+    };
+  }
+}
+
+export async function initFeatureConfigs(module: TestingModule) {
+  const run = module.get(RunCommand);
+  const revert = module.get(RevertCommand);
+  await Promise.allSettled([revert.run(['UserFeaturesInit1698652531198'])]);
+  await run.runOne('UserFeaturesInit1698652531198');
+}
--- a/packages/backend/server/tests/utils/workspace.ts
+++ b/packages/backend/server/tests/utils/workspace.ts
@@ -0,0 +1,172 @@
+import type { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+
+import type { WorkspaceType } from '../../src/modules/workspaces';
+import { gql } from './common';
+
+export async function createWorkspace(
+  app: INestApplication,
+  token: string
+): Promise<WorkspaceType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .field(
+      'operations',
+      JSON.stringify({
+        name: 'createWorkspace',
+        query: `mutation createWorkspace($init: Upload!) {
+              createWorkspace(init: $init) {
+                id
+              }
+            }`,
+        variables: { init: null },
+      })
+    )
+    .field('map', JSON.stringify({ '0': ['variables.init'] }))
+    .attach('0', Buffer.from([0, 0]), 'init.data')
+    .expect(200);
+  return res.body.data.createWorkspace;
+}
+
+export async function getWorkspacePublicPages(
+  app: INestApplication,
+  token: string,
+  workspaceId: string
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              workspace(id: "${workspaceId}") {
+                publicPages {
+                  id
+                  mode
+                }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.workspace.publicPages;
+}
+
+export async function getWorkspace(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  skip = 0,
+  take = 8
+): Promise<WorkspaceType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              workspace(id: "${workspaceId}") {
+                id, members(skip: ${skip}, take: ${take}) { id, name, email, permission, inviteId }
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.workspace;
+}
+
+export async function getPublicWorkspace(
+  app: INestApplication,
+  workspaceId: string
+): Promise<WorkspaceType> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            query {
+              publicWorkspace(id: "${workspaceId}") {
+                id
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.publicWorkspace;
+}
+
+export async function updateWorkspace(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  isPublic: boolean
+): Promise<boolean> {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              updateWorkspace(input: { id: "${workspaceId}", public: ${isPublic} }) {
+                public
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.data.updateWorkspace.public;
+}
+
+export async function publishPage(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  pageId: string
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              publishPage(workspaceId: "${workspaceId}", pageId: "${pageId}") {
+                id
+                mode
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.errors?.[0]?.message || res.body.data?.publishPage;
+}
+
+export async function revokePublicPage(
+  app: INestApplication,
+  token: string,
+  workspaceId: string,
+  pageId: string
+) {
+  const res = await request(app.getHttpServer())
+    .post(gql)
+    .auth(token, { type: 'bearer' })
+    .set({ 'x-request-id': 'test', 'x-operation-name': 'test' })
+    .send({
+      query: `
+            mutation {
+              revokePublicPage(workspaceId: "${workspaceId}", pageId: "${pageId}") {
+                id
+                mode
+                public
+              }
+            }
+          `,
+    })
+    .expect(200);
+  return res.body.errors?.[0]?.message || res.body.data?.revokePublicPage;
+}