@platforma-sdk/block-tools 2.1.11 → 2.2.0

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.1.11",
+  "version": "2.2.0",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "types": "./dist/lib.d.ts",
   "main": "./dist/index.js",
@@ -29,8 +29,8 @@
     "tar": "^7.4.3",
     "yaml": "^2.5.1",
     "zod": "^3.23.8",
-    "@milaboratories/resolve-helper": "1.0.1",
-    "@milaboratories/pl-model-middle-layer": "^1.2.20",
+    "@milaboratories/resolve-helper": "^1.0.1",
+    "@milaboratories/pl-model-middle-layer": "^1.3.0",
     "@milaboratories/ts-helpers": "^1.0.26",
     "@milaboratories/ts-helpers-oclif": "^1.1.4"
   },

package/src/cmd/build-meta.ts

@@ -2,7 +2,7 @@ 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';
+import { BlockPackMetaDescription, BlockPackMetaEmbed } from '../v2/model/block_meta';
 
 export default class BuildMeta extends Command {
   static override description =

package/src/cmd/index.ts

@@ -1,6 +1,7 @@
 import BuildMeta from './build-meta';
 import BuildModel from './build-model';
 import PackBlock from './pack-block';
+import Publish from './publish';
 import UploadPackageV1 from './upload-package-v1';
 
 // prettier-ignore
@@ -9,4 +10,5 @@ export const COMMANDS = {
   'pack': PackBlock,
   'build-model': BuildModel,
   'build-meta': BuildMeta,
+  'publish': Publish,
 };

package/src/cmd/publish.ts

@@ -0,0 +1,69 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs';
+import { OclifLoggerAdapter } from '@milaboratories/ts-helpers-oclif';
+import { ManifestFileName } from '../v2/registry/schema_public';
+import { BlockPackManifest } from '@milaboratories/pl-model-middle-layer';
+import { storageByUrl } from '../lib/storage';
+import { BlockRegistryV2 } from '../v2/registry/registry';
+import path from 'node:path';
+
+export default class Publish extends Command {
+  static description =
+    'Publishes the block package and refreshes the registry (for v2 block-pack schema)';
+
+  static flags = {
+    registry: Flags.string({
+      char: 'r',
+      summary: 'full address of the registry',
+      helpValue: '<address>',
+      env: 'PL_REGISTRY',
+      required: true
+    }),
+
+    manifest: Flags.file({
+      char: 'm',
+      summary: 'manifest file path',
+      exists: true,
+      default: `./block-pack/${ManifestFileName}`
+    }),
+
+    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(Publish);
+
+    // 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' })
+    //     );
+    // }
+
+    const manifestPath = path.resolve(flags.manifest);
+    const manifest = BlockPackManifest.parse(
+      JSON.parse(await fs.promises.readFile(manifestPath, { encoding: 'utf-8' }))
+    );
+    const manifestRoot = path.dirname(manifestPath);
+
+    this.log(`Manifest root = ${manifestRoot}`);
+
+    const storage = storageByUrl(flags.registry);
+    const registry = new BlockRegistryV2(storage, new OclifLoggerAdapter(this));
+
+    await registry.publishPackage(manifest, async (file) =>
+      Buffer.from(await fs.promises.readFile(path.resolve(manifestRoot, file)))
+    );
+
+    if (flags.refresh) await registry.updateIfNeeded();
+  }
+}

package/src/v2/build_dist.ts

@@ -1,13 +1,11 @@
 import {
-  BlockPackDescriptionAbsolute,
-  BlockPackDescriptionConsolidateToFolder,
   BlockPackDescriptionManifest,
   BlockPackManifest,
-  BlockPackManifestFile
-} from './model';
+  BlockPackManifestFile,
+  ManifestFileInfo
+} from '@milaboratories/pl-model-middle-layer';
+import { BlockPackDescriptionAbsolute, BlockPackDescriptionConsolidateToFolder } from './model';
 import fsp from 'node:fs/promises';
-import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './model/meta';
-import { patch } from 'semver';
 import path from 'node:path';
 
 export async function buildBlockPackDist(
@@ -16,14 +14,20 @@ export async function buildBlockPackDist(
 ): Promise<BlockPackManifest> {
   await fsp.mkdir(dst, { recursive: true });
   const files: string[] = [];
-  const descriptionRelative = await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(
-    description
+  const descriptionRelative: BlockPackDescriptionManifest =
+    await BlockPackDescriptionConsolidateToFolder(dst, files).parseAsync(description);
+  const filesForManifest = await Promise.all(
+    files.map(async (f): Promise<ManifestFileInfo> => {
+      const bytes = await fsp.readFile(path.resolve(dst, f));
+      const sha256 = Buffer.from(await crypto.subtle.digest('sha-256', bytes)).toString('hex');
+      return { name: f, size: bytes.length, sha256 };
+    })
   );
   const manifest: BlockPackManifest = BlockPackManifest.parse({
-    schema: 'v1',
-    ...descriptionRelative,
-    files
-  });
+    schema: 'v2',
+    description: descriptionRelative,
+    files: filesForManifest
+  } satisfies BlockPackManifest);
   await fsp.writeFile(path.resolve(dst, BlockPackManifestFile), JSON.stringify(manifest));
   return manifest;
 }

package/src/v2/model/block_components.ts

@@ -3,10 +3,14 @@ import {
   ResolvedModuleFile,
   ResolvedModuleFolder,
   packFolderToRelativeTgz,
-  cpAbsoluteToRelative,
-  mapRemoteToAbsolute,
+  cpAbsoluteToRelative
 } from './content_conversion';
-import { BlockComponents, BlockComponentsManifest, ContentAbsoluteBinaryLocal, ContentAbsoluteFolder, ContentRelativeBinary } from '@milaboratories/pl-model-middle-layer';
+import {
+  BlockComponents,
+  BlockComponentsManifest,
+  ContentAbsoluteBinaryLocal,
+  ContentAbsoluteFolder
+} from '@milaboratories/pl-model-middle-layer';
 
 export function BlockComponentsDescription(moduleRoot: string) {
   return BlockComponents(
@@ -23,10 +27,10 @@ export function BlockComponentsConsolidate(dstFolder: string, fileAccumulator?:
   ).pipe(BlockComponentsManifest);
 }
 
-export function BlockComponentsAbsoluteUrl(prefix: string) {
-  return BlockComponents(
-    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),
-    ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))
-  );
-}
-export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;
+// export function BlockComponentsAbsoluteUrl(prefix: string) {
+//   return BlockComponents(
+//     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix)),
+//     ContentRelativeBinary.transform(mapRemoteToAbsolute(prefix))
+//   );
+// }
+// export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;

package/src/v2/model/block_description.ts

@@ -0,0 +1,49 @@
+import {
+  addPrefixToRelative,
+  BlockComponents,
+  BlockPackDescriptionManifest,
+  BlockPackMeta,
+  ContentRelative,
+  ContentRelativeBinary,
+  ContentRelativeText,
+  CreateBlockPackDescriptionSchema
+} from '@milaboratories/pl-model-middle-layer';
+import { BlockComponentsConsolidate, BlockComponentsDescription } from './block_components';
+import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './block_meta';
+import { z } from 'zod';
+
+export function ResolvedBlockPackDescriptionFromPackageJson(root: string) {
+  return CreateBlockPackDescriptionSchema(
+    BlockComponentsDescription(root),
+    BlockPackMetaDescription(root)
+  );
+}
+export type BlockPackDescriptionAbsolute = z.infer<
+  ReturnType<typeof ResolvedBlockPackDescriptionFromPackageJson>
+>;
+
+export function BlockPackDescriptionConsolidateToFolder(
+  dstFolder: string,
+  fileAccumulator?: string[]
+) {
+  return CreateBlockPackDescriptionSchema(
+    BlockComponentsConsolidate(dstFolder, fileAccumulator),
+    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
+  ).pipe(BlockPackDescriptionManifest);
+}
+
+export function BlockPackDescriptionManifestAddRelativePathPrefix(prefix: string) {
+  const transformer = addPrefixToRelative(prefix);
+  return BlockPackDescriptionManifest.pipe(
+    CreateBlockPackDescriptionSchema(
+      BlockComponents(
+        ContentRelative.transform(transformer),
+        ContentRelative.transform(transformer)
+      ),
+      BlockPackMeta(
+        ContentRelativeText.transform(transformer),
+        ContentRelativeBinary.transform(transformer)
+      )
+    )
+  ).pipe(BlockPackDescriptionManifest);
+}

package/src/v2/model/{meta.ts → block_meta.ts}

@@ -1,5 +1,6 @@
 import {
   BlockPackMeta,
+  BlockPackMetaEmbeddedContent,
   ContentAbsoluteBinaryLocal,
   ContentAbsoluteTextLocal,
   DescriptionContentBinary,
@@ -12,7 +13,6 @@ import {
   mapLocalToAbsolute
 } from './content_conversion';
 import { z } from 'zod';
-import { BlockPackMetaEmbeddedContent } from '@milaboratories/pl-model-middle-layer';
 
 export function BlockPackMetaDescription(root: string) {
   return BlockPackMeta(

package/src/v2/model/content_conversion.ts

@@ -8,10 +8,13 @@ import {
   ContentAbsoluteFile,
   ContentAbsoluteFolder,
   ContentAbsoluteTextLocal,
-  ContentAbsoluteUrl,
   ContentAnyLocal,
   ContentExplicitBase64,
-  ContentRelative
+  ContentExplicitBytes,
+  ContentExplicitString,
+  ContentRelative,
+  ContentRelativeBinary,
+  ContentRelativeText
 } from '@milaboratories/pl-model-middle-layer';
 import { tryResolve } from '@milaboratories/resolve-helper';
 
@@ -157,12 +160,48 @@ export function packFolderToRelativeTgz(
   };
 }
 
-export function mapRemoteToAbsolute(
-  rootUrl: string
-): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {
-  const rootWithSlash = rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`;
-  return <T extends ContentAnyLocal>(value: T) =>
-    value.type === 'relative'
-      ? { type: 'absolute-url', url: rootWithSlash + value.path }
-      : (value as Exclude<T, ContentRelative>);
+export type RelativeContentReader = (relativePath: string) => Promise<Buffer>;
+
+export function relativeToExplicitText(
+  reader: RelativeContentReader
+): (value: ContentRelativeText) => Promise<ContentExplicitString> {
+  return async (value) =>
+    value.type === 'explicit-string'
+      ? value
+      : { type: 'explicit-string', content: (await reader(value.path)).toString('utf8') };
+}
+
+export function relativeToExplicitBinary64(
+  reader: RelativeContentReader
+): (value: ContentRelativeBinary) => Promise<ContentExplicitBase64> {
+  return async (value) => {
+    if (value.type === 'explicit-base64') return value;
+    const mimeType = mime.lookup(value.path);
+    if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.path}.`);
+    return {
+      type: 'explicit-base64',
+      mimeType,
+      content: (await reader(value.path)).toString('base64')
+    };
+  };
+}
+
+export function relativeToExplicitBytes(
+  reader: RelativeContentReader
+): (value: ContentRelativeBinary) => Promise<ContentExplicitBytes> {
+  return async (value) => {
+    if (value.type === 'explicit-base64')
+      return {
+        type: 'explicit-bytes',
+        mimeType: value.mimeType,
+        content: Buffer.from(value.content, 'base64')
+      };
+    const mimeType = mime.lookup(value.path);
+    if (!mimeType) throw new Error(`Can't recognize mime type of the file: ${value.path}.`);
+    return {
+      type: 'explicit-bytes',
+      mimeType,
+      content: await reader(value.path)
+    };
+  };
 }

package/src/v2/model/index.ts

@@ -1,46 +1,5 @@
-import { z } from 'zod';
-import { BlockComponentsConsolidate, BlockComponentsDescription } from './block_components';
-import {
-  BlockComponentsManifest,
-  BlockPackMetaManifest,
-  CreateBlockPackDescriptionSchema
-} from '@milaboratories/pl-model-middle-layer';
-import { BlockPackMetaConsolidate, BlockPackMetaDescription } from './meta';
-
-export * from './block_components';
 export * from './content_conversion';
 
-export function ResolvedBlockPackDescriptionFromPackageJson(root: string) {
-  return CreateBlockPackDescriptionSchema(
-    BlockComponentsDescription(root),
-    BlockPackMetaDescription(root)
-  );
-}
-export type BlockPackDescriptionAbsolute = z.infer<
-  ReturnType<typeof ResolvedBlockPackDescriptionFromPackageJson>
->;
-
-export function BlockPackDescriptionConsolidateToFolder(
-  dstFolder: string,
-  fileAccumulator?: string[]
-) {
-  return CreateBlockPackDescriptionSchema(
-    BlockComponentsConsolidate(dstFolder, fileAccumulator),
-    //BlockPackMetaToExplicit
-    BlockPackMetaConsolidate(dstFolder, fileAccumulator)
-  ).pipe(BlockPackDescriptionManifest);
-}
-
-export const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(
-  BlockComponentsManifest,
-  BlockPackMetaManifest
-);
-export type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;
-
-export const BlockPackManifest = BlockPackDescriptionManifest.extend({
-  schema: z.literal('v1'),
-  files: z.array(z.string())
-});
-export type BlockPackManifest = z.infer<typeof BlockPackManifest>;
-
-export const BlockPackManifestFile = 'manifest.json';
+export * from './block_meta';
+export * from './block_components';
+export * from './block_description';

package/src/v2/registry/registry.ts

@@ -0,0 +1,233 @@
+import { MiLogger } from '@milaboratories/ts-helpers';
+import { compare as compareSemver, satisfies } from 'semver';
+import { RegistryStorage } from '../../lib/storage';
+import { BlockPackIdNoVersion, BlockPackManifest } from '@milaboratories/pl-model-middle-layer';
+import {
+  GlobalUpdateSeedInFile,
+  GlobalUpdateSeedOutFile,
+  PackageUpdatePattern,
+  packageUpdateSeedPath,
+  VersionUpdatesPrefix
+} from './schema_internal';
+import {
+  GlobalOverviewReg,
+  GlobalOverviewPath,
+  ManifestSuffix,
+  packageContentPrefix,
+  PackageOverview,
+  packageOverviewPath,
+  ManifestFileName
+} from './schema_public';
+import { BlockPackDescriptionManifestAddRelativePathPrefix, RelativeContentReader } from '../model';
+import { randomUUID } from 'node:crypto';
+
+type PackageUpdateInfo = {
+  package: BlockPackIdNoVersion;
+  versions: Set<String>;
+};
+
+export class BlockRegistryV2 {
+  constructor(
+    private readonly storage: RegistryStorage,
+    private readonly logger?: MiLogger
+  ) {}
+
+  private async updateRegistry() {
+    this.logger?.info('Initiating registry refresh...');
+
+    // reading update requests
+    const packagesToUpdate = new Map<string, PackageUpdateInfo>();
+    const seedPaths: string[] = [];
+    const rawSeedPaths = await this.storage.listFiles(VersionUpdatesPrefix);
+    this.logger?.info('Packages to be updated:');
+    for (const seedPath of rawSeedPaths) {
+      const match = seedPath.match(PackageUpdatePattern);
+      if (!match) continue;
+      seedPaths.push(seedPath);
+      const { packageKeyWithoutVersion, organization, name, version, seed } = match.groups!;
+
+      let update = packagesToUpdate.get(packageKeyWithoutVersion);
+      let added = false;
+      if (!update) {
+        packagesToUpdate.set(packageKeyWithoutVersion, {
+          package: { organization, name },
+          versions: new Set([version])
+        });
+        added = true;
+      } else if (!update.versions.has(version)) {
+        update.versions.add(version);
+        added = true;
+      }
+      this.logger?.info(`  - ${organization}:${name}:${version} added:${added}`);
+    }
+
+    // loading global overview
+    const overviewContent = await this.storage.getFile(GlobalOverviewPath);
+    const overview: GlobalOverviewReg =
+      overviewContent === undefined
+        ? { schema: 'v2', packages: [] }
+        : GlobalOverviewReg.parse(JSON.parse(overviewContent.toString()));
+    let overviewPackages = overview.packages;
+    this.logger?.info(`Global overview loaded, ${overviewPackages.length} records`);
+
+    // updating packages
+    for (const [, packageInfo] of packagesToUpdate.entries()) {
+      // reading existing overview
+      const overviewFile = packageOverviewPath(packageInfo.package);
+      const pOverviewContent = await this.storage.getFile(overviewFile);
+      let packageOverview: PackageOverview =
+        pOverviewContent === undefined
+          ? { schema: 'v2', versions: [] }
+          : PackageOverview.parse(JSON.parse(pOverviewContent.toString()));
+      this.logger?.info(
+        `Updating ${packageInfo.package.organization}:${packageInfo.package.name} overview, ${packageOverview.versions.length} records`
+      );
+
+      // removing versions that we will update
+      const newVersions = packageOverview.versions.filter(
+        (e) => !packageInfo.versions.has(e.id.version)
+      );
+
+      // reading new entries
+      for (const [v] of packageInfo.versions.entries()) {
+        const version = v.toString();
+        const manifestContent = await this.storage.getFile(
+          packageContentPrefix({
+            ...packageInfo.package,
+            version
+          }) + ManifestSuffix
+        );
+        if (!manifestContent) continue; // absent package
+        newVersions.push(
+          BlockPackDescriptionManifestAddRelativePathPrefix(version).parse(
+            BlockPackManifest.parse(JSON.parse(manifestContent.toString('utf8'))).description
+          )
+        );
+      }
+
+      // sorting entries according to version
+      newVersions.sort((e1, e2) => compareSemver(e2.id.version, e1.id.version));
+
+      // write package overview back
+      await this.storage.putFile(
+        overviewFile,
+        Buffer.from(
+          JSON.stringify({ schema: 'v2', versions: newVersions } satisfies PackageOverview)
+        )
+      );
+      this.logger?.info(`Done (${newVersions.length} records)`);
+
+      // patching corresponding entry in overview
+      overviewPackages = overviewPackages.filter(
+        (e) =>
+          e.id.organization !== packageInfo.package.organization ||
+          e.id.name !== packageInfo.package.name
+      );
+      overviewPackages.push({
+        id: {
+          organization: packageInfo.package.organization,
+          name: packageInfo.package.name
+        },
+        allVersions: newVersions.map((e) => e.id.version).reverse(),
+        latest: BlockPackDescriptionManifestAddRelativePathPrefix(packageInfo.package.name).parse(
+          newVersions[0]
+        )
+      });
+    }
+
+    // writing global overview
+    await this.storage.putFile(
+      GlobalOverviewPath,
+      Buffer.from(
+        JSON.stringify({ schema: 'v2', packages: overviewPackages } satisfies GlobalOverviewReg)
+      )
+    );
+    this.logger?.info(`Global overview updated (${overviewPackages.length} records)`);
+
+    // deleting seeds
+    await this.storage.deleteFiles(...seedPaths.map((sp) => `${VersionUpdatesPrefix}${sp}`));
+    this.logger?.info(`Version update requests cleared`);
+  }
+
+  public async updateIfNeeded(force: boolean = false): Promise<void> {
+    // implementation of main convergence algorithm
+
+    this.logger?.info(`Checking if registry requires refresh...`);
+    const updateRequestSeed = await this.storage.getFile(GlobalUpdateSeedInFile);
+    const currentUpdatedSeed = await this.storage.getFile(GlobalUpdateSeedOutFile);
+    if (!force && updateRequestSeed === undefined && currentUpdatedSeed === undefined) return;
+    if (
+      !force &&
+      updateRequestSeed !== undefined &&
+      currentUpdatedSeed !== undefined &&
+      updateRequestSeed.equals(currentUpdatedSeed)
+    )
+      return;
+
+    await this.updateRegistry();
+
+    if (updateRequestSeed) {
+      await this.storage.putFile(GlobalUpdateSeedOutFile, updateRequestSeed);
+      this.logger?.info(`Refresh finished`);
+    }
+  }
+
+  public async getPackageOverview(
+    name: BlockPackIdNoVersion
+  ): Promise<undefined | PackageOverview> {
+    const content = await this.storage.getFile(packageOverviewPath(name));
+    if (content === undefined) return undefined;
+    return PackageOverview.parse(JSON.parse(content.toString()));
+  }
+
+  public async getGlobalOverview(): Promise<undefined | GlobalOverviewReg> {
+    const content = await this.storage.getFile(GlobalOverviewPath);
+    if (content === undefined) return undefined;
+    return GlobalOverviewReg.parse(JSON.parse(content.toString()));
+  }
+
+  // public async getGlobalOverviewExplicitBytes(): Promise<undefined | GlobalOverviewReg> {
+  //   const content = await this.storage.getFile(GlobalOverviewPath);
+  //   if (content === undefined) return undefined;
+  //   return GlobalOverviewReg.parse(JSON.parse(content.toString()));
+  // }
+
+  public async publishPackage(
+    manifest: BlockPackManifest,
+    fileReader: RelativeContentReader
+  ): Promise<void> {
+    const prefix = packageContentPrefix(manifest.description.id);
+    // uploading content files
+    for (const f of manifest.files) {
+      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})`
+        );
+      const sha256 = Buffer.from(await crypto.subtle.digest('sha-256', bytes))
+        .toString('hex')
+        .toUpperCase();
+      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()})`
+        );
+
+      const dst = prefix + '/' + f.name;
+      this.logger?.info(`Uploading ${f.name} -> ${dst} ...`);
+      await this.storage.putFile(dst, bytes);
+    }
+
+    // uploading manifest as the last upload action
+    const manifestDst = prefix + '/' + ManifestFileName;
+    this.logger?.info(`Uploading manifest to ${manifestDst} ...`);
+    await this.storage.putFile(manifestDst, Buffer.from(JSON.stringify(manifest)));
+
+    // adding update seed
+    const seed = randomUUID();
+    const seedPath = packageUpdateSeedPath(manifest.description.id, seed);
+    this.logger?.info(`Creating update seed at ${seedPath} ...`);
+    await this.storage.putFile(seedPath, Buffer.from(seed));
+    this.logger?.info(`Touching global update seed ${GlobalUpdateSeedInFile} ...`);
+    await this.storage.putFile(GlobalUpdateSeedInFile, Buffer.from(seed));
+  }
+}

package/src/v2/registry/schema_internal.ts

@@ -0,0 +1,13 @@
+import { BlockPackId } from '@milaboratories/pl-model-middle-layer';
+
+export const VersionUpdatesPrefix = '_updates_v2/per_package_version/';
+
+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 GlobalUpdateSeedInFile = '_updates_v2/_global_update_in';
+export const GlobalUpdateSeedOutFile = '_updates_v2/_global_update_out';