@edgestore/server 0.1.5-alpha.4 → 0.1.5-alpha.6

package/src/core/client/index.ts

@@ -49,13 +49,59 @@ export type UploadOptions = {
   temporary?: boolean;
 };
 
+type TextContent = string;
+type BlobContent = {
+  blob: Blob;
+  extension: string;
+};
+type UrlContent = {
+  url: string;
+  extension: string;
+};
+
+// type guard for `content`
+function isTextContent(
+  content: TextContent | BlobContent | UrlContent,
+): content is TextContent {
+  return typeof content === 'string';
+}
+
+function isBlobContent(
+  content: TextContent | BlobContent | UrlContent,
+): content is BlobContent {
+  return typeof content !== 'string' && 'blob' in content;
+}
+
 export type UploadFileRequest<TBucket extends AnyBuilder> = {
-  content:
-    | string
-    | {
-        blob: Blob;
-        extension: string;
-      };
+  /**
+   * Can be a string, a blob or an url.
+   *
+   * If it's a string, it will be converted to a blob with the type `text/plain`.
+   *
+   * @example
+   * ```ts
+   * // string
+   * content: "some text"
+   * ```
+   *
+   * @example
+   * ```ts
+   * // blob
+   * content: {
+   *   blob: new Blob([text], { type: "text/csv" }),
+   *   extension: "csv",
+   * }
+   * ```
+   *
+   * @example
+   * ```ts
+   * // url
+   * content: {
+   *  url: "https://example.com/my-file.csv",
+   * }
+   * ```
+   */
+  content: TextContent | BlobContent | UrlContent;
   options?: UploadOptions;
 } & (TBucket['$config']['ctx'] extends Record<string, never>
   ? {}
@@ -125,15 +171,50 @@ type EdgeStoreClient<TRouter extends AnyRouter> = {
     getFile: (params: {
       url: string;
     }) => Promise<GetFileRes<TRouter['buckets'][K]>>;
+
+    /**
+     * Use this function to upload a file to the bucket directly from your backend.
+     *
+     * @example
+     * ```ts
+     * // simple example
+     * await backendClient.myBucket.upload({
+     *   content: "some text",
+     * });
+     * ```
+     *
+     * @example
+     * ```ts
+     * // complete example
+     * await backendClient.myBucket.upload({
+     *   content: {
+     *     blob: new Blob([text], { type: "text/csv" }),
+     *     extension: "csv",
+     *   },
+     *   options: {
+     *     temporary: true,
+     *     replaceTargetUrl: replaceUrl,
+     *     manualFileName: "test.csv",
+     *   },
+     *   ctx: {
+     *     userId: "123",
+     *     userRole: "admin",
+     *   },
+     *   input: {
+     *     type: "post",
+     *   },
+     * });
+     * ```
+     */
     upload: (
       params: UploadFileRequest<TRouter['buckets'][K]>,
     ) => Promise<Prettify<UploadFileRes<TRouter['buckets'][K]>>>;
     /**
-     * Confirm a temporary file upload.
+     * Confirm a temporary file upload directly from your backend.
      */
     confirmUpload: (params: { url: string }) => Promise<{ success: boolean }>;
     /**
-     * Programmatically delete a file.
+     * Programmatically delete a file directly from your backend.
      */
     deleteFile: (params: { url: string }) => Promise<{
       success: boolean;
@@ -146,7 +227,7 @@ type EdgeStoreClient<TRouter extends AnyRouter> = {
      */
     listFiles: (
       params?: ListFilesRequest<TRouter['buckets'][K]>,
-    ) => Promise<ListFilesResponse<TRouter['buckets'][K]>>;
+    ) => Promise<Prettify<ListFilesResponse<TRouter['buckets'][K]>>>;
   };
 };
 
@@ -180,17 +261,22 @@ export function initEdgeStoreClient<TRouter extends AnyRouter>(config: {
           const ctx = 'ctx' in params ? params.ctx : {};
           const input = 'input' in params ? params.input : {};
 
-          const { blob, extension } = (() => {
-            if (typeof content === 'string') {
+          const { blob, extension } = await (async () => {
+            if (isTextContent(content)) {
               return {
                 blob: new Blob([content], { type: 'text/plain' }),
                 extension: 'txt',
               };
-            } else {
+            } else if (isBlobContent(content)) {
               return {
                 blob: content.blob,
                 extension: content.extension,
               };
+            } else {
+              return {
+                blob: await getBlobFromUrl(content.url),
+                extension: content.extension,
+              };
             }
           })();
 
@@ -328,6 +414,11 @@ function getUrl(url: string, baseUrl?: string) {
   return url;
 }
 
+async function getBlobFromUrl(url: string) {
+  const res = await fetch(url);
+  return await res.blob();
+}
+
 export type InferClientResponse<TRouter extends AnyRouter> = {
   [TBucketName in keyof TRouter['buckets']]: {
     [TClienFn in keyof EdgeStoreClient<TRouter>[TBucketName]]: Simplify<

package/src/core/index.ts

@@ -7,5 +7,11 @@ export type {
   InferBucketPathObject,
   InferMetadataObject,
 } from './internals/bucketBuilder';
+export type {
+  EdgeStoreErrorCodeKey,
+  EdgeStoreErrorDetails,
+  EdgeStoreJsonResponse,
+} from '../libs/errors/EdgeStoreError';
+export { EdgeStoreApiClientError } from '../libs/errors/EdgeStoreApiClientError';
 
 export type AnyRouter = EdgeStoreRouter<any>;

package/src/core/sdk/index.ts

@@ -1,5 +1,6 @@
 import { type AnyRouter } from '..';
 import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
+import EdgeStoreError from '../../libs/errors/EdgeStoreError';
 import { type AnyContext, type AnyMetadata } from '../internals/bucketBuilder';
 
 const API_ENDPOINT =
@@ -93,7 +94,12 @@ export const edgeStoreRawSdk = {
           path: bucket._def.path.map((p: { [key: string]: () => string }) => {
             const paramEntries = Object.entries(p);
             if (paramEntries[0] === undefined) {
-              throw new Error('Missing path param');
+              throw new EdgeStoreError({
+                message: `Empty path param found in: ${JSON.stringify(
+                  bucket._def.path,
+                )}`,
+                code: 'SERVER_ERROR',
+              });
             }
             const [key, value] = paramEntries[0];
             return {

package/src/libs/errors/EdgeStoreApiClientError.ts

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { type EdgeStoreJsonResponse } from './EdgeStoreError';
+
+export class EdgeStoreApiClientError extends Error {
+  public readonly data: EdgeStoreJsonResponse;
+
+  constructor(opts: { response: EdgeStoreJsonResponse }) {
+    super(opts.response.message);
+    this.name = 'EdgeStoreApiClientError';
+
+    this.data = opts.response;
+  }
+}

package/src/libs/errors/EdgeStoreError.ts

@@ -1,24 +1,93 @@
+import { type Simplify } from '../../types';
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 export const EDGE_STORE_ERROR_CODES = {
   BAD_REQUEST: 400,
+  FILE_TOO_LARGE: 400,
+  MIME_TYPE_NOT_ALLOWED: 400,
   UNAUTHORIZED: 401,
+  UPLOAD_NOT_ALLOWED: 403,
+  DELETE_NOT_ALLOWED: 403,
+  CREATE_CONTEXT_ERROR: 500,
+  SERVER_ERROR: 500,
 } as const;
 
 export type EdgeStoreErrorCodeKey = keyof typeof EDGE_STORE_ERROR_CODES;
 
-class EdgeStoreError extends Error {
+export type EdgeStoreErrorDetails<TCode extends EdgeStoreErrorCodeKey> =
+  TCode extends 'FILE_TOO_LARGE'
+    ? {
+        maxFileSize: number;
+        fileSize: number;
+      }
+    : TCode extends 'MIME_TYPE_NOT_ALLOWED'
+    ? {
+        allowedMimeTypes: string[];
+        mimeType: string;
+      }
+    : never;
+
+export type EdgeStoreJsonResponse = Simplify<
+  | {
+      message: string;
+      code: 'FILE_TOO_LARGE';
+      details: EdgeStoreErrorDetails<'FILE_TOO_LARGE'>;
+    }
+  | {
+      message: string;
+      code: 'MIME_TYPE_NOT_ALLOWED';
+      details: EdgeStoreErrorDetails<'MIME_TYPE_NOT_ALLOWED'>;
+    }
+  | {
+      message: string;
+      code: Exclude<
+        EdgeStoreErrorCodeKey,
+        'FILE_TOO_LARGE' | 'MIME_TYPE_NOT_ALLOWED'
+      >;
+    }
+>;
+
+class EdgeStoreError<TCode extends EdgeStoreErrorCodeKey> extends Error {
   public readonly cause?: Error;
-  public readonly code: EdgeStoreErrorCodeKey;
+  public readonly code: TCode;
+  public readonly level: 'error' | 'warn';
+  public readonly details: EdgeStoreErrorDetails<TCode>;
 
-  constructor(opts: {
-    message: string;
-    code: EdgeStoreErrorCodeKey;
-    cause?: Error;
-  }) {
+  constructor(
+    opts: {
+      message: string;
+      code: TCode;
+      cause?: Error;
+    } & (EdgeStoreErrorDetails<TCode> extends undefined
+      ? object
+      : {
+          details: EdgeStoreErrorDetails<TCode>;
+        }),
+  ) {
     super(opts.message);
     this.name = 'EdgeStoreError';
 
     this.code = opts.code;
     this.cause = opts.cause;
+    this.level = EDGE_STORE_ERROR_CODES[opts.code] >= 500 ? 'error' : 'warn';
+    this.details = 'details' in opts ? opts.details : undefined!;
+  }
+
+  formattedMessage(): string {
+    return `EdgeStore${this.level === 'error' ? 'Error' : 'Info'}: ${
+      this.message
+    }${this.details ? `\n    Details: ${JSON.stringify(this.details)}` : ''}${
+      this.cause ? `\n    Caused by: ${this.cause.message}` : ''
+    }`;
+  }
+
+  formattedJson(): EdgeStoreJsonResponse {
+    return {
+      message:
+        this.code === 'SERVER_ERROR' ? 'Internal server error' : this.message,
+      code: this.code,
+      details: this.details as any,
+    } satisfies EdgeStoreJsonResponse;
   }
 }
 

package/src/libs/logger.ts

@@ -0,0 +1,44 @@
+/* eslint-disable no-console */
+
+const logLevel = ['debug', 'info', 'warn', 'error', 'none'] as const;
+
+export type LogLevel = typeof logLevel[number];
+
+class Logger {
+  private logLevel: LogLevel;
+
+  constructor(logLevel?: LogLevel) {
+    this.logLevel =
+      logLevel ?? process.env.NODE_ENV === 'production' ? 'error' : 'info';
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return logLevel.indexOf(level) >= logLevel.indexOf(this.logLevel);
+  }
+
+  debug(message?: any, ...optionalParams: any[]): void {
+    if (this.shouldLog('debug')) {
+      console.debug(message, ...optionalParams);
+    }
+  }
+
+  info(message?: any, ...optionalParams: any[]): void {
+    if (this.shouldLog('info')) {
+      console.info(message, ...optionalParams);
+    }
+  }
+
+  warn(message?: any, ...optionalParams: any[]): void {
+    if (this.shouldLog('warn')) {
+      console.warn(message, ...optionalParams);
+    }
+  }
+
+  error(message?: any, ...optionalParams: any[]): void {
+    if (this.shouldLog('error')) {
+      console.error(message, ...optionalParams);
+    }
+  }
+}
+
+export default Logger;

package/src/providers/edgestore/index.ts

@@ -1,5 +1,6 @@
 import { initEdgeStoreSdk } from '../../core/sdk';
 import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
+import EdgeStoreError from '../../libs/errors/EdgeStoreError';
 import { type Provider, type RequestUploadRes } from '../types';
 
 const DEFAULT_BASE_URL = 'https://files.edgestore.dev';
@@ -111,7 +112,10 @@ export function EdgeStoreProvider(
             thumbnailUrl: res.thumbnailUrl,
           };
         } else {
-          throw new Error('Could not get upload url');
+          throw new EdgeStoreError({
+            message: 'Could not get upload url',
+            code: 'SERVER_ERROR',
+          });
         }
       }
       const res = await edgeStoreSdk.requestUpload({
@@ -126,7 +130,10 @@ export function EdgeStoreProvider(
           thumbnailUrl: res.thumbnailUrl,
         };
       }
-      throw new Error('Could not get upload url');
+      throw new EdgeStoreError({
+        message: 'Could not get upload url',
+        code: 'SERVER_ERROR',
+      });
     },
     requestUploadParts: async ({ multipart, path }) => {
       const res = await edgeStoreSdk.requestUploadParts({