@edgestore/server 0.4.0 → 0.5.1

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 },
+        );
+      }
+    }
+  };
+}

package/src/adapters/shared.ts

@@ -434,7 +434,7 @@ export async function deleteFile<TCtx>(params: {
 
 async function encryptJWT(ctx: any) {
   const secret =
-    process.env.EDGE_STORE_JWT_SECRET ?? process.env.EDGE_STORE_SECRET_KEY;
+    getEnv('EDGE_STORE_JWT_SECRET') ?? getEnv('EDGE_STORE_SECRET_KEY');
   if (!secret) {
     throw new EdgeStoreError({
       message: 'EDGE_STORE_JWT_SECRET or EDGE_STORE_SECRET_KEY is not defined',
@@ -452,7 +452,7 @@ async function encryptJWT(ctx: any) {
 
 async function decryptJWT(token: string) {
   const secret =
-    process.env.EDGE_STORE_JWT_SECRET ?? process.env.EDGE_STORE_SECRET_KEY;
+    getEnv('EDGE_STORE_JWT_SECRET') ?? getEnv('EDGE_STORE_SECRET_KEY');
   if (!secret) {
     throw new EdgeStoreError({
       message: 'EDGE_STORE_JWT_SECRET or EDGE_STORE_SECRET_KEY is not defined',
@@ -539,7 +539,7 @@ async function getContext(token: string) {
  * so that we can delete or confirm the upload.
  */
 function unproxyUrl(url: string) {
-  if (process.env.NODE_ENV === 'development' && url.startsWith('http://')) {
+  if (isDev() && url.startsWith('http://')) {
     // get the url param from the query string
     const urlParam = new URL(url).searchParams.get('url');
     if (urlParam) {
@@ -548,3 +548,20 @@ function unproxyUrl(url: string) {
   }
   return url;
 }
+
+export function getEnv(key: string): string | undefined {
+  if (typeof process !== 'undefined' && process.env) {
+    // @ts-expect-error - In Vite/Astro, the env variables are available on `import.meta`.
+    return process.env[key] ?? import.meta.env?.[key];
+  }
+  // @ts-expect-error - In Vite/Astro, the env variables are available on `import.meta`.
+  return import.meta.env?.[key];
+}
+
+export function isDev(): boolean {
+  return (
+    process?.env?.NODE_ENV === 'development' ||
+    // @ts-expect-error - In Vite/Astro, the env variables are available on `import.meta`.
+    import.meta.env?.DEV
+  );
+}

package/src/core/client/index.ts

@@ -10,7 +10,7 @@ import {
 } from '@edgestore/shared';
 import { type z, type ZodNever } from 'zod';
 import { type Comparison } from '..';
-import { buildPath, parsePath } from '../../adapters/shared';
+import { buildPath, isDev, parsePath } from '../../adapters/shared';
 import { initEdgeStoreSdk } from '../sdk';
 
 export type GetFileRes<TBucket extends AnyBuilder> = {
@@ -408,7 +408,7 @@ export function initEdgeStoreClient<TRouter extends AnyRouter>(config: {
  * we need to proxy the file through the server.
  */
 function getUrl(url: string, baseUrl?: string) {
-  if (process.env.NODE_ENV === 'development' && !url.includes('/_public/')) {
+  if (isDev() && !url.includes('/_public/')) {
     if (!baseUrl) {
       throw new Error(
         'Missing baseUrl. You need to pass the baseUrl to `initEdgeStoreClient` to get protected files in development.',

package/src/core/sdk/index.ts

@@ -4,10 +4,11 @@ import {
   type AnyMetadata,
   type AnyRouter,
 } from '@edgestore/shared';
+import { getEnv } from '../../adapters/shared';
 import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
 
 const API_ENDPOINT =
-  process.env.EDGE_STORE_API_ENDPOINT ?? 'https://api.edgestore.dev';
+  getEnv('EDGE_STORE_API_ENDPOINT') ?? 'https://api.edgestore.dev';
 
 type FileInfoForUpload = {
   size: number;
@@ -359,8 +360,8 @@ export function initEdgeStoreSdk(params: {
   secretKey?: string;
 }) {
   const {
-    accessKey = process.env.EDGE_STORE_ACCESS_KEY,
-    secretKey = process.env.EDGE_STORE_SECRET_KEY,
+    accessKey = getEnv('EDGE_STORE_ACCESS_KEY'),
+    secretKey = getEnv('EDGE_STORE_SECRET_KEY'),
   } = params ?? {};
 
   if (!accessKey || !secretKey) {

package/src/libs/logger.ts

@@ -1,15 +1,16 @@
 /* eslint-disable no-console */
 
+import { isDev } from '../adapters/shared';
+
 const logLevel = ['debug', 'info', 'warn', 'error', 'none'] as const;
 
-export type LogLevel = typeof logLevel[number];
+export type LogLevel = (typeof logLevel)[number];
 
 class Logger {
   private logLevel: LogLevel;
 
   constructor(logLevel?: LogLevel) {
-    this.logLevel =
-      logLevel ?? (process.env.NODE_ENV === 'production' ? 'error' : 'info');
+    this.logLevel = logLevel ?? (isDev() ? 'info' : 'error');
   }
 
   private shouldLog(level: LogLevel): boolean {

package/src/providers/aws/index.ts

@@ -5,8 +5,29 @@ import {
   S3Client,
 } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
-import { type Provider } from '@edgestore/shared';
+import {
+  type MaybePromise,
+  type Provider,
+  type RequestUploadParams,
+} from '@edgestore/shared';
 import { v4 as uuidv4 } from 'uuid';
+import { getEnv } from '../../adapters/shared';
+
+// FileInfo type as received by the provider's requestUpload, part of RequestUploadParams
+type ProviderUploadedFileInfo = RequestUploadParams['fileInfo'];
+
+export type AWSOverwritePathFnArgs = {
+  /* EdgeStore bucket name */
+  esBucketName: string;
+  /* File info after path generation and metadata by EdgeStore */
+  fileInfo: ProviderUploadedFileInfo;
+  /* The S3 key that would be generated by default by this provider */
+  defaultAccessPath: string;
+};
+
+export type AWSOverwritePathFn = (
+  args: AWSOverwritePathFnArgs,
+) => MaybePromise<string>;
 
 export type AWSProviderOptions = {
   /**
@@ -58,21 +79,28 @@ export type AWSProviderOptions = {
    * It can also be set via the `EDGE_STORE_JWT_SECRET` environment variable.
    */
   jwtSecret?: string;
+  /**
+   * Optional function to overwrite the S3 key (object path) for uploads.
+   * This function receives the EdgeStore bucket name, fileInfo and the default S3 key
+   * and should return the desired S3 key string.
+   */
+  overwritePath?: AWSOverwritePathFn;
 };
 
 export function AWSProvider(options?: AWSProviderOptions): Provider {
   const {
-    accessKeyId = process.env.ES_AWS_ACCESS_KEY_ID,
-    secretAccessKey = process.env.ES_AWS_SECRET_ACCESS_KEY,
-    region = process.env.ES_AWS_REGION,
-    bucketName = process.env.ES_AWS_BUCKET_NAME,
-    endpoint = process.env.ES_AWS_ENDPOINT,
-    forcePathStyle = process.env.ES_AWS_FORCE_PATH_STYLE === 'true',
+    accessKeyId = getEnv('ES_AWS_ACCESS_KEY_ID'),
+    secretAccessKey = getEnv('ES_AWS_SECRET_ACCESS_KEY'),
+    region = getEnv('ES_AWS_REGION'),
+    bucketName = getEnv('ES_AWS_BUCKET_NAME'),
+    endpoint = getEnv('ES_AWS_ENDPOINT'),
+    forcePathStyle = getEnv('ES_AWS_FORCE_PATH_STYLE') === 'true',
+    overwritePath,
   } = options ?? {};
 
   const baseUrl =
     options?.baseUrl ??
-    process.env.EDGE_STORE_BASE_URL ??
+    getEnv('EDGE_STORE_BASE_URL') ??
     (endpoint
       ? `${endpoint}/${bucketName}`
       : `https://${bucketName}.s3.${region}.amazonaws.com`);
@@ -119,7 +147,16 @@ export function AWSProvider(options?: AWSProviderOptions): Provider {
         uploadedAt: LastModified,
       };
     },
-    async requestUpload({ bucketName: esBucketName, fileInfo }) {
+    async requestUpload(params: RequestUploadParams) {
+      const { bucketName: esBucketName, fileInfo } = params;
+
+      if (!bucketName) {
+        throw new Error(
+          'S3 bucketName is not configured in AWSProviderOptions.',
+        );
+      }
+
+      // Default S3 key (accessPath) construction logic
       const pathPrefix = `${esBucketName}${
         fileInfo.isPublic ? '/_public' : ''
       }`;
@@ -127,11 +164,21 @@ export function AWSProvider(options?: AWSProviderOptions): Provider {
       const extension = fileInfo.extension
         ? `.${fileInfo.extension.replace('.', '')}`
         : '';
-      const fileName = fileInfo.fileName ?? `${nameId}${extension}`;
-      const filePath = fileInfo.path.reduce((acc, item) => {
+      const defaultResolvedFileName =
+        fileInfo.fileName ?? `${nameId}${extension}`;
+      const defaultFilePathFromMetadata = fileInfo.path.reduce((acc, item) => {
         return `${acc}/${item.value}`;
       }, '');
-      const accessPath = `${pathPrefix}${filePath}/${fileName}`;
+
+      let accessPath = `${pathPrefix}${defaultFilePathFromMetadata}/${defaultResolvedFileName}`;
+
+      if (overwritePath) {
+        accessPath = await overwritePath({
+          esBucketName,
+          fileInfo,
+          defaultAccessPath: accessPath,
+        });
+      }
 
       const command = new PutObjectCommand({
         Bucket: bucketName,
@@ -142,10 +189,10 @@ export function AWSProvider(options?: AWSProviderOptions): Provider {
         expiresIn: 60 * 60, // 1 hour
       });
 
-      const url = `${baseUrl}/${accessPath}`;
+      const finalAccessUrl = `${baseUrl}/${accessPath.startsWith('/') ? accessPath.substring(1) : accessPath}`;
       return {
         uploadUrl: signedUrl,
-        accessUrl: url,
+        accessUrl: finalAccessUrl,
       };
     },
     async requestUploadParts() {
@@ -158,6 +205,11 @@ export function AWSProvider(options?: AWSProviderOptions): Provider {
       throw new Error('Not implemented');
     },
     async deleteFile({ url }) {
+      if (!bucketName) {
+        throw new Error(
+          'S3 bucketName is not configured in AWSProviderOptions for deleteFile.',
+        );
+      }
       const path = url.replace(`${baseUrl}/`, '');
       await s3Client.send(
         new DeleteObjectCommand({

package/src/providers/azure/index.ts

@@ -1,6 +1,7 @@
 import { BlobServiceClient } from '@azure/storage-blob';
 import { type Provider } from '@edgestore/shared';
 import { v4 as uuidv4 } from 'uuid';
+import { getEnv } from '../../adapters/shared';
 
 /**
  * Options for the Azure provider. Compatible with Azure Blob Storage and Azurite.
@@ -41,10 +42,10 @@ export type AzureProviderOptions = {
 
 export function AzureProvider(options?: AzureProviderOptions): Provider {
   const {
-    storageAccountName = process.env.ES_AZURE_ACCOUNT_NAME,
-    sasToken = process.env.ES_AZURE_SAS_TOKEN,
-    containerName = process.env.ES_AZURE_CONTAINER_NAME,
-    customBaseUrl = process.env.ES_AZURE_BASE_URL,
+    storageAccountName = getEnv('ES_AZURE_ACCOUNT_NAME'),
+    sasToken = getEnv('ES_AZURE_SAS_TOKEN'),
+    containerName = getEnv('ES_AZURE_CONTAINER_NAME'),
+    customBaseUrl = getEnv('ES_AZURE_BASE_URL'),
   } = options ?? {};
 
   const baseUrl =

package/src/providers/edgestore/index.ts

@@ -3,6 +3,7 @@ import {
   type Provider,
   type RequestUploadRes,
 } from '@edgestore/shared';
+import { getEnv } from '../../adapters/shared';
 import { initEdgeStoreSdk } from '../../core/sdk';
 import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
 
@@ -29,11 +30,15 @@ export function EdgeStoreProvider(
   options?: EdgeStoreProviderOptions,
 ): Provider {
   const {
-    accessKey = process.env.EDGE_STORE_ACCESS_KEY,
-    secretKey = process.env.EDGE_STORE_SECRET_KEY,
+    accessKey = getEnv('EDGE_STORE_ACCESS_KEY') ??
+      // @ts-expect-error - In Vite/Astro, the env variables are available on `import.meta`.
+      import.meta.env?.EDGE_STORE_ACCESS_KEY,
+    secretKey = getEnv('EDGE_STORE_SECRET_KEY') ??
+      // @ts-expect-error - In Vite/Astro, the env variables are available on `import.meta`.
+      import.meta.env?.EDGE_STORE_SECRET_KEY,
   } = options ?? {};
 
-  const baseUrl = process.env.EDGE_STORE_BASE_URL ?? DEFAULT_BASE_URL;
+  const baseUrl = getEnv('EDGE_STORE_BASE_URL') ?? DEFAULT_BASE_URL;
 
   if (!accessKey || !secretKey) {
     throw new EdgeStoreCredentialsError();

package/adapters/index.d.ts

@@ -1 +0,0 @@
-export * from '../dist/adapters';

package/adapters/index.js

@@ -1 +0,0 @@
-module.exports = require('../dist/adapters');

package/providers/index.d.ts

@@ -1 +0,0 @@
-export * from '../dist/providers';

package/providers/index.js

@@ -1 +0,0 @@
-module.exports = require('../dist/providers');