@aligent/microservice-util-lib 0.2.2 → 1.1.0

package/src/openapi-fetch-middlewares/authentications.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeyAuthMiddleware = apiKeyAuthMiddleware;
+exports.basicAuthMiddleware = basicAuthMiddleware;
+exports.oAuth10aAuthMiddleware = oAuth10aAuthMiddleware;
+exports.oAuth20AuthMiddleware = oAuth20AuthMiddleware;
+const oauth10a_1 = require("./oauth10a/oauth10a");
+/**
+ * Creates an openapi-fetch middleware for API key authentication.
+ * This middleware sets the API key in the specified header for each request.
+ *
+ * @param {ApiKey} config - The configuration for API key authentication.
+ * @returns {Middleware} The middleware for API key authentication.
+ *
+ * @example
+ * const middleware = apiKeyAuthMiddleware({
+ *     header: 'x-api-key',
+ *     value: async () => 'your-api-key',
+ * });
+ */
+function apiKeyAuthMiddleware(config) {
+    return {
+        onRequest: async ({ request }) => {
+            request.headers.set(config.header, await config.value());
+        },
+    };
+}
+/**
+ * Creates an openapi-fetch middleware for Basic authentication.
+ * This middleware sets the `Authorization` header with the Basic authentication credentials
+ * (username and password) for each request.
+ *
+ * @param {Basic} config - The configuration for Basic authentication.
+ * @returns {Middleware} The middleware for Basic authentication.
+ *
+ * @example
+ * const middleware = basicAuthMiddleware({
+ *     credentials: async () => ({ username: 'user', password: 'pass' }),
+ * });
+ */
+function basicAuthMiddleware(config) {
+    return {
+        onRequest: async ({ request }) => {
+            const { username, password } = await config.credentials();
+            request.headers.set('Authorization', `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`);
+        },
+    };
+}
+/**
+ * Creates an openapi-fetch middleware for OAuth 1.0a authentication.
+ * This middleware generates OAuth 1.0a parameters and sets the `Authorization` header
+ * for each request.
+ *
+ * @param {OAuth10a} config - The configuration for OAuth 1.0a authentication.
+ * @returns {Middleware} The middleware for OAuth 1.0a authentication.
+ *
+ * @example
+ * const middleware = oAuth10aAuthMiddleware({
+ *     algorithm: 'HMAC-SHA256',
+ *     credentials: async () => ({
+ *         consumerKey: 'key',
+ *         consumerSecret: 'secret',
+ *         token: 'token',
+ *         tokenSecret: 'tokenSecret',
+ *     }),
+ * });
+ */
+function oAuth10aAuthMiddleware(config) {
+    return {
+        onRequest: async ({ request, options, params }) => {
+            const oauthParams = await (0, oauth10a_1.generateOauthParams)(request, options, params, config);
+            request.headers.set('Authorization', `OAuth ${oauthParams}`);
+        },
+    };
+}
+/**
+ * Creates an openapi-fetch middleware for OAuth 2.0 authentication.
+ * This middleware sets the `Authorization` header with the OAuth 2.0 token for each request.
+ *
+ * @param {OAuth20} options - The configuration for OAuth 2.0 authentication.
+ * @returns {Middleware} The middleware for OAuth 2.0 authentication.
+ *
+ * @example
+ * const middleware = oAuth20AuthMiddleware({
+ *     token: async () => 'your-access-token',
+ *     tokenType: 'Bearer',
+ * });
+ */
+function oAuth20AuthMiddleware(options) {
+    return {
+        onRequest: async ({ request }) => {
+            const { tokenType = 'Bearer' } = options;
+            request.headers.set('Authorization', `${tokenType} ${await options.token()}`);
+        },
+    };
+}

package/src/openapi-fetch-middlewares/oauth10a/oauth10a.d.ts

@@ -0,0 +1,12 @@
+import { MiddlewareCallbackParams } from 'openapi-fetch';
+import { OAuth10a } from '../authentications';
+/**
+ * Generates OAuth 1.0a parameters for signing a request.
+ *
+ * @param {MiddlewareCallbackParams['request']} request - The request object.
+ * @param {MiddlewareCallbackParams['options']} options - The options object.
+ * @param {MiddlewareCallbackParams['params']} params - The parameters object.
+ * @param {OAuth10a} config - The OAuth 1.0a configuration.
+ * @returns {Promise<string>} The generated OAuth 1.0a Authorization header.
+ */
+export declare function generateOauthParams(request: MiddlewareCallbackParams['request'], options: MiddlewareCallbackParams['options'], params: MiddlewareCallbackParams['params'], config: OAuth10a): Promise<string>;

package/src/openapi-fetch-middlewares/oauth10a/oauth10a.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOauthParams = generateOauthParams;
+const crypto_1 = __importDefault(require("crypto"));
+const oauth_sign_1 = require("oauth-sign");
+/**
+ * Determines whether a given URL is absolute.
+ *
+ * A URL is considered absolute if it begins with a scheme (e.g., "http://", "https://")
+ * or is protocol-relative (e.g., "//example.com").
+ * RFC 3986 defines scheme name as a sequence of characters beginning with a letter
+ * and followed by any combination of letters, digits, plus, period, or hyphen.
+ *
+ * @param {string} url - The URL to check.
+ * @returns {boolean} `true` if the URL is absolute, otherwise `false`.
+ *
+ * @example
+ * isAbsoluteURL('https://example.com'); // true
+ * isAbsoluteURL('//example.com'); // true
+ * isAbsoluteURL('/relative/path'); // false
+ */
+function isAbsoluteURL(url) {
+    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+/**
+ * Combines a base URL and a relative URL into a single URL.
+ *
+ * @param {string} baseURL - The base URL.
+ * @param {string} relativeURL - The relative URL to combine with the base URL.
+ * @returns {string} The combined URL.
+ *
+ * @example
+ * combineURLs('https://example.com', '/path'); // 'https://example.com/path'
+ */
+function combineURLs(baseURL, relativeURL) {
+    return relativeURL
+        ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+        : baseURL;
+}
+/**
+ * Replaces placeholders in a URL with corresponding values from the path parameters.
+ *
+ * @param {string} url - The URL containing placeholders (e.g., `{id}`).
+ * @param {Record<string, unknown>} [pathParams] - The path parameters to replace in the URL.
+ * @returns {string} The URL with placeholders replaced by actual values.
+ *
+ * @example
+ * combineUrlAndPathParams('/users/{id}', { id: 123 }); // '/users/123'
+ */
+function combineUrlAndPathParams(url, pathParams) {
+    if (!pathParams) {
+        return url;
+    }
+    for (const [key, value] of Object.entries(pathParams)) {
+        url = url.replace(`{${key}}`, String(value));
+    }
+    return url;
+}
+/**
+ * Processes a URL for OAuth 1.0a by removing unnecessary parts and preparing it for signing.
+ *
+ * @param {string} baseURL - The base URL.
+ * @param {string} url - The URL to process.
+ * @returns {{ baseUri: string, searchParams: URLSearchParams | null }} The processed URL and its search parameters.
+ */
+function handleOAuthUrl(baseURL, url) {
+    const oauthUrl = new URL(!baseURL || isAbsoluteURL(url) ? url : combineURLs(baseURL, url));
+    let searchParams = null;
+    // Query parameters are hashed as part of params rather than as part of the URL
+    if (oauthUrl.search) {
+        searchParams = new URLSearchParams(oauthUrl.search);
+        oauthUrl.search = '';
+    }
+    // Do not include hash in signature
+    oauthUrl.hash = '';
+    // Remove port if it is the default for that protocol
+    if ((oauthUrl.protocol === 'https:' && oauthUrl.port === '443') ||
+        (oauthUrl.protocol === 'http:' && oauthUrl.port === '80')) {
+        oauthUrl.port = '';
+    }
+    return {
+        baseUri: oauthUrl.toString(),
+        searchParams,
+    };
+}
+/**
+ * Adds a parameter to the list of parameters to sign.
+ *
+ * @param {Record<string, string | string[]>} paramsToSign - The parameters to sign.
+ * @param {string} key - The key of the parameter.
+ * @param {string} value - The value of the parameter.
+ */
+function addParamToSign(paramsToSign, key, value) {
+    const existingValue = paramsToSign[key];
+    if (typeof existingValue === 'string') {
+        paramsToSign[key] = [existingValue, value];
+    }
+    else if (Array.isArray(existingValue)) {
+        existingValue.push(value);
+    }
+    else {
+        paramsToSign[key] = value;
+    }
+}
+/**
+ * Adds multiple parameters to the list of parameters to sign.
+ *
+ * @param {Record<string, string | string[]>} paramsToSign - The parameters to sign.
+ * @param {URLSearchParams | Record<string, unknown> | string} params - The parameters to add.
+ */
+function addParamsToSign(paramsToSign, params) {
+    // Ensure `params` is compatible with `URLSearchParams`
+    const normalizedParams = typeof params === 'string' || params instanceof URLSearchParams
+        ? params
+        : Object.entries(params).reduce((acc, [key, value]) => {
+            acc[key] = Array.isArray(value) ? value.map(String) : String(value);
+            return acc;
+        }, {});
+    new URLSearchParams(normalizedParams).forEach((value, key) => {
+        addParamToSign(paramsToSign, key, value);
+    });
+}
+/**
+ * Determines whether a body hash should be generated for the request.
+ *
+ * @param {string} body - The request body.
+ * @param {string} method - The HTTP method.
+ * @param {OAuth10a['includeBodyHash']} includeBodyHash - The body hash inclusion setting.
+ * @returns {boolean} `true` if a body hash should be generated, otherwise `false`.
+ */
+function shouldGenerateBodyHash(body, method, includeBodyHash) {
+    if (includeBodyHash === 'auto' && ['POST', 'PUT'].includes(method) && body) {
+        return true;
+    }
+    return includeBodyHash === true;
+}
+/**
+ * Generates OAuth 1.0a parameters for signing a request.
+ *
+ * @param {MiddlewareCallbackParams['request']} request - The request object.
+ * @param {MiddlewareCallbackParams['options']} options - The options object.
+ * @param {MiddlewareCallbackParams['params']} params - The parameters object.
+ * @param {OAuth10a} config - The OAuth 1.0a configuration.
+ * @returns {Promise<string>} The generated OAuth 1.0a Authorization header.
+ */
+async function generateOauthParams(request, options, params, config) {
+    const { algorithm, includeBodyHash = 'auto', realm, callback, verifier } = config;
+    const { consumerKey, consumerSecret, token, tokenSecret } = await config.credentials();
+    const method = (request.method || 'GET').toUpperCase();
+    const url = combineUrlAndPathParams(request.url, params.path);
+    const oauthParams = {
+        oauth_consumer_key: consumerKey,
+        oauth_nonce: crypto_1.default.randomUUID(),
+        oauth_signature_method: algorithm,
+        oauth_timestamp: String(Math.floor(Date.now() * 0.001)),
+        oauth_version: '1.0',
+    };
+    // if provided, oauth_token can be included in the oauth parameters
+    // more information: https://datatracker.ietf.org/doc/html/rfc5849#section-3.1
+    if (token) {
+        oauthParams.oauth_token = token;
+    }
+    if (callback) {
+        oauthParams.oauth_callback = callback;
+    }
+    if (verifier) {
+        oauthParams.oauth_verifier = verifier;
+    }
+    const paramsToSign = {};
+    addParamsToSign(paramsToSign, oauthParams);
+    if (params.query) {
+        addParamsToSign(paramsToSign, params.query);
+    }
+    const { baseUri, searchParams } = handleOAuthUrl(options.baseUrl, url);
+    if (searchParams) {
+        addParamsToSign(paramsToSign, searchParams);
+    }
+    const body = await request.text();
+    // If user submit a form, then include form parameters in the
+    // signature as parameters rather than the body hash
+    if (request.headers.get('Content-Type') === 'application/x-www-form-urlencoded') {
+        addParamsToSign(paramsToSign, new URLSearchParams(body));
+        console.log(JSON.stringify(paramsToSign));
+    }
+    else {
+        if (shouldGenerateBodyHash(body, method, includeBodyHash)) {
+            const bodyHash = crypto_1.default
+                .createHash(algorithm === 'HMAC-SHA1' ? 'sha1' : 'sha256')
+                .update(Buffer.from(body))
+                .digest('base64');
+            oauthParams.oauth_body_hash = bodyHash;
+            addParamToSign(paramsToSign, 'oauth_body_hash', bodyHash);
+        }
+    }
+    oauthParams.oauth_signature = (0, oauth_sign_1.sign)(algorithm, method, baseUri, paramsToSign, consumerSecret, tokenSecret);
+    // realm should not be included in the signature calculation
+    // but is optional in the OAuth 1.0 Authorization header
+    // so we need to add it after signing the request
+    // more information: https://datatracker.ietf.org/doc/html/rfc5849#section-3.4.1.3.1
+    if (realm) {
+        oauthParams.realm = realm;
+    }
+    return Object.entries(oauthParams)
+        .map(e => [e[0], '="', (0, oauth_sign_1.rfc3986)(e[1]), '"'].join(''))
+        .join(',');
+}

package/src/openapi-fetch-middlewares/types/authentications.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Represents an API key authentication method.
+ *
+ * This interface is used for API key-based authentication, where the key is sent
+ * in a specific header. The value of the API key is retrieved asynchronously.
+ *
+ * @interface ApiKey
+ * @property {string} header - The header name where the API key will be set.
+ * @property {() => Promise<string>} value - A function that returns a promise resolving to the API key value.
+ */
+export interface ApiKey {
+    header: string;
+    value: () => Promise<string>;
+}
+/**
+ * Represents basic authentication credentials.
+ *
+ * This interface is used for basic authentication, where the username and password
+ * are retrieved asynchronously.
+ *
+ * @interface Basic
+ * @property {() => Promise<{ username: string; password: string }>} credentials - A function that returns a promise resolving to the username and password.
+ */
+export interface Basic {
+    credentials: () => Promise<{
+        username: string;
+        password: string;
+    }>;
+}
+/**
+ * Represents OAuth 1.0a authentication credentials.
+ *
+ * This interface is used for OAuth 1.0a authentication, where the consumer key, consumer secret,
+ * token, and token secret are retrieved asynchronously. It also supports optional parameters
+ * like body hash inclusion, realm, callback, and verifier.
+ *
+ * @interface OAuth10a
+ * @property {'HMAC-SHA1' | 'HMAC-SHA256'} algorithm - The signing algorithm to use.
+ * @property {() => Promise<{ consumerKey: string; consumerSecret: string; token?: string; tokenSecret: string }>} credentials - A function that returns a promise resolving to the OAuth 1.0a credentials.
+ * @property {boolean | 'auto'} [includeBodyHash] - Whether to include a body hash in the signature. Defaults to 'auto'.
+ * @property {string} [realm] - The realm parameter for the Authorization header.
+ * @property {string} [callback] - The callback URL for OAuth 1.0a.
+ * @property {string} [verifier] - The verifier for OAuth 1.0a.
+ */
+export interface OAuth10a {
+    algorithm: 'HMAC-SHA1' | 'HMAC-SHA256';
+    credentials: () => Promise<{
+        consumerKey: string;
+        consumerSecret: string;
+        token?: string;
+        tokenSecret: string;
+    }>;
+    includeBodyHash?: boolean | 'auto';
+    realm?: string;
+    callback?: string;
+    verifier?: string;
+}
+/**
+ * Represents OAuth 2.0 authentication credentials.
+ *
+ * This interface is used for OAuth 2.0 authentication, where an access token is retrieved
+ * asynchronously. It also supports an optional token type (e.g., 'Bearer').
+ *
+ * @interface OAuth20
+ * @property {() => Promise<string>} token - A function that returns a promise resolving to the access token.
+ * @property {string} [tokenType] - The type of the token (e.g., 'Bearer'). Defaults to 'Bearer' if not specified.
+ */
+export interface OAuth20 {
+    token: () => Promise<string>;
+    tokenType?: string;
+}

package/src/openapi-fetch-middlewares/types/authentications.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{dist → src}/remap/remap.d.ts

@@ -3,7 +3,7 @@ export type SimplifyIntersection<A> = A extends object ? {
     [K in keyof A]: A[K] extends object ? SimplifyIntersection<A[K]> : A[K];
 } : A;
 /** A list of keys to keys, with an optional transformer function */
-type ObjectMap = readonly ((readonly [string, string, ((...args: any[]) => any)?]))[];
+type ObjectMap = ReadonlyArray<readonly [string, string, ((...args: any[]) => any)?]>;
 /**
  * Given a Key, a base Object and an ObjectMap, this will return the
  * type of the property referencable by the Key on the base Object, or in
@@ -28,11 +28,11 @@ type ObjectMap = readonly ((readonly [string, string, ((...args: any[]) => any)?
  */
 type GetKeyType<Key extends string, O extends {
     [key: string]: any;
-}, M extends ObjectMap[number]> = M extends readonly [string, string, ((...args: any[]) => (infer U))] ? unknown extends U ? Key extends `${infer K}.${infer Rest}` ? GetKeyType<Rest, O[K], M> : O[Key] : U : Key extends `${infer K}.${infer Rest}` ? GetKeyType<Rest, O[K], M> : O[Key];
+}, M extends ObjectMap[number]> = M extends readonly [string, string, (...args: any[]) => infer U] ? unknown extends U ? Key extends `${infer K}.${infer Rest}` ? GetKeyType<Rest, O[K], M> : O[Key] : U : Key extends `${infer K}.${infer Rest}` ? GetKeyType<Rest, O[K], M> : O[Key];
 /**
-* Given an ObjectMap, return a new ObjectMap with the first index of each
-* tuple replaced with the value of the second index
-*/
+ * Given an ObjectMap, return a new ObjectMap with the first index of each
+ * tuple replaced with the value of the second index
+ */
 type OverrideIndex<M extends ObjectMap[number], V extends string> = readonly [M[0], V, M[2]];
 /**
  * Given a key and a base object, return the type of the property referencable
@@ -143,5 +143,5 @@ type Remap<MapArray extends ObjectMap, Original extends {
 declare function remap<Original extends {
     [key: string]: any;
 }, MapArray extends ObjectMap>(object: Original, map: MapArray): Remap<MapArray, Original>;
-export { Remap, ObjectMap };
+export type { ObjectMap, Remap };
 export default remap;

package/src/remap/remap.js

@@ -0,0 +1,97 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Get a value from an object using a dot-notation path
+ * @param obj The object to get the value from
+ * @param path The dot-notation path (e.g., 'foo.bar.baz')
+ * @returns The value at the path, or undefined if not found
+ */
+function getValue(obj, path) {
+    let current = obj;
+    for (const key of path.split('.')) {
+        if (current == null)
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * Check if a key looks like an array index (numeric string)
+ */
+function isArrayIndex(key) {
+    return /^\d+$/.test(key);
+}
+/**
+ * Set a value in an object using a dot-notation path
+ * @param obj The object to set the value in
+ * @param path The dot-notation path (e.g., 'foo.bar.baz')
+ * @param value The value to set
+ */
+function setValue(obj, path, value) {
+    const keys = path.split('.').filter(key => !!key); // Skip empty keys, e.g. in 'foo..bar'
+    const lastKey = keys.pop();
+    if (!lastKey) {
+        // Somehow we've been given a path with no keys, so we can't set anything
+        return;
+    }
+    // Navigate to the parent object, creating nested structures as needed
+    let current = obj;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]; // We've already filtered out empty keys, so this is safe
+        // If this key already has a valid object to put the next key on, continue
+        if (key in current && typeof current[key] === 'object' && current[key] !== null) {
+            current = current[key];
+            continue;
+        }
+        // Otherwise, set the current key as an object or array based on what the next key is
+        const nextKey = keys.at(i + 1) ?? lastKey;
+        current[key] = isArrayIndex(nextKey) ? [] : {};
+        current = current[key];
+    }
+    // Set the final value
+    current[lastKey] = value;
+}
+/**
+ * Map one object's values to another structure
+ * @param object the object to map from
+ * @param map the keys for the mapping
+ * @returns the remapped object
+ *
+ * @example without a transformer function
+ * ```ts
+ * const map = [
+ *   ['foo', 'baz'],
+ *   ['bar', 'qux.0']
+ * ] as const;
+ * const obj = { foo: 'hi', bar: 7 }
+ * remap(obj, map); // { baz: 'hi', qux: [7] }
+ * ```
+ * @example with a transformer function
+ * ```ts
+ * const map = [
+ *  ['foo', 'baz'],
+ *  ['bar', 'qux.0', (x: number) => x + 1]
+ * ] as const;
+ * const obj = { foo: 'hi', bar: 7 }
+ * remap(obj, map); // { baz: 'hi', qux: [8] }
+ * ```
+ * @example with an empty initial key
+ * ```ts
+ * const map = [
+ *   ['', 'baz', (x: { foo: number, bar: number }) => x.foo + x.bar]
+ * ]
+ * const obj = { foo: 3, bar: 7 }
+ * remap(obj, map); // { baz: 10 }
+ * ```
+ */
+function remap(object, map) {
+    const out = {};
+    map.forEach(item => {
+        const parser = item[2] ? item[2] : (val) => val;
+        const value = item[0] ? getValue(object, item[0]) : object;
+        setValue(out, item[1], parser(value));
+    });
+    return out;
+}
+exports.default = remap;

package/{dist/retryWrapper/retryWrapper.d.ts → src/retry-wrapper/retry-wrapper.d.ts}

@@ -36,5 +36,5 @@ interface RetryConfig {
  * ```
  */
 declare function retryWrapper<T>(fn: () => Promise<T>, config: RetryConfig): Promise<T>;
-export { RetryConfig };
+export type { RetryConfig };
 export default retryWrapper;

package/src/retry-wrapper/retry-wrapper.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Retry an async function if it fails
+ * @param fn the function to be retried
+ * @param config the configuration for retries
+ * @param retryCount the number of retries so far
+ * @param error the error from teh last retry
+ */
+async function retryWrapperInternal(fn, config, retryCount, error) {
+    if (config.retries < 0) {
+        throw error;
+    }
+    if (error) {
+        if (config.onRetry) {
+            config.onRetry(retryCount, error, config);
+        }
+    }
+    try {
+        const result = await fn();
+        return result;
+    }
+    catch (err) {
+        await (() => new Promise(res => setTimeout(res, config.delay)))();
+        return await retryWrapperInternal(fn, {
+            ...config,
+            retries: config.retries - 1,
+            delay: config.delay + config.backoffAmount,
+        }, retryCount + 1, err);
+    }
+}
+/**
+ * Retry an async function if it fails
+ * @param fn the function to be retried
+ * @param config the configuration for retries
+ * @example
+ * ```ts
+ * retryWrapper(someAsyncFunction, {
+ *   retries: 3,
+ *   onRetry: (_, error) => console.error(error)
+ * });
+ * ```
+ */
+async function retryWrapper(fn, config) {
+    const defaultConfig = {
+        retries: 1,
+        delay: 0,
+        backoffAmount: 0,
+        onRetry: () => null,
+    };
+    return await retryWrapperInternal(fn, {
+        ...defaultConfig,
+        ...config,
+    }, 0);
+}
+exports.default = retryWrapper;

package/{dist → src}/s3/s3.d.ts

@@ -20,7 +20,7 @@ declare class S3Dao {
      * @param chunkSize the number of entries that should be in each chunk
      * @returns an array of objects which can be used to fetch the chunks
      */
-    storeChunked<T extends any[]>(data: T, chunkSize: number): Promise<GetObjectCommandInput[]>;
+    storeChunked<T extends unknown[]>(data: T, chunkSize: number): Promise<GetObjectCommandInput[]>;
     /**
      * Fetch an object from the S3 bucket
      * @param objectDetails the object which describes the location of the object
@@ -33,11 +33,8 @@ declare class S3Dao {
      */
     fetchChunks<T>(chunks: GetObjectCommandInput[]): AsyncGenerator<{
         chunk: T;
-        s3Object: GetObjectCommandInput;
-    }, {
-        chunk: T;
-        s3Object: GetObjectCommandInput;
-    }, unknown>;
+        s3Object: GetObjectCommandInput | undefined;
+    }, Awaited<T>, unknown>;
     /**
      * Delete an object from the S3 bucket
      * @param objectDetails the object to delete