📦 deps(thirdparty): update snapshots

2026-05-29 08:33:53 +00:00
parent fdb52f1e96
commit 06e0d13d57
1615 changed files with 232858 additions and 0 deletions
@@ -0,0 +1,238 @@
+# Result Utilities
+
+Operations for working with `Result<T, E>` from `better-result`.
+
+## Creating Results
+
+```typescript
+import { Result } from "@outfitter/contracts";
+
+// Success
+const ok = Result.ok({ name: "Alice", id: "1" });
+
+// Failure
+const err = Result.err(new NotFoundError("user", "123"));
+```
+
+## Checking Results
+
+```typescript
+// Boolean check
+if (result.isOk()) {
+  console.log(result.value);  // TypeScript knows type
+}
+
+if (result.isErr()) {
+  console.log(result.error);  // TypeScript knows error type
+}
+```
+
+## Accessing Values
+
+```typescript
+// Safe access (only after isOk check)
+if (result.isOk()) {
+  const user = result.value;
+}
+
+// Unsafe access (throws if error)
+const user = result.unwrap();  // Throws if err!
+
+// With default
+const user = result.unwrapOr(defaultUser);
+
+// With default factory
+const user = result.unwrapOrElse(() => createDefaultUser());
+```
+
+## Pattern Matching
+
+```typescript
+const message = result.match({
+  ok: (user) => `Found ${user.name}`,
+  err: (error) => `Error: ${error.message}`,
+});
+```
+
+## Transforming Results
+
+### Map (transform success value)
+
+```typescript
+const nameResult = result.map((user) => user.name);
+// Result<string, Error>
+```
+
+### MapErr (transform error)
+
+```typescript
+const mappedResult = result.mapErr((error) => new WrappedError(error));
+// Result<User, WrappedError>
+```
+
+### FlatMap / AndThen (chain operations)
+
+```typescript
+const orderResult = getUserResult.flatMap((user) => getOrders(user.id));
+// Result<Orders, UserError | OrderError>
+```
+
+## Combining Results
+
+### combine2, combine3, etc.
+
+Combine multiple results into a tuple:
+
+```typescript
+import { combine2, combine3 } from "@outfitter/contracts";
+
+const result = combine2(userResult, orderResult);
+// Result<[User, Order], UserError | OrderError>
+
+if (result.isOk()) {
+  const [user, order] = result.value;
+}
+```
+
+### combineAll
+
+Combine an array of results:
+
+```typescript
+import { combineAll } from "@outfitter/contracts";
+
+const results = await Promise.all(ids.map((id) => getUser(id)));
+const combined = combineAll(results);
+// Result<User[], Error>
+```
+
+### combineObject
+
+Combine an object of results:
+
+```typescript
+import { combineObject } from "@outfitter/contracts";
+
+const combined = combineObject({
+  user: userResult,
+  orders: ordersResult,
+  settings: settingsResult,
+});
+// Result<{ user: User; orders: Order[]; settings: Settings }, Error>
+```
+
+## Error Recovery
+
+### OrElse (try alternative on error)
+
+```typescript
+const result = primaryResult.orElse(() => fallbackResult);
+```
+
+### Recover (convert error to success)
+
+```typescript
+const result = userResult.recover((error) => {
+  if (error._tag === "NotFoundError") {
+    return Result.ok(defaultUser);
+  }
+  return Result.err(error);
+});
+```
+
+## Async Patterns
+
+### Sequential execution
+
+```typescript
+const result = await getUser(id)
+  .then((r) => r.isOk() ? getOrders(r.value.id) : Promise.resolve(r));
+```
+
+### With async/await
+
+```typescript
+async function getUserWithOrders(id: string): Promise<Result<UserWithOrders, Error>> {
+  const userResult = await getUser(id);
+  if (userResult.isErr()) return userResult;
+
+  const ordersResult = await getOrders(userResult.value.id);
+  if (ordersResult.isErr()) return ordersResult;
+
+  return Result.ok({
+    user: userResult.value,
+    orders: ordersResult.value,
+  });
+}
+```
+
+## Validation Helper
+
+The `createValidator` utility returns `Result`:
+
+```typescript
+import { createValidator } from "@outfitter/contracts";
+import { z } from "zod";
+
+const schema = z.object({
+  email: z.string().email(),
+  age: z.number().int().positive(),
+});
+
+const validate = createValidator(schema);
+
+const result = validate({ email: "test@example.com", age: 25 });
+// Result<{ email: string; age: number }, ValidationError>
+```
+
+## Common Patterns
+
+### Early return on error
+
+```typescript
+const handler: Handler<Input, Output, Error> = async (input, ctx) => {
+  const validateResult = validate(input);
+  if (validateResult.isErr()) return validateResult;
+
+  const userResult = await getUser(validateResult.value.userId);
+  if (userResult.isErr()) return userResult;
+
+  const orderResult = await createOrder(userResult.value);
+  if (orderResult.isErr()) return orderResult;
+
+  return Result.ok(orderResult.value);
+};
+```
+
+### Collect all errors
+
+```typescript
+const errors: ValidationError[] = [];
+
+if (!input.name) errors.push(new ValidationError("Name required"));
+if (!input.email) errors.push(new ValidationError("Email required"));
+
+if (errors.length > 0) {
+  return Result.err(new ValidationError("Multiple errors", { errors }));
+}
+```
+
+### Wrap throwing functions
+
+```typescript
+function wrapThrowable<T>(fn: () => T): Result<T, InternalError> {
+  try {
+    return Result.ok(fn());
+  } catch (error) {
+    return Result.err(new InternalError("Unexpected error", { cause: error }));
+  }
+}
+
+async function wrapAsync<T>(fn: () => Promise<T>): Promise<Result<T, InternalError>> {
+  try {
+    return Result.ok(await fn());
+  } catch (error) {
+    return Result.err(new InternalError("Unexpected error", { cause: error }));
+  }
+}
+```