@platforma-sdk/block-tools 2.6.44 → 2.6.45

package/src/io/folder_reader.ts

@@ -1,10 +1,10 @@
-import type { Dispatcher } from 'undici';
-import { request } from 'undici';
-import type { RelativeContentReader } from '../v2';
-import path from 'node:path';
-import pathPosix from 'node:path/posix';
-import fsp from 'node:fs/promises';
-import { defaultHttpDispatcher } from '@milaboratories/pl-http';
+import type { Dispatcher } from "undici";
+import { request } from "undici";
+import type { RelativeContentReader } from "../v2";
+import path from "node:path";
+import pathPosix from "node:path/posix";
+import fsp from "node:fs/promises";
+import { defaultHttpDispatcher } from "@milaboratories/pl-http";
 
 export interface FolderReader {
   readonly rootUrl: URL;
@@ -28,14 +28,13 @@ class HttpFolderReader implements FolderReader {
   }
 
   public relativeReader(relativePath: string): HttpFolderReader {
-    if (!relativePath.endsWith('/')) relativePath = relativePath + '/';
+    if (!relativePath.endsWith("/")) relativePath = relativePath + "/";
     return new HttpFolderReader(new URL(relativePath, this.rootUrl), this.httpDispatcher);
   }
 
   public getContentReader(relativePath?: string): RelativeContentReader {
-    const reader: HttpFolderReader = relativePath !== undefined
-      ? this.relativeReader(relativePath)
-      : this;
+    const reader: HttpFolderReader =
+      relativePath !== undefined ? this.relativeReader(relativePath) : this;
     return (path) => reader.readFile(path);
   }
 }
@@ -52,7 +51,7 @@ class FSFolderReader implements FolderReader {
   }
 
   public relativeReader(relativePath: string): FSFolderReader {
-    if (!relativePath.endsWith('/')) relativePath = relativePath + '/';
+    if (!relativePath.endsWith("/")) relativePath = relativePath + "/";
     return new FSFolderReader(
       new URL(relativePath, this.rootUrl),
       path.join(this.root, ...relativePath.split(pathPosix.sep)),
@@ -60,9 +59,8 @@ class FSFolderReader implements FolderReader {
   }
 
   public getContentReader(relativePath?: string): RelativeContentReader {
-    const reader: FSFolderReader = relativePath !== undefined
-      ? this.relativeReader(relativePath)
-      : this;
+    const reader: FSFolderReader =
+      relativePath !== undefined ? this.relativeReader(relativePath) : this;
     return (path) => reader.readFile(path);
   }
 }
@@ -76,15 +74,15 @@ function localToPosix(p: string): string {
 }
 
 export function folderReaderByUrl(address: string, httpDispatcher?: Dispatcher): FolderReader {
-  if (!address.endsWith('/')) address = address + '/';
-  const url = new URL(address, `file:${localToPosix(path.resolve('.'))}/`);
+  if (!address.endsWith("/")) address = address + "/";
+  const url = new URL(address, `file:${localToPosix(path.resolve("."))}/`);
   switch (url.protocol) {
-    case 'file:': {
+    case "file:": {
       const rootPath = posixToLocalPath(url.pathname);
       return new FSFolderReader(url, rootPath);
     }
-    case 'https:':
-    case 'http:':
+    case "https:":
+    case "http:":
       return new HttpFolderReader(url, httpDispatcher ?? defaultHttpDispatcher());
     default:
       throw new Error(`Unknown protocol: ${url.protocol}`);

package/src/io/index.ts

@@ -1,2 +1,2 @@
-export * from './folder_reader';
-export * from './storage';
+export * from "./folder_reader";
+export * from "./storage";

package/src/io/storage.test.ts

@@ -1,46 +1,46 @@
-import { randomUUID } from 'node:crypto';
-import { test, expect } from 'vitest';
-import { S3Storage, storageByUrl } from './storage';
-import path from 'node:path';
-import * as fs from 'node:fs';
+import { randomUUID } from "node:crypto";
+import { test, expect } from "vitest";
+import { S3Storage, storageByUrl } from "./storage";
+import path from "node:path";
+import * as fs from "node:fs";
 
-test('file url test #1', async () => {
-  const url = new URL('file:./local/path', 'file://' + path.resolve('.') + '/');
-  expect(url.pathname).toEqual(path.resolve('./local/path'));
+test("file url test #1", async () => {
+  const url = new URL("file:./local/path", "file://" + path.resolve(".") + "/");
+  expect(url.pathname).toEqual(path.resolve("./local/path"));
 });
 
-test('file url test #2', async () => {
-  const url = new URL('http://a/b/c', 'file://' + path.resolve('.') + '/');
-  expect(url.toString()).toEqual('http://a/b/c');
+test("file url test #2", async () => {
+  const url = new URL("http://a/b/c", "file://" + path.resolve(".") + "/");
+  expect(url.toString()).toEqual("http://a/b/c");
 });
 
-test('test local fs read write', async () => {
+test("test local fs read write", async () => {
   const uuid = randomUUID().toString();
-  const tmp = path.resolve('tmp');
+  const tmp = path.resolve("tmp");
   const storagePath = path.resolve(tmp, uuid);
-  const storage = storageByUrl('file://' + storagePath);
-  expect(await storage.getFile('some/deep/file.txt')).toBeUndefined();
-  await storage.putFile('some/deep/file.txt', Buffer.from('test1'));
-  expect((await storage.getFile('some/deep/file.txt'))?.toString()).toEqual('test1');
+  const storage = storageByUrl("file://" + storagePath);
+  expect(await storage.getFile("some/deep/file.txt")).toBeUndefined();
+  await storage.putFile("some/deep/file.txt", Buffer.from("test1"));
+  expect((await storage.getFile("some/deep/file.txt"))?.toString()).toEqual("test1");
   await fs.promises.rm(storagePath, { recursive: true });
 });
 
-test('test local fs list', async () => {
+test("test local fs list", async () => {
   const uuid = randomUUID().toString();
-  const tmp = path.resolve('tmp');
+  const tmp = path.resolve("tmp");
   const storagePath = path.resolve(tmp, uuid);
-  const storage = storageByUrl('file://' + storagePath);
-  await storage.putFile('some/deep1/file_1.txt', Buffer.from('test1'));
-  await storage.putFile('some/deep1/file_2.txt', Buffer.from('test1'));
-  await storage.putFile('some/deep2/file_1.txt', Buffer.from('test1'));
-  const result = await storage.listFiles('some');
+  const storage = storageByUrl("file://" + storagePath);
+  await storage.putFile("some/deep1/file_1.txt", Buffer.from("test1"));
+  await storage.putFile("some/deep1/file_2.txt", Buffer.from("test1"));
+  await storage.putFile("some/deep2/file_1.txt", Buffer.from("test1"));
+  const result = await storage.listFiles("some");
   result.sort();
-  const expected = ['deep2/file_1.txt', 'deep1/file_1.txt', 'deep1/file_2.txt'];
+  const expected = ["deep2/file_1.txt", "deep1/file_1.txt", "deep1/file_2.txt"];
   expected.sort();
   expect(result).toEqual(expected);
-  await storage.deleteFiles('some/deep2/file_1.txt');
-  expected.splice(expected.indexOf('some/deep2/file_1.txt'), 1);
-  const result1 = await storage.listFiles('some');
+  await storage.deleteFiles("some/deep2/file_1.txt");
+  expected.splice(expected.indexOf("some/deep2/file_1.txt"), 1);
+  const result1 = await storage.listFiles("some");
   result1.sort();
   expect(result1).toEqual(expected);
   await fs.promises.rm(storagePath, { recursive: true });
@@ -48,38 +48,38 @@ test('test local fs list', async () => {
 
 const testS3Address = process.env.TEST_S3_ADDRESS;
 if (testS3Address) {
-  test('test s3 read write', async () => {
+  test("test s3 read write", async () => {
     const uuid = randomUUID().toString();
     const testS3AddressURL = new URL(testS3Address);
-    testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, '')}/${uuid}`;
+    testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, "")}/${uuid}`;
     const storage = storageByUrl(testS3AddressURL.toString()) as S3Storage;
-    expect(await storage.getFile('some/deep/file.txt')).toBeUndefined();
-    await storage.putFile('some/deep/file.txt', Buffer.from('test1'));
-    expect((await storage.getFile('some/deep/file.txt'))?.toString()).toEqual('test1');
+    expect(await storage.getFile("some/deep/file.txt")).toBeUndefined();
+    await storage.putFile("some/deep/file.txt", Buffer.from("test1"));
+    expect((await storage.getFile("some/deep/file.txt"))?.toString()).toEqual("test1");
     await storage.deleteFiles(`some/deep/file.txt`);
-    expect(await storage.getFile('some/deep/file.txt')).toBeUndefined();
+    expect(await storage.getFile("some/deep/file.txt")).toBeUndefined();
   });
 
-  test('test s3 fs list', async () => {
+  test("test s3 fs list", async () => {
     const uuid = randomUUID().toString();
     const testS3AddressURL = new URL(testS3Address);
-    testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, '')}/${uuid}`;
+    testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, "")}/${uuid}`;
     const storage = storageByUrl(testS3AddressURL.toString()) as S3Storage;
 
-    const nonExistingFolderListing = await storage.listFiles('not_existing_folder');
+    const nonExistingFolderListing = await storage.listFiles("not_existing_folder");
     expect(nonExistingFolderListing).toEqual([]);
 
-    await storage.putFile('some/deep1/file_1.txt', Buffer.from('test1'));
-    await storage.putFile('some/deep1/file_2.txt', Buffer.from('test1'));
-    await storage.putFile('some/deep2/file_1.txt', Buffer.from('test1'));
-    const result = await storage.listFiles('some');
+    await storage.putFile("some/deep1/file_1.txt", Buffer.from("test1"));
+    await storage.putFile("some/deep1/file_2.txt", Buffer.from("test1"));
+    await storage.putFile("some/deep2/file_1.txt", Buffer.from("test1"));
+    const result = await storage.listFiles("some");
     result.sort();
-    const expected = ['deep2/file_1.txt', 'deep1/file_1.txt', 'deep1/file_2.txt'];
+    const expected = ["deep2/file_1.txt", "deep1/file_1.txt", "deep1/file_2.txt"];
     expected.sort();
     expect(result).toEqual(expected);
-    await storage.deleteFiles('some/deep2/file_1.txt');
-    expected.splice(expected.indexOf('some/deep2/file_1.txt'), 1);
-    const result1 = await storage.listFiles('some');
+    await storage.deleteFiles("some/deep2/file_1.txt");
+    expected.splice(expected.indexOf("some/deep2/file_1.txt"), 1);
+    const result1 = await storage.listFiles("some");
     result1.sort();
     expect(result1).toEqual(expected);
     await storage.client.deleteObjects({
@@ -88,9 +88,9 @@ if (testS3Address) {
         Objects: [
           { Key: `${storage.root}/some/deep1/file_1.txt` },
           { Key: `${storage.root}/some/deep1/file_2.txt` },
-          { Key: `${storage.root}/some/deep2/file_1.txt` }
-        ]
-      }
+          { Key: `${storage.root}/some/deep2/file_1.txt` },
+        ],
+      },
     });
   });
 }

package/src/io/storage.ts

@@ -1,7 +1,7 @@
-import pathPosix from 'node:path/posix';
-import path from 'node:path';
-import { paginateListObjectsV2, S3 } from '@aws-sdk/client-s3';
-import * as fs from 'node:fs';
+import pathPosix from "node:path/posix";
+import path from "node:path";
+import { paginateListObjectsV2, S3 } from "@aws-sdk/client-s3";
+import * as fs from "node:fs";
 
 export interface RegistryStorage {
   putFile(file: string, buffer: Buffer): Promise<void>;
@@ -31,7 +31,7 @@ export class S3Storage implements RegistryStorage {
         ).Body!.transformToByteArray(),
       );
     } catch (e: unknown) {
-      if (e instanceof Error && e.name === 'NoSuchKey') return undefined;
+      if (e instanceof Error && e.name === "NoSuchKey") return undefined;
       else throw e;
     }
   }
@@ -70,7 +70,9 @@ export class S3Storage implements RegistryStorage {
       },
     });
     if (results.Errors !== undefined && results.Errors.length > 0)
-      throw new Error(`Errors encountered while deleting files: ${results.Errors.map((e) => e.Message ?? e.Code ?? 'Unknown error').join('\n')}`);
+      throw new Error(
+        `Errors encountered while deleting files: ${results.Errors.map((e) => e.Message ?? e.Code ?? "Unknown error").join("\n")}`,
+      );
   }
 }
 
@@ -83,7 +85,7 @@ export class FSStorage implements RegistryStorage {
   }
 
   private toAbsolutePath(localPath: string): string {
-    if (pathPosix.isAbsolute(localPath)) throw new Error('absolute path');
+    if (pathPosix.isAbsolute(localPath)) throw new Error("absolute path");
     return path.resolve(this.root, localPath.split(pathPosix.sep).join(path.sep));
   }
 
@@ -91,7 +93,7 @@ export class FSStorage implements RegistryStorage {
     try {
       return await fs.promises.readFile(this.toAbsolutePath(address));
     } catch (err: unknown) {
-      if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return undefined;
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") return undefined;
       else throw err;
     }
   }
@@ -102,10 +104,13 @@ export class FSStorage implements RegistryStorage {
       return (await fs.promises.readdir(listRoot, { recursive: true, withFileTypes: true }))
         .filter((e) => e.isFile())
         .map((e) =>
-          path.relative(listRoot, path.resolve(e.parentPath, e.name)).split(path.sep).join(pathPosix.sep),
+          path
+            .relative(listRoot, path.resolve(e.parentPath, e.name))
+            .split(path.sep)
+            .join(pathPosix.sep),
         );
     } catch (err: unknown) {
-      if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return [];
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") return [];
       else throw err;
     }
   }
@@ -123,18 +128,18 @@ export class FSStorage implements RegistryStorage {
 }
 
 export function storageByUrl(address: string): RegistryStorage {
-  const url = new URL(address, `file:${path.resolve('.').split(path.sep).join(pathPosix.sep)}/`);
+  const url = new URL(address, `file:${path.resolve(".").split(path.sep).join(pathPosix.sep)}/`);
   switch (url.protocol) {
-    case 'file:': {
+    case "file:": {
       const root = path.resolve(url.pathname);
       return new FSStorage(root);
     }
-    case 's3:': {
+    case "s3:": {
       const options: NonNullable<ConstructorParameters<typeof S3>[0]> = {};
-      const region = url.searchParams.get('region');
+      const region = url.searchParams.get("region");
       if (region) options.region = region;
       const bucket = url.hostname;
-      return new S3Storage(new S3(options), bucket, url.pathname.replace(/^\//, ''));
+      return new S3Storage(new S3(options), bucket, url.pathname.replace(/^\//, ""));
     }
     default:
       throw new Error(`Unknown protocol: ${url.protocol}`);

package/src/lib.ts

@@ -1,3 +1,3 @@
-export * as RegistryV1 from './registry_v1';
-export * from './io';
-export * from './v2';
+export * as RegistryV1 from "./registry_v1";
+export * from "./io";
+export * from "./v2";

package/src/registry_v1/config.ts

@@ -1,16 +1,16 @@
-import YAML from 'yaml';
-import { tryLoadFile } from '../util';
+import YAML from "yaml";
+import { tryLoadFile } from "../util";
 import {
   PlPackageJsonConfigFile,
   PlPackageYamlConfigFile,
   PlRegFullPackageConfigData,
   PlRegPackageConfigDataShard,
-} from './config_schema';
-import * as os from 'node:os';
-import { BlockRegistry } from './registry';
-import { storageByUrl } from '../io/storage';
-import type { FullBlockPackageName } from './v1_repo_schema';
-import type { MiLogger } from '@milaboratories/ts-helpers';
+} from "./config_schema";
+import * as os from "node:os";
+import { BlockRegistry } from "./registry";
+import { storageByUrl } from "../io/storage";
+import type { FullBlockPackageName } from "./v1_repo_schema";
+import type { MiLogger } from "@milaboratories/ts-helpers";
 
 function mergeConfigs(
   c1: PlRegPackageConfigDataShard,
@@ -40,8 +40,8 @@ async function tryLoadYamlConfigFromFile(
 async function loadConfigShard(): Promise<PlRegPackageConfigDataShard> {
   let conf = PlRegPackageConfigDataShard.parse({});
 
-  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile('./.pl.reg.json'));
-  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile('./.pl.reg.yaml'));
+  conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile("./.pl.reg.json"));
+  conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile("./.pl.reg.yaml"));
   conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile(`${os.homedir()}/.pl.reg.json`));
   conf = mergeConfigs(conf, await tryLoadYamlConfigFromFile(`${os.homedir()}/.pl.reg.yaml`));
   conf = mergeConfigs(conf, await tryLoadJsonConfigFromFile(PlPackageJsonConfigFile));
@@ -66,7 +66,7 @@ export class PlRegPackageConfig {
 
   createRegistry(logger?: MiLogger): BlockRegistry {
     let address = this.conf.registry;
-    if (!address.startsWith('file:') && !address.startsWith('s3:')) {
+    if (!address.startsWith("file:") && !address.startsWith("s3:")) {
       const regByAlias = this.conf.registries[address];
       if (!regByAlias) throw new Error(`Registry with alias "${address}" not found`);
       address = regByAlias;

package/src/registry_v1/config_schema.ts

@@ -1,6 +1,6 @@
-import { z } from 'zod';
-import { PlRegAddress } from '../common_types';
-import { SemVer } from '@milaboratories/pl-model-middle-layer';
+import { z } from "zod";
+import { PlRegAddress } from "../common_types";
+import { SemVer } from "@milaboratories/pl-model-middle-layer";
 
 export const PlPackageConfigData = z.object({
   organization: z.string(),
@@ -26,5 +26,5 @@ export const PlRegPackageConfigDataShard = PlRegFullPackageConfigData.partial().
 });
 export type PlRegPackageConfigDataShard = z.infer<typeof PlRegPackageConfigDataShard>;
 
-export const PlPackageJsonConfigFile = 'pl.package.json';
-export const PlPackageYamlConfigFile = 'pl.package.yaml';
+export const PlPackageJsonConfigFile = "pl.package.json";
+export const PlPackageYamlConfigFile = "pl.package.yaml";

package/src/registry_v1/flags.ts

@@ -1,5 +1,5 @@
-import { Flags } from '@oclif/core';
-import path from 'node:path';
+import { Flags } from "@oclif/core";
+import path from "node:path";
 
 export interface TargetFile {
   src: string;
@@ -17,8 +17,8 @@ function parseTargetFile(arg: string): TargetFile {
 }
 
 export const targetFile = Flags.custom<TargetFile>({
-  summary: 'target files to upload',
-  helpValue: 'file_path | package_name=file_path',
+  summary: "target files to upload",
+  helpValue: "file_path | package_name=file_path",
   // eslint-disable-next-line @typescript-eslint/require-await -- oclif requires async but parsing is sync
   parse: async (arg) => parseTargetFile(arg),
 });

package/src/registry_v1/index.ts

@@ -1,3 +1,3 @@
-export * from './v1_repo_schema';
-export * from './config_schema';
-export { PlRegPackageConfig } from './config';
+export * from "./v1_repo_schema";
+export * from "./config_schema";
+export { PlRegPackageConfig } from "./config";

package/src/registry_v1/registry.test.ts

@@ -1,10 +1,10 @@
-import { expect, test } from 'vitest';
-import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { RegistryStorage, storageByUrl } from '../io';
-import { BlockRegistry } from './registry';
+import { expect, test } from "vitest";
+import { ConsoleLoggerAdapter } from "@milaboratories/ts-helpers";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { RegistryStorage, storageByUrl } from "../io";
+import { BlockRegistry } from "./registry";
 
 type TestStorageInstance = {
   storage: RegistryStorage;
@@ -16,108 +16,108 @@ type TestStorageTarget = {
 };
 const testStorages: TestStorageTarget[] = [
   {
-    name: 'local',
+    name: "local",
     storageProvider: () => {
       const uuid = randomUUID().toString();
-      const tmp = path.resolve('tmp');
+      const tmp = path.resolve("tmp");
       const storagePath = path.resolve(tmp, uuid);
-      const storage = storageByUrl('file://' + storagePath);
+      const storage = storageByUrl("file://" + storagePath);
       return {
         storage,
         teardown: async () => {
           await fs.promises.rm(storagePath, { recursive: true, force: true });
-        }
+        },
       };
-    }
-  }
+    },
+  },
 ];
 
 const testS3Address = process.env.TEST_S3_ADDRESS;
 if (testS3Address !== undefined) {
   testStorages.push({
-    name: 's3',
+    name: "s3",
     storageProvider: () => {
       const uuid = randomUUID().toString();
       const testS3AddressURL = new URL(testS3Address!);
-      testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, '')}/${uuid}`;
+      testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, "")}/${uuid}`;
       const storage = storageByUrl(testS3AddressURL.toString());
       return {
         storage,
         teardown: async () => {
-          const allFiles = await storage.listFiles('');
-          console.log('Deleting: ', allFiles);
+          const allFiles = await storage.listFiles("");
+          console.log("Deleting: ", allFiles);
           await storage.deleteFiles(...allFiles);
-        }
+        },
       };
-    }
+    },
   });
 }
 
-test.each(testStorages)('basic registry test with $name', async ({ storageProvider }) => {
+test.each(testStorages)("basic registry test with $name", async ({ storageProvider }) => {
   const { storage, teardown } = storageProvider();
   const registry = new BlockRegistry(storage, new ConsoleLoggerAdapter());
   await registry.updateIfNeeded();
   const constructor1 = registry.constructNewPackage({
-    organization: 'org1',
-    package: 'pkg1',
-    version: '1.1.0'
+    organization: "org1",
+    package: "pkg1",
+    version: "1.1.0",
   });
-  await constructor1.writeMeta({ some: 'value1' });
+  await constructor1.writeMeta({ some: "value1" });
   await constructor1.finish();
   await registry.updateIfNeeded();
   const constructor2 = registry.constructNewPackage({
-    organization: 'org1',
-    package: 'pkg1',
-    version: '1.2.0'
+    organization: "org1",
+    package: "pkg1",
+    version: "1.2.0",
   });
-  await constructor2.writeMeta({ some: 'value2' });
+  await constructor2.writeMeta({ some: "value2" });
   await constructor2.finish();
   await registry.updateIfNeeded();
-  expect(await registry.getPackageOverview({ organization: 'org1', package: 'pkg1' })).toEqual([
-    { version: '1.2.0', meta: { some: 'value2' } },
-    { version: '1.1.0', meta: { some: 'value1' } }
+  expect(await registry.getPackageOverview({ organization: "org1", package: "pkg1" })).toEqual([
+    { version: "1.2.0", meta: { some: "value2" } },
+    { version: "1.1.0", meta: { some: "value1" } },
   ]);
   expect(await registry.getGlobalOverview()).toEqual([
     {
-      organization: 'org1',
-      package: 'pkg1',
-      allVersions: ['1.1.0', '1.2.0'],
-      latestVersion: '1.2.0',
-      latestMeta: { some: 'value2' }
-    }
+      organization: "org1",
+      package: "pkg1",
+      allVersions: ["1.1.0", "1.2.0"],
+      latestVersion: "1.2.0",
+      latestMeta: { some: "value2" },
+    },
   ]);
   await teardown();
 });
 
-test.each(testStorages)('package modification test with $name', async ({ storageProvider }) => {
+test.each(testStorages)("package modification test with $name", async ({ storageProvider }) => {
   const { storage, teardown } = storageProvider();
   const registry = new BlockRegistry(storage, new ConsoleLoggerAdapter());
   const constructor1 = registry.constructNewPackage({
-    organization: 'org1',
-    package: 'pkg1',
-    version: '1.1.0'
+    organization: "org1",
+    package: "pkg1",
+    version: "1.1.0",
   });
-  await constructor1.writeMeta({ some: 'value1' });
+  await constructor1.writeMeta({ some: "value1" });
   await constructor1.finish();
   const constructor2 = registry.constructNewPackage({
-    organization: 'org1',
-    package: 'pkg1',
-    version: '1.1.0'
+    organization: "org1",
+    package: "pkg1",
+    version: "1.1.0",
   });
-  await constructor2.writeMeta({ some: 'value2' });
+  await constructor2.writeMeta({ some: "value2" });
   await constructor2.finish();
   await registry.updateIfNeeded();
-  expect(await registry.getPackageOverview({ organization: 'org1', package: 'pkg1' })).toEqual([
-    { version: '1.1.0', meta: { some: 'value2' } }
+  expect(await registry.getPackageOverview({ organization: "org1", package: "pkg1" })).toEqual([
+    { version: "1.1.0", meta: { some: "value2" } },
   ]);
   expect(await registry.getGlobalOverview()).toEqual([
     {
-      organization: 'org1',
-      package: 'pkg1',
-      allVersions: ['1.1.0'],
-      latestVersion: '1.1.0',
-      latestMeta: { some: 'value2' }
-    }
+      organization: "org1",
+      package: "pkg1",
+      allVersions: ["1.1.0"],
+      latestVersion: "1.1.0",
+      latestMeta: { some: "value2" },
+    },
   ]);
   await teardown();
 });