@edgestore/server 0.0.0-alpha.12

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

@@ -0,0 +1,111 @@
+import { NextRequest } from 'next/server';
+import { EdgeStoreRouter } from '../../../core/internals/bucketBuilder';
+import EdgeStoreError, {
+  EDGE_STORE_ERROR_CODES,
+} from '../../../libs/errors/EdgeStoreError';
+import { EdgeStoreProvider } from '../../../providers/edgestore';
+import { Provider } from '../../../providers/types';
+import { MaybePromise } from '../../../types';
+import {
+  deleteFile,
+  DeleteFileBody,
+  init,
+  requestUpload,
+  RequestUploadBody,
+  requestUploadParts,
+  RequestUploadPartsParams,
+} from '../../shared';
+
+export type CreateContextOptions = {
+  req: NextRequest;
+};
+
+export type Config<TCtx> = {
+  provider?: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  createContext: (opts: CreateContextOptions) => MaybePromise<TCtx>;
+};
+
+export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
+  const { provider = EdgeStoreProvider() } = config;
+  return async (req: NextRequest) => {
+    try {
+      if (req.nextUrl.pathname === '/api/edgestore/init') {
+        const ctx = await config.createContext({ req });
+        const { newCookies, token, baseUrl } = await init({
+          ctx,
+          provider,
+          router: config.router,
+        });
+        return new Response(
+          JSON.stringify({
+            token,
+            baseUrl,
+          }),
+          {
+            status: 200,
+            headers: {
+              'Content-Type': 'application/json',
+              'Set-Cookie': newCookies.join('; '),
+            },
+          },
+        );
+      } else if (req.nextUrl.pathname === '/api/edgestore/request-upload') {
+        const res = await requestUpload({
+          provider,
+          router: config.router,
+          body: (await req.json()) as RequestUploadBody,
+          ctxToken: req.cookies.get('edgestore-ctx')?.value,
+        });
+        return new Response(JSON.stringify(res), {
+          status: 200,
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        });
+      } else if (
+        req.nextUrl.pathname === '/api/edgestore/request-upload-parts'
+      ) {
+        const res = await requestUploadParts({
+          provider,
+          router: config.router,
+          body: (await req.json()) as RequestUploadPartsParams,
+          ctxToken: req.cookies.get('edgestore-ctx')?.value,
+        });
+        return new Response(JSON.stringify(res), {
+          status: 200,
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        });
+      } else if (req.nextUrl.pathname === '/api/edgestore/delete-file') {
+        await deleteFile({
+          provider,
+          router: config.router,
+          body: (await req.json()) as DeleteFileBody,
+          ctxToken: req.cookies.get('edgestore-ctx')?.value,
+        });
+        return new Response(null, {
+          status: 200,
+        });
+      } else {
+        return new Response(null, {
+          status: 404,
+        });
+      }
+    } 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,
+        });
+      }
+      return new Response('Internal server error', {
+        status: 500,
+      });
+    }
+  };
+}

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

@@ -0,0 +1,84 @@
+import { NextApiRequest, NextApiResponse } from 'next/types';
+import { EdgeStoreRouter } from '../../../core/internals/bucketBuilder';
+import EdgeStoreError, {
+  EDGE_STORE_ERROR_CODES,
+} from '../../../libs/errors/EdgeStoreError';
+import { EdgeStoreProvider } from '../../../providers/edgestore';
+import { Provider } from '../../../providers/types';
+import { MaybePromise } from '../../../types';
+import {
+  deleteFile,
+  DeleteFileBody,
+  init,
+  requestUpload,
+  RequestUploadBody,
+  requestUploadParts,
+  RequestUploadPartsParams,
+} from '../../shared';
+
+export type CreateContextOptions = {
+  req: NextApiRequest;
+  res: NextApiResponse;
+};
+
+export type Config<TCtx> = {
+  provider?: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  createContext: (opts: CreateContextOptions) => MaybePromise<TCtx>;
+};
+
+export function createEdgeStoreNextHandler<TCtx>(config: Config<TCtx>) {
+  const { provider = EdgeStoreProvider() } = config;
+  return async (req: NextApiRequest, res: NextApiResponse) => {
+    try {
+      if (req.url === '/api/edgestore/init') {
+        const ctx = await config.createContext({ req, res });
+        const { newCookies, token, baseUrl } = await init({
+          ctx,
+          provider,
+          router: config.router,
+        });
+        res.setHeader('Set-Cookie', newCookies);
+        res.json({
+          token,
+          baseUrl,
+        });
+      } else if (req.url === '/api/edgestore/request-upload') {
+        res.json(
+          await requestUpload({
+            provider,
+            router: config.router,
+            body: req.body as RequestUploadBody,
+            ctxToken: req.cookies['edgestore-ctx'],
+          }),
+        );
+      } else if (req.url === '/api/edgestore/request-upload-parts') {
+        res.json(
+          await requestUploadParts({
+            provider,
+            router: config.router,
+            body: req.body as RequestUploadPartsParams,
+            ctxToken: req.cookies['edgestore-ctx'],
+          }),
+        );
+      } else if (req.url === '/api/edgestore/delete-file') {
+        await deleteFile({
+          provider,
+          router: config.router,
+          body: req.body as DeleteFileBody,
+          ctxToken: req.cookies['edgestore-ctx'],
+        });
+        res.status(200).end();
+      } else {
+        res.status(404).end();
+      }
+    } 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);
+      }
+      res.status(500).send('Internal server error');
+    }
+  };
+}

package/src/adapters/shared.ts

@@ -0,0 +1,306 @@
+import { hkdf } from '@panva/hkdf';
+import { serialize } from 'cookie';
+import { EncryptJWT, jwtDecrypt } from 'jose';
+import { v4 as uuidv4 } from 'uuid';
+import {
+  AnyBuilder,
+  AnyPath,
+  EdgeStoreRouter,
+} from '../core/internals/bucketBuilder';
+import EdgeStoreError from '../libs/errors/EdgeStoreError';
+import { 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
+
+export async function init<TCtx>(params: {
+  provider: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  ctx: TCtx;
+}) {
+  const { ctx, provider, router } = params;
+  const ctxToken = await encryptJWT(ctx);
+  const { token } = await provider.init({
+    ctx,
+    router: router,
+  });
+  const newCookies = [
+    serialize('edgestore-ctx', ctxToken, {
+      path: '/',
+      maxAge: DEFAULT_MAX_AGE,
+    }),
+  ];
+  if (token) {
+    newCookies.push(
+      serialize('edgestore-token', token, {
+        path: '/',
+        maxAge: DEFAULT_MAX_AGE,
+      }),
+    );
+  }
+  const baseUrl = provider.getBaseUrl();
+
+  return {
+    newCookies,
+    token,
+    baseUrl,
+  };
+}
+
+export type RequestUploadBody = {
+  bucketName: string;
+  input: any;
+  fileInfo: {
+    size: number;
+    type: string;
+    extension: string;
+    replaceTargetUrl?: string;
+  };
+};
+
+export async function requestUpload<TCtx>(params: {
+  provider: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  ctxToken: string | undefined;
+  body: RequestUploadBody;
+}) {
+  const {
+    provider,
+    router,
+    ctxToken,
+    body: { bucketName, input, fileInfo },
+  } = params;
+
+  if (!ctxToken) {
+    throw new EdgeStoreError({
+      message: 'Missing edgestore-ctx cookie',
+      code: 'UNAUTHORIZED',
+    });
+  }
+  const ctx = await getContext(ctxToken);
+  const bucket = router.buckets[bucketName];
+  if (!bucket) {
+    throw new Error(`Bucket ${bucketName} not found`);
+  }
+  if (bucket._def.beforeUpload) {
+    const canUpload = await bucket._def.beforeUpload?.({
+      ctx,
+      input,
+      fileInfo: {
+        size: fileInfo.size,
+        type: fileInfo.type,
+        extension: fileInfo.extension,
+        replaceTargetUrl: fileInfo.replaceTargetUrl,
+      },
+    });
+    if (!canUpload) {
+      throw new Error('Upload not allowed');
+    }
+  }
+
+  if (bucket._def.type === 'IMAGE') {
+    if (!IMAGE_MIME_TYPES.includes(fileInfo.type)) {
+      throw new EdgeStoreError({
+        code: 'BAD_REQUEST',
+        message: 'Only images are allowed in this bucket',
+      });
+    }
+  }
+
+  const path = buildPath({
+    fileInfo,
+    bucket,
+    pathAttrs: { ctx, input },
+  });
+  const metadata = await bucket._def.metadata?.({ ctx, input });
+  const isPublic = bucket._def.accessControl === undefined;
+  const requestUploadRes = await provider.requestUpload({
+    bucketName,
+    bucketType: bucket._def.type,
+    fileInfo: {
+      ...fileInfo,
+      path,
+      isPublic,
+      metadata,
+    },
+  });
+  return {
+    ...requestUploadRes,
+    size: fileInfo.size,
+    uploadedAt: new Date().toISOString(),
+    path,
+    metadata,
+  };
+}
+
+export type RequestUploadPartsParams = {
+  multipart: {
+    uploadId: string;
+    parts: number[];
+  };
+  path: string;
+};
+
+export async function requestUploadParts<TCtx>(params: {
+  provider: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  ctxToken: string | undefined;
+  body: RequestUploadPartsParams;
+}) {
+  const {
+    provider,
+    router,
+    ctxToken,
+    body: { multipart, path },
+  } = params;
+  if (!ctxToken) {
+    throw new EdgeStoreError({
+      message: 'Missing edgestore-ctx cookie',
+      code: 'UNAUTHORIZED',
+    });
+  }
+  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({
+    multipart,
+    path,
+  });
+}
+
+export type DeleteFileBody = {
+  bucketName: string;
+  url: string;
+};
+
+export async function deleteFile<TCtx>(params: {
+  provider: Provider;
+  router: EdgeStoreRouter<TCtx>;
+  ctxToken: string | undefined;
+  body: DeleteFileBody;
+}) {
+  const {
+    provider,
+    router,
+    ctxToken,
+    body: { bucketName, url },
+  } = params;
+
+  if (!ctxToken) {
+    throw new EdgeStoreError({
+      message: 'Missing edgestore-ctx cookie',
+      code: 'UNAUTHORIZED',
+    });
+  }
+  const ctx = await getContext(ctxToken);
+  const bucket = router.buckets[bucketName];
+  if (!bucket) {
+    throw new Error(`Bucket ${bucketName} not found`);
+  }
+
+  if (!bucket._def.beforeDelete) {
+    throw new Error(
+      'You need to define beforeDelete if you want to delete files directly from the frontend.',
+    );
+  }
+
+  const file = await provider.getFile({
+    url,
+  });
+  const canDelete = await bucket._def.beforeDelete({
+    ctx,
+    file,
+  });
+  if (!canDelete) {
+    throw new Error('Delete not allowed');
+  }
+  await provider.deleteFile({
+    bucket,
+    url,
+  });
+}
+
+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',
+    );
+  }
+  const encryptionSecret = await getDerivedEncryptionKey(secret);
+  return await new EncryptJWT(ctx)
+    .setProtectedHeader({ alg: 'dir', enc: 'A256GCM' })
+    .setIssuedAt()
+    .setExpirationTime(Date.now() / 1000 + DEFAULT_MAX_AGE)
+    .setJti(uuidv4())
+    .encrypt(encryptionSecret);
+}
+
+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',
+    );
+  }
+  const encryptionSecret = await getDerivedEncryptionKey(secret);
+  const { payload } = await jwtDecrypt(token, encryptionSecret, {
+    clockTolerance: 15,
+  });
+  return payload;
+}
+
+async function getDerivedEncryptionKey(secret: string) {
+  return await hkdf(
+    'sha256',
+    secret,
+    '',
+    'Edge Store Generated Encryption Key',
+    32,
+  );
+}
+
+function buildPath(params: {
+  fileInfo: RequestUploadBody['fileInfo'];
+  bucket: AnyBuilder;
+  pathAttrs: {
+    ctx: any;
+    input: any;
+  };
+}) {
+  const { bucket } = params;
+  const pathParams = bucket._def.path as AnyPath;
+  const path = pathParams.map((param) => {
+    const paramEntries = Object.entries(param);
+    if (paramEntries[0] === undefined) {
+      throw new Error('Missing path param');
+    }
+    const [key, value] = paramEntries[0];
+    // this is a string like: "ctx.xxx" or "input.yyy.zzz"
+    const currParamVal = value()
+      .split('.')
+      .reduce((acc2: any, key: string) => {
+        if (acc2[key] === undefined) {
+          throw new Error(`Missing key ${key} in ${JSON.stringify(acc2)}`);
+        }
+        return acc2[key];
+      }, params.pathAttrs as any) as string;
+    return {
+      key,
+      value: currParamVal,
+    };
+  });
+  return path;
+}
+
+async function getContext(token?: string) {
+  if (!token) {
+    throw new Error('No token');
+  }
+  return await decryptJWT(token);
+}

package/src/core/client/index.ts

@@ -0,0 +1,202 @@
+import { AnyRouter, Comparison } from '..';
+import { Simplify } from '../../types';
+import {
+  AnyBuilder,
+  InferBucketPathKeys,
+  InferMetadataObject,
+} from '../internals/bucketBuilder';
+import { initEdgeStoreSdk } from '../sdk';
+
+export type GetFileRes<TBucket extends AnyBuilder> = {
+  url: string;
+  size: number;
+  uploadedAt: Date;
+  metadata: InferMetadataObject<TBucket>;
+  path: {
+    [TKey in InferBucketPathKeys<TBucket>]: string;
+  };
+};
+
+type Filter<TBucket extends AnyBuilder> = {
+  AND?: Filter<TBucket>[];
+  OR?: Filter<TBucket>[];
+  uploadedAt?: Comparison<Date>;
+  path?: {
+    [K in InferBucketPathKeys<TBucket>]?: Comparison;
+  };
+  metadata?: {
+    [K in keyof InferMetadataObject<TBucket>]?: Comparison;
+  };
+};
+
+export type ListFilesRequest<TBucket extends AnyBuilder> = {
+  filter?: Filter<TBucket>;
+  pagination?: {
+    currentPage: number;
+    pageSize: number;
+  };
+};
+
+export type ListFilesResponse<TBucket extends AnyBuilder> = {
+  data: {
+    url: string;
+    thumbnailUrl: TBucket['_def']['type'] extends 'IMAGE'
+      ? string | null
+      : never;
+    size: number;
+    uploadedAt: Date;
+    metadata: InferMetadataObject<TBucket>;
+    path: {
+      [TKey in InferBucketPathKeys<TBucket>]: string;
+    };
+  }[];
+  pagination: {
+    currentPage: number;
+    totalPages: number;
+    totalCount: number;
+  };
+};
+
+type EdgeStoreClient<TRouter extends AnyRouter> = {
+  [K in keyof TRouter['buckets']]: {
+    getFile: (params: {
+      url: string;
+    }) => Promise<GetFileRes<TRouter['buckets'][K]>>;
+    // TODO: replace with `upload`
+    // requestUpload: (params: {
+    //   file: File;
+    //   path: {
+    //     [TKey in InferBucketPathKeys<TRouter['buckets'][K]>]: string;
+    //   };
+    //   metadata: InferMetadataObject<TRouter['buckets'][K]>;
+    //   replaceTargetUrl?: string;
+    // }) => Promise<{
+    //   uploadUrl: string;
+    //   accessUrl: string;
+    // }>;
+    /**
+     * Programmatically delete a file.
+     */
+    deleteFile: (params: { url: string }) => Promise<{
+      success: boolean;
+    }>;
+    /**
+     * List files in a bucket.
+     *
+     * You can also filter the results by passing a filter object.
+     * The results are paginated.
+     */
+    listFiles: (
+      params?: ListFilesRequest<TRouter['buckets'][K]>,
+    ) => Promise<ListFilesResponse<TRouter['buckets'][K]>>;
+  };
+};
+
+export function initEdgeStoreClient<TRouter extends AnyRouter>(config: {
+  router: TRouter;
+  accessKey?: string;
+  secretKey?: string;
+}) {
+  const sdk = initEdgeStoreSdk({
+    accessKey: config.accessKey,
+    secretKey: config.secretKey,
+  });
+  return new Proxy<EdgeStoreClient<TRouter>>({} as any, {
+    get(_target, key) {
+      const bucketName = key as string;
+      const bucket = config.router.buckets[bucketName];
+      if (!bucket) {
+        throw new Error(`Bucket ${bucketName} not found`);
+      }
+      const client: EdgeStoreClient<TRouter>[string] = {
+        async getFile(params) {
+          const res = await sdk.getFile(params);
+          return {
+            url: res.url,
+            size: res.size,
+            uploadedAt: new Date(res.uploadedAt),
+            metadata: res.metadata,
+            path: res.path as any,
+          } satisfies GetFileRes<typeof bucket> as GetFileRes<
+            TRouter['buckets'][string]
+          >;
+        },
+        // TODO: Replace with `upload`
+        // async requestUpload(params) {
+        //   const { file, path, metadata, replaceTargetUrl } = params;
+        //   const fileExtension = file.name.includes('.')
+        //     ? file.name.split('.').pop()
+        //     : undefined;
+        //   if (!fileExtension) {
+        //     throw new Error('Missing file extension');
+        //   }
+        //   const parsedPath = Object.keys(bucket._def.path).map((key) => {
+        //     const value = path[key as keyof typeof path];
+        //     if (value === undefined) {
+        //       throw new Error(`Missing path param ${key}`);
+        //     }
+        //     return {
+        //       key,
+        //       value,
+        //     };
+        //   });
+
+        //   const fileInfo = {
+        //     size: file.size,
+        //     extension: fileExtension,
+        //     isPublic: bucket._def.accessControl === undefined,
+        //     path: parsedPath,
+        //     metadata,
+        //     replaceTargetUrl,
+        //   };
+
+        //   return await sdk.requestUpload({
+        //     bucketName,
+        //     bucketType: bucket._def.type,
+        //     fileInfo,
+        //   });
+        // },
+
+        async deleteFile(params) {
+          return await sdk.deleteFile({
+            ...params,
+          });
+        },
+
+        async listFiles(params) {
+          const res = await sdk.listFiles({
+            bucketName,
+            ...params,
+          });
+
+          const files = res.data.map((file) => {
+            return {
+              url: file.url,
+              thumbnailUrl: file.thumbnailUrl,
+              size: file.size,
+              uploadedAt: new Date(file.uploadedAt),
+              metadata: file.metadata,
+              path: file.path as any,
+            };
+          }) satisfies ListFilesResponse<
+            typeof bucket
+          >['data'] as ListFilesResponse<TRouter['buckets'][string]>['data'];
+
+          return {
+            data: files,
+            pagination: res.pagination,
+          };
+        },
+      };
+      return client;
+    },
+  });
+}
+
+export type InferClientResponse<TRouter extends AnyRouter> = {
+  [TBucketName in keyof TRouter['buckets']]: {
+    [TClienFn in keyof EdgeStoreClient<TRouter>[TBucketName]]: Simplify<
+      Awaited<ReturnType<EdgeStoreClient<TRouter>[TBucketName][TClienFn]>>
+    >;
+  };
+};

package/src/core/index.ts

@@ -0,0 +1,10 @@
+import { EdgeStoreRouter } from './internals/bucketBuilder';
+
+export * from './client';
+export * from './sdk';
+export type {
+  InferBucketPathKeys,
+  InferMetadataObject,
+} from './internals/bucketBuilder';
+
+export type AnyRouter = EdgeStoreRouter<any>;