@ouroboros/body 1.2.2 → 1.3.1

package/README.md

@@ -70,7 +70,13 @@ function MyApp() {
       'my_service',
       'my_request',
       {  _id: 'someid' }
-    ).then(setData, setError);
+    ).then(res => {
+      if(res.error) {
+        setError(res.error);
+      } else {
+        setData(res.data);
+      }
+    });
   }
 
   return <>
@@ -136,7 +142,13 @@ the [example](#body) could have also been written as
       'my_service',
       'my_request',
       {  _id: 'someid' }
-    ).then(setData, setError);
+    ).then(res => {
+      if(res.error) {
+        setError(res.error);
+      } else {
+        setData(res.data);
+      }
+    });
 ```
 
 [ [top](#ouroborosbody), [contents](#contents), [body](#body) ]
@@ -289,17 +301,17 @@ body.read(
   'my_service',
   'my/request',
   { _id: 'someid' }
-).then(res => {},
-  error => {
-    if(error.code === errors.DATA_FIELDS) {
+).then(res => {
+  if(res.error) {
+    if(res.error.code === errors.DATA_FIELDS) {
       // Bad data sent to request
-    } else if(error.code === errors.DB_NO_RECORD) {
+    } else if(res.error.code === errors.DB_NO_RECORD) {
       // Bad ID, no such record
     } else {
       // Unknown error code
     }
   }
-)
+})
 ```
 
 [ [top](#ouroborosbody), [contents](#contents) ]

package/lib/index.d.ts

@@ -36,7 +36,7 @@ export type onRequestingStruct = {
     data: any;
     url: string;
 };
-export type onWarning = (warning: any, info: onRequestedStruct) => void;
+export type onWarning = (warning: any, info: onRequestedStruct) => void | false;
 export type responseStruct = {
     data?: any;
     error?: responseErrorStruct;
@@ -47,7 +47,7 @@ export type responseErrorStruct = {
     msg?: any;
 };
 export type responseResolve = (res: responseStruct) => void;
-export type responseReject = (error: responseErrorStruct) => boolean;
+export type responseReject = (error: responseErrorStruct) => void;
 /**
  * Body
  *

package/lib/index.js

@@ -21,6 +21,8 @@ const METHODS = {
     read: 'GET',
     update: 'PUT'
 };
+// 30 second timeout
+const REQUEST_TIMEOUT = 30000;
 /**
  * Body
  *
@@ -80,6 +82,11 @@ class Body {
      * @param data The data associated with the request
      */
     request(action, service, noun, data) {
+        // If no error handler was assigned
+        if (!this.error) {
+            throw new Error('Must assign an error handler via body.on(\'error\', handler)' +
+                ' or body.onError(handler)');
+        }
         // Generate the URL for the request
         let url = `https://${this._domain}/${service}/${noun}`;
         // Init the response and json variables
@@ -98,24 +105,31 @@ class Body {
         }
         // Set this
         const _ = this;
-        // Handles an error based on whether an error handler is set
-        function handleError(message) {
-            if (_.error) {
-                _.error(message, { action, data, url });
-            }
-            else {
-                throw new Error(message);
-            }
-        }
         // Create a new Promise and return it
         return new Promise((resolve, reject) => {
+            // Handle errors the same way every time
+            function handleError(reason) {
+                // Generate the error message
+                const err = `${METHODS[action]} ${url} ${reason}`;
+                // Call the error handler
+                _.error(err, { action, data, url });
+                // Return reject path
+                return reject({ code: 0, msg: err });
+            }
+            // Create an abort controller for timeouts
+            const controller = new AbortController();
             // Init the fetch init
             const fetchInit = {
-                method: METHODS[action],
                 headers: {
                     'Content-Type': 'application/json; charset=utf-8'
-                }
+                },
+                method: METHODS[action],
+                signal: controller.signal
             };
+            // Start a timer so we timeout if the request doesn't return
+            const timer = setTimeout(() => {
+                controller.abort();
+            }, REQUEST_TIMEOUT);
             // If we have a session token, add it as the Authorization header
             if (_.token) {
                 fetchInit.headers.Authorization = _.token;
@@ -135,54 +149,63 @@ class Body {
                     // If the Content-Type is missing or invalid
                     const ct = response.headers.get('Content-Type');
                     if (!ct || ct !== 'application/json; charset=utf-8') {
-                        handleError(`${METHODS[action]} ${url} returned invalid Content-Type: ${ct}`);
+                        return handleError(`returned invalid Content-Type: "${ct}"`);
                     }
                     // Return the JSON
-                    return response.json();
+                    return response.json().then(result => {
+                        // If there's no result, return an error + reject
+                        if (!result) {
+                            return handleError('returned: empty JSON');
+                        }
+                        // Set res
+                        res = result;
+                        // Init the structure to pass to resolve
+                        const oResult = {};
+                        // If we got an error
+                        if ('error' in result && result.error) {
+                            // If we don't have an onErrorCode callback, or we
+                            //	do and calling it returns false
+                            if (!_.errorCode ||
+                                _.errorCode(result.error, { action, data, res, url }) === false) {
+                                // If it wasn't handled, add it to the result
+                                oResult.error = structuredClone(result.error);
+                            }
+                        }
+                        // If we got a warning
+                        if ('warning' in result && result.warning) {
+                            // If we don't have an onWarning callback, or we do
+                            //	and calling it returns false
+                            if (!_.warning ||
+                                _.warning(result.warning, { action, data, res, url }) === false) {
+                                // If it wasn't handled, add it to the result
+                                oResult.warning = structuredClone(result.warning);
+                            }
+                        }
+                        // If we got data
+                        if ('data' in result) {
+                            // Add it
+                            oResult.data = structuredClone(result.data);
+                        }
+                        // Resolve
+                        return resolve(oResult);
+                    });
                 }
                 // If it's 401
-                if (response.status === 401) {
+                else if (response.status === 401) {
                     // If we have a no session callback
                     if (_.noSession) {
                         _.noSession();
-                        return reject({ code: 0, msg: '401 Not Authorized' });
-                    }
-                    else {
-                        throw new Error(`${METHODS[action]} ${url} return 401 NOT AUTHORIZED`);
                     }
+                    // Reject the request
+                    return handleError('returned: 401 NOT AUTHORIZED');
                 }
                 // Else, invalid status
-                else {
-                    handleError(`${METHODS[action]} ${url} returned invalid status: ${response.status}`);
-                }
-            }).then(result => {
-                // If there's no result, do nothing
-                if (!result) {
-                    return;
-                }
-                // Set res
-                res = result;
-                // If we got an error
-                if ('error' in result && result.error) {
-                    // If we don't have an onErrorCode callback, or we do and
-                    //  calling it returns false
-                    if (!_.errorCode ||
-                        _.errorCode(result.error, { action, data, res, url }) === false) {
-                        return reject(result.error);
-                    }
-                }
-                // If we got a warning and we have an onWarning callback
-                if ('warning' in result && result.warning && _.warning) {
-                    _.warning(result.warning, { action, data, res, url });
-                }
-                // If we got data
-                if ('data' in result) {
-                    // Resolve it
-                    return resolve(result.data);
-                }
+                return handleError(`returned: invalid status ${response.status}`);
             }).catch(reason => {
-                handleError(`${METHODS[action]} ${url} failed because of "${reason}"`);
+                return handleError(`failed with: "${String(reason)}"`);
             }).finally(() => {
+                // Clear the timeout timer
+                clearTimeout(timer);
                 // If we have a requested callback
                 if (this.requested) {
                     this.requested({ action, data, res, url });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ouroboros/body",
-	"version": "1.2.2",
+	"version": "1.3.1",
 	"description": "Classes to communicate with Ouroboros Coding Inc. body services",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
@@ -26,6 +26,6 @@
 	"devDependencies": {
 		"tslint": "^6.1.3",
 		"tslint-config-prettier": "^1.18.0",
-		"typescript": "^5.9.2"
+		"typescript": "^5.9.3"
 	}
-}
+}

package/releases.md

@@ -1,5 +1,12 @@
 # @ouroboros/body releases
 
+## 1.3.1
+- Fixed issues with requests potentially not resolving promises on errors.
+- Added 30 second timeout on requests so they don't hang forever.
+
+## 1.3.0
+- Stopped splitting data and error into resolve and reject as this made it harder to identify and solve real communication problems. From now on all requests that are returned successfully, regardless of the result, are returned in full to resolve. This means all current `.then()` calls on requests must handle the full responseStruct result instead of just the `.data`. Similarly, any code currently running in the reject based on completed, but error filled, requests must be moved into the first argument of `.then()`.
+
 ## 1.2.2
 - Fixed issue where `finally` not being called on Promises if 401 Not Authorized is returned.
 

package/src/index.ts

@@ -42,7 +42,7 @@ export type onRequestingStruct = {
 	data: any,
 	url: string
 };
-export type onWarning = (warning: any, info: onRequestedStruct) => void;
+export type onWarning = (warning: any, info: onRequestedStruct) => void | false;
 export type responseStruct = {
 	data?: any,
 	error?: responseErrorStruct,
@@ -53,7 +53,7 @@ export type responseErrorStruct = {
 	msg?: any
 }
 export type responseResolve = (res: responseStruct) => void;
-export type responseReject = (error: responseErrorStruct) => boolean;
+export type responseReject = (error: responseErrorStruct) => void;
 
 // Actions to methods
 const METHODS = {
@@ -63,6 +63,9 @@ const METHODS = {
 	update: 'PUT'
 }
 
+// 30 second timeout
+const REQUEST_TIMEOUT = 30000;
+
 /**
  * Body
  *
@@ -140,6 +143,14 @@ class Body {
 		data: any
 	): Promise<any> {
 
+		// If no error handler was assigned
+		if(!this.error) {
+			throw new Error(
+				'Must assign an error handler via body.on(\'error\', handler)' +
+				' or body.onError(handler)'
+			)
+		}
+
 		// Generate the URL for the request
 		let url = `https://${this._domain}/${service}/${noun}`;
 
@@ -162,26 +173,39 @@ class Body {
 		// Set this
 		const _ = this;
 
-		// Handles an error based on whether an error handler is set
-		function handleError(message: string): void {
-			if(_.error) {
-				_.error(message, { action, data, url });
-			} else {
-				throw new Error(message);
-			}
-		}
-
 		// Create a new Promise and return it
 		return new Promise((resolve: responseResolve, reject) => {
 
+			// Handle errors the same way every time
+			function handleError(reason: string): void {
+
+				// Generate the error message
+				const err: string = `${METHODS[action]} ${url} ${reason}`;
+
+				// Call the error handler
+				(_.error as onError)(err, { action, data, url });
+
+				// Return reject path
+				return reject({ code: 0, msg: err });
+			}
+
+			// Create an abort controller for timeouts
+			const controller = new AbortController()
+
 			// Init the fetch init
 			const fetchInit: any = {
-				method: METHODS[action],
 				headers: {
 					'Content-Type': 'application/json; charset=utf-8'
-				}
+				},
+				method: METHODS[action],
+				signal: controller.signal
 			}
 
+			// Start a timer so we timeout if the request doesn't return
+			const timer = setTimeout(() => {
+				controller.abort();
+			}, REQUEST_TIMEOUT);
+
 			// If we have a session token, add it as the Authorization header
 			if(_.token) {
 				fetchInit.headers.Authorization = _.token;
@@ -206,81 +230,91 @@ class Body {
 					// If the Content-Type is missing or invalid
 					const ct = response.headers.get('Content-Type');
 					if(!ct || ct !== 'application/json; charset=utf-8') {
-						handleError(
-							`${METHODS[action]} ${url} returned invalid Content-Type: ${ct}`
-						);
+						return handleError(`returned invalid Content-Type: "${ct}"`);
 					}
 
 					// Return the JSON
-					return response.json();
+					return response.json().then(result => {
+
+						// If there's no result, return an error + reject
+						if(!result) {
+							return handleError('returned: empty JSON');
+						}
+
+						// Set res
+						res = result;
+
+						// Init the structure to pass to resolve
+						const oResult: responseStruct = { };
+
+						// If we got an error
+						if('error' in result && result.error) {
+
+							// If we don't have an onErrorCode callback, or we
+							//	do and calling it returns false
+							if(!_.errorCode ||
+								_.errorCode(
+									result.error as responseErrorStruct,
+									{ action, data, res, url }
+								) === false
+							) {
+								// If it wasn't handled, add it to the result
+								oResult.error = structuredClone(result.error);
+							}
+						}
+
+						// If we got a warning
+						if('warning' in result && result.warning) {
+
+							// If we don't have an onWarning callback, or we do
+							//	and calling it returns false
+							if(!_.warning ||
+								_.warning(
+									result.warning,
+									{ action, data, res, url }
+								) === false
+							) {
+								// If it wasn't handled, add it to the result
+								oResult.warning = structuredClone(
+									result.warning
+								);
+							}
+						}
+
+						// If we got data
+						if('data' in result) {
+
+							// Add it
+							oResult.data = structuredClone(result.data);
+						}
+
+						// Resolve
+						return resolve(oResult);
+					});
 				}
 
 				// If it's 401
-				if(response.status === 401) {
+				else if(response.status === 401) {
 
 					// If we have a no session callback
 					if(_.noSession) {
 						_.noSession();
-						return reject({ code: 0, msg: '401 Not Authorized' });
-					} else {
-						throw new Error(
-							`${METHODS[action]} ${url} return 401 NOT AUTHORIZED`
-						);
 					}
-				}
-				// Else, invalid status
-				else {
-					handleError(
-						`${METHODS[action]} ${url} returned invalid status: ${response.status}`
-					);
-				}
 
-			}).then(result => {
-
-				// If there's no result, do nothing
-				if(!result) {
-					return;
-				}
-
-				// Set res
-				res = result;
-
-				// If we got an error
-				if('error' in result && result.error) {
-
-					// If we don't have an onErrorCode callback, or we do and
-					//  calling it returns false
-					if(!_.errorCode ||
-						_.errorCode(
-							result.error as responseErrorStruct,
-							{ action, data, res, url }
-						) === false
-					) {
-						return reject(result.error);
-					}
+					// Reject the request
+					return handleError('returned: 401 NOT AUTHORIZED');
 				}
 
-				// If we got a warning and we have an onWarning callback
-				if('warning' in result && result.warning && _.warning) {
-					_.warning(
-						result.warning, { action, data, res, url }
-					);
-				}
-
-				// If we got data
-				if('data' in result) {
-
-					// Resolve it
-					return resolve(result.data);
-				}
+				// Else, invalid status
+				return handleError(`returned: invalid status ${response.status}`);
 
 			}).catch(reason => {
-				handleError(
-					`${METHODS[action]} ${url} failed because of "${reason}"`
-				)
-
+				return handleError(`failed with: "${String(reason)}"`);
 			}).finally(() => {
 
+				// Clear the timeout timer
+				clearTimeout(timer);
+
 				// If we have a requested callback
 				if(this.requested) {
 					this.requested({ action, data, res, url });

package/tslint-to-eslint-config.log

@@ -0,0 +1,19 @@
+6 ESLint rules behave differently from their TSLint counterparts:
+  * no-invalid-this:
+    - Functions in methods will no longer be ignored.
+  * @typescript-eslint/no-unused-expressions:
+    - The TSLint optional config "allow-new" is the default ESLint behavior and will no longer be ignored.
+  * prefer-arrow/prefer-arrow-functions:
+    - ESLint (eslint-plugin-prefer-arrow plugin) does not support allowing named functions defined with the function keyword.
+  * eqeqeq:
+    - Option "smart" allows for comparing two literal values, evaluating the value of typeof and null comparisons.
+  * no-underscore-dangle:
+    - Leading and trailing underscores (_) on identifiers will now be ignored.
+  * padded-blocks:
+    - ESLint's padded-blocks rule also bans a blank line before a closing brace.
+
+Error: multiple output react/jsx-curly-spacing ESLint rule options were generated, but tslint-to-eslint-config doesn't have "merger" logic to deal with this.
+Please file an issue at https://github.com/typescript-eslint/tslint-to-eslint-config/issues/new?template=missing_merger.md. Thanks!
+
+  * import-destructuring-spacing
+