@platforma-sdk/block-tools 2.6.27 → 2.6.28

package/src/v2/registry/registry.test.ts

@@ -4,7 +4,7 @@ import { randomUUID } from 'crypto';
 import path from 'path';
 import fsp from 'fs/promises';
 import { BlockRegistryV2 } from './registry';
-import semver from 'semver';
+import * as semver from 'semver';
 import { UpdateSuggestions, BlockPackManifest } from '@milaboratories/pl-model-middle-layer';
 import { inferUpdateSuggestions } from './registry_reader';
 import { OverviewSnapshotsPrefix } from './schema_internal';

package/src/v2/registry/registry.ts

@@ -1,14 +1,16 @@
-import { ConsoleLoggerAdapter, MiLogger } from '@milaboratories/ts-helpers';
-import { compare as compareSemver, satisfies } from 'semver';
+import type { MiLogger } from '@milaboratories/ts-helpers';
+import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
+import { compare as compareSemver } from 'semver';
 import { gzip, gunzip } from 'node:zlib';
 import { promisify } from 'node:util';
-import { RegistryStorage } from '../../io/storage';
+import type { RegistryStorage } from '../../io/storage';
+import type {
+  BlockPackId,
+  BlockPackIdNoVersion } from '@milaboratories/pl-model-middle-layer';
 import {
   AnyChannel,
-  BlockPackId,
-  BlockPackIdNoVersion,
   blockPackIdToString,
-  BlockPackManifest
+  BlockPackManifest,
 } from '@milaboratories/pl-model-middle-layer';
 import {
   GlobalUpdateSeedInFile,
@@ -17,11 +19,9 @@ import {
   packageUpdateSeedPath,
   VersionUpdatesPrefix,
   GlobalOverviewSnapshotPattern,
-  OverviewSnapshotsPrefix,
   GlobalSnapshotsPrefix,
-  PackageSnapshotsPrefix,
   globalOverviewSnapshotPath,
-  packageOverviewSnapshotPath
+  packageOverviewSnapshotPath,
 } from './schema_internal';
 import {
   GlobalOverviewReg,
@@ -36,9 +36,10 @@ import {
   packageChannelPrefix,
   ChannelNameRegexp,
   MainPrefix,
-  PackageManifestPattern
+  PackageManifestPattern,
 } from './schema_public';
-import { BlockPackDescriptionManifestAddRelativePathPrefix, RelativeContentReader } from '../model';
+import type { RelativeContentReader } from '../model';
+import { BlockPackDescriptionManifestAddRelativePathPrefix } from '../model';
 import { randomUUID } from 'node:crypto';
 import { calculateSha256 } from '../../util';
 
@@ -53,7 +54,7 @@ export interface GlobalOverviewBackupDescription {
 
 type PackageUpdateInfo = {
   package: BlockPackIdNoVersion;
-  versions: Set<String>;
+  versions: Set<string>;
 };
 
 export class BlockRegistryV2 {
@@ -63,7 +64,7 @@ export class BlockRegistryV2 {
   constructor(
     private readonly storage: RegistryStorage,
     private readonly logger: MiLogger = new ConsoleLoggerAdapter(),
-    private readonly settings: BlockRegistrySettings = {}
+    private readonly settings: BlockRegistrySettings = {},
   ) {}
 
   private generateTimestamp(): string {
@@ -80,20 +81,20 @@ export class BlockRegistryV2 {
 
   private async createGlobalOverviewSnapshot(overviewData: string, timestamp: string): Promise<void> {
     if (this.settings.skipSnapshotCreation) return;
-    
+
     try {
       const gzippedData = await this.gzipAsync(overviewData);
       const snapshotPath = globalOverviewSnapshotPath(timestamp);
       await this.storage.putFile(snapshotPath, Buffer.from(gzippedData));
       this.logger.info(`Global overview snapshot created at ${snapshotPath}`);
     } catch (error) {
-      this.logger.warn(`Failed to create global overview snapshot: ${error}`);
+      this.logger.warn(`Failed to create global overview snapshot: ${String(error)}`);
     }
   }
 
   private async createPackageOverviewSnapshot(pkg: BlockPackIdNoVersion, overview: PackageOverview, timestamp: string): Promise<void> {
     if (this.settings.skipSnapshotCreation) return;
-    
+
     try {
       const overviewData = JSON.stringify(overview);
       const gzippedData = await this.gzipAsync(overviewData);
@@ -101,7 +102,7 @@ export class BlockRegistryV2 {
       await this.storage.putFile(snapshotPath, Buffer.from(gzippedData));
       this.logger.info(`Package overview snapshot created at ${snapshotPath} for ${pkg.organization}:${pkg.name}`);
     } catch (error) {
-      this.logger.warn(`Failed to create package overview snapshot for ${pkg.organization}:${pkg.name}: ${error}`);
+      this.logger.warn(`Failed to create package overview snapshot for ${pkg.organization}:${pkg.name}: ${String(error)}`);
     }
   }
 
@@ -118,11 +119,11 @@ export class BlockRegistryV2 {
 
     const addVersionToBeUpdated = ({ organization, name, version }: BlockPackId) => {
       const keyNoVersion = `${organization}:${name}`;
-      let update = packagesToUpdate.get(keyNoVersion);
+      const update = packagesToUpdate.get(keyNoVersion);
       if (!update) {
         packagesToUpdate.set(keyNoVersion, {
           package: { organization, name },
-          versions: new Set([version])
+          versions: new Set([version]),
         });
         return true;
       } else if (!update.versions.has(version)) {
@@ -137,7 +138,7 @@ export class BlockRegistryV2 {
       const match = seedPath.match(PackageUpdatePattern);
       if (!match) continue;
       seedPaths.push(seedPath);
-      const { organization, name, version, seed } = match.groups!;
+      const { organization, name, version, seed: _seed } = match.groups!;
       const added = addVersionToBeUpdated({ organization, name, version });
       this.logger.info(`  - ${organization}:${name}:${version} added:${added}`);
     }
@@ -156,13 +157,13 @@ export class BlockRegistryV2 {
 
     // loading global overview
     const overviewContent = await this.storage.getFile(GlobalOverviewPath);
-    
+
     // Create pre-write snapshot in force mode if overview exists
     if (mode === 'force' && overviewContent !== undefined) {
       const preWriteTimestamp = this.generatePreWriteTimestamp();
       await this.createGlobalOverviewSnapshot(overviewContent.toString(), preWriteTimestamp);
     }
-    
+
     const overview: GlobalOverviewReg = mode === 'force'
       ? { schema: 'v2', packages: [] }
       : overviewContent === undefined
@@ -176,26 +177,26 @@ export class BlockRegistryV2 {
       // reading existing overview
       const overviewFile = packageOverviewPath(packageInfo.package);
       const pOverviewContent = await this.storage.getFile(overviewFile);
-      
+
       // Create pre-write snapshot in force mode if package overview exists
       if (mode === 'force' && pOverviewContent !== undefined) {
         const preWriteTimestamp = this.generatePreWriteTimestamp();
         const existingOverview = PackageOverview.parse(JSON.parse(pOverviewContent.toString()));
         await this.createPackageOverviewSnapshot(packageInfo.package, existingOverview, preWriteTimestamp);
       }
-      
+
       const packageOverview: PackageOverview = mode === 'force'
         ? { schema: 'v2', versions: [] }
         : pOverviewContent === undefined
           ? { schema: 'v2', versions: [] }
           : PackageOverview.parse(JSON.parse(pOverviewContent.toString()));
       this.logger.info(
-        `Updating ${packageInfo.package.organization}:${packageInfo.package.name} overview${mode === 'force' ? ' (starting empty in force mode)' : ''}, ${packageOverview.versions.length} records`
+        `Updating ${packageInfo.package.organization}:${packageInfo.package.name} overview${mode === 'force' ? ' (starting empty in force mode)' : ''}, ${packageOverview.versions.length} records`,
       );
 
       // removing versions that we will update
       const newVersions = packageOverview.versions.filter(
-        (e) => !packageInfo.versions.has(e.description.id.version)
+        (e) => !packageInfo.versions.has(e.description.id.version),
       );
 
       // reading new entries
@@ -203,10 +204,10 @@ export class BlockRegistryV2 {
         const version = v.toString();
         const id: BlockPackId = {
           ...packageInfo.package,
-          version
+          version,
         };
         const manifestContent = await this.storage.getFile(
-          packageContentPrefix(id) + ManifestSuffix
+          packageContentPrefix(id) + ManifestSuffix,
         );
         if (!manifestContent) continue; // absent package
         const sha256 = await calculateSha256(manifestContent);
@@ -221,16 +222,16 @@ export class BlockRegistryV2 {
         // pushing the overview
         newVersions.push({
           description: BlockPackDescriptionManifestAddRelativePathPrefix(version).parse(
-            BlockPackManifest.parse(JSON.parse(manifestContent.toString('utf8'))).description
+            BlockPackManifest.parse(JSON.parse(manifestContent.toString('utf8'))).description,
           ),
           manifestSha256: sha256,
-          channels
+          channels,
         });
       }
 
       // sorting entries according to version
       newVersions.sort((e1, e2) =>
-        compareSemver(e2.description.id.version, e1.description.id.version)
+        compareSemver(e2.description.id.version, e1.description.id.version),
       );
 
       // write package overview back
@@ -238,9 +239,9 @@ export class BlockRegistryV2 {
       if (mode !== 'dry-run') {
         await this.storage.putFile(
           overviewFile,
-          Buffer.from(JSON.stringify(packageOverviewData))
+          Buffer.from(JSON.stringify(packageOverviewData)),
         );
-        
+
         // Create snapshot after successful write
         await this.createPackageOverviewSnapshot(packageInfo.package, packageOverviewData, snapshotTimestamp);
       }
@@ -253,16 +254,16 @@ export class BlockRegistryV2 {
       // patching corresponding entry in overview
       overviewPackages = overviewPackages.filter(
         (e) =>
-          e.id.organization !== packageInfo.package.organization ||
-          e.id.name !== packageInfo.package.name
+          e.id.organization !== packageInfo.package.organization
+          || e.id.name !== packageInfo.package.name,
       );
       const relativeDescriptionSchema = BlockPackDescriptionManifestAddRelativePathPrefix(
-        `${packageInfo.package.organization}/${packageInfo.package.name}`
+        `${packageInfo.package.organization}/${packageInfo.package.name}`,
       );
       overviewPackages.push({
         id: {
           organization: packageInfo.package.organization,
-          name: packageInfo.package.name
+          name: packageInfo.package.name,
         },
         // left for backward compatibility
         allVersions: newVersions.map((e) => e.description.id.version).reverse(),
@@ -282,11 +283,11 @@ export class BlockRegistryV2 {
               c,
               {
                 description: relativeDescriptionSchema.parse(v.description),
-                manifestSha256: v?.manifestSha256
-              }
+                manifestSha256: v?.manifestSha256,
+              },
             ];
-          })
-        )
+          }),
+        ),
       });
     }
 
@@ -294,14 +295,14 @@ export class BlockRegistryV2 {
     if (mode !== 'dry-run') {
       const overviewData = JSON.stringify({ schema: 'v2', packages: overviewPackages } satisfies GlobalOverviewReg);
       const overviewBuffer = Buffer.from(overviewData);
-      
+
       // Write regular overview file
       await this.storage.putFile(GlobalOverviewPath, overviewBuffer);
-      
+
       // Write gzipped overview file
       const gzippedBuffer = await this.gzipAsync(overviewData);
       await this.storage.putFile(GlobalOverviewGzPath, Buffer.from(gzippedBuffer));
-      
+
       // Create snapshot after successful writes
       await this.createGlobalOverviewSnapshot(overviewData, snapshotTimestamp);
     }
@@ -324,10 +325,10 @@ export class BlockRegistryV2 {
       return;
     }
     if (
-      mode !== 'force' &&
-      updateRequestSeed !== undefined &&
-      currentUpdatedSeed !== undefined &&
-      updateRequestSeed.equals(currentUpdatedSeed)
+      mode !== 'force'
+      && updateRequestSeed !== undefined
+      && currentUpdatedSeed !== undefined
+      && updateRequestSeed.equals(currentUpdatedSeed)
     ) {
       this.logger.info(`Registry is up to date.`);
       return;
@@ -343,7 +344,7 @@ export class BlockRegistryV2 {
   }
 
   public async getPackageOverview(
-    name: BlockPackIdNoVersion
+    name: BlockPackIdNoVersion,
   ): Promise<undefined | PackageOverview> {
     const content = await this.storage.getFile(packageOverviewPath(name));
     if (content === undefined) return undefined;
@@ -395,20 +396,20 @@ export class BlockRegistryV2 {
   public async listGlobalOverviewSnapshots(): Promise<GlobalOverviewBackupDescription[]> {
     const snapshotPaths = await this.storage.listFiles(GlobalSnapshotsPrefix);
     const snapshots: GlobalOverviewBackupDescription[] = [];
-    
+
     for (const path of snapshotPaths) {
       // Extract filename from path
       const filename = path.indexOf('/') === -1 ? path : path.substring(path.lastIndexOf('/') + 1);
-      
+
       const match = filename.match(GlobalOverviewSnapshotPattern);
       if (match) {
         snapshots.push({
           timestamp: match.groups!.timestamp,
-          path: GlobalSnapshotsPrefix + filename
+          path: GlobalSnapshotsPrefix + filename,
         });
       }
     }
-    
+
     // Sort by timestamp descending (newest first)
     snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
     return snapshots;
@@ -416,36 +417,36 @@ export class BlockRegistryV2 {
 
   public async restoreGlobalOverviewFromSnapshot(backupId: string): Promise<void> {
     const snapshotPath = globalOverviewSnapshotPath(backupId);
-    
+
     // Read and decompress the snapshot
     const snapshotData = await this.storage.getFile(snapshotPath);
     if (!snapshotData) {
       throw new Error(`Snapshot ${backupId} not found at ${snapshotPath}`);
     }
-    
+
     const decompressedData = await this.gunzipAsync(snapshotData);
     const overviewData = decompressedData.toString('utf8');
-    
+
     // Validate the data
     try {
       GlobalOverviewReg.parse(JSON.parse(overviewData));
     } catch (error) {
-      throw new Error(`Invalid snapshot data in ${backupId}: ${error}`);
+      throw new Error(`Invalid snapshot data in ${backupId}: ${String(error)}`);
     }
-    
+
     // Write both regular and gzipped versions
     const overviewBuffer = Buffer.from(overviewData);
     await this.storage.putFile(GlobalOverviewPath, overviewBuffer);
-    
+
     const gzippedBuffer = await this.gzipAsync(overviewData);
     await this.storage.putFile(GlobalOverviewGzPath, Buffer.from(gzippedBuffer));
-    
+
     this.logger.info(`Global overview restored from snapshot ${backupId}`);
   }
 
   public async publishPackage(
     manifest: BlockPackManifest,
-    fileReader: RelativeContentReader
+    fileReader: RelativeContentReader,
   ): Promise<void> {
     const prefix = packageContentPrefix(manifest.description.id);
     // uploading content files
@@ -453,12 +454,12 @@ export class BlockRegistryV2 {
       const bytes = await fileReader(f.name);
       if (bytes.length !== f.size)
         throw new Error(
-          `Actual file size don't match file size from the manifest file for ${f.name} (actual = ${bytes.length}; manifest = ${f.size})`
+          `Actual file size don't match file size from the manifest file for ${f.name} (actual = ${bytes.length}; manifest = ${f.size})`,
         );
       const sha256 = await calculateSha256(bytes);
       if (sha256 !== f.sha256.toUpperCase())
         throw new Error(
-          `Actual file SHA-256 don't match the checksum from the manifest file for ${f.name} (actual = ${sha256}; manifest = ${f.sha256.toUpperCase()})`
+          `Actual file SHA-256 don't match the checksum from the manifest file for ${f.name} (actual = ${sha256}; manifest = ${f.sha256.toUpperCase()})`,
         );
 
       const dst = prefix + '/' + f.name;

package/src/v2/registry/registry_reader.ts

@@ -1,17 +1,18 @@
-import {
+import type {
   BlockPackId,
   BlockPackIdNoVersion,
-  blockPackIdNoVersionEquals,
-  BlockPackManifest,
   BlockPackMetaEmbeddedBytes,
   BlockPackMetaManifest,
-  BlockPackOverview,
   UpdateSuggestions,
   SingleBlockPackOverview,
+  BlockPackOverviewNoRegistryId,
+} from '@milaboratories/pl-model-middle-layer';
+import {
+  blockPackIdNoVersionEquals,
+  BlockPackManifest,
   AnyChannel,
-  BlockPackOverviewNoRegistryId
 } from '@milaboratories/pl-model-middle-layer';
-import { FolderReader } from '../../io';
+import type { FolderReader } from '../../io';
 import canonicalize from 'canonicalize';
 import {
   GlobalOverviewFileName,
@@ -19,11 +20,11 @@ import {
   MainPrefix,
   ManifestFileName,
   ManifestSuffix,
-  packageContentPrefixInsideV2
+  packageContentPrefixInsideV2,
 } from './schema_public';
 import { BlockComponentsAbsoluteUrl, BlockPackMetaEmbedBytes } from '../model';
 import { LRUCache } from 'lru-cache';
-import semver from 'semver';
+import * as semver from 'semver';
 import { calculateSha256 } from '../../util';
 import { retry, Retry2TimesWithDelay } from '@milaboratories/ts-helpers';
 
@@ -36,7 +37,7 @@ export type RegistryV2ReaderOps = {
 
 const DefaultRegistryV2ReaderOps: RegistryV2ReaderOps = {
   cacheBlockListFor: 45e3, // 45 seconds
-  keepStaleBlockListFor: 300e3 // 5 minutes
+  keepStaleBlockListFor: 300e3, // 5 minutes
 };
 
 /** @param availableVersions must be reverse sorted (from highest version to lowest) */
@@ -49,7 +50,7 @@ export function inferUpdateSuggestions(currentVersion: string, availableVersions
   const suggestions: UpdateSuggestions<string> = [];
 
   const patch = availableVersions.find(
-    (v) => semver.gt(v, currentVersion) && semver.lt(v, nextMinor)
+    (v) => semver.gt(v, currentVersion) && semver.lt(v, nextMinor),
   );
   const minor = availableVersions.find((v) => semver.gte(v, nextMinor) && semver.lt(v, nextMajor));
   const major = availableVersions.find((v) => semver.gte(v, nextMajor));
@@ -67,7 +68,7 @@ export class RegistryV2Reader {
 
   constructor(
     private readonly registryReader: FolderReader,
-    ops?: Partial<RegistryV2ReaderOps>
+    ops?: Partial<RegistryV2ReaderOps>,
   ) {
     this.v2RootFolderReader = registryReader.relativeReader(MainPrefix);
     this.ops = { ...DefaultRegistryV2ReaderOps, ...(ops ?? {}) };
@@ -86,25 +87,25 @@ export class RegistryV2Reader {
     max: 500,
     fetchMethod: async (_key, _staleValue, options) =>
       await retry(async () => {
-        const contentReader =
-          options.context.relativeTo !== undefined
+        const contentReader
+          = options.context.relativeTo !== undefined
             ? this.v2RootFolderReader
-                .relativeReader(packageContentPrefixInsideV2(options.context.relativeTo))
-                .getContentReader()
+              .relativeReader(packageContentPrefixInsideV2(options.context.relativeTo))
+              .getContentReader()
             : this.v2RootFolderReader.getContentReader();
         return await BlockPackMetaEmbedBytes(contentReader).parseAsync(options.context.meta);
-      }, Retry2TimesWithDelay)
+      }, Retry2TimesWithDelay),
   });
 
   private async embedMetaContent(
     id: BlockPackId,
     sha256: string,
     absolutePath: boolean,
-    meta: BlockPackMetaManifest
+    meta: BlockPackMetaManifest,
   ): Promise<BlockPackMetaEmbeddedBytes> {
     return await this.embeddedGlobalMetaCache.forceFetch(
       canonicalize({ id, sha256, absolutePath })!,
-      { context: { meta, relativeTo: absolutePath ? undefined : id } }
+      { context: { meta, relativeTo: absolutePath ? undefined : id } },
     );
   }
 
@@ -113,8 +114,8 @@ export class RegistryV2Reader {
 
   public async listBlockPacks(): Promise<BlockPackOverviewNoRegistryId[]> {
     if (
-      this.listCache !== undefined &&
-      Date.now() - this.listCacheTimestamp <= this.ops.cacheBlockListFor
+      this.listCache !== undefined
+      && Date.now() - this.listCacheTimestamp <= this.ops.cacheBlockListFor
     )
       return this.listCache;
     try {
@@ -122,8 +123,8 @@ export class RegistryV2Reader {
         // const rootContentReader = this.v2RootFolderReader.getContentReader();
         const globalOverview = GlobalOverviewReg.parse(
           JSON.parse(
-            Buffer.from(await this.v2RootFolderReader.readFile(GlobalOverviewFileName)).toString()
-          )
+            Buffer.from(await this.v2RootFolderReader.readFile(GlobalOverviewFileName)).toString(),
+          ),
         );
 
         const result = await Promise.all(
@@ -137,24 +138,24 @@ export class RegistryV2Reader {
                     data.description.id,
                     data.manifestSha256,
                     true,
-                    data.description.meta
+                    data.description.meta,
                   ),
                   featureFlags: data.description.featureFlags,
                   spec: {
                     type: 'from-registry-v2',
                     id: data.description.id,
                     registryUrl: this.registryReader.rootUrl.toString(),
-                    channel
-                  }
-                }
-              ])
+                    channel,
+                  },
+                },
+              ]),
             );
             return {
               id: p.id,
-              latestByChannel: Object.fromEntries(byChannelEntries),
-              allVersions: p.allVersionsWithChannels
+              latestByChannel: Object.fromEntries(byChannelEntries) as BlockPackOverviewNoRegistryId['latestByChannel'],
+              allVersions: p.allVersionsWithChannels,
             } satisfies BlockPackOverviewNoRegistryId;
-          })
+          }),
         );
 
         this.listCache = result;
@@ -164,8 +165,8 @@ export class RegistryV2Reader {
       }, Retry2TimesWithDelay);
     } catch (e: unknown) {
       if (
-        this.listCache !== undefined &&
-        Date.now() - this.listCacheTimestamp <= this.ops.keepStaleBlockListFor
+        this.listCache !== undefined
+        && Date.now() - this.listCacheTimestamp <= this.ops.keepStaleBlockListFor
       )
         return this.listCache;
       throw e;
@@ -174,10 +175,10 @@ export class RegistryV2Reader {
 
   public async getLatestOverview(
     id: BlockPackIdNoVersion,
-    channel: string
+    channel: string,
   ): Promise<SingleBlockPackOverview | undefined> {
     const overview = (await this.listBlockPacks()).find((e) =>
-      blockPackIdNoVersionEquals(id, e.id)
+      blockPackIdNoVersionEquals(id, e.id),
     );
     if (overview === undefined) return undefined;
     return overview.latestByChannel[channel];
@@ -185,10 +186,10 @@ export class RegistryV2Reader {
 
   public async getUpdateSuggestions(
     id: BlockPackId,
-    channel: string
+    channel: string,
   ): Promise<UpdateSuggestions<string> | undefined> {
     const overview = (await this.listBlockPacks()).find((e) =>
-      blockPackIdNoVersionEquals(id, e.id)
+      blockPackIdNoVersionEquals(id, e.id),
     );
     if (overview === undefined) return undefined;
 
@@ -204,11 +205,11 @@ export class RegistryV2Reader {
 
   public async getSpecificOverview(
     id: BlockPackId,
-    channel: string
+    channel: string,
   ): Promise<SingleBlockPackOverview> {
     return await retry(async () => {
       const manifestContent = await this.v2RootFolderReader.readFile(
-        packageContentPrefixInsideV2(id) + ManifestSuffix
+        packageContentPrefixInsideV2(id) + ManifestSuffix,
       );
       const overview = BlockPackManifest.parse(JSON.parse(Buffer.from(manifestContent).toString()));
       return {
@@ -217,32 +218,32 @@ export class RegistryV2Reader {
           id,
           await calculateSha256(manifestContent),
           false,
-          overview.description.meta
+          overview.description.meta,
         ),
         spec: {
           type: 'from-registry-v2',
           id,
           registryUrl: this.registryReader.rootUrl.toString(),
-          channel
-        }
+          channel,
+        },
       };
     }, Retry2TimesWithDelay);
   }
 
   private readonly componentsCache = new LRUCache<string, BlockComponentsAbsoluteUrl, BlockPackId>({
     max: 500,
-    fetchMethod: async (key, staleValue, { context: id }) =>
+    fetchMethod: async (_key, _staleValue, { context: id }) =>
       await retry(async () => {
         const packageFolderReader = this.v2RootFolderReader.relativeReader(
-          packageContentPrefixInsideV2(id)
+          packageContentPrefixInsideV2(id),
         );
         const manifest = BlockPackManifest.parse(
-          JSON.parse(Buffer.from(await packageFolderReader.readFile(ManifestFileName)).toString())
+          JSON.parse(Buffer.from(await packageFolderReader.readFile(ManifestFileName)).toString()),
         );
         return BlockComponentsAbsoluteUrl(packageFolderReader.rootUrl.toString()).parse(
-          manifest.description.components
+          manifest.description.components,
         );
-      }, Retry2TimesWithDelay)
+      }, Retry2TimesWithDelay),
   });
 
   public async getComponents(id: BlockPackId): Promise<BlockComponentsAbsoluteUrl> {

package/src/v2/registry/schema_internal.ts

@@ -1,4 +1,4 @@
-import { BlockPackId, BlockPackIdNoVersion } from '@milaboratories/pl-model-middle-layer';
+import type { BlockPackId, BlockPackIdNoVersion } from '@milaboratories/pl-model-middle-layer';
 
 export const VersionUpdatesPrefix = '_updates_v2/per_package_version/';
 
@@ -6,8 +6,8 @@ export function packageUpdateSeedPath(bp: BlockPackId, seed: string): string {
   return `${VersionUpdatesPrefix}${bp.organization}/${bp.name}/${bp.version}/${seed}`;
 }
 
-export const PackageUpdatePattern =
-  /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<name>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/;
+export const PackageUpdatePattern
+  = /(?<packageKeyWithoutVersion>(?<organization>[^/]+)\/(?<name>[^/]+))\/(?<version>[^/]+)\/(?<seed>[^/]+)$/;
 
 export const GlobalUpdateSeedInFile = '_updates_v2/_global_update_in';
 export const GlobalUpdateSeedOutFile = '_updates_v2/_global_update_out';