@lobb-js/lobb-ext-storage 0.5.8 → 0.8.1

package/extensions/storage/studio/tests/fileManager.spec.ts

@@ -0,0 +1,23 @@
+import { test, expect } from "@playwright/test";
+
+const FILE_MANAGER_URL = "/studio/extensions/storage/file_manager";
+
+test.describe("File Manager page", () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto(FILE_MANAGER_URL);
+  });
+
+  test("loads the file manager page", async ({ page }) => {
+    await expect(page).toHaveURL(new RegExp(FILE_MANAGER_URL));
+  });
+
+  test("shows the file manager nav link in the sidebar", async ({ page }) => {
+    await expect(page.locator(`a[href="${FILE_MANAGER_URL}"]`)).toBeVisible();
+  });
+
+  test("file manager page is accessible from the nav", async ({ page }) => {
+    await page.goto("/studio");
+    await page.locator(`a[href="${FILE_MANAGER_URL}"]`).click();
+    await expect(page).toHaveURL(new RegExp(FILE_MANAGER_URL));
+  });
+});

package/extensions/storage/studio/tests/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/extensions/storage/studio/tests/playwright.config.cjs

@@ -0,0 +1,27 @@
+const { defineConfig, devices } = require("@playwright/test");
+
+module.exports = defineConfig({
+  testDir: __dirname,
+  testMatch: "**/*.spec.ts",
+  fullyParallel: true,
+  retries: 0,
+  expect: { timeout: 15000 },
+  use: {
+    baseURL: "http://localhost:3000",
+    trace: "on-first-retry",
+    headless: true,
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+  ],
+  // Automatically start the dev server before running tests
+  webServer: {
+    command: "bun run dev",
+    url: "http://localhost:3000/studio",
+    reuseExistingServer: true,
+    cwd: "../../../../", // packages/storage-ext root
+  },
+});

package/extensions/storage/studioExtension.json

@@ -0,0 +1 @@
+{}

package/extensions/storage/tests/configs/simple.ts

@@ -0,0 +1,95 @@
+import type { Config } from "@lobb-js/core";
+import storage from "../../index.ts";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+export function createSimpleConfig(storagePath?: string): Config & { storagePath: string } {
+  const resolvedStoragePath = storagePath ?? join(tmpdir(), "lobb_storage_" + crypto.randomUUID());
+  return {
+    storagePath: resolvedStoragePath,
+    project: {
+      name: "Lobb",
+      force_sync: true,
+    },
+    database: {
+      host: "localhost",
+      port: 5432,
+      username: "test",
+      password: "test",
+      database: "*",
+    },
+    web_server: {
+      host: "0.0.0.0",
+      port: 0,
+      cors: {
+        origin: "*",
+      },
+    },
+    extensions: [
+      storage({
+        adapter: "local",
+        storagePath: resolvedStoragePath,
+      }),
+    ],
+    collections: {
+      articles: {
+        indexes: {},
+        fields: {
+          id: {
+            type: "integer",
+          },
+          image: {
+            type: "string",
+            length: 255,
+          },
+          title: {
+            type: "string",
+            length: 255,
+            validators: {
+              required: true,
+            },
+          },
+          description: {
+            type: "string",
+            length: 255,
+          },
+          body: {
+            type: "string",
+            length: 255,
+            validators: {
+              required: true,
+            },
+          },
+          status: {
+            type: "string",
+            length: 255,
+            validators: {
+              enum: ["public", "private"],
+            },
+          },
+        },
+      },
+      comments: {
+        indexes: {},
+        fields: {
+          id: {
+            type: "integer",
+          },
+          body: {
+            type: "string",
+            length: 255,
+            validators: {
+              required: true,
+            },
+          },
+          article_id: {
+            type: "integer",
+            validators: {
+              required: true,
+            },
+          },
+        },
+      },
+    },
+  };
+}

package/extensions/storage/tests/directories.test.ts

@@ -0,0 +1,156 @@
+import { Lobb } from "@lobb-js/core";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { createSimpleConfig } from "./configs/simple.ts";
+
+describe("Directories Operations", () => {
+  let lobb: Lobb;
+  let baseUrl: string;
+  let createdRecordId: number;
+
+  beforeAll(async () => {
+    const config = createSimpleConfig();
+    lobb = await Lobb.init(config);
+    baseUrl = `http://127.0.0.1:${lobb.webServer.port}`;
+  });
+
+  afterAll(async () => {
+    await lobb.close();
+  });
+
+  it("should create a directory successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "test_directory",
+            path: "/",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "test_directory",
+        path: "/",
+        type: "directory",
+      },
+    });
+
+    createdRecordId = data.data.id;
+  });
+
+  it("should prevent creating a directory in a non existing path", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "another_dir",
+            path: "/none_existing_directory",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toEqual({
+      code: "BAD_REQUEST",
+      status: 400,
+      message: "The specified path does not exist. Please create it first.",
+    });
+  });
+
+  it("should respond with the record of the requested directory entry", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdRecordId}`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "test_directory",
+        path: "/",
+        type: "directory",
+      },
+    });
+  });
+
+  it("should list all file system entries", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [
+        {
+          name: "test_directory",
+          path: "/",
+          type: "directory",
+        },
+      ],
+      meta: {
+        totalCount: 1,
+      },
+    });
+  });
+
+  it("should list all file system entries using a filter", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/search`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          filter: {
+            path: {
+              $starts_with: "/",
+            },
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [
+        {
+          name: "test_directory",
+          path: "/",
+          type: "directory",
+        },
+      ],
+      meta: {
+        totalCount: 1,
+      },
+    });
+  });
+
+  it("should delete the directory successully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdRecordId}`,
+      {
+        method: "DELETE",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "test_directory",
+        path: "/",
+        type: "directory",
+      },
+    });
+  });
+});

package/extensions/storage/tests/extraFormData.test.ts

@@ -0,0 +1,47 @@
+import { Lobb } from "@lobb-js/core";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { readFileSync } from "node:fs";
+import { createSimpleConfig } from "./configs/simple.ts";
+
+describe("Extra Form Data", () => {
+  let lobb: Lobb;
+  let baseUrl: string;
+
+  beforeAll(async () => {
+    const config = createSimpleConfig();
+    lobb = await Lobb.init(config);
+    baseUrl = `http://127.0.0.1:${lobb.webServer.port}`;
+  });
+
+  afterAll(async () => {
+    await lobb.close();
+  });
+
+  it("should persist extra form fields alongside the file record", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+
+    const formData = new FormData();
+    formData.append("file", new File([image], "rose.jpeg"));
+    formData.append("icon", "Image");
+
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: formData,
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "rose.jpeg",
+        path: "/",
+        type: "file",
+        icon: "Image",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+  });
+});

package/extensions/storage/tests/files.test.ts

@@ -0,0 +1,292 @@
+import { Lobb } from "@lobb-js/core";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { readFileSync, existsSync } from "node:fs";
+import { createSimpleConfig } from "./configs/simple.ts";
+
+describe("Files Storage", () => {
+  let lobb: Lobb;
+  let baseUrl: string;
+  let storagePath: string;
+  let createdFileId: number;
+
+  beforeAll(async () => {
+    const config = createSimpleConfig();
+    storagePath = config.storagePath;
+    lobb = await Lobb.init(config);
+    baseUrl = `http://127.0.0.1:${lobb.webServer.port}`;
+  });
+
+  afterAll(async () => {
+    await lobb.close();
+  });
+
+  it("should throw an error if no files were provided", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: new FormData(),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toEqual({
+      code: "BAD_REQUEST",
+      status: 400,
+      message: "No files were provided.",
+    });
+  });
+
+  it("should throw an error if more than one file is provided", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const imageFileName = "rose.jpeg";
+
+    const formData = new FormData();
+    formData.append("file", new File([image], imageFileName));
+    formData.append("file", new File([image], imageFileName));
+
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: formData,
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toEqual({
+      code: "BAD_REQUEST",
+      status: 400,
+      message: "Only one file can be uploaded at a time.",
+    });
+  });
+
+  it("should create a file record and upload it successfully", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const imageFileName = "rose.jpeg";
+
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new File([image], imageFileName),
+    );
+
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: formData,
+      },
+    );
+    const result = await response.json();
+
+    createdFileId = result.data.id;
+
+    expect(result).toMatchObject({
+      data: {
+        name: "rose.jpeg",
+        path: "/",
+        type: "file",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+
+    const uploadedFileExists = existsSync(`${storagePath}/${createdFileId}`);
+
+    expect(uploadedFileExists).toBe(true);
+  });
+
+  it("should prevent uploading a file in a non existing path", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const imageFileName = "rose.jpeg";
+
+    const formData = new FormData();
+    formData.append("file", new File([image], imageFileName));
+    formData.append("path", "/some/folder/");
+
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: formData,
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toEqual({
+      code: "BAD_REQUEST",
+      status: 400,
+      message: "The specified path does not exist. Please create it first.",
+    });
+  });
+
+  it("should create a directory successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "test_directory",
+            path: "/",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "test_directory",
+        path: "/",
+        type: "directory",
+      },
+    });
+  });
+
+  it("should respond with the record of the requested file from the file system collection", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "rose.jpeg",
+        path: "/",
+        type: "file",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+  });
+
+  it("should respond with the image itself when you specify the action query into view", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}?action=view`,
+      {
+        method: "GET",
+      },
+    );
+    const headers = response.headers;
+    await response.text();
+
+    expect(headers.get("Content-Type")).toBe("image/jpeg");
+  });
+
+  it("should respond with the image itself and have the (Content-Disposition) header when you specify the action query into download to download it right away if requested from a browser", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}?action=download`,
+      {
+        method: "GET",
+      },
+    );
+    const headers = response.headers;
+    await response.text();
+
+    expect(headers.get("Content-Type")).toBe("image/jpeg");
+
+    expect(
+      headers.get("Content-Disposition"),
+    ).toBe(`attachment; filename="rose.jpeg"`);
+  });
+
+  it("should update the icon of rose.jpeg file successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({
+          data: {
+            icon: "Image",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "rose.jpeg",
+        type: "file",
+        path: "/",
+        icon: "Image",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+  });
+
+  it("should update the name of rose.jpeg file successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({
+          data: {
+            name: "renamed_file_name.txt",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "renamed_file_name.txt",
+        type: "file",
+        path: "/",
+        icon: "Image",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+  });
+
+  it("should prevent updating the record if the specified path didnt exist", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({
+          data: {
+            icon: "Image",
+            path: "/none_existing_path/bla_bla_bla",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toEqual({
+      code: "BAD_REQUEST",
+      status: 400,
+      message: "The specified path does not exist. Please create it first.",
+    });
+  });
+
+  it("should delete the file record and delete the file itself successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${createdFileId}`,
+      {
+        method: "DELETE",
+      },
+    );
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toMatchObject({
+      data: {
+        name: "renamed_file_name.txt",
+        path: "/",
+        type: "file",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+  });
+});