@edgestore/server 0.1.1 → 0.1.3-alpha.0

package/src/adapters/index.ts

@@ -0,0 +1,6 @@
+export type {
+  InitRes,
+  RequestUploadRes,
+  RequestUploadPartsRes,
+  DeleteFileRes,
+} from './shared';

package/src/adapters/next/app/index.ts

@@ -7,10 +7,14 @@ import { EdgeStoreProvider } from '../../../providers/edgestore';
 import { type Provider } from '../../../providers/types';
 import { type MaybePromise } from '../../../types';
 import {
+  completeMultipartUpload,
+  confirmUpload,
   deleteFile,
   init,
   requestUpload,
   requestUploadParts,
+  type CompleteMultipartUploadBody,
+  type ConfirmUploadBody,
   type DeleteFileBody,
   type RequestUploadBody,
   type RequestUploadPartsParams,
@@ -45,7 +49,7 @@ export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
           provider,
           router: config.router,
         });
-        return new Response(
+        const res = new Response(
           JSON.stringify({
             token,
             baseUrl,
@@ -54,10 +58,13 @@ export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
             status: 200,
             headers: {
               'Content-Type': 'application/json',
-              'Set-Cookie': newCookies.join('; '),
             },
           },
         );
+        for (const cookie of newCookies) {
+          res.headers.append('Set-Cookie', cookie);
+        }
+        return res;
       } else if (req.nextUrl.pathname === '/api/edgestore/request-upload') {
         const res = await requestUpload({
           provider,
@@ -86,6 +93,28 @@ export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
             'Content-Type': 'application/json',
           },
         });
+      } else if (
+        req.nextUrl.pathname === '/api/edgestore/complete-multipart-upload'
+      ) {
+        await completeMultipartUpload({
+          provider,
+          router: config.router,
+          body: (await req.json()) as CompleteMultipartUploadBody,
+          ctxToken: req.cookies.get('edgestore-ctx')?.value,
+        });
+        return new Response(null, {
+          status: 200,
+        });
+      } else if (req.nextUrl.pathname === '/api/edgestore/confirm-upload') {
+        await confirmUpload({
+          provider,
+          router: config.router,
+          body: (await req.json()) as ConfirmUploadBody,
+          ctxToken: req.cookies.get('edgestore-ctx')?.value,
+        });
+        return new Response(null, {
+          status: 200,
+        });
       } else if (req.nextUrl.pathname === '/api/edgestore/delete-file') {
         await deleteFile({
           provider,

package/src/adapters/next/pages/index.ts

@@ -7,10 +7,14 @@ import { EdgeStoreProvider } from '../../../providers/edgestore';
 import { type Provider } from '../../../providers/types';
 import { type MaybePromise } from '../../../types';
 import {
+  completeMultipartUpload,
+  confirmUpload,
   deleteFile,
   init,
   requestUpload,
   requestUploadParts,
+  type CompleteMultipartUploadBody,
+  type ConfirmUploadBody,
   type DeleteFileBody,
   type RequestUploadBody,
   type RequestUploadPartsParams,
@@ -69,6 +73,22 @@ export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
             ctxToken: req.cookies['edgestore-ctx'],
           }),
         );
+      } else if (req.url === '/api/edgestore/complete-multipart-upload') {
+        await completeMultipartUpload({
+          provider,
+          router: config.router,
+          body: req.body as CompleteMultipartUploadBody,
+          ctxToken: req.cookies['edgestore-ctx'],
+        });
+        res.status(200).end();
+      } else if (req.url === '/api/edgestore/confirm-upload') {
+        await confirmUpload({
+          provider,
+          router: config.router,
+          body: req.body as ConfirmUploadBody,
+          ctxToken: req.cookies['edgestore-ctx'],
+        });
+        res.status(200).end();
       } else if (req.url === '/api/edgestore/delete-file') {
         await deleteFile({
           provider,

package/src/adapters/shared.ts

@@ -56,6 +56,7 @@ export type RequestUploadBody = {
     extension: string;
     fileName?: string;
     replaceTargetUrl?: string;
+    temporary: boolean;
   };
 };
 
@@ -93,6 +94,7 @@ export async function requestUpload<TCtx>(params: {
         fileName: fileInfo.fileName,
         extension: fileInfo.extension,
         replaceTargetUrl: fileInfo.replaceTargetUrl,
+        temporary: fileInfo.temporary,
       },
     });
     if (!canUpload) {
@@ -206,6 +208,82 @@ export async function requestUploadParts<TCtx>(params: {
   });
 }
 
+export type CompleteMultipartUploadBody = {
+  bucketName: string;
+  uploadId: string;
+  key: string;
+  parts: {
+    partNumber: number;
+    eTag: string;
+  }[];
+};
+
+export async function completeMultipartUpload<TCtx>(params: {
+  provider: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  ctxToken: string | undefined;
+  body: CompleteMultipartUploadBody;
+}) {
+  const {
+    provider,
+    router,
+    ctxToken,
+    body: { bucketName, uploadId, key, parts },
+  } = params;
+  if (!ctxToken) {
+    throw new EdgeStoreError({
+      message: 'Missing edgestore-ctx cookie',
+      code: 'UNAUTHORIZED',
+    });
+  }
+  await getContext(ctxToken); // just to check if the token is valid
+  const bucket = router.buckets[bucketName];
+  if (!bucket) {
+    throw new Error(`Bucket ${bucketName} not found`);
+  }
+  return await provider.completeMultipartUpload({
+    uploadId,
+    key,
+    parts,
+  });
+}
+
+export type ConfirmUploadBody = {
+  bucketName: string;
+  url: string;
+};
+
+export async function confirmUpload<TCtx>(params: {
+  provider: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  ctxToken: string | undefined;
+  body: ConfirmUploadBody;
+}) {
+  const {
+    provider,
+    router,
+    ctxToken,
+    body: { bucketName, url },
+  } = params;
+
+  if (!ctxToken) {
+    throw new EdgeStoreError({
+      message: 'Missing edgestore-ctx cookie',
+      code: 'UNAUTHORIZED',
+    });
+  }
+  await getContext(ctxToken); // just to check if the token is valid
+  const bucket = router.buckets[bucketName];
+  if (!bucket) {
+    throw new Error(`Bucket ${bucketName} not found`);
+  }
+
+  await provider.confirmUpload({
+    bucket,
+    url,
+  });
+}
+
 export type DeleteFileBody = {
   bucketName: string;
   url: string;
@@ -339,3 +417,10 @@ async function getContext(token?: string) {
   }
   return await decryptJWT(token);
 }
+
+export type InitRes = Awaited<ReturnType<typeof init>>;
+export type RequestUploadRes = Awaited<ReturnType<typeof requestUpload>>;
+export type RequestUploadPartsRes = Awaited<
+  ReturnType<typeof requestUploadParts>
+>;
+export type DeleteFileRes = Awaited<ReturnType<typeof deleteFile>>;

package/src/core/client/index.ts

@@ -77,6 +77,10 @@ type EdgeStoreClient<TRouter extends AnyRouter> = {
     //   uploadUrl: string;
     //   accessUrl: string;
     // }>;
+    /**
+     * Confirm a temporary file upload.
+     */
+    confirmUpload: (params: { url: string }) => Promise<{ success: boolean }>;
     /**
      * Programmatically delete a file.
      */
@@ -168,10 +172,12 @@ export function initEdgeStoreClient<TRouter extends AnyRouter>(config: {
         //   });
         // },
 
+        async confirmUpload(params) {
+          return await sdk.confirmUpload(params);
+        },
+
         async deleteFile(params) {
-          return await sdk.deleteFile({
-            ...params,
-          });
+          return await sdk.deleteFile(params);
         },
 
         async listFiles(params) {

package/src/core/internals/bucketBuilder.ts

@@ -117,6 +117,7 @@ type FileInfo = {
   extension: string;
   fileName?: string;
   replaceTargetUrl?: string;
+  temporary: boolean;
 };
 
 type BeforeUploadFn<TCtx, TDef extends AnyDef> = (params: {

package/src/core/sdk/index.ts

@@ -17,6 +17,7 @@ type FileInfoForUpload = {
   metadata: AnyMetadata;
   fileName?: string;
   replaceTargetUrl?: string;
+  temporary: boolean;
 };
 
 export type SimpleOperator =
@@ -162,6 +163,7 @@ export const edgeStoreRawSdk = {
   }) {
     const res = await makeRequest<{
       multipart?: {
+        key: string;
         uploadId: string;
         parts: {
           partNumber: number;
@@ -170,6 +172,8 @@ export const edgeStoreRawSdk = {
       };
       signedUrl?: string;
       url: string;
+      path: string;
+      thumbnailUrl: string | null;
     }>({
       path: '/request-upload',
       accessKey,
@@ -186,12 +190,15 @@ export const edgeStoreRawSdk = {
         metadata: fileInfo.metadata,
         fileName: fileInfo.fileName,
         replaceTargetUrl: fileInfo.replaceTargetUrl,
+        isTemporary: fileInfo.temporary,
       },
     });
     return {
       multipart: res.multipart,
       signedUrl: res.signedUrl,
       accessUrl: res.url,
+      path: res.path,
+      thumbnailUrl: res.thumbnailUrl,
     };
   },
 
@@ -231,6 +238,53 @@ export const edgeStoreRawSdk = {
     };
   },
 
+  async completeMultipartUpload({
+    accessKey,
+    secretKey,
+    uploadId,
+    key,
+    parts,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    uploadId: string;
+    key: string;
+    parts: {
+      partNumber: number;
+      eTag: string;
+    }[];
+  }) {
+    return await makeRequest<{ success: boolean }>({
+      path: '/complete-multipart-upload',
+      accessKey,
+      secretKey,
+      body: {
+        uploadId,
+        key,
+        parts,
+      },
+    });
+  },
+
+  async confirmUpload({
+    accessKey,
+    secretKey,
+    url,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    url: string;
+  }) {
+    return await makeRequest<{ success: boolean }>({
+      path: '/confirm-upload',
+      accessKey,
+      secretKey,
+      body: {
+        url,
+      },
+    });
+  },
+
   async deleteFile({
     accessKey,
     secretKey,
@@ -359,6 +413,33 @@ export function initEdgeStoreSdk(params: {
         multipart,
       });
     },
+    async completeMultipartUpload({
+      uploadId,
+      key,
+      parts,
+    }: {
+      uploadId: string;
+      key: string;
+      parts: {
+        partNumber: number;
+        eTag: string;
+      }[];
+    }) {
+      return await edgeStoreRawSdk.completeMultipartUpload({
+        accessKey,
+        secretKey,
+        uploadId,
+        key,
+        parts,
+      });
+    },
+    async confirmUpload({ url }: { url: string }) {
+      return await edgeStoreRawSdk.confirmUpload({
+        accessKey,
+        secretKey,
+        url,
+      });
+    },
     async deleteFile({ url }: { url: string }) {
       return await edgeStoreRawSdk.deleteFile({
         accessKey,

package/src/providers/aws/index.ts

@@ -121,6 +121,12 @@ export function AWSProvider(options?: AWSProviderOptions): Provider {
     async requestUploadParts() {
       throw new Error('Not implemented');
     },
+    async completeMultipartUpload() {
+      throw new Error('Not implemented');
+    },
+    async confirmUpload() {
+      throw new Error('Not implemented');
+    },
     async deleteFile({ url }) {
       const path = url.replace(`${baseUrl}/`, '');
       await s3Client.send(

package/src/providers/edgestore/index.ts

@@ -66,31 +66,29 @@ export function EdgeStoreProvider(
       bucketType,
       fileInfo,
     }): Promise<RequestUploadRes> {
-      // multiplart upload if file is bigger than a certain size
+      // multipart upload if file is bigger than a certain size
       const MULTIPART_THRESHOLD = 10 * 1024 * 1024; // 10MB
-      const CONCURRENCY = 3;
       let partSize = 5 * 1024 * 1024; // 5MB
       if (fileInfo.size > MULTIPART_THRESHOLD) {
         let totalParts = Math.ceil(fileInfo.size / partSize);
-        if (totalParts > 10000) {
-          // the maximum number of parts is 10000
-          totalParts = 10000;
+        if (totalParts > 1000) {
+          // the maximum number of parts is 1000
+          totalParts = 1000;
           partSize = Math.ceil(fileInfo.size / totalParts);
         }
-        const requestParts =
-          totalParts > CONCURRENCY ? CONCURRENCY : totalParts;
         const res = await edgeStoreSdk.requestUpload({
           bucketName,
           bucketType,
           fileInfo,
           multipart: {
-            parts: Array.from({ length: requestParts }).map(
+            parts: Array.from({ length: totalParts }).map(
               (_, index) => index + 1,
             ),
           },
         });
         const multipart = res.multipart
           ? {
+              key: res.multipart.key,
               uploadId: res.multipart.uploadId,
               parts: res.multipart.parts.map((part) => ({
                 partNumber: part.partNumber,
@@ -103,12 +101,14 @@ export function EdgeStoreProvider(
         if (multipart) {
           return {
             accessUrl: res.accessUrl,
+            thumbnailUrl: res.thumbnailUrl,
             multipart,
           };
         } else if (res.signedUrl) {
           return {
             accessUrl: res.accessUrl,
             uploadUrl: res.signedUrl,
+            thumbnailUrl: res.thumbnailUrl,
           };
         } else {
           throw new Error('Could not get upload url');
@@ -123,6 +123,7 @@ export function EdgeStoreProvider(
         return {
           accessUrl: res.accessUrl,
           uploadUrl: res.signedUrl,
+          thumbnailUrl: res.thumbnailUrl,
         };
       }
       throw new Error('Could not get upload url');
@@ -142,6 +143,18 @@ export function EdgeStoreProvider(
         },
       };
     },
+    completeMultipartUpload: async ({ uploadId, key, parts }) => {
+      return await edgeStoreSdk.completeMultipartUpload({
+        uploadId,
+        key,
+        parts,
+      });
+    },
+    confirmUpload: async ({ url }) => {
+      return await edgeStoreSdk.confirmUpload({
+        url,
+      });
+    },
     deleteFile: async ({ url }) => {
       return await edgeStoreSdk.deleteFile({
         url,

package/src/providers/index.ts

@@ -1,2 +1 @@
-export * from './aws';
-export * from './edgestore';
+export * from './types';

package/src/providers/types.ts

@@ -47,6 +47,7 @@ export type RequestUploadParams = {
     }[];
     metadata: AnyMetadata;
     replaceTargetUrl?: string;
+    temporary: boolean;
   };
 };
 
@@ -68,13 +69,28 @@ export type RequestUploadPartsRes = {
   };
 };
 
+export type CompleteMultipartUploadParams = {
+  uploadId: string;
+  key: string;
+  parts: {
+    partNumber: number;
+    eTag: string;
+  }[];
+};
+
+export type CompleteMultipartUploadRes = {
+  success: boolean;
+};
+
 export type RequestUploadRes =
   | {
       uploadUrl: string;
       accessUrl: string;
+      thumbnailUrl?: string | null;
     }
   | {
       multipart: {
+        key: string;
         uploadId: string;
         partSize: number;
         totalParts: number;
@@ -84,8 +100,18 @@ export type RequestUploadRes =
         }[];
       };
       accessUrl: string;
+      thumbnailUrl?: string | null;
     };
 
+export type ConfirmUpload = {
+  bucket: AnyBuilder;
+  url: string;
+};
+
+export type ConfirmUploadRes = {
+  success: boolean;
+};
+
 export type DeleteFileParams = {
   bucket: AnyBuilder;
   url: string;
@@ -105,5 +131,9 @@ export type Provider = {
   requestUploadParts: (
     params: RequestUploadPartsParams,
   ) => MaybePromise<RequestUploadPartsRes>;
+  completeMultipartUpload: (
+    params: CompleteMultipartUploadParams,
+  ) => MaybePromise<CompleteMultipartUploadRes>;
+  confirmUpload: (params: ConfirmUpload) => MaybePromise<ConfirmUploadRes>;
   deleteFile: (params: DeleteFileParams) => MaybePromise<DeleteFileRes>;
 };