@backstage/plugin-techdocs-node 1.2.0 → 1.2.1-next.0

package/dist/index.cjs.js

@@ -74,7 +74,9 @@ const lowerCaseEntityTripletInStoragePath = (originalPath) => {
     parts.shift();
   }
   if (parts.length <= 3) {
-    throw new Error(`Encountered file unmanaged by TechDocs ${originalPath}. Skipping.`);
+    throw new Error(
+      `Encountered file unmanaged by TechDocs ${originalPath}. Skipping.`
+    );
   }
   return lowerCaseEntityTriplet(parts.join(path__default["default"].posix.sep));
 };
@@ -205,7 +207,10 @@ const getMkdocsYml = async (inputDir) => {
       mkdocsYmlPath = path__default["default"].join(inputDir, "mkdocs.yml");
       mkdocsYmlFileString = await fs__default["default"].readFile(mkdocsYmlPath, "utf8");
     } catch (error) {
-      throw new errors.ForwardedError("Could not read MkDocs YAML config file mkdocs.yml or mkdocs.yaml for validation", error);
+      throw new errors.ForwardedError(
+        "Could not read MkDocs YAML config file mkdocs.yml or mkdocs.yaml for validation",
+        error
+      );
     }
   }
   return {
@@ -222,8 +227,10 @@ const validateMkdocsYaml = async (inputDir, mkdocsYmlFileString) => {
   }
   const parsedMkdocsYml = mkdocsYml;
   if (parsedMkdocsYml.docs_dir && !backendCommon.isChildPath(inputDir, path.resolve(inputDir, parsedMkdocsYml.docs_dir))) {
-    throw new Error(`docs_dir configuration value in mkdocs can't be an absolute directory or start with ../ for security reasons.
-       Use relative paths instead which are resolved relative to your mkdocs.yml file location.`);
+    throw new Error(
+      `docs_dir configuration value in mkdocs can't be an absolute directory or start with ../ for security reasons.
+       Use relative paths instead which are resolved relative to your mkdocs.yml file location.`
+    );
   }
   return parsedMkdocsYml.docs_dir;
 };
@@ -253,10 +260,12 @@ const patchIndexPreBuild = async ({
       logger.warn(`${path__default["default"].relative(inputDir, filePath)} not found.`);
     }
   }
-  logger.warn(`Could not find any techdocs' index file. Please make sure at least one of ${[
-    indexMdPath,
-    ...fallbacks
-  ].join(" ")} exists.`);
+  logger.warn(
+    `Could not find any techdocs' index file. Please make sure at least one of ${[
+      indexMdPath,
+      ...fallbacks
+    ].join(" ")} exists.`
+  );
 };
 const createOrUpdateMetadata = async (techdocsMetadataPath, logger) => {
   const techdocsMetadataDir = techdocsMetadataPath.split(path__default["default"].sep).slice(0, -1).join(path__default["default"].sep);
@@ -276,7 +285,9 @@ const createOrUpdateMetadata = async (techdocsMetadataPath, logger) => {
   }
   json.build_timestamp = Date.now();
   try {
-    json.files = (await getFileTreeRecursively(techdocsMetadataDir)).map((file) => file.replace(`${techdocsMetadataDir}${path__default["default"].sep}`, ""));
+    json.files = (await getFileTreeRecursively(techdocsMetadataDir)).map(
+      (file) => file.replace(`${techdocsMetadataDir}${path__default["default"].sep}`, "")
+    );
   } catch (err) {
     errors.assertError(err);
     json.files = [];
@@ -298,7 +309,9 @@ const patchMkdocsFile = async (mkdocsYmlPath, logger, updateAction) => {
     mkdocsYmlFileString = await fs__default["default"].readFile(mkdocsYmlPath, "utf8");
   } catch (error) {
     errors.assertError(error);
-    logger.warn(`Could not read MkDocs YAML config file ${mkdocsYmlPath} before running the generator: ${error.message}`);
+    logger.warn(
+      `Could not read MkDocs YAML config file ${mkdocsYmlPath} before running the generator: ${error.message}`
+    );
     return;
   }
   let mkdocsYml;
@@ -309,28 +322,44 @@ const patchMkdocsFile = async (mkdocsYmlPath, logger, updateAction) => {
     }
   } catch (error) {
     errors.assertError(error);
-    logger.warn(`Error in parsing YAML at ${mkdocsYmlPath} before running the generator. ${error.message}`);
+    logger.warn(
+      `Error in parsing YAML at ${mkdocsYmlPath} before running the generator. ${error.message}`
+    );
     return;
   }
   didEdit = updateAction(mkdocsYml);
   try {
     if (didEdit) {
-      await fs__default["default"].writeFile(mkdocsYmlPath, yaml__default["default"].dump(mkdocsYml, { schema: MKDOCS_SCHEMA }), "utf8");
+      await fs__default["default"].writeFile(
+        mkdocsYmlPath,
+        yaml__default["default"].dump(mkdocsYml, { schema: MKDOCS_SCHEMA }),
+        "utf8"
+      );
     }
   } catch (error) {
     errors.assertError(error);
-    logger.warn(`Could not write to ${mkdocsYmlPath} after updating it before running the generator. ${error.message}`);
+    logger.warn(
+      `Could not write to ${mkdocsYmlPath} after updating it before running the generator. ${error.message}`
+    );
     return;
   }
 };
 const patchMkdocsYmlPreBuild = async (mkdocsYmlPath, logger, parsedLocationAnnotation, scmIntegrations) => {
   await patchMkdocsFile(mkdocsYmlPath, logger, (mkdocsYml) => {
     if (!("repo_url" in mkdocsYml) && !("edit_uri" in mkdocsYml)) {
-      const result = getRepoUrlFromLocationAnnotation(parsedLocationAnnotation, scmIntegrations, mkdocsYml.docs_dir);
+      const result = getRepoUrlFromLocationAnnotation(
+        parsedLocationAnnotation,
+        scmIntegrations,
+        mkdocsYml.docs_dir
+      );
       if (result.repo_url || result.edit_uri) {
         mkdocsYml.repo_url = result.repo_url;
         mkdocsYml.edit_uri = result.edit_uri;
-        logger.info(`Set ${JSON.stringify(result)}. You can disable this feature by manually setting 'repo_url' or 'edit_uri' according to the MkDocs documentation at https://www.mkdocs.org/user-guide/configuration/#repo_url`);
+        logger.info(
+          `Set ${JSON.stringify(
+            result
+          )}. You can disable this feature by manually setting 'repo_url' or 'edit_uri' according to the MkDocs documentation at https://www.mkdocs.org/user-guide/configuration/#repo_url`
+        );
         return true;
       }
     }
@@ -381,7 +410,12 @@ const _TechdocsGenerator = class {
     const { path: mkdocsYmlPath, content } = await getMkdocsYml(inputDir);
     const docsDir = await validateMkdocsYaml(inputDir, content);
     if (parsedLocationAnnotation) {
-      await patchMkdocsYmlPreBuild(mkdocsYmlPath, childLogger, parsedLocationAnnotation, this.scmIntegrations);
+      await patchMkdocsYmlPreBuild(
+        mkdocsYmlPath,
+        childLogger,
+        parsedLocationAnnotation,
+        this.scmIntegrations
+      );
     }
     if (this.options.legacyCopyReadmeMdToIndexMd) {
       await patchIndexPreBuild({ inputDir, logger: childLogger, docsDir });
@@ -404,7 +438,9 @@ const _TechdocsGenerator = class {
             },
             logStream
           });
-          childLogger.info(`Successfully generated docs from ${inputDir} into ${outputDir} using local mkdocs`);
+          childLogger.info(
+            `Successfully generated docs from ${inputDir} into ${outputDir} using local mkdocs`
+          );
           break;
         case "docker":
           await this.containerRunner.runContainer({
@@ -416,18 +452,33 @@ const _TechdocsGenerator = class {
             envVars: { HOME: "/tmp" },
             pullImage: this.options.pullImage
           });
-          childLogger.info(`Successfully generated docs from ${inputDir} into ${outputDir} using techdocs-container`);
+          childLogger.info(
+            `Successfully generated docs from ${inputDir} into ${outputDir} using techdocs-container`
+          );
           break;
         default:
-          throw new Error(`Invalid config value "${this.options.runIn}" provided in 'techdocs.generators.techdocs'.`);
+          throw new Error(
+            `Invalid config value "${this.options.runIn}" provided in 'techdocs.generators.techdocs'.`
+          );
       }
     } catch (error) {
-      this.logger.debug(`Failed to generate docs from ${inputDir} into ${outputDir}`);
-      throw new errors.ForwardedError(`Failed to generate docs from ${inputDir} into ${outputDir}`, error);
-    }
-    await createOrUpdateMetadata(path__default["default"].join(outputDir, "techdocs_metadata.json"), childLogger);
+      this.logger.debug(
+        `Failed to generate docs from ${inputDir} into ${outputDir}`
+      );
+      throw new errors.ForwardedError(
+        `Failed to generate docs from ${inputDir} into ${outputDir}`,
+        error
+      );
+    }
+    await createOrUpdateMetadata(
+      path__default["default"].join(outputDir, "techdocs_metadata.json"),
+      childLogger
+    );
     if (etag) {
-      await storeEtagMetadata(path__default["default"].join(outputDir, "techdocs_metadata.json"), etag);
+      await storeEtagMetadata(
+        path__default["default"].join(outputDir, "techdocs_metadata.json"),
+        etag
+      );
     }
   }
 };
@@ -435,16 +486,24 @@ let TechdocsGenerator = _TechdocsGenerator;
 TechdocsGenerator.defaultDockerImage = "spotify/techdocs:v1.0.3";
 function readGeneratorConfig(config, logger) {
   var _a;
-  const legacyGeneratorType = config.getOptionalString("techdocs.generators.techdocs");
+  const legacyGeneratorType = config.getOptionalString(
+    "techdocs.generators.techdocs"
+  );
   if (legacyGeneratorType) {
-    logger.warn(`The 'techdocs.generators.techdocs' configuration key is deprecated and will be removed in the future. Please use 'techdocs.generator' instead. See here https://backstage.io/docs/features/techdocs/configuration`);
+    logger.warn(
+      `The 'techdocs.generators.techdocs' configuration key is deprecated and will be removed in the future. Please use 'techdocs.generator' instead. See here https://backstage.io/docs/features/techdocs/configuration`
+    );
   }
   return {
     runIn: (_a = legacyGeneratorType != null ? legacyGeneratorType : config.getOptionalString("techdocs.generator.runIn")) != null ? _a : "docker",
     dockerImage: config.getOptionalString("techdocs.generator.dockerImage"),
     pullImage: config.getOptionalBoolean("techdocs.generator.pullImage"),
-    omitTechdocsCoreMkdocsPlugin: config.getOptionalBoolean("techdocs.generator.mkdocs.omitTechdocsCorePlugin"),
-    legacyCopyReadmeMdToIndexMd: config.getOptionalBoolean("techdocs.generator.mkdocs.legacyCopyReadmeMdToIndexMd")
+    omitTechdocsCoreMkdocsPlugin: config.getOptionalBoolean(
+      "techdocs.generator.mkdocs.omitTechdocsCorePlugin"
+    ),
+    legacyCopyReadmeMdToIndexMd: config.getOptionalBoolean(
+      "techdocs.generator.mkdocs.legacyCopyReadmeMdToIndexMd"
+    )
   };
 }
 
@@ -475,7 +534,9 @@ const parseReferenceAnnotation = (annotationName, entity) => {
   var _a;
   const annotation = (_a = entity.metadata.annotations) == null ? void 0 : _a[annotationName];
   if (!annotation) {
-    throw new errors.InputError(`No location annotation provided in entity: ${entity.metadata.name}`);
+    throw new errors.InputError(
+      `No location annotation provided in entity: ${entity.metadata.name}`
+    );
   }
   const { type, target } = catalogModel.parseLocationRef(annotation);
   return {
@@ -497,7 +558,10 @@ const transformDirLocation = (entity, dirAnnotation, scmIntegrations) => {
       };
     }
     case "file": {
-      const target = backendCommon.resolveSafeChildPath(path__default["default"].dirname(location.target), dirAnnotation.target);
+      const target = backendCommon.resolveSafeChildPath(
+        path__default["default"].dirname(location.target),
+        dirAnnotation.target
+      );
       return {
         type: "dir",
         target
@@ -508,7 +572,10 @@ const transformDirLocation = (entity, dirAnnotation, scmIntegrations) => {
   }
 };
 const getLocationForEntity = (entity, scmIntegration) => {
-  const annotation = parseReferenceAnnotation("backstage.io/techdocs-ref", entity);
+  const annotation = parseReferenceAnnotation(
+    "backstage.io/techdocs-ref",
+    entity
+  );
   switch (annotation.type) {
     case "url":
       return annotation;
@@ -520,7 +587,10 @@ const getLocationForEntity = (entity, scmIntegration) => {
 };
 const getDocFilesFromRepository = async (reader, entity, opts) => {
   var _a, _b;
-  const { target } = parseReferenceAnnotation("backstage.io/techdocs-ref", entity);
+  const { target } = parseReferenceAnnotation(
+    "backstage.io/techdocs-ref",
+    entity
+  );
   (_a = opts == null ? void 0 : opts.logger) == null ? void 0 : _a.debug(`Reading files from ${target}`);
   const readTreeResponse = await reader.readTree(target, { etag: opts == null ? void 0 : opts.etag });
   const preparedDir = await readTreeResponse.dir();
@@ -541,8 +611,15 @@ class DirectoryPreparer {
   }
   async prepare(entity, options) {
     var _a, _b;
-    const annotation = parseReferenceAnnotation("backstage.io/techdocs-ref", entity);
-    const { type, target } = transformDirLocation(entity, annotation, this.scmIntegrations);
+    const annotation = parseReferenceAnnotation(
+      "backstage.io/techdocs-ref",
+      entity
+    );
+    const { type, target } = transformDirLocation(
+      entity,
+      annotation,
+      this.scmIntegrations
+    );
     switch (type) {
       case "url": {
         (_a = options == null ? void 0 : options.logger) == null ? void 0 : _a.debug(`Reading files from ${target}`);
@@ -587,7 +664,9 @@ class UrlPreparer {
       if (error.name === "NotModifiedError") {
         this.logger.debug(`Cache is valid for etag ${options == null ? void 0 : options.etag}`);
       } else {
-        this.logger.debug(`Unable to fetch files for building docs ${error.message}`);
+        this.logger.debug(
+          `Unable to fetch files for building docs ${error.message}`
+        );
       }
       throw error;
     }
@@ -613,7 +692,10 @@ class Preparers {
     this.preparerMap.set(protocol, preparer);
   }
   get(entity) {
-    const { type } = parseReferenceAnnotation("backstage.io/techdocs-ref", entity);
+    const { type } = parseReferenceAnnotation(
+      "backstage.io/techdocs-ref",
+      entity
+    );
     const preparer = this.preparerMap.get(type);
     if (!preparer) {
       throw new Error(`No preparer registered for type: "${type}"`);
@@ -627,7 +709,10 @@ const streamToBuffer$1 = (stream) => {
     try {
       const chunks = [];
       stream.on("data", (chunk) => chunks.push(chunk));
-      stream.on("error", reject);
+      stream.on(
+        "error",
+        (e) => reject(new errors.ForwardedError("Unable to read stream", e))
+      );
       stream.on("end", () => resolve(Buffer.concat(chunks)));
     } catch (e) {
       throw new errors.ForwardedError("Unable to parse the response data", e);
@@ -648,22 +733,34 @@ class AwsS3Publish {
     try {
       bucketName = config.getString("techdocs.publisher.awsS3.bucketName");
     } catch (error) {
-      throw new Error("Since techdocs.publisher.type is set to 'awsS3' in your app config, techdocs.publisher.awsS3.bucketName is required.");
+      throw new Error(
+        "Since techdocs.publisher.type is set to 'awsS3' in your app config, techdocs.publisher.awsS3.bucketName is required."
+      );
     }
-    const bucketRootPath = normalizeExternalStorageRootPath(config.getOptionalString("techdocs.publisher.awsS3.bucketRootPath") || "");
+    const bucketRootPath = normalizeExternalStorageRootPath(
+      config.getOptionalString("techdocs.publisher.awsS3.bucketRootPath") || ""
+    );
     const sse = config.getOptionalString("techdocs.publisher.awsS3.sse");
-    const credentialsConfig = config.getOptionalConfig("techdocs.publisher.awsS3.credentials");
+    const credentialsConfig = config.getOptionalConfig(
+      "techdocs.publisher.awsS3.credentials"
+    );
     const credentials = AwsS3Publish.buildCredentials(credentialsConfig);
     const region = config.getOptionalString("techdocs.publisher.awsS3.region");
-    const endpoint = config.getOptionalString("techdocs.publisher.awsS3.endpoint");
-    const s3ForcePathStyle = config.getOptionalBoolean("techdocs.publisher.awsS3.s3ForcePathStyle");
+    const endpoint = config.getOptionalString(
+      "techdocs.publisher.awsS3.endpoint"
+    );
+    const s3ForcePathStyle = config.getOptionalBoolean(
+      "techdocs.publisher.awsS3.s3ForcePathStyle"
+    );
     const storageClient = new aws__default["default"].S3({
       credentials,
       ...region && { region },
       ...endpoint && { endpoint },
       ...s3ForcePathStyle && { s3ForcePathStyle }
     });
-    const legacyPathCasing = config.getOptionalBoolean("techdocs.legacyUseCaseSensitiveTripletPaths") || false;
+    const legacyPathCasing = config.getOptionalBoolean(
+      "techdocs.legacyUseCaseSensitiveTripletPaths"
+    ) || false;
     return new AwsS3Publish({
       storageClient,
       bucketName,
@@ -701,10 +798,14 @@ class AwsS3Publish {
   async getReadiness() {
     try {
       await this.storageClient.headBucket({ Bucket: this.bucketName }).promise();
-      this.logger.info(`Successfully connected to the AWS S3 bucket ${this.bucketName}.`);
+      this.logger.info(
+        `Successfully connected to the AWS S3 bucket ${this.bucketName}.`
+      );
       return { isAvailable: true };
     } catch (error) {
-      this.logger.error(`Could not retrieve metadata about the AWS S3 bucket ${this.bucketName}. Make sure the bucket exists. Also make sure that authentication is setup either by explicitly defining credentials and region in techdocs.publisher.awsS3 in app config or by using environment variables. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`);
+      this.logger.error(
+        `Could not retrieve metadata about the AWS S3 bucket ${this.bucketName}. Make sure the bucket exists. Also make sure that authentication is setup either by explicitly defining credentials and region in techdocs.publisher.awsS3 in app config or by using environment variables. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`
+      );
       this.logger.error(`from AWS client library`, error);
       return {
         isAvailable: false
@@ -721,45 +822,76 @@ class AwsS3Publish {
     const sse = this.sse;
     let existingFiles = [];
     try {
-      const remoteFolder = getCloudPathForLocalPath(entity, void 0, useLegacyPathCasing, bucketRootPath);
+      const remoteFolder = getCloudPathForLocalPath(
+        entity,
+        void 0,
+        useLegacyPathCasing,
+        bucketRootPath
+      );
       existingFiles = await this.getAllObjectsFromBucket({
         prefix: remoteFolder
       });
     } catch (e) {
       errors.assertError(e);
-      this.logger.error(`Unable to list files for Entity ${entity.metadata.name}: ${e.message}`);
+      this.logger.error(
+        `Unable to list files for Entity ${entity.metadata.name}: ${e.message}`
+      );
     }
     let absoluteFilesToUpload;
     try {
       absoluteFilesToUpload = await getFileTreeRecursively(directory);
-      await bulkStorageOperation(async (absoluteFilePath) => {
-        const relativeFilePath = path__default["default"].relative(directory, absoluteFilePath);
-        const fileStream = fs__default["default"].createReadStream(absoluteFilePath);
-        const params = {
-          Bucket: this.bucketName,
-          Key: getCloudPathForLocalPath(entity, relativeFilePath, useLegacyPathCasing, bucketRootPath),
-          Body: fileStream,
-          ...sse && { ServerSideEncryption: sse }
-        };
-        objects.push(params.Key);
-        return this.storageClient.upload(params).promise();
-      }, absoluteFilesToUpload, { concurrencyLimit: 10 });
-      this.logger.info(`Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${absoluteFilesToUpload.length}`);
+      await bulkStorageOperation(
+        async (absoluteFilePath) => {
+          const relativeFilePath = path__default["default"].relative(directory, absoluteFilePath);
+          const fileStream = fs__default["default"].createReadStream(absoluteFilePath);
+          const params = {
+            Bucket: this.bucketName,
+            Key: getCloudPathForLocalPath(
+              entity,
+              relativeFilePath,
+              useLegacyPathCasing,
+              bucketRootPath
+            ),
+            Body: fileStream,
+            ...sse && { ServerSideEncryption: sse }
+          };
+          objects.push(params.Key);
+          return this.storageClient.upload(params).promise();
+        },
+        absoluteFilesToUpload,
+        { concurrencyLimit: 10 }
+      );
+      this.logger.info(
+        `Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${absoluteFilesToUpload.length}`
+      );
     } catch (e) {
       const errorMessage = `Unable to upload file(s) to AWS S3. ${e}`;
       this.logger.error(errorMessage);
       throw new Error(errorMessage);
     }
     try {
-      const relativeFilesToUpload = absoluteFilesToUpload.map((absoluteFilePath) => getCloudPathForLocalPath(entity, path__default["default"].relative(directory, absoluteFilePath), useLegacyPathCasing, bucketRootPath));
+      const relativeFilesToUpload = absoluteFilesToUpload.map(
+        (absoluteFilePath) => getCloudPathForLocalPath(
+          entity,
+          path__default["default"].relative(directory, absoluteFilePath),
+          useLegacyPathCasing,
+          bucketRootPath
+        )
+      );
       const staleFiles = getStaleFiles(relativeFilesToUpload, existingFiles);
-      await bulkStorageOperation(async (relativeFilePath) => {
-        return await this.storageClient.deleteObject({
-          Bucket: this.bucketName,
-          Key: relativeFilePath
-        }).promise();
-      }, staleFiles, { concurrencyLimit: 10 });
-      this.logger.info(`Successfully deleted stale files for Entity ${entity.metadata.name}. Total number of files: ${staleFiles.length}`);
+      await bulkStorageOperation(
+        async (relativeFilePath) => {
+          return await this.storageClient.deleteObject({
+            Bucket: this.bucketName,
+            Key: relativeFilePath
+          }).promise();
+        },
+        staleFiles,
+        { concurrencyLimit: 10 }
+      );
+      this.logger.info(
+        `Successfully deleted stale files for Entity ${entity.metadata.name}. Total number of files: ${staleFiles.length}`
+      );
     } catch (error) {
       const errorMessage = `Unable to delete file(s) from AWS S3. ${error}`;
       this.logger.error(errorMessage);
@@ -779,9 +911,13 @@ class AwsS3Publish {
         try {
           const techdocsMetadataJson = await streamToBuffer$1(stream);
           if (!techdocsMetadataJson) {
-            throw new Error(`Unable to parse the techdocs metadata file ${entityRootDir}/techdocs_metadata.json.`);
+            throw new Error(
+              `Unable to parse the techdocs metadata file ${entityRootDir}/techdocs_metadata.json.`
+            );
           }
-          const techdocsMetadata = JSON5__default["default"].parse(techdocsMetadataJson.toString("utf-8"));
+          const techdocsMetadata = JSON5__default["default"].parse(
+            techdocsMetadataJson.toString("utf-8")
+          );
           resolve(techdocsMetadata);
         } catch (err) {
           errors.assertError(err);
@@ -803,13 +939,17 @@ class AwsS3Publish {
       const responseHeaders = getHeadersForFileExtension(fileExtension);
       const stream = this.storageClient.getObject({ Bucket: this.bucketName, Key: filePath }).createReadStream();
       try {
-        for (const [headerKey, headerValue] of Object.entries(responseHeaders)) {
+        for (const [headerKey, headerValue] of Object.entries(
+          responseHeaders
+        )) {
           res.setHeader(headerKey, headerValue);
         }
         res.send(await streamToBuffer$1(stream));
       } catch (err) {
         errors.assertError(err);
-        this.logger.warn(`TechDocs S3 router failed to serve static files from bucket ${this.bucketName} at key ${filePath}: ${err.message}`);
+        this.logger.warn(
+          `TechDocs S3 router failed to serve static files from bucket ${this.bucketName} at key ${filePath}: ${err.message}`
+        );
         res.status(404).send("File Not Found");
       }
     };
@@ -834,36 +974,40 @@ class AwsS3Publish {
   }) {
     const allObjects = await this.getAllObjectsFromBucket();
     const limiter = createLimiter__default["default"](concurrency);
-    await Promise.all(allObjects.map((f) => limiter(async (file) => {
-      let newPath;
-      try {
-        newPath = lowerCaseEntityTripletInStoragePath(file);
-      } catch (e) {
-        errors.assertError(e);
-        this.logger.warn(e.message);
-        return;
-      }
-      if (file === newPath) {
-        return;
-      }
-      try {
-        this.logger.verbose(`Migrating ${file}`);
-        await this.storageClient.copyObject({
-          Bucket: this.bucketName,
-          CopySource: [this.bucketName, file].join("/"),
-          Key: newPath
-        }).promise();
-        if (removeOriginal) {
-          await this.storageClient.deleteObject({
-            Bucket: this.bucketName,
-            Key: file
-          }).promise();
-        }
-      } catch (e) {
-        errors.assertError(e);
-        this.logger.warn(`Unable to migrate ${file}: ${e.message}`);
-      }
-    }, f)));
+    await Promise.all(
+      allObjects.map(
+        (f) => limiter(async (file) => {
+          let newPath;
+          try {
+            newPath = lowerCaseEntityTripletInStoragePath(file);
+          } catch (e) {
+            errors.assertError(e);
+            this.logger.warn(e.message);
+            return;
+          }
+          if (file === newPath) {
+            return;
+          }
+          try {
+            this.logger.verbose(`Migrating ${file}`);
+            await this.storageClient.copyObject({
+              Bucket: this.bucketName,
+              CopySource: [this.bucketName, file].join("/"),
+              Key: newPath
+            }).promise();
+            if (removeOriginal) {
+              await this.storageClient.deleteObject({
+                Bucket: this.bucketName,
+                Key: file
+              }).promise();
+            }
+          } catch (e) {
+            errors.assertError(e);
+            this.logger.warn(`Unable to migrate ${file}: ${e.message}`);
+          }
+        }, f)
+      )
+    );
   }
   async getAllObjectsFromBucket({ prefix } = { prefix: "" }) {
     const objects = [];
@@ -875,7 +1019,9 @@ class AwsS3Publish {
         ContinuationToken: nextContinuation,
         ...prefix ? { Prefix: prefix } : {}
       }).promise();
-      objects.push(...(allObjects.Contents || []).map((f) => f.Key || "").filter((f) => !!f));
+      objects.push(
+        ...(allObjects.Contents || []).map((f) => f.Key || "").filter((f) => !!f)
+      );
       nextContinuation = allObjects.NextContinuationToken;
     } while (nextContinuation);
     return objects;
@@ -893,25 +1039,40 @@ class AzureBlobStoragePublish {
   static fromConfig(config, logger) {
     let containerName = "";
     try {
-      containerName = config.getString("techdocs.publisher.azureBlobStorage.containerName");
+      containerName = config.getString(
+        "techdocs.publisher.azureBlobStorage.containerName"
+      );
     } catch (error) {
-      throw new Error("Since techdocs.publisher.type is set to 'azureBlobStorage' in your app config, techdocs.publisher.azureBlobStorage.containerName is required.");
+      throw new Error(
+        "Since techdocs.publisher.type is set to 'azureBlobStorage' in your app config, techdocs.publisher.azureBlobStorage.containerName is required."
+      );
     }
     let accountName = "";
     try {
-      accountName = config.getString("techdocs.publisher.azureBlobStorage.credentials.accountName");
+      accountName = config.getString(
+        "techdocs.publisher.azureBlobStorage.credentials.accountName"
+      );
     } catch (error) {
-      throw new Error("Since techdocs.publisher.type is set to 'azureBlobStorage' in your app config, techdocs.publisher.azureBlobStorage.credentials.accountName is required.");
+      throw new Error(
+        "Since techdocs.publisher.type is set to 'azureBlobStorage' in your app config, techdocs.publisher.azureBlobStorage.credentials.accountName is required."
+      );
     }
-    const accountKey = config.getOptionalString("techdocs.publisher.azureBlobStorage.credentials.accountKey");
+    const accountKey = config.getOptionalString(
+      "techdocs.publisher.azureBlobStorage.credentials.accountKey"
+    );
     let credential;
     if (accountKey) {
       credential = new storageBlob.StorageSharedKeyCredential(accountName, accountKey);
     } else {
       credential = new identity.DefaultAzureCredential();
     }
-    const storageClient = new storageBlob.BlobServiceClient(`https://${accountName}.blob.core.windows.net`, credential);
-    const legacyPathCasing = config.getOptionalBoolean("techdocs.legacyUseCaseSensitiveTripletPaths") || false;
+    const storageClient = new storageBlob.BlobServiceClient(
+      `https://${accountName}.blob.core.windows.net`,
+      credential
+    );
+    const legacyPathCasing = config.getOptionalBoolean(
+      "techdocs.legacyUseCaseSensitiveTripletPaths"
+    ) || false;
     return new AzureBlobStoragePublish({
       storageClient,
       containerName,
@@ -928,13 +1089,17 @@ class AzureBlobStoragePublish {
         };
       }
       if (response._response.status >= 400) {
-        this.logger.error(`Failed to retrieve metadata from ${response._response.request.url} with status code ${response._response.status}.`);
+        this.logger.error(
+          `Failed to retrieve metadata from ${response._response.request.url} with status code ${response._response.status}.`
+        );
       }
     } catch (e) {
       errors.assertError(e);
       this.logger.error(`from Azure Blob Storage client library: ${e.message}`);
     }
-    this.logger.error(`Could not retrieve metadata about the Azure Blob Storage container ${this.containerName}. Make sure that the Azure project and container exist and the access key is setup correctly techdocs.publisher.azureBlobStorage.credentials defined in app config has correct permissions. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`);
+    this.logger.error(
+      `Could not retrieve metadata about the Azure Blob Storage container ${this.containerName}. Make sure that the Azure project and container exist and the access key is setup correctly techdocs.publisher.azureBlobStorage.credentials defined in app config has correct permissions. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`
+    );
     return { isAvailable: false };
   }
   async publish({
@@ -943,7 +1108,11 @@ class AzureBlobStoragePublish {
   }) {
     const objects = [];
     const useLegacyPathCasing = this.legacyPathCasing;
-    const remoteFolder = getCloudPathForLocalPath(entity, void 0, useLegacyPathCasing);
+    const remoteFolder = getCloudPathForLocalPath(
+      entity,
+      void 0,
+      useLegacyPathCasing
+    );
     let existingFiles = [];
     try {
       existingFiles = await this.getAllBlobsFromContainer({
@@ -952,7 +1121,9 @@ class AzureBlobStoragePublish {
       });
     } catch (e) {
       errors.assertError(e);
-      this.logger.error(`Unable to list files for Entity ${entity.metadata.name}: ${e.message}`);
+      this.logger.error(
+        `Unable to list files for Entity ${entity.metadata.name}: ${e.message}`
+      );
     }
     let absoluteFilesToUpload;
     let container;
@@ -960,32 +1131,62 @@ class AzureBlobStoragePublish {
       absoluteFilesToUpload = await getFileTreeRecursively(directory);
       container = this.storageClient.getContainerClient(this.containerName);
       const failedOperations = [];
-      await bulkStorageOperation(async (absoluteFilePath) => {
-        const relativeFilePath = path__default["default"].normalize(path__default["default"].relative(directory, absoluteFilePath));
-        const remotePath = getCloudPathForLocalPath(entity, relativeFilePath, useLegacyPathCasing);
-        objects.push(remotePath);
-        const response = await container.getBlockBlobClient(remotePath).uploadFile(absoluteFilePath);
-        if (response._response.status >= 400) {
-          failedOperations.push(new Error(`Upload failed for ${absoluteFilePath} with status code ${response._response.status}`));
-        }
-        return response;
-      }, absoluteFilesToUpload, { concurrencyLimit: BATCH_CONCURRENCY });
+      await bulkStorageOperation(
+        async (absoluteFilePath) => {
+          const relativeFilePath = path__default["default"].normalize(
+            path__default["default"].relative(directory, absoluteFilePath)
+          );
+          const remotePath = getCloudPathForLocalPath(
+            entity,
+            relativeFilePath,
+            useLegacyPathCasing
+          );
+          objects.push(remotePath);
+          const response = await container.getBlockBlobClient(remotePath).uploadFile(absoluteFilePath);
+          if (response._response.status >= 400) {
+            failedOperations.push(
+              new Error(
+                `Upload failed for ${absoluteFilePath} with status code ${response._response.status}`
+              )
+            );
+          }
+          return response;
+        },
+        absoluteFilesToUpload,
+        { concurrencyLimit: BATCH_CONCURRENCY }
+      );
       if (failedOperations.length > 0) {
-        throw new Error(failedOperations.map((r) => r.message).filter(Boolean).join(" "));
+        throw new Error(
+          failedOperations.map((r) => r.message).filter(Boolean).join(" ")
+        );
       }
-      this.logger.info(`Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${absoluteFilesToUpload.length}`);
+      this.logger.info(
+        `Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${absoluteFilesToUpload.length}`
+      );
     } catch (e) {
       const errorMessage = `Unable to upload file(s) to Azure. ${e}`;
       this.logger.error(errorMessage);
       throw new Error(errorMessage);
     }
     try {
-      const relativeFilesToUpload = absoluteFilesToUpload.map((absoluteFilePath) => getCloudPathForLocalPath(entity, path__default["default"].relative(directory, absoluteFilePath), useLegacyPathCasing));
+      const relativeFilesToUpload = absoluteFilesToUpload.map(
+        (absoluteFilePath) => getCloudPathForLocalPath(
+          entity,
+          path__default["default"].relative(directory, absoluteFilePath),
+          useLegacyPathCasing
+        )
+      );
       const staleFiles = getStaleFiles(relativeFilesToUpload, existingFiles);
-      await bulkStorageOperation(async (relativeFilePath) => {
-        return await container.deleteBlob(relativeFilePath);
-      }, staleFiles, { concurrencyLimit: BATCH_CONCURRENCY });
-      this.logger.info(`Successfully deleted stale files for Entity ${entity.metadata.name}. Total number of files: ${staleFiles.length}`);
+      await bulkStorageOperation(
+        async (relativeFilePath) => {
+          return await container.deleteBlob(relativeFilePath);
+        },
+        staleFiles,
+        { concurrencyLimit: BATCH_CONCURRENCY }
+      );
+      this.logger.info(
+        `Successfully deleted stale files for Entity ${entity.metadata.name}. Total number of files: ${staleFiles.length}`
+      );
     } catch (error) {
       const errorMessage = `Unable to delete file(s) from Azure. ${error}`;
       this.logger.error(errorMessage);
@@ -1013,11 +1214,18 @@ class AzureBlobStoragePublish {
     const entityTriplet = `${entityName.namespace}/${entityName.kind}/${entityName.name}`;
     const entityRootDir = this.legacyPathCasing ? entityTriplet : lowerCaseEntityTriplet(entityTriplet);
     try {
-      const techdocsMetadataJson = await this.download(this.containerName, `${entityRootDir}/techdocs_metadata.json`);
+      const techdocsMetadataJson = await this.download(
+        this.containerName,
+        `${entityRootDir}/techdocs_metadata.json`
+      );
       if (!techdocsMetadataJson) {
-        throw new Error(`Unable to parse the techdocs metadata file ${entityRootDir}/techdocs_metadata.json.`);
+        throw new Error(
+          `Unable to parse the techdocs metadata file ${entityRootDir}/techdocs_metadata.json.`
+        );
       }
-      const techdocsMetadata = JSON5__default["default"].parse(techdocsMetadataJson.toString("utf-8"));
+      const techdocsMetadata = JSON5__default["default"].parse(
+        techdocsMetadataJson.toString("utf-8")
+      );
       return techdocsMetadata;
     } catch (e) {
       throw new errors.ForwardedError("TechDocs metadata fetch failed", e);
@@ -1030,12 +1238,16 @@ class AzureBlobStoragePublish {
       const fileExtension = path__default["default"].extname(filePath);
       const responseHeaders = getHeadersForFileExtension(fileExtension);
       this.download(this.containerName, filePath).then((fileContent) => {
-        for (const [headerKey, headerValue] of Object.entries(responseHeaders)) {
+        for (const [headerKey, headerValue] of Object.entries(
+          responseHeaders
+        )) {
           res.setHeader(headerKey, headerValue);
         }
         res.send(fileContent);
       }).catch((e) => {
-        this.logger.warn(`TechDocs Azure router failed to serve content from container ${this.containerName} at path ${filePath}: ${e.message}`);
+        this.logger.warn(
+          `TechDocs Azure router failed to serve content from container ${this.containerName} at path ${filePath}: ${e.message}`
+        );
         res.status(404).send("File Not Found");
       });
     };
@@ -1082,7 +1294,13 @@ class AzureBlobStoragePublish {
     const limiter = createLimiter__default["default"](concurrency);
     const container = this.storageClient.getContainerClient(this.containerName);
     for await (const blob of container.listBlobsFlat()) {
-      promises.push(limiter(this.renameBlobToLowerCase.bind(this), blob.name, removeOriginal));
+      promises.push(
+        limiter(
+          this.renameBlobToLowerCase.bind(this),
+          blob.name,
+          removeOriginal
+        )
+      );
     }
     await Promise.all(promises);
   }
@@ -1136,7 +1354,9 @@ class MigrateWriteStream extends stream.Writable {
     }
     const migrate = this.removeOriginal ? file.move.bind(file) : file.copy.bind(file);
     this.logger.verbose(`Migrating ${file.name}`);
-    migrate(newFile).catch((e) => this.logger.warn(`Unable to migrate ${file.name}: ${e.message}`)).finally(() => {
+    migrate(newFile).catch(
+      (e) => this.logger.warn(`Unable to migrate ${file.name}: ${e.message}`)
+    ).finally(() => {
       this.inFlight--;
       if (shouldCallNext) {
         next();
@@ -1158,16 +1378,24 @@ class GoogleGCSPublish {
     try {
       bucketName = config.getString("techdocs.publisher.googleGcs.bucketName");
     } catch (error) {
-      throw new Error("Since techdocs.publisher.type is set to 'googleGcs' in your app config, techdocs.publisher.googleGcs.bucketName is required.");
-    }
-    const bucketRootPath = normalizeExternalStorageRootPath(config.getOptionalString("techdocs.publisher.googleGcs.bucketRootPath") || "");
-    const credentials = config.getOptionalString("techdocs.publisher.googleGcs.credentials");
+      throw new Error(
+        "Since techdocs.publisher.type is set to 'googleGcs' in your app config, techdocs.publisher.googleGcs.bucketName is required."
+      );
+    }
+    const bucketRootPath = normalizeExternalStorageRootPath(
+      config.getOptionalString("techdocs.publisher.googleGcs.bucketRootPath") || ""
+    );
+    const credentials = config.getOptionalString(
+      "techdocs.publisher.googleGcs.credentials"
+    );
     let credentialsJson = {};
     if (credentials) {
       try {
         credentialsJson = JSON.parse(credentials);
       } catch (err) {
-        throw new Error("Error in parsing techdocs.publisher.googleGcs.credentials config to JSON.");
+        throw new Error(
+          "Error in parsing techdocs.publisher.googleGcs.credentials config to JSON."
+        );
       }
     }
     const storageClient = new storage.Storage({
@@ -1176,7 +1404,9 @@ class GoogleGCSPublish {
         credentials: credentialsJson
       }
     });
-    const legacyPathCasing = config.getOptionalBoolean("techdocs.legacyUseCaseSensitiveTripletPaths") || false;
+    const legacyPathCasing = config.getOptionalBoolean(
+      "techdocs.legacyUseCaseSensitiveTripletPaths"
+    ) || false;
     return new GoogleGCSPublish({
       storageClient,
       bucketName,
@@ -1188,13 +1418,17 @@ class GoogleGCSPublish {
   async getReadiness() {
     try {
       await this.storageClient.bucket(this.bucketName).getMetadata();
-      this.logger.info(`Successfully connected to the GCS bucket ${this.bucketName}.`);
+      this.logger.info(
+        `Successfully connected to the GCS bucket ${this.bucketName}.`
+      );
       return {
         isAvailable: true
       };
     } catch (err) {
       errors.assertError(err);
-      this.logger.error(`Could not retrieve metadata about the GCS bucket ${this.bucketName}. Make sure the bucket exists. Also make sure that authentication is setup either by explicitly defining techdocs.publisher.googleGcs.credentials in app config or by using environment variables. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`);
+      this.logger.error(
+        `Could not retrieve metadata about the GCS bucket ${this.bucketName}. Make sure the bucket exists. Also make sure that authentication is setup either by explicitly defining techdocs.publisher.googleGcs.credentials in app config or by using environment variables. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`
+      );
       this.logger.error(`from GCS client library: ${err.message}`);
       return { isAvailable: false };
     }
@@ -1209,34 +1443,65 @@ class GoogleGCSPublish {
     const bucketRootPath = this.bucketRootPath;
     let existingFiles = [];
     try {
-      const remoteFolder = getCloudPathForLocalPath(entity, void 0, useLegacyPathCasing, bucketRootPath);
+      const remoteFolder = getCloudPathForLocalPath(
+        entity,
+        void 0,
+        useLegacyPathCasing,
+        bucketRootPath
+      );
       existingFiles = await this.getFilesForFolder(remoteFolder);
     } catch (e) {
       errors.assertError(e);
-      this.logger.error(`Unable to list files for Entity ${entity.metadata.name}: ${e.message}`);
+      this.logger.error(
+        `Unable to list files for Entity ${entity.metadata.name}: ${e.message}`
+      );
     }
     let absoluteFilesToUpload;
     try {
       absoluteFilesToUpload = await getFileTreeRecursively(directory);
-      await bulkStorageOperation(async (absoluteFilePath) => {
-        const relativeFilePath = path__default["default"].relative(directory, absoluteFilePath);
-        const destination = getCloudPathForLocalPath(entity, relativeFilePath, useLegacyPathCasing, bucketRootPath);
-        objects.push(destination);
-        return await bucket.upload(absoluteFilePath, { destination });
-      }, absoluteFilesToUpload, { concurrencyLimit: 10 });
-      this.logger.info(`Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${absoluteFilesToUpload.length}`);
+      await bulkStorageOperation(
+        async (absoluteFilePath) => {
+          const relativeFilePath = path__default["default"].relative(directory, absoluteFilePath);
+          const destination = getCloudPathForLocalPath(
+            entity,
+            relativeFilePath,
+            useLegacyPathCasing,
+            bucketRootPath
+          );
+          objects.push(destination);
+          return await bucket.upload(absoluteFilePath, { destination });
+        },
+        absoluteFilesToUpload,
+        { concurrencyLimit: 10 }
+      );
+      this.logger.info(
+        `Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${absoluteFilesToUpload.length}`
+      );
     } catch (e) {
       const errorMessage = `Unable to upload file(s) to Google Cloud Storage. ${e}`;
       this.logger.error(errorMessage);
       throw new Error(errorMessage);
     }
     try {
-      const relativeFilesToUpload = absoluteFilesToUpload.map((absoluteFilePath) => getCloudPathForLocalPath(entity, path__default["default"].relative(directory, absoluteFilePath), useLegacyPathCasing, bucketRootPath));
+      const relativeFilesToUpload = absoluteFilesToUpload.map(
+        (absoluteFilePath) => getCloudPathForLocalPath(
+          entity,
+          path__default["default"].relative(directory, absoluteFilePath),
+          useLegacyPathCasing,
+          bucketRootPath
+        )
+      );
       const staleFiles = getStaleFiles(relativeFilesToUpload, existingFiles);
-      await bulkStorageOperation(async (relativeFilePath) => {
-        return await bucket.file(relativeFilePath).delete();
-      }, staleFiles, { concurrencyLimit: 10 });
-      this.logger.info(`Successfully deleted stale files for Entity ${entity.metadata.name}. Total number of files: ${staleFiles.length}`);
+      await bulkStorageOperation(
+        async (relativeFilePath) => {
+          return await bucket.file(relativeFilePath).delete();
+        },
+        staleFiles,
+        { concurrencyLimit: 10 }
+      );
+      this.logger.info(
+        `Successfully deleted stale files for Entity ${entity.metadata.name}. Total number of files: ${staleFiles.length}`
+      );
     } catch (error) {
       const errorMessage = `Unable to delete file(s) from Google Cloud Storage. ${error}`;
       this.logger.error(errorMessage);
@@ -1271,7 +1536,9 @@ class GoogleGCSPublish {
       this.storageClient.bucket(this.bucketName).file(filePath).createReadStream().on("pipe", () => {
         res.writeHead(200, responseHeaders);
       }).on("error", (err) => {
-        this.logger.warn(`TechDocs Google GCS router failed to serve content from bucket ${this.bucketName} at path ${filePath}: ${err.message}`);
+        this.logger.warn(
+          `TechDocs Google GCS router failed to serve content from bucket ${this.bucketName} at path ${filePath}: ${err.message}`
+        );
         if (!res.headersSent) {
           res.status(404).send("File Not Found");
         } else {
@@ -1295,7 +1562,11 @@ class GoogleGCSPublish {
   migrateDocsCase({ removeOriginal = false, concurrency = 25 }) {
     return new Promise((resolve, reject) => {
       const allFileMetadata = this.storageClient.bucket(this.bucketName).getFilesStream();
-      const migrateFiles = new MigrateWriteStream(this.logger, removeOriginal, concurrency);
+      const migrateFiles = new MigrateWriteStream(
+        this.logger,
+        removeOriginal,
+        concurrency
+      );
       migrateFiles.on("finish", resolve).on("error", reject);
       allFileMetadata.pipe(migrateFiles).on("error", (error) => {
         migrateFiles.destroy();
@@ -1328,11 +1599,18 @@ class LocalPublish {
     this.staticDocsDir = options.staticDocsDir;
   }
   static fromConfig(config, logger, discovery) {
-    const legacyPathCasing = config.getOptionalBoolean("techdocs.legacyUseCaseSensitiveTripletPaths") || false;
-    let staticDocsDir = config.getOptionalString("techdocs.publisher.local.publishDirectory");
+    const legacyPathCasing = config.getOptionalBoolean(
+      "techdocs.legacyUseCaseSensitiveTripletPaths"
+    ) || false;
+    let staticDocsDir = config.getOptionalString(
+      "techdocs.publisher.local.publishDirectory"
+    );
     if (!staticDocsDir) {
       try {
-        staticDocsDir = backendCommon.resolvePackagePath("@backstage/plugin-techdocs-backend", "static/docs");
+        staticDocsDir = backendCommon.resolvePackagePath(
+          "@backstage/plugin-techdocs-backend",
+          "static/docs"
+        );
       } catch (err) {
         staticDocsDir = os__default["default"].tmpdir();
       }
@@ -1357,9 +1635,18 @@ class LocalPublish {
     const entityNamespace = (_a = entity.metadata.namespace) != null ? _a : "default";
     let publishDir;
     try {
-      publishDir = this.staticEntityPathJoin(entityNamespace, entity.kind, entity.metadata.name);
+      publishDir = this.staticEntityPathJoin(
+        entityNamespace,
+        entity.kind,
+        entity.metadata.name
+      );
     } catch (error) {
-      throw new errors.ForwardedError(`Unable to publish TechDocs site for entity: ${catalogModel.stringifyEntityRef(entity)}`, error);
+      throw new errors.ForwardedError(
+        `Unable to publish TechDocs site for entity: ${catalogModel.stringifyEntityRef(
+          entity
+        )}`,
+        error
+      );
     }
     if (!fs__default["default"].existsSync(publishDir)) {
       this.logger.info(`Could not find ${publishDir}, creating the directory.`);
@@ -1369,29 +1656,48 @@ class LocalPublish {
       await fs__default["default"].copy(directory, publishDir);
       this.logger.info(`Published site stored at ${publishDir}`);
     } catch (error) {
-      this.logger.debug(`Failed to copy docs from ${directory} to ${publishDir}`);
+      this.logger.debug(
+        `Failed to copy docs from ${directory} to ${publishDir}`
+      );
       throw error;
     }
     const techdocsApiUrl = await this.discovery.getBaseUrl("techdocs");
-    const publishedFilePaths = (await getFileTreeRecursively(publishDir)).map((abs) => {
-      return abs.split(`${this.staticDocsDir}/`)[1];
-    });
+    const publishedFilePaths = (await getFileTreeRecursively(publishDir)).map(
+      (abs) => {
+        return abs.split(`${this.staticDocsDir}/`)[1];
+      }
+    );
     return {
-      remoteUrl: `${techdocsApiUrl}/static/docs/${encodeURIComponent(entity.metadata.name)}`,
+      remoteUrl: `${techdocsApiUrl}/static/docs/${encodeURIComponent(
+        entity.metadata.name
+      )}`,
       objects: publishedFilePaths
     };
   }
   async fetchTechDocsMetadata(entityName) {
     let metadataPath;
     try {
-      metadataPath = this.staticEntityPathJoin(entityName.namespace, entityName.kind, entityName.name, "techdocs_metadata.json");
+      metadataPath = this.staticEntityPathJoin(
+        entityName.namespace,
+        entityName.kind,
+        entityName.name,
+        "techdocs_metadata.json"
+      );
     } catch (err) {
-      throw new errors.ForwardedError(`Unexpected entity when fetching metadata: ${catalogModel.stringifyEntityRef(entityName)}`, err);
+      throw new errors.ForwardedError(
+        `Unexpected entity when fetching metadata: ${catalogModel.stringifyEntityRef(
+          entityName
+        )}`,
+        err
+      );
     }
     try {
       return await fs__default["default"].readJson(metadataPath);
     } catch (err) {
-      throw new errors.ForwardedError(`Unable to read techdocs_metadata.json at ${metadataPath}. Error: ${err}`, err);
+      throw new errors.ForwardedError(
+        `Unable to read techdocs_metadata.json at ${metadataPath}. Error: ${err}`,
+        err
+      );
     }
   }
   docsRouter() {
@@ -1416,27 +1722,38 @@ class LocalPublish {
       }
       return res.redirect(301, req.baseUrl + newPath);
     });
-    router.use(express__default["default"].static(this.staticDocsDir, {
-      setHeaders: (res, filePath) => {
-        const fileExtension = path__default["default"].extname(filePath);
-        const headers = getHeadersForFileExtension(fileExtension);
-        for (const [header, value] of Object.entries(headers)) {
-          res.setHeader(header, value);
+    router.use(
+      express__default["default"].static(this.staticDocsDir, {
+        setHeaders: (res, filePath) => {
+          const fileExtension = path__default["default"].extname(filePath);
+          const headers = getHeadersForFileExtension(fileExtension);
+          for (const [header, value] of Object.entries(headers)) {
+            res.setHeader(header, value);
+          }
         }
-      }
-    }));
+      })
+    );
     return router;
   }
   async hasDocsBeenGenerated(entity) {
     var _a;
     const namespace = (_a = entity.metadata.namespace) != null ? _a : "default";
     try {
-      const indexHtmlPath = this.staticEntityPathJoin(namespace, entity.kind, entity.metadata.name, "index.html");
+      const indexHtmlPath = this.staticEntityPathJoin(
+        namespace,
+        entity.kind,
+        entity.metadata.name,
+        "index.html"
+      );
       await fs__default["default"].access(indexHtmlPath, fs__default["default"].constants.F_OK);
       return true;
     } catch (err) {
       if (err.name === "NotAllowedError") {
-        this.logger.error(`Unexpected entity when checking if generated: ${catalogModel.stringifyEntityRef(entity)}`);
+        this.logger.error(
+          `Unexpected entity when checking if generated: ${catalogModel.stringifyEntityRef(
+            entity
+          )}`
+        );
       }
       return false;
     }
@@ -1447,29 +1764,41 @@ class LocalPublish {
   }) {
     const files = await getFileTreeRecursively(this.staticDocsDir);
     const limit = createLimiter__default["default"](concurrency);
-    await Promise.all(files.map((f) => limit(async (file) => {
-      const relativeFile = file.replace(`${this.staticDocsDir}${path__default["default"].sep}`, "");
-      const newFile = lowerCaseEntityTripletInStoragePath(relativeFile);
-      if (relativeFile === newFile) {
-        return;
-      }
-      await new Promise((resolve) => {
-        const migrate = removeOriginal ? fs__default["default"].move : fs__default["default"].copyFile;
-        this.logger.verbose(`Migrating ${relativeFile}`);
-        migrate(file, newFile, (err) => {
-          if (err) {
-            this.logger.warn(`Unable to migrate ${relativeFile}: ${err.message}`);
+    await Promise.all(
+      files.map(
+        (f) => limit(async (file) => {
+          const relativeFile = file.replace(
+            `${this.staticDocsDir}${path__default["default"].sep}`,
+            ""
+          );
+          const newFile = lowerCaseEntityTripletInStoragePath(relativeFile);
+          if (relativeFile === newFile) {
+            return;
           }
-          resolve();
-        });
-      });
-    }, f)));
+          await new Promise((resolve) => {
+            const migrate = removeOriginal ? fs__default["default"].move : fs__default["default"].copyFile;
+            this.logger.verbose(`Migrating ${relativeFile}`);
+            migrate(file, newFile, (err) => {
+              if (err) {
+                this.logger.warn(
+                  `Unable to migrate ${relativeFile}: ${err.message}`
+                );
+              }
+              resolve();
+            });
+          });
+        }, f)
+      )
+    );
   }
   staticEntityPathJoin(...allParts) {
     let staticEntityPath = this.staticDocsDir;
     allParts.map((part) => part.split(path__default["default"].sep)).flat().forEach((part, index) => {
       if (index < 3) {
-        staticEntityPath = backendCommon.resolveSafeChildPath(staticEntityPath, this.legacyPathCasing ? part : part.toLowerCase());
+        staticEntityPath = backendCommon.resolveSafeChildPath(
+          staticEntityPath,
+          this.legacyPathCasing ? part : part.toLowerCase()
+        );
         return;
       }
       staticEntityPath = backendCommon.resolveSafeChildPath(staticEntityPath, part);
@@ -1505,11 +1834,17 @@ class OpenStackSwiftPublish {
   static fromConfig(config, logger) {
     let containerName = "";
     try {
-      containerName = config.getString("techdocs.publisher.openStackSwift.containerName");
+      containerName = config.getString(
+        "techdocs.publisher.openStackSwift.containerName"
+      );
     } catch (error) {
-      throw new Error("Since techdocs.publisher.type is set to 'openStackSwift' in your app config, techdocs.publisher.openStackSwift.containerName is required.");
+      throw new Error(
+        "Since techdocs.publisher.type is set to 'openStackSwift' in your app config, techdocs.publisher.openStackSwift.containerName is required."
+      );
     }
-    const openStackSwiftConfig = config.getConfig("techdocs.publisher.openStackSwift");
+    const openStackSwiftConfig = config.getConfig(
+      "techdocs.publisher.openStackSwift"
+    );
     const storageClient = new openstackSwiftSdk.SwiftClient({
       authEndpoint: openStackSwiftConfig.getString("authUrl"),
       swiftEndpoint: openStackSwiftConfig.getString("swiftUrl"),
@@ -1520,14 +1855,20 @@ class OpenStackSwiftPublish {
   }
   async getReadiness() {
     try {
-      const container = await this.storageClient.getContainerMetadata(this.containerName);
+      const container = await this.storageClient.getContainerMetadata(
+        this.containerName
+      );
       if (!(container instanceof types.NotFound)) {
-        this.logger.info(`Successfully connected to the OpenStack Swift container ${this.containerName}.`);
+        this.logger.info(
+          `Successfully connected to the OpenStack Swift container ${this.containerName}.`
+        );
         return {
           isAvailable: true
         };
       }
-      this.logger.error(`Could not retrieve metadata about the OpenStack Swift container ${this.containerName}. Make sure the container exists. Also make sure that authentication is setup either by explicitly defining credentials and region in techdocs.publisher.openStackSwift in app config or by using environment variables. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`);
+      this.logger.error(
+        `Could not retrieve metadata about the OpenStack Swift container ${this.containerName}. Make sure the container exists. Also make sure that authentication is setup either by explicitly defining credentials and region in techdocs.publisher.openStackSwift in app config or by using environment variables. Refer to https://backstage.io/docs/features/techdocs/using-cloud-storage`
+      );
       return {
         isAvailable: false
       };
@@ -1557,12 +1898,18 @@ class OpenStackSwiftPublish {
         const uploadFile = limiter(async () => {
           const fileBuffer = await fs__default["default"].readFile(filePath);
           const stream = bufferToStream(fileBuffer);
-          return this.storageClient.upload(this.containerName, destination, stream);
+          return this.storageClient.upload(
+            this.containerName,
+            destination,
+            stream
+          );
         });
         uploadPromises.push(uploadFile);
       }
       await Promise.all(uploadPromises);
-      this.logger.info(`Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${allFilesToUpload.length}`);
+      this.logger.info(
+        `Successfully uploaded all the generated files for Entity ${entity.metadata.name}. Total number of files: ${allFilesToUpload.length}`
+      );
       return { objects };
     } catch (e) {
       const errorMessage = `Unable to upload file(s) to OpenStack Swift. ${e}`;
@@ -1573,15 +1920,22 @@ class OpenStackSwiftPublish {
   async fetchTechDocsMetadata(entityName) {
     return await new Promise(async (resolve, reject) => {
       const entityRootDir = `${entityName.namespace}/${entityName.kind}/${entityName.name}`;
-      const downloadResponse = await this.storageClient.download(this.containerName, `${entityRootDir}/techdocs_metadata.json`);
+      const downloadResponse = await this.storageClient.download(
+        this.containerName,
+        `${entityRootDir}/techdocs_metadata.json`
+      );
       if (!(downloadResponse instanceof types.NotFound)) {
         const stream = downloadResponse.data;
         try {
           const techdocsMetadataJson = await streamToBuffer(stream);
           if (!techdocsMetadataJson) {
-            throw new Error(`Unable to parse the techdocs metadata file ${entityRootDir}/techdocs_metadata.json.`);
+            throw new Error(
+              `Unable to parse the techdocs metadata file ${entityRootDir}/techdocs_metadata.json.`
+            );
           }
-          const techdocsMetadata = JSON5__default["default"].parse(techdocsMetadataJson.toString("utf-8"));
+          const techdocsMetadata = JSON5__default["default"].parse(
+            techdocsMetadataJson.toString("utf-8")
+          );
           resolve(techdocsMetadata);
         } catch (err) {
           errors.assertError(err);
@@ -1600,21 +1954,30 @@ class OpenStackSwiftPublish {
       const filePath = decodeURI(req.path.replace(/^\//, ""));
       const fileExtension = path__default["default"].extname(filePath);
       const responseHeaders = getHeadersForFileExtension(fileExtension);
-      const downloadResponse = await this.storageClient.download(this.containerName, filePath);
+      const downloadResponse = await this.storageClient.download(
+        this.containerName,
+        filePath
+      );
       if (!(downloadResponse instanceof types.NotFound)) {
         const stream = downloadResponse.data;
         try {
-          for (const [headerKey, headerValue] of Object.entries(responseHeaders)) {
+          for (const [headerKey, headerValue] of Object.entries(
+            responseHeaders
+          )) {
             res.setHeader(headerKey, headerValue);
           }
           res.send(await streamToBuffer(stream));
         } catch (err) {
           errors.assertError(err);
-          this.logger.warn(`TechDocs OpenStack swift router failed to serve content from container ${this.containerName} at path ${filePath}: ${err.message}`);
+          this.logger.warn(
+            `TechDocs OpenStack swift router failed to serve content from container ${this.containerName} at path ${filePath}: ${err.message}`
+          );
           res.status(404).send("File Not Found");
         }
       } else {
-        this.logger.warn(`TechDocs OpenStack swift router failed to serve content from container ${this.containerName} at path ${filePath}: Not found`);
+        this.logger.warn(
+          `TechDocs OpenStack swift router failed to serve content from container ${this.containerName} at path ${filePath}: Not found`
+        );
         res.status(404).send("File Not Found");
       }
     };
@@ -1622,7 +1985,10 @@ class OpenStackSwiftPublish {
   async hasDocsBeenGenerated(entity) {
     const entityRootDir = `${entity.metadata.namespace}/${entity.kind}/${entity.metadata.name}`;
     try {
-      const fileResponse = await this.storageClient.getMetadata(this.containerName, `${entityRootDir}/index.html`);
+      const fileResponse = await this.storageClient.getMetadata(
+        this.containerName,
+        `${entityRootDir}/index.html`
+      );
       if (!(fileResponse instanceof types.NotFound)) {
         return true;
       }
@@ -1639,34 +2005,47 @@ class OpenStackSwiftPublish {
   }) {
     const allObjects = await this.getAllObjectsFromContainer();
     const limiter = createLimiter__default["default"](concurrency);
-    await Promise.all(allObjects.map((f) => limiter(async (file) => {
-      let newPath;
-      try {
-        newPath = lowerCaseEntityTripletInStoragePath(file);
-      } catch (e) {
-        errors.assertError(e);
-        this.logger.warn(e.message);
-        return;
-      }
-      if (file === newPath) {
-        return;
-      }
-      try {
-        this.logger.verbose(`Migrating ${file} to ${newPath}`);
-        await this.storageClient.copy(this.containerName, file, this.containerName, newPath);
-        if (removeOriginal) {
-          await this.storageClient.delete(this.containerName, file);
-        }
-      } catch (e) {
-        errors.assertError(e);
-        this.logger.warn(`Unable to migrate ${file}: ${e.message}`);
-      }
-    }, f)));
+    await Promise.all(
+      allObjects.map(
+        (f) => limiter(async (file) => {
+          let newPath;
+          try {
+            newPath = lowerCaseEntityTripletInStoragePath(file);
+          } catch (e) {
+            errors.assertError(e);
+            this.logger.warn(e.message);
+            return;
+          }
+          if (file === newPath) {
+            return;
+          }
+          try {
+            this.logger.verbose(`Migrating ${file} to ${newPath}`);
+            await this.storageClient.copy(
+              this.containerName,
+              file,
+              this.containerName,
+              newPath
+            );
+            if (removeOriginal) {
+              await this.storageClient.delete(this.containerName, file);
+            }
+          } catch (e) {
+            errors.assertError(e);
+            this.logger.warn(`Unable to migrate ${file}: ${e.message}`);
+          }
+        }, f)
+      )
+    );
   }
   async getAllObjectsFromContainer({ prefix } = { prefix: "" }) {
     let objects = [];
     const OSS_MAX_LIMIT = Math.pow(2, 31) - 1;
-    const allObjects = await this.storageClient.list(this.containerName, prefix, OSS_MAX_LIMIT);
+    const allObjects = await this.storageClient.list(
+      this.containerName,
+      prefix,
+      OSS_MAX_LIMIT
+    );
     objects = allObjects.map((object) => object.name);
     return objects;
   }
@@ -1675,7 +2054,9 @@ class OpenStackSwiftPublish {
 class Publisher {
   static async fromConfig(config, { logger, discovery }) {
     var _a;
-    const publisherType = (_a = config.getOptionalString("techdocs.publisher.type")) != null ? _a : "local";
+    const publisherType = (_a = config.getOptionalString(
+      "techdocs.publisher.type"
+    )) != null ? _a : "local";
     switch (publisherType) {
       case "googleGcs":
         logger.info("Creating Google Storage Bucket publisher for TechDocs");
@@ -1684,10 +2065,14 @@ class Publisher {
         logger.info("Creating AWS S3 Bucket publisher for TechDocs");
         return AwsS3Publish.fromConfig(config, logger);
       case "azureBlobStorage":
-        logger.info("Creating Azure Blob Storage Container publisher for TechDocs");
+        logger.info(
+          "Creating Azure Blob Storage Container publisher for TechDocs"
+        );
         return AzureBlobStoragePublish.fromConfig(config, logger);
       case "openStackSwift":
-        logger.info("Creating OpenStack Swift Container publisher for TechDocs");
+        logger.info(
+          "Creating OpenStack Swift Container publisher for TechDocs"
+        );
         return OpenStackSwiftPublish.fromConfig(config, logger);
       case "local":
         logger.info("Creating Local publisher for TechDocs");