go-go-try 6.2.0 → 7.1.0

package/.github/workflows/main.yml

@@ -1,24 +1,76 @@
 name: CI
+
 on:
-    - push
-    - pull_request
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+permissions:
+  contents: read
+  id-token: write
+
 jobs:
-    test:
-        name: Node.js ${{ matrix.node-version }}
-        runs-on: ubuntu-latest
-        strategy:
-            # `fail-fast` is set to `false` because we won't know which Node versions are failing and which are passing
-            fail-fast: false
-            matrix:
-                node-version:
-                    - 18
-                    - 16
-                    - 14
-                    - 12
-        steps:
-            - uses: actions/checkout@v3
-            - uses: actions/setup-node@v3
-              with:
-                  node-version: ${{ matrix.node-version }}
-            - run: yarn install
-            - run: yarn test
+  test:
+    name: Node.js ${{ matrix.node-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version:
+          - 22
+          - 20
+          - 18
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Run tests
+        run: npx vitest run --coverage
+
+      - name: Upload coverage to Codecov
+        if: matrix.node-version == 22
+        uses: codecov/codecov-action@v4
+        with:
+          files: ./coverage/lcov.info
+          fail_ci_if_error: false
+
+  publish:
+    name: Publish to npm
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish with provenance
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/CONTRIBUTING.md

@@ -0,0 +1,87 @@
+# Contributing to go-go-try
+
+Thank you for your interest in contributing to go-go-try! This document provides guidelines for contributing to the project.
+
+## Development Setup
+
+1. Fork and clone the repository
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+## Development Workflow
+
+### Building
+
+```bash
+npm run build
+```
+
+### Testing
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npx vitest
+
+# Run tests with coverage
+npx vitest run --coverage
+```
+
+### Linting
+
+```bash
+npm run lint
+```
+
+## Coding Style
+
+- Use TypeScript for all new code
+- Follow the existing code style (enforced by Biome)
+- Write comprehensive tests for new features
+- Ensure all tests pass before submitting PR
+
+## Commit Guidelines
+
+- Use clear, descriptive commit messages
+- Reference issue numbers when applicable
+- Keep commits focused and atomic
+
+## Pull Request Process
+
+1. Ensure your branch is up to date with `main`
+2. Run the full test suite: `npm test`
+3. Update documentation if needed
+4. Submit PR with a clear description of changes
+5. Wait for CI checks to pass
+6. Address any review feedback
+
+## Adding New Features
+
+When adding new features:
+
+1. Add type definitions first
+2. Implement the feature with full type safety
+3. Add comprehensive tests covering:
+   - Happy path
+   - Error cases
+   - Edge cases (null, undefined, etc.)
+4. Update README.md with usage examples
+5. Update CHANGELOG.md
+
+## Reporting Bugs
+
+When reporting bugs, please include:
+
+- Clear description of the issue
+- Steps to reproduce
+- Expected vs actual behavior
+- Node.js and TypeScript versions
+- Minimal code example if possible
+
+## Questions?
+
+Feel free to open an issue for any questions or discussions.

package/README.md

@@ -30,7 +30,7 @@ Why not just `try`/`catch`?
 npm install go-go-try
 ```
 
-## Usage
+## Basic Usage
 
 ```ts
 import { goTry, goTryRaw } from 'go-go-try'
@@ -53,13 +53,286 @@ const [err, todos = []] = await goTryRaw(fetchTodos()) // err is Error | undefin
 if (err) sendToErrorTrackingService(err)
 ```
 
+## Advanced Usage
+
+### Sequential Async Operations
+
+Chain multiple async operations with clean error handling:
+
+```ts
+import { goTry } from 'go-go-try'
+
+async function fetchUserData(userId: string) {
+  // Fetch user
+  const [fetchErr, user] = await goTry(fetch(`/api/users/${userId}`))
+  if (fetchErr) return [fetchErr, undefined] as const
+  
+  // Parse response
+  const [parseErr, data] = await goTry(user!.json())
+  if (parseErr) return [parseErr, undefined] as const
+  
+  // Validate/transform
+  const [validateErr, validated] = goTry(() => validateUser(data!))
+  if (validateErr) return [validateErr, undefined] as const
+  
+  return [undefined, validated] as const
+}
+
+const [err, user] = await fetchUserData('123')
+if (err) {
+  console.error('Failed to fetch user:', err)
+} else {
+  console.log('User:', user)
+}
+```
+
+### Parallel Execution with `goTryAll`
+
+Execute multiple promises in parallel:
+
+```ts
+import { goTryAll } from 'go-go-try'
+
+const [errors, results] = await goTryAll([
+  fetchUser(userId),
+  fetchPosts(userId),
+  fetchComments(userId)
+])
+
+// errors is [string | undefined, string | undefined, string | undefined]
+// results is [User | undefined, Posts | undefined, Comments | undefined]
+
+const [user, posts, comments] = results
+```
+
+### Safe Unwrapping with `goTryOr`
+
+Like `goTry`, but returns a default value on failure instead of `undefined`:
+
+> **Note:** For static default values, you can use destructuring instead:
+> ```ts
+> // These are equivalent for static defaults:
+> const [err, config = {port: 3000}] = goTry(() => JSON.parse(configString))
+> const [err, config] = goTryOr(() => JSON.parse(configString), {port: 3000})
+> ```
+> Use `goTryOr` when you need **lazy evaluation** (the default is only computed on failure):
+
+```ts
+import { goTryOr } from 'go-go-try'
+
+// ✅ Use goTryOr with a function for lazy evaluation - default only computed on failure
+const [err, user] = await goTryOr(fetchUser(id), () => ({
+  id: 'anonymous',
+  name: 'Guest',
+  createdAt: new Date()  // This won't run on success
+}))
+
+// ❌ Avoid: wasteful - createDefault() runs even on success
+const [err, config = createDefault()] = goTry(loadConfig())
+
+// ✅ Better: lazy - createDefault() only runs on failure
+const [err, config] = goTryOr(loadConfig(), () => createDefault())
+```
+
+### Express/Fastify Error Handling
+
+Use in API route handlers:
+
+```ts
+import { goTry } from 'go-go-try'
+import express from 'express'
+
+const app = express()
+
+app.post('/users', async (req, res) => {
+  const [err, user] = await goTry(createUser(req.body))
+  
+  if (err) {
+    return res.status(400).json({ error: err })
+  }
+  
+  res.json(user)
+})
+
+// Batch endpoint
+app.post('/batch', async (req, res) => {
+  const [errors, results] = await goTryAll(
+    req.body.operations.map(op => processOperation(op))
+  )
+  
+  const hasErrors = errors.some(e => e !== undefined)
+  
+  res.status(hasErrors ? 207 : 200).json({
+    results,
+    errors: errors.filter(Boolean)
+  })
+})
+```
+
+### Type Guards
+
+Narrow types using `isSuccess` and `isFailure`:
+
+```ts
+import { goTry, isSuccess, isFailure } from 'go-go-try'
+
+const result = goTry(() => riskyOperation())
+
+if (isSuccess(result)) {
+  // result[1] is typed as T (not T | undefined)
+  console.log(result[1])
+} else if (isFailure(result)) {
+  // result[0] is typed as E (not E | undefined)
+  console.error(result[0])
+}
+```
+
+You can also narrow types by destructuring and checking the error:
+
+```ts
+const [err, value] = goTry(() => riskyOperation())
+
+if (err === undefined) {
+  // value is typed as T (not T | undefined)
+  console.log(value)
+} else {
+  // err is typed as string (not string | undefined)
+  console.error(err)
+  // value is typed as undefined in this branch
+}
+```
+
+### Helper Functions
+
+Build custom utilities on top of the primitives:
+
+```ts
+import { goTry, success, failure, type Result } from 'go-go-try'
+
+// Custom validation helper
+function validateEmail(email: string): Result<string, string> {
+  if (!email.includes('@')) {
+    return failure('Invalid email format')
+  }
+  return success(email.toLowerCase().trim())
+}
+
+// Usage
+const [err, normalizedEmail] = validateEmail('User@Example.COM')
+if (err) {
+  console.error(err) // Doesn't trigger
+} else {
+  console.log(normalizedEmail) // 'user@example.com'
+}
+```
+
 ## API
 
-**First parameter** accepts:
+### `goTry<T>(value)`
+
+Executes a function, promise, or value and returns a Result type with error message as string.
+
+```ts
+function goTry<T>(value: T | Promise<T> | (() => T | Promise<T>)): Result<string, T> | Promise<Result<string, T>>
+```
+
+### `goTryRaw<T, E>(value)`
+
+Like `goTry` but returns the raw Error object instead of just the message.
+
+```ts
+function goTryRaw<T, E = Error>(value: T | Promise<T> | (() => T | Promise<T>)): Result<E, T> | Promise<Result<E, T>>
+```
+
+### `goTryAll<T>(items, options?)`
+
+Executes multiple promises or factory functions with optional concurrency limit. Returns a tuple of `[errors, results]` with fixed tuple types preserving input order.
+
+```ts
+interface GoTryAllOptions {
+  concurrency?: number  // 0 = unlimited (default), 1 = sequential, N = max concurrent
+}
+
+function goTryAll<T extends readonly unknown[]>(
+  items: { [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) },
+  options?: GoTryAllOptions
+): Promise<[{ [K in keyof T]: string | undefined }, { [K in keyof T]: T[K] | undefined }]>
+```
+
+**Promise mode** (pass promises directly):
+```ts
+// Run all in parallel (default):
+const [errors, results] = await goTryAll([
+  fetchUser(1),      // Promise<User>
+  fetchUser(2),      // Promise<User>
+  fetchUser(3),      // Promise<User>
+])
+// errors: [string | undefined, string | undefined, string | undefined]
+// results: [User | undefined, User | undefined, User | undefined]
+```
+
+**Factory mode** (pass functions that return promises):
+```ts
+// True lazy execution - factories only called when a slot is available
+const [errors, results] = await goTryAll([
+  () => fetchUser(1),  // Only called when concurrency slot available
+  () => fetchUser(2),  // Only called when concurrency slot available
+  () => fetchUser(3),  // Only called when concurrency slot available
+  () => fetchUser(4),  // Only called when concurrency slot available
+], { concurrency: 2 })
+
+// Use factory mode when you need to:
+// - Rate limit API calls (don't start HTTP requests until allowed)
+// - Control database connection limits
+// - Limit expensive computation resources
+```
+
+### `goTryAllRaw<T>(items, options?)`
+
+Like `goTryAll`, but returns raw Error objects instead of error messages.
+
+```ts
+function goTryAllRaw<T extends readonly unknown[]>(
+  items: { [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) },
+  options?: GoTryAllOptions
+): Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>
+```
+
+### `goTryOr<T>(value, defaultValue)`
+
+Like `goTry`, but returns a default value on failure instead of `undefined`.
+The default can be either a static value or a function (for lazy evaluation).
+
+```ts
+function goTryOr<T>(value: T | Promise<T> | (() => T | Promise<T>), defaultValue: T | (() => T)): Result<string, T> | Promise<Result<string, T>>
+```
+
+### `isSuccess(result)` / `isFailure(result)`
+
+Type guards to check result status.
+
+```ts
+function isSuccess<E, T>(result: Result<E, T>): result is Success<T>
+function isFailure<E, T>(result: Result<E, T>): result is Failure<E>
+```
+
+### `success(value)` / `failure(error)`
 
--   synchronous/asynchronous function / Promise
+Helper functions to create Result tuples.
 
-**Returns** a tuple with the possible error and result as `[Err | undefined, T | undefined]` (Golang style)
+```ts
+function success<T>(value: T): Success<T>
+function failure<E>(error: E): Failure<E>
+```
+
+## Types
+
+```ts
+type Success<T> = readonly [undefined, T]
+type Failure<E> = readonly [E, undefined]
+type Result<E, T> = Success<T> | Failure<E>
+```
 
+## License
 
-If you use TypeScript, the types are well defined and won't let you make a mistake.
+MIT

package/dist/index.cjs

@@ -12,6 +12,83 @@ function success(value) {
 function failure(error) {
   return [error, void 0];
 }
+function resolveDefault(defaultValue) {
+  return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+}
+function goTryOr(value, defaultValue) {
+  try {
+    const result = typeof value === "function" ? value() : value;
+    if (isPromise(result)) {
+      return result.then((resolvedValue) => success(resolvedValue)).catch((err) => [getErrorMessage(err), resolveDefault(defaultValue)]);
+    }
+    return success(result);
+  } catch (err) {
+    return [getErrorMessage(err), resolveDefault(defaultValue)];
+  }
+}
+async function runWithConcurrency(items, concurrency) {
+  if (items.length === 0) {
+    return [];
+  }
+  const isFactoryMode = typeof items[0] === "function";
+  if (!isFactoryMode && concurrency <= 0) {
+    return Promise.allSettled(items);
+  }
+  const results = new Array(items.length);
+  let index = 0;
+  async function worker() {
+    while (index < items.length) {
+      const currentIndex = index++;
+      try {
+        const item = items[currentIndex];
+        const value = isFactoryMode ? await item() : await item;
+        results[currentIndex] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[currentIndex] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workerCount = concurrency <= 0 ? items.length : Math.min(concurrency, items.length);
+  const workers = [];
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(worker());
+  }
+  await Promise.all(workers);
+  return results;
+}
+async function goTryAll(items, options) {
+  const settled = await runWithConcurrency(items, options?.concurrency ?? 0);
+  const errors = [];
+  const results = [];
+  for (let i = 0; i < settled.length; i++) {
+    const item = settled[i];
+    if (item.status === "fulfilled") {
+      errors[i] = void 0;
+      results[i] = item.value;
+    } else {
+      errors[i] = getErrorMessage(item.reason);
+      results[i] = void 0;
+    }
+  }
+  return [errors, results];
+}
+async function goTryAllRaw(items, options) {
+  const settled = await runWithConcurrency(items, options?.concurrency ?? 0);
+  const errors = [];
+  const results = [];
+  for (let i = 0; i < settled.length; i++) {
+    const item = settled[i];
+    if (item.status === "fulfilled") {
+      errors[i] = void 0;
+      results[i] = item.value;
+    } else {
+      const reason = item.reason;
+      errors[i] = isError(reason) ? reason : new Error(String(reason));
+      results[i] = void 0;
+    }
+  }
+  return [errors, results];
+}
 function getErrorMessage(error) {
   if (error === void 0) return "undefined";
   if (typeof error === "string") return error;
@@ -64,6 +141,9 @@ function goTryRaw(value) {
 
 exports.failure = failure;
 exports.goTry = goTry;
+exports.goTryAll = goTryAll;
+exports.goTryAllRaw = goTryAllRaw;
+exports.goTryOr = goTryOr;
 exports.goTryRaw = goTryRaw;
 exports.isFailure = isFailure;
 exports.isSuccess = isSuccess;

package/dist/index.d.cts

@@ -1,11 +1,101 @@
 type Success<T> = readonly [undefined, T];
 type Failure<E> = readonly [E, undefined];
 type Result<E, T> = Success<T> | Failure<E>;
+type ResultWithDefault<E, T> = readonly [E | undefined, T];
 type MaybePromise<T> = T | Promise<T>;
+interface GoTryAllOptions {
+    /**
+     * Maximum number of concurrent promises.
+     * Set to 0 (default) for unlimited concurrency (all promises run in parallel).
+     */
+    concurrency?: number;
+}
 declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
 declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
 declare function success<T>(value: T): Success<T>;
 declare function failure<E>(error: E): Failure<E>;
+/**
+ * Executes a function, promise, or value and returns a Result type with a fallback default.
+ * If an error occurs, it returns the error message and the default value.
+ *
+ * @template T The type of the successful result
+ * @param {T | Promise<T> | (() => T | Promise<T>)} value - The value, promise, or function to execute
+ * @param {T | (() => T)} defaultValue - The default value or a function to compute it (only called on failure)
+ * @returns {ResultWithDefault<string, T> | Promise<ResultWithDefault<string, T>>} A tuple of [error, value] or Promise thereof
+ *
+ * @example
+ * // With a static default
+ * const [err, config] = goTryOr(() => JSON.parse('invalid'), { port: 3000 })
+ * // err is the error message, config is { port: 3000 }
+ *
+ * @example
+ * // With a computed default (lazy evaluation)
+ * const [err, user] = await goTryOr(fetchUser(id), () => ({
+ *   id: 'anonymous',
+ *   name: 'Guest'
+ * }))
+ */
+declare function goTryOr<T>(fn: () => never, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
+declare function goTryOr<T>(fn: () => Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault<string, T>>;
+declare function goTryOr<T>(promise: Promise<T>, defaultValue: T | (() => T)): Promise<ResultWithDefault<string, T>>;
+declare function goTryOr<T>(fn: () => T, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
+declare function goTryOr<T>(value: T, defaultValue: T | (() => T)): ResultWithDefault<string, T>;
+/**
+ * Executes multiple promises or factory functions in parallel (or with limited concurrency)
+ * and returns a tuple of [errors, results]. Unlike Promise.all, this doesn't fail fast -
+ * it waits for all promises to settle.
+ *
+ * Accepts either:
+ * - An array of promises (for simple parallel execution)
+ * - An array of factory functions that return promises (for lazy execution with concurrency control)
+ *
+ * @template T The tuple type of all promise results
+ * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
+ * @param {GoTryAllOptions} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: string | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ *          A tuple where the first element is a tuple of errors (or undefined) and
+ *          the second element is a tuple of results (or undefined), preserving input order
+ *
+ * @example
+ * // Run all in parallel (default) - with promises
+ * const [errors, results] = await goTryAll([
+ *   fetchUser(1),
+ *   fetchUser(2),
+ *   fetchUser(3)
+ * ])
+ *
+ * @example
+ * // Limit concurrency with factory functions (lazy execution)
+ * const [errors, results] = await goTryAll([
+ *   () => fetchUser(1),  // Only called when a slot is available
+ *   () => fetchUser(2),  // Only called when a slot is available
+ *   () => fetchUser(3),  // Only called when a slot is available
+ * ], { concurrency: 2 })
+ */
+declare function goTryAll<T extends readonly unknown[]>(items: {
+    [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>);
+}, options?: GoTryAllOptions): Promise<[{
+    [K in keyof T]: string | undefined;
+}, {
+    [K in keyof T]: T[K] | undefined;
+}]>;
+/**
+ * Like `goTryAll`, but returns raw Error objects instead of error messages.
+ *
+ * @template T The tuple type of all promise results
+ * @param {readonly [...{ [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>) }]} items - Array of promises or factories
+ * @param {GoTryAllOptions} options - Optional configuration
+ * @returns {Promise<[{ [K in keyof T]: Error | undefined }, { [K in keyof T]: T[K] | undefined }]>}
+ *          A tuple where the first element is a tuple of Error objects (or undefined) and
+ *          the second element is a tuple of results (or undefined), preserving input order
+ */
+declare function goTryAllRaw<T extends readonly unknown[]>(items: {
+    [K in keyof T]: Promise<T[K]> | (() => Promise<T[K]>);
+}, options?: GoTryAllOptions): Promise<[{
+    [K in keyof T]: Error | undefined;
+}, {
+    [K in keyof T]: T[K] | undefined;
+}]>;
 /**
  * Executes a function, promise, or value and returns a Result type.
  * If an error occurs, it returns a Failure with the error message as a string.
@@ -58,4 +148,6 @@ declare function goTryRaw<T, E = Error>(promise: Promise<T>): Promise<Result<E,
 declare function goTryRaw<T, E = Error>(fn: () => T): Result<E, T>;
 declare function goTryRaw<T, E = Error>(value: T): Result<E, T>;
 
-export { type Failure, type MaybePromise, type Result, type Success, failure, goTry, goTryRaw, isFailure, isSuccess, success };
+export { failure, goTry, goTryAll, goTryAllRaw, goTryOr, goTryRaw, isFailure, isSuccess, success };
+export type { Failure, GoTryAllOptions, MaybePromise, Result, ResultWithDefault, Success };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sources":["../src/index.ts"],"mappings":"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","names":[]}