feat: catch errors internally

create custom error type

Author: dragonish

README.md

@@ -20,16 +20,50 @@ npm install userscript-with-webdav
 
 ## Usage
 
-When embed:
+Example:
 
-```javascript
+```typescript
+// When embed:
 import Webdav from 'userscript-with-webdav';
+
+(async () => {
+  const wh = new Webdav('<webDAVURL>', '<webDAVUser>', '<webDAVPassword>');
+
+  // download
+  try {
+    const res = await wh.download('path/to/your/file');
+    console.log('status:', res.status);
+    console.log('data:', res.data);
+  } catch (err) {
+    if (err instanceof Webdav.NotFound) {
+      console.error('file does not exist');
+    } else if (err instanceof Webdav.Unauthorized) {
+      console.error('authentication failed');
+    }
+  }
+
+  // upload
+  try {
+    await wh.upload('path/to/your/file', '<data>');
+  } catch (err) {
+    if (err instanceof Webdav.Forbidden) {
+      console.error('permission error');
+    }
+  }
+})();
 ```
 
 ## Type
 
 ```typescript
-class Webdav {
+declare class Webdav {
+  static InternalError: typeof InternalError;
+  static Unauthorized: typeof Unauthorized;
+  static Forbidden: typeof Forbidden;
+  static NotFound: typeof NotFound;
+  static Redirection: typeof Redirection;
+  static ClientSideError: typeof ClientSideError;
+  static ServerSideError: typeof ServerSideError;
   /**
    * Constructor
    * @param domainURL WebDAV domain
@@ -38,34 +72,30 @@ class Webdav {
    */
   constructor(domainURL?: string, user?: string, password?: string);
   /**
-   * Update Config
-   * @param domainURL WebDAV domain
-   * @param user User name
-   * @param password User password
+   * Generate validation request header
+   * @returns Verification request header
    */
   updateConfig(domainURL: string, user: string, password: string): void;
   /**
    * Download file content
    * @param fileURL Relative file URL
    * @returns Response
    */
-  download(fileURL: string): Promise<{
-    status: number;
-    data: string;
-  }>;
+  download(fileURL: string): Promise<ConnectionResponse>;
   /**
    * Upload file content
    * @param fileURL Relative file URL
    * @param data Data
    * @returns Response
    */
-  upload(
-    fileURL: string,
-    data: string
-  ): Promise<{
+  upload(fileURL: string, data: string): Promise<ConnectionResponse>;
+}
+
+declare interface ConnectionResponse {
+    /** Response status code */
     status: number;
-    data: any;
-  }>;
+    /** Response data */
+    data: string;
 }
 ```
 

src/common/errors.ts

@@ -0,0 +1,48 @@
+export class InternalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InternalError';
+  }
+}
+
+export class Unauthorized extends Error {
+  constructor() {
+    super('unauthorized (401)');
+    this.name = 'Unauthorized';
+  }
+}
+
+export class Forbidden extends Error {
+  constructor() {
+    super('forbidden (403)');
+    this.name = 'Forbidden';
+  }
+}
+
+export class NotFound extends Error {
+  constructor() {
+    super('not found (404)');
+    this.name = 'NotFound';
+  }
+}
+
+export class Redirection extends Error {
+  constructor(code: number) {
+    super(`redirection (${code})`);
+    this.name = 'Redirection';
+  }
+}
+
+export class ClientSideError extends Error {
+  constructor(code: number) {
+    super(`client-side error (${code})`);
+    this.name = 'ClientSideError';
+  }
+}
+
+export class ServerSideError extends Error {
+  constructor(code: number) {
+    super(`server-side error (${code})`);
+    this.name = 'ServerSideError';
+  }
+}

src/index.ts

@@ -1,6 +1,22 @@
 import G from './common/gm';
+import { InternalError, Unauthorized, Forbidden, NotFound, Redirection, ClientSideError, ServerSideError } from './common/errors';
+
+interface ConnectionResponse {
+  /** Response status code */
+  status: number;
+  /** Response data */
+  data: string;
+}
 
 class Webdav {
+  static InternalError = InternalError;
+  static Unauthorized = Unauthorized;
+  static Forbidden = Forbidden;
+  static NotFound = NotFound;
+  static Redirection = Redirection;
+  static ClientSideError = ClientSideError;
+  static ServerSideError = ServerSideError;
+
   /**
    * Constructor
    * @param domainURL WebDAV domain
@@ -36,6 +52,35 @@ class Webdav {
     return this.domainURL + fileURL;
   }
 
+  /**
+   * Data Encapsulation
+   * @param status status code
+   * @param data data
+   * @returns
+   */
+  private dataEncapsulation(status: number, data: string): ConnectionResponse {
+    if (status === -1) {
+      throw new Webdav.InternalError('internal program error');
+    } else if (status === 401) {
+      throw new Webdav.Unauthorized();
+    } else if (status === 403) {
+      throw new Webdav.Forbidden();
+    } else if (status === 404) {
+      throw new Webdav.NotFound();
+    } else if (status >= 300 && status < 400) {
+      throw new Webdav.Redirection(status);
+    } else if (status >= 400 && status < 500) {
+      throw new Webdav.ClientSideError(status);
+    } else if (status >= 500) {
+      throw new Webdav.ServerSideError(status);
+    }
+
+    return {
+      status,
+      data,
+    };
+  }
+
   /**
    * Update Config
    * @param domainURL WebDAV domain
@@ -53,23 +98,24 @@ class Webdav {
    * @param fileURL Relative file URL
    * @returns Response
    */
-  async download(fileURL: string) {
+  async download(fileURL: string): Promise<ConnectionResponse> {
     const headers = this.generateHeaders();
+    let status = 0,
+      data = '';
+
     try {
       const res = await G.ajax(this.generateFullURL(fileURL), {
         method: 'GET',
         headers,
       });
-      return {
-        status: res.status,
-        data: res.responseText,
-      };
+      status = res.status;
+      data = res.responseText;
     } catch {
-      return {
-        status: -1,
-        data: '',
-      };
+      status = -1;
+      data = '';
     }
+
+    return this.dataEncapsulation(status, data);
   }
 
   /**
@@ -78,24 +124,25 @@ class Webdav {
    * @param data Data
    * @returns Response
    */
-  async upload(fileURL: string, data: string) {
+  async upload(fileURL: string, data: string): Promise<ConnectionResponse> {
     const headers = this.generateHeaders();
+    let status = 0,
+      resData = '';
+
     try {
       const res = await G.ajax(this.generateFullURL(fileURL), {
         method: 'PUT',
         headers,
         data,
       });
-      return {
-        status: res.status,
-        data: res.response,
-      };
+      status = res.status;
+      resData = res.response;
     } catch {
-      return {
-        status: -1,
-        data: null,
-      };
+      status = -1;
+      resData = '';
     }
+
+    return this.dataEncapsulation(status, resData);
   }
 }