promise-tuple 1.0.0 → 1.1.2

package/README.md

@@ -121,15 +121,51 @@ const [error, data] = await promiseTuple<string, CustomError>(
 );
 ```
 
+### With Callbacks
+
+You can optionally provide success and failure callbacks:
+
+```typescript
+import promiseTuple from 'promise-tuple';
+
+const [error, data] = await promiseTuple(
+  fetch('/api/data'),
+  () => console.log('Request succeeded!'),
+  () => console.log('Request failed!')
+);
+```
+
+Only the appropriate callback will be executed:
+
+```typescript
+import promiseTuple from 'promise-tuple';
+
+const [error, data] = await promiseTuple(
+  someAsyncOperation(),
+  () => {
+    // This runs on success
+    console.log('Operation completed successfully');
+    sendAnalytics('success');
+  },
+  () => {
+    // This runs on failure
+    console.error('Operation failed');
+    sendAnalytics('failure');
+  }
+);
+```
+
 ## API
 
-### `promiseTuple<R, E>(promise)`
+### `promiseTuple<R, E>(promise, successCallback?, failureCallback?)`
 
 Handles a promise and returns a tuple with error and result.
 
 **Parameters:**
 
 - `promise: Promise<R>` - The promise to handle
+- `successCallback?: () => void` - Optional callback executed when the promise resolves
+- `failureCallback?: () => void` - Optional callback executed when the promise rejects
 
 **Returns:**
 
@@ -142,8 +178,8 @@ Handles a promise and returns a tuple with error and result.
 
 **Behavior:**
 
-- If the promise resolves: returns `[undefined, result]`
-- If the promise rejects: returns `[error, undefined]`
+- If the promise resolves: returns `[undefined, result]` and executes `successCallback` if provided
+- If the promise rejects: returns `[error, undefined]` and executes `failureCallback` if provided
 
 ## Examples
 
@@ -186,6 +222,35 @@ async function readConfigFile(path: string) {
 }
 ```
 
+### With Callbacks for Side Effects
+
+```typescript
+import promiseTuple from 'promise-tuple';
+import db from './database';
+
+async function getUserById(id: number) {
+  const [error, user] = await promiseTuple(
+    db.users.findById(id),
+    () => {
+      // Track successful database query
+      console.log(`User ${id} retrieved successfully`);
+      metrics.incrementCounter('db.user.success');
+    },
+    () => {
+      // Track failed database query
+      console.error(`Failed to retrieve user ${id}`);
+      metrics.incrementCounter('db.user.failure');
+    }
+  );
+
+  if (error) {
+    return { success: false, message: 'User not found' };
+  }
+
+  return { success: true, user };
+}
+```
+
 ## License
 
 ISC

package/dist/index.cjs

@@ -24,8 +24,8 @@ __export(index_exports, {
   promiseTuple: () => promiseTuple
 });
 module.exports = __toCommonJS(index_exports);
-async function promiseTuple(promise) {
-  return promise.then((result) => [void 0, result]).catch((error) => [error, void 0]);
+async function promiseTuple(promise, successCallback, failureCallback) {
+  return promise.then((result) => (successCallback?.(), [void 0, result])).catch((error) => (failureCallback?.(), [error, void 0]));
 }
 var index_default = promiseTuple;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\r\n * Handles a promise and returns a tuple with error and result.\r\n *\r\n * This function wraps a promise and returns a tuple containing either an error or a result,\r\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\r\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\r\n *\r\n * @template R - The type of the resolved value. Defaults to `unknown`.\r\n * @template E - The type of the error. Defaults to `unknown`.\r\n * @param promise - The promise to handle.\r\n * @returns A promise that resolves to a tuple containing either an error or a result.\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(fetchData());\r\n * if (error) {\r\n *   console.error('Error:', error);\r\n * } else {\r\n *   console.log('Data:', data);\r\n * }\r\n */\r\nexport async function promiseTuple<R = unknown, E = unknown>(\r\n    promise: Promise<R>\r\n): Promise<[E | undefined, R | undefined]> {\r\n    return promise\r\n        .then((result) => [undefined, result] as [undefined, R])\r\n        .catch((error) => [error, undefined] as [E, undefined])\r\n}\r\nexport default promiseTuple\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,eAAsB,aAClB,SACuC;AACvC,SAAO,QACF,KAAK,CAAC,WAAW,CAAC,QAAW,MAAM,CAAmB,EACtD,MAAM,CAAC,UAAU,CAAC,OAAO,MAAS,CAAmB;AAC9D;AACA,IAAO,gBAAQ;","names":[]}
+{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\r\n * Handles a promise and returns a tuple with error and result.\r\n *\r\n * This function wraps a promise and returns a tuple containing either an error or a result,\r\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\r\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\r\n *\r\n * @template R - The type of the resolved value. Defaults to `unknown`.\r\n * @template E - The type of the error. Defaults to `unknown`.\r\n * @param promise - The promise to handle.\r\n * @param successCallback - Optional callback to execute when the promise resolves successfully.\r\n * @param failureCallback - Optional callback to execute when the promise rejects.\r\n * @returns A promise that resolves to a tuple containing either an error or a result.\r\n *          On success: `[undefined, result]`\r\n *          On failure: `[error, undefined]`\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(fetchData());\r\n * if (error) {\r\n *   console.error('Error:', error);\r\n * } else {\r\n *   console.log('Data:', data);\r\n * }\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(\r\n *   fetchData(),\r\n *   () => console.log('Success!'),\r\n *   () => console.log('Failed!')\r\n * );\r\n */\r\nexport async function promiseTuple<R = unknown, E = unknown>(\r\n    promise: Promise<R>,\r\n    successCallback?: () => void,\r\n    failureCallback?: () => void\r\n): Promise<[E | undefined, R | undefined]> {\r\n    return promise\r\n        .then((result) => (successCallback?.(), [undefined, result] as [undefined, R]))\r\n        .catch((error) => (failureCallback?.(), [error, undefined] as [E, undefined]))\r\n}\r\n\r\nexport default promiseTuple\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,eAAsB,aAClB,SACA,iBACA,iBACuC;AACvC,SAAO,QACF,KAAK,CAAC,YAAY,kBAAkB,GAAG,CAAC,QAAW,MAAM,EAAoB,EAC7E,MAAM,CAAC,WAAW,kBAAkB,GAAG,CAAC,OAAO,MAAS,EAAoB;AACrF;AAEA,IAAO,gBAAQ;","names":[]}

package/dist/index.d.cts

@@ -8,7 +8,11 @@
  * @template R - The type of the resolved value. Defaults to `unknown`.
  * @template E - The type of the error. Defaults to `unknown`.
  * @param promise - The promise to handle.
+ * @param successCallback - Optional callback to execute when the promise resolves successfully.
+ * @param failureCallback - Optional callback to execute when the promise rejects.
  * @returns A promise that resolves to a tuple containing either an error or a result.
+ *          On success: `[undefined, result]`
+ *          On failure: `[error, undefined]`
  *
  * @example
  * const [error, data] = await promiseTuple(fetchData());
@@ -17,7 +21,14 @@
  * } else {
  *   console.log('Data:', data);
  * }
+ *
+ * @example
+ * const [error, data] = await promiseTuple(
+ *   fetchData(),
+ *   () => console.log('Success!'),
+ *   () => console.log('Failed!')
+ * );
  */
-declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>): Promise<[E | undefined, R | undefined]>;
+declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>, successCallback?: () => void, failureCallback?: () => void): Promise<[E | undefined, R | undefined]>;
 
 export { promiseTuple as default, promiseTuple };

package/dist/index.d.ts

@@ -8,7 +8,11 @@
  * @template R - The type of the resolved value. Defaults to `unknown`.
  * @template E - The type of the error. Defaults to `unknown`.
  * @param promise - The promise to handle.
+ * @param successCallback - Optional callback to execute when the promise resolves successfully.
+ * @param failureCallback - Optional callback to execute when the promise rejects.
  * @returns A promise that resolves to a tuple containing either an error or a result.
+ *          On success: `[undefined, result]`
+ *          On failure: `[error, undefined]`
  *
  * @example
  * const [error, data] = await promiseTuple(fetchData());
@@ -17,7 +21,14 @@
  * } else {
  *   console.log('Data:', data);
  * }
+ *
+ * @example
+ * const [error, data] = await promiseTuple(
+ *   fetchData(),
+ *   () => console.log('Success!'),
+ *   () => console.log('Failed!')
+ * );
  */
-declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>): Promise<[E | undefined, R | undefined]>;
+declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>, successCallback?: () => void, failureCallback?: () => void): Promise<[E | undefined, R | undefined]>;
 
 export { promiseTuple as default, promiseTuple };

package/dist/index.js

@@ -1,6 +1,6 @@
 // index.ts
-async function promiseTuple(promise) {
-  return promise.then((result) => [void 0, result]).catch((error) => [error, void 0]);
+async function promiseTuple(promise, successCallback, failureCallback) {
+  return promise.then((result) => (successCallback?.(), [void 0, result])).catch((error) => (failureCallback?.(), [error, void 0]));
 }
 var index_default = promiseTuple;
 export {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\r\n * Handles a promise and returns a tuple with error and result.\r\n *\r\n * This function wraps a promise and returns a tuple containing either an error or a result,\r\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\r\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\r\n *\r\n * @template R - The type of the resolved value. Defaults to `unknown`.\r\n * @template E - The type of the error. Defaults to `unknown`.\r\n * @param promise - The promise to handle.\r\n * @returns A promise that resolves to a tuple containing either an error or a result.\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(fetchData());\r\n * if (error) {\r\n *   console.error('Error:', error);\r\n * } else {\r\n *   console.log('Data:', data);\r\n * }\r\n */\r\nexport async function promiseTuple<R = unknown, E = unknown>(\r\n    promise: Promise<R>\r\n): Promise<[E | undefined, R | undefined]> {\r\n    return promise\r\n        .then((result) => [undefined, result] as [undefined, R])\r\n        .catch((error) => [error, undefined] as [E, undefined])\r\n}\r\nexport default promiseTuple\r\n"],"mappings":";AAoBA,eAAsB,aAClB,SACuC;AACvC,SAAO,QACF,KAAK,CAAC,WAAW,CAAC,QAAW,MAAM,CAAmB,EACtD,MAAM,CAAC,UAAU,CAAC,OAAO,MAAS,CAAmB;AAC9D;AACA,IAAO,gBAAQ;","names":[]}
+{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\r\n * Handles a promise and returns a tuple with error and result.\r\n *\r\n * This function wraps a promise and returns a tuple containing either an error or a result,\r\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\r\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\r\n *\r\n * @template R - The type of the resolved value. Defaults to `unknown`.\r\n * @template E - The type of the error. Defaults to `unknown`.\r\n * @param promise - The promise to handle.\r\n * @param successCallback - Optional callback to execute when the promise resolves successfully.\r\n * @param failureCallback - Optional callback to execute when the promise rejects.\r\n * @returns A promise that resolves to a tuple containing either an error or a result.\r\n *          On success: `[undefined, result]`\r\n *          On failure: `[error, undefined]`\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(fetchData());\r\n * if (error) {\r\n *   console.error('Error:', error);\r\n * } else {\r\n *   console.log('Data:', data);\r\n * }\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(\r\n *   fetchData(),\r\n *   () => console.log('Success!'),\r\n *   () => console.log('Failed!')\r\n * );\r\n */\r\nexport async function promiseTuple<R = unknown, E = unknown>(\r\n    promise: Promise<R>,\r\n    successCallback?: () => void,\r\n    failureCallback?: () => void\r\n): Promise<[E | undefined, R | undefined]> {\r\n    return promise\r\n        .then((result) => (successCallback?.(), [undefined, result] as [undefined, R]))\r\n        .catch((error) => (failureCallback?.(), [error, undefined] as [E, undefined]))\r\n}\r\n\r\nexport default promiseTuple\r\n"],"mappings":";AA+BA,eAAsB,aAClB,SACA,iBACA,iBACuC;AACvC,SAAO,QACF,KAAK,CAAC,YAAY,kBAAkB,GAAG,CAAC,QAAW,MAAM,EAAoB,EAC7E,MAAM,CAAC,WAAW,kBAAkB,GAAG,CAAC,OAAO,MAAS,EAAoB;AACrF;AAEA,IAAO,gBAAQ;","names":[]}

package/package.json

@@ -1,63 +1,64 @@
 {
-    "name": "promise-tuple",
-    "version": "1.0.0",
-    "description": "A utility function for handling promises with Go-like error handling pattern",
-    "main": "./dist/index.cjs",
-    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "type": "module",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "require": {
-                "types": "./dist/index.d.cts",
-                "default": "./dist/index.cjs"
-            },
-            "import": {
-                "types": "./dist/index.d.ts",
-                "default": "./dist/index.js"
-            }
-        }
-    },
-    "sideEffects": false,
-    "scripts": {
-        "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
-        "build": "tsup index.ts",
-        "test": "tsx index.test.ts",
-        "prepublishOnly": "npm run clean && npm run build && npm test"
-    },
-    "keywords": [
-        "promise",
-        "error-handling",
-        "async",
-        "utility",
-        "go-style",
-        "tuple",
-        "await",
-        "typescript"
-    ],
-    "author": "Eduardo DONATO <eduardo.donato@gmail.com>",
-    "license": "ISC",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/ebdonato/promise-tuple.git"
-    },
-    "bugs": {
-        "url": "https://github.com/ebdonato/promise-tuple/issues"
-    },
-    "homepage": "https://github.com/ebdonato/promise-tuple#readme",
-    "engines": {
-        "node": ">=16"
-    },
-    "files": [
-        "dist",
-        "README.md",
-        "LICENSE"
-    ],
-    "devDependencies": {
-        "@types/node": "^20.0.0",
-        "tsup": "^8.5.1",
-        "tsx": "^4.21.0",
-        "typescript": "^5.9.3"
+  "name": "promise-tuple",
+  "version": "1.1.2",
+  "description": "A utility function for handling promises with Go-like error handling pattern",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
     }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "tsup index.ts",
+    "test": "vitest run",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "keywords": [
+    "promise",
+    "error-handling",
+    "async",
+    "utility",
+    "go-style",
+    "tuple",
+    "await",
+    "typescript"
+  ],
+  "author": "Eduardo DONATO <eduardo.donato@gmail.com>",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ebdonato/promise-tuple.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ebdonato/promise-tuple/issues"
+  },
+  "homepage": "https://github.com/ebdonato/promise-tuple#readme",
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
 }