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

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

@@ -2,7 +2,9 @@ import { type NextRequest } from 'next/server';
 import { type EdgeStoreRouter } from '../../../core/internals/bucketBuilder';
 import EdgeStoreError, {
   EDGE_STORE_ERROR_CODES,
+  type EdgeStoreErrorCodeKey,
 } from '../../../libs/errors/EdgeStoreError';
+import Logger, { type LogLevel } from '../../../libs/logger';
 import { EdgeStoreProvider } from '../../../providers/edgestore';
 import { type Provider } from '../../../providers/types';
 import { type MaybePromise } from '../../../types';
@@ -24,26 +26,54 @@ export type CreateContextOptions = {
   req: NextRequest;
 };
 
-export type Config<TCtx> = TCtx extends Record<string, never>
-  ? {
-      provider?: Provider;
-      router: EdgeStoreRouter<TCtx>;
-    }
+export type Config<TCtx> = {
+  provider?: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  logLevel?: LogLevel;
+} & (TCtx extends Record<string, never>
+  ? object
   : {
       provider?: Provider;
       router: EdgeStoreRouter<TCtx>;
       createContext: (opts: CreateContextOptions) => MaybePromise<TCtx>;
-    };
+    });
+
+declare const globalThis: {
+  _EDGE_STORE_LOGGER: Logger;
+};
 
 export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
   const { provider = EdgeStoreProvider() } = config;
+  const log = new Logger(config.logLevel);
+  globalThis._EDGE_STORE_LOGGER = log;
+  log.debug('Creating Edge Store Next handler (app adapter)');
+
   return async (req: NextRequest) => {
     try {
-      if (req.nextUrl.pathname.endsWith('/init')) {
-        const ctx =
-          'createContext' in config
-            ? await config.createContext({ req })
-            : ({} as TCtx);
+      if (!('nextUrl' in req))
+        throw new EdgeStoreError({
+          message:
+            'Error running the app adapter. Make sure you are importing the correct adapter in your router configuration',
+          code: 'SERVER_ERROR',
+        });
+      if (req.nextUrl.pathname.endsWith('/health')) {
+        return new Response('OK', {
+          status: 200,
+        });
+      } else if (req.nextUrl.pathname.endsWith('/init')) {
+        let ctx = {} as TCtx;
+        try {
+          ctx =
+            'createContext' in config
+              ? await config.createContext({ req })
+              : ({} as TCtx);
+        } catch (err) {
+          throw new EdgeStoreError({
+            message: 'Error creating context',
+            code: 'CREATE_CONTEXT_ERROR',
+            cause: err instanceof Error ? err : undefined,
+          });
+        }
         const { newCookies, token, baseUrl } = await init({
           ctx,
           provider,
@@ -157,17 +187,30 @@ export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
       }
     } catch (err) {
       if (err instanceof EdgeStoreError) {
-        return new Response(err.message, {
-          status: EDGE_STORE_ERROR_CODES[err.code],
-        });
-      } else if (err instanceof Error) {
-        return new Response(err.message, {
-          status: 500,
+        log[err.level](err.formattedMessage());
+        if (err.cause) log[err.level](err.cause);
+        return new Response(JSON.stringify(err.formattedJson()), {
+          status: EDGE_STORE_ERROR_CODES[err.code as EdgeStoreErrorCodeKey],
+          headers: {
+            'Content-Type': 'application/json',
+          },
         });
       }
-      return new Response('Internal server error', {
-        status: 500,
-      });
+      log.error(err);
+      return new Response(
+        JSON.stringify(
+          new EdgeStoreError({
+            message: 'Internal server error',
+            code: 'SERVER_ERROR',
+          }).formattedJson(),
+        ),
+        {
+          status: 500,
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        },
+      );
     }
   };
 }

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

@@ -2,7 +2,9 @@ import { type NextApiRequest, type NextApiResponse } from 'next/types';
 import { type EdgeStoreRouter } from '../../../core/internals/bucketBuilder';
 import EdgeStoreError, {
   EDGE_STORE_ERROR_CODES,
+  type EdgeStoreErrorCodeKey,
 } from '../../../libs/errors/EdgeStoreError';
+import Logger, { type LogLevel } from '../../../libs/logger';
 import { EdgeStoreProvider } from '../../../providers/edgestore';
 import { type Provider } from '../../../providers/types';
 import { type MaybePromise } from '../../../types';
@@ -25,26 +27,52 @@ export type CreateContextOptions = {
   res: NextApiResponse;
 };
 
-export type Config<TCtx> = TCtx extends Record<string, never>
-  ? {
-      provider?: Provider;
-      router: EdgeStoreRouter<TCtx>;
-    }
+export type Config<TCtx> = {
+  provider?: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  logLevel?: LogLevel;
+} & (TCtx extends Record<string, never>
+  ? object
   : {
       provider?: Provider;
       router: EdgeStoreRouter<TCtx>;
       createContext: (opts: CreateContextOptions) => MaybePromise<TCtx>;
-    };
+    });
+
+declare const globalThis: {
+  _EDGE_STORE_LOGGER: Logger;
+};
 
 export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
   const { provider = EdgeStoreProvider() } = config;
+  const log = new Logger(config.logLevel);
+  globalThis._EDGE_STORE_LOGGER = log;
+  log.debug('Creating Edge Store Next handler (pages adapter)');
+
   return async (req: NextApiRequest, res: NextApiResponse) => {
     try {
-      if (req.url?.includes?.('/init')) {
-        const ctx =
-          'createContext' in config
-            ? await config.createContext({ req, res })
-            : ({} as TCtx);
+      if (!('json' in res))
+        throw new EdgeStoreError({
+          message:
+            'Error running the pages adapter. Make sure you are importing the correct adapter in your router configuration',
+          code: 'SERVER_ERROR',
+        });
+      if (req.url?.includes?.('/health')) {
+        res.send('OK');
+      } else if (req.url?.includes?.('/init')) {
+        let ctx = {} as TCtx;
+        try {
+          ctx =
+            'createContext' in config
+              ? await config.createContext({ req, res })
+              : ({} as TCtx);
+        } catch (err) {
+          throw new EdgeStoreError({
+            message: 'Error creating context',
+            code: 'CREATE_CONTEXT_ERROR',
+            cause: err instanceof Error ? err : undefined,
+          });
+        }
         const { newCookies, token, baseUrl } = await init({
           ctx,
           provider,
@@ -123,11 +151,20 @@ export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
       }
     } catch (err) {
       if (err instanceof EdgeStoreError) {
-        res.status(EDGE_STORE_ERROR_CODES[err.code]).send(err.message);
-      } else if (err instanceof Error) {
-        res.status(500).send(err.message);
+        log[err.level](err.formattedMessage());
+        if (err.cause) log[err.level](err.cause);
+        res
+          .status(EDGE_STORE_ERROR_CODES[err.code as EdgeStoreErrorCodeKey])
+          .json(err.formattedJson());
+      } else {
+        log.error(err);
+        res.status(500).send(
+          new EdgeStoreError({
+            message: 'Internal Server Error',
+            code: 'SERVER_ERROR',
+          }).formattedJson(),
+        );
       }
-      res.status(500).send('Internal server error');
     }
   };
 }

package/src/adapters/shared.ts

@@ -7,18 +7,25 @@ import {
   type EdgeStoreRouter,
 } from '../core/internals/bucketBuilder';
 import EdgeStoreError from '../libs/errors/EdgeStoreError';
+import type Logger from '../libs/logger';
 import { type Provider } from '../providers/types';
 import { IMAGE_MIME_TYPES } from './imageTypes';
 
 // 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
 
+declare const globalThis: {
+  _EDGE_STORE_LOGGER: Logger;
+};
+
 export async function init<TCtx>(params: {
   provider: Provider;
   router: EdgeStoreRouter<TCtx>;
   ctx: TCtx;
 }) {
+  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,
@@ -40,6 +47,8 @@ export async function init<TCtx>(params: {
   }
   const baseUrl = await provider.getBaseUrl();
 
+  log.debug('Finished [init]', { ctx, newCookies, token, baseUrl });
+
   return {
     newCookies,
     token,
@@ -72,6 +81,8 @@ export async function requestUpload<TCtx>(params: {
     ctxToken,
     body: { bucketName, input, fileInfo },
   } = params;
+  const log = globalThis._EDGE_STORE_LOGGER;
+  log.debug('Running [requestUpload]', { bucketName, input, fileInfo });
 
   if (!ctxToken) {
     throw new EdgeStoreError({
@@ -80,11 +91,18 @@ export async function requestUpload<TCtx>(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,
@@ -97,16 +115,24 @@ export async function requestUpload<TCtx>(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,
+        },
       });
     }
   }
@@ -114,8 +140,12 @@ export async function requestUpload<TCtx>(params: {
   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,
+        },
       });
     }
   }
@@ -137,10 +167,14 @@ export async function requestUpload<TCtx>(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,
+        },
       });
     }
   }
@@ -152,6 +186,14 @@ export async function requestUpload<TCtx>(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,
@@ -162,12 +204,10 @@ export async function requestUpload<TCtx>(params: {
       metadata,
     },
   });
-  const parsedPath = path.reduce<Record<string, string>>((acc, curr) => {
-    acc[curr.key] = curr.value;
-    return acc;
-  }, {});
+  const { parsedPath, pathOrder } = parsePath(path);
+
+  log.debug('Finished [requestUpload]');
 
-  const pathOrder = path.map((p) => p.key);
   return {
     ...requestUploadRes,
     size: fileInfo.size,
@@ -194,10 +234,13 @@ export async function requestUploadParts<TCtx>(params: {
 }) {
   const {
     provider,
-    router,
     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',
@@ -205,14 +248,15 @@ export async function requestUploadParts<TCtx>(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;
 }
 
 export type CompleteMultipartUploadBody = {
@@ -237,6 +281,14 @@ export async function completeMultipartUpload<TCtx>(params: {
     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',
@@ -246,13 +298,21 @@ export async function completeMultipartUpload<TCtx>(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;
 }
 
 export type ConfirmUploadBody = {
@@ -273,6 +333,9 @@ export async function confirmUpload<TCtx>(params: {
     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',
@@ -282,13 +345,19 @@ export async function confirmUpload<TCtx>(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;
 }
 
 export type DeleteFileBody = {
@@ -309,6 +378,9 @@ export async function deleteFile<TCtx>(params: {
     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',
@@ -318,38 +390,52 @@ export async function deleteFile<TCtx>(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: any) {
   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)
@@ -364,9 +450,10 @@ async function decryptJWT(token: string) {
   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, {
@@ -385,7 +472,7 @@ async function getDerivedEncryptionKey(secret: string) {
   );
 }
 
-function buildPath(params: {
+export function buildPath(params: {
   fileInfo: RequestUploadBody['fileInfo'];
   bucket: AnyBuilder;
   pathAttrs: {
@@ -398,7 +485,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"
@@ -406,7 +496,10 @@ function buildPath(params: {
       .split('.')
       .reduce((acc2: any, key: string) => {
         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 as any) as string;
@@ -418,10 +511,19 @@ function buildPath(params: {
   return path;
 }
 
-async function getContext(token?: string) {
-  if (!token) {
-    throw new Error('No token');
-  }
+export function parsePath(path: { key: string; value: string }[]) {
+  const parsedPath = path.reduce<Record<string, string>>((acc, curr) => {
+    acc[curr.key] = curr.value;
+    return acc;
+  }, {});
+  const pathOrder = path.map((p) => p.key);
+  return {
+    parsedPath,
+    pathOrder,
+  };
+}
+
+async function getContext(token: string) {
   return await decryptJWT(token);
 }