@wbce-d9/storage-driver-cloudinary 9.26.3

package/dist/constants.js

@@ -0,0 +1,62 @@
+export const IMAGE_EXTENSIONS = [
+    '.ai',
+    '.avif',
+    '.png',
+    '.webp',
+    '.bmp',
+    '.bw',
+    '.dfvu',
+    '.ps',
+    '.ept',
+    '.eps',
+    '.eps3',
+    '.fbx',
+    '.flif',
+    '.gif',
+    '.glb',
+    '.gltf',
+    '.heif',
+    '.heic',
+    '.ico',
+    '.indd',
+    '.jpg',
+    '.jpe',
+    '.jpeg',
+    '.jp2',
+    '.wdp',
+    '.jxr',
+    '.hdp',
+    '.obj',
+    '.pdf',
+    '.ply',
+    '.png',
+    '.psd',
+    '.arw',
+    '.cr2',
+    '.svg',
+    '.tga',
+    '.tif',
+    '.tiff',
+    '.u3ma',
+    '.usdz',
+    '.webp',
+];
+export const VIDEO_EXTENSIONS = [
+    '.3g2',
+    '.3gp',
+    '.avi',
+    '.flv',
+    '.m3u8',
+    '.ts',
+    '.m2ts',
+    '.mts',
+    '.mov',
+    '.mkv',
+    '.mp4',
+    '.mpeg',
+    '.mpd',
+    '.mxf',
+    '.ogv',
+    '.webm',
+    '.wmv',
+];

package/dist/index.js

@@ -0,0 +1,303 @@
+import { normalizePath } from '@wbce-d9/utils';
+import { Blob, Buffer } from 'node:buffer';
+import { createHash } from 'node:crypto';
+import { extname, join, parse } from 'node:path';
+import { Readable } from 'node:stream';
+import PQueue from 'p-queue';
+import { fetch, FormData } from 'undici';
+import { IMAGE_EXTENSIONS, VIDEO_EXTENSIONS } from './constants.js';
+export class DriverCloudinary {
+    root;
+    apiKey;
+    apiSecret;
+    cloudName;
+    accessMode;
+    constructor(config) {
+        this.root = config.root ? normalizePath(config.root, { removeLeading: true }) : '';
+        this.apiKey = config.apiKey;
+        this.apiSecret = config.apiSecret;
+        this.cloudName = config.cloudName;
+        this.accessMode = config.accessMode;
+    }
+    fullPath(filepath) {
+        return normalizePath(join(this.root, filepath), { removeLeading: true });
+    }
+    toFormUrlEncoded(obj, options) {
+        let entries = Object.entries(obj);
+        if (options?.sort) {
+            entries = entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+        }
+        return new URLSearchParams(entries).toString();
+    }
+    /**
+     * Generate the Cloudinary sha256 signature for the given payload
+     * @see https://cloudinary.com/documentation/signatures
+     */
+    getFullSignature(payload) {
+        const denylist = ['file', 'cloud_name', 'resource_type', 'api_key'];
+        const signaturePayload = Object.fromEntries(Object.entries(payload).filter(([key]) => denylist.includes(key) === false));
+        const signaturePayloadString = this.toFormUrlEncoded(signaturePayload, { sort: true });
+        return createHash('sha256')
+            .update(signaturePayloadString + this.apiSecret)
+            .digest('hex');
+    }
+    /**
+     * Creates inline URL signature for use with the image reading API
+     * @see https://cloudinary.com/documentation/advanced_url_delivery_options#generating_delivery_url_signatures
+     */
+    getParameterSignature(filepath) {
+        return `s--${createHash('sha256')
+            .update(filepath + this.apiSecret)
+            .digest('base64url')
+            .substring(0, 8)}--`;
+    }
+    getTimestamp() {
+        return String(new Date().getTime());
+    }
+    /**
+     * Used to guess what resource type is appropriate for a given filepath
+     * @see https://cloudinary.com/documentation/image_transformations#image_upload_note
+     */
+    getResourceType(filepath) {
+        const fileExtension = extname(filepath);
+        if (IMAGE_EXTENSIONS.includes(fileExtension))
+            return 'image';
+        if (VIDEO_EXTENSIONS.includes(fileExtension))
+            return 'video';
+        return 'raw';
+    }
+    /**
+     * For Cloudinary Admin APIs, the file extension needs to be omitted for images and videos. Raw
+     * on the other hand requires the extension to be present.
+     */
+    getPublicId(filepath) {
+        const resourceType = this.getResourceType(filepath);
+        if (resourceType === 'raw')
+            return filepath;
+        return parse(filepath).name;
+    }
+    /**
+     * Generates the Authorization header value for Cloudinary's basic auth endpoints
+     */
+    getBasicAuth() {
+        const creds = `${this.apiKey}:${this.apiSecret}`;
+        const base64 = Buffer.from(creds).toString('base64');
+        return `Basic ${base64}`;
+    }
+    async read(filepath, range) {
+        const resourceType = this.getResourceType(filepath);
+        const fullPath = this.fullPath(filepath);
+        const signature = this.getParameterSignature(fullPath);
+        const url = `https://res.cloudinary.com/${this.cloudName}/${resourceType}/upload/${signature}/${fullPath}`;
+        const requestInit = { method: 'GET' };
+        if (range) {
+            requestInit.headers = {
+                Range: `bytes=${range.start ?? ''}-${range.end ?? ''}`,
+            };
+        }
+        const response = await fetch(url, requestInit);
+        if (response.status >= 400 || !response.body) {
+            throw new Error(`No stream returned for file "${filepath}"`);
+        }
+        return Readable.fromWeb(response.body);
+    }
+    async stat(filepath) {
+        const fullPath = this.fullPath(filepath);
+        const resourceType = this.getResourceType(fullPath);
+        const publicId = this.getPublicId(fullPath);
+        const parameters = {
+            public_id: publicId,
+            type: 'upload',
+            api_key: this.apiKey,
+            timestamp: this.getTimestamp(),
+        };
+        const signature = this.getFullSignature(parameters);
+        const body = this.toFormUrlEncoded({
+            ...parameters,
+            signature,
+        });
+        const url = `https://api.cloudinary.com/v1_1/${this.cloudName}/${resourceType}/explicit`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            },
+            body,
+        });
+        if (response.status >= 400) {
+            throw new Error(`No stat returned for file "${filepath}"`);
+        }
+        const { bytes, created_at } = (await response.json());
+        return { size: bytes, modified: new Date(created_at) };
+    }
+    async exists(filepath) {
+        try {
+            await this.stat(filepath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async move(src, dest) {
+        const fullSrc = this.fullPath(src);
+        const fullDest = this.fullPath(dest);
+        const resourceType = this.getResourceType(fullSrc);
+        const url = `https://api.cloudinary.com/v1_1/${this.cloudName}/${resourceType}/rename`;
+        const parameters = {
+            from_public_id: this.getPublicId(fullSrc),
+            to_public_id: this.getPublicId(fullDest),
+            api_key: this.apiKey,
+            timestamp: this.getTimestamp(),
+        };
+        const signature = this.getFullSignature(parameters);
+        const body = this.toFormUrlEncoded({
+            ...parameters,
+            signature,
+        });
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            },
+            body,
+        });
+        if (response.status >= 400) {
+            const responseData = (await response.json());
+            throw new Error(`Can't move file "${src}": ${responseData?.error?.message ?? 'Unknown'}`);
+        }
+    }
+    async copy(src, dest) {
+        const stream = await this.read(src);
+        await this.write(dest, stream);
+    }
+    async write(filepath, content) {
+        const fullPath = this.fullPath(filepath);
+        const resourceType = this.getResourceType(fullPath);
+        const uploadParameters = {
+            timestamp: this.getTimestamp(),
+            api_key: this.apiKey,
+            type: 'upload',
+            access_mode: this.accessMode,
+            public_id: this.getPublicId(fullPath),
+        };
+        const signature = this.getFullSignature(uploadParameters);
+        let currentChunkSize = 0;
+        let totalSize = 0;
+        let uploaded = 0;
+        let error = null;
+        const queue = new PQueue({ concurrency: 10 });
+        const chunks = [];
+        for await (const chunk of content) {
+            chunks.push(chunk);
+            currentChunkSize += chunk.length;
+            // Cloudinary requires each chunk to be at least 5MB. We'll submit the chunk as soon as we
+            // reach 5.5MB to be safe
+            if (currentChunkSize >= 5.5e6) {
+                const uploadChunkParams = {
+                    resourceType,
+                    blob: new Blob(chunks),
+                    bytesOffset: uploaded,
+                    bytesTotal: -1,
+                    parameters: {
+                        signature,
+                        ...uploadParameters,
+                    },
+                };
+                queue
+                    .add(() => this.uploadChunk(uploadChunkParams))
+                    .catch((err) => {
+                    error = err;
+                });
+                uploaded += currentChunkSize;
+                currentChunkSize = 0;
+                chunks.length = 0; // empty the array of chunks
+            }
+            totalSize += chunk.length;
+        }
+        queue
+            .add(() => this.uploadChunk({
+            resourceType,
+            blob: new Blob(chunks),
+            bytesOffset: uploaded,
+            bytesTotal: totalSize,
+            parameters: {
+                signature,
+                ...uploadParameters,
+            },
+        }))
+            .catch((err) => {
+            error = err;
+        });
+        await queue.onIdle();
+        if (error) {
+            throw new Error(`Can't upload file "${filepath}": ${error.message}`, { cause: error });
+        }
+    }
+    async uploadChunk({ resourceType, blob, bytesOffset, bytesTotal, parameters, }) {
+        const formData = new FormData();
+        formData.set('file', blob);
+        for (const [key, value] of Object.entries(parameters)) {
+            formData.set(key, value);
+        }
+        const response = await fetch(`https://api.cloudinary.com/v1_1/${this.cloudName}/${resourceType}/upload`, {
+            method: 'POST',
+            body: formData,
+            headers: {
+                /** @see https://support.cloudinary.com/hc/en-us/articles/208263735-Guidelines-for-self-implementing-chunked-upload-to-Cloudinary */
+                'X-Unique-Upload-Id': parameters.timestamp,
+                'Content-Range': `bytes ${bytesOffset}-${bytesOffset + blob.size - 1}/${bytesTotal}`,
+            },
+        });
+        if (response.status >= 400) {
+            const responseData = (await response.json());
+            throw new Error(responseData?.error?.message ?? 'Unknown');
+        }
+    }
+    async delete(filepath) {
+        const fullPath = this.fullPath(filepath);
+        const resourceType = this.getResourceType(fullPath);
+        const publicId = this.getPublicId(fullPath);
+        const url = `https://api.cloudinary.com/v1_1/${this.cloudName}/${resourceType}/destroy`;
+        const parameters = {
+            timestamp: this.getTimestamp(),
+            api_key: this.apiKey,
+            resource_type: resourceType,
+            public_id: publicId,
+        };
+        const signature = this.getFullSignature(parameters);
+        await fetch(url, {
+            method: 'POST',
+            body: this.toFormUrlEncoded({
+                ...parameters,
+                signature,
+            }),
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            },
+        });
+    }
+    async *list(prefix = '') {
+        const fullPath = this.fullPath(prefix);
+        const publicId = this.getPublicId(fullPath);
+        let nextCursor = '';
+        do {
+            const response = await fetch(`https://api.cloudinary.com/v1_1/${this.cloudName}/resources/search?expression=${publicId}*&next_cursor=${nextCursor}`, {
+                method: 'GET',
+                headers: {
+                    Authorization: this.getBasicAuth(),
+                },
+            });
+            const json = (await response.json());
+            if (response.status >= 400) {
+                const responseData = (await response.json());
+                throw new Error(`Can't list for prefix "${prefix}": ${responseData?.error?.message ?? 'Unknown'}`);
+            }
+            nextCursor = json.next_cursor;
+            for (const file of json.resources) {
+                yield file.public_id;
+            }
+        } while (nextCursor);
+    }
+}
+export default DriverCloudinary;

package/dist/index.test.js

@@ -0,0 +1,951 @@
+import { normalizePath } from '@wbce-d9/utils';
+import { rand, randAlphaNumeric, randDirectoryPath, randFilePath, randFileType, randGitBranch as randCloudName, randGitCommitSha as randSha, randGitShortSha as randUnique, randNumber, randPastDate, randText, randWord, } from '@ngneat/falso';
+import { Blob } from 'node:buffer';
+import { createHash } from 'node:crypto';
+import { extname, join, parse } from 'node:path';
+import { PassThrough, Readable } from 'node:stream';
+import { ReadableStream } from 'node:stream/web';
+import { fetch, FormData } from 'undici';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { IMAGE_EXTENSIONS, VIDEO_EXTENSIONS } from './constants.js';
+import { DriverCloudinary } from './index.js';
+vi.mock('@wbce-d9/utils/node');
+vi.mock('@wbce-d9/utils');
+vi.mock('node:path');
+vi.mock('node:crypto');
+vi.mock('undici');
+let sample;
+let driver;
+beforeEach(() => {
+    sample = {
+        config: {
+            root: randDirectoryPath(),
+            apiKey: randNumber({ length: 15 }).join(''),
+            apiSecret: randAlphaNumeric({ length: 27 }).join(''),
+            cloudName: randCloudName(),
+            accessMode: rand(['public', 'authenticated']),
+        },
+        path: {
+            input: randUnique() + randFilePath(),
+            inputFull: randUnique() + randFilePath(),
+            src: randUnique() + randFilePath(),
+            srcFull: randUnique() + randFilePath(),
+            dest: randUnique() + randFilePath(),
+            destFull: randUnique() + randFilePath(),
+        },
+        range: {
+            start: randNumber(),
+            end: randNumber(),
+        },
+        stream: new PassThrough(),
+        text: randText(),
+        file: {
+            type: randFileType(),
+            size: randNumber(),
+            modified: randPastDate(),
+        },
+        resourceType: rand(['image', 'video', 'raw']),
+        publicId: {
+            input: randUnique() + randFilePath(),
+            src: randUnique() + randFilePath(),
+            dest: randUnique() + randFilePath(),
+        },
+        parameterSignature: `s--${randAlphaNumeric({ length: 8 }).join('')}--`,
+        fullSignature: randSha(),
+        basicAuth: `Basic ${randSha()}`,
+        timestamp: String(randPastDate().getTime()),
+        formUrlEncoded: randAlphaNumeric({ length: 30 }).join(''),
+    };
+    driver = new DriverCloudinary({
+        cloudName: sample.config.cloudName,
+        apiKey: sample.config.apiKey,
+        apiSecret: sample.config.apiSecret,
+        accessMode: sample.config.accessMode,
+    });
+    driver['fullPath'] = vi.fn().mockImplementation((input) => {
+        if (input === sample.path.src)
+            return sample.path.srcFull;
+        if (input === sample.path.dest)
+            return sample.path.destFull;
+        if (input === sample.path.input)
+            return sample.path.inputFull;
+        return '';
+    });
+    driver['getPublicId'] = vi.fn().mockImplementation((input) => {
+        if (input === sample.path.srcFull)
+            return sample.publicId.src;
+        if (input === sample.path.destFull)
+            return sample.publicId.dest;
+        if (input === sample.path.inputFull)
+            return sample.publicId.input;
+        return '';
+    });
+    driver['getResourceType'] = vi.fn().mockReturnValue(sample.resourceType);
+    driver['getParameterSignature'] = vi.fn().mockReturnValue(sample.parameterSignature);
+    driver['getBasicAuth'] = vi.fn().mockReturnValue(sample.basicAuth);
+    driver['getFullSignature'] = vi.fn().mockReturnValue(sample.fullSignature);
+    driver['getTimestamp'] = vi.fn().mockReturnValue(sample.timestamp);
+    driver['toFormUrlEncoded'] = vi.fn().mockReturnValue(sample.formUrlEncoded);
+});
+afterEach(() => {
+    vi.resetAllMocks();
+});
+describe('#constructor', () => {
+    test('Saves apiKey internally', () => {
+        expect(driver['apiKey']).toBe(sample.config.apiKey);
+    });
+    test('Saves apiSecret internally', () => {
+        expect(driver['apiSecret']).toBe(sample.config.apiSecret);
+    });
+    test('Saves cloudName internally', () => {
+        expect(driver['cloudName']).toBe(sample.config.cloudName);
+    });
+    test('Saves accessMode internally', () => {
+        expect(driver['accessMode']).toBe(sample.config.accessMode);
+    });
+    test('Defaults root to empty string', () => {
+        expect(driver['root']).toBe('');
+    });
+    test('Normalizes config path when root is given', () => {
+        vi.mocked(normalizePath).mockReturnValue(sample.path.inputFull);
+        new DriverCloudinary({
+            cloudName: sample.config.cloudName,
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            root: sample.config.root,
+            accessMode: sample.config.accessMode,
+        });
+        expect(normalizePath).toHaveBeenCalledWith(sample.config.root, { removeLeading: true });
+    });
+});
+describe('#fullPath', () => {
+    test('Returns normalized joined path', () => {
+        vi.mocked(join).mockReturnValue(sample.path.inputFull);
+        vi.mocked(normalizePath).mockReturnValue(sample.path.inputFull);
+        const driver = new DriverCloudinary({
+            cloudName: sample.config.cloudName,
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            accessMode: sample.config.accessMode,
+        });
+        driver['root'] = sample.config.root;
+        const result = driver['fullPath'](sample.path.input);
+        expect(join).toHaveBeenCalledWith(sample.config.root, sample.path.input);
+        expect(normalizePath).toHaveBeenCalledWith(sample.path.inputFull, { removeLeading: true });
+        expect(result).toBe(sample.path.inputFull);
+    });
+});
+describe('#toFormUrlEncoded', () => {
+    let mockProps;
+    let mockValues;
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+        mockProps = Array.from(Array(3), () => randAlphaNumeric({ length: randNumber({ min: 2, max: 15 }) }).join(''));
+        mockValues = randWord({ length: 3 });
+    });
+    test('Parses plain object of strings', () => {
+        const result = driver['toFormUrlEncoded']({
+            [mockProps[0]]: mockValues[0],
+            [mockProps[1]]: mockValues[1],
+            [mockProps[2]]: mockValues[2],
+        });
+        // The order isn't guaranteed
+        expect(result).toContain(`${mockProps[0]}=${mockValues[0]}`);
+        expect(result).toContain(`${mockProps[1]}=${mockValues[1]}`);
+        expect(result).toContain(`${mockProps[2]}=${mockValues[2]}`);
+    });
+    test('Optionally sorts the properties alphabetically', () => {
+        // Expected order should be 2-0-1
+        mockProps[0] = `b_${mockProps[0]}`;
+        mockProps[1] = `c_${mockProps[1]}`;
+        mockProps[2] = `a_${mockProps[2]}`;
+        expect(driver['toFormUrlEncoded']({
+            [mockProps[0]]: mockValues[0],
+            [mockProps[1]]: mockValues[1],
+            [mockProps[2]]: mockValues[2],
+        }, { sort: true })).toBe(`${mockProps[2]}=${mockValues[2]}&${mockProps[0]}=${mockValues[0]}&${mockProps[1]}=${mockValues[1]}`);
+    });
+});
+describe('#getFullSignature', () => {
+    let mockPayload;
+    let mockCreateHash;
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+        mockCreateHash = {
+            update: vi.fn().mockReturnThis(),
+            digest: vi.fn().mockReturnThis(),
+        };
+        vi.mocked(createHash).mockReturnValue(mockCreateHash);
+        driver['toFormUrlEncoded'] = vi.fn();
+        const randLength = randNumber({ min: 1, max: 10 });
+        const props = randWord({ length: randLength });
+        const values = randWord({ length: randLength });
+        mockPayload = Object.fromEntries(props.map((key, index) => [key, values[index]]));
+    });
+    test('Ignores Cloudinary denylist of keys', () => {
+        const payload = {
+            ...mockPayload,
+            // Ignored properties:
+            file: randText(),
+            cloud_name: randCloudName(),
+            resource_type: randWord(),
+            api_key: randAlphaNumeric({ length: 15 }).join(''),
+        };
+        driver['getFullSignature'](payload);
+        expect(driver['toFormUrlEncoded']).toHaveBeenCalledWith(mockPayload, { sort: true });
+    });
+    test('Creates sha256 hash', () => {
+        driver['getFullSignature'](mockPayload);
+        expect(createHash).toHaveBeenCalledWith('sha256');
+    });
+    test('Updates sha256 hash with signature payload + api secret', () => {
+        const mockFormUrlEncoded = randWord();
+        vi.mocked(driver['toFormUrlEncoded']).mockReturnValue(mockFormUrlEncoded);
+        driver['getFullSignature'](mockPayload);
+        expect(mockCreateHash.update).toHaveBeenCalledWith(mockFormUrlEncoded + sample.config.apiSecret);
+    });
+    test('Digests hash as hex', () => {
+        driver['getFullSignature'](mockPayload);
+        expect(mockCreateHash.digest).toHaveBeenCalledWith('hex');
+    });
+    test('Returns digested hash', () => {
+        const mockHash = randSha();
+        mockCreateHash.digest.mockReturnValue(mockHash);
+        const hash = driver['getFullSignature'](mockPayload);
+        expect(hash).toBe(mockHash);
+    });
+});
+describe('#getParameterSignature', () => {
+    let mockHash;
+    let result;
+    let mockCreateHash;
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+        mockHash = randSha();
+        mockCreateHash = {
+            update: vi.fn().mockReturnThis(),
+            digest: vi.fn().mockReturnValue(mockHash),
+        };
+        vi.mocked(createHash).mockReturnValue(mockCreateHash);
+        result = driver['getParameterSignature'](sample.path.input);
+    });
+    test('Creates sha256 hash', () => {
+        expect(createHash).toHaveBeenCalledWith('sha256');
+    });
+    test('Updates hash with passed filepath + apiSecret', () => {
+        expect(mockCreateHash.update).toHaveBeenCalledWith(sample.path.input + sample.config.apiSecret);
+    });
+    test('Digests hash to base64url', () => {
+        expect(mockCreateHash.digest).toHaveBeenCalledWith('base64url');
+    });
+    test('Returns first 8 characters of base64 sha hash wrapped in Cloudinary prefix/suffix', () => {
+        expect(result).toBe(`s--${mockHash.substring(0, 8)}--`);
+    });
+});
+describe('#getTimestamp', () => {
+    let mockDate;
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+        mockDate = randPastDate();
+        vi.useFakeTimers();
+        vi.setSystemTime(mockDate);
+    });
+    test('Returns unix timestamp for current time', () => {
+        expect(driver['getTimestamp']()).toBe(String(mockDate.getTime()));
+    });
+});
+describe('#getResourceType', () => {
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+    });
+    test('Returns "image" for extensions contained in the image extensions constant', () => {
+        IMAGE_EXTENSIONS.forEach((ext) => {
+            vi.mocked(extname).mockReturnValue(ext);
+            const result = driver['getResourceType'](sample.path.inputFull);
+            expect(extname).toHaveBeenCalledWith(sample.path.inputFull);
+            expect(result).toBe('image');
+        });
+    });
+    test('Returns "video" for extensions contained in the video extensions constant', () => {
+        VIDEO_EXTENSIONS.forEach((ext) => {
+            vi.mocked(extname).mockReturnValue(ext);
+            const result = driver['getResourceType'](sample.path.inputFull);
+            expect(extname).toHaveBeenCalledWith(sample.path.inputFull);
+            expect(result).toBe('video');
+        });
+    });
+    test('Returns "raw" for unknown / other extensions', () => {
+        randWord({ length: 5 }).forEach((filepath) => expect(driver['getResourceType'](filepath)).toBe('raw'));
+    });
+});
+describe('#getPublicId', () => {
+    let mockParsedPath;
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+        driver['getResourceType'] = vi.fn().mockReturnValue(sample.resourceType);
+        mockParsedPath = randDirectoryPath();
+        vi.mocked(parse).mockReturnValue({ name: mockParsedPath });
+    });
+    test('Gets resourceType for given filepath', () => {
+        driver['getPublicId'](sample.path.input);
+        expect(driver['getResourceType']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Returns original file path if type is raw', () => {
+        driver['getResourceType'] = vi.fn().mockReturnValue('raw');
+        const publicId = driver['getPublicId'](sample.path.input);
+        expect(publicId).toBe(sample.path.input);
+    });
+    test('Parsed base path if other type', () => {
+        driver['getResourceType'] = vi.fn().mockReturnValue(rand(['image', 'video']));
+        const publicId = driver['getPublicId'](sample.path.input);
+        expect(publicId).toBe(mockParsedPath);
+    });
+});
+describe('#getBasicAuth', () => {
+    let mockToString;
+    beforeEach(() => {
+        driver = new DriverCloudinary({
+            apiKey: sample.config.apiKey,
+            apiSecret: sample.config.apiSecret,
+            cloudName: sample.config.cloudName,
+            accessMode: sample.config.accessMode,
+        });
+        mockToString = vi.fn();
+        vi.spyOn(Buffer, 'from').mockReturnValue({ toString: mockToString });
+    });
+    test('Creates base64 hash of key:secret', () => {
+        driver['getBasicAuth']();
+        expect(Buffer.from).toHaveBeenCalledWith(`${sample.config.apiKey}:${sample.config.apiSecret}`);
+        expect(mockToString).toHaveBeenCalledWith('base64');
+    });
+    test(`Returns 'Basic <base64>'`, () => {
+        const mockBase64 = randSha();
+        mockToString.mockReturnValue(mockBase64);
+        const result = driver['getBasicAuth']();
+        expect(result).toBe(`Basic ${mockBase64}`);
+    });
+});
+describe('#read', () => {
+    let mockResponse;
+    beforeEach(() => {
+        mockResponse = {
+            status: 200,
+            body: new ReadableStream(),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        vi.spyOn(Readable, 'fromWeb').mockReturnValue(sample.stream);
+    });
+    test('Gets resource type for extension of given filepath', async () => {
+        await driver.read(sample.path.input);
+        expect(driver['getResourceType']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Creates signature for full filepath', async () => {
+        await driver.read(sample.path.input);
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
+        expect(driver['getParameterSignature']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Calls fetch with generated URL', async () => {
+        await driver.read(sample.path.input);
+        expect(fetch).toHaveBeenCalledWith(`https://res.cloudinary.com/${sample.config.cloudName}/${sample.resourceType}/upload/${sample.parameterSignature}/${sample.path.inputFull}`, { method: 'GET' });
+    });
+    test('Adds optional Range header for start', async () => {
+        await driver.read(sample.path.input, { start: sample.range.start });
+        expect(fetch).toHaveBeenCalledWith(`https://res.cloudinary.com/${sample.config.cloudName}/${sample.resourceType}/upload/${sample.parameterSignature}/${sample.path.inputFull}`, { method: 'GET', headers: { Range: `bytes=${sample.range.start}-` } });
+    });
+    test('Adds optional Range header for end', async () => {
+        await driver.read(sample.path.input, { end: sample.range.end });
+        expect(fetch).toHaveBeenCalledWith(`https://res.cloudinary.com/${sample.config.cloudName}/${sample.resourceType}/upload/${sample.parameterSignature}/${sample.path.inputFull}`, { method: 'GET', headers: { Range: `bytes=-${sample.range.end}` } });
+    });
+    test('Adds optional Range header for start and end', async () => {
+        await driver.read(sample.path.input, sample.range);
+        expect(fetch).toHaveBeenCalledWith(`https://res.cloudinary.com/${sample.config.cloudName}/${sample.resourceType}/upload/${sample.parameterSignature}/${sample.path.inputFull}`, { method: 'GET', headers: { Range: `bytes=${sample.range.start}-${sample.range.end}` } });
+    });
+    test('Throws error when response has status >= 400', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        try {
+            await driver.read(sample.path.input);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`No stream returned for file "${sample.path.input}"`);
+        }
+    });
+    test('Throws error when response has no readable body', async () => {
+        mockResponse.body = null;
+        try {
+            await driver.read(sample.path.input);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`No stream returned for file "${sample.path.input}"`);
+        }
+    });
+    test('Returns readable stream from web stream', async () => {
+        const stream = await driver.read(sample.path.input);
+        expect(Readable.fromWeb).toHaveBeenCalledWith(mockResponse.body);
+        expect(stream).toBe(sample.stream);
+    });
+});
+describe('#stat', () => {
+    let mockResponse;
+    let mockResponseBody;
+    beforeEach(() => {
+        mockResponseBody = {
+            bytes: sample.file.size,
+            created_at: sample.file.modified.toISOString(),
+        };
+        mockResponse = {
+            json: vi.fn().mockResolvedValue(mockResponseBody),
+            status: 200,
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+    });
+    test('Gets full path for given filepath', async () => {
+        await driver.stat(sample.path.input);
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Gets resource type for given filepath', async () => {
+        await driver.stat(sample.path.input);
+        expect(driver['getResourceType']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Gets publicId for given filepath', async () => {
+        await driver.stat(sample.path.input);
+        expect(driver['getPublicId']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Creates signature for body parameters', async () => {
+        await driver.stat(sample.path.input);
+        expect(driver['getFullSignature']).toHaveBeenCalledWith({
+            type: 'upload',
+            public_id: sample.publicId.input,
+            api_key: sample.config.apiKey,
+            timestamp: sample.timestamp,
+        });
+    });
+    test('Creates form url encoded body ', async () => {
+        await driver.stat(sample.path.input);
+        expect(driver['toFormUrlEncoded']).toHaveBeenCalledWith({
+            type: 'upload',
+            public_id: sample.publicId.input,
+            api_key: sample.config.apiKey,
+            timestamp: sample.timestamp,
+            signature: sample.fullSignature,
+        });
+    });
+    test('Fetches URL with url encoded body', async () => {
+        await driver.stat(sample.path.input);
+        expect(fetch).toHaveBeenCalledWith(`https://api.cloudinary.com/v1_1/${sample.config.cloudName}/${sample.resourceType}/explicit`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            },
+            body: sample.formUrlEncoded,
+        });
+    });
+    test('Throws error when status is >400', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        try {
+            await driver.stat(sample.path.input);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`No stat returned for file "${sample.path.input}"`);
+        }
+    });
+    test('Returns size/modified from bytes/created_at from Cloudinary', async () => {
+        const result = await driver.stat(sample.path.input);
+        expect(result).toStrictEqual({
+            size: sample.file.size,
+            modified: sample.file.modified,
+        });
+    });
+});
+describe('#exists', () => {
+    beforeEach(() => {
+        driver['stat'] = vi.fn().mockResolvedValue({ size: sample.file.size, modified: sample.file.modified });
+    });
+    test('Calls stat', async () => {
+        await driver.exists(sample.path.input);
+        expect(driver['stat']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Returns true if stat returns the stats', async () => {
+        const exists = await driver.exists(sample.path.input);
+        expect(exists).toBe(true);
+    });
+    test('Returns false if stat throws an error', async () => {
+        vi.mocked(driver.stat).mockRejectedValue(new Error());
+        const exists = await driver.exists(sample.path.input);
+        expect(exists).toBe(false);
+    });
+});
+describe('#move', () => {
+    let mockResponse;
+    let mockResponseBody;
+    beforeEach(() => {
+        mockResponseBody = {};
+        mockResponse = {
+            json: vi.fn().mockResolvedValue(mockResponseBody),
+            status: 200,
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+    });
+    test('Gets full path for src', async () => {
+        await driver.move(sample.path.src, sample.path.dest);
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.src);
+    });
+    test('Gets full path for dest', async () => {
+        await driver.move(sample.path.src, sample.path.dest);
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.dest);
+    });
+    test('Gets resource type for src', async () => {
+        await driver.move(sample.path.src, sample.path.dest);
+        expect(driver['getResourceType']).toHaveBeenCalledWith(sample.path.srcFull);
+    });
+    test('Creates signature for body parameters', async () => {
+        await driver.move(sample.path.src, sample.path.dest);
+        expect(driver['getFullSignature']).toHaveBeenCalledWith({
+            from_public_id: sample.publicId.src,
+            to_public_id: sample.publicId.dest,
+            api_key: sample.config.apiKey,
+            timestamp: sample.timestamp,
+        });
+    });
+    test('Creates form url encoded body ', async () => {
+        await driver.move(sample.path.src, sample.path.dest);
+        expect(driver['toFormUrlEncoded']).toHaveBeenCalledWith({
+            from_public_id: sample.publicId.src,
+            to_public_id: sample.publicId.dest,
+            api_key: sample.config.apiKey,
+            timestamp: sample.timestamp,
+            signature: sample.fullSignature,
+        });
+    });
+    test('Fetches URL with url encoded body', async () => {
+        await driver.move(sample.path.src, sample.path.dest);
+        expect(fetch).toHaveBeenCalledWith(`https://api.cloudinary.com/v1_1/${sample.config.cloudName}/${sample.resourceType}/rename`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            },
+            body: sample.formUrlEncoded,
+        });
+    });
+    test('Throws error if status is >400', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        try {
+            await driver.move(sample.path.src, sample.path.dest);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't move file "${sample.path.src}": Unknown`);
+        }
+    });
+    test(`Defaults to Unknown if error object doesn't contain message`, async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        mockResponseBody.error = {};
+        try {
+            await driver.move(sample.path.src, sample.path.dest);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't move file "${sample.path.src}": Unknown`);
+        }
+    });
+    test(`Renders message if returned by Cloudinary`, async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        mockResponseBody.error = { message: randText() };
+        try {
+            await driver.move(sample.path.src, sample.path.dest);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't move file "${sample.path.src}": ${mockResponseBody.error.message}`);
+        }
+    });
+});
+describe('#copy', () => {
+    beforeEach(() => {
+        driver.read = vi.fn().mockResolvedValue(sample.stream);
+        driver.write = vi.fn();
+    });
+    test('Calls read with input path', async () => {
+        await driver.copy(sample.path.src, sample.path.dest);
+        expect(driver.read).toHaveBeenCalledWith(sample.path.src);
+    });
+    test('Calls write with dest path and read stream', async () => {
+        await driver.copy(sample.path.src, sample.path.dest);
+        expect(driver.write).toHaveBeenCalledWith(sample.path.dest, sample.stream);
+    });
+});
+describe('#write', () => {
+    let stream;
+    let chunks;
+    beforeEach(async () => {
+        chunks = randUnique({ length: randNumber({ min: 1, max: 10 }) });
+        async function* generate() {
+            for (const chunk of chunks) {
+                yield chunk;
+            }
+        }
+        stream = Readable.from(generate());
+        driver['uploadChunk'] = vi.fn();
+    });
+    test('Gets full path for input', async () => {
+        await driver.write(sample.path.input, stream);
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Gets resource type for full path', async () => {
+        await driver.write(sample.path.input, stream);
+        expect(driver['getResourceType']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Constructs signature from correct upload parameters', async () => {
+        await driver.write(sample.path.input, stream);
+        expect(driver['getFullSignature']).toHaveBeenCalledWith({
+            timestamp: sample.timestamp,
+            api_key: sample.config.apiKey,
+            type: 'upload',
+            access_mode: sample.config.accessMode,
+            public_id: sample.publicId.input,
+        });
+    });
+    test('Queues upload once stream has buffered', async () => {
+        await driver.write(sample.path.input, stream);
+        expect(driver['uploadChunk']).toHaveBeenCalledOnce();
+        expect(driver['uploadChunk']).toHaveBeenCalledWith({
+            resourceType: sample.resourceType,
+            blob: new Blob(chunks),
+            bytesOffset: 0,
+            bytesTotal: new Blob(chunks).size,
+            parameters: {
+                timestamp: sample.timestamp,
+                access_mode: sample.config.accessMode,
+                api_key: sample.config.apiKey,
+                public_id: sample.publicId.input,
+                signature: sample.fullSignature,
+                type: 'upload',
+            },
+        });
+    });
+    test('Queues chunk upload each time chunks add up to at least 5.5MB of data', async () => {
+        const chunk1 = Buffer.alloc(3e6).toString(); // nothing happens yet
+        const chunk2 = Buffer.alloc(3e6).toString(); // adds up to 6MB together with chunk1, so sent as chunk
+        const chunk3 = Buffer.alloc(1e6).toString(); // sent as separate final request
+        chunks = [chunk1, chunk2, chunk3];
+        await driver.write(sample.path.input, stream);
+        expect(driver['uploadChunk']).toHaveBeenCalledTimes(2);
+        expect(driver['uploadChunk']).toHaveBeenCalledWith({
+            resourceType: sample.resourceType,
+            blob: new Blob([chunk1, chunk2]),
+            bytesOffset: 0,
+            bytesTotal: -1,
+            parameters: {
+                timestamp: sample.timestamp,
+                access_mode: sample.config.accessMode,
+                api_key: sample.config.apiKey,
+                public_id: sample.publicId.input,
+                signature: sample.fullSignature,
+                type: 'upload',
+            },
+        });
+    });
+    test('Sends final chunk with total size information', async () => {
+        const chunk1 = Buffer.alloc(3e6).toString(); // nothing happens yet
+        const chunk2 = Buffer.alloc(3e6).toString(); // adds up to 6MB together with chunk1, so sent as chunk
+        const chunk3 = Buffer.alloc(1e6).toString(); // sent as separate final request
+        chunks = [chunk1, chunk2, chunk3];
+        await driver.write(sample.path.input, stream);
+        expect(driver['uploadChunk']).toHaveBeenCalledTimes(2);
+        expect(driver['uploadChunk']).toHaveBeenCalledWith({
+            resourceType: sample.resourceType,
+            blob: new Blob([chunk3]),
+            bytesOffset: 6e6,
+            bytesTotal: 7e6,
+            parameters: {
+                timestamp: sample.timestamp,
+                access_mode: sample.config.accessMode,
+                api_key: sample.config.apiKey,
+                public_id: sample.publicId.input,
+                signature: sample.fullSignature,
+                type: 'upload',
+            },
+        });
+    });
+    test('Throws error if one of the chunks failed to upload', async () => {
+        const chunk1 = Buffer.alloc(3e6).toString(); // nothing happens yet
+        const chunk2 = Buffer.alloc(3e6).toString(); // adds up to 6MB together with chunk1, so sent as chunk
+        const chunk3 = Buffer.alloc(1e6).toString(); // sent as separate final request
+        chunks = [chunk1, chunk2, chunk3];
+        const mockErrorMessage = randText();
+        vi.mocked(driver['uploadChunk']).mockRejectedValueOnce(new Error(mockErrorMessage));
+        vi.mocked(driver['uploadChunk']).mockResolvedValueOnce();
+        try {
+            await driver.write(sample.path.input, stream);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't upload file "${sample.path.input}": ${mockErrorMessage}`);
+        }
+    });
+    test('Throws error if last chunk failed to upload', async () => {
+        const chunk1 = Buffer.alloc(3e6).toString(); // nothing happens yet
+        const chunk2 = Buffer.alloc(3e6).toString(); // adds up to 6MB together with chunk1, so sent as chunk
+        const chunk3 = Buffer.alloc(1e6).toString(); // sent as separate final request
+        chunks = [chunk1, chunk2, chunk3];
+        const mockErrorMessage = randText();
+        vi.mocked(driver['uploadChunk']).mockResolvedValueOnce();
+        vi.mocked(driver['uploadChunk']).mockRejectedValueOnce(new Error(mockErrorMessage));
+        try {
+            await driver.write(sample.path.input, stream);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't upload file "${sample.path.input}": ${mockErrorMessage}`);
+        }
+    });
+});
+describe('#uploadChunk', () => {
+    let mockResponse;
+    let mockResponseBody;
+    let mockFormData;
+    let input;
+    beforeEach(() => {
+        mockResponseBody = {};
+        mockResponse = {
+            json: vi.fn().mockResolvedValue(mockResponseBody),
+            status: 200,
+        };
+        mockFormData = {
+            set: vi.fn(),
+        };
+        input = {
+            resourceType: sample.resourceType,
+            blob: { size: randNumber({ min: 0, max: 1500 }) },
+            bytesOffset: randNumber({ min: 0, max: 500 }),
+            bytesTotal: randNumber(),
+            parameters: {
+                timestamp: sample.timestamp,
+            },
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+        vi.mocked(FormData).mockReturnValue(mockFormData);
+    });
+    test('Creates FormData object', async () => {
+        await driver['uploadChunk'](input);
+        expect(FormData).toHaveBeenCalledOnce();
+        expect(FormData).toHaveBeenCalledWith();
+    });
+    test('Saves all passed parameters to form data', async () => {
+        const keys = randUnique({ length: randNumber({ min: 1, max: 10 }) });
+        const values = randUnique({ length: randNumber({ min: 1, max: 10 }) });
+        keys.forEach((key, index) => {
+            input.parameters[key] = values[index];
+        });
+        await driver['uploadChunk'](input);
+        keys.forEach((key, index) => {
+            expect(mockFormData.set).toHaveBeenCalledWith(key, values[index]);
+        });
+    });
+    test('Calls fetch with formData an range header', async () => {
+        await driver['uploadChunk'](input);
+        expect(fetch).toHaveBeenCalledWith(`https://api.cloudinary.com/v1_1/${sample.config.cloudName}/${sample.resourceType}/upload`, {
+            method: 'POST',
+            body: mockFormData,
+            headers: {
+                'X-Unique-Upload-Id': sample.timestamp,
+                'Content-Range': `bytes ${input.bytesOffset}-${input.bytesOffset + input.blob.size - 1}/${input.bytesTotal}`,
+            },
+        });
+    });
+    test('Throws an error when the response statusCode is >=400', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        try {
+            await driver['uploadChunk'](input);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe('Unknown');
+        }
+    });
+    test('Defaults to Unknown if Cloudinary API response error message is not known', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        mockResponseBody.error = {};
+        try {
+            await driver['uploadChunk'](input);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe('Unknown');
+        }
+    });
+    test('Sets error message to Cloudinary return message', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        mockResponseBody.error = { message: randWord() };
+        try {
+            await driver['uploadChunk'](input);
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(mockResponseBody.error.message);
+        }
+    });
+});
+describe('#delete', () => {
+    beforeEach(async () => {
+        await driver.delete(sample.path.input);
+    });
+    test('Gets full path', () => {
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Gets resource type for full path', () => {
+        expect(driver['getResourceType']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Gets publicId for full path', () => {
+        expect(driver['getPublicId']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Generates signature for delete parameters', () => {
+        expect(driver['getFullSignature']).toHaveBeenCalledWith({
+            timestamp: sample.timestamp,
+            api_key: sample.config.apiKey,
+            resource_type: sample.resourceType,
+            public_id: sample.publicId.input,
+        });
+    });
+    test('Calls fetch with correct parameters', () => {
+        expect(driver['toFormUrlEncoded']).toHaveBeenCalledWith({
+            timestamp: sample.timestamp,
+            api_key: sample.config.apiKey,
+            resource_type: sample.resourceType,
+            public_id: sample.publicId.input,
+            signature: sample.fullSignature,
+        });
+        expect(fetch).toHaveBeenCalledWith(`https://api.cloudinary.com/v1_1/${sample.config.cloudName}/${sample.resourceType}/destroy`, {
+            method: 'POST',
+            body: sample.formUrlEncoded,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            },
+        });
+    });
+});
+describe('#list', () => {
+    let mockResponse;
+    let mockFilePaths;
+    let mockResponseBody;
+    beforeEach(() => {
+        mockFilePaths = randFilePath({ length: randNumber({ min: 1, max: 10 }) });
+        mockResponseBody = {
+            resources: mockFilePaths.map((filepath) => ({
+                public_id: filepath,
+            })),
+        };
+        mockResponse = {
+            status: 200,
+            json: vi.fn().mockResolvedValue(mockResponseBody),
+        };
+        vi.mocked(fetch).mockResolvedValue(mockResponse);
+    });
+    test('Gets full path for prefix', async () => {
+        await driver.list(sample.path.input).next();
+        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
+    });
+    test('Gets public id for prefix', async () => {
+        await driver.list(sample.path.input).next();
+        expect(driver['getPublicId']).toHaveBeenCalledWith(sample.path.inputFull);
+    });
+    test('Fetches search api results', async () => {
+        await driver.list(sample.path.input).next();
+        expect(fetch).toHaveBeenCalledWith(`https://api.cloudinary.com/v1_1/${sample.config.cloudName}/resources/search?expression=${sample.publicId.input}*&next_cursor=`, {
+            method: 'GET',
+            headers: {
+                Authorization: sample.basicAuth,
+            },
+        });
+    });
+    test('Yields resource public IDs from response', async () => {
+        const output = [];
+        for await (const path of driver.list(sample.path.input)) {
+            output.push(path);
+        }
+        expect(output.length).toBe(mockResponseBody.resources.length);
+        expect(output).toStrictEqual(mockFilePaths);
+    });
+    test('Keeps calling fetch as long as a next_cursor is returned', async () => {
+        const mockNextCursor = randSha();
+        mockResponse.json.mockResolvedValueOnce({
+            ...mockResponseBody,
+            next_cursor: mockNextCursor,
+        });
+        const output = [];
+        for await (const path of driver.list(sample.path.input)) {
+            output.push(path);
+        }
+        expect(fetch).toHaveBeenCalledTimes(2);
+        expect(fetch).toHaveBeenCalledWith(`https://api.cloudinary.com/v1_1/${sample.config.cloudName}/resources/search?expression=${sample.publicId.input}*&next_cursor=${mockNextCursor}`, {
+            method: 'GET',
+            headers: {
+                Authorization: sample.basicAuth,
+            },
+        });
+    });
+    test('Throws error if search api fails', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        try {
+            await driver.list(sample.path.input).next();
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't list for prefix "${sample.path.input}": Unknown`);
+        }
+    });
+    test('Defaults to Unknown error if the error response does not contain a message', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        mockResponseBody.error = {};
+        try {
+            await driver.list(sample.path.input).next();
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't list for prefix "${sample.path.input}": Unknown`);
+        }
+    });
+    test('Provides Cloudinary error message', async () => {
+        mockResponse.status = randNumber({ min: 400, max: 599 });
+        mockResponseBody.error = { message: randText() };
+        try {
+            await driver.list(sample.path.input).next();
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(Error);
+            expect(err.message).toBe(`Can't list for prefix "${sample.path.input}": ${mockResponseBody.error.message}`);
+        }
+    });
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@wbce-d9/storage-driver-cloudinary",
+  "version": "9.26.3",
+  "type": "module",
+  "description": "Cloudinary file storage abstraction for `@wbce-d9/storage`",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LaWebcapsule/directus9.git",
+    "directory": "packages/storage-driver-cloudinary"
+  },
+  "funding": "https://github.com/LaWebcapsule/directus9?sponsor=1",
+  "license": "GPL-3.0",
+  "author": "Rijk van Zanten <rijkvanzanten@me.com>",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "!**/*.d.ts?(.map)"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "p-queue": "7.3.4",
+    "undici": "5.22.0",
+    "@wbce-d9/storage": "9.26.3",
+    "@wbce-d9/utils": "9.26.3"
+  },
+  "devDependencies": {
+    "@wbce-d9/tsconfig": "0.0.7",
+    "@ngneat/falso": "6.4.0",
+    "@vitest/coverage-c8": "0.30.1",
+    "typescript": "5.0.4",
+    "vitest": "0.30.1"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --watch",
+    "test": "vitest --watch=false"
+  }
+}

package/readme.md

@@ -0,0 +1,3 @@
+# `@wbce-d9/storage-driver-cloudinary`
+
+Cloudinary file storage driver for `@wbce-d9/storage`