@backblaze-labs/b2-sdk 0.1.0

package/dist/simulator/index.d.ts

@@ -0,0 +1,495 @@
+import { HttpTransport } from '../http/transport.js';
+import { FileVersion } from '../types/file.js';
+import { EventNotificationRule } from '../types/notifications.js';
+export { BUCKET_INFO_MAX_KEYS, BUCKET_INFO_VALUE_MAX, BUCKET_NAME_MAX, BUCKET_NAME_MIN, FILE_INFO_TOTAL_MAX, FILE_INFO_VALUE_MAX, FILE_NAME_MAX_BYTES, LIST_ENDPOINT_CAPS, } from './validation.js';
+/** JSON response returned by {@link B2Simulator.handleRequest} and {@link B2Simulator.handleUpload}. */
+export interface SimulatorJsonResponse {
+    /** HTTP status code. */
+    readonly status: number;
+    /** JSON response body. */
+    readonly body: unknown;
+}
+/** Download response returned by {@link B2Simulator.handleDownload}. */
+export interface SimulatorDownloadResponse {
+    /** HTTP status code. */
+    readonly status: number;
+    /** B2 response headers (content type, SHA-1, file info, etc.). */
+    readonly headers: Record<string, string>;
+    /** Raw file bytes, or null if the file was not found. */
+    readonly data: Uint8Array | null;
+}
+/**
+ * Specification for a synthetic failure to return from the simulator's
+ * transport. See {@link B2Simulator.injectFailure}.
+ */
+export interface FaultSpec {
+    /**
+     * URL substring matched against `request.url`. The fault triggers on
+     * every request whose URL contains this substring. Typically a B2
+     * endpoint name like `'b2_upload_part'`, `'b2_authorize_account'`,
+     * `'b2_download_file_by_id'`, or `'/file/'` for download-by-name.
+     */
+    readonly on: string;
+    /** HTTP status to return. Defaults to `503`. */
+    readonly status?: number;
+    /** B2 error code to return in the JSON body. Defaults to `'service_unavailable'`. */
+    readonly code?: string;
+    /** Human-readable message. Defaults to `'simulated failure'`. */
+    readonly message?: string;
+    /**
+     * Number of matched requests to fail before the fault retires. Defaults
+     * to `Number.POSITIVE_INFINITY` (every matched request fails until
+     * cleared). Set to e.g. `3` to fail the next 3 matched requests then
+     * stop.
+     */
+    readonly count?: number;
+    /**
+     * Number of matched requests to let through before failures start.
+     * Defaults to `0` (fail from the first matched request). Set to e.g.
+     * `2` to let the first 2 succeed and start failing on the 3rd.
+     */
+    readonly skip?: number;
+    /**
+     * If set, the synthetic response includes a `Retry-After: <n>` header
+     * (in seconds). Used to exercise the retry transport's
+     * `Retry-After`-respecting backoff path.
+     */
+    readonly retryAfter?: number;
+}
+/**
+ * Handle returned by {@link B2Simulator.injectFailure} so a specific
+ * fault registration can be torn down without affecting other faults.
+ */
+export interface FaultHandle {
+    /**
+     * Remove this fault registration. Idempotent: calling twice is a no-op.
+     * Faults whose `count` budget has already been exhausted retire
+     * automatically and do not need to be cleared explicitly.
+     */
+    clear(): void;
+}
+/**
+ * Options for constructing a {@link B2Simulator}.
+ */
+export interface B2SimulatorOptions {
+    /**
+     * The minimum part size the simulator advertises in `b2_authorize_account`
+     * responses (`apiInfo.storageApi.absoluteMinimumPartSize`). Defaults to
+     * `5_000_000` to mirror production B2. Lower this in tests that exercise
+     * multipart control-flow branches but don't need realistic part sizes,
+     * because v8 coverage instrumentation pushes 5 MB+ part hashing past 60 s
+     * on the slowest CI runners, which trips vitest's IPC RPC timeout.
+     */
+    minimumPartSize?: number;
+    /**
+     * The recommended part size the simulator advertises in
+     * `b2_authorize_account` responses (`apiInfo.storageApi.recommendedPartSize`).
+     * Defaults to `100_000_000` to mirror production B2. Lower this when a test
+     * needs to exercise the SDK's "use the recommended size when the caller
+     * omits `partSize`" default-branch without uploading 100 MB of bytes.
+     */
+    recommendedPartSize?: number;
+    /**
+     * Pluggable hook: invoked after every successful upload, copy, or
+     * `finishLargeFile` on a bucket with a matching event-notification
+     * rule. Tests can register a hook to assert the SDK's webhook
+     * publishing path without spinning up a real HTTP listener.
+     *
+     * Receives the freshly-stored `FileVersion`, the bucket the upload
+     * landed in, and the rule that matched. Returns a promise so async
+     * hook implementations are allowed; the simulator never blocks on it
+     * (errors thrown from the hook are surfaced via `bestEffort` to
+     * avoid masking the underlying API call's success).
+     */
+    onWebhookDeliver?: (event: {
+        rule: EventNotificationRule;
+        fileVersion: FileVersion;
+        bucketId: string;
+    }) => Promise<void> | void;
+    /**
+     * Pluggable hook: invoked after every successful upload on a bucket
+     * configured as a replication source. Receives the source `FileVersion`
+     * and the destination bucket ID. Tests can register a hook to
+     * verify replication intent without actually copying bytes inside
+     * the simulator.
+     */
+    onReplicate?: (event: {
+        sourceFileVersion: FileVersion;
+        sourceBucketId: string;
+        destinationBucketId: string;
+    }) => Promise<void> | void;
+    /**
+     * Diagnostic hook: invoked with any error thrown or rejected by
+     * `onWebhookDeliver` / `onReplicate`. Without this, errors thrown by
+     * user-supplied hooks are silently swallowed (intentional: a buggy
+     * hook must not corrupt an otherwise-successful upload), which makes
+     * test debugging hard when a hook quietly stops firing. Register
+     * `onHookError` to surface what would otherwise be invisible.
+     */
+    onHookError?: (event: {
+        kind: 'webhook' | 'replication';
+        error: Error;
+    }) => void;
+    /**
+     * When `true`, the simulator enforces application-key capability
+     * checks, bucket scoping, prefix scoping, and auth-token expiry on
+     * every request. The default `false` keeps the simulator permissive
+     * (matching its long-standing behaviour) so the existing test suite
+     * doesn't have to set up keys with the right capabilities.
+     *
+     * In strict mode:
+     *
+     * - Unknown auth tokens return HTTP 401 with code `bad_auth_token`.
+     * - Expired tokens (per {@link B2Simulator.advanceTime}) return HTTP 401 with code `expired_auth_token`.
+     * - Calls without the required capability for the endpoint return HTTP 403 `unauthorized`.
+     * - Calls outside the key's bucketId / namePrefix scope return HTTP 403 `unauthorized`.
+     *
+     * Each test can opt in: `new B2Simulator({ strictAuth: true })`.
+     */
+    strictAuth?: boolean;
+    /**
+     * How long auth tokens issued via `b2_authorize_account` are valid
+     * for, in milliseconds. Defaults to 24 hours (real B2). Tests that
+     * want to exercise the 401/reauth retry path can lower this so a
+     * single call to {@link B2Simulator.advanceTime} expires the token.
+     */
+    authTokenTtlMs?: number;
+}
+/**
+ * In-memory B2 simulator for testing. Implements the B2 native API at the
+ * request/response level without any network I/O. Supports 25+ operations
+ * including buckets, files, large files, keys, and notifications.
+ *
+ * @example
+ * ```ts
+ * const sim = new B2Simulator()
+ * const client = new B2Client({
+ *   applicationKeyId: 'test-key-id',
+ *   applicationKey: 'test-key',
+ *   transport: sim.transport(),
+ * })
+ * await client.authorize()
+ * ```
+ */
+export declare class B2Simulator {
+    private readonly buckets;
+    private readonly accountId;
+    private readonly largeFiles;
+    private readonly keys;
+    private readonly notificationRules;
+    private readonly minimumPartSize;
+    private readonly recommendedPartSize;
+    private readonly faults;
+    private nextFaultId;
+    private readonly onWebhookDeliver?;
+    private readonly onReplicate?;
+    private readonly onHookError?;
+    private readonly strictAuth;
+    private readonly authTokenTtlMs;
+    /**
+     * Issued auth tokens with their associated grant scope + expiry. In
+     * permissive mode (`strictAuth: false`) this is still populated by
+     * `authorize` but never consulted on subsequent requests. In strict
+     * mode each request looks up its `Authorization` header here.
+     */
+    private readonly issuedTokens;
+    /**
+     * Virtual-clock offset applied to `Date.now()` for expiry checks.
+     * Defaults to 0. Tests advance via {@link advanceTime} to fast-forward
+     * past auth-token expiry without sleeping.
+     */
+    private clockOffsetMs;
+    /**
+     * Per-instance monotonic counter used to mint realistic-looking
+     * IDs (`b2_bucket_<24-hex>`, `4_z<24-hex>`, etc.) and auth tokens.
+     * Module-global previously, which leaked state across `B2Simulator`
+     * instances in the same Vitest worker — concurrent tests could see
+     * colliding tokens. Per-instance ensures determinism within a single
+     * simulator's lifetime.
+     */
+    private nextId;
+    /**
+     * Last-issued upload timestamp. The simulator enforces strict
+     * monotonicity so version ordering is deterministic for tests; if
+     * two writes hit the same `Date.now()` millisecond, the second
+     * receives `lastTimestamp + 1`.
+     */
+    private lastTimestamp;
+    /**
+     * Outstanding fire-and-forget hook invocations. Tracked so tests
+     * (and future {@link flushHooks} callers) can wait for every
+     * dispatched `onWebhookDeliver` / `onReplicate` callback to settle
+     * before asserting against observable side effects. The microtask
+     * dance in fidelity tests was previously brittle: positive cases
+     * flushed twice, negative cases flushed once, and any addition to
+     * the hook dispatch chain quietly broke the negative path.
+     */
+    private readonly pendingHooks;
+    /**
+     * Constructs a new in-memory B2 simulator.
+     * @param options - Optional simulator overrides. See {@link B2SimulatorOptions}.
+     */
+    constructor(options?: B2SimulatorOptions);
+    /**
+     * Advance the simulator's virtual clock by `ms` milliseconds. Used in
+     * conjunction with `strictAuth: true` + a finite `authTokenTtlMs` to
+     * force token expiry without `setTimeout`-based delays.
+     *
+     * @param ms - Milliseconds to advance. Negative values rewind (rarely useful).
+     */
+    advanceTime(ms: number): void;
+    /**
+     * Current simulator time. Equal to `Date.now() + clockOffsetMs`.
+     *
+     * @returns Unix milliseconds.
+     */
+    private now;
+    /**
+     * Generate a deterministic-but-realistic-looking B2 identifier of the
+     * shape `<prefix>_<24-hex-counter>`, which approximates the visual
+     * width of real B2 wire IDs. The counter is monotonic per instance
+     * so test fixtures are deterministic across runs of the same
+     * simulator.
+     *
+     * @param prefix - B2-style prefix (`'b2_bucket'`, `'4_z'`, etc.).
+     *
+     * @returns A simulator-issued identifier that looks like a B2 wire ID.
+     */
+    private genId;
+    /**
+     * Return a strictly-increasing upload timestamp, even when multiple
+     * writes land in the same `Date.now()` millisecond. Tests rely on
+     * `uploadTimestamp` ordering to discriminate file versions; ties from
+     * coarse system-clock resolution would otherwise make version
+     * selection nondeterministic.
+     *
+     * @returns Unix milliseconds.
+     */
+    private monotonicTimestamp;
+    /**
+     * Wait for every fire-and-forget hook (`onWebhookDeliver`,
+     * `onReplicate`) currently in flight to settle. Use in tests after
+     * an upload/copy/finish-large-file call to deterministically observe
+     * hook side effects without microtask-flush guesswork.
+     *
+     * @returns A promise that resolves once every pending hook callback
+     *   has either resolved or rejected.
+     */
+    flushHooks(): Promise<void>;
+    /**
+     * Authorize a request against the strict-auth bookkeeping. Returns
+     * a `SimulatorJsonResponse` error on failure or `null` on success.
+     * Only consulted when `strictAuth: true`.
+     *
+     * @param authToken - The `Authorization` header value from the request.
+     * @param endpoint - B2 endpoint name being invoked.
+     * @param bucketId - Optional bucket ID the request operates on, for scope check.
+     * @param fileName - Optional file name the request operates on, for prefix check.
+     *
+     * @returns `null` when the request is authorized, otherwise a 401/403 response.
+     */
+    private authorizeRequest;
+    /**
+     * Look up the application key matching the `Authorization` header on
+     * an `authorize_account` request. The header is in the form
+     * `Basic base64(applicationKeyId:applicationKey)`.
+     *
+     * Returns `null` for the implicit master credential (anything that
+     * does not match a key minted via `b2_create_key`); in that case
+     * `authorize` grants the full master capability set.
+     *
+     * @param authzHeader - Raw HTTP `Authorization` header value.
+     *
+     * @returns The matching key's grant scope, or `null` for the master.
+     */
+    private findKeyForAuthHeader;
+    /**
+     * Creates an {@link HttpTransport} that routes requests to this simulator.
+     * @returns A transport instance backed by this in-memory simulator.
+     */
+    transport(): HttpTransport;
+    /**
+     * Register a synthetic failure to inject on requests whose URL contains
+     * `spec.on`. Use this to exercise retry / backoff / error-handling
+     * paths in tests without hand-rolling a wrapping `HttpTransport`. The
+     * fault is consumed in registration order on each matched request;
+     * once its `count` budget is exhausted it auto-retires.
+     *
+     * Faults are checked BEFORE the simulator's real handlers run, so a
+     * matched request never touches in-memory state — failed uploads
+     * don't create partial parts, failed deletes don't remove anything.
+     *
+     * @param spec - The failure to inject. See {@link FaultSpec}.
+     *
+     * @returns A handle whose `clear()` method removes this specific
+     *   fault registration (other faults remain in effect).
+     *
+     * @example
+     * ```ts
+     * // Fail the next 2 b2_upload_part calls with 503, then succeed.
+     * sim.injectFailure({ on: 'b2_upload_part', status: 503, count: 2 })
+     *
+     * // Fail every b2_authorize_account with 401 + Retry-After: 5.
+     * const handle = sim.injectFailure({
+     *   on: 'b2_authorize_account',
+     *   status: 401,
+     *   code: 'expired_auth_token',
+     *   retryAfter: 5,
+     * })
+     * // ... later
+     * handle.clear()
+     * ```
+     */
+    injectFailure(spec: FaultSpec): FaultHandle;
+    /**
+     * Remove every registered fault. Equivalent to calling `.clear()` on
+     * every handle returned by {@link injectFailure}, plus a defensive
+     * reset for tests that re-use a simulator across cases.
+     */
+    clearFaults(): void;
+    /**
+     * Internal: checks the registered faults for a match on the given URL
+     * and consumes one if it should fire. Called from
+     * {@link SimulatorTransport.send} before any real handler runs.
+     *
+     * @param url - The request URL to match against each fault's `on`
+     *   substring.
+     *
+     * @returns The fault to apply, or `null` if no fault should fire.
+     *
+     * @internal
+     */
+    consumeMatchingFault(url: string): FaultSpec | null;
+    /**
+     * Dispatches a JSON API request to the appropriate handler.
+     * @param _method - The HTTP method (unused).
+     * @param path - The request URL path containing the B2 endpoint name.
+     * @param headers - The HTTP request headers; consulted by the
+     *   strict-auth gate to look up the issued auth token.
+     * @param body - The parsed JSON request body.
+     *
+     * @returns An object with HTTP status and JSON response body.
+     */
+    handleRequest(_method: string, path: string, headers: Record<string, string>, body: unknown): Promise<SimulatorJsonResponse>;
+    /**
+     * Handles file and part upload requests (`b2_upload_file`, `b2_upload_part`).
+     * Dispatches to the appropriate internal handler based on the URL.
+     * @param url - The upload endpoint URL used to determine the upload type.
+     * @param headers - The HTTP headers containing file metadata and authorization.
+     * @param data - The raw file or part content as bytes.
+     *
+     * @returns An object with HTTP status and JSON response body.
+     */
+    handleUpload(url: string, headers: Record<string, string>, data: Uint8Array): SimulatorJsonResponse;
+    /**
+     * Handles file download requests (`b2_download_file_by_id`, `/file/` by name).
+     * Returns the file data along with B2 response headers.
+     * @param path - The request URL path identifying the file to download.
+     * @param headers - The HTTP request headers for range or authorization.
+     * @param method - The HTTP method; `'HEAD'` suppresses the response body.
+     *
+     * @returns The download response containing file data and B2 headers.
+     */
+    handleDownload(path: string, headers: Record<string, string>, method?: 'GET' | 'HEAD'): SimulatorDownloadResponse;
+    /**
+     * Convert a synthetic JSON error body into a `SimulatorDownloadResponse`
+     * shape so the strict-auth gate on download paths can surface 401/403s
+     * through the same transport plumbing as a regular failed download.
+     *
+     * @param json - The JSON error from {@link authorizeRequest}.
+     *
+     * @returns A download-shaped response with the error body bytes inline.
+     */
+    private errorAsDownload;
+    /**
+     * Applies HEAD-method body suppression and `b2Content*` response-header
+     * overrides parsed from the download URL's query string. Mirrors what the
+     * real B2 service does: any `b2Content*` query parameter is echoed back as
+     * the corresponding response header.
+     *
+     * @param response - The download response produced by {@link downloadById} or {@link downloadByName}.
+     * @param url - The parsed download URL (used to read `b2Content*` query params).
+     * @param method - The HTTP method of the originating request.
+     *
+     * @returns The response with overrides applied.
+     */
+    private finalizeDownload;
+    private handleUploadFile;
+    private handleUploadPart;
+    private downloadById;
+    private downloadByName;
+    private serveFile;
+    private authorize;
+    private createBucket;
+    private listBuckets;
+    private deleteBucket;
+    private updateBucket;
+    private getUploadUrl;
+    private listFileNames;
+    private listFileVersions;
+    private getFileInfo;
+    private hideFile;
+    private deleteFileVersion;
+    private copyFile;
+    private startLargeFile;
+    private getUploadPartUrl;
+    private finishLargeFile;
+    private cancelLargeFile;
+    private listUnfinishedLargeFiles;
+    private listParts;
+    private copyPart;
+    private getDownloadAuthorization;
+    private createKey;
+    private listKeys;
+    private deleteKey;
+    private updateFileRetention;
+    private updateFileLegalHold;
+    private getBucketNotificationRules;
+    private setBucketNotificationRules;
+    /**
+     * Locates a stored file version by its `fileId`, scanning every bucket.
+     *
+     * Returns enough context to support read-only inspection (`stored`,
+     * `bucketId`) AND in-place mutation (`versions`, `index`) so callers
+     * that need to splice the version out can do so without re-scanning.
+     *
+     * Real B2 fileIds embed the bucketId, so production lookups are O(1);
+     * the simulator's flat ID generator (`this.genId('4_z')`) doesn't, so this
+     * is O(buckets × files × versions). Acceptable for tests.
+     *
+     * @param fileId - The file version ID to locate.
+     *
+     * @returns The location of the matching version, or `null` if not found.
+     */
+    private findFile;
+    private makeFileVersion;
+    private error;
+    /**
+     * Fire the pluggable post-upload hooks for a file that just landed in
+     * a bucket: matching event-notification rules → `onWebhookDeliver`,
+     * configured replication source rules → `onReplicate`. Errors thrown
+     * from user-supplied hooks are swallowed so a buggy listener never
+     * masks an otherwise-successful API response.
+     *
+     * Fired-and-forgotten (no await) by the handler so the synthetic
+     * response is returned to the caller as fast as production B2 would
+     * acknowledge the write.
+     *
+     * @param fileVersion - The freshly-stored file metadata.
+     * @param bucketId - The bucket the upload landed in.
+     * @param eventType - The B2 event-type tag (e.g. `'b2:ObjectCreated:Upload'`)
+     *   used to match against `EventNotificationRule.eventTypes` globs.
+     */
+    private firePostUploadHooks;
+    /**
+     * Schedule a user-supplied hook callback. Errors are routed to
+     * `onHookError` if configured, swallowed otherwise. The returned
+     * promise is tracked in {@link pendingHooks} so `flushHooks()` can
+     * wait for every dispatched hook to settle.
+     *
+     * @param kind - Which hook this is (`'webhook'` or `'replication'`).
+     * @param fn - Thunk that performs the hook invocation.
+     */
+    private dispatchHook;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/simulator/index.d.ts.map

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