@superfunctions/storage-azure 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# @superfunctions/storage-azure
+
+Azure Blob Storage adapter for `@superfunctions/storage`.
+
+## Installation
+
+```bash
+npm install @superfunctions/storage-azure
+```
+
+## Usage
+
+```typescript
+import { createAzureStorageAdapter } from '@superfunctions/storage-azure';
+
+const connectionStringAdapter = createAzureStorageAdapter({
+  containerName: 'my-container',
+  connectionString: process.env.AZURE_STORAGE_CONNECTION_STRING,
+});
+
+// Or use account name and key
+const accountKeyAdapter = createAzureStorageAdapter({
+  containerName: 'my-container',
+  accountName: 'myaccount',
+  accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY,
+});
+
+// Or use SAS token
+const sasTokenAdapter = createAzureStorageAdapter({
+  containerName: 'my-container',
+  accountName: 'myaccount',
+  sasToken: process.env.AZURE_STORAGE_SAS_TOKEN,
+});
+```
+
+## Features
+
+- ✅ Signed upload URLs (SAS tokens)
+- ✅ Signed download URLs (SAS tokens)
+- ✅ Multipart uploads (Azure block blobs)
+- ✅ Proxy streaming upload
+- ✅ Proxy streaming download
+
+## Azure Block Blob Semantics
+
+Azure Blob Storage uses "block blobs" with "block IDs" instead of S3-style multipart uploads. This adapter maps:
+
+- **uploadId**: Azure commitment placeholder (client-generated)
+- **partNumber**: Mapped to block ID (base64-encoded)
+- **etag**: Block ID returned as the ETag for consistency
+
+When completing a multipart upload, the adapter commits all blocks to finalize the blob.
+
+## License
+
+MIT

package/dist/adapter.d.ts

@@ -0,0 +1,10 @@
+import type { StorageAdapter } from '@superfunctions/storage';
+export interface AzureStorageConfig {
+    containerName: string;
+    connectionString?: string;
+    accountName?: string;
+    accountKey?: string;
+    sasToken?: string;
+    endpoint?: string;
+}
+export declare function createAzureStorageAdapter(config: AzureStorageConfig): StorageAdapter;

package/dist/adapter.js

@@ -0,0 +1,306 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { PassThrough } from 'node:stream';
+import { BlobServiceClient, StorageSharedKeyCredential, BlobSASPermissions, generateBlobSASQueryParameters, SASProtocol, } from '@azure/storage-blob';
+import { assertMultipartParts, createNotFoundError, isNotFoundError, } from '@superfunctions/storage/internal/errors';
+function toAzureUploadError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function normalizeSasToken(sasToken) {
+    return sasToken.replace(/^\?+/, '');
+}
+function encodeUploadId(key) {
+    return Buffer.from(JSON.stringify({
+        key,
+        sessionId: randomUUID(),
+    }), 'utf8').toString('base64');
+}
+function decodeUploadId(uploadId) {
+    const decoded = Buffer.from(uploadId, 'base64').toString('utf8');
+    try {
+        const parsed = JSON.parse(decoded);
+        if (typeof parsed.key === 'string' &&
+            parsed.key.length > 0 &&
+            typeof parsed.sessionId === 'string' &&
+            parsed.sessionId.length > 0) {
+            return {
+                key: parsed.key,
+                sessionId: parsed.sessionId,
+            };
+        }
+    }
+    catch {
+        // Fall through to support legacy uploadIds that were just base64(key).
+    }
+    if (decoded.length > 0) {
+        return {
+            key: decoded,
+            sessionId: uploadId,
+        };
+    }
+    throw new Error('Invalid Azure multipart uploadId');
+}
+function createContainerClient(config) {
+    const { containerName, connectionString, accountName, accountKey, sasToken, endpoint } = config;
+    if (connectionString) {
+        const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+        const containerClient = blobServiceClient.getContainerClient(containerName);
+        // Extract account name and credential from connection string for SAS generation
+        const accountNameMatch = connectionString.match(/AccountName=([^;]+)/);
+        const accountKeyMatch = connectionString.match(/AccountKey=([^;]+)/);
+        const extractedAccountName = accountNameMatch?.[1];
+        const extractedAccountKey = accountKeyMatch?.[1];
+        const credential = extractedAccountName && extractedAccountKey
+            ? new StorageSharedKeyCredential(extractedAccountName, extractedAccountKey)
+            : undefined;
+        return { containerClient, credential, accountName: extractedAccountName };
+    }
+    if (accountName && accountKey) {
+        const credential = new StorageSharedKeyCredential(accountName, accountKey);
+        const blobServiceClient = new BlobServiceClient(endpoint || `https://${accountName}.blob.core.windows.net`, credential);
+        const containerClient = blobServiceClient.getContainerClient(containerName);
+        return { containerClient, credential, accountName };
+    }
+    if (accountName && sasToken) {
+        const blobServiceClient = new BlobServiceClient(`${endpoint || `https://${accountName}.blob.core.windows.net`}?${normalizeSasToken(sasToken)}`);
+        const containerClient = blobServiceClient.getContainerClient(containerName);
+        return { containerClient, accountName };
+    }
+    throw new Error('Azure storage config requires either connectionString or (accountName + accountKey) or (accountName + sasToken)');
+}
+function generateBlockId(uploadId, partNumber) {
+    return createHash('sha256')
+        .update(`${uploadId}:${String(partNumber).padStart(6, '0')}`, 'utf8')
+        .digest('base64');
+}
+export function createAzureStorageAdapter(config) {
+    const { containerClient, credential, accountName } = createContainerClient(config);
+    const supportsSignedUrls = Boolean(credential && accountName);
+    const capabilities = {
+        signedUploadUrls: supportsSignedUrls,
+        signedDownloadUrls: supportsSignedUrls,
+        multipart: supportsSignedUrls,
+        proxyStreamingUpload: true,
+        proxyStreamingDownload: true,
+    };
+    // Stateless adapter: no activeUploads map
+    return {
+        name: 'azure',
+        capabilities,
+        async statObject(input) {
+            try {
+                const blobClient = containerClient.getBlobClient(input.key);
+                const properties = await blobClient.getProperties();
+                return {
+                    key: input.key,
+                    size: properties.contentLength ?? 0,
+                    contentType: properties.contentType,
+                    etag: properties.etag,
+                    lastModifiedAt: properties.lastModified?.toISOString(),
+                };
+            }
+            catch (err) {
+                if (isNotFoundError(err, { statusCode: 404, stringCodes: ['BlobNotFound'] })) {
+                    throw createNotFoundError();
+                }
+                throw err;
+            }
+        },
+        async deleteObject(input) {
+            const blobClient = containerClient.getBlobClient(input.key);
+            await blobClient.deleteIfExists();
+        },
+        async signUploadUrl(input) {
+            if (!credential || !accountName) {
+                throw new Error('SAS URL generation requires accountName and credential (accountKey)');
+            }
+            const blobClient = containerClient.getBlobClient(input.key);
+            const blockBlobClient = blobClient.getBlockBlobClient();
+            const startsOn = new Date();
+            const expiresOn = new Date(startsOn.getTime() + input.expiresInSeconds * 1000);
+            const permissions = BlobSASPermissions.parse('w'); // write
+            const sasToken = generateBlobSASQueryParameters({
+                containerName: config.containerName,
+                blobName: input.key,
+                permissions,
+                startsOn,
+                expiresOn,
+                protocol: SASProtocol.Https,
+                contentType: input.constraints?.contentType,
+            }, credential).toString();
+            const url = `${blockBlobClient.url}?${sasToken}`;
+            const headers = {
+                'x-ms-blob-type': 'BlockBlob',
+            };
+            if (input.constraints?.contentType) {
+                headers['x-ms-blob-content-type'] = input.constraints.contentType;
+            }
+            return { url, headers: Object.keys(headers).length > 0 ? headers : undefined };
+        },
+        async signDownloadUrl(input) {
+            if (!credential || !accountName) {
+                throw new Error('SAS URL generation requires accountName and credential (accountKey)');
+            }
+            const blobClient = containerClient.getBlobClient(input.key);
+            const startsOn = new Date();
+            const expiresOn = new Date(startsOn.getTime() + input.expiresInSeconds * 1000);
+            const permissions = BlobSASPermissions.parse('r'); // read
+            const sasToken = generateBlobSASQueryParameters({
+                containerName: config.containerName,
+                blobName: input.key,
+                permissions,
+                startsOn,
+                expiresOn,
+                protocol: SASProtocol.Https,
+                contentType: input.constraints?.responseContentType,
+            }, credential).toString();
+            const url = `${blobClient.url}?${sasToken}`;
+            return { url };
+        },
+        async createMultipartUpload(input) {
+            const uploadId = encodeUploadId(input.key);
+            return { uploadId };
+        },
+        async signMultipartUploadPartUrl(input) {
+            if (!credential || !accountName) {
+                throw new Error('SAS URL generation requires accountName and credential (accountKey)');
+            }
+            // Verify uploadId matches key (stateless check)
+            const decodedUpload = decodeUploadId(input.uploadId);
+            if (decodedUpload.key !== input.key) {
+                throw new Error(`Invalid uploadId for key: ${input.key}`);
+            }
+            const blockBlobClient = containerClient.getBlockBlobClient(input.key);
+            const blockId = generateBlockId(input.uploadId, input.partNumber);
+            const startsOn = new Date();
+            const expiresOn = new Date(startsOn.getTime() + input.expiresInSeconds * 1000);
+            const permissions = BlobSASPermissions.parse('w'); // write
+            const sasToken = generateBlobSASQueryParameters({
+                containerName: config.containerName,
+                blobName: input.key,
+                permissions,
+                startsOn,
+                expiresOn,
+                protocol: SASProtocol.Https,
+            }, credential).toString();
+            // The URL must include the blockid query parameter for PutBlock operation
+            const url = `${blockBlobClient.url}?comp=block&blockid=${encodeURIComponent(blockId)}&${sasToken}`;
+            return { url };
+        },
+        async completeMultipartUpload(input) {
+            assertMultipartParts(input.parts);
+            // Verify uploadId
+            const decodedUpload = decodeUploadId(input.uploadId);
+            if (decodedUpload.key !== input.key) {
+                throw new Error(`Invalid uploadId for key: ${input.key}`);
+            }
+            const blockBlobClient = containerClient.getBlockBlobClient(input.key);
+            // In Azure, the etag from each part is actually the blockId we generated
+            // Sort parts and commit blocks
+            const sortedParts = [...input.parts].sort((a, b) => a.partNumber - b.partNumber);
+            const blockList = sortedParts.map((part) => generateBlockId(input.uploadId, part.partNumber));
+            await blockBlobClient.commitBlockList(blockList);
+        },
+        async abortMultipartUpload(input) {
+            // Azure automatically garbage-collects uncommitted blocks after 7 days
+            // No explicit cleanup needed for stateless tracking
+        },
+        async openUploadStream(input) {
+            const blockBlobClient = containerClient.getBlockBlobClient(input.key);
+            const stream = new PassThrough();
+            let uploadError;
+            stream.on('error', (error) => {
+                uploadError = toAzureUploadError(error);
+            });
+            const uploadPromise = blockBlobClient.uploadStream(stream, 4 * 1024 * 1024, 5, {
+                blobHTTPHeaders: {
+                    blobContentType: input.contentType,
+                },
+            });
+            void uploadPromise.catch((error) => {
+                uploadError = toAzureUploadError(error);
+            });
+            return new WritableStream({
+                async write(chunk) {
+                    if (uploadError) {
+                        throw uploadError;
+                    }
+                    const buf = chunk instanceof Uint8Array ? Buffer.from(chunk) : chunk;
+                    if (stream.write(buf)) {
+                        return;
+                    }
+                    await new Promise((resolve, reject) => {
+                        const cleanup = () => {
+                            stream.off('drain', onDrain);
+                            stream.off('error', onError);
+                        };
+                        const onDrain = () => {
+                            cleanup();
+                            resolve();
+                        };
+                        const onError = (err) => {
+                            cleanup();
+                            reject(err);
+                        };
+                        stream.once('drain', onDrain);
+                        stream.once('error', onError);
+                    });
+                },
+                async close() {
+                    if (uploadError) {
+                        throw uploadError;
+                    }
+                    stream.end();
+                    await uploadPromise;
+                },
+                abort(reason) {
+                    stream.destroy(reason instanceof Error ? reason : new Error(String(reason)));
+                    void uploadPromise.catch(() => undefined);
+                },
+            });
+        },
+        async openDownloadStream(input) {
+            const blobClient = containerClient.getBlobClient(input.key);
+            try {
+                const exists = await blobClient.exists();
+                if (!exists) {
+                    const notFoundError = new Error('Object not found');
+                    notFoundError.code = 'STORAGE_NOT_FOUND';
+                    throw notFoundError;
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && 'code' in err && err.code === 'STORAGE_NOT_FOUND') {
+                    throw err;
+                }
+                throw err;
+            }
+            const downloadOptions = input.range
+                ? { offset: input.range.start, count: input.range.endInclusive - input.range.start + 1 }
+                : undefined;
+            const response = await blobClient.download(downloadOptions?.offset, downloadOptions?.count);
+            if (!response.readableStreamBody) {
+                throw new Error('No readable stream in download response');
+            }
+            const nodeStream = response.readableStreamBody;
+            return new ReadableStream({
+                start(controller) {
+                    nodeStream.on('data', (chunk) => {
+                        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+                        controller.enqueue(new Uint8Array(buffer));
+                    });
+                    nodeStream.on('end', () => {
+                        controller.close();
+                    });
+                    nodeStream.on('error', (err) => {
+                        controller.error(err);
+                    });
+                },
+                cancel() {
+                    if ('destroy' in nodeStream && typeof nodeStream.destroy === 'function') {
+                        nodeStream.destroy();
+                    }
+                },
+            });
+        },
+    };
+}

package/dist/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapter.test.js

@@ -0,0 +1,248 @@
+import { describe, it, expect } from 'vitest';
+import { createAzureStorageAdapter } from './adapter.js';
+import { runConformanceTests } from '@superfunctions/storage';
+describe('storage-azure adapter', () => {
+    describe('conformance', () => {
+        it('should pass conformance tests (method existence)', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const result = await runConformanceTests(adapter);
+            expect(result.ok).toBe(true);
+        });
+        it('should have correct capabilities', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            expect(adapter.capabilities).toEqual({
+                signedUploadUrls: true,
+                signedDownloadUrls: true,
+                multipart: true,
+                proxyStreamingUpload: true,
+                proxyStreamingDownload: true,
+            });
+        });
+    });
+    describe('adapter creation', () => {
+        it('should create adapter with connection string', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'my-container',
+                connectionString: 'DefaultEndpointsProtocol=https;AccountName=testaccount;AccountKey=dGVzdGtleQ==;EndpointSuffix=core.windows.net',
+            });
+            expect(adapter.name).toBe('azure');
+        });
+        it('should create adapter with account name and key', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'my-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            expect(adapter.name).toBe('azure');
+        });
+        it('should create adapter with account name and SAS token', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'my-container',
+                accountName: 'testaccount',
+                sasToken: 'sv=2020-08-04&ss=b&srt=sco&sp=rwdlac&se=2025-01-01T00:00:00Z&st=2024-01-01T00:00:00Z&spr=https&sig=signature',
+            });
+            expect(adapter.name).toBe('azure');
+        });
+        it('should create adapter with custom endpoint', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'my-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+                endpoint: 'https://custom-endpoint.blob.core.windows.net',
+            });
+            expect(adapter.name).toBe('azure');
+        });
+        it('should throw error with incomplete config', () => {
+            expect(() => {
+                createAzureStorageAdapter({
+                    containerName: 'my-container',
+                });
+            }).toThrow('Azure storage config requires either connectionString or (accountName + accountKey) or (accountName + sasToken)');
+        });
+    });
+    describe('multipart methods', () => {
+        it('should have multipart methods (Azure block blob semantics)', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            expect(adapter.createMultipartUpload).toBeDefined();
+            expect(adapter.signMultipartUploadPartUrl).toBeDefined();
+            expect(adapter.completeMultipartUpload).toBeDefined();
+            expect(adapter.abortMultipartUpload).toBeDefined();
+        });
+        it('should generate stateless uploadId (base64 of key)', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const key = 'test-file.bin';
+            const result = await adapter.createMultipartUpload({
+                key,
+                contentType: 'application/octet-stream',
+            });
+            const decoded = JSON.parse(Buffer.from(result.uploadId, 'base64').toString('utf8'));
+            expect(decoded.key).toBe(key);
+            expect(decoded.sessionId).toEqual(expect.any(String));
+        });
+        it('should generate unique uploadIds per multipart session for the same key', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const first = await adapter.createMultipartUpload({ key: 'test-file.bin' });
+            const second = await adapter.createMultipartUpload({ key: 'test-file.bin' });
+            expect(first.uploadId).not.toBe(second.uploadId);
+        });
+        it('still accepts legacy base64(key) uploadIds even when the key is valid JSON', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const key = 'null';
+            const legacyUploadId = Buffer.from(key).toString('base64');
+            const part = await adapter.signMultipartUploadPartUrl({
+                key,
+                uploadId: legacyUploadId,
+                partNumber: 1,
+                expiresInSeconds: 900,
+            });
+            expect(part.url).toContain('blockid=');
+        });
+    });
+    describe('signed URL methods', () => {
+        it('should have signed URL methods', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            expect(adapter.signUploadUrl).toBeDefined();
+            expect(adapter.signDownloadUrl).toBeDefined();
+        });
+        it('should throw error when generating SAS without credentials', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                sasToken: 'existing-token',
+            });
+            await expect(async () => {
+                await adapter.signUploadUrl({
+                    key: 'test.txt',
+                    expiresInSeconds: 900,
+                });
+            }).rejects.toThrow('SAS URL generation requires accountName and credential (accountKey)');
+        });
+        it('returns the required blob type header for signed uploads', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const result = await adapter.signUploadUrl({
+                key: 'test.txt',
+                expiresInSeconds: 900,
+            });
+            expect(result.headers).toMatchObject({
+                'x-ms-blob-type': 'BlockBlob',
+            });
+        });
+        it('disables signed-url capabilities when only a SAS token is configured', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                sasToken: '?existing-token',
+            });
+            expect(adapter.capabilities).toMatchObject({
+                signedUploadUrls: false,
+                signedDownloadUrls: false,
+                multipart: false,
+            });
+        });
+    });
+    describe('proxy streaming methods', () => {
+        it('should have proxy streaming methods', () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            expect(adapter.openUploadStream).toBeDefined();
+            expect(adapter.openDownloadStream).toBeDefined();
+        });
+    });
+    describe('block blob semantics', () => {
+        it('should map part numbers to block IDs', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const key = 'test-multipart.bin';
+            const { uploadId } = await adapter.createMultipartUpload({
+                key,
+            });
+            // Sign part 1
+            const part1 = await adapter.signMultipartUploadPartUrl({
+                key,
+                uploadId,
+                partNumber: 1,
+                expiresInSeconds: 900,
+            });
+            // URL should contain blockid parameter
+            expect(part1.url).toContain('comp=block');
+            expect(part1.url).toContain('blockid=');
+        });
+        it('TV-STORAGE-AZURE-STATELESS-001: should allow cross-instance multipart operations', async () => {
+            const config = {
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            };
+            const adapterA = createAzureStorageAdapter(config);
+            const adapterB = createAzureStorageAdapter(config);
+            const key = 'stateless-test.bin';
+            // Create with A
+            const { uploadId } = await adapterA.createMultipartUpload({
+                key,
+                contentType: 'application/octet-stream',
+            });
+            // Sign with B
+            const part = await adapterB.signMultipartUploadPartUrl({
+                key,
+                uploadId,
+                partNumber: 1,
+                expiresInSeconds: 900,
+            });
+            expect(part.url).toBeDefined();
+            expect(part.url).toContain('blockid=');
+        });
+        it('should reject invalid uploadId', async () => {
+            const adapter = createAzureStorageAdapter({
+                containerName: 'test-container',
+                accountName: 'testaccount',
+                accountKey: 'dGVzdGtleQ==',
+            });
+            const key = 'test-file.bin';
+            const badUploadId = Buffer.from('wrong-key').toString('base64');
+            await expect(adapter.signMultipartUploadPartUrl({
+                key,
+                uploadId: badUploadId,
+                partNumber: 1,
+                expiresInSeconds: 900,
+            })).rejects.toThrow(`Invalid uploadId for key: ${key}`);
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './adapter.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './adapter.js';

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@superfunctions/storage-azure",
+  "version": "0.1.0",
+  "description": "Azure Blob Storage adapter for @superfunctions/storage",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "keywords": ["storage", "azure", "azure-blob-storage", "superfunctions"],
+  "author": "21n",
+  "license": "MIT",
+  "bugs": { "url": "https://github.com/21nCo/super-functions/issues" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/21nCo/super-functions.git",
+    "directory": "packages/storage-azure"
+  },
+  "publishConfig": { "access": "public" },
+  "dependencies": {
+    "@azure/storage-blob": "^12.18.0",
+    "@superfunctions/storage": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.2.4"
+  }
+}