remove missleading flag

Author: Zetazzz

graphile/graphile-settings/__tests__/upload-resolver.e2e.test.ts

@@ -101,7 +101,6 @@ describe('upload-resolver e2e', () => {
   const uploadedKeys = new Set<string>();
 
   beforeAll(async () => {
-    process.env.UPLOAD_V2_ENABLED = 'true';
     process.env.BUCKET_PROVIDER = 'minio';
     process.env.BUCKET_NAME = BUCKET;
     process.env.AWS_REGION = 'us-east-1';

graphile/graphile-settings/__tests__/upload-resolver.test.ts

@@ -1,31 +1,29 @@
 import { Readable } from 'stream';
 
-interface MockUploadResult {
-  upload: { Location: string };
-  contentType: string;
-}
-
 async function loadUploadResolverModule(opts: {
   detectedContentType: string;
-  uploadResultContentType?: string;
 }) {
   jest.resetModules();
 
-  const mockDetectContentType = jest.fn().mockResolvedValue({
+  const mockStreamContentType = jest.fn().mockResolvedValue({
     stream: Readable.from([Buffer.alloc(16)]),
     magic: { type: opts.detectedContentType, charset: 'binary' },
     contentType: opts.detectedContentType,
   });
 
-  const mockUploadWithContentType = jest.fn().mockResolvedValue({
-    upload: { Location: 'https://cdn.example.com/uploaded-file' },
-    contentType: opts.uploadResultContentType ?? opts.detectedContentType,
-  } as MockUploadResult);
+  const mockUpload = jest.fn().mockResolvedValue({ etag: 'test-etag' });
+  const mockPresignGet = jest.fn().mockResolvedValue('https://cdn.example.com/signed-url');
 
-  const mockUpload = jest.fn().mockResolvedValue({
-    upload: { Location: 'https://cdn.example.com/storage-upload' },
-    contentType: 'application/octet-stream',
-  } as MockUploadResult);
+  const MockS3StorageProvider = jest.fn().mockImplementation(() => ({
+    upload: mockUpload,
+    presignGet: mockPresignGet,
+  }));
+
+  const mockPoolQuery = jest.fn().mockResolvedValue({ rows: [], rowCount: 0 });
+  const MockPool = jest.fn().mockImplementation(() => ({
+    query: mockPoolQuery,
+    end: jest.fn(),
+  }));
 
   jest.doMock('@constructive-io/graphql-env', () => ({
     getEnvOptions: jest.fn(() => ({
@@ -40,25 +38,24 @@ async function loadUploadResolverModule(opts: {
     })),
   }));
 
-  jest.doMock('@constructive-io/s3-streamer', () => {
-    const StreamerMock = jest.fn().mockImplementation(() => ({
-      upload: mockUpload,
-      uploadWithContentType: mockUploadWithContentType,
-      detectContentType: mockDetectContentType,
-    }));
-    return {
-      __esModule: true,
-      default: StreamerMock,
-    };
-  });
+  jest.doMock('@constructive-io/s3-streamer', () => ({
+    __esModule: true,
+    S3StorageProvider: MockS3StorageProvider,
+    streamContentType: mockStreamContentType,
+  }));
+
+  jest.doMock('pg', () => ({
+    Pool: MockPool,
+  }));
 
   const mod = await import('../src/upload-resolver');
 
   return {
     ...mod,
-    mockDetectContentType,
-    mockUploadWithContentType,
+    mockStreamContentType,
     mockUpload,
+    mockPresignGet,
+    mockPoolQuery,
   };
 }
 
@@ -69,12 +66,21 @@ function makeFakeUpload(filename: string) {
   };
 }
 
+function makeFakeContext(databaseId?: string, userId?: string) {
+  return {
+    req: {
+      api: { databaseId },
+      token: { user_id: userId },
+    },
+  };
+}
+
 describe('uploadResolver MIME validation', () => {
   it('rejects disallowed MIME before uploading to storage', async () => {
     const {
       constructiveUploadFieldDefinitions,
-      mockDetectContentType,
-      mockUploadWithContentType,
+      mockStreamContentType,
+      mockUpload,
     } = await loadUploadResolverModule({
       detectedContentType: 'application/pdf',
     });
@@ -92,23 +98,23 @@ describe('uploadResolver MIME validation', () => {
       imageDef.resolve(
         fakeUpload as any,
         {},
-        {},
+        makeFakeContext('1'),
         { uploadPlugin: { tags: {}, type: 'image' } },
       ),
     ).rejects.toThrow('UPLOAD_MIMETYPE');
 
-    expect(mockDetectContentType).toHaveBeenCalledTimes(1);
-    expect(mockUploadWithContentType).not.toHaveBeenCalled();
+    expect(mockStreamContentType).toHaveBeenCalledTimes(1);
+    expect(mockUpload).not.toHaveBeenCalled();
   });
 
   it('uploads and returns image metadata when MIME is allowed', async () => {
     const {
       constructiveUploadFieldDefinitions,
-      mockDetectContentType,
-      mockUploadWithContentType,
+      mockStreamContentType,
+      mockUpload,
+      mockPresignGet,
     } = await loadUploadResolverModule({
       detectedContentType: 'image/png',
-      uploadResultContentType: 'image/png',
     });
 
     const imageDef = constructiveUploadFieldDefinitions.find(
@@ -123,21 +129,44 @@ describe('uploadResolver MIME validation', () => {
     const result = await imageDef.resolve(
       fakeUpload as any,
       {},
-      {},
+      makeFakeContext('1', 'user-123'),
       { uploadPlugin: { tags: {}, type: 'image' } },
     );
 
-    expect(result).toEqual({
-      filename: 'photo.png',
-      mime: 'image/png',
-      url: 'https://cdn.example.com/uploaded-file',
-    });
-    expect(mockDetectContentType).toHaveBeenCalledTimes(1);
-    expect(mockUploadWithContentType).toHaveBeenCalledTimes(1);
-    expect(mockUploadWithContentType).toHaveBeenCalledWith(
+    expect(result).toEqual(
       expect.objectContaining({
-        contentType: 'image/png',
+        filename: 'photo.png',
+        mime: 'image/png',
+        url: 'https://cdn.example.com/signed-url',
+        key: expect.stringMatching(/^1\/default\/[0-9a-f-]+_origin$/),
       }),
     );
+    expect(mockStreamContentType).toHaveBeenCalledTimes(1);
+    expect(mockUpload).toHaveBeenCalledTimes(1);
+    expect(mockPresignGet).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws when databaseId is missing', async () => {
+    const { constructiveUploadFieldDefinitions } = await loadUploadResolverModule({
+      detectedContentType: 'image/png',
+    });
+
+    const imageDef = constructiveUploadFieldDefinitions.find(
+      (def) => 'name' in def && def.name === 'image',
+    );
+    if (!imageDef) {
+      throw new Error('Missing image upload field definition');
+    }
+
+    const fakeUpload = makeFakeUpload('photo.png');
+
+    await expect(
+      imageDef.resolve(
+        fakeUpload as any,
+        {},
+        {}, // no databaseId
+        { uploadPlugin: { tags: {}, type: 'image' } },
+      ),
+    ).rejects.toThrow('databaseId is required');
   });
 });