@cellaware/utils 8.11.19 → 8.11.21

package/dist/azure/cosmos.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Returns the current date time
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentDateTime(timeZone?: string): string;
+/**
+ * Returns the record's date time using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampDateTime(timeZone?: string): string;
+/**
+ * Returns the current year
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentYear(timeZone?: string): string;
+/**
+ * Returns the record's year using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampYear(timeZone?: string): string;
+/**
+ * Returns the current month
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentMonth(timeZone?: string): string;
+/**
+ * Returns the record's month using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampMonth(timeZone?: string): string;
+/**
+ * Returns the current day
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentDay(timeZone?: string): string;
+/**
+ * Returns the record's day using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampDay(timeZone?: string): string;
+/**
+ * Returns the record's hour using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampHour(timeZone?: string): string;
+/**
+ * Returns the record's minute using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampMinute(timeZone?: string): string;
+/**
+ * Returns the record's second using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosTimestampSecond(timeZone?: string): string;
+/**
+ * Returns a `WHERE` clause condition to retrieve records with a `_ts` of today
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentDayClause(timeZone?: string): string;
+/**
+ * Returns a `WHERE` clause condition to retrieve records with a `_ts` of this month
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentMonthClause(timeZone?: string): string;
+/**
+ * Returns a `WHERE` clause condition to retrieve records with a `_ts` of this year
+ *
+ * NOTE: default time zone is UTC
+ */
+export declare function getCosmosCurrentYearClause(timeZone?: string): string;
+export declare function _cosmosSelect(endpoint: string, key: string, databaseId: string, collectionId: string, partitionKey: string, query: string): Promise<any[]>;
+export declare function cosmosSelect(databaseId: string, collectionId: string, partitionKey: string, query: string): Promise<any[]>;
+export declare function _cosmosInsert(endpoint: string, key: string, databaseId: string, collectionId: string, partitionKey: string, data: any): Promise<boolean>;
+export declare function cosmosInsert(databaseId: string, collectionId: string, partitionKey: string, data: any): Promise<boolean>;
+/**
+ * Will delete **multiple** records if `query` returns multiple rows.
+ */
+export declare function _cosmosDelete(endpoint: string, key: string, databaseId: string, collectionId: string, partitionKey: string, query: string): Promise<boolean>;
+/**
+ * Will delete **multiple** records if `query` returns multiple rows.
+ */
+export declare function cosmosDelete(databaseId: string, collectionId: string, partitionKey: string, query: string): Promise<boolean>;
+/**
+ * Will only update a **single** record. If multiple records are returned from `query`, we will only update the first one.
+ */
+export declare function _cosmosUpdate(endpoint: string, key: string, databaseId: string, collectionId: string, partitionKey: string, query: string, data: any): Promise<boolean>;
+/**
+ * Will only update a **single** record. If multiple records are returned from `query`, we will only update the first one.
+ */
+export declare function cosmosUpdate(databaseId: string, collectionId: string, partitionKey: string, query: string, data: any): Promise<boolean>;
+/**
+ * Simply deletes an existing record(s) then inserts a new one.
+ */
+export declare function _cosmosUpsert(endpoint: string, key: string, databaseId: string, collectionId: string, partitionKey: string, query: string, data: any): Promise<boolean>;
+/**
+ * Simply deletes an existing record(s) then inserts a new one.
+ */
+export declare function cosmosUpsert(databaseId: string, collectionId: string, partitionKey: string, query: string, data: any): Promise<boolean>;

package/dist/azure/cosmos.js

@@ -0,0 +1,305 @@
+import { ConnectionMode, CosmosClient } from '@azure/cosmos';
+import { isDaylightSavingTime } from '../util.js';
+const COSMOS_CURRENT_DATETIME = `GetCurrentDateTime()`;
+const COSMOS_TIMESTAMP_DATETIME = `TimestampToDateTime(c._ts*1000)`;
+/**
+ * All Cosmos timestamps are UTC.
+ * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+ */
+const TIME_ZONE_OFFSETS = {
+    // North America:
+    'America/New_York': -5, 'America/New_York_DST': -4, // Eastern
+    'America/Chicago': -6, 'America/Chicago_DST': -5, // Central
+    'America/Denver': -7, 'America/Denver_DST': -6, // Mountain
+    'America/Phoenix': -7, // Mountain (no DST)
+    'America/Los_Angeles': -8, 'America/Los_Angeles_DST': -7, // Pacific
+    'America/Anchorage': -9, 'America/Anchorage_DST': -8, // Alaska
+    'Pacific/Honolulu': -10, // Hawaii (no DST)
+    // South America:
+    'America/Sao_Paulo': -3, // Brazil (DST mostly abolished)
+    'America/Buenos_Aires': -3, // Argentina
+    // Europe:
+    'Europe/London': 0, 'Europe/London_DST': 1, // UK
+    'Europe/Berlin': 1, 'Europe/Berlin_DST': 2, // Central Europe
+    'Europe/Moscow': 3, // Russia (no DST)
+    // Asia:
+    'Asia/Dubai': 4, // UAE
+    'Asia/Kolkata': 5.5, // India
+    'Asia/Shanghai': 8, // China
+    'Asia/Tokyo': 9, // Japan
+    'Asia/Singapore': 8,
+    // Australia:
+    'Australia/Sydney': 10, 'Australia/Sydney_DST': 11,
+    'Australia/Perth': 8,
+    // Africa:
+    'Africa/Johannesburg': 2,
+    'Africa/Lagos': 1
+};
+function getCosmosTimeZoneHourDiff(timeZone) {
+    let diff = 0;
+    if (!!timeZone) {
+        let lookupTimeZone = timeZone;
+        if (isDaylightSavingTime(timeZone)) {
+            lookupTimeZone += '_DST';
+        }
+        if (lookupTimeZone in TIME_ZONE_OFFSETS) {
+            diff = TIME_ZONE_OFFSETS[lookupTimeZone];
+        }
+    }
+    return diff;
+}
+/**
+ * Returns the current date time
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentDateTime(timeZone) {
+    return `DateTimeAdd("hh", ${getCosmosTimeZoneHourDiff(timeZone)}, ${COSMOS_CURRENT_DATETIME})`;
+}
+/**
+ * Returns the record's date time using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampDateTime(timeZone) {
+    return `DateTimeAdd("hh", ${getCosmosTimeZoneHourDiff(timeZone)}, ${COSMOS_TIMESTAMP_DATETIME})`;
+}
+/**
+ * Returns the current year
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentYear(timeZone) {
+    return `DateTimePart('yyyy', ${getCosmosCurrentDateTime(timeZone)})`;
+}
+/**
+ * Returns the record's year using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampYear(timeZone) {
+    return `DateTimePart('yyyy', ${getCosmosTimestampDateTime(timeZone)})`;
+}
+/**
+ * Returns the current month
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentMonth(timeZone) {
+    return `DateTimePart('mm', ${getCosmosCurrentDateTime(timeZone)})`;
+}
+/**
+ * Returns the record's month using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampMonth(timeZone) {
+    return `DateTimePart('mm', ${getCosmosTimestampDateTime(timeZone)})`;
+}
+/**
+ * Returns the current day
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentDay(timeZone) {
+    return `DateTimePart('dd', ${getCosmosCurrentDateTime(timeZone)})`;
+}
+/**
+ * Returns the record's day using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampDay(timeZone) {
+    return `DateTimePart('dd', ${getCosmosTimestampDateTime(timeZone)})`;
+}
+/**
+ * Returns the record's hour using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampHour(timeZone) {
+    return `DateTimePart('hh', ${getCosmosTimestampDateTime(timeZone)})`;
+}
+/**
+ * Returns the record's minute using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampMinute(timeZone) {
+    return `DateTimePart('mi', ${getCosmosTimestampDateTime(timeZone)})`;
+}
+/**
+ * Returns the record's second using the `_ts` field
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosTimestampSecond(timeZone) {
+    return `DateTimePart('ss', ${getCosmosTimestampDateTime(timeZone)})`;
+}
+/**
+ * Returns a `WHERE` clause condition to retrieve records with a `_ts` of today
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentDayClause(timeZone) {
+    return `DateTimeDiff('dd', ${getCosmosTimestampDateTime(timeZone)}, ${getCosmosCurrentDateTime(timeZone)}) = 0`;
+}
+/**
+ * Returns a `WHERE` clause condition to retrieve records with a `_ts` of this month
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentMonthClause(timeZone) {
+    return `DateTimeDiff('mm', ${getCosmosTimestampDateTime(timeZone)}, ${getCosmosCurrentDateTime(timeZone)}) = 0`;
+}
+/**
+ * Returns a `WHERE` clause condition to retrieve records with a `_ts` of this year
+ *
+ * NOTE: default time zone is UTC
+ */
+export function getCosmosCurrentYearClause(timeZone) {
+    return `DateTimeDiff('yyyy', ${getCosmosTimestampDateTime(timeZone)}, ${getCosmosCurrentDateTime(timeZone)}) = 0`;
+}
+export async function _cosmosSelect(endpoint, key, databaseId, collectionId, partitionKey, query) {
+    try {
+        const cosmosClient = new CosmosClient({
+            endpoint,
+            key,
+            connectionPolicy: { connectionMode: ConnectionMode.Gateway, enableEndpointDiscovery: false }
+        });
+        const { database } = await cosmosClient.databases.createIfNotExists({ id: databaseId });
+        const { container } = await database.containers.createIfNotExists({
+            id: collectionId,
+            partitionKey
+        });
+        const { resources } = await container.items.query({ query }).fetchAll();
+        return resources;
+    }
+    catch (err) {
+        throw new Error(`COSMOS: Select error: ${err.message}`);
+    }
+}
+export async function cosmosSelect(databaseId, collectionId, partitionKey, query) {
+    return _cosmosSelect(process.env.COSMOS_DB_ENDPOINT ?? '', process.env.COSMOS_DB_KEY ?? '', databaseId, collectionId, partitionKey, query);
+}
+export async function _cosmosInsert(endpoint, key, databaseId, collectionId, partitionKey, data) {
+    try {
+        const cosmosClient = new CosmosClient({
+            endpoint,
+            key,
+            connectionPolicy: { connectionMode: ConnectionMode.Gateway, enableEndpointDiscovery: false }
+        });
+        const { database } = await cosmosClient.databases.createIfNotExists({ id: databaseId });
+        const { container } = await database.containers.createIfNotExists({
+            id: collectionId,
+            partitionKey
+        });
+        await container.items.create(data);
+        return true;
+    }
+    catch (err) {
+        throw new Error(`COSMOS: Insert error: ${err.message}`);
+    }
+}
+export async function cosmosInsert(databaseId, collectionId, partitionKey, data) {
+    return _cosmosInsert(process.env.COSMOS_DB_ENDPOINT ?? '', process.env.COSMOS_DB_KEY ?? '', databaseId, collectionId, partitionKey, data);
+}
+/**
+ * Will delete **multiple** records if `query` returns multiple rows.
+ */
+export async function _cosmosDelete(endpoint, key, databaseId, collectionId, partitionKey, query) {
+    try {
+        const cosmosClient = new CosmosClient({
+            endpoint,
+            key,
+            connectionPolicy: { connectionMode: ConnectionMode.Gateway, enableEndpointDiscovery: false }
+        });
+        const { database } = await cosmosClient.databases.createIfNotExists({ id: databaseId });
+        const { container } = await database.containers.createIfNotExists({
+            id: collectionId,
+            partitionKey
+        });
+        const { resources } = await container.items.query({ query }).fetchAll();
+        // NOTE: need to remove the '/' at the beginning.
+        const partitionKeyColumn = partitionKey.startsWith('/') ? partitionKey.substring(1) : partitionKey;
+        resources.forEach(doc => {
+            container.item(doc.id, doc[partitionKeyColumn]).delete();
+        });
+        return true;
+    }
+    catch (err) {
+        throw new Error(`COSMOS: Delete error: ${err.message}`);
+    }
+}
+/**
+ * Will delete **multiple** records if `query` returns multiple rows.
+ */
+export async function cosmosDelete(databaseId, collectionId, partitionKey, query) {
+    return _cosmosDelete(process.env.COSMOS_DB_ENDPOINT ?? '', process.env.COSMOS_DB_KEY ?? '', databaseId, collectionId, partitionKey, query);
+}
+/**
+ * Will only update a **single** record. If multiple records are returned from `query`, we will only update the first one.
+ */
+export async function _cosmosUpdate(endpoint, key, databaseId, collectionId, partitionKey, query, data) {
+    try {
+        if (Array.isArray(data)) {
+            throw new Error('COSMOS: Input `data` cannot be an array');
+        }
+        const cosmosClient = new CosmosClient({
+            endpoint,
+            key,
+            connectionPolicy: { connectionMode: ConnectionMode.Gateway, enableEndpointDiscovery: false }
+        });
+        const { database } = await cosmosClient.databases.createIfNotExists({ id: databaseId });
+        const { container } = await database.containers.createIfNotExists({
+            id: collectionId,
+            partitionKey
+        });
+        const { resources } = await container.items.query({ query }).fetchAll();
+        // NOTE: need to remove the '/' at the beginning.
+        const partitionKeyColumn = partitionKey.startsWith('/') ? partitionKey.substring(1) : partitionKey;
+        if (resources.length > 0) {
+            const doc = resources[0];
+            // Data needs original `id` and partition key field.
+            data.id = doc.id;
+            data[partitionKeyColumn] = doc[partitionKeyColumn];
+            await container.item(doc.id, doc[partitionKeyColumn]).replace(data);
+            return true;
+        }
+        else {
+            console.log(`COSMOS: Update warning: No data found`);
+            return false;
+        }
+    }
+    catch (err) {
+        throw new Error(`COSMOS: Update error: ${err.message}`);
+    }
+}
+/**
+ * Will only update a **single** record. If multiple records are returned from `query`, we will only update the first one.
+ */
+export async function cosmosUpdate(databaseId, collectionId, partitionKey, query, data) {
+    return _cosmosUpdate(process.env.COSMOS_DB_ENDPOINT ?? '', process.env.COSMOS_DB_KEY ?? '', databaseId, collectionId, partitionKey, query, data);
+}
+/**
+ * Simply deletes an existing record(s) then inserts a new one.
+ */
+export async function _cosmosUpsert(endpoint, key, databaseId, collectionId, partitionKey, query, data) {
+    const delRes = await _cosmosDelete(endpoint, key, databaseId, collectionId, partitionKey, query);
+    if (!delRes) {
+        return delRes;
+    }
+    const insRes = await _cosmosInsert(endpoint, key, databaseId, collectionId, partitionKey, data);
+    return insRes;
+}
+/**
+ * Simply deletes an existing record(s) then inserts a new one.
+ */
+export async function cosmosUpsert(databaseId, collectionId, partitionKey, query, data) {
+    const delRes = await cosmosDelete(databaseId, collectionId, partitionKey, query);
+    if (!delRes) {
+        return delRes;
+    }
+    const insRes = await cosmosInsert(databaseId, collectionId, partitionKey, data);
+    return insRes;
+}

package/dist/azure/email.d.ts

@@ -0,0 +1,3 @@
+import { EmailAttachment, EmailClient, EmailContent } from "@azure/communication-email";
+export declare function initEmailClient(): EmailClient;
+export declare function emailSend(client: EmailClient, senderAddress: string, recipients: string[], content: EmailContent, attachments?: EmailAttachment[]): Promise<import("@azure/core-lro").PollerLike<import("@azure/core-lro").PollOperationState<import("@azure/communication-email").EmailSendResponse>, import("@azure/communication-email").EmailSendResponse>>;

package/dist/azure/email.js

@@ -0,0 +1,20 @@
+import { EmailClient } from "@azure/communication-email";
+export function initEmailClient() {
+    return new EmailClient(process.env.COMMUNICATION_SERVICES_CONNECTION_STRING ?? '');
+}
+export async function emailSend(client, senderAddress, recipients, content, attachments) {
+    const message = {
+        senderAddress,
+        content,
+        recipients: {
+            to: recipients.map(address => {
+                return {
+                    address,
+                    displayName: "Recipient",
+                };
+            }),
+        },
+        attachments
+    };
+    return client.beginSend(message);
+}

package/dist/azure/function.d.ts

@@ -0,0 +1,14 @@
+import { Readable } from "stream";
+export declare const AZURE_HEADER_FUNCTION_KEY = "x-functions-key";
+export declare const AZURE_HEADER_PRINCIPAL = "x-ms-client-principal";
+export declare function functionFetchJson(url: string, method: string, key: string, principal: string, body?: any): Promise<Response>;
+export declare function functionFetchJsonWithText(url: string, method: string, key: string, principal: string, text: string): Promise<Response>;
+export declare function functionFetchText(url: string, method: string, key: string, principal: string, body?: any): Promise<Response>;
+export declare function functionStreamJson(url: string, method: string, key: string, principal: string, body: any, errorBody: any): Promise<{
+    headers: {
+        "Content-Type": string;
+        "Cache-Control": string;
+        "Transfer-Encoding": string;
+    };
+    body: Readable;
+}>;

package/dist/azure/function.js

@@ -0,0 +1,124 @@
+import { Readable } from "stream";
+import { sleep } from "../util.js";
+export const AZURE_HEADER_FUNCTION_KEY = 'x-functions-key';
+export const AZURE_HEADER_PRINCIPAL = 'x-ms-client-principal';
+const STATUS_INTERNAL_SERVER_ERROR = 500;
+const STATUS_SERVICE_UNAVAILABLE = 503;
+const RETRY_SLEEP_MS = 3000;
+const MAX_RETRIES = 3;
+async function functionFetch(url, req) {
+    let res = new Response(null, { status: STATUS_SERVICE_UNAVAILABLE, statusText: 'Service Unavailable' });
+    let retryNum = 0;
+    do {
+        if (retryNum > 0) {
+            await sleep(RETRY_SLEEP_MS);
+        }
+        try {
+            res = await fetch(url, req);
+        }
+        catch (err) {
+            // if at max retries throw the error
+            if (retryNum === MAX_RETRIES) {
+                throw err;
+            }
+        }
+        retryNum++;
+    } while (retryNum < MAX_RETRIES &&
+        (res.status === STATUS_INTERNAL_SERVER_ERROR || res.status === STATUS_SERVICE_UNAVAILABLE));
+    return res;
+}
+async function functionStream(url, req, errorBody) {
+    let stream = new Readable();
+    stream._read = () => { };
+    fetch(url, req)
+        .then(async (res) => {
+        const body = res.body;
+        if (!!body) {
+            const reader = body.getReader();
+            let streamDone = false;
+            while (!streamDone) {
+                const { value, done } = await reader.read();
+                streamDone = done;
+                if (!!value) {
+                    const buf = Buffer.from(value);
+                    stream.push(buf.toString());
+                }
+            }
+            stream.push(null);
+        }
+    })
+        .catch(err => {
+        stream.push(JSON.stringify(errorBody));
+        stream.push(null);
+    });
+    return {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Transfer-Encoding": "chunked"
+        },
+        body: stream
+    };
+}
+export async function functionFetchJson(url, method, key, principal, body) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'x-functions-key': key,
+        'x-ms-client-principal': principal
+    };
+    let req = {
+        method,
+        headers
+    };
+    if (body != null) {
+        req.body = JSON.stringify(body);
+    }
+    return functionFetch(url, req);
+}
+export async function functionFetchJsonWithText(url, method, key, principal, text) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'x-functions-key': key,
+        'x-ms-client-principal': principal
+    };
+    let req = {
+        method,
+        headers,
+        body: text
+    };
+    return functionFetch(url, req);
+}
+export async function functionFetchText(url, method, key, principal, body) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/text',
+        'x-functions-key': key,
+        'x-ms-client-principal': principal
+    };
+    let req = {
+        method,
+        headers
+    };
+    if (body != null) {
+        req.body = JSON.stringify(body);
+    }
+    return functionFetch(url, req);
+}
+export async function functionStreamJson(url, method, key, principal, body, errorBody) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'x-functions-key': key,
+        'x-ms-client-principal': principal
+    };
+    let req = {
+        method,
+        headers
+    };
+    if (body != null) {
+        req.body = JSON.stringify(body);
+    }
+    return functionStream(url, req, errorBody);
+}

package/dist/azure/slot.d.ts

@@ -0,0 +1 @@
+export declare function slotIsProduction(): boolean;

package/dist/azure/slot.js

@@ -0,0 +1,4 @@
+const SLOT_PRODUCTION = 'Production';
+export function slotIsProduction() {
+    return (process.env.WEBSITE_SLOT_NAME ?? SLOT_PRODUCTION) === SLOT_PRODUCTION;
+}

package/dist/azure/storage.d.ts

@@ -0,0 +1,14 @@
+export declare function storageContainerCreate(containerClientId: string): Promise<void>;
+/**
+ * Stringifies `data` and uploads to blob storage.
+ *
+ * **Important:** `data` must not be a string.
+ */
+export declare function storageBlobUpload(containerClientId: string, blobId: string, data: any): Promise<void>;
+/**
+ * Parses string data downloaded from blob storage and returns JSON object/JSON array.
+ *
+ * **Important:** will return `undefined` if any issues or blob does not exist.
+ */
+export declare function storageBlobDownload(containerClientId: string, blobId: string): Promise<any>;
+export declare function storageBlobDelete(containerClientId: string, blobId: string): Promise<void>;

package/dist/azure/storage.js

@@ -0,0 +1,81 @@
+import { BlobServiceClient } from '@azure/storage-blob';
+function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on("data", (data) => {
+            chunks.push(Buffer.isBuffer(data) ? data : Buffer.from(data));
+        });
+        stream.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on("error", reject);
+    });
+}
+export async function storageContainerCreate(containerClientId) {
+    try {
+        const blobServiceClient = BlobServiceClient.fromConnectionString(process.env.STORAGE_CONNECTION_STRING ?? '');
+        const containerClient = blobServiceClient.getContainerClient(containerClientId);
+        await containerClient.create();
+    }
+    catch (err) {
+        console.log(`STORAGE: CONTAINER create error: ${err.message}`);
+    }
+}
+/**
+ * Stringifies `data` and uploads to blob storage.
+ *
+ * **Important:** `data` must not be a string.
+ */
+export async function storageBlobUpload(containerClientId, blobId, data) {
+    if (typeof data === 'string') {
+        throw new Error('STORAGE: Input `data` cannot be a string');
+    }
+    try {
+        const blobServiceClient = BlobServiceClient.fromConnectionString(process.env.STORAGE_CONNECTION_STRING ?? '');
+        const containerClient = blobServiceClient.getContainerClient(containerClientId);
+        const blockBlobClient = containerClient.getBlockBlobClient(blobId);
+        const str = JSON.stringify(data);
+        await blockBlobClient.upload(str, str.length);
+    }
+    catch (err) {
+        console.log(`STORAGE: BLOB upload error: ${err.message}`);
+    }
+}
+/**
+ * Parses string data downloaded from blob storage and returns JSON object/JSON array.
+ *
+ * **Important:** will return `undefined` if any issues or blob does not exist.
+ */
+export async function storageBlobDownload(containerClientId, blobId) {
+    if (!process.env.STORAGE_CONNECTION_STRING) {
+        console.log(`STORAGE: No connection string set`);
+        return undefined;
+    }
+    try {
+        const blobServiceClient = BlobServiceClient.fromConnectionString(process.env.STORAGE_CONNECTION_STRING ?? '');
+        const containerClient = blobServiceClient.getContainerClient(containerClientId);
+        const blockBlobClient = containerClient.getBlockBlobClient(blobId);
+        const downloadBlockBlobResponse = await blockBlobClient.download(0);
+        let data;
+        if (downloadBlockBlobResponse.readableStreamBody) {
+            let buf = await streamToBuffer(downloadBlockBlobResponse.readableStreamBody);
+            data = buf.toString();
+        }
+        return JSON.parse(data);
+    }
+    catch (err) {
+        console.log(`STORAGE: BLOB download error: ${err.message}`);
+    }
+    return undefined;
+}
+export async function storageBlobDelete(containerClientId, blobId) {
+    try {
+        const blobServiceClient = BlobServiceClient.fromConnectionString(process.env.STORAGE_CONNECTION_STRING ?? '');
+        const containerClient = blobServiceClient.getContainerClient(containerClientId);
+        const blockBlobClient = containerClient.getBlockBlobClient(blobId);
+        await blockBlobClient.delete();
+    }
+    catch (err) {
+        console.log(`STORAGE: BLOB delete error: ${err.message}`);
+    }
+}