aws-sdk-vitest-mock 0.1.0 → 0.2.1

package/README.md

@@ -44,31 +44,53 @@ pnpm add -D aws-sdk-vitest-mock
 ### Basic Usage
 
 ```typescript
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { mockClient } from "aws-sdk-vitest-mock";
 import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
 
-// Mock the S3 client
-const s3Mock = mockClient(S3Client);
+// Your application code
+class DocumentService {
+  constructor(private s3Client: S3Client) {}
+
+  async getDocument(bucket: string, key: string) {
+    const result = await this.s3Client.send(
+      new GetObjectCommand({ Bucket: bucket, Key: key }),
+    );
+    return result.Body;
+  }
+}
+
+describe("DocumentService", () => {
+  let s3Mock: ReturnType<typeof mockClient>;
+  let documentService: DocumentService;
+
+  beforeEach(() => {
+    // Mock the S3 client
+    s3Mock = mockClient(S3Client);
+
+    // Create service with real S3Client (which is now mocked)
+    const s3Client = new S3Client({ region: "us-east-1" });
+    documentService = new DocumentService(s3Client);
+  });
 
-// Configure mock responses
-s3Mock.on(GetObjectCommand).resolves({
-  Body: "mock data",
-  ContentType: "text/plain",
-});
+  afterEach(() => {
+    s3Mock.restore();
+  });
 
-// Use in your tests
-const client = new S3Client({});
-const result = await client.send(
-  new GetObjectCommand({
-    Bucket: "my-bucket",
-    Key: "my-key",
-  }),
-);
+  test("should retrieve document from S3", async () => {
+    // Configure mock response
+    s3Mock.on(GetObjectCommand).resolves({
+      Body: "document content",
+      ContentType: "text/plain",
+    });
 
-console.log(result.Body); // 'mock data'
+    // Test your application code
+    const result = await documentService.getDocument("my-bucket", "doc.txt");
 
-// Clean up
-s3Mock.restore();
+    expect(result).toBe("document content");
+    expect(s3Mock).toHaveReceivedCommand(GetObjectCommand);
+  });
+});
 ```
 
 ### Request Matching
@@ -99,6 +121,199 @@ s3Mock
 // All other calls return 'subsequent calls'
 ```
 
+### Fixture Loading
+
+Load mock responses from files for easier test data management:
+
+```typescript
+// Load JSON response from file
+s3Mock.on(GetObjectCommand).resolvesFromFile("./fixtures/s3-response.json");
+
+// Load text response from file
+s3Mock.on(GetObjectCommand).resolvesFromFile("./fixtures/response.txt");
+
+// JSON files are automatically parsed, text files returned as strings
+// File paths are resolved relative to current working directory
+```
+
+### Paginator Support
+
+Mock AWS SDK v3 pagination with automatic token handling:
+
+```typescript
+// Mock DynamoDB scan with pagination
+const items = Array.from({ length: 25 }, (_, i) => ({
+  id: { S: `item-${i + 1}` },
+}));
+
+dynamoMock.on(ScanCommand).resolvesPaginated(items, {
+  pageSize: 10,
+  itemsKey: "Items",
+  tokenKey: "NextToken",
+});
+
+// First call returns items 1-10 with NextToken
+// Second call with NextToken returns items 11-20
+// Third call returns items 21-25 without NextToken
+
+// Mock S3 list objects with pagination
+const objects = Array.from({ length: 15 }, (_, i) => ({
+  Key: `file-${i + 1}.txt`,
+}));
+
+s3Mock.on(ListObjectsV2Command).resolvesPaginated(objects, {
+  pageSize: 10,
+  itemsKey: "Contents",
+  tokenKey: "ContinuationToken",
+});
+```
+
+### DynamoDB with Marshal/Unmarshal
+
+Mock DynamoDB operations using AWS SDK's marshal/unmarshal utilities for type-safe data handling:
+
+```typescript
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mockClient } from "aws-sdk-vitest-mock";
+import {
+  DynamoDBClient,
+  GetItemCommand,
+  PutItemCommand,
+} from "@aws-sdk/client-dynamodb";
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+
+// Your application service
+class UserService {
+  constructor(private dynamoClient: DynamoDBClient) {}
+
+  async getUser(userId: string) {
+    const result = await this.dynamoClient.send(
+      new GetItemCommand({
+        TableName: "Users",
+        Key: marshall({ id: userId }),
+      }),
+    );
+
+    return result.Item ? unmarshall(result.Item) : null;
+  }
+
+  async createUser(user: { id: string; name: string; email: string }) {
+    await this.dynamoClient.send(
+      new PutItemCommand({
+        TableName: "Users",
+        Item: marshall(user),
+      }),
+    );
+  }
+}
+
+describe("UserService with DynamoDB", () => {
+  let dynamoMock: ReturnType<typeof mockClient>;
+  let userService: UserService;
+
+  beforeEach(() => {
+    dynamoMock = mockClient(DynamoDBClient);
+    const dynamoClient = new DynamoDBClient({ region: "us-east-1" });
+    userService = new UserService(dynamoClient);
+  });
+
+  afterEach(() => {
+    dynamoMock.restore();
+  });
+
+  test("should get user by id", async () => {
+    const mockUser = { id: "123", name: "John Doe", email: "john@example.com" };
+
+    // Mock DynamoDB response with marshalled data
+    dynamoMock.on(GetItemCommand).resolves({
+      Item: marshall(mockUser),
+    });
+
+    const result = await userService.getUser("123");
+
+    expect(result).toEqual(mockUser);
+    expect(dynamoMock).toHaveReceivedCommandWith(GetItemCommand, {
+      TableName: "Users",
+      Key: marshall({ id: "123" }),
+    });
+  });
+
+  test("should create new user", async () => {
+    const newUser = {
+      id: "456",
+      name: "Jane Smith",
+      email: "jane@example.com",
+    };
+
+    dynamoMock.on(PutItemCommand).resolves({});
+
+    await userService.createUser(newUser);
+
+    expect(dynamoMock).toHaveReceivedCommandWith(PutItemCommand, {
+      TableName: "Users",
+      Item: marshall(newUser),
+    });
+  });
+
+  test("should return null for non-existent user", async () => {
+    dynamoMock.on(GetItemCommand).resolves({}); // No Item in response
+
+    const result = await userService.getUser("999");
+
+    expect(result).toBeNull();
+  });
+});
+```
+
+### Stream Mocking (S3 Helper)
+
+Mock S3 operations that return streams with automatic environment detection:
+
+```typescript
+// Mock with string content
+s3Mock.on(GetObjectCommand).resolvesStream("Hello, World!");
+
+// Mock with Buffer
+s3Mock.on(GetObjectCommand).resolvesStream(Buffer.from("Binary data"));
+
+// One-time stream response
+s3Mock
+  .on(GetObjectCommand)
+  .resolvesStreamOnce("First call")
+  .resolvesStream("Subsequent calls");
+```
+
+### Delay/Latency Simulation
+
+Simulate network delays for testing timeouts and race conditions:
+
+```typescript
+// Resolve with delay
+s3Mock.on(GetObjectCommand).resolvesWithDelay({ Body: "data" }, 1000);
+
+// Reject with delay
+s3Mock.on(GetObjectCommand).rejectsWithDelay("Network timeout", 500);
+```
+
+### AWS Error Simulation
+
+Convenient methods for common AWS errors:
+
+```typescript
+// S3 Errors
+s3Mock.on(GetObjectCommand).rejectsWithNoSuchKey("missing-key");
+s3Mock.on(GetObjectCommand).rejectsWithNoSuchBucket("missing-bucket");
+s3Mock.on(GetObjectCommand).rejectsWithAccessDenied("protected-resource");
+
+// DynamoDB Errors
+dynamoMock.on(GetItemCommand).rejectsWithResourceNotFound("missing-table");
+dynamoMock.on(PutItemCommand).rejectsWithConditionalCheckFailed();
+
+// General AWS Errors
+s3Mock.on(GetObjectCommand).rejectsWithThrottling();
+s3Mock.on(GetObjectCommand).rejectsWithInternalServerError();
+```
+
 ### Error Handling
 
 ```typescript
@@ -124,20 +339,80 @@ s3Mock.on(GetObjectCommand).callsFake(async (input, getClient) => {
 ### Mocking Existing Instances
 
 ```typescript
-const existingClient = new S3Client({ region: "us-east-1" });
-const mock = mockClientInstance(existingClient);
+// Your application service that uses an injected S3 client
+class FileUploadService {
+  constructor(private s3Client: S3Client) {}
+
+  async uploadFile(bucket: string, key: string, data: string) {
+    return await this.s3Client.send(
+      new PutObjectCommand({ Bucket: bucket, Key: key, Body: data }),
+    );
+  }
+}
+
+test("should mock existing S3 client instance", async () => {
+  // Create the client your application will use
+  const s3Client = new S3Client({ region: "us-east-1" });
+  const service = new FileUploadService(s3Client);
+
+  // Mock the existing client instance
+  const mock = mockClientInstance(s3Client);
+  mock.on(PutObjectCommand).resolves({ ETag: "mock-etag" });
+
+  // Test your service
+  const result = await service.uploadFile("bucket", "key", "data");
+
+  expect(result.ETag).toBe("mock-etag");
+  expect(mock).toHaveReceivedCommand(PutObjectCommand);
+});
+```
+
+### Debug Mode
 
-mock.on(GetObjectCommand).resolves({ Body: "mocked" });
+Enable debug logging to troubleshoot mock configurations and see detailed information about command matching:
 
-// The existing instance is now mocked
-const result = await existingClient.send(
-  new GetObjectCommand({
-    Bucket: "b",
-    Key: "k",
-  }),
+```typescript
+const s3Mock = mockClient(S3Client);
+
+// Enable debug logging
+s3Mock.enableDebug();
+
+s3Mock
+  .on(GetObjectCommand, { Bucket: "test-bucket" })
+  .resolves({ Body: "data" });
+
+// This will log:
+// [AWS Mock Debug] Received command: GetObjectCommand
+// [AWS Mock Debug] Found 1 mock(s) for GetObjectCommand
+// [AWS Mock Debug] Using mock at index 0 for GetObjectCommand
+await client.send(
+  new GetObjectCommand({ Bucket: "test-bucket", Key: "file.txt" }),
 );
+
+// Disable debug logging
+s3Mock.disableDebug();
 ```
 
+Debug mode logs include:
+
+- Incoming commands and their inputs
+- Number of configured mocks for each command
+- Mock matching results and reasons for failures
+- One-time mock removal notifications
+
+## 🧪 Test Coverage
+
+The library includes comprehensive test suites covering all features:
+
+- **Core mocking functionality** - Command matching, response handling, sequential responses
+- **Paginator support** - Automatic token handling for AWS pagination patterns
+- **Debug logging** - Enable/disable functionality and proper console output formatting
+- **Stream mocking** - S3 stream responses with environment detection
+- **Error simulation** - AWS-specific errors and general error handling
+- **Custom matchers** - Vitest integration for asserting command calls
+
+All utilities have dedicated test files ensuring reliability and maintainability.
+
 ## 🧪 Custom Matchers
 
 Import the custom matchers in your test setup:
@@ -182,6 +457,9 @@ test("should call DynamoDB", async () => {
   expect(ddbMock).toHaveReceivedNthCommandWith(1, GetItemCommand, {
     TableName: "users",
   });
+
+  // Assert no other commands were received
+  expect(ddbMock).toHaveReceivedNoOtherCommands([GetItemCommand]);
 });
 ```
 
@@ -205,6 +483,8 @@ Mocks an existing AWS SDK client instance.
 - `reset()` - Clear all mocks and call history
 - `restore()` - Restore original client behavior
 - `calls()` - Get call history
+- `enableDebug()` - Enable debug logging for troubleshooting
+- `disableDebug()` - Disable debug logging
 
 ### `AwsCommandStub` Methods (Chainable)
 
@@ -214,6 +494,19 @@ Mocks an existing AWS SDK client instance.
 - `rejectsOnce(error)` - Return error once
 - `callsFake(handler)` - Custom response handler
 - `callsFakeOnce(handler)` - Custom response handler (once)
+- `resolvesStream(data)` - Return stream response (S3 helper)
+- `resolvesStreamOnce(data)` - Return stream response once (S3 helper)
+- `resolvesWithDelay(output, delayMs)` - Return response with delay
+- `rejectsWithDelay(error, delayMs)` - Return error with delay
+- `resolvesPaginated(items, options?)` - Return paginated responses with automatic token handling
+- `resolvesFromFile(filePath)` - Load response from file (JSON files are parsed, others returned as strings)
+- `rejectsWithNoSuchKey(key?)` - Reject with S3 NoSuchKey error
+- `rejectsWithNoSuchBucket(bucket?)` - Reject with S3 NoSuchBucket error
+- `rejectsWithAccessDenied(resource?)` - Reject with AccessDenied error
+- `rejectsWithResourceNotFound(resource?)` - Reject with DynamoDB ResourceNotFound error
+- `rejectsWithConditionalCheckFailed()` - Reject with DynamoDB ConditionalCheckFailed error
+- `rejectsWithThrottling()` - Reject with Throttling error
+- `rejectsWithInternalServerError()` - Reject with InternalServerError
 
 ## 🤝 Contributing
 
@@ -250,6 +543,10 @@ bun nx build
 
 See [CONTRIBUTING.md](./CONTRIBUTING.md) for the complete guide.
 
+## 🙏 Acknowledgements
+
+This library was inspired by [aws-sdk-client-mock](https://github.com/m-radzikowski/aws-sdk-client-mock). Adapted the core concepts and API design for Vitest while adding additional features and capabilities.
+
 ## 📝 License
 
 MIT

package/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("vitest"),h=require("./matchers-D1XEjFLq.cjs");function m(r,t){return Object.keys(t).every(c=>{const o=t[c],n=r[c];return o&&typeof o=="object"&&!Array.isArray(o)?typeof n!="object"||n===null?!1:m(n,o):n===o})}function y(r,t){if(r===t)return!0;if(typeof r!="object"||r===null||typeof t!="object"||t===null)return r===t;const c=Object.keys(r),o=Object.keys(t);return c.length!==o.length?!1:o.every(n=>{if(!Object.prototype.hasOwnProperty.call(r,n))return!1;const s=r[n],e=t[n];return typeof s=="object"&&s!==null&&typeof e=="object"&&e!==null?y(s,e):s===e})}function k(r){return async function(t){const c=this,o=()=>c,n=r.map.get(t.constructor);if(n){const s=n.findIndex(e=>e.strict?e.matcher&&y(t.input,e.matcher):!e.matcher||m(t.input,e.matcher));if(s!==-1){const e=n[s];return e.once&&n.splice(s,1),e.handler(t.input,o)}}throw new Error(`No mock configured for command: ${t.constructor.name}`)}}function b(r,t,c,o={}){const n=(e,a)=>{const p={matcher:c,handler:e,once:a,strict:!!o.strict},i=r.map.get(t)??[];if(a){const l=i.findIndex(u=>!u.once);l===-1?i.push(p):i.splice(l,0,p),r.map.set(t,i)}else{const l=i.filter(u=>u.once||JSON.stringify(u.matcher)!==JSON.stringify(c));l.push(p),r.map.set(t,l)}},s={resolves(e){return n(()=>Promise.resolve(e),!1),s},rejects(e){return n(()=>{const a=typeof e=="string"?new Error(e):e;return Promise.reject(a)},!1),s},callsFake(e){return n(e,!1),s},resolvesOnce(e){return n(()=>Promise.resolve(e),!0),s},rejectsOnce(e){return n(()=>{const a=typeof e=="string"?new Error(e):e;return Promise.reject(a)},!0),s},callsFakeOnce(e){return n(e,!0),s}};return s}const j=r=>{const t={map:new WeakMap},c=("prototype"in r,r.prototype),o=f.vi.spyOn(c,"send").mockImplementation(k(t));return{client:void 0,on:(s,e,a)=>b(t,s,e,a),reset:()=>{o.mockClear(),t.map=new WeakMap},restore:()=>{o.mockRestore(),t.map=new WeakMap},calls:()=>o.mock.calls}},d=r=>{const t={map:new WeakMap},c=f.vi.spyOn(r,"send").mockImplementation(k(t));return{client:r,on:(n,s,e)=>b(t,n,s,e),reset:()=>{c.mockClear(),t.map=new WeakMap},restore:()=>{c.mockRestore(),t.map=new WeakMap},calls:()=>c.mock.calls}};exports.matchers=h.matchers;exports.mockClient=j;exports.mockClientInstance=d;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const b=require("vitest"),P=require("node:fs"),R=require("node:path"),N=require("node:stream"),W=require("./matchers-G36N2DNa.cjs");class d extends Error{constructor(e,s,c,n){super(e),this.name="AwsError",this.code=s,this.statusCode=c,this.retryable=n}}const C=t=>{const e=t?`The specified key does not exist. Key: ${t}`:"The specified key does not exist.";return new d(e,"NoSuchKey",404,!1)},M=t=>{const e=t?`The specified bucket does not exist. Bucket: ${t}`:"The specified bucket does not exist.";return new d(e,"NoSuchBucket",404,!1)},$=t=>{const e=t?`Access Denied for resource: ${t}`:"Access Denied";return new d(e,"AccessDenied",403,!1)},D=t=>{const e=t?`Requested resource not found: ${t}`:"Requested resource not found";return new d(e,"ResourceNotFoundException",400,!1)},I=()=>new d("The conditional request failed","ConditionalCheckFailedException",400,!1),O=()=>new d("Rate exceeded","Throttling",400,!0),T=()=>new d("We encountered an internal error. Please try again.","InternalServerError",500,!0);function k(){return{enabled:!1,log(t,e){this.enabled&&(e===void 0?console.log(`[aws-sdk-vitest-mock](Debug) ${t}`):console.log(`[aws-sdk-vitest-mock](Debug) ${t}`,e))}}}function y(t){t.enabled=!0}function v(t){t.enabled=!1}function F(t){const e=R.resolve(t),s=P.readFileSync(e,"utf8");return t.endsWith(".json")?JSON.parse(s):s}function L(t,e={}){const{pageSize:s=10,tokenKey:c="NextToken",itemsKey:n="Items"}=e;if(t.length===0)return[{[n]:[]}];const o=[];for(let r=0;r<t.length;r+=s){const u=t.slice(r,r+s),i=r+s<t.length,l={[n]:u};if(i){const a=l;a[c]=`token-${r+s}`}o.push(l)}return o}function A(){return typeof process<"u"&&process.versions?.node?"node":typeof process<"u"&&process.versions?.bun?"bun":"browser"}function K(t){const e=typeof t=="string"?Buffer.from(t,"utf8"):Buffer.from(t);return new N.Readable({read(){this.push(e),this.push(void 0)}})}function q(t){let e;return typeof t=="string"?e=new TextEncoder().encode(t):t instanceof Buffer?e=new Uint8Array(t):e=t,new ReadableStream({start(s){s.enqueue(e),s.close()}})}function m(t){const e=A();return e==="node"||e==="bun"?K(t):q(t)}function w(t,e){return Object.keys(e).every(s=>{const c=e[s],n=t[s];return c&&typeof c=="object"&&!Array.isArray(c)?typeof n!="object"||n===null?!1:w(n,c):n===c})}function j(t,e){if(t===e)return!0;if(typeof t!="object"||t===null||typeof e!="object"||e===null)return t===e;const s=Object.keys(t),c=Object.keys(e);return s.length!==c.length?!1:c.every(n=>{if(!Object.prototype.hasOwnProperty.call(t,n))return!1;const o=t,r=e,u=o[n],i=r[n];return typeof u=="object"&&u!==null&&typeof i=="object"&&i!==null?j(u,i):u===i})}function S(t){return async function(e){const s=()=>this;t.debugLogger.log(`Received command: ${e.constructor.name}`,e.input);const c=t.map.get(e.constructor);if(c){t.debugLogger.log(`Found ${c.length} mock(s) for ${e.constructor.name}`);const n=c.findIndex(o=>o.strict?o.matcher&&j(e.input,o.matcher):!o.matcher||w(e.input,o.matcher));if(n===-1)t.debugLogger.log(`No matching mock found for ${e.constructor.name}`,e.input);else{const o=c[n];if(!o)throw new Error(`Mock at index ${n} not found`);return t.debugLogger.log(`Using mock at index ${n} for ${e.constructor.name}`),o.once&&(c.splice(n,1),t.debugLogger.log(`Removed one-time mock for ${e.constructor.name}`)),o.handler(e.input,s())}}else t.debugLogger.log(`No mocks configured for ${e.constructor.name}`);throw new Error(`No mock configured for command: ${e.constructor.name}`)}}function x(t,e,s,c={}){const n=(r,u)=>{const i={matcher:s,handler:r,once:u,strict:!!c.strict},l=t.map.get(e)??[];if(u){const a=l.findIndex(f=>!f.once);a===-1?l.push(i):l.splice(a,0,i),t.map.set(e,l)}else{const a=l.filter(f=>f.once||JSON.stringify(f.matcher)!==JSON.stringify(s));a.push(i),t.map.set(e,a)}},o={resolves(r){return n(()=>Promise.resolve(r),!1),o},rejects(r){return n(()=>{const u=typeof r=="string"?new Error(r):r;return Promise.reject(u)},!1),o},callsFake(r){return n(r,!1),o},resolvesOnce(r){return n(()=>Promise.resolve(r),!0),o},rejectsOnce(r){return n(()=>{const u=typeof r=="string"?new Error(r):r;return Promise.reject(u)},!0),o},callsFakeOnce(r){return n(r,!0),o},resolvesStream(r){return n(()=>Promise.resolve({Body:m(r)}),!1),o},resolvesStreamOnce(r){return n(()=>Promise.resolve({Body:m(r)}),!0),o},resolvesWithDelay(r,u){const i=l=>{setTimeout(()=>l(r),u)};return n(()=>new Promise(i),!1),o},rejectsWithDelay(r,u){const i=typeof r=="string"?new Error(r):r,l=(a,f)=>{setTimeout(()=>f(i),u)};return n(()=>new Promise(l),!1),o},rejectsWithNoSuchKey(r){return n(()=>Promise.reject(C(r)),!1),o},rejectsWithNoSuchBucket(r){return n(()=>Promise.reject(M(r)),!1),o},rejectsWithAccessDenied(r){return n(()=>Promise.reject($(r)),!1),o},rejectsWithResourceNotFound(r){return n(()=>Promise.reject(D(r)),!1),o},rejectsWithConditionalCheckFailed(){return n(()=>Promise.reject(I()),!1),o},rejectsWithThrottling(){return n(()=>Promise.reject(O()),!1),o},rejectsWithInternalServerError(){return n(()=>Promise.reject(T()),!1),o},resolvesPaginated(r,u={}){const i=L(r,u);let l=0;return n(a=>{const f=u.tokenKey||"NextToken",p=a[f];if(p){const g=/token-(\d+)/.exec(p);if(g&&g[1]){const E=g[1];l=Math.floor(Number.parseInt(E,10)/(u.pageSize||10))}}else l=0;const h=i[l]||i[i.length-1]||i[0];if(!h)throw new Error("No paginated responses available");return l=Math.min(l+1,i.length-1),Promise.resolve(h)},!1),o},resolvesFromFile(r){return n(()=>{const u=F(r);return Promise.resolve(u)},!1),o}};return o}const B=t=>{const e={map:new WeakMap,debugLogger:k()},s=t.prototype,c=b.vi.spyOn(s,"send").mockImplementation(S(e));return{client:void 0,on:(o,r,u)=>x(e,o,r,u),reset:()=>{c.mockClear(),e.map=new WeakMap},restore:()=>{c.mockRestore(),e.map=new WeakMap},calls:()=>c.mock.calls,enableDebug:()=>{y(e.debugLogger)},disableDebug:()=>{v(e.debugLogger)}}},V=t=>{const e={map:new WeakMap,debugLogger:k()},s=b.vi.spyOn(t,"send").mockImplementation(S(e));return{client:t,on:(n,o,r)=>x(e,n,o,r),reset:()=>{s.mockClear(),e.map=new WeakMap},restore:()=>{s.mockRestore(),e.map=new WeakMap},calls:()=>s.mock.calls,enableDebug:()=>{y(e.debugLogger)},disableDebug:()=>{v(e.debugLogger)}}};exports.matchers=W.matchers;exports.mockClient=B;exports.mockClientInstance=V;

package/index.js

@@ -1,113 +1,344 @@
-import { vi as f } from "vitest";
-import { m as w } from "./matchers-DclpcT4f.js";
-function m(r, t) {
-  return Object.keys(t).every((c) => {
-    const o = t[c], n = r[c];
-    return o && typeof o == "object" && !Array.isArray(o) ? typeof n != "object" || n === null ? !1 : m(n, o) : n === o;
+import { vi as b } from "vitest";
+import { readFileSync as P } from "node:fs";
+import R from "node:path";
+import { Readable as N } from "node:stream";
+import { m as X } from "./matchers-DdPGAOsD.js";
+class d extends Error {
+  constructor(e, s, c, n) {
+    super(e), this.name = "AwsError", this.code = s, this.statusCode = c, this.retryable = n;
+  }
+}
+const W = (t) => {
+  const e = t ? `The specified key does not exist. Key: ${t}` : "The specified key does not exist.";
+  return new d(e, "NoSuchKey", 404, !1);
+}, $ = (t) => {
+  const e = t ? `The specified bucket does not exist. Bucket: ${t}` : "The specified bucket does not exist.";
+  return new d(e, "NoSuchBucket", 404, !1);
+}, D = (t) => {
+  const e = t ? `Access Denied for resource: ${t}` : "Access Denied";
+  return new d(e, "AccessDenied", 403, !1);
+}, M = (t) => {
+  const e = t ? `Requested resource not found: ${t}` : "Requested resource not found";
+  return new d(e, "ResourceNotFoundException", 400, !1);
+}, C = () => new d(
+  "The conditional request failed",
+  "ConditionalCheckFailedException",
+  400,
+  !1
+), I = () => new d("Rate exceeded", "Throttling", 400, !0), O = () => new d(
+  "We encountered an internal error. Please try again.",
+  "InternalServerError",
+  500,
+  !0
+);
+function k() {
+  return {
+    enabled: !1,
+    log(t, e) {
+      this.enabled && (e === void 0 ? console.log(`[aws-sdk-vitest-mock](Debug) ${t}`) : console.log(`[aws-sdk-vitest-mock](Debug) ${t}`, e));
+    }
+  };
+}
+function y(t) {
+  t.enabled = !0;
+}
+function v(t) {
+  t.enabled = !1;
+}
+function T(t) {
+  const e = R.resolve(t), s = P(e, "utf8");
+  return t.endsWith(".json") ? JSON.parse(s) : s;
+}
+function F(t, e = {}) {
+  const { pageSize: s = 10, tokenKey: c = "NextToken", itemsKey: n = "Items" } = e;
+  if (t.length === 0)
+    return [{ [n]: [] }];
+  const o = [];
+  for (let r = 0; r < t.length; r += s) {
+    const u = t.slice(r, r + s), i = r + s < t.length, l = { [n]: u };
+    if (i) {
+      const a = l;
+      a[c] = `token-${r + s}`;
+    }
+    o.push(l);
+  }
+  return o;
+}
+function L() {
+  return typeof process < "u" && process.versions?.node ? "node" : typeof process < "u" && process.versions?.bun ? "bun" : "browser";
+}
+function A(t) {
+  const e = typeof t == "string" ? Buffer.from(t, "utf8") : Buffer.from(t);
+  return new N({
+    read() {
+      this.push(e), this.push(void 0);
+    }
+  });
+}
+function K(t) {
+  let e;
+  return typeof t == "string" ? e = new TextEncoder().encode(t) : t instanceof Buffer ? e = new Uint8Array(t) : e = t, new ReadableStream({
+    start(s) {
+      s.enqueue(e), s.close();
+    }
+  });
+}
+function h(t) {
+  const e = L();
+  return e === "node" || e === "bun" ? A(t) : K(t);
+}
+function w(t, e) {
+  return Object.keys(e).every((s) => {
+    const c = e[s], n = t[s];
+    return c && typeof c == "object" && !Array.isArray(c) ? typeof n != "object" || n === null ? !1 : w(
+      n,
+      c
+    ) : n === c;
   });
 }
-function y(r, t) {
-  if (r === t) return !0;
-  if (typeof r != "object" || r === null || typeof t != "object" || t === null)
-    return r === t;
-  const c = Object.keys(r), o = Object.keys(t);
-  return c.length !== o.length ? !1 : o.every((n) => {
-    if (!Object.prototype.hasOwnProperty.call(r, n)) return !1;
-    const s = r[n], e = t[n];
-    return typeof s == "object" && s !== null && typeof e == "object" && e !== null ? y(s, e) : s === e;
+function j(t, e) {
+  if (t === e) return !0;
+  if (typeof t != "object" || t === null || typeof e != "object" || e === null)
+    return t === e;
+  const s = Object.keys(t), c = Object.keys(e);
+  return s.length !== c.length ? !1 : c.every((n) => {
+    if (!Object.prototype.hasOwnProperty.call(t, n)) return !1;
+    const o = t, r = e, u = o[n], i = r[n];
+    return typeof u == "object" && u !== null && typeof i == "object" && i !== null ? j(u, i) : u === i;
   });
 }
-function k(r) {
-  return async function(t) {
-    const c = this, o = () => c, n = r.map.get(t.constructor);
-    if (n) {
-      const s = n.findIndex((e) => e.strict ? e.matcher && y(t.input, e.matcher) : !e.matcher || m(t.input, e.matcher));
-      if (s !== -1) {
-        const e = n[s];
-        return e.once && n.splice(s, 1), e.handler(t.input, o);
+function x(t) {
+  return async function(e) {
+    const s = () => this;
+    t.debugLogger.log(
+      `Received command: ${e.constructor.name}`,
+      e.input
+    );
+    const c = t.map.get(
+      e.constructor
+    );
+    if (c) {
+      t.debugLogger.log(
+        `Found ${c.length} mock(s) for ${e.constructor.name}`
+      );
+      const n = c.findIndex((o) => o.strict ? o.matcher && j(e.input, o.matcher) : !o.matcher || w(e.input, o.matcher));
+      if (n === -1)
+        t.debugLogger.log(
+          `No matching mock found for ${e.constructor.name}`,
+          e.input
+        );
+      else {
+        const o = c[n];
+        if (!o)
+          throw new Error(`Mock at index ${n} not found`);
+        return t.debugLogger.log(
+          `Using mock at index ${n} for ${e.constructor.name}`
+        ), o.once && (c.splice(n, 1), t.debugLogger.log(
+          `Removed one-time mock for ${e.constructor.name}`
+        )), o.handler(
+          e.input,
+          s()
+        );
       }
-    }
-    throw new Error(`No mock configured for command: ${t.constructor.name}`);
+    } else
+      t.debugLogger.log(
+        `No mocks configured for ${e.constructor.name}`
+      );
+    throw new Error(
+      `No mock configured for command: ${e.constructor.name}`
+    );
   };
 }
-function b(r, t, c, o = {}) {
-  const n = (e, a) => {
-    const p = {
-      matcher: c,
-      handler: e,
-      once: a,
-      strict: !!o.strict
-    }, i = r.map.get(t) ?? [];
-    if (a) {
-      const l = i.findIndex((u) => !u.once);
-      l === -1 ? i.push(p) : i.splice(l, 0, p), r.map.set(t, i);
+function S(t, e, s, c = {}) {
+  const n = (r, u) => {
+    const i = {
+      matcher: s,
+      handler: r,
+      once: u,
+      strict: !!c.strict
+    }, l = t.map.get(e) ?? [];
+    if (u) {
+      const a = l.findIndex((f) => !f.once);
+      a === -1 ? l.push(i) : l.splice(a, 0, i), t.map.set(
+        e,
+        l
+      );
     } else {
-      const l = i.filter(
-        (u) => u.once || JSON.stringify(u.matcher) !== JSON.stringify(c)
+      const a = l.filter(
+        (f) => f.once || JSON.stringify(f.matcher) !== JSON.stringify(s)
+      );
+      a.push(i), t.map.set(
+        e,
+        a
       );
-      l.push(p), r.map.set(t, l);
     }
-  }, s = {
-    resolves(e) {
-      return n(() => Promise.resolve(e), !1), s;
+  }, o = {
+    resolves(r) {
+      return n(() => Promise.resolve(r), !1), o;
     },
-    rejects(e) {
+    rejects(r) {
       return n(() => {
-        const a = typeof e == "string" ? new Error(e) : e;
-        return Promise.reject(a);
-      }, !1), s;
+        const u = typeof r == "string" ? new Error(r) : r;
+        return Promise.reject(u);
+      }, !1), o;
     },
-    callsFake(e) {
-      return n(e, !1), s;
+    callsFake(r) {
+      return n(r, !1), o;
     },
-    resolvesOnce(e) {
-      return n(() => Promise.resolve(e), !0), s;
+    resolvesOnce(r) {
+      return n(() => Promise.resolve(r), !0), o;
     },
-    rejectsOnce(e) {
+    rejectsOnce(r) {
       return n(() => {
-        const a = typeof e == "string" ? new Error(e) : e;
-        return Promise.reject(a);
-      }, !0), s;
+        const u = typeof r == "string" ? new Error(r) : r;
+        return Promise.reject(u);
+      }, !0), o;
+    },
+    callsFakeOnce(r) {
+      return n(r, !0), o;
+    },
+    resolvesStream(r) {
+      return n(
+        () => Promise.resolve({ Body: h(r) }),
+        !1
+      ), o;
+    },
+    resolvesStreamOnce(r) {
+      return n(
+        () => Promise.resolve({ Body: h(r) }),
+        !0
+      ), o;
+    },
+    resolvesWithDelay(r, u) {
+      const i = (l) => {
+        setTimeout(() => l(r), u);
+      };
+      return n(() => new Promise(i), !1), o;
+    },
+    rejectsWithDelay(r, u) {
+      const i = typeof r == "string" ? new Error(r) : r, l = (a, f) => {
+        setTimeout(() => f(i), u);
+      };
+      return n(() => new Promise(l), !1), o;
+    },
+    rejectsWithNoSuchKey(r) {
+      return n(() => Promise.reject(W(r)), !1), o;
+    },
+    rejectsWithNoSuchBucket(r) {
+      return n(() => Promise.reject($(r)), !1), o;
+    },
+    rejectsWithAccessDenied(r) {
+      return n(() => Promise.reject(D(r)), !1), o;
     },
-    callsFakeOnce(e) {
-      return n(e, !0), s;
+    rejectsWithResourceNotFound(r) {
+      return n(
+        () => Promise.reject(M(r)),
+        !1
+      ), o;
+    },
+    rejectsWithConditionalCheckFailed() {
+      return n(
+        () => Promise.reject(C()),
+        !1
+      ), o;
+    },
+    rejectsWithThrottling() {
+      return n(() => Promise.reject(I()), !1), o;
+    },
+    rejectsWithInternalServerError() {
+      return n(() => Promise.reject(O()), !1), o;
+    },
+    resolvesPaginated(r, u = {}) {
+      const i = F(r, u);
+      let l = 0;
+      return n((a) => {
+        const f = u.tokenKey || "NextToken", p = a[f];
+        if (p) {
+          const g = /token-(\d+)/.exec(p);
+          if (g && g[1]) {
+            const E = g[1];
+            l = Math.floor(
+              Number.parseInt(E, 10) / (u.pageSize || 10)
+            );
+          }
+        } else
+          l = 0;
+        const m = (
+          // eslint-disable-next-line security/detect-object-injection
+          i[l] || // eslint-disable-next-line unicorn/prefer-at -- TypeScript target doesn't support Array.at() method
+          i[i.length - 1] || i[0]
+        );
+        if (!m)
+          throw new Error("No paginated responses available");
+        return l = Math.min(l + 1, i.length - 1), Promise.resolve(m);
+      }, !1), o;
+    },
+    resolvesFromFile(r) {
+      return n(() => {
+        const u = T(r);
+        return Promise.resolve(u);
+      }, !1), o;
     }
   };
-  return s;
+  return o;
 }
-const j = (r) => {
-  const t = {
-    map: /* @__PURE__ */ new WeakMap()
-  }, c = ("prototype" in r, r.prototype), o = f.spyOn(c, "send").mockImplementation(k(t));
+const _ = (t) => {
+  const e = {
+    map: /* @__PURE__ */ new WeakMap(),
+    debugLogger: k()
+  }, s = t.prototype, c = b.spyOn(s, "send").mockImplementation(x(e));
   return {
     client: void 0,
-    on: (s, e, a) => b(t, s, e, a),
+    on: (o, r, u) => S(
+      e,
+      o,
+      r,
+      u
+    ),
     reset: () => {
-      o.mockClear(), t.map = /* @__PURE__ */ new WeakMap();
+      c.mockClear(), e.map = /* @__PURE__ */ new WeakMap();
     },
     restore: () => {
-      o.mockRestore(), t.map = /* @__PURE__ */ new WeakMap();
+      c.mockRestore(), e.map = /* @__PURE__ */ new WeakMap();
+    },
+    calls: () => c.mock.calls,
+    enableDebug: () => {
+      y(e.debugLogger);
     },
-    calls: () => o.mock.calls
+    disableDebug: () => {
+      v(e.debugLogger);
+    }
   };
-}, d = (r) => {
-  const t = {
-    map: /* @__PURE__ */ new WeakMap()
-  }, c = f.spyOn(r, "send").mockImplementation(k(t));
+}, G = (t) => {
+  const e = {
+    map: /* @__PURE__ */ new WeakMap(),
+    debugLogger: k()
+  }, s = b.spyOn(t, "send").mockImplementation(x(e));
   return {
-    client: r,
-    on: (n, s, e) => b(t, n, s, e),
+    client: t,
+    on: (n, o, r) => S(
+      e,
+      n,
+      o,
+      r
+    ),
     reset: () => {
-      c.mockClear(), t.map = /* @__PURE__ */ new WeakMap();
+      s.mockClear(), e.map = /* @__PURE__ */ new WeakMap();
     },
     restore: () => {
-      c.mockRestore(), t.map = /* @__PURE__ */ new WeakMap();
+      s.mockRestore(), e.map = /* @__PURE__ */ new WeakMap();
     },
-    calls: () => c.mock.calls
+    calls: () => s.mock.calls,
+    enableDebug: () => {
+      y(e.debugLogger);
+    },
+    disableDebug: () => {
+      v(e.debugLogger);
+    }
   };
 };
 export {
-  w as matchers,
-  j as mockClient,
-  d as mockClientInstance
+  X as matchers,
+  _ as mockClient,
+  G as mockClientInstance
 };

package/lib/matchers.d.ts

@@ -1,29 +1,31 @@
-import { AwsClientStub } from './mock-client.js';
-type CommandConstructor = new (...args: unknown[]) => unknown;
+import { MetadataBearer } from '@smithy/types';
+import { AwsClientStub, CommandConstructor } from './mock-client.js';
 interface MatcherResult {
     pass: boolean;
     message: () => string;
 }
 export declare const matchers: {
-    toHaveReceivedCommand(received: AwsClientStub, command: CommandConstructor): MatcherResult;
-    toHaveReceivedCommandTimes(received: AwsClientStub, command: CommandConstructor, times: number): MatcherResult;
-    toHaveReceivedCommandWith(this: {
+    toHaveReceivedCommand<TInput extends object, TOutput extends MetadataBearer>(received: AwsClientStub, command: CommandConstructor<TInput, TOutput>): MatcherResult;
+    toHaveReceivedCommandTimes<TInput extends object, TOutput extends MetadataBearer>(received: AwsClientStub, command: CommandConstructor<TInput, TOutput>, times: number): MatcherResult;
+    toHaveReceivedCommandWith<TInput extends object, TOutput extends MetadataBearer>(this: {
         equals: (a: unknown, b: unknown) => boolean;
-    }, received: AwsClientStub, command: CommandConstructor, input: Record<string, unknown>): MatcherResult;
-    toHaveReceivedNthCommandWith(this: {
+    }, received: AwsClientStub, command: CommandConstructor<TInput, TOutput>, input: TInput): MatcherResult;
+    toHaveReceivedNthCommandWith<TInput extends object, TOutput extends MetadataBearer>(this: {
         equals: (a: unknown, b: unknown) => boolean;
-    }, received: AwsClientStub, n: number, command: CommandConstructor, input: Record<string, unknown>): MatcherResult;
+    }, received: AwsClientStub, n: number, command: CommandConstructor<TInput, TOutput>, input: TInput): MatcherResult;
+    toHaveReceivedNoOtherCommands<TInput extends object, TOutput extends MetadataBearer>(received: AwsClientStub, expectedCommands?: CommandConstructor<TInput, TOutput>[]): MatcherResult;
 };
 export interface AwsSdkMatchers<R = unknown> {
-    toHaveReceivedCommand(command: CommandConstructor): R;
-    toHaveReceivedCommandTimes(command: CommandConstructor, times: number): R;
-    toHaveReceivedCommandWith(command: CommandConstructor, input: Record<string, unknown>): R;
-    toHaveReceivedNthCommandWith(n: number, command: CommandConstructor, input: Record<string, unknown>): R;
+    toHaveReceivedCommand<TInput extends object, TOutput extends MetadataBearer>(command: CommandConstructor<TInput, TOutput>): R;
+    toHaveReceivedCommandTimes<TInput extends object, TOutput extends MetadataBearer>(command: CommandConstructor<TInput, TOutput>, times: number): R;
+    toHaveReceivedCommandWith<TInput extends object, TOutput extends MetadataBearer>(command: CommandConstructor<TInput, TOutput>, input: TInput): R;
+    toHaveReceivedNthCommandWith<TInput extends object, TOutput extends MetadataBearer>(n: number, command: CommandConstructor<TInput, TOutput>, input: TInput): R;
+    toHaveReceivedNoOtherCommands<TInput extends object, TOutput extends MetadataBearer>(expectedCommands?: CommandConstructor<TInput, TOutput>[]): R;
 }
-declare module 'vitest' {
+export type { MatcherResult };
+declare module "vitest" {
     interface Assertion extends AwsSdkMatchers {
     }
     interface AsymmetricMatchersContaining extends AwsSdkMatchers {
     }
 }
-export {};

package/lib/mock-client.d.ts

@@ -1,33 +1,36 @@
-import { SmithyResolvedConfiguration } from '@smithy/smithy-client';
-import { MiddlewareStack, Handler } from '@smithy/types';
+import { Command as SmithyCommand, SmithyResolvedConfiguration } from '@smithy/smithy-client';
+import { HttpHandlerOptions, MetadataBearer } from '@smithy/types';
 import { Mock } from 'vitest';
-export interface MetadataBearer {
-    $metadata?: unknown;
-}
-export interface StructuralCommand<TInput extends object, TOutput extends MetadataBearer> {
+import { PaginatorOptions } from './utils/paginator-helpers.js';
+import { StreamInput } from './utils/stream-helpers.js';
+export type StructuralCommand<TInput extends object, TOutput extends MetadataBearer> = SmithyCommand<TInput, TOutput, any, any, any> | {
     readonly input: TInput;
-    middlewareStack: MiddlewareStack<TInput, TOutput>;
-    resolveMiddleware(stack: MiddlewareStack<TInput, TOutput>, configuration: unknown, options: unknown): Handler<TInput, TOutput>;
-}
+    readonly __awsSdkVitestMockOutput?: TOutput;
+};
 export type CommandConstructor<TInput extends object, TOutput extends MetadataBearer> = new (input: TInput) => StructuralCommand<TInput, TOutput>;
+type AwsCommandConstructor = CommandConstructor<any, MetadataBearer>;
+export type CommandInputType<TCtor extends AwsCommandConstructor> = ConstructorParameters<TCtor>[0];
+export type CommandOutputType<TCtor extends AwsCommandConstructor> = InstanceType<TCtor> extends StructuralCommand<any, infer TOutput> ? TOutput : MetadataBearer;
 export type AnyClient = {
     send(command: AnyCommand): Promise<MetadataBearer>;
-    config: SmithyResolvedConfiguration<unknown>;
+    config: SmithyResolvedConfiguration<HttpHandlerOptions> | Record<string, unknown>;
 };
 export type AnyCommand = StructuralCommand<object, MetadataBearer>;
-export type ClientConstructor<TClient extends AnyClient> = (abstract new (config: unknown) => TClient) | {
+export type ClientConstructor<TClient extends AnyClient> = (abstract new (...args: unknown[]) => TClient) | {
     prototype: TClient;
 };
-type CommandHandler<TInput extends object = object, TOutput extends MetadataBearer = MetadataBearer, TClient extends AnyClient = AnyClient> = (input: TInput, getClient: () => TClient | undefined) => Promise<TOutput>;
+type CommandHandler<TInput extends object = object, TOutput extends MetadataBearer = MetadataBearer, TClient extends AnyClient = AnyClient> = (input: TInput, clientInstance: TClient | undefined) => Promise<Partial<TOutput>>;
 interface MockOptions {
     strict?: boolean;
 }
 export interface AwsClientStub<TClient extends AnyClient = AnyClient> {
     readonly client: TClient | undefined;
-    on: <TInput extends object, TOutput extends MetadataBearer>(command: CommandConstructor<TInput, TOutput>, request?: Partial<TInput>, options?: MockOptions) => AwsCommandStub<TInput, TOutput, TClient>;
+    on: <TCtor extends AwsCommandConstructor>(command: TCtor, request?: Partial<CommandInputType<TCtor>>, options?: MockOptions) => AwsCommandStub<CommandInputType<TCtor>, CommandOutputType<TCtor>, TClient>;
     reset: () => void;
     restore: () => void;
-    calls: () => ReturnType<Mock['mock']['calls']['slice']>;
+    calls: () => ReturnType<Mock["mock"]["calls"]["slice"]>;
+    enableDebug: () => void;
+    disableDebug: () => void;
 }
 export interface AwsCommandStub<TInput extends object, TOutput extends MetadataBearer, TClient extends AnyClient = AnyClient> {
     /** Set a permanent mock response (used after all once handlers are consumed) */
@@ -42,6 +45,32 @@ export interface AwsCommandStub<TInput extends object, TOutput extends MetadataB
     rejectsOnce: (error: Error | string) => AwsCommandStub<TInput, TOutput, TClient>;
     /** Add a one-time custom handler (consumed in order) */
     callsFakeOnce: (fn: CommandHandler<TInput, TOutput, TClient>) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set a permanent stream response for S3-like operations */
+    resolvesStream: (data: StreamInput) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set a one-time stream response for S3-like operations */
+    resolvesStreamOnce: (data: StreamInput) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set a permanent mock response with delay */
+    resolvesWithDelay: (output: Partial<TOutput>, delayMs: number) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set a permanent mock rejection with delay */
+    rejectsWithDelay: (error: Error | string, delayMs: number) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with S3 NoSuchKey error */
+    rejectsWithNoSuchKey: (key?: string) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with S3 NoSuchBucket error */
+    rejectsWithNoSuchBucket: (bucket?: string) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with AccessDenied error */
+    rejectsWithAccessDenied: (resource?: string) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with DynamoDB ResourceNotFound error */
+    rejectsWithResourceNotFound: (resource?: string) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with DynamoDB ConditionalCheckFailed error */
+    rejectsWithConditionalCheckFailed: () => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with Throttling error */
+    rejectsWithThrottling: () => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Reject with InternalServerError */
+    rejectsWithInternalServerError: () => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Set paginated responses for AWS pagination */
+    resolvesPaginated: <T = unknown>(items: T[], options?: PaginatorOptions) => AwsCommandStub<TInput, TOutput, TClient>;
+    /** Load response from file (JSON files are parsed, others returned as strings) */
+    resolvesFromFile: (filePath: string) => AwsCommandStub<TInput, TOutput, TClient>;
 }
 export declare const mockClient: <TClient extends AnyClient>(clientConstructor: ClientConstructor<TClient>) => AwsClientStub<TClient>;
 export declare const mockClientInstance: <TClient extends AnyClient>(clientInstance: TClient) => AwsClientStub<AnyClient>;

package/lib/utils/aws-errors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Common AWS SDK error types and factory functions
+ */
+export declare class AwsError extends Error {
+    readonly name: string;
+    readonly code: string;
+    readonly statusCode?: number;
+    readonly retryable?: boolean;
+    constructor(message: string, code: string, statusCode?: number, retryable?: boolean);
+}
+export declare const createNoSuchKeyError: (key?: string) => AwsError;
+export declare const createNoSuchBucketError: (bucket?: string) => AwsError;
+export declare const createAccessDeniedError: (resource?: string) => AwsError;
+export declare const createResourceNotFoundError: (resource?: string) => AwsError;
+export declare const createConditionalCheckFailedError: () => AwsError;
+export declare const createThrottlingError: () => AwsError;
+export declare const createInternalServerError: () => AwsError;

package/lib/utils/colors.d.ts

@@ -0,0 +1,10 @@
+export declare const colors: {
+    readonly red: (text: string) => string;
+    readonly green: (text: string) => string;
+    readonly yellow: (text: string) => string;
+    readonly blue: (text: string) => string;
+    readonly magenta: (text: string) => string;
+    readonly cyan: (text: string) => string;
+    readonly gray: (text: string) => string;
+    readonly bold: (text: string) => string;
+};

package/lib/utils/debug-logger.d.ts

@@ -0,0 +1,7 @@
+export interface DebugLogger {
+    enabled: boolean;
+    log: (message: string, data?: unknown) => void;
+}
+export declare function createDebugLogger(): DebugLogger;
+export declare function enableDebug(logger: DebugLogger): void;
+export declare function disableDebug(logger: DebugLogger): void;

package/lib/utils/file-helpers.d.ts

@@ -0,0 +1 @@
+export declare function loadFixture(filePath: string): unknown;

package/lib/utils/paginator-helpers.d.ts

@@ -0,0 +1,13 @@
+export interface PaginatorOptions {
+    pageSize?: number;
+    tokenKey?: string;
+    itemsKey?: string;
+}
+export interface PaginatedResponse<T = unknown> {
+    [key: string]: unknown;
+    NextToken?: string;
+    ContinuationToken?: string;
+    Items?: T[];
+    Contents?: T[];
+}
+export declare function createPaginatedResponses<T>(items: T[], options?: PaginatorOptions): PaginatedResponse<T>[];

package/lib/utils/stream-helpers.d.ts

@@ -0,0 +1,6 @@
+import { Readable } from 'node:stream';
+export type StreamInput = string | Buffer | Uint8Array;
+/**
+ * Creates an appropriate stream for the current environment
+ */
+export declare function createStream(data: StreamInput): Readable | ReadableStream<Uint8Array>;

package/matchers-DdPGAOsD.js

@@ -0,0 +1,124 @@
+const e = {
+  red: (t) => `\x1B[31m${t}\x1B[39m`,
+  green: (t) => `\x1B[32m${t}\x1B[39m`,
+  yellow: (t) => `\x1B[33m${t}\x1B[39m`,
+  blue: (t) => `\x1B[34m${t}\x1B[39m`,
+  magenta: (t) => `\x1B[35m${t}\x1B[39m`,
+  cyan: (t) => `\x1B[36m${t}\x1B[39m`,
+  gray: (t) => `\x1B[90m${t}\x1B[39m`,
+  bold: (t) => `\x1B[1m${t}\x1B[22m`
+}, $ = (t) => {
+  const c = t.calls();
+  return Array.isArray(c) ? c.filter(
+    (a) => Array.isArray(a) && a.length > 0
+  ) : [];
+}, f = {
+  toHaveReceivedCommand(t, c) {
+    const a = $(t), r = a.some((o) => o[0] instanceof c), m = c.name;
+    return {
+      pass: r,
+      message: () => {
+        if (r)
+          return `Expected AWS SDK mock not to have received command ${e.red(m)}`;
+        const o = a.map((n) => n[0].constructor?.name ?? "Unknown");
+        return o.length === 0 ? `Expected AWS SDK mock to have received command ${e.red(m)}, but ${e.gray("no commands were received")}` : `Expected AWS SDK mock to have received command ${e.red(m)}, but received: ${e.yellow(o.join(", "))}`;
+      }
+    };
+  },
+  toHaveReceivedCommandTimes(t, c, a) {
+    const r = $(t).filter(
+      (n) => n[0] instanceof c
+    ), m = r.length === a, o = c.name;
+    return {
+      pass: m,
+      message: () => m ? `Expected AWS SDK mock not to have received command ${o} ${a} times` : `Expected AWS SDK mock to have received command ${o} ${a} times, but received ${r.length} times`
+    };
+  },
+  toHaveReceivedCommandWith(t, c, a) {
+    const r = $(t).filter(
+      (n) => n[0] instanceof c
+    ), m = r.some((n) => this.equals(n[0].input, a)), o = c.name;
+    return {
+      pass: m,
+      message: () => {
+        if (m) {
+          const s = e.red(o), u = e.cyan(
+            JSON.stringify(a, void 0, 2)
+          );
+          return `Expected AWS SDK mock not to have received command ${s} with input:
+${u}`;
+        }
+        if (r.length === 0) {
+          const s = e.red(o), u = e.cyan(
+            JSON.stringify(a, void 0, 2)
+          ), i = e.gray(`${o} was never called`);
+          return `Expected AWS SDK mock to have received command ${s} with input:
+${u}
+
+But ${i}`;
+        }
+        const n = r.map((s) => s[0].input), d = e.red(o), g = e.cyan(JSON.stringify(a, void 0, 2)), l = e.gray("But received"), h = e.yellow(o), p = e.gray("with"), S = e.yellow(
+          n.map((s) => JSON.stringify(s, void 0, 2)).join(`
+
+`)
+        );
+        return `Expected AWS SDK mock to have received command ${d} with input:
+${g}
+
+${l} ${h} ${p}:
+${S}`;
+      }
+    };
+  },
+  toHaveReceivedNthCommandWith(t, c, a, r) {
+    const m = $(t), o = m[c - 1], n = o?.[0], d = n?.input, g = !!o && n instanceof a && this.equals(d, r), l = a.name;
+    return {
+      pass: g,
+      message: () => {
+        if (g) {
+          const i = e.magenta(c.toString()), v = e.red(l), y = e.cyan(JSON.stringify(r, void 0, 2));
+          return `Expected AWS SDK mock not to have received nth (${i}) command ${v} with input:
+${y}`;
+        }
+        if (!o) {
+          const i = e.magenta(c.toString()), v = e.gray(
+            `only received ${m.length} call(s)`
+          );
+          return `Expected AWS SDK mock to have received at least ${i} call(s), but ${v}`;
+        }
+        if (!(n instanceof a)) {
+          const i = n?.constructor?.name ?? typeof n, v = e.magenta(c.toString()), y = e.red(l), x = e.yellow(i);
+          return `Expected AWS SDK mock nth (${v}) call to be ${y}, but received ${x}`;
+        }
+        const h = e.magenta(c.toString()), p = e.red(l), S = e.cyan(JSON.stringify(r, void 0, 2)), s = e.gray("But received"), u = e.yellow(
+          JSON.stringify(d, void 0, 2)
+        );
+        return `Expected AWS SDK mock nth (${h}) command ${p} with input:
+${S}
+
+${s}:
+${u}`;
+      }
+    };
+  },
+  toHaveReceivedNoOtherCommands(t, c = []) {
+    const r = $(t).filter((o) => {
+      const n = o[0];
+      return !c.some(
+        (d) => n instanceof d
+      );
+    }), m = r.length === 0;
+    return {
+      pass: m,
+      message: () => {
+        if (m)
+          return `Expected AWS SDK mock to have received other commands besides ${e.green(c.map((n) => n.name).join(", "))}`;
+        const o = r.map((n) => n[0].constructor?.name ?? "Unknown");
+        return `Expected AWS SDK mock to have received ${e.gray("no other commands")}, but received: ${e.red(o.join(", "))}`;
+      }
+    };
+  }
+};
+export {
+  f as m
+};

package/matchers-G36N2DNa.cjs

@@ -0,0 +1,16 @@
+"use strict";const e={red:t=>`\x1B[31m${t}\x1B[39m`,green:t=>`\x1B[32m${t}\x1B[39m`,yellow:t=>`\x1B[33m${t}\x1B[39m`,blue:t=>`\x1B[34m${t}\x1B[39m`,magenta:t=>`\x1B[35m${t}\x1B[39m`,cyan:t=>`\x1B[36m${t}\x1B[39m`,gray:t=>`\x1B[90m${t}\x1B[39m`,bold:t=>`\x1B[1m${t}\x1B[22m`},$=t=>{const c=t.calls();return Array.isArray(c)?c.filter(a=>Array.isArray(a)&&a.length>0):[]},f={toHaveReceivedCommand(t,c){const a=$(t),r=a.some(o=>o[0]instanceof c),m=c.name;return{pass:r,message:()=>{if(r)return`Expected AWS SDK mock not to have received command ${e.red(m)}`;const o=a.map(n=>n[0].constructor?.name??"Unknown");return o.length===0?`Expected AWS SDK mock to have received command ${e.red(m)}, but ${e.gray("no commands were received")}`:`Expected AWS SDK mock to have received command ${e.red(m)}, but received: ${e.yellow(o.join(", "))}`}}},toHaveReceivedCommandTimes(t,c,a){const r=$(t).filter(n=>n[0]instanceof c),m=r.length===a,o=c.name;return{pass:m,message:()=>m?`Expected AWS SDK mock not to have received command ${o} ${a} times`:`Expected AWS SDK mock to have received command ${o} ${a} times, but received ${r.length} times`}},toHaveReceivedCommandWith(t,c,a){const r=$(t).filter(n=>n[0]instanceof c),m=r.some(n=>this.equals(n[0].input,a)),o=c.name;return{pass:m,message:()=>{if(m){const s=e.red(o),u=e.cyan(JSON.stringify(a,void 0,2));return`Expected AWS SDK mock not to have received command ${s} with input:
+${u}`}if(r.length===0){const s=e.red(o),u=e.cyan(JSON.stringify(a,void 0,2)),i=e.gray(`${o} was never called`);return`Expected AWS SDK mock to have received command ${s} with input:
+${u}
+
+But ${i}`}const n=r.map(s=>s[0].input),d=e.red(o),h=e.cyan(JSON.stringify(a,void 0,2)),l=e.gray("But received"),g=e.yellow(o),S=e.gray("with"),p=e.yellow(n.map(s=>JSON.stringify(s,void 0,2)).join(`
+
+`));return`Expected AWS SDK mock to have received command ${d} with input:
+${h}
+
+${l} ${g} ${S}:
+${p}`}}},toHaveReceivedNthCommandWith(t,c,a,r){const m=$(t),o=m[c-1],n=o?.[0],d=n?.input,h=!!o&&n instanceof a&&this.equals(d,r),l=a.name;return{pass:h,message:()=>{if(h){const i=e.magenta(c.toString()),v=e.red(l),y=e.cyan(JSON.stringify(r,void 0,2));return`Expected AWS SDK mock not to have received nth (${i}) command ${v} with input:
+${y}`}if(!o){const i=e.magenta(c.toString()),v=e.gray(`only received ${m.length} call(s)`);return`Expected AWS SDK mock to have received at least ${i} call(s), but ${v}`}if(!(n instanceof a)){const i=n?.constructor?.name??typeof n,v=e.magenta(c.toString()),y=e.red(l),x=e.yellow(i);return`Expected AWS SDK mock nth (${v}) call to be ${y}, but received ${x}`}const g=e.magenta(c.toString()),S=e.red(l),p=e.cyan(JSON.stringify(r,void 0,2)),s=e.gray("But received"),u=e.yellow(JSON.stringify(d,void 0,2));return`Expected AWS SDK mock nth (${g}) command ${S} with input:
+${p}
+
+${s}:
+${u}`}}},toHaveReceivedNoOtherCommands(t,c=[]){const r=$(t).filter(o=>{const n=o[0];return!c.some(d=>n instanceof d)}),m=r.length===0;return{pass:m,message:()=>{if(m)return`Expected AWS SDK mock to have received other commands besides ${e.green(c.map(n=>n.name).join(", "))}`;const o=r.map(n=>n[0].constructor?.name??"Unknown");return`Expected AWS SDK mock to have received ${e.gray("no other commands")}, but received: ${e.red(o.join(", "))}`}}}};exports.matchers=f;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-sdk-vitest-mock",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",

package/vitest-setup.cjs

@@ -1 +1 @@
-"use strict";const e=require("vitest"),t=require("./matchers-D1XEjFLq.cjs");e.expect.extend(t.matchers);
+"use strict";const e=require("vitest"),t=require("./matchers-G36N2DNa.cjs");e.expect.extend(t.matchers);

package/vitest-setup.js

@@ -1,3 +1,3 @@
 import { expect as m } from "vitest";
-import { m as e } from "./matchers-DclpcT4f.js";
+import { m as e } from "./matchers-DdPGAOsD.js";
 m.extend(e);

package/matchers-D1XEjFLq.cjs

@@ -1 +0,0 @@
-"use strict";const d={toHaveReceivedCommand(n,e){const t=n.calls().some(a=>a[0]instanceof e),s=e.name;return{pass:t,message:()=>t?`Expected AWS SDK mock not to have received command ${s}`:`Expected AWS SDK mock to have received command ${s}`}},toHaveReceivedCommandTimes(n,e,c){const t=n.calls().filter(o=>o[0]instanceof e),s=t.length===c,a=e.name;return{pass:s,message:()=>s?`Expected AWS SDK mock not to have received command ${a} ${c} times`:`Expected AWS SDK mock to have received command ${a} ${c} times, but received ${t.length} times`}},toHaveReceivedCommandWith(n,e,c){const s=n.calls().filter(o=>o[0]instanceof e).some(o=>this.equals(o[0].input,c)),a=e.name;return{pass:s,message:()=>s?`Expected AWS SDK mock not to have received command ${a} with ${JSON.stringify(c)}`:`Expected AWS SDK mock to have received command ${a} with ${JSON.stringify(c)}`}},toHaveReceivedNthCommandWith(n,e,c,t){const a=n.calls().filter(i=>i[0]instanceof c)[e-1],o=!!(a&&this.equals(a[0].input,t)),m=c.name;return{pass:o,message:()=>o?`Expected AWS SDK mock not to have received nth (${e}) command ${m} with ${JSON.stringify(t)}`:`Expected AWS SDK mock to have received nth (${e}) command ${m} with ${JSON.stringify(t)}`}}};exports.matchers=d;

package/matchers-DclpcT4f.js

@@ -1,33 +0,0 @@
-const d = {
-  toHaveReceivedCommand(n, e) {
-    const t = n.calls().some((a) => a[0] instanceof e), o = e.name;
-    return {
-      pass: t,
-      message: () => t ? `Expected AWS SDK mock not to have received command ${o}` : `Expected AWS SDK mock to have received command ${o}`
-    };
-  },
-  toHaveReceivedCommandTimes(n, e, c) {
-    const t = n.calls().filter((s) => s[0] instanceof e), o = t.length === c, a = e.name;
-    return {
-      pass: o,
-      message: () => o ? `Expected AWS SDK mock not to have received command ${a} ${c} times` : `Expected AWS SDK mock to have received command ${a} ${c} times, but received ${t.length} times`
-    };
-  },
-  toHaveReceivedCommandWith(n, e, c) {
-    const o = n.calls().filter((s) => s[0] instanceof e).some((s) => this.equals(s[0].input, c)), a = e.name;
-    return {
-      pass: o,
-      message: () => o ? `Expected AWS SDK mock not to have received command ${a} with ${JSON.stringify(c)}` : `Expected AWS SDK mock to have received command ${a} with ${JSON.stringify(c)}`
-    };
-  },
-  toHaveReceivedNthCommandWith(n, e, c, t) {
-    const a = n.calls().filter((i) => i[0] instanceof c)[e - 1], s = !!(a && this.equals(a[0].input, t)), m = c.name;
-    return {
-      pass: s,
-      message: () => s ? `Expected AWS SDK mock not to have received nth (${e}) command ${m} with ${JSON.stringify(t)}` : `Expected AWS SDK mock to have received nth (${e}) command ${m} with ${JSON.stringify(t)}`
-    };
-  }
-};
-export {
-  d as m
-};