@edgestore/server 0.0.0-alpha.12

package/src/core/sdk/index.ts

@@ -0,0 +1,381 @@
+import { AnyRouter } from '..';
+import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
+import { AnyContext } from '../internals/bucketBuilder';
+
+const API_ENDPOINT =
+  process.env.EDGE_STORE_API_ENDPOINT ?? 'https://api.edge-store.com';
+
+type FileInfoForUpload = {
+  size: number;
+  extension: string;
+  isPublic: boolean;
+  path: {
+    key: string;
+    value: string;
+  }[];
+  metadata?: {
+    [key: string]: string;
+  };
+  replaceTargetUrl?: string;
+};
+
+export type SimpleOperator =
+  | 'eq'
+  | 'neq'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'startsWith'
+  | 'endsWith';
+
+export type Comparison<TType = string> =
+  | TType
+  | Partial<
+      {
+        [K in SimpleOperator]: TType;
+      } & {
+        between: [TType, TType];
+      }
+    >;
+
+type ListFilesFilter = {
+  AND?: ListFilesFilter[];
+  OR?: ListFilesFilter[];
+  uploadedAt?: Comparison<Date>;
+  path?: Partial<{
+    [key: string]: Comparison;
+  }>;
+  metadata?: Partial<{
+    [key: string]: Comparison;
+  }>;
+};
+
+type Pagination = {
+  currentPage: number;
+  pageSize: number;
+};
+
+async function makeRequest<TOutput>(params: {
+  body: object;
+  accessKey: string;
+  secretKey: string;
+  path: string;
+}) {
+  const { body, accessKey, secretKey, path } = params;
+  const res = await fetch(`${API_ENDPOINT}${path}`, {
+    method: 'POST',
+    body: JSON.stringify(body),
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Basic ${Buffer.from(`${accessKey}:${secretKey}`).toString(
+        'base64',
+      )}`,
+    },
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to make request to ${path}`);
+  }
+  return (await res.json()) as TOutput;
+}
+
+export const edgeStoreRawSdk = {
+  async getToken(params: {
+    accessKey: string;
+    secretKey: string;
+    ctx: AnyContext;
+    router: AnyRouter;
+  }) {
+    const reqBuckets = Object.entries(params.router.buckets).reduce(
+      (acc, [bucketName, bucket]) => {
+        acc[bucketName] = {
+          path: bucket._def.path.map((p: { [key: string]: () => string }) => {
+            const paramEntries = Object.entries(p);
+            if (paramEntries[0] === undefined) {
+              throw new Error('Missing path param');
+            }
+            const [key, value] = paramEntries[0];
+            return {
+              key,
+              value: value(),
+            };
+          }),
+          accessControl: bucket._def.accessControl,
+        };
+        return acc;
+      },
+      {} as any,
+    );
+    const { token } = await makeRequest<{ token: string }>({
+      body: {
+        ctx: params.ctx,
+        buckets: reqBuckets,
+      },
+      accessKey: params.accessKey,
+      secretKey: params.secretKey,
+      path: '/get-token',
+    });
+    return token;
+  },
+
+  async getFile({
+    accessKey,
+    secretKey,
+    url,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    url: string;
+  }) {
+    return await makeRequest<{
+      url: string;
+      size: number;
+      uploadedAt: string;
+      path: Record<string, string>;
+      metadata: Record<string, string>;
+    }>({
+      path: '/get-file',
+      accessKey,
+      secretKey,
+      body: {
+        url,
+      },
+    });
+  },
+
+  async requestUpload({
+    accessKey,
+    secretKey,
+    bucketName,
+    bucketType,
+    fileInfo,
+    multipart,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    bucketName: string;
+    bucketType: string;
+    fileInfo: FileInfoForUpload;
+    multipart?: {
+      parts: number[];
+    };
+  }) {
+    const res = await makeRequest<{
+      multipart?: {
+        uploadId: string;
+        parts: {
+          partNumber: number;
+          signedUrl: string;
+        }[];
+      };
+      signedUrl?: string;
+      url: string;
+    }>({
+      path: '/request-upload',
+      accessKey,
+      secretKey,
+      body: {
+        multipart,
+        bucketName,
+        bucketType,
+        isPublic: fileInfo.isPublic,
+        path: fileInfo.path,
+        extension: fileInfo.extension,
+        size: fileInfo.size,
+        metadata: fileInfo.metadata,
+        replaceTargetUrl: fileInfo.replaceTargetUrl,
+      },
+    });
+    return {
+      multipart: res.multipart,
+      signedUrl: res.signedUrl,
+      accessUrl: res.url,
+    };
+  },
+
+  async requestUploadParts({
+    accessKey,
+    secretKey,
+    key,
+    multipart,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    key: string;
+    multipart: {
+      uploadId?: string;
+      parts: number[];
+    };
+  }) {
+    const res = await makeRequest<{
+      multipart: {
+        uploadId: string;
+        parts: {
+          partNumber: number;
+          signedUrl: string;
+        }[];
+      };
+    }>({
+      path: '/request-upload-parts',
+      accessKey,
+      secretKey,
+      body: {
+        multipart,
+        key,
+      },
+    });
+    return {
+      multipart: res.multipart,
+    };
+  },
+
+  async deleteFile({
+    accessKey,
+    secretKey,
+    url,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    url: string;
+  }) {
+    return await makeRequest<{ success: boolean }>({
+      path: '/delete-file',
+      accessKey,
+      secretKey,
+      body: {
+        url,
+      },
+    });
+  },
+
+  async listFiles({
+    accessKey,
+    secretKey,
+    bucketName,
+    filter,
+    pagination,
+  }: {
+    accessKey: string;
+    secretKey: string;
+    bucketName: string;
+    filter?: ListFilesFilter;
+    pagination?: Pagination;
+  }) {
+    return await makeRequest<{
+      data: {
+        url: string;
+        thumbnailUrl: string | null;
+        size: number;
+        uploadedAt: string;
+        path: Record<string, string>;
+        metadata: Record<string, string>;
+      }[];
+      pagination: {
+        currentPage: number;
+        pageSize: number;
+        totalPages: number;
+        totalCount: number;
+      };
+    }>({
+      path: '/list-files',
+      accessKey,
+      secretKey,
+      body: {
+        bucketName,
+        filter,
+        pagination,
+      },
+    });
+  },
+};
+
+export function initEdgeStoreSdk(params: {
+  accessKey?: string;
+  secretKey?: string;
+}) {
+  const {
+    accessKey = process.env.EDGE_STORE_ACCESS_KEY,
+    secretKey = process.env.EDGE_STORE_SECRET_KEY,
+  } = params ?? {};
+
+  if (!accessKey || !secretKey) {
+    throw new EdgeStoreCredentialsError();
+  }
+
+  return {
+    async getToken(params: { ctx: AnyContext; router: AnyRouter }) {
+      return await edgeStoreRawSdk.getToken({
+        accessKey,
+        secretKey,
+        ctx: params.ctx,
+        router: params.router,
+      });
+    },
+    async getFile({ url }: { url: string }) {
+      return await edgeStoreRawSdk.getFile({
+        accessKey,
+        secretKey,
+        url,
+      });
+    },
+    async requestUpload({
+      bucketName,
+      bucketType,
+      fileInfo,
+      multipart,
+    }: {
+      bucketName: string;
+      bucketType: string;
+      fileInfo: FileInfoForUpload;
+      multipart?: {
+        parts: number[];
+      };
+    }) {
+      return await edgeStoreRawSdk.requestUpload({
+        accessKey,
+        secretKey,
+        bucketName,
+        bucketType,
+        fileInfo,
+        multipart,
+      });
+    },
+    async requestUploadParts({
+      key,
+      multipart,
+    }: {
+      key: string;
+      multipart: {
+        uploadId?: string;
+        parts: number[];
+      };
+    }) {
+      return await edgeStoreRawSdk.requestUploadParts({
+        accessKey,
+        secretKey,
+        key,
+        multipart,
+      });
+    },
+    async deleteFile({ url }: { url: string }) {
+      return await edgeStoreRawSdk.deleteFile({
+        accessKey,
+        secretKey,
+        url,
+      });
+    },
+    async listFiles(params: {
+      bucketName: string;
+      filter?: ListFilesFilter;
+      pagination?: Pagination;
+    }) {
+      return await edgeStoreRawSdk.listFiles({
+        accessKey,
+        secretKey,
+        ...params,
+      });
+    },
+  };
+}
+
+export type EdgeStoreSdk = ReturnType<typeof initEdgeStoreSdk>;

package/src/index.ts

@@ -0,0 +1 @@
+export { initEdgeStore } from './core/internals/bucketBuilder';

package/src/libs/errors/EdgeStoreCredentialsError.ts

@@ -0,0 +1,12 @@
+const DEFAULT_MESSAGE = `Missing EDGE_STORE_ACCESS_KEY or EDGE_STORE_SECRET_KEY. 
+This can happen if you are trying to use the vanilla client in your frontend.
+The vanilla client should only be used in the backend.`;
+
+class EdgeStoreCredentialsError extends Error {
+  constructor(message = DEFAULT_MESSAGE) {
+    super(message);
+    this.name = 'EdgeStoreCredentialsError';
+  }
+}
+
+export default EdgeStoreCredentialsError;

package/src/libs/errors/EdgeStoreError.ts

@@ -0,0 +1,25 @@
+export const EDGE_STORE_ERROR_CODES = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+} as const;
+
+export type EdgeStoreErrorCodeKey = keyof typeof EDGE_STORE_ERROR_CODES;
+
+class EdgeStoreError extends Error {
+  public readonly cause?: Error;
+  public readonly code: EdgeStoreErrorCodeKey;
+
+  constructor(opts: {
+    message: string;
+    code: EdgeStoreErrorCodeKey;
+    cause?: Error;
+  }) {
+    super(opts.message);
+    this.name = 'EdgeStoreError';
+
+    this.code = opts.code;
+    this.cause = opts.cause;
+  }
+}
+
+export default EdgeStoreError;

package/src/providers/aws/index.ts

@@ -0,0 +1,109 @@
+import {
+  DeleteObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { v4 as uuidv4 } from 'uuid';
+import { Provider } from '../types';
+
+export type AWSProviderOptions = {
+  accessKeyId?: string;
+  secretAccessKey?: string;
+  region?: string;
+  bucketName?: string;
+};
+
+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,
+  } = options ?? {};
+
+  const credentials =
+    accessKeyId && secretAccessKey
+      ? {
+          accessKeyId,
+          secretAccessKey,
+        }
+      : undefined;
+  const s3Client = new S3Client({ region, credentials });
+
+  const baseUrl =
+    process.env.EDGE_STORE_BASE_URL ??
+    `https://${bucketName}.s3.${region}.amazonaws.com`;
+
+  return {
+    async init() {
+      return {};
+    },
+    getBaseUrl() {
+      return baseUrl;
+    },
+    async getFile({ url }) {
+      const path = url.replace(`${baseUrl}/`, '');
+      const { ContentLength, LastModified } = await s3Client.send(
+        new HeadObjectCommand({
+          Bucket: bucketName,
+          Key: path,
+        }),
+      );
+
+      if (!ContentLength || !LastModified) {
+        throw new Error('File not found');
+      }
+
+      return {
+        url,
+        metadata: {},
+        path: {},
+        size: ContentLength,
+        uploadedAt: LastModified,
+      };
+    },
+    async requestUpload({ bucketName, fileInfo }) {
+      const pathPrefix = `${bucketName}${fileInfo.isPublic ? '/_public' : ''}`;
+      const nameId = uuidv4();
+      const extension = fileInfo.extension
+        ? `.${fileInfo.extension.replace('.', '')}`
+        : '';
+      const fileName = `${nameId}${extension}`;
+      const filePath = fileInfo.path.reduce((acc, item) => {
+        return `${acc}/${item.value}`;
+      }, '');
+
+      const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: `${pathPrefix}/${filePath}/${fileName}`,
+      });
+
+      const signedUrl = await getSignedUrl(s3Client, command, {
+        expiresIn: 60 * 60, // 1 hour
+      });
+
+      const url = `${baseUrl}/${fileInfo.path}`;
+      return {
+        uploadUrl: signedUrl,
+        accessUrl: url,
+      };
+    },
+    async requestUploadParts() {
+      throw new Error('Not implemented');
+    },
+    async deleteFile({ url }) {
+      const path = url.replace(`${baseUrl}/`, '');
+      await s3Client.send(
+        new DeleteObjectCommand({
+          Bucket: bucketName,
+          Key: path,
+        }),
+      );
+      return {
+        success: true,
+      };
+    },
+  };
+}

package/src/providers/edgestore/index.ts

@@ -0,0 +1,140 @@
+import { initEdgeStoreSdk } from '../../core/sdk';
+import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
+import { Provider, RequestUploadRes } from '../types';
+
+const DEFAULT_BASE_URL =
+  process.env.EDGE_STORE_BASE_URL ?? 'https://files.edge-store.com';
+
+export type EdgeStoreProviderOptions = {
+  accessKey?: string;
+  secretKey?: string;
+  baseUrl?: string;
+};
+
+export function EdgeStoreProvider(
+  options?: EdgeStoreProviderOptions,
+): Provider {
+  const {
+    accessKey = process.env.EDGE_STORE_ACCESS_KEY,
+    secretKey = process.env.EDGE_STORE_SECRET_KEY,
+    baseUrl = process.env.EDGE_STORE_BASE_URL ?? DEFAULT_BASE_URL,
+  } = options ?? {};
+
+  if (!accessKey || !secretKey) {
+    throw new EdgeStoreCredentialsError();
+  }
+
+  const edgeStoreSdk = initEdgeStoreSdk({
+    accessKey,
+    secretKey,
+  });
+  return {
+    init: async ({ ctx, router }) => {
+      const token = await edgeStoreSdk.getToken({
+        ctx,
+        router,
+      });
+      return {
+        token,
+      };
+    },
+    getBaseUrl() {
+      return baseUrl;
+    },
+    getFile: async ({ url }) => {
+      const { uploadedAt, ...rest } = await edgeStoreSdk.getFile({
+        url,
+      });
+      return {
+        uploadedAt: new Date(uploadedAt),
+        ...rest,
+      };
+    },
+    async requestUpload({
+      bucketName,
+      bucketType,
+      fileInfo,
+    }): Promise<RequestUploadRes> {
+      // multiplart upload if file is bigger than a certain size
+      const MULTIPART_THRESHOLD = 10 * 1024 * 1024; // 10MB
+      const CONCURRENCY = 3;
+      let partSize = 5 * 1024 * 1024; // 5MB
+      if (fileInfo.size > MULTIPART_THRESHOLD) {
+        let totalParts = Math.ceil(fileInfo.size / partSize);
+        if (totalParts > 10000) {
+          // the maximum number of parts is 10000
+          totalParts = 10000;
+          partSize = Math.ceil(fileInfo.size / totalParts);
+        }
+        const requestParts =
+          totalParts > CONCURRENCY ? CONCURRENCY : totalParts;
+        const res = await edgeStoreSdk.requestUpload({
+          bucketName,
+          bucketType,
+          fileInfo,
+          multipart: {
+            parts: Array.from({ length: requestParts }).map(
+              (_, index) => index + 1,
+            ),
+          },
+        });
+        const multipart = res.multipart
+          ? {
+              uploadId: res.multipart.uploadId,
+              parts: res.multipart.parts.map((part) => ({
+                partNumber: part.partNumber,
+                uploadUrl: part.signedUrl,
+              })),
+              partSize,
+              totalParts,
+            }
+          : undefined;
+        if (multipart) {
+          return {
+            accessUrl: res.accessUrl,
+            multipart,
+          };
+        } else if (res.signedUrl) {
+          return {
+            accessUrl: res.accessUrl,
+            uploadUrl: res.signedUrl,
+          };
+        } else {
+          throw new Error('Could not get upload url');
+        }
+      }
+      const res = await edgeStoreSdk.requestUpload({
+        bucketName,
+        bucketType,
+        fileInfo,
+      });
+      if (res.signedUrl) {
+        return {
+          accessUrl: res.accessUrl,
+          uploadUrl: res.signedUrl,
+        };
+      }
+      throw new Error('Could not get upload url');
+    },
+    requestUploadParts: async ({ multipart, path }) => {
+      const res = await edgeStoreSdk.requestUploadParts({
+        multipart,
+        key: path,
+      });
+      return {
+        multipart: {
+          uploadId: res.multipart.uploadId,
+          parts: res.multipart.parts.map((part) => ({
+            partNumber: part.partNumber,
+            uploadUrl: part.signedUrl,
+          })),
+        },
+      };
+    },
+    deleteFile: async ({ url }) => {
+      return await edgeStoreSdk.deleteFile({
+        url,
+      });
+    },
+  };
+}

package/src/providers/index.ts

@@ -0,0 +1,2 @@
+export * from './aws';
+export * from './edgestore';