@platforma-sdk/block-tools 2.1.5 → 2.1.6

package/dist/v2/model/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../../src/v2/model/meta.ts"],"names":[],"mappings":"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"}

package/dist/v2/registry/schema.d.ts

@@ -0,0 +1,15 @@
+import { BlockPackId, BlockPackIdNoVersion } from '@milaboratories/pl-model-middle-layer';
+export declare function packageContentPrefix(bp: BlockPackId): string;
+export declare function payloadFilePath(bp: BlockPackId, file: string): string;
+export declare function packageOverviewPath(bp: BlockPackIdNoVersion): string;
+export declare const GlobalOverviewPath = "v2/overview.json";
+export declare const ManifestFile = "manifest.json";
+export interface GlobalOverviewEntry {
+    organization: string;
+    package: string;
+    allVersions: string[];
+    latestVersion: string;
+    latestMeta: object;
+}
+export type GlobalOverview = GlobalOverviewEntry[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/v2/registry/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/v2/registry/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAI1F,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,oBAAoB,GAAG,MAAM,CAEpE;AAED,eAAO,MAAM,kBAAkB,qBAA+B,CAAC;AAE/D,eAAO,MAAM,YAAY,kBAAkB,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,EAAE,CAAC"}

package/dist/v2/source_package.d.ts

@@ -0,0 +1,8 @@
+import { BlockPackDescriptionAbsolute } from './model';
+import { BlockPackDescriptionRaw, BlockPackId } from '@milaboratories/pl-model-middle-layer';
+export declare const BlockDescriptionPackageJsonField = "block";
+export declare function parsePackageName(packageName: string): Pick<BlockPackId, 'organization' | 'name'>;
+export declare function tryLoadPackDescription(moduleRoot: string): Promise<BlockPackDescriptionAbsolute | undefined>;
+export declare function loadPackDescriptionRaw(moduleRoot: string): Promise<BlockPackDescriptionRaw>;
+export declare function loadPackDescription(moduleRoot: string): Promise<BlockPackDescriptionAbsolute>;
+//# sourceMappingURL=source_package.d.ts.map

package/dist/v2/source_package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source_package.d.ts","sourceRoot":"","sources":["../../src/v2/source_package.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+C,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAGpG,OAAO,EAEL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,uCAAuC,CAAC;AAE/C,eAAO,MAAM,gCAAgC,UAAU,CAAC;AAKxD,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,cAAc,GAAG,MAAM,CAAC,CAQhG;AAED,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,4BAA4B,GAAG,SAAS,CAAC,CAyBnD;AAED,wBAAsB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAiBjG;AAED,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,4BAA4B,CAAC,CAGvC"}

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
-  "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
     }
   },
   "bin": {
     "block-tools": "./bin/run.js"
   },
   "files": [
-    "bin/*",
-    "dist/**/*",
-    "README.md"
+    "./bin/*",
+    "./dist/**/*",
+    "./src/**/*",
+    "./README.md"
   ],
   "license": "UNLICENSED",
   "dependencies": {
@@ -27,34 +27,38 @@
     "tar": "^7.4.3",
     "yaml": "^2.5.1",
     "zod": "^3.23.8",
-    "@milaboratories/pl-model-middle-layer": "^1.2.16",
-    "@milaboratories/ts-helpers": "^1.0.22",
-    "@milaboratories/ts-helpers-oclif": "^1.1.0"
+    "@milaboratories/pl-model-middle-layer": "^1.2.17",
+    "@milaboratories/ts-helpers": "^1.0.23",
+    "@milaboratories/ts-helpers-oclif": "^1.1.1"
   },
   "devDependencies": {
+    "typescript": "~5.6.2",
+    "vite": "^5.4.7",
+    "rollup-plugin-node-externals": "^7.1.3",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "vite-plugin-dts": "^4.2.1",
     "@types/jest": "^29.5.13",
     "@types/mime-types": "^2.1.4",
-    "@types/node": "^20.16.5",
+    "@types/node": "~20.16.5",
     "@types/semver": "^7.5.8",
     "jest": "^29.7.0",
     "oclif": "^4.14.34",
     "ts-jest": "^29.2.5",
-    "tsup": "~8.2.4",
-    "typescript": "^5.6.2",
-    "@milaboratories/platforma-build-configs": "1.0.0"
+    "@milaboratories/platforma-build-configs": "1.0.1"
   },
   "oclif": {
+    "bin": "block-tools",
     "commands": {
       "strategy": "explicit",
       "target": "./dist/cli.js",
       "identifier": "COMMANDS"
     },
-    "bin": "block-tools",
     "dirname": "block-tools",
     "topicSeparator": " "
   },
   "scripts": {
-    "build": "tsup",
+    "type-check": "tsc --noEmit --composite false",
+    "build": "vite build",
     "readme": "exec oclif readme",
     "test": "jest"
   }

package/src/cmd/build-meta.ts

@@ -0,0 +1,38 @@
+import { Command, Flags } from '@oclif/core';
+import path from 'path';
+import fs from 'fs';
+import { loadPackDescriptionRaw } from '../v2';
+import { BlockPackMetaDescription, BlockPackMetaEmbed } from '../v2/model/meta';
+
+export default class BuildMeta extends Command {
+  static override description =
+    'Extracts meta information from blocks package.json and outputs meta.json with embedded binary ' +
+    'and textual information linked from the meta section.';
+
+  static flags = {
+    modulePath: Flags.string({
+      char: 'i',
+      summary: 'input module path',
+      helpValue: '<path>',
+      default: '.'
+    }),
+
+    destination: Flags.string({
+      char: 'o',
+      summary: 'output meta.json file',
+      helpValue: '<path>',
+      required: true
+    })
+  };
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(BuildMeta);
+    const modulePath = path.resolve(flags.modulePath);
+    const descriptionRaw = await loadPackDescriptionRaw(modulePath);
+    const metaEmbedded = await BlockPackMetaEmbed.parseAsync(
+      BlockPackMetaDescription(modulePath).parse(descriptionRaw.meta)
+    );
+
+    await fs.promises.writeFile(path.resolve(flags.destination), JSON.stringify(metaEmbedded));
+  }
+}

package/src/cmd/build-model.ts

@@ -0,0 +1,76 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'fs';
+import path from 'path';
+
+async function getFileContent(path: string) {
+  try {
+    return await fs.promises.readFile(path, 'utf8');
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+export default class BuildModel extends Command {
+  static override description =
+    'Extracts and outputs block model JSON from pre-built block model module';
+
+  static flags = {
+    modulePath: Flags.string({
+      char: 'i',
+      summary: 'input module path',
+      helpValue: '<path>',
+      default: '.'
+    }),
+
+    sourceBundle: Flags.string({
+      char: 'b',
+      summary: 'bundled model code to embed into the model for callback-based rendering to work',
+      helpValue: '<path>',
+      default: './dist/bundle.js'
+    }),
+
+    destination: Flags.string({
+      char: 'o',
+      summary: 'output model file',
+      helpValue: '<path>',
+      default: './dist/model.json'
+    })
+  };
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(BuildModel);
+    const modulePath = path.resolve(flags.modulePath); // i.e. folder with package.json file
+    let { model, platforma } = require(modulePath);
+
+    if (!model) model = platforma;
+    if (!model) throw new Error('"model" export not found');
+
+    const { config } = model;
+
+    if (!config)
+      throw new Error(
+        'Malformed "model" object, check it is created with "BlockModel" ' +
+          'and ".done()" is executed as the call in the chain.'
+      );
+
+    if (
+      !('canRun' in config || 'inputsValid' in config) ||
+      !('outputs' in config) ||
+      !('sections' in config)
+    )
+      throw new Error('"config" has unexpected structure');
+
+    const code = await getFileContent(flags.sourceBundle);
+    if (code !== undefined) {
+      config.code = {
+        type: 'plain',
+        content: code
+      };
+    }
+
+    await fs.promises.writeFile(path.resolve(flags.destination), JSON.stringify(config));
+  }
+}

package/src/cmd/index.ts

@@ -0,0 +1,12 @@
+import BuildMeta from './build-meta';
+import BuildModel from './build-model';
+import PackBlock from './pack-block';
+import UploadPackageV1 from './upload-package-v1';
+
+// prettier-ignore
+export const COMMANDS = {
+  'upload-package-v1': UploadPackageV1,
+  'pack': PackBlock,
+  'build-model': BuildModel,
+  'build-meta': BuildMeta,
+};

package/src/cmd/pack-block.ts

@@ -0,0 +1,32 @@
+import { Command, Flags } from '@oclif/core';
+import { loadPackDescription } from '../v2/source_package';
+import path from 'path';
+import { buildBlockPackDist } from '../v2/build_dist';
+
+export default class PackBlock extends Command {
+  static description =
+    'Builds block pack and outputs a block pack manifest consolidating all ' +
+    'references assets into a single folder';
+
+  static flags = {
+    modulePath: Flags.string({
+      char: 'i',
+      summary: 'input module path',
+      helpValue: '<path>',
+      default: '.'
+    }),
+
+    destinationPath: Flags.string({
+      char: 'o',
+      summary: 'output folder',
+      helpValue: '<path>',
+      default: './block-pack'
+    })
+  };
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(PackBlock);
+    const description = await loadPackDescription(path.resolve(flags.modulePath));
+    await buildBlockPackDist(description, path.resolve(flags.destinationPath));
+  }
+}

package/src/cmd/upload-package-v1.ts

@@ -0,0 +1,105 @@
+import { Command, Flags } from '@oclif/core';
+import { getConfig } from '../registry_v1/config';
+import { targetFile } from '../registry_v1/flags';
+import fs from 'node:fs';
+import YAML from 'yaml';
+import { PlRegPackageConfigDataShard } from '../registry_v1/config_schema';
+import { OclifLoggerAdapter } from '@milaboratories/ts-helpers-oclif';
+
+type BasicConfigField = keyof PlRegPackageConfigDataShard &
+  ('registry' | 'organization' | 'package' | 'version');
+const BasicConfigFields: BasicConfigField[] = ['registry', 'organization', 'package', 'version'];
+
+export default class UploadPackageV1 extends Command {
+  static description = 'Uploads V1 package and refreshes the registry';
+
+  static flags = {
+    registry: Flags.string({
+      char: 'r',
+      summary: 'full address of the registry or alias from .pl.reg',
+      helpValue: '<address|alias>',
+      env: 'PL_REGISTRY'
+    }),
+
+    organization: Flags.string({
+      char: 'o',
+      summary: 'target organisation',
+      env: 'PL_PACKAGE_ORGANIZATION'
+    }),
+
+    package: Flags.string({
+      char: 'p',
+      summary: 'target package',
+      env: 'PL_PACKAGE_NAME'
+    }),
+
+    version: Flags.string({
+      char: 'v',
+      summary: 'target version',
+      env: 'PL_PACKAGE_VERSION'
+    }),
+
+    meta: Flags.file({
+      char: 'm',
+      summary: 'json file containing meta information to associate with tha package',
+      exists: true
+    }),
+
+    file: targetFile({
+      char: 'f',
+      summary: 'package files',
+      multiple: true,
+      default: []
+    }),
+
+    refresh: Flags.boolean({
+      summary: 'refresh repository after adding the package',
+      default: true,
+      allowNo: true,
+      env: 'PL_REGISTRY_REFRESH'
+    })
+  };
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(UploadPackageV1);
+    const configFromFlags: PlRegPackageConfigDataShard = PlRegPackageConfigDataShard.parse({});
+
+    for (const field of BasicConfigFields) if (flags[field]) configFromFlags[field] = flags[field];
+
+    if (flags.meta) {
+      if (flags.meta.endsWith('.json'))
+        configFromFlags.meta = JSON.parse(
+          await fs.promises.readFile(flags.meta, { encoding: 'utf-8' })
+        );
+      else if (flags.meta.endsWith('.yaml'))
+        configFromFlags.meta = YAML.parse(
+          await fs.promises.readFile(flags.meta, { encoding: 'utf-8' })
+        );
+    }
+
+    for (const targetFile of flags.file) {
+      configFromFlags.files[targetFile.destName] = targetFile.src;
+    }
+
+    const conf = await getConfig(configFromFlags);
+
+    this.log(YAML.stringify(conf.conf));
+
+    const registry = conf.createRegistry(new OclifLoggerAdapter(this));
+    const name = conf.fullPackageName;
+
+    const builder = registry.constructNewPackage(name);
+
+    for (const [dst, src] of Object.entries(conf.conf.files)) {
+      this.log(`Uploading ${src} -> ${dst} ...`);
+      const content = await fs.promises.readFile(src);
+      await builder.addFile(dst, content);
+    }
+
+    this.log(`Uploading meta information...`);
+    await builder.writeMeta(conf.conf.meta);
+    await builder.finish();
+
+    if (flags.refresh) await registry.updateIfNeeded();
+  }
+}

package/src/common_types.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const PlRegAddress = z.string().regex(/^(?:s3:|file:)/);

package/src/lib/storage.test.ts

@@ -0,0 +1,91 @@
+import { randomUUID } from 'node:crypto';
+import { FSStorage, 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 #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 () => {
+  const uuid = randomUUID().toString();
+  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');
+  await fs.promises.rm(storagePath, { recursive: true });
+});
+
+test('test local fs list', async () => {
+  const uuid = randomUUID().toString();
+  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');
+  result.sort();
+  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');
+  result1.sort();
+  expect(result1).toEqual(expected);
+  await fs.promises.rm(storagePath, { recursive: true });
+});
+
+const testS3Address = process.env.TEST_S3_ADDRESS;
+if (testS3Address) {
+  test('test s3 read write', async () => {
+    const uuid = randomUUID().toString();
+    const testS3AddressURL = new URL(testS3Address);
+    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');
+    await storage.deleteFiles(`some/deep/file.txt`);
+    expect(await storage.getFile('some/deep/file.txt')).toBeUndefined();
+  });
+
+  test('test s3 fs list', async () => {
+    const uuid = randomUUID().toString();
+    const testS3AddressURL = new URL(testS3Address);
+    testS3AddressURL.pathname = `${testS3AddressURL.pathname.replace(/\/$/, '')}/${uuid}`;
+    const storage = storageByUrl(testS3AddressURL.toString()) as S3Storage;
+    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'];
+    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');
+    result1.sort();
+    expect(result1).toEqual(expected);
+    await storage.client.deleteObjects({
+      Bucket: storage.bucket,
+      Delete: {
+        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` }
+        ]
+      }
+    });
+  });
+}

package/src/lib/storage.ts

@@ -0,0 +1,140 @@
+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>;
+
+  getFile(file: string): Promise<Buffer | undefined>;
+
+  listFiles(prefix: string): Promise<string[]>;
+
+  deleteFiles(...files: string[]): Promise<void>;
+}
+
+export class S3Storage implements RegistryStorage {
+  constructor(
+    public readonly client: S3,
+    public readonly bucket: string,
+    public readonly root: string
+  ) {}
+
+  async getFile(file: string): Promise<Buffer | undefined> {
+    try {
+      return Buffer.from(
+        await (
+          await this.client.getObject({
+            Bucket: this.bucket,
+            Key: pathPosix.join(this.root, file)
+          })
+        ).Body!.transformToByteArray()
+      );
+    } catch (e: any) {
+      if (e.name === 'NoSuchKey') return undefined;
+      else throw e;
+    }
+  }
+
+  async listFiles(prefix: string): Promise<string[]> {
+    const listRoot = pathPosix.join(this.root, prefix);
+    const paginator = paginateListObjectsV2(
+      { client: this.client },
+      {
+        Bucket: this.bucket,
+        Prefix: listRoot
+      }
+    );
+    const result: string[] = [];
+    for await (const page of paginator)
+      result.push(...page.Contents!.map((e) => pathPosix.relative(listRoot, e.Key!)));
+    return result;
+  }
+
+  async putFile(file: string, buffer: Buffer): Promise<void> {
+    await this.client.putObject({
+      Bucket: this.bucket,
+      Key: pathPosix.join(this.root, file),
+      Body: buffer
+    });
+  }
+
+  async deleteFiles(...files: string[]): Promise<void> {
+    // TODO implement support of more than 1000 files
+    const results = await this.client.deleteObjects({
+      Bucket: this.bucket,
+      Delete: {
+        Objects: files.map((file) => ({
+          Key: pathPosix.join(this.root, file)
+        }))
+      }
+    });
+    if (results.Errors !== undefined && results.Errors.length > 0)
+      throw new Error(`Errors encountered while deleting files: ${results.Errors.join('\n')}`);
+  }
+}
+
+export class FSStorage implements RegistryStorage {
+  /** Absolute path */
+  public readonly root: string;
+
+  constructor(_root: string) {
+    this.root = path.resolve(_root);
+  }
+
+  private toAbsolutePath(localPath: string): string {
+    if (pathPosix.isAbsolute(localPath)) throw new Error('absolute path');
+    return path.resolve(this.root, localPath.split(pathPosix.sep).join(path.sep));
+  }
+
+  async getFile(address: string): Promise<Buffer | undefined> {
+    try {
+      return await fs.promises.readFile(this.toAbsolutePath(address));
+    } catch (err: any) {
+      if (err.code == 'ENOENT') return undefined;
+      else throw new Error('', { cause: err });
+    }
+  }
+
+  async listFiles(prefix: string): Promise<string[]> {
+    try {
+      const listRoot = this.toAbsolutePath(prefix);
+      return (await fs.promises.readdir(listRoot, { recursive: true, withFileTypes: true }))
+        .filter((e) => e.isFile())
+        .map((e) =>
+          path.relative(listRoot, path.resolve(e.path, e.name)).split(path.sep).join(pathPosix.sep)
+        );
+    } catch (err: any) {
+      if (err.code == 'ENOENT') return [];
+      else throw new Error('', { cause: err });
+    }
+  }
+
+  async putFile(address: string, buffer: Buffer): Promise<void> {
+    const absoluteAddress = this.toAbsolutePath(address);
+    await fs.promises.mkdir(path.dirname(absoluteAddress), { recursive: true });
+    await fs.promises.writeFile(absoluteAddress, buffer);
+  }
+
+  async deleteFiles(...files: string[]): Promise<void> {
+    // Folders are not removed, deletes issued sequentially
+    for (const file of files) await fs.promises.rm(this.toAbsolutePath(file));
+  }
+}
+
+export function storageByUrl(address: string): RegistryStorage {
+  const url = new URL(address, `file:${path.resolve('.').split(path.sep).join(pathPosix.sep)}/`);
+  switch (url.protocol) {
+    case 'file:':
+      const root = path.resolve(url.pathname);
+      return new FSStorage(root);
+    case 's3:':
+      const options: NonNullable<ConstructorParameters<typeof S3>[0]> = {};
+      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(/^\//, ''));
+    default:
+      throw new Error(`Unknown protocol: ${url.protocol}`);
+  }
+}

package/src/lib.ts

@@ -0,0 +1,2 @@
+export * as RegistryV1 from './registry_v1';
+export * from './v2';