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

package/dist/{shared-306c1af2.js → shared-06cb0d86.js}

@@ -4,22 +4,7 @@ var hkdf = require('@panva/hkdf');
 var cookie = require('cookie');
 var jose = require('jose');
 var uuid = require('uuid');
-var _define_property = require('@swc/helpers/_/_define_property');
-
-const EDGE_STORE_ERROR_CODES = {
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401
-};
-class EdgeStoreError extends Error {
-    constructor(opts){
-        super(opts.message);
-        _define_property._(this, "cause", void 0);
-        _define_property._(this, "code", void 0);
-        this.name = 'EdgeStoreError';
-        this.code = opts.code;
-        this.cause = opts.cause;
-    }
-}
+var index = require('./index-a2e7ca9e.js');
 
 const IMAGE_MIME_TYPES = [
     'image/jpeg',
@@ -35,7 +20,11 @@ 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,
@@ -54,6 +43,12 @@ async function init(params) {
         }));
     }
     const baseUrl = await provider.getBaseUrl();
+    log.debug('Finished [init]', {
+        ctx,
+        newCookies,
+        token,
+        baseUrl
+    });
     return {
         newCookies,
         token,
@@ -62,18 +57,31 @@ 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({
+        throw new index.EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
             code: 'UNAUTHORIZED'
         });
     }
     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 index.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,
@@ -86,23 +94,37 @@ async function requestUpload(params) {
                 temporary: fileInfo.temporary
             }
         });
+        log.debug('Finished [beforeUpload]', {
+            canUpload
+        });
         if (!canUpload) {
-            throw new Error('Upload not allowed');
+            throw new index.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',
-                message: 'Only images are allowed in this bucket'
+            throw new index.EdgeStoreError({
+                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',
-                message: `File size is too big. Max size is ${bucket._def.bucketConfig.maxSize}`
+            throw new index.EdgeStoreError({
+                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
+                }
             });
         }
     }
@@ -122,9 +144,13 @@ async function requestUpload(params) {
             }
         }
         if (!accepted) {
-            throw new EdgeStoreError({
-                code: 'BAD_REQUEST',
-                message: `"${fileInfo.type}" is not allowed. Accepted types are ${JSON.stringify(accept)}`
+            throw new index.EdgeStoreError({
+                code: 'MIME_TYPE_NOT_ALLOWED',
+                message: `"${fileInfo.type}" is not allowed. Accepted types are ${JSON.stringify(accept)}`,
+                details: {
+                    allowedMimeTypes: accept,
+                    mimeType: fileInfo.type
+                }
             });
         }
     }
@@ -141,6 +167,12 @@ async function requestUpload(params) {
         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,
@@ -151,11 +183,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,
@@ -166,27 +195,36 @@ 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({
+        throw new index.EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
             code: 'UNAUTHORIZED'
         });
     }
     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({
+        throw new index.EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
             code: 'UNAUTHORIZED'
         });
@@ -194,18 +232,28 @@ 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 index.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({
+        throw new index.EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
             code: 'UNAUTHORIZED'
         });
@@ -213,17 +261,27 @@ 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 index.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({
+        throw new index.EdgeStoreError({
             message: 'Missing edgestore-ctx cookie',
             code: 'UNAUTHORIZED'
         });
@@ -231,30 +289,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 index.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 index.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 index.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 index.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 jose.EncryptJWT(ctx).setProtectedHeader({
@@ -265,7 +337,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 index.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 jose.jwtDecrypt(token, encryptionSecret, {
@@ -282,13 +357,19 @@ 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 index.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"
         const currParamVal = value().split('.').reduce((acc2, key)=>{
             if (acc2[key] === undefined) {
-                throw new Error(`Missing key ${key} in ${JSON.stringify(acc2)}`);
+                throw new index.EdgeStoreError({
+                    message: `Missing key ${key} in ${JSON.stringify(acc2)}`,
+                    code: 'BAD_REQUEST'
+                });
             }
             return acc2[key];
         }, params.pathAttrs);
@@ -299,10 +380,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);
 }
 /**
@@ -322,11 +411,11 @@ async function getContext(token) {
     return url;
 }
 
-exports.EDGE_STORE_ERROR_CODES = EDGE_STORE_ERROR_CODES;
-exports.EdgeStoreError = EdgeStoreError;
+exports.buildPath = buildPath;
 exports.completeMultipartUpload = completeMultipartUpload;
 exports.confirmUpload = confirmUpload;
 exports.deleteFile = deleteFile;
 exports.init = init;
+exports.parsePath = parsePath;
 exports.requestUpload = requestUpload;
 exports.requestUploadParts = requestUploadParts;