Added loadNodeContent implementation and upgraded blob functionality to v12 SDK

gatsby-node.js

@@ -1,36 +1,8 @@
 const crypto = require("crypto");
-var azure = require('azure-storage');
 var path = require('path');
 var mkdirp = require('mkdirp');
 var { createFileNode } = require('gatsby-source-filesystem/create-file-node');
-
-const getValueWithDefault = (valueItem, defaultValue) => { return ((valueItem || { _: defaultValue })._ || defaultValue) }
-const getValue = valueItem => getValueWithDefault(valueItem, null)
-
-
-function makeTableNode(createNode, createNodeId, tableName, tableType) {
-  const item = {
-    name: tableName,
-    type: tableType
-  }
-  const nodeId = createNodeId('azureTable/' + tableName)
-  const nodeContent = JSON.stringify(item)
-  const nodeContentDigest = crypto
-    .createHash('md5')
-    .update(nodeContent)
-    .digest('hex')
-  const nodeData = Object.assign(item, {
-    id: nodeId,
-    parent: null,
-    children: [],
-    internal: {
-      type: 'azureTable',
-      content: nodeContent,
-      contentDigest: nodeContentDigest,
-    },
-  })
-  createNode(nodeData)
-}
+const { BlobServiceClient } = require("@azure/storage-blob");
 
 function makeContainerNode(createNode, createNodeId, containerName, localFolder) {
   const item = {
@@ -56,142 +28,68 @@ function makeContainerNode(createNode, createNodeId, containerName, localFolder)
   createNode(nodeData)
 }
 
-function downloadBlobFile(createNode, createNodeId, blobService, { container, name, localPath }) {
-  mkdirp.sync(path.dirname(localPath, createNodeId));
-  return new Promise(function (resolve, reject) {
-    try {
-      blobService.getBlobToLocalFile(container, name, localPath, function (error, result, response) {
-        if (!error) {
-          createFileNode(localPath, createNodeId, pluginOptions = {
-            name: "gatsby-source-azure-storage"
-          }).then(function (node) {
-
-              let publicUrl = blobService.getUrl(container, name)
-              let nodeWithUrl = Object.assign({ url: publicUrl}, node)
-              createNode(nodeWithUrl)
-
-              resolve()
-            }, function (failure) {
-              console.error(` Failed creating node from blob "${name}" from container "${container}"`)
-              reject(failure)
-            })
-        } else {
-          console.error(` Failed downloading blob "${name}" from container "${container}"`)
-          reject(error)
-        }
-      })
-    } catch (err) {
-      console.error(` Failed to download blob "${name}" from container "${container}"`)
-      reject(err)
-    }
-  })
-}
-
-function makeNodesFromQuery(createNode, createNodeId, tableService, tableName, typeName) {
-  return new Promise(function (resolve, reject) {
-    try {
-      const query = new azure.TableQuery()
-
-      function queryWithToken(token) {
-        tableService.queryEntities(tableName, query, token, function (error, result, response) {
-          if (!error) {
-            result.entries.forEach(value => {
-              const item = Object.entries(value).reduce((o, prop) => ({ ...o, [prop[0]]: getValue(prop[1]) }), {})
-              const nodeId = createNodeId(`${item.PartitionKey}/${item.RowKey}`)
-              const nodeContent = JSON.stringify(item)
-              const nodeContentDigest = crypto
-                .createHash('md5')
-                .update(nodeContent)
-                .digest('hex')
-              const nodeData = Object.assign(item, {
-                id: nodeId,
-                parent: null,
-                children: [],
-                internal: {
-                  type: typeName,
-                  content: nodeContent,
-                  contentDigest: nodeContentDigest,
-                },
-              })
-              createNode(nodeData)
-            })
-
-            if (result.continuationToken == null) {
-              resolve()
-            } else {
-              queryWithToken(result.continuationToken)
-            }
-          } else {
-            console.error(` Unable to query table "${tableName}"`)
-            reject(error)
-          }
-        })
-      }
-
-      queryWithToken(null)
-    } catch (err) {
-      console.error(` Error on table "${tableName}"`)
-      reject(err)
-    }
-  })
+async function downloadBlobFile(createNode, createNodeId, blobService, { container, name, localPath }) {
+  mkdirp.sync(path.dirname(localPath));
+  try {
+    const containerClient = blobService.getContainerClient(container);
+    const blockBlobClient = containerClient.getBlockBlobClient(name);
+    await blockBlobClient.downloadToFile(localPath);
+
+    const node = await createFileNode(localPath, createNodeId, {
+      name: "gatsby-source-azure-storage"
+    });
+
+    const publicUrl = blockBlobClient.url;
+    const nodeWithUrl = Object.assign({ url: publicUrl }, node);
+    createNode(nodeWithUrl);
+
+    return;
+  } catch (err) {
+    console.error(` Failed to download blob "${name}" from container "${container}"`);
+    throw err;
+  }
 }
 
-function makeNodesFromContainer(createNode, createNodeId, blobService, containerName, downloadFolder) {
-  return new Promise(function (resolve, reject) {
-    try {
-      function queryWithToken(token = null, nodes = []) {
-        blobService.listBlobsSegmented(containerName, token, function (error, result, response) {
-          if (!error) {
-            result.entries.forEach(value => {
-              const item = {
-                name: value.name,
-                container: value.container || containerName,
-                contentMD5: value.contentSettings.contentMD5,
-                creationTime: value.creationTime,
-                lastModified: value.lastModified,
-                blobType: value.blobType,
-                serverEncrypted: value.serverEncrypted,
-                localPath: (downloadFolder == null ? null : path.join(process.cwd(), downloadFolder, value.name))
-              }
-              const nodeId = createNodeId(`${value.name}/${value.contentSettings.contentMD5}`)
-              const nodeContent = JSON.stringify(item)
-              const nodeContentDigest = crypto
-                .createHash('md5')
-                .update(nodeContent)
-                .digest('hex')
-              const nodeData = Object.assign(item, {
-                id: nodeId,
-                parent: null,
-                children: [],
-                internal: {
-                  type: 'azureBlob',
-                  content: nodeContent,
-                  contentDigest: nodeContentDigest,
-                },
-              })
-              createNode(nodeData)
-
-              nodes.push(nodeData)
-            })
-
-            if (result.continuationToken == null) {
-              resolve(nodes)
-            } else {
-              queryWithToken(result.continuationToken, nodes)
-            }
-          } else {
-            console.error(` Unable to query container "${tableName}"`)
-            reject(error)
-          }
-        })
-      }
-
-      queryWithToken()
-    } catch (err) {
-      console.error(` Error on container "${containerName}"`)
-      reject(err)
+async function makeNodesFromContainer(createNode, createNodeId, containerClient, containerName, downloadFolder) {
+  try {
+    let nodes = [];
+    for await (const blob of containerClient.listBlobsFlat()) {
+      const item = {
+        name: blob.name,
+        container: containerName,
+        contentMD5: blob.properties.contentMD5,
+        creationTime: blob.properties.createdOn,
+        lastModified: blob.properties.lastModified,
+        blobType: blob.properties.blobType,
+        serverEncrypted: blob.properties.serverEncrypted,
+        localPath: downloadFolder ? path.join(process.cwd(), downloadFolder, blob.name) : null
+      };
+
+      const nodeId = createNodeId(`${item.name}/${blob.properties.contentMD5 || ''}`);
+      const nodeContent = JSON.stringify(item);
+      const nodeContentDigest = crypto
+        .createHash('md5')
+        .update(nodeContent)
+        .digest('hex');
+      const nodeData = Object.assign(item, {
+        id: nodeId,
+        parent: null,
+        children: [],
+        internal: {
+          type: 'azureBlob',
+          content: nodeContent,
+          contentDigest: nodeContentDigest,
+        },
+      });
+      createNode(nodeData);
+
+      nodes.push(nodeData);
     }
-  })
+    return nodes;
+  } catch (err) {
+    console.error(` Error on container "${containerName}"`);
+    throw err;
+  }
 }
 
 exports.sourceNodes = (
@@ -203,23 +101,15 @@ exports.sourceNodes = (
   // Gatsby adds a configOption that's not needed for this plugin, delete it
   delete configOptions.plugins
 
-  let tableService = azure.createTableService()
-  let blobService = azure.createBlobService()
-
-  let hasTables = configOptions.tables != null && configOptions.tables.length > 0
-  let tablePromises = hasTables
-    ? configOptions.tables.map(x => {
-      let typeName = (x.type || x.name)
-      makeTableNode(createNode, createNodeId, x.name, typeName)
-      return makeNodesFromQuery(createNode, createNodeId, tableService, x.name, typeName)
-    })
-    : []
+  const blobService = BlobServiceClient.fromConnectionString(process.env.AZURE_STORAGE_CONNECTION_STRING);
 
   let blobPromises = (configOptions.containers != null && configOptions.containers.length > 0)
     ? configOptions.containers.map(x => {
       let localFolder = (x.localFolder || configOptions.containerLocalFolder)
       makeContainerNode(createNode, createNodeId, x.name, localFolder)
-      let promiseNode = makeNodesFromContainer(createNode, createNodeId, blobService, x.name, localFolder)
+
+      let containerClient = blobService.getContainerClient(x.name);
+      let promiseNode = makeNodesFromContainer(createNode, createNodeId, containerClient, x.name, localFolder)
 
       if (localFolder == null) {
         return promiseNode
@@ -234,5 +124,5 @@ exports.sourceNodes = (
     })
     : []
 
-  return Promise.all(tablePromises.concat(blobPromises))
+  return Promise.all(blobPromises)
 }

index.js

@@ -1 +1,9 @@
-// no-op-lo-op
+"use strict";
+
+const fs = require(`fs-extra`);
+
+function loadNodeContent(fileNode) {
+  return fs.readFile(fileNode.absolutePath, `utf-8`);
+}
+
+exports.loadNodeContent = loadNodeContent;