@edgestore/server 0.0.0-alpha.12

package/dist/providers/edgestore/index.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../index-3999aae6.js');
+
+const DEFAULT_BASE_URL = process.env.EDGE_STORE_BASE_URL ?? 'https://files.edge-store.com';
+function EdgeStoreProvider(options) {
+    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 index.EdgeStoreCredentialsError();
+    }
+    const edgeStoreSdk = index.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 }) {
+            // 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
+            });
+        }
+    };
+}
+
+exports.EdgeStoreProvider = EdgeStoreProvider;

package/dist/providers/edgestore/index.mjs

@@ -0,0 +1,117 @@
+import { E as EdgeStoreCredentialsError, i as initEdgeStoreSdk } from '../../index-ca41982b.mjs';
+
+const DEFAULT_BASE_URL = process.env.EDGE_STORE_BASE_URL ?? 'https://files.edge-store.com';
+function EdgeStoreProvider(options) {
+    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 }) {
+            // 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
+            });
+        }
+    };
+}
+
+export { EdgeStoreProvider };

package/dist/providers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './aws';
+export * from './edgestore';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,aAAa,CAAC"}

package/dist/providers/types.d.ts

@@ -0,0 +1,91 @@
+import { AnyBuilder, EdgeStoreRouter } from '../core/internals/bucketBuilder';
+import { MaybePromise } from '../types';
+export type InitParams = {
+    ctx: any;
+    router: EdgeStoreRouter<any>;
+};
+export type InitRes = {
+    token?: string;
+};
+export type GetFileParams = {
+    url: string;
+};
+export type GetFileRes = {
+    url: string;
+    size: number;
+    uploadedAt: Date;
+    path: {
+        [key: string]: string;
+    };
+    metadata: {
+        [key: string]: string;
+    };
+};
+export type RequestUploadParams = {
+    multipart?: {
+        uploadId?: string;
+        parts: number[];
+    };
+    bucketName: string;
+    bucketType: string;
+    fileInfo: {
+        size: number;
+        extension: string;
+        isPublic: boolean;
+        path: {
+            key: string;
+            value: string;
+        }[];
+        metadata?: {
+            [key: string]: string;
+        };
+        replaceTargetUrl?: string;
+    };
+};
+export type RequestUploadPartsParams = {
+    multipart: {
+        uploadId: string;
+        parts: number[];
+    };
+    path: string;
+};
+export type RequestUploadPartsRes = {
+    multipart: {
+        uploadId: string;
+        parts: {
+            partNumber: number;
+            uploadUrl: string;
+        }[];
+    };
+};
+export type RequestUploadRes = {
+    uploadUrl: string;
+    accessUrl: string;
+} | {
+    multipart: {
+        uploadId: string;
+        partSize: number;
+        totalParts: number;
+        parts: {
+            partNumber: number;
+            uploadUrl: string;
+        }[];
+    };
+    accessUrl: string;
+};
+export type DeleteFileParams = {
+    bucket: AnyBuilder;
+    url: string;
+};
+export type DeleteFileRes = {
+    success: boolean;
+};
+export type Provider = {
+    init: (params: InitParams) => MaybePromise<InitRes>;
+    getBaseUrl: () => MaybePromise<string>;
+    getFile: (params: GetFileParams) => MaybePromise<GetFileRes>;
+    requestUpload: (params: RequestUploadParams) => MaybePromise<RequestUploadRes>;
+    requestUploadParts: (params: RequestUploadPartsParams) => MaybePromise<RequestUploadPartsRes>;
+    deleteFile: (params: DeleteFileParams) => MaybePromise<DeleteFileRes>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/providers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/providers/types.ts"],"names":[],"mappings":"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"}

package/dist/shared-43667670.mjs

@@ -0,0 +1,232 @@
+import { hkdf } from '@panva/hkdf';
+import { serialize } from 'cookie';
+import { EncryptJWT, jwtDecrypt } from 'jose';
+import { v4 } from 'uuid';
+import { _ } from '@swc/helpers/_/_define_property';
+
+const EDGE_STORE_ERROR_CODES = {
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401
+};
+class EdgeStoreError extends Error {
+    constructor(opts){
+        super(opts.message);
+        _(this, "cause", void 0);
+        _(this, "code", void 0);
+        this.name = 'EdgeStoreError';
+        this.code = opts.code;
+        this.cause = opts.cause;
+    }
+}
+
+const IMAGE_MIME_TYPES = [
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+    'image/svg+xml',
+    'image/tiff',
+    'image/bmp',
+    'image/x-icon'
+];
+
+// 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
+async function init(params) {
+    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
+    };
+}
+async function requestUpload(params) {
+    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
+    };
+}
+async function requestUploadParts(params) {
+    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
+    });
+}
+async function deleteFile(params) {
+    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) {
+    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(v4()).encrypt(encryptionSecret);
+}
+async function decryptJWT(token) {
+    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) {
+    return await hkdf('sha256', secret, '', 'Edge Store Generated Encryption Key', 32);
+}
+function buildPath(params) {
+    const { bucket } = params;
+    const pathParams = bucket._def.path;
+    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, key)=>{
+            if (acc2[key] === undefined) {
+                throw new Error(`Missing key ${key} in ${JSON.stringify(acc2)}`);
+            }
+            return acc2[key];
+        }, params.pathAttrs);
+        return {
+            key,
+            value: currParamVal
+        };
+    });
+    return path;
+}
+async function getContext(token) {
+    if (!token) {
+        throw new Error('No token');
+    }
+    return await decryptJWT(token);
+}
+
+export { EdgeStoreError as E, requestUploadParts as a, EDGE_STORE_ERROR_CODES as b, deleteFile as d, init as i, requestUpload as r };