feat: Add Request object and options to adjust requests before sending (#6)

hofmeister · web-flow · commit a186ebe1b520 · 2023-12-12T17:38:50.000+01:00
diff --git a/index.ts b/index.ts
@@ -22,6 +22,7 @@ type RequestMethod =
     | 'UNLOCK'
     | 'PROPFIND'
     | 'VIEW';
+type Options = {url:string, init:RequestInit};
 export interface RequestArgument {
     name: string;
     value: any;
@@ -47,99 +48,221 @@ const JSONStringifyReplacer = function(this:any, key:string, value:any) {
     return value;
 }
 
-export class RestClient {
+export class RestClientRequest<ReturnType = any> {
     private readonly _baseUrl: string;
+    private readonly _path: string;
+    private readonly _method: RequestMethod;
+    private readonly _requestArguments: RequestArgument[];
+    private readonly _headers: { [key: string]: string } = {};
 
-    /**
-     * Initialise rest client
-     *
-     * @param {string} baseUrl
-     */
-    constructor(baseUrl: string) {
-        if (!baseUrl) {
-            baseUrl = '/';
-        }
-
-        if (!baseUrl.endsWith('/')) {
-            baseUrl += '/';
+    constructor(baseUrl: string, method: RequestMethod, path: string, requestArguments: RequestArgument[]) {
+        while (path.startsWith('/')) {
+            path = path.substring(1);
         }
 
         this._baseUrl = baseUrl;
+        this._path = path;
+        this._method = method;
+        this._requestArguments = requestArguments;
     }
 
-    /**
-     * Executes a request to the specified path using the specified method.
-     *
-     * @param {RequestMethod} method The HTTP method to use for the request.
-     * @param {string} path The path of the resource to request.
-     * @param {RequestArgument[]} requestArguments An array of request arguments.
-     * @return {Promise<ReturnData | null>} The result of the request, or null if the response status is 404.
-     */
-    async execute<ReturnData = any>(method: RequestMethod, path: string, requestArguments: RequestArgument[] = []) {
-        while (path.startsWith('/')) {
-            path = path.substring(1);
+    public get url() {
+        return this._baseUrl + this._path;
+    }
+
+    public get method() {
+        return this._method;
+    }
+
+    public get arguments() {
+        return [...this._requestArguments];
+    }
+
+    public get headers() {
+        return {
+            ...this._headers,
+        };
+    }
+
+    public withHeader(name: string, value: string) {
+        this._headers[name] = value;
+        return this;
+    }
+
+    public withAuthorization(auth: string) {
+        return this.withHeader('Authorization', auth);
+    }
+
+    public withBearerToken(token: string) {
+        return this.withAuthorization(`Bearer ${token}`);
+    }
+
+    public withContentType(contentType: string) {
+        return this.withHeader('Content-Type', contentType);
+    }
+
+    public async call():Promise<ReturnType|null> {
+        const opts = this.createOptions();
+        const result = await fetch(opts.url, opts.init);
+
+        if (result.status === 404) {
+            return null;
+        }
+
+        let output: ReturnType | null = null;
+        if (result.headers.get('content-type')?.startsWith('application/json')) {
+            //Only parse json if content-type is application/json
+            const text = await result.text();
+            output = text ? (JSON.parse(text) as ReturnType) : null;
         }
 
-        let url = this._baseUrl + path;
+        if (result.status >= 400) {
+            const error =
+                output && typeof output === 'object' && 'error' in output && typeof output.error === 'string'
+                    ? output.error
+                    : 'Unknown error';
+            throw new RestError(error, result);
+        }
 
-        const query: string[] = [];
-        const headers: { [key: string]: string } = {
+        return output;
+    }
+
+    private createOptions():Options {
+        const query: string[] = []
+        const headers = new Headers({
+            ...this._headers,
             accept: 'application/json',
-        };
-        const opts: RequestInit = {
-            method,
-            headers,
+        });
+        const out:Options = {
+            url: this.url,
+            init: {
+                method: this.method,
+                headers,
+            }
         };
 
-        requestArguments.forEach((requestArgument) => {
-            switch (requestArgument.transport.toLowerCase()) {
+        this._requestArguments.forEach((requestArgument) => {
+            const transport = requestArgument.transport?.toLowerCase() as Lowercase<RequestArgumentTransport>;
+            switch (transport) {
                 case 'path':
-                    url = url.replaceAll('{' + requestArgument.name + '}', requestArgument.value);
+                    out.url = out.url.replace('{' + requestArgument.name + '}', requestArgument.value);
                     break;
                 case 'header':
-                    headers[requestArgument.name] = requestArgument.value;
+                    headers.set(requestArgument.name, requestArgument.value);
                     break;
                 case 'body':
-                    if (!headers['content-type']) {
-                        headers['content-type'] = 'application/json';
+                    if (!headers.has('content-type')) {
+                        headers.set('content-type', 'application/json');
                     }
-                    opts.body = JSON.stringify(requestArgument.value, JSONStringifyReplacer);
+                    out.init.body = JSON.stringify(requestArgument.value, JSONStringifyReplacer);
                     break;
                 case 'query':
                     query.push(
                         encodeURIComponent(requestArgument.name) + '=' + encodeURIComponent(requestArgument.value)
                     );
                     break;
                 default:
+                    transport satisfies never;
                     throw new Error('Unknown argument transport: ' + requestArgument.transport);
             }
         });
 
         if (query.length > 0) {
-            url += '?' + query.join('&');
+            out.url += '?' + query.join('&');
+        }
+        return out;
+    }
+
+}
+
+export class RestClient {
+    private static globalHeaders: { [key: string]: string } = {};
+
+    static setHeader(name: string, value: string|undefined) {
+        if (!value) {
+            delete this.globalHeaders[name];
+            return this;
         }
+        this.globalHeaders[name] = value;
+        return this;
+    }
 
-        const result = await fetch(url, opts);
+    static setAuthorization(auth: string|undefined) {
+        return this.setHeader('Authorization', auth);
+    }
 
-        if (result.status === 404) {
-            return null;
+    static setBearerToken(token: string|undefined) {
+        return this.setAuthorization(token ? `Bearer ${token}` : token);
+    }
+
+    private readonly _baseUrl: string;
+    private _fixedHeaders: { [key: string]: string } = {};
+
+    /**
+     * Initialise rest client
+     */
+    constructor(baseUrl: string) {
+        if (!baseUrl) {
+            baseUrl = '/';
         }
 
-        let output: ReturnData | null = null;
-        if (result.headers.get('content-type')?.startsWith('application/json')) {
-            //Only parse json if content-type is application/json
-            const text = await result.text();
-            output = text ? (JSON.parse(text) as ReturnData) : null;
+        if (!baseUrl.endsWith('/')) {
+            baseUrl += '/';
         }
 
-        if (result.status >= 400) {
-            const error =
-                output && typeof output === 'object' && 'error' in output && typeof output.error === 'string'
-                    ? output.error
-                    : 'Unknown error';
-            throw new RestError(error, result);
+        this._baseUrl = baseUrl;
+    }
+
+    public get baseUrl() {
+        return this._baseUrl;
+    }
+
+    public withHeader(name: string, value: string|undefined) {
+        if (!value) {
+            delete this._fixedHeaders[name];
+            return this;
         }
+        this._fixedHeaders[name] = value;
+        return this;
+    }
 
-        return output;
+    public withContentType(contentType: string|undefined) {
+        return this.withHeader('Content-Type', contentType);
+    }
+
+    public withAuthorization(auth: string|undefined) {
+        return this.withHeader('Authorization', auth);
+    }
+
+    public withBearerToken(token: string|undefined) {
+        return this.withAuthorization(token ? `Bearer ${token}` : token);
+    }
+
+    protected afterCreate(request: RestClientRequest):void {
+        // Override this method to add additional headers or similar to all requests
+    }
+
+    public create<ReturnType = any>(method: RequestMethod, path: string, requestArguments: RequestArgument[]):RestClientRequest<ReturnType> {
+        const request = new RestClientRequest<ReturnType>(this._baseUrl, method, path, requestArguments);
+
+        Object.entries(RestClient.globalHeaders).forEach(([key, value]) => {
+            request.withHeader(key, value);
+        });
+
+        Object.entries(this._fixedHeaders).forEach(([key, value]) => {
+            request.withHeader(key, value);
+        });
+
+        this.afterCreate(request);
+        return request;
+    }
+
+    /**
+     * Executes a request to the specified path using the specified method.
+     */
+    public execute<ReturnType = any>(method: RequestMethod, path: string, requestArguments: RequestArgument[]) {
+        const request = this.create<ReturnType>(method, path, requestArguments);
+
+        return request.call()
     }
 }
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -74,7 +74,7 @@
         ]
     },
     "devDependencies": {
-        "typescript": "^5.1.3",
+        "typescript": "^5.3.3",
         "@kapeta/eslint-config": "^0.6.0",
         "@kapeta/prettier-config": "^0.6.0",
         "eslint": "^8.42.0",

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@`
`74`	`74`	`]`
`75`	`75`	`},`
`76`	`76`	`"devDependencies": {`
`77`		`- "typescript": "^5.1.3",`
	`77`	`+ "typescript": "^5.3.3",`
`78`	`78`	`"@kapeta/eslint-config": "^0.6.0",`
`79`	`79`	`"@kapeta/prettier-config": "^0.6.0",`
`80`	`80`	`"eslint": "^8.42.0",`