@edgestore/server 0.1.5-alpha.0 → 0.1.5-alpha.10

package/dist/{shared-9fad0d51.js → shared-d474acc6.js}

@@ -2,19 +2,7 @@ import { hkdf } from '@panva/hkdf';
 import { serialize } from 'cookie';
 import { EncryptJWT, jwtDecrypt } from 'jose';
 import { v4 } from 'uuid';
-
-const EDGE_STORE_ERROR_CODES = {
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-};
-class EdgeStoreError extends Error {
-    constructor(opts) {
-        super(opts.message);
-        this.name = 'EdgeStoreError';
-        this.code = opts.code;
-        this.cause = opts.cause;
-    }
-}
+import { E as EdgeStoreError } from './index-0c401ce1.js';
 
 const IMAGE_MIME_TYPES = [
     'image/jpeg',
@@ -30,7 +18,9 @@ const IMAGE_MIME_TYPES = [
 // TODO: change it to 1 hour when we have a way to refresh the token
 const DEFAULT_MAX_AGE = 30 * 24 * 60 * 60; // 30 days
 async function init(params) {
+    const log = globalThis._EDGE_STORE_LOGGER;
     const { ctx, provider, router } = params;
+    log.debug('Running [init]', { ctx });
     const ctxToken = await encryptJWT(ctx);
     const { token } = await provider.init({
         ctx,
@@ -49,6 +39,7 @@ async function init(params) {
         }));
     }
     const baseUrl = await provider.getBaseUrl();
+    log.debug('Finished [init]', { ctx, newCookies, token, baseUrl });
     return {
         newCookies,
         token,
@@ -57,6 +48,8 @@ async function init(params) {
 }
 async function requestUpload(params) {
     const { provider, router, ctxToken, body: { bucketName, input, fileInfo }, } = params;
+    const log = globalThis._EDGE_STORE_LOGGER;
+    log.debug('Running [requestUpload]', { bucketName, input, fileInfo });
     if (!ctxToken) {
         throw new EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
@@ -64,11 +57,16 @@ async function requestUpload(params) {
         });
     }
     const ctx = await getContext(ctxToken);
+    log.debug('Decrypted Context', { ctx });
     const bucket = router.buckets[bucketName];
     if (!bucket) {
-        throw new Error(`Bucket ${bucketName} not found`);
+        throw new EdgeStoreError({
+            message: `Bucket ${bucketName} not found`,
+            code: 'BAD_REQUEST',
+        });
     }
     if (bucket._def.beforeUpload) {
+        log.debug('Running [beforeUpload]');
         const canUpload = await bucket._def.beforeUpload?.({
             ctx,
             input,
@@ -81,23 +79,35 @@ async function requestUpload(params) {
                 temporary: fileInfo.temporary,
             },
         });
+        log.debug('Finished [beforeUpload]', { canUpload });
         if (!canUpload) {
-            throw new Error('Upload not allowed');
+            throw new EdgeStoreError({
+                message: 'Upload not allowed for the current context',
+                code: 'UPLOAD_NOT_ALLOWED',
+            });
         }
     }
     if (bucket._def.type === 'IMAGE') {
         if (!IMAGE_MIME_TYPES.includes(fileInfo.type)) {
             throw new EdgeStoreError({
-                code: 'BAD_REQUEST',
+                code: 'MIME_TYPE_NOT_ALLOWED',
                 message: 'Only images are allowed in this bucket',
+                details: {
+                    allowedMimeTypes: IMAGE_MIME_TYPES,
+                    mimeType: fileInfo.type,
+                },
             });
         }
     }
     if (bucket._def.bucketConfig?.maxSize) {
         if (fileInfo.size > bucket._def.bucketConfig.maxSize) {
             throw new EdgeStoreError({
-                code: 'BAD_REQUEST',
+                code: 'FILE_TOO_LARGE',
                 message: `File size is too big. Max size is ${bucket._def.bucketConfig.maxSize}`,
+                details: {
+                    maxFileSize: bucket._def.bucketConfig.maxSize,
+                    fileSize: fileInfo.size,
+                },
             });
         }
     }
@@ -119,8 +129,12 @@ async function requestUpload(params) {
         }
         if (!accepted) {
             throw new EdgeStoreError({
-                code: 'BAD_REQUEST',
+                code: 'MIME_TYPE_NOT_ALLOWED',
                 message: `"${fileInfo.type}" is not allowed. Accepted types are ${JSON.stringify(accept)}`,
+                details: {
+                    allowedMimeTypes: accept,
+                    mimeType: fileInfo.type,
+                },
             });
         }
     }
@@ -131,6 +145,12 @@ async function requestUpload(params) {
     });
     const metadata = await bucket._def.metadata?.({ ctx, input });
     const isPublic = bucket._def.accessControl === undefined;
+    log.debug('upload info', {
+        path,
+        metadata,
+        isPublic,
+        bucketType: bucket._def.type,
+    });
     const requestUploadRes = await provider.requestUpload({
         bucketName,
         bucketType: bucket._def.type,
@@ -141,11 +161,8 @@ async function requestUpload(params) {
             metadata,
         },
     });
-    const parsedPath = path.reduce((acc, curr) => {
-        acc[curr.key] = curr.value;
-        return acc;
-    }, {});
-    const pathOrder = path.map((p) => p.key);
+    const { parsedPath, pathOrder } = parsePath(path);
+    log.debug('Finished [requestUpload]');
     return {
         ...requestUploadRes,
         size: fileInfo.size,
@@ -156,7 +173,9 @@ async function requestUpload(params) {
     };
 }
 async function requestUploadParts(params) {
-    const { provider, router, ctxToken, body: { multipart, path }, } = params;
+    const { provider, ctxToken, body: { multipart, path }, } = params;
+    const log = globalThis._EDGE_STORE_LOGGER;
+    log.debug('Running [requestUploadParts]', { multipart, path });
     if (!ctxToken) {
         throw new EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
@@ -164,17 +183,21 @@ async function requestUploadParts(params) {
         });
     }
     await getContext(ctxToken); // just to check if the token is valid
-    const bucket = router.buckets[multipart.uploadId];
-    if (!bucket) {
-        throw new Error(`Bucket ${multipart.uploadId} not found`);
-    }
-    return await provider.requestUploadParts({
+    const res = await provider.requestUploadParts({
         multipart,
         path,
     });
+    log.debug('Finished [requestUploadParts]');
+    return res;
 }
 async function completeMultipartUpload(params) {
     const { provider, router, ctxToken, body: { bucketName, uploadId, key, parts }, } = params;
+    const log = globalThis._EDGE_STORE_LOGGER;
+    log.debug('Running [completeMultipartUpload]', {
+        bucketName,
+        uploadId,
+        key,
+    });
     if (!ctxToken) {
         throw new EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
@@ -184,16 +207,23 @@ async function completeMultipartUpload(params) {
     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`);
+        throw new EdgeStoreError({
+            message: `Bucket ${bucketName} not found`,
+            code: 'BAD_REQUEST',
+        });
     }
-    return await provider.completeMultipartUpload({
+    const res = await provider.completeMultipartUpload({
         uploadId,
         key,
         parts,
     });
+    log.debug('Finished [completeMultipartUpload]');
+    return res;
 }
 async function confirmUpload(params) {
     const { provider, router, ctxToken, body: { bucketName, url }, } = params;
+    const log = globalThis._EDGE_STORE_LOGGER;
+    log.debug('Running [confirmUpload]', { bucketName, url });
     if (!ctxToken) {
         throw new EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
@@ -203,15 +233,22 @@ async function confirmUpload(params) {
     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`);
+        throw new EdgeStoreError({
+            message: `Bucket ${bucketName} not found`,
+            code: 'BAD_REQUEST',
+        });
     }
-    return await provider.confirmUpload({
+    const res = await provider.confirmUpload({
         bucket,
         url: unproxyUrl(url),
     });
+    log.debug('Finished [confirmUpload]');
+    return res;
 }
 async function deleteFile(params) {
     const { provider, router, ctxToken, body: { bucketName, url }, } = params;
+    const log = globalThis._EDGE_STORE_LOGGER;
+    log.debug('Running [deleteFile]', { bucketName, url });
     if (!ctxToken) {
         throw new EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
@@ -221,30 +258,44 @@ async function deleteFile(params) {
     const ctx = await getContext(ctxToken);
     const bucket = router.buckets[bucketName];
     if (!bucket) {
-        throw new Error(`Bucket ${bucketName} not found`);
+        throw new EdgeStoreError({
+            message: `Bucket ${bucketName} not found`,
+            code: 'BAD_REQUEST',
+        });
     }
     if (!bucket._def.beforeDelete) {
-        throw new Error('You need to define beforeDelete if you want to delete files directly from the frontend.');
+        throw new EdgeStoreError({
+            message: 'You need to define beforeDelete if you want to delete files directly from the frontend.',
+            code: 'SERVER_ERROR',
+        });
     }
     const fileInfo = await provider.getFile({
-        url,
+        url: unproxyUrl(url),
     });
     const canDelete = await bucket._def.beforeDelete({
         ctx,
         fileInfo,
     });
     if (!canDelete) {
-        throw new Error('Delete not allowed');
+        throw new EdgeStoreError({
+            message: 'Delete not allowed for the current context',
+            code: 'DELETE_NOT_ALLOWED',
+        });
     }
-    return await provider.deleteFile({
+    const res = await provider.deleteFile({
         bucket,
         url: unproxyUrl(url),
     });
+    log.debug('Finished [deleteFile]');
+    return res;
 }
 async function encryptJWT(ctx) {
     const secret = process.env.EDGE_STORE_JWT_SECRET ?? process.env.EDGE_STORE_SECRET_KEY;
     if (!secret) {
-        throw new Error('EDGE_STORE_JWT_SECRET or EDGE_STORE_SECRET_KEY is not defined');
+        throw new EdgeStoreError({
+            message: 'EDGE_STORE_JWT_SECRET or EDGE_STORE_SECRET_KEY is not defined',
+            code: 'SERVER_ERROR',
+        });
     }
     const encryptionSecret = await getDerivedEncryptionKey(secret);
     return await new EncryptJWT(ctx)
@@ -257,7 +308,10 @@ async function encryptJWT(ctx) {
 async function decryptJWT(token) {
     const secret = process.env.EDGE_STORE_JWT_SECRET ?? process.env.EDGE_STORE_SECRET_KEY;
     if (!secret) {
-        throw new Error('EDGE_STORE_JWT_SECRET or EDGE_STORE_SECRET_KEY is not set');
+        throw new EdgeStoreError({
+            message: 'EDGE_STORE_JWT_SECRET or EDGE_STORE_SECRET_KEY is not defined',
+            code: 'SERVER_ERROR',
+        });
     }
     const encryptionSecret = await getDerivedEncryptionKey(secret);
     const { payload } = await jwtDecrypt(token, encryptionSecret, {
@@ -274,7 +328,10 @@ function buildPath(params) {
     const path = pathParams.map((param) => {
         const paramEntries = Object.entries(param);
         if (paramEntries[0] === undefined) {
-            throw new Error('Missing path param');
+            throw new EdgeStoreError({
+                message: `Empty path param found in: ${JSON.stringify(pathParams)}`,
+                code: 'SERVER_ERROR',
+            });
         }
         const [key, value] = paramEntries[0];
         // this is a string like: "ctx.xxx" or "input.yyy.zzz"
@@ -282,7 +339,10 @@ function buildPath(params) {
             .split('.')
             .reduce((acc2, key) => {
             if (acc2[key] === undefined) {
-                throw new Error(`Missing key ${key} in ${JSON.stringify(acc2)}`);
+                throw new EdgeStoreError({
+                    message: `Missing key ${key} in ${JSON.stringify(acc2)}`,
+                    code: 'BAD_REQUEST',
+                });
             }
             return acc2[key];
         }, params.pathAttrs);
@@ -293,10 +353,18 @@ function buildPath(params) {
     });
     return path;
 }
+function parsePath(path) {
+    const parsedPath = path.reduce((acc, curr) => {
+        acc[curr.key] = curr.value;
+        return acc;
+    }, {});
+    const pathOrder = path.map((p) => p.key);
+    return {
+        parsedPath,
+        pathOrder,
+    };
+}
 async function getContext(token) {
-    if (!token) {
-        throw new Error('No token');
-    }
     return await decryptJWT(token);
 }
 /**
@@ -317,4 +385,4 @@ function unproxyUrl(url) {
     return url;
 }
 
-export { EdgeStoreError as E, requestUploadParts as a, confirmUpload as b, completeMultipartUpload as c, deleteFile as d, EDGE_STORE_ERROR_CODES as e, init as i, requestUpload as r };
+export { requestUploadParts as a, buildPath as b, completeMultipartUpload as c, confirmUpload as d, deleteFile as e, init as i, parsePath as p, requestUpload as r };