@pi-r/azure 0.0.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 An Pham
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+### @pi-r/azure
+
+### LICENSE
+
+MIT

package/client/index.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.createBucketV2 = exports.createBucket = exports.createDatabaseClient = exports.createStorageClient = exports.validateDatabase = exports.validateStorage = void 0;
+const path = require("path");
+const types_1 = require("@e-mc/types");
+const util_1 = require("@e-mc/cloud/util");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+function validateStorage(credential) {
+    const env = process.env;
+    if (credential.accountName && credential.accountKey || credential.connectionString || credential.sharedAccessSignature || env.AZURE_TENANT_ID && env.AZURE_CLIENT_ID && env.AZURE_CLIENT_SECRET && (credential.accountName || env.AZURE_STORAGE_ACCOUNT)) {
+        return true;
+    }
+    return Module.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) && !!((credential.connectionString = env.AZURE_STORAGE_CONNECTION_STRING) || (credential.sharedAccessSignature = env.AZURE_STORAGE_SAS_TOKEN) || (credential.accountName = env.AZURE_STORAGE_ACCOUNT) && (credential.accountKey = env.AZURE_STORAGE_KEY));
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    return !!(data.name && data.table && (credential.endpoint && credential.key || Module.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) && (credential.endpoint = process.env.AZURE_COSMOS_ENDPOINT) && (credential.key = process.env.AZURE_COSMOS_KEY)));
+}
+exports.validateDatabase = validateDatabase;
+function createStorageClient(credential) {
+    let packageName = '';
+    try {
+        const { BlobServiceClient, StorageSharedKeyCredential } = require(packageName = '@azure/storage-blob');
+        const { accountName, accountKey, connectionString, sharedAccessSignature } = credential;
+        if (connectionString) {
+            credential.accountName || (credential.accountName = /AccountName=([^;]+);/.exec(connectionString)?.[1]);
+            return BlobServiceClient.fromConnectionString(connectionString);
+        }
+        if (sharedAccessSignature) {
+            credential.accountName || (credential.accountName = /^https:\/\/([a-z\d]+)\./.exec(sharedAccessSignature)?.[1]);
+            return new BlobServiceClient(sharedAccessSignature);
+        }
+        let azureCredential;
+        if (accountName && accountKey) {
+            azureCredential = new StorageSharedKeyCredential(accountName, accountKey);
+        }
+        else {
+            const { DefaultAzureCredential } = require(packageName = '@azure/identity');
+            azureCredential = new DefaultAzureCredential();
+        }
+        return new BlobServiceClient(`https://${accountName || process.env.AZURE_STORAGE_ACCOUNT}.blob.core.windows.net`, azureCredential);
+    }
+    catch (err) {
+        this.checkPackage(err, packageName, { passThrough: true });
+        throw err;
+    }
+}
+exports.createStorageClient = createStorageClient;
+function createDatabaseClient(credential) {
+    try {
+        const { CosmosClient } = require('@azure/cosmos');
+        return new CosmosClient(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, '@azure/cosmos', { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+async function createBucket(credential, bucket, publicRead, service = 'azure') {
+    return createBucketV2.call(this, credential, bucket, publicRead ? 'blob' : 'container', undefined, service);
+}
+exports.createBucket = createBucket;
+async function createBucketV2(credential, bucket, access, options, service = 'azure') {
+    switch (access) {
+        case 'blob':
+        case 'container':
+            break;
+        default:
+            access = undefined;
+            break;
+    }
+    const containerClient = createStorageClient.call(this, credential).getContainerClient(bucket);
+    const setAccessPolicy = () => containerClient.setAccessPolicy(access).catch(err => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure container" /* ERR_AZURE.CONFIGURE_CONTAINER */, bucket], err, { ...Cloud.LOG_CLOUD_WARN }));
+    if (await containerClient.exists().catch(() => false)) {
+        if (access) {
+            await setAccessPolicy();
+        }
+        return true;
+    }
+    options = { ...options };
+    if (access) {
+        options.access = access;
+    }
+    options.abortSignal = this.signal;
+    return containerClient.create(options)
+        .then(response => {
+        if (response.errorCode) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Container created with errors', bucket], (0, types_1.errorMessage)("Error code" /* ERR_MESSAGE.ERROR_CODE */, response.errorCode), { ...Cloud.LOG_CLOUD_WARN });
+        }
+        else {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Container created', bucket], response.requestId, { ...Cloud.LOG_CLOUD_COMMAND });
+        }
+        return true;
+    })
+        .catch(async (err) => {
+        if (err instanceof Error && err.code === 'ContainerAlreadyExists') {
+            if (access) {
+                await setAccessPolicy();
+            }
+            return true;
+        }
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to create container" /* ERR_AZURE.CREATE_CONTAINER */, bucket], err, { ...Cloud.LOG_CLOUD_FAIL });
+        return false;
+    });
+}
+exports.createBucketV2 = createBucketV2;
+function setBucketWebsite(credential, bucket, options, service = 'azure') {
+    const staticWebsite = { enabled: true };
+    if ((0, types_1.isString)(options.indexPage)) {
+        staticWebsite.indexDocument = path.basename(options.indexPage);
+    }
+    if ((0, types_1.isString)(options.indexPath)) {
+        staticWebsite.defaultIndexDocumentPath = Module.joinPath(bucket, options.indexPath);
+    }
+    if ((0, types_1.isString)(options.errorPath)) {
+        staticWebsite.errorDocument404Path = Module.joinPath(bucket, options.errorPath);
+    }
+    return createStorageClient.call(this, credential).setProperties({ staticWebsite })
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* VAL_CLOUD.CONFIGURE_BUCKET */, bucket], options, { ...Cloud.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(err => {
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure bucket" /* ERR_CLOUD.CONFIGURE_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        return false;
+    });
+}
+exports.setBucketWebsite = setBucketWebsite;
+function deleteObjects(credential, Bucket, service) {
+    return deleteObjectsV2.call(this, credential, Bucket, true, service);
+}
+exports.deleteObjects = deleteObjects;
+async function deleteObjectsV2(credential, bucket, recursive = true, service = 'azure') {
+    const containerClient = createStorageClient.call(this, credential).getContainerClient(bucket);
+    if (await containerClient.exists().catch(() => false)) {
+        try {
+            const tasks = [];
+            let fileCount = 0;
+            for await (const blob of containerClient.listBlobsFlat({ includeUncommitedBlobs: true })) {
+                if (!recursive && blob.name.indexOf('/') !== -1) {
+                    continue;
+                }
+                tasks.push(containerClient.deleteBlob(blob.name, { versionId: blob.versionId }).catch(() => { --fileCount; }));
+            }
+            fileCount = tasks.length;
+            return this.allSettled(tasks, ["Unable to delete blob" /* ERR_AZURE.DELETE_BLOB */, bucket], 64 /* LOG_TYPE.CLOUD */).then(() => {
+                const files = fileCount + ' files';
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [`Container emptied (${recursive ? 'recursive' : files})`, bucket], recursive ? files : '', { ...Cloud.LOG_CLOUD_COMMAND });
+            });
+        }
+        catch (err) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to list bucket" /* ERR_CLOUD.LIST_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        }
+    }
+}
+exports.deleteObjectsV2 = deleteObjectsV2;
+async function executeQuery(credential, data, sessionKey) {
+    return (await executeBatchQuery.call(this, credential, [data], sessionKey))[0] || [];
+}
+exports.executeQuery = executeQuery;
+async function executeBatchQuery(credential, batch, sessionKey) {
+    const length = batch.length;
+    const result = new Array(length);
+    const caching = length > 0 && this.hasCache(batch[0].service, sessionKey);
+    const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
+    let client;
+    const createClient = (name, table) => {
+        client || (client = createDatabaseClient.call(this, length === 1 ? credential : { ...credential }));
+        return client.database(name).container(table);
+    };
+    const closeClient = () => client?.dispose();
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, name, table, id, query, storedProcedureId, partitionKey, params, limit = 0, update, ignoreCache } = item;
+        if (!name || !table) {
+            closeClient();
+            throw (0, util_1.formatError)(item, name ? "Missing database table" /* ERR_DB.TABLE */ : "Missing database name" /* ERR_DB.NAME */);
+        }
+        const renewCache = ignoreCache === 0;
+        const getCache = (value) => {
+            if (ignoreCache === 1) {
+                return;
+            }
+            cacheValue.renewCache = renewCache;
+            return this.getQueryResult(service, credential, value, cacheValue);
+        };
+        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? name + '_' + table + '_' : '';
+        if (storedProcedureId && params) {
+            const { options } = item;
+            if (queryString && (rows = getCache(queryString += (partitionKey || '') + '_' + storedProcedureId + Module.asString(params, true) + Module.asString(options, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            const { statusCode, resource } = await createClient(name, table).scripts.storedProcedure(storedProcedureId).execute(partitionKey, params, options);
+            if (statusCode === 200 /* HTTP_STATUS.OK */) {
+                rows = Array.isArray(resource) ? resource : [resource];
+            }
+        }
+        else if (id) {
+            const { options } = item;
+            if (queryString) {
+                queryString += (partitionKey || '') + '_' + id + Module.asString(options, true);
+                if (!update && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            const db = createClient(name, table).item(id, partitionKey);
+            const { statusCode, resource } = update ? await db.patch(update, options) : await db.read(options);
+            if (statusCode === 200 /* HTTP_STATUS.OK */) {
+                rows = [resource];
+            }
+        }
+        else if (query) {
+            let { options } = item;
+            if (limit > 0) {
+                (options || (options = {})).maxItemCount = limit;
+            }
+            if (queryString && (rows = getCache(queryString += Module.asString(query, true) + Module.asString(options, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            rows = (await createClient(name, table).items.query(query, options).fetchAll()).resources;
+        }
+        else {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+        }
+        result[i] = this.setQueryResult(service, credential, queryString, rows, cacheValue);
+    }
+    closeClient();
+    return result;
+}
+exports.executeBatchQuery = executeBatchQuery;

package/download/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+function download(credential, service = 'azure') {
+    const blobServiceClient = client_1.createStorageClient.call(this, credential);
+    return (data, callback) => {
+        const { bucket: Bucket, download: target } = data;
+        const Key = target.filename;
+        if (!Bucket || !Key) {
+            callback((0, types_1.errorValue)('Missing property', !Bucket ? 'Container' : 'Name'));
+            return;
+        }
+        const location = Module.joinPath(Bucket, Key);
+        const blobClient = blobServiceClient.getContainerClient(Bucket);
+        blobClient.getBlockBlobClient(Key).downloadToBuffer()
+            .then(value => {
+            callback(null, value);
+            const deleteObject = target.deleteObject;
+            if (target.deleteObject) {
+                blobClient.delete((0, types_1.isPlainObject)(deleteObject) && (deleteObject.abortSignal = this.signal) ? deleteObject : undefined)
+                    .then(() => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* VAL_CLOUD.DELETE_FILE */, location, { ...Cloud.LOG_CLOUD_DELETE }))
+                    .catch((err) => {
+                    if (!(err instanceof Error && err.code === 'BlobNotFound')) {
+                        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, location], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: !!target.active });
+                    }
+                });
+            }
+        })
+            .catch(err => callback(err));
+    };
+}
+
+module.exports = download;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@pi-r/azure",
+  "version": "0.0.1",
+  "description": "Azure cloud functions for E-mc.",
+  "main": "client/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/pi-r.git",
+    "directory": "src/cloud/azure"
+  },
+  "keywords": [
+    "squared",
+    "e-mc",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/anpham6/pi-r#readme",
+  "dependencies": {
+    "@e-mc/cloud": "^0.4.0",
+    "@e-mc/module": "^0.4.0",
+    "@e-mc/types": "^0.4.0",
+    "@azure/cosmos": "^3.17.3",
+    "@azure/storage-blob": "^12.13.0"
+  }
+}

package/upload/index.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const client_1 = require("../client");
+const util_1 = require("@e-mc/cloud/util");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+const BUCKET_SESSION = new Set();
+const BUCKET_RESPONSE = {};
+const getBucketKey = (credential, bucket, acl = '') => Module.asString(credential, true) + bucket + '_' + acl;
+function upload(credential, service = 'azure') {
+    const blobServiceClient = client_1.createStorageClient.call(this, credential);
+    return async (data, callback) => {
+        var _a, _b;
+        const { bucket, localUri } = data;
+        const { pathname = '', fileGroup, contentType, metadata, endpoint, admin = {}, overwrite, options } = data.upload;
+        const containerClient = blobServiceClient.getContainerClient(bucket);
+        let filename = data.upload.filename || path.basename(localUri), bucketKey;
+        const cleanup = () => {
+            BUCKET_SESSION.delete(bucket);
+            if (bucketKey) {
+                delete BUCKET_RESPONSE[bucketKey];
+            }
+        };
+        const errorResponse = (err) => {
+            cleanup();
+            callback(err);
+        };
+        if (!BUCKET_SESSION.has(bucket)) {
+            const bucketAcl = admin.publicRead ? 'blob' : admin.acl;
+            const response = BUCKET_RESPONSE[_a = bucketKey = getBucketKey(credential, bucket, bucketAcl)] || (BUCKET_RESPONSE[_a] = client_1.createBucketV2.call(this, credential, bucket, bucketAcl, admin.configBucket?.create));
+            if (!await response) {
+                errorResponse(null);
+                return;
+            }
+            BUCKET_SESSION.add(bucket);
+        }
+        if (!overwrite) {
+            try {
+                const current = filename;
+                const next = (0, util_1.generateFilename)(filename);
+                let i = 0, exists;
+                do {
+                    if (i > 0) {
+                        [filename, exists] = next(i);
+                        if (!exists) {
+                            break;
+                        }
+                    }
+                    const name = pathname ? Module.joinPath(pathname, filename) : filename;
+                    for await (const blob of containerClient.listBlobsFlat({ includeUncommitedBlobs: true })) {
+                        if (blob.name === name) {
+                            exists = true;
+                            break;
+                        }
+                    }
+                } while (exists && ++i);
+                if (i > 0) {
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["File renamed" /* VAL_CLOUD.RENAME_FILE */, current], filename, { ...Cloud.LOG_CLOUD_WARN });
+                }
+            }
+            catch (err) {
+                errorResponse(err);
+                return;
+            }
+        }
+        const Key = [filename];
+        const Body = [data.buffer];
+        const ContentType = [contentType];
+        const addLog = (err) => err instanceof Error && this.addLog(this.statusType.WARN, err.message, service + ': ' + bucket);
+        if (fileGroup) {
+            for (const [content, ext, localFile] of fileGroup) {
+                try {
+                    Body.push(typeof content === 'string' ? fs.readFileSync(content) : content);
+                    Key.push(ext === '.map' && localFile ? path.basename(localFile) : filename + ext);
+                }
+                catch (err) {
+                    addLog(err);
+                }
+            }
+        }
+        for (let i = 0; i < Key.length; ++i) {
+            const first = i === 0;
+            if (this.aborted) {
+                if (first) {
+                    errorResponse((0, types_1.createAbortError)());
+                }
+                return;
+            }
+            const blobName = Module.joinPath(pathname, Key[i]);
+            const params = { ...options, abortSignal: this.signal };
+            if (first && metadata) {
+                params.metadata = metadata;
+            }
+            (_b = (params.blobHTTPHeaders || (params.blobHTTPHeaders = {}))).blobContentType || (_b.blobContentType = ContentType[i]);
+            containerClient.getBlockBlobClient(blobName).upload(Body[i], Body[i].byteLength, params)
+                .then(result => {
+                let requestUrl = result._response.request.url;
+                const url = endpoint ? Module.joinPath(endpoint, blobName) : Module.isFile(requestUrl = decodeURIComponent(requestUrl), 'http/s') ? requestUrl : Module.joinPath(`https://${credential.accountName}.blob.core.windows.net`, bucket, blobName);
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* VAL_CLOUD.UPLOAD_FILE */, url, { ...Cloud.LOG_CLOUD_UPLOAD });
+                if (first) {
+                    cleanup();
+                    callback(null, url);
+                }
+            })
+                .catch(err => {
+                if (first) {
+                    errorResponse(err);
+                }
+                else {
+                    addLog(err);
+                }
+            });
+        }
+    };
+}
+
+module.exports = upload;