@pi-r/azure 0.6.0 → 0.6.2

package/README.md

@@ -1,5 +1,7 @@
 ### @pi-r/azure
 
+https://e-mc.readthedocs.io/en/latest/cloud/azure.html
+
 ### LICENSE
 
 MIT

package/client/index.js

@@ -7,42 +7,51 @@ const cosmos = require("@azure/cosmos");
 const identity = require("@azure/identity");
 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)) {
+    if (credential.accountName && credential.accountKey || credential.connectionString || credential.sharedAccessSignature || env.AZURE_TENANT_ID && env.AZURE_CLIENT_ID && env.AZURE_CLIENT_SECRET) {
         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));
+    return Cloud.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)));
+    return !!(data.name && data.table && (credential.endpoint && credential.key || credential.username && credential.password && (credential.tenantId && credential.clientId || (credential.tenantId = process.env.AZURE_TENANT_ID) && (credential.clientId = process.env.AZURE_CLIENT_ID)) || Cloud.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) {
-    const { BlobServiceClient, StorageSharedKeyCredential } = storage;
-    const { accountName, accountKey, connectionString, sharedAccessSignature } = credential;
+    let { accountName, accountKey, connectionString, sharedAccessSignature } = credential;
     if (connectionString) {
-        credential.accountName || (credential.accountName = /AccountName=([^;]+);/.exec(connectionString)?.[1]);
-        return BlobServiceClient.fromConnectionString(connectionString);
+        if (!accountName) {
+            credential.accountName = /AccountName=([^;]+);/.exec(connectionString)?.[1];
+        }
+        return storage.BlobServiceClient.fromConnectionString(connectionString);
     }
+    const url = `https://${accountName || process.env.AZURE_STORAGE_ACCOUNT}.blob.core.windows.net`;
     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 {
-        azureCredential = new identity.DefaultAzureCredential();
+        if (accountName) {
+            if (!Cloud.isURL(sharedAccessSignature)) {
+                sharedAccessSignature = url + (!sharedAccessSignature.startsWith('?') ? '?' : '') + sharedAccessSignature;
+            }
+        }
+        else {
+            credential.accountName || (credential.accountName = /^https:\/\/([a-z\d]+)\./.exec(sharedAccessSignature)?.[1]);
+        }
+        return new storage.BlobServiceClient(sharedAccessSignature);
     }
-    return new BlobServiceClient(`https://${accountName || process.env.AZURE_STORAGE_ACCOUNT}.blob.core.windows.net`, azureCredential);
+    return new storage.BlobServiceClient(url, accountName && accountKey ? new storage.StorageSharedKeyCredential(accountName, accountKey) : new identity.DefaultAzureCredential());
 }
 exports.createStorageClient = createStorageClient;
 function createDatabaseClient(credential) {
+    if (credential.username && credential.password && credential.tenantId && credential.clientId) {
+        credential.aadCredentials = new identity.UsernamePasswordCredential(credential.username, credential.password, credential.tenantId, credential.clientId);
+        credential = { ...credential };
+        delete credential.username;
+        delete credential.password;
+        delete credential.tenantId;
+        delete credential.clientId;
+    }
     return new cosmos.CosmosClient(credential);
 }
 exports.createDatabaseClient = createDatabaseClient;
@@ -102,14 +111,20 @@ async function setBucketWebsite(credential, bucket, options, service = 'azure')
         staticWebsite.indexDocument = path.basename(indexPage);
     }
     if ((0, types_1.isString)(indexPath)) {
-        staticWebsite.defaultIndexDocumentPath = Module.joinPath(bucket, indexPath);
+        staticWebsite.defaultIndexDocumentPath = Cloud.joinPath(bucket, indexPath);
     }
     if ((0, types_1.isString)(errorPath)) {
-        staticWebsite.errorDocument404Path = Module.joinPath(bucket, errorPath);
+        staticWebsite.errorDocument404Path = Cloud.joinPath(bucket, 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 });
+        .then(response => {
+        const { requestId, errorCode } = response;
+        if (errorCode) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* VAL_CLOUD.CONFIGURE_BUCKET */ + ' with errors', bucket], (0, types_1.errorMessage)("Error code" /* ERR_MESSAGE.ERROR_CODE */, errorCode), { ...Cloud.LOG_CLOUD_WARN });
+        }
+        else {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* VAL_CLOUD.CONFIGURE_BUCKET */, bucket], requestId, { ...Cloud.LOG_CLOUD_COMMAND });
+        }
         return true;
     })
         .catch(err => {
@@ -129,15 +144,15 @@ async function deleteObjectsV2(credential, bucket, recursive = true, service = '
             const tasks = [];
             let fileCount = 0;
             for await (const blob of containerClient.listBlobsFlat({ includeUncommitedBlobs: true })) {
-                if (!recursive && blob.name.includes('/')) {
-                    continue;
+                if (recursive || !blob.name.includes('/')) {
+                    tasks.push(containerClient.deleteBlob(blob.name, { versionId: blob.versionId }).catch(() => {
+                        --fileCount;
+                    }));
                 }
-                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 });
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Container emptied' + (recursive ? ' (recursive)' : ''), bucket], fileCount + ' files', { ...Cloud.LOG_CLOUD_COMMAND });
             });
         }
         catch (err) {
@@ -157,7 +172,7 @@ async function executeBatchQuery(credential, batch, sessionKey) {
     const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
     let client;
     const createClient = (name, table) => {
-        client || (client = createDatabaseClient.call(this, length === 1 ? credential : { ...credential }));
+        client || (client = createDatabaseClient.call(this, credential));
         return client.database(name).container(table);
     };
     const closeClient = () => client?.dispose();
@@ -168,17 +183,17 @@ async function executeBatchQuery(credential, batch, sessionKey) {
             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) {
-                cacheValue.renewCache = renewCache;
+                cacheValue.renewCache = ignoreCache === 0;
                 return this.getQueryResult(service, credential, value, cacheValue);
             }
         };
-        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? name + '_' + table + '_' : '';
+        cacheValue.exclusiveOf = Array.isArray(ignoreCache) ? ignoreCache : undefined;
+        let rows, queryString = caching && ignoreCache !== true ? name + '_' + table + '_' : '';
         if (storedProcedureId && params) {
             const { options } = item;
-            if (queryString && (rows = getCache(queryString += Module.asString(partitionKey, true) + '_' + storedProcedureId + Module.asString(params, true) + Module.asString(options, true)))) {
+            if (queryString && (rows = getCache(queryString += Cloud.asString(partitionKey, true) + '_' + storedProcedureId + Cloud.asString(params, true) + Cloud.asString(options, true)))) {
                 result[i] = rows;
                 continue;
             }
@@ -190,7 +205,7 @@ async function executeBatchQuery(credential, batch, sessionKey) {
         else if (id) {
             const { options } = item;
             if (queryString) {
-                queryString += Module.asString(partitionKey, true) + '_' + id + Module.asString(options, true);
+                queryString += Cloud.asString(partitionKey, true) + '_' + id + Cloud.asString(options, true);
                 if (!update && (rows = getCache(queryString))) {
                     result[i] = rows;
                     continue;
@@ -202,20 +217,26 @@ async function executeBatchQuery(credential, batch, sessionKey) {
                 rows = [resource];
             }
         }
-        else if (query) {
+        else {
             let { options } = item;
+            if (partitionKey) {
+                (options || (options = {})).partitionKey = partitionKey;
+            }
             if (limit > 0) {
                 (options || (options = {})).maxItemCount = limit;
             }
-            if (queryString && (rows = getCache(queryString += Module.asString(query, true) + Module.asString(options, true)))) {
-                result[i] = rows;
-                continue;
+            if (query || (0, types_1.isPlainObject)(options)) {
+                if (queryString && (rows = getCache(queryString += (query ? Cloud.asString(query, true) : '') + Cloud.asString(options, true)))) {
+                    result[i] = rows;
+                    continue;
+                }
+                const items = createClient(name, table).items;
+                ({ resources: rows } = await (query ? items.query(query, options).fetchAll() : items.readAll(options).fetchAll()));
+            }
+            else {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
             }
-            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);
     }

package/download/index.js

@@ -20,7 +20,7 @@ function download(credential, service = 'azure') {
             callback(null, value);
             const deleteObject = target.deleteObject;
             if (deleteObject) {
-                blobClient.delete((0, types_1.isPlainObject)(deleteObject) && (deleteObject.abortSignal = this.signal) ? deleteObject : undefined)
+                blobClient.delete((0, types_1.isPlainObject)(deleteObject) ? (deleteObject.abortSignal = this.signal, deleteObject) : { abortSignal: this.signal })
                     .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')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/azure",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Azure cloud functions for E-mc.",
   "main": "client/index.js",
   "publishConfig": {
@@ -20,11 +20,11 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/cloud": "^0.8.0",
-    "@e-mc/module": "^0.8.0",
-    "@e-mc/types": "^0.8.0",
+    "@e-mc/cloud": "^0.8.2",
+    "@e-mc/module": "^0.8.2",
+    "@e-mc/types": "^0.8.2",
     "@azure/cosmos": "^4.0.0",
-    "@azure/identity": "^4.0.0",
+    "@azure/identity": "^4.0.1",
     "@azure/storage-blob": "^12.17.0"
   }
 }

package/upload/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
-const fs = require("fs");
 const util_1 = require("@e-mc/cloud/util");
 const types_1 = require("@e-mc/types");
 const Module = require("@e-mc/module");
@@ -84,15 +83,10 @@ function upload(credential, service = 'azure') {
         const Body = [data.buffer];
         const ContentType = [contentType];
         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);
-                }
-            }
+            const [key, body, type] = (0, util_1.createKeyAndBody)(filename, fileGroup, addLog);
+            Key.push(...key);
+            Body.push(...body);
+            ContentType.push(...type);
         }
         for (let i = 0; i < Key.length; ++i) {
             const first = i === 0;