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

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

@@ -0,0 +1,72 @@
+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("Force Upload", () => {
+  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 fail uploading to a non-existent path without force", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const formData = new FormData();
+    formData.append("file", new Blob([image]), "rose.jpeg");
+    formData.append("path", "/does_not_exist");
+
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      { method: "POST", body: formData },
+    );
+
+    const data = await response.json();
+    expect(data).toMatchObject({ code: "BAD_REQUEST" });
+  });
+
+  it("should upload to a non-existent path with force=true, auto-creating directories", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const formData = new FormData();
+    formData.append("file", new Blob([image]), "rose.jpeg");
+    formData.append("path", "/auto_created/nested");
+
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs?force=true`,
+      { method: "POST", body: formData },
+    );
+
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "rose.jpeg",
+        path: "/auto_created/nested",
+        type: "file",
+      },
+    });
+  });
+
+  it("should have auto-created the directory entries", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs?sort=id`,
+      { method: "GET" },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [
+        { name: "auto_created", path: "/", type: "directory" },
+        { name: "nested", path: "/auto_created/", type: "directory" },
+        { name: "rose.jpeg", path: "/auto_created/nested", type: "file" },
+      ],
+    });
+  });
+});

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

@@ -0,0 +1,189 @@
+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("Mass Remove", () => {
+  let lobb: Lobb;
+  let baseUrl: string;
+  let createdEntriesIds: any[];
+  let fileEntryId: 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();
+  });
+
+  ///////////////////////////
+  // ADDING DEPENDANT DATA //
+  ///////////////////////////
+
+  it("should upload a file successfully", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const imageFileName = "rose.jpeg";
+
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new Blob([image]),
+      imageFileName,
+    );
+    formData.append(
+      "payload",
+      JSON.stringify({
+        data: {},
+      }),
+    );
+
+    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",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+  });
+
+  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",
+      },
+    });
+  });
+
+  ////////////////////////////
+  // Remove MASS OPERATIONS //
+  ////////////////////////////
+
+  it("should list all available entries", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs?sort=id`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [
+        {
+          name: "rose.jpeg",
+          type: "file",
+          path: "/",
+          icon: null,
+          file_mime_type: "image/jpeg",
+          file_size: "1086103",
+        },
+        {
+          name: "test_directory",
+          path: "/",
+          type: "directory",
+          icon: null,
+        },
+      ],
+      meta: {
+        totalCount: 2,
+      },
+    });
+
+    createdEntriesIds = (data.data as any[]).map((el) => el.id);
+    fileEntryId = (data.data as any[]).find((el) => el.type === "file").id;
+  });
+
+  it("should respond with the content of the file", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${fileEntryId}?action=view`,
+      {
+        method: "GET",
+      },
+    );
+    await response.text();
+
+    expect(
+      response.headers.get("content-type"),
+    ).toBe("image/jpeg");
+  });
+
+  it("should remove all entries", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "DELETE",
+        body: JSON.stringify({
+          filter: {
+            id: {
+              $in: createdEntriesIds,
+            },
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      affectedCount: 2,
+    });
+  });
+
+  it("shouldnt be able to get the content of the removed file using deleteMany", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${fileEntryId}?action=view`,
+      {
+        method: "GET",
+      },
+    );
+    await response.json();
+
+    expect(response.status).toBe(404);
+  });
+
+  it("should list an empty array since all entries are removed", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [],
+      meta: {
+        totalCount: 0,
+      },
+    });
+  });
+});

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

@@ -0,0 +1,26 @@
+import { Lobb } from "@lobb-js/core";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { createSimpleConfig } from "./configs/simple.ts";
+
+describe("Meta Operations", () => {
+  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 return true for the refresh token", async () => {
+    const response = await fetch(`${baseUrl}/api/meta`);
+    const data = await response.json();
+    expect(data.extensions.storage).toMatchObject({
+      storageCollectionName: "storage_fs",
+    });
+  });
+});

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

@@ -0,0 +1,208 @@
+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("Recursive Delete Many", () => {
+  let lobb: Lobb;
+  let baseUrl: string;
+  let directoryEntryId: string;
+  let fileEntryId: 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 create a directory successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "test",
+            path: "/",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "test",
+        path: "/",
+        type: "directory",
+      },
+    });
+
+    directoryEntryId = data.data.id;
+  });
+
+  it("should create a directory inside that directory successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "nested_test",
+            path: "/test",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "nested_test",
+        path: "/test",
+        type: "directory",
+      },
+    });
+  });
+
+  it("should upload a file inside the test directory successfully", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const imageFileName = "rose.jpeg";
+
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new Blob([image]),
+      imageFileName,
+    );
+    formData.append("path", "/test/nested_test");
+
+    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: "/test/nested_test",
+        type: "file",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+
+    fileEntryId = data.data.id;
+  });
+
+  it("should list all available entries", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs?sort=id`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [
+        {
+          name: "test",
+          path: "/",
+          type: "directory",
+          icon: null,
+        },
+        {
+          name: "nested_test",
+          path: "/test",
+          type: "directory",
+          icon: null,
+        },
+        {
+          path: "/test/nested_test",
+          name: "rose.jpeg",
+          type: "file",
+          file_mime_type: "image/jpeg",
+          file_size: "1086103",
+          icon: null,
+        },
+      ],
+      meta: {
+        totalCount: 3,
+      },
+    });
+  });
+
+  it("removing the test directory should remove everything inside it too", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "DELETE",
+        body: JSON.stringify({
+          filter: {
+            id: {
+              $in: [directoryEntryId],
+            },
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toEqual({
+      affectedCount: 1,
+    });
+
+    const response1 = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "GET",
+      },
+    );
+    const data1 = await response1.json();
+
+    expect(data1).toMatchObject({
+      data: [],
+      meta: {
+        totalCount: 0,
+      },
+    });
+  });
+
+  it("shouldnt be able to get the content of the removed file using deleteMany", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${fileEntryId}?action=view`,
+      {
+        method: "GET",
+      },
+    );
+    await response.json();
+
+    expect(response.status).toBe(404);
+  });
+
+  it("should list an empty array since all entries are removed", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [],
+      meta: {
+        totalCount: 0,
+      },
+    });
+  });
+});

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

@@ -0,0 +1,206 @@
+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("Recursive Delete One", () => {
+  let lobb: Lobb;
+  let baseUrl: string;
+  let directoryEntryId: string;
+  let fileEntryId: 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 create a directory successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "test",
+            path: "/",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "test",
+        path: "/",
+        type: "directory",
+      },
+    });
+
+    directoryEntryId = data.data.id;
+  });
+
+  it("should create a directory inside that directory successfully", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          data: {
+            name: "nested_test",
+            path: "/test",
+          },
+        }),
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        name: "nested_test",
+        path: "/test",
+        type: "directory",
+      },
+    });
+  });
+
+  it("should upload a file inside the test directory successfully", async () => {
+    const image = readFileSync(import.meta.dirname + "/files/rose.jpeg");
+    const imageFileName = "rose.jpeg";
+
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new Blob([image]),
+      imageFileName,
+    );
+    formData.append("path", "/test/nested_test");
+
+    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: "/test/nested_test",
+        type: "file",
+        file_mime_type: "image/jpeg",
+        file_size: "1086103",
+      },
+    });
+
+    fileEntryId = data.data.id;
+  });
+
+  it("should list all available entries", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs?sort=id`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [
+        {
+          name: "test",
+          path: "/",
+          type: "directory",
+          icon: null,
+        },
+        {
+          name: "nested_test",
+          path: "/test",
+          type: "directory",
+          icon: null,
+        },
+        {
+          path: "/test/nested_test",
+          name: "rose.jpeg",
+          type: "file",
+          icon: null,
+          file_mime_type: "image/jpeg",
+          file_size: "1086103",
+        },
+      ],
+      meta: {
+        totalCount: 3,
+      },
+    });
+  });
+
+  it("removing the test directory should remove everything inside it too", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${directoryEntryId}`,
+      {
+        method: "DELETE",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: {
+        path: "/",
+        name: "test",
+        type: "directory",
+        icon: null,
+      },
+    });
+
+    const response1 = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "GET",
+      },
+    );
+    const data1 = await response1.json();
+
+    expect(data1).toMatchObject({
+      data: [],
+      meta: {
+        totalCount: 0,
+      },
+    });
+  });
+
+  it("shouldnt be able to get the content of the removed file using deleteMany", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs/${fileEntryId}?action=view`,
+      {
+        method: "GET",
+      },
+    );
+    await response.json();
+
+    expect(response.status).toBe(404);
+  });
+
+  it("should list an empty array since all entries are removed", async () => {
+    const response = await fetch(
+      `${baseUrl}/api/collections/storage_fs`,
+      {
+        method: "GET",
+      },
+    );
+    const data = await response.json();
+
+    expect(data).toMatchObject({
+      data: [],
+      meta: {
+        totalCount: 0,
+      },
+    });
+  });
+});

package/extensions/storage/types.ts

@@ -0,0 +1,11 @@
+import type { ExposedServiceOutput, ServiceOp } from "@lobb-js/core";
+
+export type StorageFsCreateOne = ServiceOp<
+  { file: File; data?: { path?: string }; force?: boolean },
+  ExposedServiceOutput
+>;
+
+export type StorageFsFindOne = ServiceOp<
+  { id: string; readFile: boolean },
+  { data: { file_mime_type: string; name: string } | null; file: Uint8Array }
+>;