use SQLITE_DATABASE resource type for createStagedUpload

fix tests and lint

Author: jordanverasamy

packages/store/src/apis/admin/index.ts

@@ -14,6 +14,7 @@ import type {ShopDetailsQuery, ShopDetailsQueryVariables} from '../../cli/api/gr
 export async function createStagedUploadAdmin(
   storeFqdn: string,
   input: StagedUploadInput[],
+  version?: string,
 ): Promise<StagedUploadsCreateMutation> {
   const adminSession = await ensureAuthenticatedAdmin(storeFqdn)
 
@@ -23,6 +24,7 @@ export async function createStagedUploadAdmin(
     variables: {
       input,
     },
+    version,
   })
 }
 

packages/store/src/cli/api/graphql/admin/generated/types.d.ts

@@ -232,3 +232,10 @@ export type StagedUploadTargetGenerateUploadResource =
    * [fileCreate mutation](https://shopify.dev/api/admin-graphql/latest/mutations/fileCreate).
    */
   | 'VIDEO'
+  /**
+   * A SQLite database file.
+   *
+   * For example, after uploading the database file, you can use the
+   * bulkDataImportStart mutation to import the data into a Shopify store.
+   */
+  | 'SQLITE_DATABASE'

packages/store/src/services/store/utils/file-uploader.test.ts

@@ -26,7 +26,7 @@ describe('FileUploader', () => {
         stagedTargets: [
           {
             url: 'https://upload.shopify.com/staged',
-            resourceUrl: 'https://shopify.com/resource/123',
+            resourceUrl: 'https://shopify.com/resource/123/',
             parameters: [
               {name: 'key', value: 'uploads/123'},
               {name: 'policy', value: 'policy123'},
@@ -52,17 +52,21 @@ describe('FileUploader', () => {
     test('should successfully upload a valid SQLite file', async () => {
       const result = await fileUploader.uploadSqliteFile(mockFilePath, mockStoreFqdn)
 
-      expect(result).toBe('https://shopify.com/resource/123')
+      expect(result).toBe('https://shopify.com/resource/123/uploads/123')
       expect(readFileSync).toHaveBeenCalledWith(mockFilePath)
-      expect(createStagedUploadAdmin).toHaveBeenCalledWith(mockStoreFqdn, [
-        {
-          resource: 'FILE',
-          filename: 'database.sqlite',
-          mimeType: 'application/x-sqlite3',
-          httpMethod: 'POST',
-          fileSize: '1024',
-        },
-      ])
+      expect(createStagedUploadAdmin).toHaveBeenCalledWith(
+        mockStoreFqdn,
+        [
+          {
+            resource: 'SQLITE_DATABASE',
+            filename: 'database.sqlite',
+            mimeType: 'application/x-sqlite3',
+            httpMethod: 'POST',
+            fileSize: '1024',
+          },
+        ],
+        'unstable',
+      )
       expect(fetch).toHaveBeenCalledWith('https://upload.shopify.com/staged', {
         method: 'POST',
         body: expect.any(FormData),
@@ -103,14 +107,14 @@ describe('FileUploader', () => {
     })
 
     test('should throw error when file is too large', async () => {
-      const largeSize = 30 * 1024 * 1024
+      const largeSize = 400 * 1024 * 1024
       vi.mocked(fileSize).mockResolvedValue(largeSize)
 
       const promise = fileUploader.uploadSqliteFile(mockFilePath, mockStoreFqdn)
       await expect(promise).rejects.toThrow(ValidationError)
       await expect(promise).rejects.toMatchObject({
         code: ErrorCodes.FILE_TOO_LARGE,
-        params: {filePath: mockFilePath, fileSize: '30MB', maxSize: '20MB'},
+        params: {filePath: mockFilePath, fileSize: '400MB', maxSize: '300MB'},
       })
     })
 

packages/store/src/services/store/utils/file-uploader.ts

@@ -5,22 +5,22 @@ import {fileExistsSync, fileSize, isDirectory, readFileSync} from '@shopify/cli-
 import {outputDebug} from '@shopify/cli-kit/node/output'
 
 export class FileUploader {
-  private readonly MAX_FILE_SIZE = 20 * 1024 * 1024
+  private readonly MAX_FILE_SIZE = 300 * 1024 * 1024
 
   async uploadSqliteFile(filePath: string, storeFqdn: string): Promise<string> {
     await this.validateSqliteFile(filePath)
 
     const fileBuffer = readFileSync(filePath)
     const sizeOfFile = await fileSize(filePath)
     const uploadInput: StagedUploadInput = {
-      resource: 'FILE',
+      resource: 'SQLITE_DATABASE',
       filename: 'database.sqlite',
       mimeType: 'application/x-sqlite3',
       httpMethod: 'POST',
       fileSize: sizeOfFile.toString(),
     }
 
-    const stagedUploadResponse = await createStagedUploadAdmin(storeFqdn, [uploadInput])
+    const stagedUploadResponse = await createStagedUploadAdmin(storeFqdn, [uploadInput], 'unstable')
 
     if (!stagedUploadResponse.stagedUploadsCreate?.stagedTargets?.length) {
       throw new OperationError('upload', ErrorCodes.STAGED_UPLOAD_FAILED, {
@@ -42,6 +42,15 @@ export class FileUploader {
       })
     }
 
+    const stagedUploadKeyParam = parameters.find((parameter) => parameter.name === 'key')
+    if (!stagedUploadKeyParam) {
+      throw new OperationError('upload', ErrorCodes.STAGED_UPLOAD_FAILED, {
+        reason: 'Missing key parameter in staged upload target',
+      })
+    }
+
+    const finalResourceUrl = resourceUrl + stagedUploadKeyParam.value
+
     const formData = new FormData()
 
     parameters.forEach((param) => {
@@ -63,7 +72,7 @@ export class FileUploader {
       })
     }
 
-    return resourceUrl
+    return finalResourceUrl
   }
 
   private async validateSqliteFile(filePath: string): Promise<void> {