@galadrim/galadmin 0.2.8 → 0.2.9

package/src/front/src/components/inputs/BetterRichTextInput.js

@@ -1,10 +1,13 @@
 import { useState } from "react";
 import Editor from "ckeditor5-custom-build"
 import { CKEditor } from '@ckeditor/ckeditor5-react'
+import { useParams } from "react-router-dom";
 
 const baseURL = process.env.NODE_ENV === "development" ? 'http://localhost/admin/api' : '/_HOMEPAGE_/api';
 
 export default ({ column, onChange, initialData }) => {
+    const { viewIndex } = useParams();
+    const uploadTarget = new URLSearchParams({ viewIndex, columnId: column.__id__ });
     const [characters, setCharacters] = useState(0);
     const [words, setWords] = useState(0);
 
@@ -14,11 +17,8 @@ export default ({ column, onChange, initialData }) => {
                 editor={Editor}
                 config={{
                     simpleUpload: {
-                        uploadUrl: `${baseURL}/uploadFileFromBetterRichTextInput`,
+                        uploadUrl: `${baseURL}/uploadFileFromBetterRichTextInput?${uploadTarget}`,
                         withCredentials: true,
-                        headers: {
-                            "file-upload-properties": JSON.stringify(column.fileUploadProperties)
-                        }
                     },
                     wordCount: {
                         onUpdate: stats => {

package/src/front/src/components/inputs/BetterRichTextInput.test.js

@@ -0,0 +1,32 @@
+import { render } from "@testing-library/react";
+import { MemoryRouter, Route } from "react-router-dom";
+import BetterRichTextInput from "./BetterRichTextInput";
+import { CKEditor } from "@ckeditor/ckeditor5-react";
+
+jest.mock("ckeditor5-custom-build", () => ({}));
+jest.mock("@ckeditor/ckeditor5-react", () => ({ CKEditor: jest.fn(() => null) }));
+
+it("identifies the selected server column without sending storage settings", () => {
+  CKEditor.mockImplementation(() => null);
+  const column = {
+    __id__: "panel-column&1", htmlField: "body",
+    fileUploadProperties: { s3Config: { secretAccessKey: "server-secret" } },
+  };
+  render(
+    <MemoryRouter initialEntries={["/records/2/1"]}>
+      <Route path="/records/:viewIndex/:recordId">
+        <BetterRichTextInput column={column} initialData={{ body: "Hello" }} onChange={() => {}} />
+      </Route>
+    </MemoryRouter>,
+  );
+  const { config, data } = CKEditor.mock.calls[0][0];
+  const upload = config.simpleUpload;
+  const url = new URL(upload.uploadUrl, "http://localhost");
+  expect(url.pathname).toMatch(/\/uploadFileFromBetterRichTextInput$/);
+  expect(url.searchParams.get("viewIndex")).toBe("2");
+  expect(url.searchParams.get("columnId")).toBe(column.__id__);
+  expect(upload.withCredentials).toBe(true);
+  expect(upload.headers).toBeUndefined();
+  expect(upload.uploadUrl).not.toContain("server-secret");
+  expect(data).toBe("Hello");
+});

package/tests/integration/routes.authorization.integration.test.ts

@@ -207,9 +207,7 @@ describeIntegration("authorization against real databases", () => {
     });
 
     it("/uploadFileFromBetterRichTextInput: read-only role gets 403 before any upload happens", async () => {
-      // This endpoint carries no viewIndex: the upload target comes entirely
-      // from the client-supplied file-upload-properties header, so it is
-      // gated on the caller being able to write at least one view.
+      // The selected view must be writable before multipart data is processed.
       const config = baseConfig({
         views: [fruitView({ roles: ["editor"], readRoles: ["viewer"] })],
       });
@@ -220,6 +218,7 @@ describeIntegration("authorization against real databases", () => {
       try {
         await request(app(config, VIEWER))
           .post("/api/uploadFileFromBetterRichTextInput")
+          .query({ viewIndex: 0, columnId: "rich-text" })
           .set(
             "file-upload-properties",
             JSON.stringify({ publicPath: uploadRoot, subdirectory: "/sub" }),

package/tests/integration/routes.upload.integration.test.ts

@@ -391,34 +391,123 @@ describeIntegration("upload routes against real databases", () => {
     });
 
     describe("POST /api/uploadFileFromBetterRichTextInput", () => {
-      it("takes the upload config from the file-upload-properties header", async () => {
-        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
-        const app = buildAppForManager(
-          harness.manager,
-          baseConfig({ views: [fruitView({ primaryId: "id" })] }),
-        );
+      const richColumn = (overrides: any = {}) => ({
+        label: "Body", dataType: "betterRichText", htmlField: "note",
+        fileUploadProperties: {
+          s3Config: {
+            host: "s3.example.com", accessKeyId: "k", secretAccessKey: "s",
+            bucket: "configured-bucket", subfolder: "editor",
+            pathTransform: (p: string) => `https://cdn.example.com/${p}`,
+          },
+        },
+        ...overrides,
+      });
+      const upload = (app: any, query: any) => request(app)
+        .post("/api/uploadFileFromBetterRichTextInput")
+        .query(query)
+        .attach("upload", PNG_BUFFER, { filename: "photo.png", contentType: "image/png" });
+      const expectNoStorage = () => {
+        expect(jest.requireMock("@aws-sdk/client-s3").__send).not.toHaveBeenCalled();
+        expect(jest.requireMock("@google-cloud/storage").__upload).not.toHaveBeenCalled();
+      };
+
+      it("uses the configured S3 transform and ignores client storage settings", async () => {
+        const column = richColumn();
+        const { app, colId } = appWithColumn(column);
         const res = await request(app)
           .post("/api/uploadFileFromBetterRichTextInput")
-          .set(
-            "file-upload-properties",
-            JSON.stringify({
-              s3Config: {
-                host: "s3.example.com",
-                accessKeyId: "k",
-                secretAccessKey: "s",
-                bucket: "b",
-              },
-            }),
-          )
-          .attach("upload", PNG_BUFFER, {
-            filename: "photo.png",
-            contentType: "image/png",
-          })
+          .query({ viewIndex: 0, columnId: colId })
+          .set("file-upload-properties", JSON.stringify({ s3Config: { bucket: "attacker-bucket" } }))
+          .attach("upload", PNG_BUFFER, { filename: "photo.png", contentType: "image/png" })
           .expect(200);
-        expect(s3Mock.PutObjectCommand).toHaveBeenCalledWith(
-          expect.objectContaining({ Bucket: "b" }),
-        );
-        expect(res.body.path).toMatch(/^photo-\d+\.png$/);
+        const s3 = jest.requireMock("@aws-sdk/client-s3");
+        const key = s3.PutObjectCommand.mock.calls[0][0].Key;
+        expect(key).toMatch(/^editor\/photo-\d+\.png$/);
+        expect(s3.PutObjectCommand).toHaveBeenCalledWith(expect.objectContaining({ Bucket: "configured-bucket" }));
+        expect(res.body).toEqual({
+          path: `https://cdn.example.com/${key}`,
+          url: `https://s3.example.com/configured-bucket/${key}`,
+          aspectRatio: 1, originalFilename: "photo.png",
+        });
+      });
+
+      it("keeps GCP pathTransform on the server, even with a malformed legacy header", async () => {
+        const column = richColumn({ fileUploadProperties: { gcpConfig: {
+          host: "storage.googleapis.com", bucket: "configured-gcp", subfolder: "editor",
+          pathTransform: (p: string) => `https://cdn.example.com/${p}`,
+        } } });
+        const { app, colId } = appWithColumn(column);
+        const res = await request(app)
+          .post("/api/uploadFileFromBetterRichTextInput")
+          .query({ viewIndex: 0, columnId: colId })
+          .set("file-upload-properties", "not JSON")
+          .attach("upload", PNG_BUFFER, { filename: "photo.png", contentType: "image/png" })
+          .expect(200);
+        const gcp = jest.requireMock("@google-cloud/storage");
+        expect(gcp.__bucket).toHaveBeenCalledWith("configured-gcp");
+        const destination = gcp.__upload.mock.calls[0][1].destination;
+        expect(destination).toMatch(/^editor\/photo-\d+\.png$/);
+        expect(res.body.path).toBe(`https://cdn.example.com/${destination}`);
+      });
+
+      it("resolves a panel creation column", async () => {
+        const column = richColumn();
+        const app = buildAppForManager(harness.manager, baseConfig({ views: [fruitView({
+          recordViewPanels: [{ type: "table", label: "Notes", query: "SELECT * FROM fruit_notes",
+            createConfig: { tableName: "fruit_notes", recordIdKey: "fruitId", columns: [column] } }],
+        })] }));
+        const res = await upload(app, { viewIndex: 0, columnId: generateUniqueIdForObject(column) }).expect(200);
+        expect(res.body.path).toMatch(/^https:\/\/cdn.example.com\/editor\/photo-\d+\.png$/);
+      });
+
+      it.each([
+        {}, { viewIndex: 0 }, { viewIndex: 99, columnId: "missing" },
+        { viewIndex: "__proto__", columnId: "missing" },
+        { viewIndex: 0, columnId: "missing" }, { viewIndex: [0, 1], columnId: "missing" },
+      ])("rejects an invalid target before storage: %j", async (query) => {
+        const { app } = appWithColumn(richColumn());
+        await upload(app, query).expect(403);
+        expectNoStorage();
+      });
+
+      it.each([
+        { label: "Text", name: "note" },
+        { label: "Body", dataType: "betterRichText", htmlField: "note" },
+      ])("rejects a column without rich-text upload settings: %j", async (column) => {
+        const { app, colId } = appWithColumn(column);
+        await upload(app, { viewIndex: 0, columnId: colId }).expect(400);
+        expectNoStorage();
+      });
+
+      it("does not authorize a read-only target merely because another view is writable", async () => {
+        const column = richColumn();
+        const app = buildAppForManager(harness.manager, baseConfig({ views: [
+          fruitView({ roles: ["editor"], readRoles: ["viewer"], columns: [column] }),
+          fruitView({ roles: ["viewer"] }),
+        ] }), { role: "viewer" });
+        await upload(app, { viewIndex: 0, columnId: generateUniqueIdForObject(column) }).expect(403);
+        expectNoStorage();
+      });
+
+      it.each([false, true])("rejects a role-restricted column (panel: %s)", async (panel) => {
+        const column = richColumn({ roles: ["editor"] });
+        const view = fruitView(panel ? {
+          recordViewPanels: [{ type: "table", label: "Notes", query: "SELECT * FROM fruit_notes",
+            createConfig: { tableName: "fruit_notes", recordIdKey: "fruitId", columns: [column] } }],
+        } : { columns: [column] });
+        const app = buildAppForManager(harness.manager, baseConfig({ views: [view] }), { role: "viewer" });
+        await upload(app, { viewIndex: 0, columnId: generateUniqueIdForObject(column) }).expect(403);
+        expectNoStorage();
+      });
+
+      it("uses indexes from the role-filtered views", async () => {
+        const column = richColumn();
+        const app = buildAppForManager(harness.manager, baseConfig({ views: [
+          fruitView({ roles: ["other"] }),
+          fruitView({ roles: ["editor"], columns: [column] }),
+        ] }), { role: "editor" });
+        const res = await upload(app, { viewIndex: 0, columnId: generateUniqueIdForObject(column) }).expect(200);
+        expect(res.body.path).toMatch(/^https:\/\/cdn.example.com\//);
       });
     });
   });