@directus/storage-driver-azure 9.26.0 → 10.0.1

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Driver, Range } from '@directus/storage';
+import type { Readable } from 'node:stream';
+export type DriverAzureConfig = {
+    containerName: string;
+    accountName: string;
+    accountKey: string;
+    root?: string;
+    endpoint?: string;
+};
+export declare class DriverAzure implements Driver {
+    private containerClient;
+    private signedCredentials;
+    private root;
+    constructor(config: DriverAzureConfig);
+    private fullPath;
+    read(filepath: string, range?: Range): Promise<Readable>;
+    write(filepath: string, content: Readable, type?: string): Promise<void>;
+    delete(filepath: string): Promise<void>;
+    stat(filepath: string): Promise<{
+        size: number;
+        modified: Date;
+    }>;
+    exists(filepath: string): Promise<boolean>;
+    move(src: string, dest: string): Promise<void>;
+    copy(src: string, dest: string): Promise<void>;
+    list(prefix?: string): AsyncGenerator<string, void, unknown>;
+}
+export default DriverAzure;

package/license

@@ -0,0 +1,107 @@
+Licensor:             Monospace, Inc.
+
+Licensed Work:        Directus
+                      The Licensed Work is Copyright © 2023 Monospace, Inc.
+
+Additional Use Grant: You may use the Licensed Work in production as long as
+                      your Total Finances do not exceed US $5,000,000 for the
+                      most recent 12-month period, provided that Monospace, Inc.
+                      will not be liable to you in any way, including for any
+                      damages, including general, special, incidental or
+                      consequential damages, arising out of such use.
+
+                      References to: “Total Finances” mean the largest of your
+                      aggregate gross revenues, entire budget, and/or funding
+                      (no matter the source); “you” and “your” include (without
+                      limitation) any individual or entity agreeing to these
+                      terms and any affiliates of such individual or entity; and
+                      “production” mean any use other than (i) development of
+                      (including evaluation of the Licensed Work), debugging, or
+                      testing your offerings, or (ii) making the Licensed Work
+                      available standalone in unmodified object code form.
+
+Change Date:          Three years from release date
+
+Change License:       GNU General Public License (GPL) v3
+
+For information about alternative licensing arrangements, please visit
+https://directus.io/pricing.
+
+--------------------------------------------------------------------------------
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production
+use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under the
+terms of the Change License, and the rights granted in the paragraph above
+terminate.
+
+If your use of the Licensed Work does not comply with the requirements currently
+in effect as described in this License, you must purchase a commercial license
+from the Licensor, its affiliated entities, or authorized resellers, or you must
+refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works of
+the Licensed Work, are subject to this License. This License applies separately
+for each version of the Licensed Work and the Change Date may vary for each
+version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy of
+the Licensed Work. If you receive the Licensed Work in original or modified form
+from a third party, the terms and conditions set forth in this License apply to
+your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other versions
+of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of Licensor
+or its affiliates (provided that you may use a trademark or logo of Licensor as
+expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN
+“AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS
+OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license your
+works, and to refer to it using the trademark “Business Source License”, as long
+as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the “Business
+Source License” name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where “compatible” means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text “None”.
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.
+
+License text copyright © 2023 MariaDB plc, All Rights Reserved.
+“Business Source License” is a trademark of MariaDB plc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/storage-driver-azure",
-  "version": "9.26.0",
+  "version": "10.0.1",
   "type": "module",
   "description": "Azure file storage abstraction for `@directus/storage`",
   "repository": {
@@ -9,7 +9,7 @@
     "directory": "packages/storage-driver-azure"
   },
   "funding": "https://github.com/directus/directus?sponsor=1",
-  "license": "GPL-3.0",
+  "license": "BUSL-1.1",
   "author": "Rijk van Zanten <rijkvanzanten@me.com>",
   "exports": {
     ".": "./dist/index.js",
@@ -17,26 +17,25 @@
   },
   "main": "dist/index.js",
   "files": [
-    "dist",
-    "!**/*.d.ts?(.map)"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@azure/storage-blob": "12.14.0",
-    "@directus/storage": "9.26.0",
-    "@directus/utils": "9.26.0"
+    "@directus/storage": "10.0.1",
+    "@directus/utils": "10.0.1"
   },
   "devDependencies": {
     "@directus/tsconfig": "0.0.7",
     "@ngneat/falso": "6.4.0",
-    "@vitest/coverage-c8": "0.30.1",
+    "@vitest/coverage-c8": "0.31.0",
     "typescript": "5.0.4",
-    "vitest": "0.30.1"
+    "vitest": "0.31.0"
   },
   "scripts": {
-    "build": "tsc --build",
+    "build": "tsc --project tsconfig.prod.json",
     "dev": "tsc --watch",
     "test": "vitest --watch=false"
   }

package/dist/index.test.js

@@ -1,373 +0,0 @@
-import { BlobServiceClient, StorageSharedKeyCredential } from '@azure/storage-blob';
-import { normalizePath } from '@directus/utils';
-import { isReadableStream } from '@directus/utils/node';
-import { join } from 'node:path';
-import { PassThrough } from 'node:stream';
-import { afterEach, describe, expect, test, vi, beforeEach } from 'vitest';
-import { DriverAzure } from './index.js';
-import { randAlphaNumeric, randDirectoryPath, randDomainName, randFilePath, randGitBranch as randContainer, randNumber, randPastDate, randWord, randText, randFileType, randUrl, randGitShortSha as randUnique, } from '@ngneat/falso';
-vi.mock('@directus/utils/node');
-vi.mock('@directus/utils');
-vi.mock('@azure/storage-blob');
-vi.mock('node:path');
-let sample;
-let driver;
-beforeEach(() => {
-    sample = {
-        config: {
-            containerName: randContainer(),
-            accountName: randWord(),
-            accountKey: randAlphaNumeric({ length: 40 }).join(''),
-            root: randDirectoryPath(),
-            endpoint: `https://${randDomainName()}`,
-        },
-        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(),
-        },
-    };
-    driver = new DriverAzure({
-        containerName: sample.config.containerName,
-        accountKey: sample.config.accountKey,
-        accountName: sample.config.accountName,
-    });
-    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 '';
-    });
-});
-afterEach(() => {
-    vi.resetAllMocks();
-});
-describe('#constructor', () => {
-    test('Creates signed credentials', () => {
-        expect(StorageSharedKeyCredential).toHaveBeenCalledWith(sample.config.accountName, sample.config.accountKey);
-        expect(driver['signedCredentials']).toBeInstanceOf(StorageSharedKeyCredential);
-    });
-    test('Creates blob service client and sets containerClient', () => {
-        const mockSignedCredentials = {};
-        vi.mocked(StorageSharedKeyCredential).mockReturnValueOnce(mockSignedCredentials);
-        const mockContainerClient = {};
-        const mockBlobServiceClient = {
-            getContainerClient: vi.fn().mockReturnValue(mockContainerClient),
-        };
-        vi.mocked(BlobServiceClient).mockReturnValue(mockBlobServiceClient);
-        const driver = new DriverAzure({
-            containerName: sample.config.containerName,
-            accountName: sample.config.accountName,
-            accountKey: sample.config.accountKey,
-        });
-        expect(BlobServiceClient).toHaveBeenCalledWith(`https://${sample.config.accountName}.blob.core.windows.net`, mockSignedCredentials);
-        expect(mockBlobServiceClient.getContainerClient).toHaveBeenCalledWith(sample.config.containerName);
-        expect(driver['containerClient']).toBe(mockContainerClient);
-    });
-    test('Allows overriding endpoint with optional setting', () => {
-        test('Creates blob service client and sets containerClient', () => {
-            const mockSignedCredentials = {};
-            vi.mocked(StorageSharedKeyCredential).mockReturnValueOnce(mockSignedCredentials);
-            const mockContainerClient = {};
-            const mockBlobServiceClient = {
-                getContainerClient: vi.fn().mockReturnValue(mockContainerClient),
-            };
-            vi.mocked(BlobServiceClient).mockReturnValue(mockBlobServiceClient);
-            const driver = new DriverAzure({
-                containerName: sample.config.containerName,
-                accountName: sample.config.accountName,
-                accountKey: sample.config.accountKey,
-                endpoint: sample.config.endpoint,
-            });
-            expect(BlobServiceClient).toHaveBeenCalledWith(sample.config.endpoint, mockSignedCredentials);
-            expect(mockBlobServiceClient.getContainerClient).toHaveBeenCalledWith(sample.config.containerName);
-            expect(driver['containerClient']).toBe(mockContainerClient);
-        });
-    });
-    test('Defaults root path to empty string', () => {
-        expect(driver['root']).toBe('');
-    });
-    test('Normalizes config path when root is given', () => {
-        vi.mocked(normalizePath).mockReturnValue(sample.path.inputFull);
-        new DriverAzure({
-            containerName: sample.config.containerName,
-            accountName: sample.config.accountName,
-            accountKey: sample.config.accountKey,
-            root: sample.path.input,
-        });
-        expect(normalizePath).toHaveBeenCalledWith(sample.path.input, { 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 DriverAzure({
-            containerName: sample.config.containerName,
-            accountName: sample.config.accountName,
-            accountKey: sample.config.accountKey,
-        });
-        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);
-        expect(result).toBe(sample.path.inputFull);
-    });
-});
-describe('#read', () => {
-    let mockDownload;
-    beforeEach(async () => {
-        mockDownload = vi.fn().mockResolvedValue({ readableStreamBody: sample.stream });
-        const mockBlobClient = vi.fn().mockReturnValue({
-            download: mockDownload,
-        });
-        driver['containerClient'] = {
-            getBlobClient: mockBlobClient,
-        };
-    });
-    test('Uses blobClient at full path', async () => {
-        await driver.read(sample.path.input);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
-        expect(driver['containerClient'].getBlobClient).toHaveBeenCalledWith(sample.path.inputFull);
-    });
-    test('Calls download with undefined undefined when no range is passed', async () => {
-        await driver.read(sample.path.input);
-        expect(mockDownload).toHaveBeenCalledWith(undefined, undefined);
-    });
-    test('Calls download with offset if start range is provided', async () => {
-        await driver.read(sample.path.input, { start: sample.range.start });
-        expect(mockDownload).toHaveBeenCalledWith(sample.range.start, undefined);
-    });
-    test('Calls download with count if end range is provided', async () => {
-        await driver.read(sample.path.input, { end: sample.range.end });
-        expect(mockDownload).toHaveBeenCalledWith(undefined, sample.range.end);
-    });
-    test('Calls download with offset and count if start and end ranges are provided', async () => {
-        await driver.read(sample.path.input, sample.range);
-        expect(mockDownload).toHaveBeenCalledWith(sample.range.start, sample.range.end - sample.range.start);
-    });
-    test('Throws error when no readable stream is returned', async () => {
-        mockDownload.mockResolvedValue({ readableStreamBody: undefined });
-        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}"`);
-        }
-    });
-});
-describe('#write', () => {
-    let mockUploadStream;
-    let mockBlockBlobClient;
-    beforeEach(() => {
-        mockUploadStream = vi.fn();
-        mockBlockBlobClient = vi.fn().mockReturnValue({
-            uploadStream: mockUploadStream,
-        });
-        driver['containerClient'] = {
-            getBlockBlobClient: mockBlockBlobClient,
-        };
-        vi.mocked(isReadableStream).mockReturnValue(true);
-    });
-    test('Gets BlockBlobClient for file path', async () => {
-        await driver.write(sample.path.input, sample.stream);
-        expect(mockBlockBlobClient).toHaveBeenCalledWith(sample.path.inputFull);
-    });
-    test('Uploads stream through uploadStream', async () => {
-        await driver.write(sample.path.input, sample.stream);
-        expect(mockUploadStream).toHaveBeenCalledWith(sample.stream, undefined, undefined, {
-            blobHTTPHeaders: { blobContentType: 'application/octet-stream' },
-        });
-    });
-    test('Allows optional mime type to be set', async () => {
-        await driver.write(sample.path.input, sample.stream, sample.file.type);
-        expect(mockUploadStream).toHaveBeenCalledWith(sample.stream, undefined, undefined, {
-            blobHTTPHeaders: { blobContentType: sample.file.type },
-        });
-    });
-});
-describe('#delete', () => {
-    let mockDeleteIfExists;
-    beforeEach(() => {
-        mockDeleteIfExists = vi.fn().mockResolvedValue(true);
-        const mockBlockBlobClient = vi.fn().mockReturnValue({
-            deleteIfExists: mockDeleteIfExists,
-        });
-        driver['containerClient'] = {
-            getBlockBlobClient: mockBlockBlobClient,
-        };
-    });
-    test('Uses blobClient at full path', async () => {
-        await driver.delete(sample.path.input);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
-        expect(driver['containerClient'].getBlockBlobClient).toHaveBeenCalledWith(sample.path.inputFull);
-    });
-    test('Returns delete result', async () => {
-        await driver.delete(sample.path.input);
-        expect(mockDeleteIfExists).toHaveBeenCalled();
-    });
-});
-describe('#stat', () => {
-    beforeEach(() => {
-        const mockGetProperties = vi.fn().mockReturnValue({
-            contentLength: sample.file.size,
-            lastModified: sample.file.modified,
-        });
-        const mockBlobClient = vi.fn().mockReturnValue({
-            getProperties: mockGetProperties,
-        });
-        driver['containerClient'] = {
-            getBlobClient: mockBlobClient,
-        };
-    });
-    test('Uses blobClient at full path', async () => {
-        await driver.stat(sample.path.input);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
-        expect(driver['containerClient'].getBlobClient).toHaveBeenCalledWith(sample.path.inputFull);
-    });
-    test('Returns contentLength/lastModified as size/modified from getProperties', async () => {
-        const result = await driver.stat(sample.path.input);
-        expect(result).toStrictEqual({
-            size: sample.file.size,
-            modified: sample.file.modified,
-        });
-    });
-});
-describe('#exists', () => {
-    let mockExists;
-    beforeEach(() => {
-        mockExists = vi.fn().mockResolvedValue(true);
-        const mockBlockBlobClient = vi.fn().mockReturnValue({
-            exists: mockExists,
-        });
-        driver['containerClient'] = {
-            getBlockBlobClient: mockBlockBlobClient,
-        };
-    });
-    test('Uses blobClient at full path', async () => {
-        await driver.exists(sample.path.input);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
-        expect(driver['containerClient'].getBlockBlobClient).toHaveBeenCalledWith(sample.path.inputFull);
-    });
-    test('Returns exists result', async () => {
-        const result = await driver.exists(sample.path.input);
-        expect(mockExists).toHaveBeenCalled();
-        expect(result).toBe(true);
-    });
-});
-describe('#move', () => {
-    let mockDeleteIfExists;
-    let mockBlockBlobClient;
-    beforeEach(() => {
-        mockDeleteIfExists = vi.fn();
-        mockBlockBlobClient = vi.fn().mockReturnValue({
-            deleteIfExists: mockDeleteIfExists,
-        });
-        driver['containerClient'] = {
-            getBlockBlobClient: mockBlockBlobClient,
-        };
-        driver.copy = vi.fn();
-    });
-    test('Calls #copy with src and dest', async () => {
-        await driver.move(sample.path.src, sample.path.dest);
-        expect(driver.copy).toHaveBeenCalledWith(sample.path.src, sample.path.dest);
-    });
-    test('Deletes src file after copy is completed', async () => {
-        await driver.move(sample.path.src, sample.path.dest);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.src);
-        expect(mockBlockBlobClient).toHaveBeenCalledWith(sample.path.srcFull);
-        expect(mockDeleteIfExists).toHaveBeenCalledOnce();
-    });
-});
-describe('#copy', () => {
-    let mockPollUntilDone;
-    let mockBeginCopyFromUrl;
-    let mockBlockBlobClient;
-    let mockUrl;
-    beforeEach(() => {
-        mockPollUntilDone = vi.fn();
-        mockBeginCopyFromUrl = vi.fn().mockResolvedValue({
-            pollUntilDone: mockPollUntilDone,
-        });
-        mockUrl = randUrl();
-        mockBlockBlobClient = vi
-            .fn()
-            .mockReturnValueOnce({
-            url: mockUrl,
-        })
-            .mockReturnValueOnce({
-            beginCopyFromURL: mockBeginCopyFromUrl,
-        });
-        driver['containerClient'] = {
-            getBlockBlobClient: mockBlockBlobClient,
-        };
-    });
-    test('Gets BlockBlobClient for src and dest', async () => {
-        await driver.copy(sample.path.src, sample.path.dest);
-        expect(driver['fullPath']).toHaveBeenCalledTimes(2);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.src);
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.dest);
-        expect(mockBlockBlobClient).toHaveBeenCalledTimes(2);
-        expect(mockBlockBlobClient).toHaveBeenCalledWith(sample.path.srcFull);
-        expect(mockBlockBlobClient).toHaveBeenCalledWith(sample.path.destFull);
-    });
-    test('Calls beginCopyFromUrl with source url', async () => {
-        await driver.copy(sample.path.src, sample.path.dest);
-        expect(mockBeginCopyFromUrl).toHaveBeenCalledOnce();
-        expect(mockBeginCopyFromUrl).toHaveBeenCalledWith(mockUrl);
-    });
-    test('Waits for the polling to be done', async () => {
-        await driver.copy(sample.path.src, sample.path.dest);
-        expect(mockPollUntilDone).toHaveBeenCalledOnce();
-    });
-});
-describe('#list', () => {
-    let mockListBlobsFlat;
-    beforeEach(() => {
-        mockListBlobsFlat = vi.fn().mockReturnValue([]);
-        driver['containerClient'] = {
-            listBlobsFlat: mockListBlobsFlat,
-        };
-    });
-    test('Uses listBlobsFlat at default empty path', async () => {
-        await driver.list().next();
-        expect(driver['fullPath']).toHaveBeenCalledWith('');
-        expect(mockListBlobsFlat).toHaveBeenCalledWith({
-            prefix: '',
-        });
-    });
-    test('Allows for optional prefix', async () => {
-        await driver.list(sample.path.input).next();
-        expect(driver['fullPath']).toHaveBeenCalledWith(sample.path.input);
-        expect(mockListBlobsFlat).toHaveBeenCalledWith({
-            prefix: sample.path.inputFull,
-        });
-    });
-    test('Returns blob.name for each returned blob', async () => {
-        const mockFile = randFilePath();
-        mockListBlobsFlat.mockReturnValue([{ name: mockFile }]);
-        const output = [];
-        for await (const filepath of driver.list()) {
-            output.push(filepath);
-        }
-        expect(output).toStrictEqual([mockFile]);
-    });
-});