feat: init

twake/backend/node/test/e2e/documents/assets/test.txt

@@ -0,0 +1 @@
+test

twake/backend/node/test/e2e/documents/documents-tab.spec.ts

@@ -0,0 +1,183 @@
+import { afterAll, afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+import { deserialize } from "class-transformer";
+import { AccessInformation } from "../../../src/services/documents/entities/drive-file";
+import { init, TestPlatform } from "../setup";
+import { TestDbService } from "../utils.prepare.db";
+import { e2e_createDocument, e2e_getDocument } from "./utils";
+
+const url = "/internal/services/documents/v1";
+
+describe("the Drive Twake tabs feature", () => {
+  let platform: TestPlatform;
+
+  class DriveFileMockClass {
+    id: string;
+    name: string;
+    size: number;
+    added: string;
+    parent_id: string;
+    access_info: AccessInformation;
+  }
+
+  class DriveItemDetailsMockClass {
+    path: string[];
+    item: DriveFileMockClass;
+    children: DriveFileMockClass[];
+    versions: Record<string, unknown>[];
+  }
+
+  beforeEach(async () => {
+    platform = await init({
+      services: [
+        "webserver",
+        "database",
+        "applications",
+        "search",
+        "storage",
+        "message-queue",
+        "user",
+        "search",
+        "files",
+        "websocket",
+        "messages",
+        "auth",
+        "realtime",
+        "channels",
+        "counter",
+        "statistics",
+        "platform-services",
+        "documents",
+      ],
+    });
+  });
+
+  afterEach(async () => {
+    await platform.tearDown();
+  });
+
+  afterAll(async () => {
+    await platform.app.close();
+  });
+
+  it("did create a tab configuration on Drive side", async done => {
+    await TestDbService.getInstance(platform, true);
+
+    const item = {
+      name: "new tab test file",
+      parent_id: "root",
+      company_id: platform.workspace.company_id,
+    };
+
+    const version = {};
+
+    const response = await e2e_createDocument(platform, item, version);
+    const doc = deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
+
+    const tab = {
+      company_id: platform.workspace.company_id,
+      tab_id: "1234567890",
+      channel_id: "abcdefghij",
+      item_id: doc.id,
+      level: "write",
+    };
+
+    const token = await platform.auth.getJWTToken();
+
+    const createdTab = await platform.app.inject({
+      method: "POST",
+      url: `${url}/companies/${platform.workspace.company_id}/tabs/${tab.tab_id}`,
+      headers: {
+        authorization: `Bearer ${token}`,
+      },
+      payload: tab,
+    });
+
+    expect(createdTab.statusCode).toBe(200);
+    expect(createdTab.body).toBeDefined();
+    expect(createdTab.json().company_id).toBe(tab.company_id);
+    expect(createdTab.json().tab_id).toBe(tab.tab_id);
+    expect(createdTab.json().item_id).toBe(tab.item_id);
+
+    const getTabResponse = await platform.app.inject({
+      method: "GET",
+      url: `${url}/companies/${platform.workspace.company_id}/tabs/${tab.tab_id}`,
+      headers: {
+        authorization: `Bearer ${token}`,
+      },
+    });
+
+    expect(getTabResponse.statusCode).toBe(200);
+    expect(getTabResponse.body).toBeDefined();
+    expect(getTabResponse.json().company_id).toBe(tab.company_id);
+    expect(getTabResponse.json().tab_id).toBe(tab.tab_id);
+    expect(getTabResponse.json().item_id).toBe(tab.item_id);
+
+    const documentResponse = await e2e_getDocument(platform, doc.id);
+    const documentResult = deserialize<DriveItemDetailsMockClass>(
+      DriveItemDetailsMockClass,
+      documentResponse.body,
+    );
+
+    console.log(documentResult?.item);
+
+    expect(
+      documentResult?.item?.access_info?.entities?.find(
+        a => a?.type === "channel" && a.id === "abcdefghij" && a.level === "write",
+      ),
+    ).toBeDefined();
+
+    done?.();
+  });
+
+  it("did refuse to create a tab configuration for an item I can't manage", async done => {
+    const dbService = await TestDbService.getInstance(platform, true);
+    const ws0pk = {
+      id: platform.workspace.workspace_id,
+      company_id: platform.workspace.company_id,
+    };
+    const otherUser = await dbService.createUser([ws0pk]);
+
+    const item = {
+      name: "new tab test file",
+      parent_id: "root",
+      company_id: platform.workspace.company_id,
+      access_info: {
+        entities: [
+          {
+            type: "folder",
+            id: "parent",
+            level: "none",
+          } as any,
+        ],
+      },
+    };
+
+    const version = {};
+
+    const response = await e2e_createDocument(platform, item, version);
+    const doc = deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
+
+    const tab = {
+      company_id: platform.workspace.company_id,
+      tab_id: "1234567890",
+      channel_id: "abcdefghij",
+      item_id: doc.id,
+      level: "read",
+    };
+
+    const token = await platform.auth.getJWTToken({ sub: otherUser.id });
+
+    const createdTab = await platform.app.inject({
+      method: "POST",
+      url: `${url}/companies/${platform.workspace.company_id}/tabs/${tab.tab_id}`,
+      headers: {
+        authorization: `Bearer ${token}`,
+      },
+      payload: tab,
+    });
+
+    expect(createdTab.statusCode).toBe(403);
+
+    done?.();
+  });
+});

twake/backend/node/test/e2e/documents/documents.spec.ts

@@ -0,0 +1,238 @@
+import { describe, beforeEach, afterEach, it, expect, afterAll } from "@jest/globals";
+import { deserialize } from "class-transformer";
+import { File } from "../../../src/services/files/entities/file";
+import { ResourceUpdateResponse } from "../../../src/utils/types";
+import { init, TestPlatform } from "../setup";
+import { TestDbService } from "../utils.prepare.db";
+import {
+  e2e_createDocument,
+  e2e_createDocumentFile,
+  e2e_createVersion,
+  e2e_deleteDocument,
+  e2e_getDocument,
+  e2e_searchDocument,
+  e2e_updateDocument,
+} from "./utils";
+
+describe("the Drive feature", () => {
+  let platform: TestPlatform;
+
+  class DriveFileMockClass {
+    id: string;
+    name: string;
+    size: number;
+    added: string;
+    parent_id: string;
+  }
+
+  class DriveItemDetailsMockClass {
+    path: string[];
+    item: DriveFileMockClass;
+    children: DriveFileMockClass[];
+    versions: Record<string, unknown>[];
+  }
+
+  class SearchResultMockClass {
+    entities: DriveFileMockClass[];
+  }
+
+  beforeEach(async () => {
+    platform = await init({
+      services: [
+        "webserver",
+        "database",
+        "applications",
+        "search",
+        "storage",
+        "message-queue",
+        "user",
+        "search",
+        "files",
+        "websocket",
+        "messages",
+        "auth",
+        "realtime",
+        "channels",
+        "counter",
+        "statistics",
+        "platform-services",
+        "documents",
+      ],
+    });
+  });
+
+  afterEach(async () => {
+    await platform.tearDown();
+  });
+
+  afterAll(async () => {
+    await platform.app.close();
+  });
+
+  const createItem = async (): Promise<DriveFileMockClass> => {
+    await TestDbService.getInstance(platform, true);
+
+    const item = {
+      name: "new test file",
+      parent_id: "root",
+      company_id: platform.workspace.company_id,
+    };
+
+    const version = {};
+
+    const response = await e2e_createDocument(platform, item, version);
+    return deserialize<DriveFileMockClass>(DriveFileMockClass, response.body);
+  };
+
+  it("did create the drive item", async done => {
+    const result = await createItem();
+
+    expect(result).toBeDefined();
+    expect(result.name).toEqual("new test file");
+    expect(result.added).toBeDefined();
+
+    done?.();
+  });
+
+  it("did fetch the drive item", async done => {
+    await TestDbService.getInstance(platform, true);
+
+    const response = await e2e_getDocument(platform, "");
+    const result = deserialize<DriveItemDetailsMockClass>(DriveItemDetailsMockClass, response.body);
+
+    expect(result.item.name).toEqual("root");
+
+    done?.();
+  });
+
+  it("did fetch the trash", async done => {
+    await TestDbService.getInstance(platform, true);
+
+    const response = await e2e_getDocument(platform, "trash");
+    const result = deserialize<DriveItemDetailsMockClass>(DriveItemDetailsMockClass, response.body);
+
+    expect(result.item.name).toEqual("trash");
+
+    done?.();
+  });
+
+  it("did delete an item", async done => {
+    const createItemResult = await createItem();
+
+    expect(createItemResult.id).toBeDefined();
+
+    const deleteResponse = await e2e_deleteDocument(platform, createItemResult.id);
+    expect(deleteResponse.statusCode).toEqual(200);
+
+    done?.();
+  });
+
+  it("did update an item", async done => {
+    const createItemResult = await createItem();
+
+    expect(createItemResult.id).toBeDefined();
+
+    const update = {
+      name: "somethingelse",
+    };
+
+    const updateItemResponse = await e2e_updateDocument(platform, createItemResult.id, update);
+    const updateItemResult = deserialize<DriveFileMockClass>(
+      DriveFileMockClass,
+      updateItemResponse.body,
+    );
+
+    expect(createItemResult.id).toEqual(updateItemResult.id);
+    expect(updateItemResult.name).toEqual("somethingelse");
+
+    done?.();
+  });
+
+  it("did move an item to trash", async done => {
+    const createItemResult = await createItem();
+
+    expect(createItemResult.id).toBeDefined();
+
+    const moveToTrashResponse = await e2e_deleteDocument(platform, createItemResult.id);
+    expect(moveToTrashResponse.statusCode).toEqual(200);
+
+    const listTrashResponse = await e2e_getDocument(platform, "trash");
+    const listTrashResult = deserialize<DriveItemDetailsMockClass>(
+      DriveItemDetailsMockClass,
+      listTrashResponse.body,
+    );
+
+    expect(listTrashResult.item.name).toEqual("trash");
+    expect(listTrashResult.children.some(({ id }) => id === createItemResult.id)).toBeTruthy();
+
+    done?.();
+  });
+
+  // TODO: wait for elastic search index
+  it("did search for an item", async done => {
+    const createItemResult = await createItem();
+
+    expect(createItemResult.id).toBeDefined();
+
+    await e2e_getDocument(platform, "root");
+    await e2e_getDocument(platform, createItemResult.id);
+
+    await new Promise(resolve => setTimeout(resolve, 3000));
+
+    const searchPayload = {
+      search: "test",
+    };
+
+    const searchResponse = await e2e_searchDocument(platform, searchPayload);
+    const searchResult = deserialize<SearchResultMockClass>(
+      SearchResultMockClass,
+      searchResponse.body,
+    );
+
+    expect(searchResult.entities.length).toBeGreaterThanOrEqual(1);
+
+    done?.();
+  });
+
+  it("did search for an item that doesn't exist", async done => {
+    await createItem();
+
+    const unexistingSeachPayload = {
+      search: "somethingthatdoesn'tandshouldn'texist",
+    };
+    const failSearchResponse = await e2e_searchDocument(platform, unexistingSeachPayload);
+    const failSearchResult = deserialize<SearchResultMockClass>(
+      SearchResultMockClass,
+      failSearchResponse.body,
+    );
+
+    expect(failSearchResult.entities).toHaveLength(0);
+
+    done?.();
+  });
+
+  it("did create a version for a drive item", async done => {
+    const item = await createItem();
+    const fileUploadResponse = await e2e_createDocumentFile(platform);
+    const fileUploadResult = deserialize<ResourceUpdateResponse<File>>(
+      ResourceUpdateResponse,
+      fileUploadResponse.body,
+    );
+
+    const file_metadata = { external_id: fileUploadResult.resource.id };
+
+    await e2e_createVersion(platform, item.id, { filename: "file2", file_metadata });
+    await e2e_createVersion(platform, item.id, { filename: "file3", file_metadata });
+    await e2e_createVersion(platform, item.id, { filename: "file4", file_metadata });
+
+    const fetchItemResponse = await e2e_getDocument(platform, item.id);
+    const fetchItemResult = deserialize<DriveItemDetailsMockClass>(
+      DriveItemDetailsMockClass,
+      fetchItemResponse.body,
+    );
+
+    expect(fetchItemResult.versions).toHaveLength(4);
+
+    done?.();
+  });
+});

twake/backend/node/test/e2e/documents/utils.ts

@@ -0,0 +1,116 @@
+import { DriveFile } from "../../../src/services/documents/entities/drive-file";
+import { FileVersion } from "../../../src/services/documents/entities/file-version";
+import { TestPlatform } from "../setup";
+import formAutoContent from "form-auto-content";
+import fs from "fs";
+
+const url = "/internal/services/documents/v1";
+
+export const e2e_createDocument = async (
+  platform: TestPlatform,
+  item: Partial<DriveFile>,
+  version: Partial<FileVersion>,
+) => {
+  const token = await platform.auth.getJWTToken();
+
+  return await platform.app.inject({
+    method: "POST",
+    url: `${url}/companies/${platform.workspace.company_id}/item`,
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+    payload: {
+      item,
+      version,
+    },
+  });
+};
+
+export const e2e_getDocument = async (platform: TestPlatform, id: string | "root" | "trash") => {
+  const token = await platform.auth.getJWTToken();
+
+  return await platform.app.inject({
+    method: "GET",
+    url: `${url}/companies/${platform.workspace.company_id}/item/${id}`,
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+  });
+};
+
+export const e2e_deleteDocument = async (platform: TestPlatform, id: string | "root" | "trash") => {
+  const token = await platform.auth.getJWTToken();
+
+  return await platform.app.inject({
+    method: "DELETE",
+    url: `${url}/companies/${platform.workspace.company_id}/item/${id}`,
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+  });
+};
+
+export const e2e_updateDocument = async (
+  platform: TestPlatform,
+  id: string | "root" | "trash",
+  item: Partial<DriveFile>,
+) => {
+  const token = await platform.auth.getJWTToken();
+
+  return await platform.app.inject({
+    method: "POST",
+    url: `${url}/companies/${platform.workspace.company_id}/item/${id}`,
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+    payload: item,
+  });
+};
+
+export const e2e_searchDocument = async (
+  platform: TestPlatform,
+  payload: Record<string, string>,
+) => {
+  const token = await platform.auth.getJWTToken();
+
+  const response = await platform.app.inject({
+    method: "POST",
+    url: `${url}/companies/${platform.workspace.company_id}/search`,
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+    payload,
+  });
+
+  return response;
+};
+
+export const e2e_createVersion = async (
+  platform: TestPlatform,
+  id: string,
+  payload: Partial<FileVersion>,
+) => {
+  const token = await platform.auth.getJWTToken();
+
+  return await platform.app.inject({
+    method: "POST",
+    url: `${url}/companies/${platform.workspace.company_id}/item/${id}/version`,
+    headers: {
+      authorization: `Bearer ${token}`,
+    },
+    payload,
+  });
+};
+
+export const e2e_createDocumentFile = async (platform: TestPlatform) => {
+  const filePath = `${__dirname}/assets/test.txt`;
+  const token = await platform.auth.getJWTToken();
+  const form = formAutoContent({ file: fs.createReadStream(filePath) });
+  form.headers["authorization"] = `Bearer ${token}`;
+
+  return await platform.app.inject({
+    method: "POST",
+    url: `/internal/services/files/v1/companies/${platform.workspace.company_id}/files`,
+    ...form,
+  });
+};