@edgestore/server 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgestore/server",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Upload files with ease from React/Next.js",
   "homepage": "https://edgestore.dev",
   "repository": "https://github.com/edgestorejs/edgestore.git",
@@ -37,6 +37,11 @@
       "require": "./dist/core/index.js",
       "default": "./dist/core/index.js"
     },
+    "./adapters/astro": {
+      "import": "./dist/adapters/astro/index.mjs",
+      "require": "./dist/adapters/astro/index.js",
+      "default": "./dist/adapters/astro/index.js"
+    },
     "./adapters/express": {
       "import": "./dist/adapters/express/index.mjs",
       "require": "./dist/adapters/express/index.js",
@@ -47,6 +52,11 @@
       "require": "./dist/adapters/fastify/index.js",
       "default": "./dist/adapters/fastify/index.js"
     },
+    "./adapters/hono": {
+      "import": "./dist/adapters/hono/index.mjs",
+      "require": "./dist/adapters/hono/index.js",
+      "default": "./dist/adapters/hono/index.js"
+    },
     "./adapters/next/pages": {
       "import": "./dist/adapters/next/pages/index.mjs",
       "require": "./dist/adapters/next/pages/index.js",
@@ -57,6 +67,11 @@
       "require": "./dist/adapters/next/app/index.js",
       "default": "./dist/adapters/next/app/index.js"
     },
+    "./adapters/remix": {
+      "import": "./dist/adapters/remix/index.mjs",
+      "require": "./dist/adapters/remix/index.js",
+      "default": "./dist/adapters/remix/index.js"
+    },
     "./adapters/start": {
       "import": "./dist/adapters/start/index.mjs",
       "require": "./dist/adapters/start/index.js",
@@ -94,7 +109,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@edgestore/shared": "0.4.0",
+    "@edgestore/shared": "0.5.0",
     "@panva/hkdf": "^1.0.4",
     "cookie": "^0.5.0",
     "jose": "^4.13.1",
@@ -127,12 +142,14 @@
     "@types/cookie": "^0.5.1",
     "@types/node": "^20",
     "@types/uuid": "^9.0.1",
+    "astro": "^5.7.12",
     "fastify": "^5.3.2",
+    "hono": "^4.7.9",
     "next": "^15.2.4",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "typescript": "^5",
     "zod": "3.21.4"
   },
-  "gitHead": "63d6ba86e038a61bfbf506385183482c91e80842"
+  "gitHead": "1bc997b2797e026d6661b9964e74c6e117dba352"
 }

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/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/remix/index.ts

@@ -0,0 +1,201 @@
+import {
+  EDGE_STORE_ERROR_CODES,
+  EdgeStoreError,
+  type EdgeStoreErrorCodeKey,
+  type EdgeStoreRouter,
+  type MaybePromise,
+  type Provider,
+} from '@edgestore/shared';
+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: Request;
+};
+
+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 Remix request
+function getCookie(req: Request, name: string): string | undefined {
+  const cookieHeader = req.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 createEdgeStoreRemixHandler<TCtx>(config: Config<TCtx>) {
+  const { provider = EdgeStoreProvider() } = config;
+  const log = new Logger(config.logLevel);
+  globalThis._EDGE_STORE_LOGGER = log;
+  log.debug('Creating EdgeStore Remix handler');
+
+  return async ({ request: req }: { request: Request }) => {
+    try {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+
+      if (matchPath(pathname, '/health')) {
+        return new Response('OK');
+      } else if (matchPath(pathname, '/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,
+          router: config.router,
+        });
+
+        // Create response with cookies and token
+        const responseHeaders = new Headers();
+
+        if (Array.isArray(newCookies)) {
+          for (const cookie of newCookies) {
+            responseHeaders.append('Set-Cookie', cookie);
+          }
+        } else if (newCookies) {
+          responseHeaders.append('Set-Cookie', newCookies);
+        }
+
+        return new Response(JSON.stringify({ token, baseUrl }), {
+          headers: responseHeaders,
+          status: 200,
+        });
+      } else if (matchPath(pathname, '/request-upload')) {
+        const body = (await req.json()) as RequestUploadBody;
+        return Response.json(
+          await requestUpload({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/request-upload-parts')) {
+        const body = (await req.json()) as RequestUploadPartsParams;
+        return Response.json(
+          await requestUploadParts({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/complete-multipart-upload')) {
+        const body = (await req.json()) as CompleteMultipartUploadBody;
+        await completeMultipartUpload({
+          provider,
+          router: config.router,
+          body,
+          ctxToken: getCookie(req, 'edgestore-ctx'),
+        });
+        return new Response(null, { status: 200 });
+      } else if (matchPath(pathname, '/confirm-upload')) {
+        const body = (await req.json()) as ConfirmUploadBody;
+        return Response.json(
+          await confirmUpload({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/delete-file')) {
+        const body = (await req.json()) as DeleteFileBody;
+        return Response.json(
+          await deleteFile({
+            provider,
+            router: config.router,
+            body,
+            ctxToken: getCookie(req, 'edgestore-ctx'),
+          }),
+        );
+      } else if (matchPath(pathname, '/proxy-file')) {
+        const url = new URL(req.url).searchParams.get('url');
+        if (typeof url === 'string') {
+          const proxyRes = await fetch(url, {
+            headers: {
+              cookie: req.headers.get('cookie') ?? '',
+            },
+          });
+
+          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 Response.json(err.formattedJson(), {
+          status: EDGE_STORE_ERROR_CODES[err.code as EdgeStoreErrorCodeKey],
+        });
+      } else {
+        log.error(err);
+        return Response.json(
+          new EdgeStoreError({
+            message: 'Internal Server Error',
+            code: 'SERVER_ERROR',
+          }).formattedJson(),
+          { status: 500 },
+        );
+      }
+    }
+  };
+}