Creates a new instance of AzureFileStorage.
Initializes the connection to Azure Blob Storage using environment variables. Throws an error if any required environment variables are missing.
Private _accountThe Azure Storage account name
Private _blobBlobServiceClient for the Azure Storage account
Private _containerThe Azure Storage container name
Private _containerContainerClient for the specified container
Private _sharedAzure Storage SharedKeyCredential for authentication
Protected Readonly providerThe name of this storage provider, used in error messages
Checks if Azure Blob provider is properly configured. Returns true if account name and container name are present.
Copies a blob within Azure Blob Storage.
This method creates a copy of a blob at a new location without removing the original. It uses a SAS URL to provide the source blob access for the copy operation.
The name of the blob to copy
The name to assign to the copied blob
A Promise resolving to a boolean indicating success
// Create a backup copy of an important file
const copied = await azureStorage.CopyObject(
'documents/contract.pdf',
'backups/contract_2024-05-16.pdf'
);
if (copied) {
console.log('File copied successfully');
} else {
console.log('Failed to copy file');
}
Creates a directory (virtual) in Azure Blob Storage.
Since Azure Blob Storage doesn't have a native directory concept, this method creates a zero-byte blob with a trailing slash to simulate a directory. The blob has a special content type to indicate it's a directory.
The path of the directory to create
A Promise resolving to a boolean indicating success
// Create a new directory structure
const created = await azureStorage.CreateDirectory('documents/reports/annual/');
if (created) {
console.log('Directory created successfully');
} else {
console.log('Failed to create directory');
}
Creates a pre-authenticated download URL for a blob in Azure Blob Storage.
This method generates a Shared Access Signature (SAS) URL that allows for downloading a blob without needing the Azure Storage account credentials. The URL is valid for 10 minutes and can only be used for reading the specified blob.
The name of the blob to download (including any path/directory)
A Promise resolving to the download URL
// Generate a pre-authenticated download URL for a PDF file
const downloadUrl = await azureStorage.CreatePreAuthDownloadUrl('documents/report.pdf');
// The URL can be shared with users or used in applications for direct download
console.log(downloadUrl);
Creates a pre-authenticated upload URL for a blob in Azure Blob Storage.
This method generates a Shared Access Signature (SAS) URL that allows for uploading a blob without needing the Azure Storage account credentials. The URL is valid for 10 minutes and can only be used for writing the specified blob.
The name of the blob to upload (including any path/directory)
A Promise resolving to an object with the upload URL
// Generate a pre-authenticated upload URL for a PDF file
const { UploadUrl } = await azureStorage.CreatePreAuthUploadUrl('documents/report.pdf');
// The URL can be used with tools like curl to upload the file
// curl -H "x-ms-blob-type: BlockBlob" --upload-file report.pdf --url "https://accountname.blob.core.windows.net/container/documents/report.pdf?sastoken"
console.log(UploadUrl);
Deletes a directory (virtual) and optionally its contents from Azure Blob Storage.
For non-recursive deletion, this method simply deletes the directory placeholder blob. For recursive deletion, it lists all blobs with the directory path as prefix and deletes them all, including the directory placeholder.
The path of the directory to delete
If true, deletes all contents recursively (default: false)
A Promise resolving to a boolean indicating success
// Delete an empty directory
const deleted = await azureStorage.DeleteDirectory('documents/temp/');
// Delete a directory and all its contents
const recursivelyDeleted = await azureStorage.DeleteDirectory('documents/old_projects/', true);
Deletes a blob from Azure Blob Storage.
This method attempts to delete the specified blob if it exists. It returns true if the blob was successfully deleted or if it didn't exist.
The name of the blob to delete (including any path/directory)
A Promise resolving to a boolean indicating success
// Delete a temporary file
const deleted = await azureStorage.DeleteObject('temp/report-draft.pdf');
if (deleted) {
console.log('File successfully deleted');
} else {
console.log('Failed to delete file');
}
Checks if a directory (virtual) exists in Azure Blob Storage.
Since Azure Blob Storage doesn't have a native directory concept, this method checks for either:
The path of the directory to check
A Promise resolving to a boolean indicating if the directory exists
// Check if a directory exists before trying to save files to it
const exists = await azureStorage.DirectoryExists('documents/reports/');
if (!exists) {
console.log('Directory does not exist, creating it first');
await azureStorage.CreateDirectory('documents/reports/');
}
// Now safe to use the directory
await azureStorage.PutObject('documents/reports/new-report.pdf', fileData);
Downloads a blob's content from Azure Blob Storage.
This method retrieves the full content of a blob and returns it as a Buffer for processing in memory.
Object identifier (objectId and fullPath are equivalent for Azure Blob)
A Promise resolving to a Buffer containing the blob's data
Error if the blob doesn't exist or cannot be downloaded
try {
// For Azure Blob, objectId and fullPath are the same (both are the blob name)
const content = await azureStorage.GetObject({ fullPath: 'documents/config.json' });
// Or equivalently:
const content2 = await azureStorage.GetObject({ objectId: 'documents/config.json' });
// Parse the JSON content
const config = JSON.parse(content.toString('utf8'));
console.log('Configuration loaded:', config);
} catch (error) {
console.error('Failed to download file:', error.message);
}
Retrieves metadata for a specific blob in Azure Blob Storage.
This method fetches the properties of a blob without downloading its content, which is more efficient for checking file attributes like size, content type, and last modified date.
Object identifier (objectId and fullPath are equivalent for Azure Blob)
A Promise resolving to a StorageObjectMetadata object
Error if the blob doesn't exist or cannot be accessed
try {
// For Azure Blob, objectId and fullPath are the same (both are the blob name)
const metadata = await azureStorage.GetObjectMetadata({ fullPath: 'documents/report.pdf' });
// Or equivalently:
const metadata2 = await azureStorage.GetObjectMetadata({ objectId: 'documents/report.pdf' });
console.log(`File: ${metadata.name}`);
console.log(`Size: ${metadata.size} bytes`);
console.log(`Last modified: ${metadata.lastModified}`);
} catch (error) {
console.error('File does not exist or cannot be accessed');
}
Lists blobs with the specified prefix in Azure Blob Storage.
This method returns a list of blobs (files) and virtual directories under the specified path prefix. Since Azure Blob Storage doesn't have actual directories, this method simulates directory structure by looking at blob names with common prefixes and using the delimiter to identify "directory" paths.
The path prefix to list blobs from (e.g., 'documents/')
The character used to simulate directory structure, defaults to '/'
A Promise resolving to a StorageListResult containing objects and prefixes
// List all files and directories in the documents folder
const result = await azureStorage.ListObjects('documents/');
// Process files
for (const file of result.objects) {
console.log(`File: ${file.name}, Size: ${file.size}, Type: ${file.contentType}`);
}
// Process subdirectories
for (const dir of result.prefixes) {
console.log(`Directory: ${dir}`);
}
Moves a blob from one location to another within Azure Blob Storage.
Since Azure Blob Storage doesn't provide a native move operation, this method implements move as a copy followed by a delete operation. It first copies the blob to the new location, and if successful, deletes the blob from the original location.
The current name/path of the blob
The new name/path for the blob
A Promise resolving to a boolean indicating success
// Move a file from drafts to published folder
const success = await azureStorage.MoveObject(
'drafts/report.docx',
'published/final-report.docx'
);
if (success) {
console.log('File successfully moved');
} else {
console.log('Failed to move file');
}
Checks if a blob exists in Azure Blob Storage.
This method verifies the existence of a blob without downloading its content, which is efficient for validation purposes.
The name of the blob to check
A Promise resolving to a boolean indicating if the blob exists
// Check if a file exists before attempting to use it
const exists = await azureStorage.ObjectExists('documents/report.pdf');
if (exists) {
console.log('File exists, proceeding with download');
const content = await azureStorage.GetObject('documents/report.pdf');
// Process the content...
} else {
console.log('File does not exist');
}
Uploads data to a blob in Azure Blob Storage.
This method directly uploads a Buffer of data to a blob with the specified name. It's useful for server-side operations where you already have the data in memory.
The name to assign to the uploaded blob
The Buffer containing the data to upload
Optional contentType: stringOptional MIME type for the blob (inferred from name if not provided)
Optional metadata: Record<string, string>Optional key-value pairs of custom metadata to associate with the blob
A Promise resolving to a boolean indicating success
// Upload a text file
const content = Buffer.from('Hello, World!', 'utf8');
const uploaded = await azureStorage.PutObject(
'documents/hello.txt',
content,
'text/plain',
{ author: 'John Doe', department: 'Engineering' }
);
if (uploaded) {
console.log('File uploaded successfully');
} else {
console.log('Failed to upload file');
}
Search is not supported by Azure Blob Storage. Blob Storage is an object storage service without built-in search capabilities.
To search Azure Blob Storage objects, consider:
The search query (not used)
Optional options: FileSearchOptionsSearch options (not used)
UnsupportedOperationError always
Private _getPrivate Creates a BlobClient for the specified object.
This is a helper method used internally to get a BlobClient instance for a specific blob (file) in the container.
The name of the blob for which to create a client
A BlobClient instance for the specified blob
Private _normalizePrivate Normalizes a directory path to ensure it ends with a slash.
This is a helper method used internally to ensure consistency in directory path representation. Azure Blob Storage doesn't have actual directories, so we use a trailing slash to simulate them.
The directory path to normalize
The normalized path with a trailing slash
Optional initialization method for storage providers that require async setup.
This method can be overridden by subclasses that need to perform async initialization after construction, such as setting up access tokens, establishing connections, or verifying permissions.
The default implementation does nothing and resolves immediately. Storage provider implementations should override this method if they need to perform async setup.
A Promise that resolves when initialization is complete.
// In a specific provider implementation:
public async initialize(): Promise<void> {
// Set up OAuth tokens or other async initialization
await this.refreshAccessToken();
await this.verifyBucketAccess();
}
// Usage:
const storage = new MyStorageProvider();
await storage.initialize();
// Now the provider is ready to use
Protected throwHelper method to throw an UnsupportedOperationError with appropriate context. This method simplifies implementation of methods not supported by specific providers.
The name of the method that is not supported
UnsupportedOperationError with information about the unsupported method and provider
Azure Blob Storage implementation of the FileStorageBase interface.
This class provides methods for interacting with Azure Blob Storage as a file storage provider. It implements all the abstract methods defined in FileStorageBase and handles Azure-specific authentication, authorization, and file operations.
It requires the following environment variables to be set:
Example