@edgestore/server 0.3.3 → 0.5.0

package/src/adapters/astro/index.ts

@@ -0,0 +1,222 @@
+import {
+  EDGE_STORE_ERROR_CODES,
+  EdgeStoreError,
+  type EdgeStoreErrorCodeKey,
+  type EdgeStoreRouter,
+  type MaybePromise,
+  type Provider,
+} from '@edgestore/shared';
+import type { APIContext } from 'astro';
+import Logger, { type LogLevel } from '../../libs/logger';
+import { matchPath } from '../../libs/utils';
+import { EdgeStoreProvider } from '../../providers/edgestore';
+import {
+  completeMultipartUpload,
+  confirmUpload,
+  deleteFile,
+  init,
+  requestUpload,
+  requestUploadParts,
+  type CompleteMultipartUploadBody,
+  type ConfirmUploadBody,
+  type DeleteFileBody,
+  type RequestUploadBody,
+  type RequestUploadPartsParams,
+} from '../shared';
+
+export type Config<TCtx> = {
+  provider?: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  logLevel?: LogLevel;
+} & (TCtx extends Record<string, never>
+  ? object
+  : {
+      provider?: Provider;
+      router: EdgeStoreRouter<TCtx>;
+      createContext: (opts: APIContext) => MaybePromise<TCtx>;
+    });
+
+declare const globalThis: {
+  _EDGE_STORE_LOGGER: Logger;
+};
+
+// Helper to safely get cookies from Astro request
+function getCookie(request: Request, name: string): string | undefined {
+  const cookieHeader = request.headers.get('cookie');
+  if (!cookieHeader) return undefined;
+
+  const cookies = cookieHeader
+    .split(';')
+    .reduce<Record<string, string>>((acc, cookie) => {
+      const [key, value] = cookie.trim().split('=');
+      if (key && value) acc[key] = value;
+      return acc;
+    }, {});
+
+  return cookies[name];
+}
+
+export function createEdgeStoreAstroHandler<TCtx>(config: Config<TCtx>) {
+  const { provider = EdgeStoreProvider() } = config;
+  const log = new Logger(config.logLevel);
+  globalThis._EDGE_STORE_LOGGER = log;
+  log.debug('Creating EdgeStore Astro handler');
+
+  return async (context: APIContext) => {
+    try {
+      const { request } = context;
+      const url = new URL(request.url);
+
+      if (matchPath(url.pathname, 'health')) {
+        return new Response('OK');
+      } else if (matchPath(url.pathname, 'init')) {
+        let ctx = {} as TCtx;
+        try {
+          ctx =
+            'createContext' in config
+              ? await config.createContext(context)
+              : ({} 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,
+          router: config.router,
+        });
+
+        const headers = new Headers();
+        headers.set('Content-Type', 'application/json');
+
+        // Set cookies
+        if (Array.isArray(newCookies)) {
+          for (const cookie of newCookies) {
+            headers.append('Set-Cookie', cookie);
+          }
+        } else if (newCookies) {
+          headers.append('Set-Cookie', newCookies);
+        }
+
+        return new Response(
+          JSON.stringify({
+            token,
+            baseUrl,
+          }),
+          { headers },
+        );
+      } else if (matchPath(url.pathname, 'request-upload')) {
+        const body = (await request.json()) as RequestUploadBody;
+        const result = await requestUpload({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(request, 'edgestore-ctx'),
+        });
+
+        return new Response(JSON.stringify(result), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } else if (matchPath(url.pathname, 'request-upload-parts')) {
+        const body = (await request.json()) as RequestUploadPartsParams;
+        const result = await requestUploadParts({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(request, 'edgestore-ctx'),
+        });
+
+        return new Response(JSON.stringify(result), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } else if (matchPath(url.pathname, 'complete-multipart-upload')) {
+        const body = (await request.json()) as CompleteMultipartUploadBody;
+        await completeMultipartUpload({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(request, 'edgestore-ctx'),
+        });
+
+        return new Response(null, { status: 200 });
+      } else if (matchPath(url.pathname, 'confirm-upload')) {
+        const body = (await request.json()) as ConfirmUploadBody;
+        const result = await confirmUpload({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(request, 'edgestore-ctx'),
+        });
+
+        return new Response(JSON.stringify(result), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } else if (matchPath(url.pathname, 'delete-file')) {
+        const body = (await request.json()) as DeleteFileBody;
+        const result = await deleteFile({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(request, 'edgestore-ctx'),
+        });
+
+        return new Response(JSON.stringify(result), {
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } else if (matchPath(url.pathname, 'proxy-file')) {
+        const url = new URL(request.url).searchParams.get('url');
+
+        if (typeof url === 'string') {
+          const cookieHeader = request.headers.get('cookie') ?? '';
+
+          const proxyRes = await fetch(url, {
+            headers: {
+              cookie: cookieHeader,
+            },
+          });
+
+          const data = await proxyRes.arrayBuffer();
+          const headers = new Headers();
+          headers.set(
+            'Content-Type',
+            proxyRes.headers.get('Content-Type') ?? 'application/octet-stream',
+          );
+
+          return new Response(data, { headers });
+        } else {
+          return new Response(null, { status: 400 });
+        }
+      } else {
+        return new Response(null, { status: 404 });
+      }
+    } catch (err) {
+      if (err instanceof EdgeStoreError) {
+        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' },
+        });
+      } else {
+        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/express/index.ts

@@ -49,7 +49,7 @@ export function createEdgeStoreExpressHandler<TCtx>(config: Config<TCtx>) {
   const { provider = EdgeStoreProvider() } = config;
   const log = new Logger(config.logLevel);
   globalThis._EDGE_STORE_LOGGER = log;
-  log.debug('Creating Edge Store Express handler');
+  log.debug('Creating EdgeStore Express handler');
 
   return async (req: Request, res: Response) => {
     try {

package/src/adapters/fastify/index.ts

@@ -0,0 +1,205 @@
+import {
+  EDGE_STORE_ERROR_CODES,
+  EdgeStoreError,
+  type EdgeStoreErrorCodeKey,
+  type EdgeStoreRouter,
+  type MaybePromise,
+  type Provider,
+} from '@edgestore/shared';
+import { type FastifyRequest, type FastifyReply } from 'fastify';
+import Logger, { type LogLevel } from '../../libs/logger';
+import { matchPath } from '../../libs/utils';
+import { EdgeStoreProvider } from '../../providers/edgestore';
+import {
+  completeMultipartUpload,
+  confirmUpload,
+  deleteFile,
+  init,
+  requestUpload,
+  requestUploadParts,
+  type CompleteMultipartUploadBody,
+  type ConfirmUploadBody,
+  type DeleteFileBody,
+  type RequestUploadBody,
+  type RequestUploadPartsParams,
+} from '../shared';
+
+export type CreateContextOptions = {
+  req: FastifyRequest;
+  reply: FastifyReply;
+};
+
+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;
+};
+
+// Helper to safely get cookies from Fastify request
+function getCookie(req: FastifyRequest, name: string): string | undefined {
+  // Check if cookies plugin is available
+  if ('cookies' in req) {
+    // Type assertion for TypeScript
+    return (req as any).cookies[name];
+  }
+  
+  // Fallback to parsing cookie header
+  const cookieHeader = req.headers.cookie;
+  if (!cookieHeader) return undefined;
+  
+  const cookies = cookieHeader.split(';').reduce<Record<string, string>>((acc, cookie) => {
+    const [key, value] = cookie.trim().split('=');
+    if (key && value) acc[key] = value;
+    return acc;
+  }, {});
+  
+  return cookies[name];
+}
+
+export function createEdgeStoreFastifyHandler<TCtx>(config: Config<TCtx>) {
+  const { provider = EdgeStoreProvider() } = config;
+  const log = new Logger(config.logLevel);
+  globalThis._EDGE_STORE_LOGGER = log;
+  log.debug('Creating EdgeStore Fastify handler');
+
+  return async (req: FastifyRequest, reply: FastifyReply) => {
+    try {
+      // Get the URL from the request - simplified approach
+      const pathname = req.url;
+      
+      if (matchPath(pathname, '/health')) {
+        return reply.send('OK');
+      } else if (matchPath(pathname, '/init')) {
+        let ctx = {} as TCtx;
+        try {
+          ctx =
+            'createContext' in config
+              ? await config.createContext({ req, reply })
+              : ({} 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,
+          router: config.router,
+        });
+        
+        // Set cookies more efficiently - handling them using void operator
+        // to explicitly mark these synchronous calls as intentionally not awaited
+        if (Array.isArray(newCookies)) {
+          // If it's an array of cookies, set them all
+          for (const cookie of newCookies) {
+            void reply.header('Set-Cookie', cookie);
+          }
+        } else if (newCookies) {
+          // If it's a single cookie string
+          void reply.header('Set-Cookie', newCookies);
+        }
+        
+        return reply.send({
+          token,
+          baseUrl,
+        });
+      } else if (matchPath(pathname, '/request-upload')) {
+        return reply.send(
+          await requestUpload({
+            provider,
+            router: config.router,
+            body: req.body as RequestUploadBody,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/request-upload-parts')) {
+        return reply.send(
+          await requestUploadParts({
+            provider,
+            router: config.router,
+            body: req.body as RequestUploadPartsParams,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/complete-multipart-upload')) {
+        await completeMultipartUpload({
+          provider,
+          router: config.router,
+          body: req.body as CompleteMultipartUploadBody,
+          ctxToken: getCookie(req, 'edgestore-ctx'),
+        });
+        return reply.status(200).send();
+      } else if (matchPath(pathname, '/confirm-upload')) {
+        return reply.send(
+          await confirmUpload({
+            provider,
+            router: config.router,
+            body: req.body as ConfirmUploadBody,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/delete-file')) {
+        return reply.send(
+          await deleteFile({
+            provider,
+            router: config.router,
+            body: req.body as DeleteFileBody,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/proxy-file')) {
+        const url = req.query ? (req.query as Record<string, any>).url : undefined;
+        
+        if (typeof url === 'string') {
+          const cookieHeader = req.headers.cookie ?? '';
+          
+          const proxyRes = await fetch(url, {
+            headers: {
+              cookie: cookieHeader,
+            },
+          });
+
+          const data = await proxyRes.arrayBuffer();
+          void reply.header(
+            'Content-Type',
+            proxyRes.headers.get('Content-Type') ?? 'application/octet-stream',
+          );
+
+          return reply.send(Buffer.from(data));
+        } else {
+          return reply.status(400).send();
+        }
+      } else {
+        return reply.status(404).send();
+      }
+    } catch (err) {
+      if (err instanceof EdgeStoreError) {
+        log[err.level](err.formattedMessage());
+        if (err.cause) log[err.level](err.cause);
+        return reply
+          .status(EDGE_STORE_ERROR_CODES[err.code as EdgeStoreErrorCodeKey])
+          .send(err.formattedJson());
+      } else {
+        log.error(err);
+        return reply.status(500).send(
+          new EdgeStoreError({
+            message: 'Internal Server Error',
+            code: 'SERVER_ERROR',
+          }).formattedJson(),
+        );
+      }
+    }
+  };
+}

package/src/adapters/hono/index.ts

@@ -0,0 +1,195 @@
+import {
+  EDGE_STORE_ERROR_CODES,
+  EdgeStoreError,
+  type EdgeStoreErrorCodeKey,
+  type EdgeStoreRouter,
+  type MaybePromise,
+  type Provider,
+} from '@edgestore/shared';
+import { type Context } from 'hono';
+import Logger, { type LogLevel } from '../../libs/logger';
+import { matchPath } from '../../libs/utils';
+import { EdgeStoreProvider } from '../../providers/edgestore';
+import {
+  completeMultipartUpload,
+  confirmUpload,
+  deleteFile,
+  init,
+  requestUpload,
+  requestUploadParts,
+  type CompleteMultipartUploadBody,
+  type ConfirmUploadBody,
+  type DeleteFileBody,
+  type RequestUploadBody,
+  type RequestUploadPartsParams,
+} from '../shared';
+
+export type CreateContextOptions = {
+  c: Context;
+};
+
+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;
+};
+
+// Helper to get a cookie value from Hono Context
+function getCookie(c: Context, name: string): string | undefined {
+  const cookies = c.req.header('cookie');
+  if (!cookies) return undefined;
+
+  const match = new RegExp(`${name}=([^;]+)`).exec(cookies);
+  return match ? match[1] : undefined;
+}
+
+export function createEdgeStoreHonoHandler<TCtx>(config: Config<TCtx>) {
+  const { provider = EdgeStoreProvider() } = config;
+  const log = new Logger(config.logLevel);
+  globalThis._EDGE_STORE_LOGGER = log;
+  log.debug('Creating EdgeStore Hono handler');
+
+  return async (c: Context) => {
+    try {
+      const pathname = new URL(c.req.url).pathname;
+
+      if (matchPath(pathname, '/health')) {
+        return c.text('OK');
+      } else if (matchPath(pathname, '/init')) {
+        let ctx = {} as TCtx;
+        try {
+          ctx =
+            'createContext' in config
+              ? await config.createContext({ c })
+              : ({} 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,
+          router: config.router,
+        });
+
+        // Set cookies
+        if (Array.isArray(newCookies)) {
+          for (const cookie of newCookies) {
+            c.header('Set-Cookie', cookie);
+          }
+        } else if (newCookies) {
+          c.header('Set-Cookie', newCookies);
+        }
+
+        return c.json({
+          token,
+          baseUrl,
+        });
+      } else if (matchPath(pathname, '/request-upload')) {
+        const body = await c.req.json<RequestUploadBody>();
+        return c.json(
+          await requestUpload({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(c, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/request-upload-parts')) {
+        const body = await c.req.json<RequestUploadPartsParams>();
+        return c.json(
+          await requestUploadParts({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(c, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/complete-multipart-upload')) {
+        const body = await c.req.json<CompleteMultipartUploadBody>();
+        await completeMultipartUpload({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(c, 'edgestore-ctx'),
+        });
+        return c.body(null, 200);
+      } else if (matchPath(pathname, '/confirm-upload')) {
+        const body = await c.req.json<ConfirmUploadBody>();
+        return c.json(
+          await confirmUpload({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(c, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/delete-file')) {
+        const body = await c.req.json<DeleteFileBody>();
+        return c.json(
+          await deleteFile({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(c, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/proxy-file')) {
+        const url = c.req.query('url');
+
+        if (typeof url === 'string') {
+          const cookieHeader = c.req.header('cookie') ?? '';
+
+          const proxyRes = await fetch(url, {
+            headers: {
+              cookie: cookieHeader,
+            },
+          });
+
+          const data = await proxyRes.arrayBuffer();
+          c.header(
+            'Content-Type',
+            proxyRes.headers.get('Content-Type') ?? 'application/octet-stream',
+          );
+
+          return c.body(Buffer.from(data));
+        } else {
+          return c.body(null, 400);
+        }
+      } else {
+        return c.body(null, 404);
+      }
+    } catch (err) {
+      if (err instanceof EdgeStoreError) {
+        log[err.level](err.formattedMessage());
+        if (err.cause) log[err.level](err.cause);
+        return c.json(
+          err.formattedJson(),
+          EDGE_STORE_ERROR_CODES[err.code as EdgeStoreErrorCodeKey],
+        );
+      } else {
+        log.error(err);
+        return c.json(
+          new EdgeStoreError({
+            message: 'Internal Server Error',
+            code: 'SERVER_ERROR',
+          }).formattedJson(),
+          500,
+        );
+      }
+    }
+  };
+}

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

@@ -48,7 +48,7 @@ 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)');
+  log.debug('Creating EdgeStore Next handler (app adapter)');
 
   return async (req: NextRequest) => {
     try {

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

@@ -49,7 +49,7 @@ 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)');
+  log.debug('Creating EdgeStore Next handler (pages adapter)');
 
   return async (req: NextApiRequest, res: NextApiResponse) => {
     try {