@galadrim/galadmin 0.1.236 → 0.2.7

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

@@ -0,0 +1,425 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as request from "supertest";
+import { generateUniqueIdForObject } from "../../src/api";
+import { buildAppForManager } from "../helpers/app";
+import { baseConfig, fruitView } from "../helpers/fixtures";
+import {
+  BackendName,
+  DbHarness,
+  describeIntegration,
+  getMysql2Harness,
+  getMysqlHarness,
+  getPgHarness,
+  resetTables,
+} from "./dbHarness";
+
+jest.mock("axios");
+// Explicit factories: the file-based manual mocks in tests/__mocks__/ are not
+// on the integration config's roots. They replicate the same CJS shapes.
+jest.mock("@aws-sdk/client-s3", () => {
+  const send = jest.fn().mockResolvedValue({});
+  return {
+    S3Client: jest.fn(() => ({ send })),
+    PutObjectCommand: jest.fn((input: any) => ({ input })),
+    __send: send,
+  };
+});
+jest.mock("@aws-sdk/s3-request-presigner", () => ({
+  getSignedUrl: jest
+    .fn()
+    .mockResolvedValue("https://signed.example.com/put-object"),
+}));
+jest.mock("@google-cloud/storage", () => {
+  const upload = jest.fn().mockResolvedValue([{}]);
+  const bucket = jest.fn(() => ({ upload }));
+  return {
+    Storage: jest.fn(() => ({ bucket })),
+    __bucket: bucket,
+    __upload: upload,
+  };
+});
+jest.mock("ssh2-sftp-client", () => {
+  const connect = jest.fn().mockResolvedValue(undefined);
+  const fastPut = jest.fn().mockResolvedValue(undefined);
+  const end = jest.fn().mockResolvedValue(undefined);
+  const SftpClient: any = function () {
+    return { connect, fastPut, end };
+  };
+  SftpClient.__sftp = { connect, fastPut, end };
+  return SftpClient;
+});
+
+const PNG_BUFFER = Buffer.from(
+  "89504e470d0a1a0a0000000d49484452000000010000000108" + "0".repeat(64),
+  "hex",
+);
+
+function fileColumn(overrides: any = {}) {
+  return {
+    label: "Image",
+    name: "imageUrl",
+    dataType: "file",
+    ...overrides,
+  };
+}
+
+/**
+ * Upload routes against real engines. The uploads themselves are external
+ * systems (S3 / GCP / SFTP / local fs), so those stay mocked; the real
+ * database provides the schema enrichment and the write-guard context.
+ */
+describeIntegration("upload routes against real databases", () => {
+  const harnesses: Record<BackendName, DbHarness> = {} as any;
+
+  beforeAll(async () => {
+    harnesses.mysql = await getMysqlHarness();
+    harnesses.mysql2 = await getMysql2Harness();
+    harnesses.postgresql = await getPgHarness();
+  });
+
+  afterAll(async () => {
+    await harnesses.mysql?.stop();
+    await harnesses.mysql2?.stop();
+    await harnesses.postgresql?.stop();
+  });
+
+  describe.each([
+    ["mysql", () => harnesses.mysql],
+    ["mysql2", () => harnesses.mysql2],
+    ["postgresql", () => harnesses.postgresql],
+  ])("backend: %s", (_backend, getHarness) => {
+    let harness: DbHarness;
+
+    beforeEach(async () => {
+      harness = getHarness();
+      await resetTables(harness);
+    });
+
+    const appWithColumn = (column: any, role: any = { role: "root", userId: 1 }) => {
+      const config = baseConfig({
+        views: [
+          fruitView({
+            primaryId: "id",
+            columns: [{ label: "Nom", name: "fruitName" }, column],
+          }),
+        ],
+      });
+      const colId = generateUniqueIdForObject(column);
+      return { app: buildAppForManager(harness.manager, config, role), colId };
+    };
+
+    const s3Request = (app: any, colId: string) =>
+      request(app)
+        .post("/api/uploadFile")
+        .query({ viewIndex: 0, columnId: colId })
+        .attach("file", PNG_BUFFER, {
+          filename: "photo.png",
+          contentType: "image/png",
+        });
+
+    describe("S3 backend", () => {
+      it("uploads with a public-read PutObjectCommand and returns the public URL", async () => {
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "AKIA",
+            secretAccessKey: "SECRET",
+            bucket: "my-bucket",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+
+        expect(res.body.originalFilename).toBe("photo.png");
+        expect(res.body.aspectRatio).toBe(1); // PNG_BUFFER is a real 1x1 PNG header
+        expect(res.body.path).toMatch(/^photo-\d+\.png$/);
+        expect(res.body.url).toMatch(
+          /^https:\/\/s3\.example\.com\/my-bucket\/photo-\d+\.png$/,
+        );
+        expect(res.body.url).toBe(
+          `https://s3.example.com/my-bucket/${res.body.path}`,
+        );
+
+        expect(s3Mock.S3Client).toHaveBeenCalledWith(
+          expect.objectContaining({
+            endpoint: "https://s3.example.com",
+            region: undefined,
+            credentials: { accessKeyId: "AKIA", secretAccessKey: "SECRET" },
+          }),
+        );
+        expect(s3Mock.PutObjectCommand).toHaveBeenCalledWith(
+          expect.objectContaining({
+            Bucket: "my-bucket",
+            ContentType: "image/png",
+            ACL: "public-read",
+            Key: res.body.path,
+          }),
+        );
+        const sentCommand = s3Mock.PutObjectCommand.mock.calls[0][0];
+        expect(Buffer.isBuffer(sentCommand.Body)).toBe(true);
+      });
+
+      it("prefixes https:// to hosts missing a scheme", async () => {
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "k",
+            secretAccessKey: "s",
+            bucket: "b",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(200);
+        expect(s3Mock.S3Client).toHaveBeenCalledWith(
+          expect.objectContaining({ endpoint: "https://s3.example.com" }),
+        );
+      });
+
+      it("keeps explicit http schemes untouched", async () => {
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "http://minio.local:9000",
+            accessKeyId: "k",
+            secretAccessKey: "s",
+            bucket: "b",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(200);
+        expect(s3Mock.S3Client).toHaveBeenCalledWith(
+          expect.objectContaining({ endpoint: "http://minio.local:9000" }),
+        );
+      });
+
+      it("uses the signed-URL flow when signedUrlNeeded is set", async () => {
+        const presignerMock = jest.requireMock("@aws-sdk/s3-request-presigner");
+        const axiosMock = jest.requireMock("axios");
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "k",
+            secretAccessKey: "s",
+            bucket: "b",
+            signedUrlNeeded: true,
+            region: "eu-west-3",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+
+        expect(presignerMock.getSignedUrl).toHaveBeenCalledWith(
+          s3Mock.S3Client.mock.results[0].value,
+          expect.objectContaining({
+            input: expect.objectContaining({ Bucket: "b" }),
+          }),
+          { expiresIn: 150 },
+        );
+        expect(axiosMock.put).toHaveBeenCalledWith(
+          "https://signed.example.com/put-object",
+          expect.any(Buffer),
+          expect.objectContaining({
+            headers: { "Content-Type": "image/png" },
+          }),
+        );
+        // signed flow does not expose a public url
+        expect(res.body.url).toBeUndefined();
+        expect(res.body.path).toMatch(/^photo-\d+\.png$/);
+      });
+
+      it("applies pathTransform when provided", async () => {
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "k",
+            secretAccessKey: "s",
+            bucket: "b",
+            pathTransform: (p: string) => `transformed/${p}`,
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+        expect(res.body.path).toMatch(/^transformed\/photo-\d+\.png$/);
+      });
+
+      it("supports a subfolder", async () => {
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "k",
+            secretAccessKey: "s",
+            bucket: "b",
+            subfolder: "images",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+        expect(res.body.path).toMatch(/^images\/photo-\d+\.png$/);
+      });
+
+      it("returns 500 when the S3 upload fails", async () => {
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        s3Mock.__send.mockRejectedValueOnce(new Error("s3 down"));
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "k",
+            secretAccessKey: "s",
+            bucket: "b",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(500);
+      });
+    });
+
+    describe("GCP backend", () => {
+      it("uploads to the bucket and applies pathTransform", async () => {
+        const gcpMock = jest.requireMock("@google-cloud/storage");
+        const column = fileColumn({
+          gcpConfig: {
+            host: "storage.googleapis.com",
+            bucket: "gcp-bucket",
+            pathTransform: (p: string) => `cdn/${p}`,
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+
+        expect(gcpMock.Storage).toHaveBeenCalled();
+        expect(gcpMock.__bucket).toHaveBeenCalledWith("gcp-bucket");
+        expect(gcpMock.__upload).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({
+            destination: expect.stringMatching(/^photo-\d+\.png$/),
+          }),
+        );
+        expect(res.body.path).toMatch(/^cdn\/photo-\d+\.png$/);
+        expect(res.body.aspectRatio).toBe(1); // PNG_BUFFER is a real 1x1 PNG header
+      });
+
+      it("returns 500 when the upload fails", async () => {
+        const gcpMock = jest.requireMock("@google-cloud/storage");
+        gcpMock.__upload.mockRejectedValueOnce(new Error("gcp down"));
+        const column = fileColumn({
+          gcpConfig: { host: "storage.googleapis.com", bucket: "gcp-bucket" },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(500);
+      });
+    });
+
+    describe("SFTP backend", () => {
+      it("requires publicPath", async () => {
+        const column = fileColumn({
+          sftpConfig: { host: "h", user: "u", password: "p" },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(500);
+        expect(res.text).toContain("publicPath");
+      });
+
+      it("fastPuts the temp file to the remote path and cleans it up", async () => {
+        const sftpMock = jest.requireMock("ssh2-sftp-client");
+        const column = fileColumn({
+          publicPath: "/srv/public",
+          subdirectory: "img",
+          sftpConfig: { host: "sftp.example.com", user: "u", password: "p" },
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+
+        expect(sftpMock.__sftp.connect).toHaveBeenCalledWith({
+          host: "sftp.example.com",
+          port: 22,
+          username: "u",
+          password: "p",
+        });
+        const [localPath, remotePath] = sftpMock.__sftp.fastPut.mock.calls[0];
+        expect(path.dirname(remotePath)).toBe("/srv/public/img");
+        expect(path.basename(remotePath)).toBe(path.basename(localPath));
+        expect(res.body).toEqual({
+          path: path.basename(remotePath),
+          originalFilename: "photo.png",
+        });
+        // the temp file is removed after a successful transfer
+        expect(fs.existsSync(localPath)).toBe(false);
+        expect(sftpMock.__sftp.end).toHaveBeenCalled();
+      });
+    });
+
+    describe("local fs backend", () => {
+      let uploadRoot: string;
+
+      beforeEach(() => {
+        uploadRoot = fs.mkdtempSync(path.join(os.tmpdir(), "galadmin-upload-"));
+        fs.mkdirSync(path.join(uploadRoot, "sub"));
+      });
+
+      afterEach(() => {
+        fs.rmSync(uploadRoot, { recursive: true, force: true });
+      });
+
+      it("stores the file under publicPath + subdirectory and returns the relative path", async () => {
+        const column = fileColumn({
+          publicPath: uploadRoot,
+          subdirectory: "/sub",
+        });
+        const { app, colId } = appWithColumn(column);
+        const res = await s3Request(app, colId).expect(200);
+        // the local backend keeps multiparty's random temp filename (not the
+        // original one) — documented behavior
+        expect(res.body.path).toMatch(/^\/sub\/[A-Za-z0-9_-]+\.png$/);
+        expect(res.body.originalFilename).toBe("photo.png");
+        const stored = path.join(uploadRoot, res.body.path);
+        expect(fs.existsSync(stored)).toBe(true);
+      });
+
+      it("fails without a subdirectory (publicPath + undefined concat — documented quirk)", async () => {
+        // uploadDir becomes "<publicPath>undefined", which never exists, so
+        // the multipart parse fails with 500. A subdirectory is effectively
+        // required for the local backend.
+        const column = fileColumn({ publicPath: uploadRoot });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(500);
+      });
+    });
+
+    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 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",
+          })
+          .expect(200);
+        expect(s3Mock.PutObjectCommand).toHaveBeenCalledWith(
+          expect.objectContaining({ Bucket: "b" }),
+        );
+        expect(res.body.path).toMatch(/^photo-\d+\.png$/);
+      });
+    });
+  });
+});

package/tests/setup/silence-console.ts

@@ -0,0 +1,15 @@
+const noop = () => {};
+
+const originalError = console.error;
+const originalLog = console.log;
+
+beforeEach(() => {
+  if (process.env.TEST_VERBOSE) return;
+  console.error = noop;
+  console.log = noop;
+});
+
+afterEach(() => {
+  console.error = originalError;
+  console.log = originalLog;
+});