feat: struct type feature config (#5142)

packages/backend/server/tests/app.e2e.ts

@@ -12,6 +12,7 @@ import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';
 import request from 'supertest';
 
 import { AppModule } from '../src/app';
+import { FeatureManagementService } from '../src/modules/features';
 import { PrismaService } from '../src/prisma/service';
 
 const gql = '/graphql';
@@ -60,6 +61,8 @@ test.beforeEach(async t => {
   })
     .overrideProvider(PrismaService)
     .useClass(FakePrisma)
+    .overrideProvider(FeatureManagementService)
+    .useValue({ canEarlyAccess: () => true })
     .compile();
   t.context.app = module.createNestApplication({
     cors: true,

packages/backend/server/tests/exception-logger.e2e.ts

@@ -6,6 +6,7 @@ import request from 'supertest';
 
 import { AppModule } from '../src/app';
 import { ExceptionLogger } from '../src/middleware/exception-logger';
+import { FeatureManagementService } from '../src/modules/features';
 import { PrismaService } from '../src/prisma';
 
 const gql = '/graphql';
@@ -38,6 +39,8 @@ test.beforeEach(async () => {
   })
     .overrideProvider(PrismaService)
     .useClass(FakePrisma)
+    .overrideProvider(FeatureManagementService)
+    .useValue({})
     .compile();
   app = module.createNestApplication({
     cors: true,

packages/backend/server/tests/feature.spec.ts

@@ -81,12 +81,8 @@ test('should be able to set feature', async t => {
   await feature.addUserFeature(u1.id, FeatureType.EarlyAccess, 1, 'test');
 
   const f2 = await feature.getUserFeatures(u1.id);
-  t.is(f2.length, 1, 'should have one feature');
-  t.is(
-    f2[0].feature.feature,
-    FeatureType.EarlyAccess,
-    'should be early access'
-  );
+  t.is(f2.length, 1, 'should have 1 feature');
+  t.is(f2[0].feature.name, FeatureType.EarlyAccess, 'should be early access');
 });
 
 test('should be able to check early access', async t => {
@@ -101,7 +97,7 @@ test('should be able to check early access', async t => {
   t.true(f2, 'should have early access');
 
   const f3 = await feature.listFeatureUsers(FeatureType.EarlyAccess);
-  t.is(f3.length, 1, 'should have one user');
+  t.is(f3.length, 1, 'should have 1 user');
   t.is(f3[0].id, u1.id, 'should be the same user');
 });
 
@@ -116,7 +112,7 @@ test('should be able revert quota', async t => {
   const f2 = await early_access.canEarlyAccess(u1.email);
   t.true(f2, 'should have early access');
   const q1 = await early_access.listEarlyAccess();
-  t.is(q1.length, 1, 'should have one user');
+  t.is(q1.length, 1, 'should have 1 user');
   t.is(q1[0].id, u1.id, 'should be the same user');
 
   await early_access.removeEarlyAccess(u1.id);
@@ -127,10 +123,21 @@ test('should be able revert quota', async t => {
 
   const q3 = await feature.getUserFeatures(u1.id);
   t.is(q3.length, 1, 'should have 1 feature');
-  t.is(
-    q3[0].feature.feature,
-    FeatureType.EarlyAccess,
-    'should be early access'
-  );
+  t.is(q3[0].feature.name, FeatureType.EarlyAccess, 'should be early access');
   t.is(q3[0].activated, false, 'should be deactivated');
 });
+
+test('should be same instance after reset the feature', async t => {
+  const { auth, feature, early_access } = t.context;
+  const u1 = await auth.signUp('DarkSky', 'darksky@example.org', '123456');
+
+  await early_access.addEarlyAccess(u1.id);
+  const f1 = (await feature.getUserFeatures(u1.id))[0];
+
+  await early_access.removeEarlyAccess(u1.id);
+
+  await early_access.addEarlyAccess(u1.id);
+  const f2 = (await feature.getUserFeatures(u1.id))[1];
+
+  t.is(f1.feature, f2.feature, 'should be same instance');
+});

packages/backend/server/tests/mailer.spec.ts

@@ -9,6 +9,7 @@ import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.mjs';
 
 import { AppModule } from '../src/app';
 import { MailService } from '../src/modules/auth/mailer';
+import { FeatureManagementService } from '../src/modules/features';
 import { PrismaService } from '../src/prisma';
 import { createWorkspace, getInviteInfo, inviteUser, signUp } from './utils';
 
@@ -100,6 +101,8 @@ test.beforeEach(async t => {
   })
     .overrideProvider(PrismaService)
     .useValue(FakePrisma)
+    .overrideProvider(FeatureManagementService)
+    .useValue({})
     .compile();
   const app = module.createNestApplication();
   app.use(

packages/backend/server/tests/quota.spec.ts

@@ -80,12 +80,12 @@ test('should be able to set quota', async t => {
 
   const q1 = await quota.getUserQuota(u1.id);
   t.truthy(q1, 'should have quota');
-  t.is(q1?.feature.feature, QuotaType.Quota_FreePlanV1, 'should be free plan');
+  t.is(q1?.feature.name, QuotaType.FreePlanV1, 'should be free plan');
 
-  await quota.switchUserQuota(u1.id, QuotaType.Quota_ProPlanV1);
+  await quota.switchUserQuota(u1.id, QuotaType.ProPlanV1);
 
   const q2 = await quota.getUserQuota(u1.id);
-  t.is(q2?.feature.feature, QuotaType.Quota_ProPlanV1, 'should be pro plan');
+  t.is(q2?.feature.name, QuotaType.ProPlanV1, 'should be pro plan');
 
   const fail = quota.switchUserQuota(u1.id, 'not_exists_plan_v1' as QuotaType);
   await t.throwsAsync(fail, { instanceOf: Error }, 'should throw error');
@@ -99,7 +99,7 @@ test('should be able to check storage quota', async t => {
   t.is(q1?.blobLimit, Quotas[0].configs.blobLimit, 'should be free plan');
   t.is(q1?.storageQuota, Quotas[0].configs.storageQuota, 'should be free plan');
 
-  await quota.switchUserQuota(u1.id, QuotaType.Quota_ProPlanV1);
+  await quota.switchUserQuota(u1.id, QuotaType.ProPlanV1);
   const q2 = await storageQuota.getUserQuota(u1.id);
   t.is(q2?.blobLimit, Quotas[1].configs.blobLimit, 'should be pro plan');
   t.is(q2?.storageQuota, Quotas[1].configs.storageQuota, 'should be pro plan');
@@ -113,32 +113,20 @@ test('should be able revert quota', async t => {
   t.is(q1?.blobLimit, Quotas[0].configs.blobLimit, 'should be free plan');
   t.is(q1?.storageQuota, Quotas[0].configs.storageQuota, 'should be free plan');
 
-  await quota.switchUserQuota(u1.id, QuotaType.Quota_ProPlanV1);
+  await quota.switchUserQuota(u1.id, QuotaType.ProPlanV1);
   const q2 = await storageQuota.getUserQuota(u1.id);
   t.is(q2?.blobLimit, Quotas[1].configs.blobLimit, 'should be pro plan');
   t.is(q2?.storageQuota, Quotas[1].configs.storageQuota, 'should be pro plan');
 
-  await quota.switchUserQuota(u1.id, QuotaType.Quota_FreePlanV1);
+  await quota.switchUserQuota(u1.id, QuotaType.FreePlanV1);
   const q3 = await storageQuota.getUserQuota(u1.id);
   t.is(q3?.blobLimit, Quotas[0].configs.blobLimit, 'should be free plan');
 
   const quotas = await quota.getUserQuotas(u1.id);
   t.is(quotas.length, 3, 'should have 3 quotas');
-  t.is(
-    quotas[0].feature.feature,
-    QuotaType.Quota_FreePlanV1,
-    'should be free plan'
-  );
-  t.is(
-    quotas[1].feature.feature,
-    QuotaType.Quota_ProPlanV1,
-    'should be pro plan'
-  );
-  t.is(
-    quotas[2].feature.feature,
-    QuotaType.Quota_FreePlanV1,
-    'should be free plan'
-  );
+  t.is(quotas[0].feature.name, QuotaType.FreePlanV1, 'should be free plan');
+  t.is(quotas[1].feature.name, QuotaType.ProPlanV1, 'should be pro plan');
+  t.is(quotas[2].feature.name, QuotaType.FreePlanV1, 'should be free plan');
   t.is(quotas[0].activated, false, 'should be activated');
   t.is(quotas[1].activated, false, 'should be activated');
   t.is(quotas[2].activated, true, 'should be activated');

packages/backend/server/tests/utils.ts

@@ -1,619 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-import type {
-  DynamicModule,
-  FactoryProvider,
-  INestApplication,
-} from '@nestjs/common';
-import { TestingModule } from '@nestjs/testing';
-import { hashSync } from '@node-rs/argon2';
-import { PrismaClient, type User } from '@prisma/client';
-import request from 'supertest';
-
-import { RevertCommand, RunCommand } from '../src/data/commands/run';
-import type { TokenType } from '../src/modules/auth';
-import type { UserType } from '../src/modules/users';
-import type { InvitationType, WorkspaceType } from '../src/modules/workspaces';
-import { StorageProvide } from '../src/storage';
-
-const gql = '/graphql';
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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();
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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;
-}
-
-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');
-}
-
-export {
-  acceptInviteById,
-  changeEmail,
-  checkBlobSize,
-  collectAllBlobSizes,
-  createWorkspace,
-  currentUser,
-  flushDB,
-  getInviteInfo,
-  getPublicWorkspace,
-  getWorkspace,
-  getWorkspaceBlobsSize,
-  inviteUser,
-  leaveWorkspace,
-  listBlobs,
-  publishPage,
-  revokePublicPage,
-  revokeUser,
-  sendChangeEmail,
-  sendVerifyChangeEmail,
-  setBlob,
-  signUp,
-  updateWorkspace,
-};

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;
+}

packages/backend/server/tests/utils/common.ts

@@ -0,0 +1 @@
+export const gql = '/graphql';

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';

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;
+}

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;
+}

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');
+}

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;
+}

packages/backend/server/tests/workspace-blobs.spec.ts

@@ -179,7 +179,7 @@ test('should be able calc quota after switch plan', async t => {
   );
   t.is(size1, 0, 'failed to check free plan blob size');
 
-  quota.switchUserQuota(u1.id, QuotaType.Quota_ProPlanV1);
+  quota.switchUserQuota(u1.id, QuotaType.ProPlanV1);
 
   const size2 = await checkBlobSize(
     app,

packages/backend/server/tests/workspace-usage.spec.ts

@@ -4,6 +4,7 @@ import ava, { type TestFn } from 'ava';
 import { stub } from 'sinon';
 
 import { AppModule } from '../src/app';
+import { FeatureManagementService } from '../src/modules/features';
 import { Quotas } from '../src/modules/quota';
 import { UsersService } from '../src/modules/users';
 import { PermissionService } from '../src/modules/workspaces/permission';
@@ -59,6 +60,23 @@ test.beforeEach(async t => {
           };
         },
       },
+      features: {
+        async findFirst() {
+          return {
+            id: 0,
+            feature: 'free_plan_v1',
+            version: 1,
+            type: 1,
+            configs: {
+              name: 'Free',
+              blobLimit: 1,
+              storageQuota: 1,
+              historyPeriod: 1,
+              memberLimit: 3,
+            },
+          };
+        },
+      },
     })
     .overrideProvider(PermissionService)
     .useClass(FakePermission)
@@ -70,6 +88,8 @@ test.beforeEach(async t => {
         return 1024 * 10;
       },
     })
+    .overrideProvider(FeatureManagementService)
+    .useValue({})
     .compile();
   t.context.app = module.createNestApplication();
   t.context.resolver = t.context.app.get(WorkspaceResolver);