@platforma-sdk/block-tools 2.6.27 → 2.6.29

package/src/cmd/pack.ts

@@ -1,27 +1,27 @@
 import { Command, Flags } from '@oclif/core';
 import { loadPackDescription } from '../v2/source_package';
-import path from 'path';
+import path from 'node: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 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: '.'
+      default: '.',
     }),
 
     destinationPath: Flags.string({
       char: 'o',
       summary: 'output folder',
       helpValue: '<path>',
-      default: './block-pack'
-    })
+      default: './block-pack',
+    }),
   };
 
   public async run(): Promise<void> {

package/src/cmd/publish.ts

@@ -9,7 +9,7 @@ import path from 'node:path';
 
 function simpleDeepMerge<T extends Record<string, unknown>>(
   target: Record<string, unknown>,
-  source: T
+  source: T,
 ): T {
   const result = { ...target };
 
@@ -29,52 +29,52 @@ function simpleDeepMerge<T extends Record<string, unknown>>(
 }
 
 export default class Publish extends Command {
-  static description =
-    'Publishes the block package and refreshes the registry (for v2 block-pack schema)';
+  static description
+    = 'Publishes the block package and refreshes the registry (for v2 block-pack schema)';
 
   static flags = {
-    registry: Flags.string({
+    'registry': Flags.string({
       char: 'r',
       summary: 'full address of the registry',
       helpValue: '<address>',
       env: 'PL_REGISTRY',
-      required: true
+      required: true,
     }),
 
-    manifest: Flags.file({
+    'manifest': Flags.file({
       char: 'm',
       summary: 'manifest file path',
       exists: true,
-      default: `./block-pack/${ManifestFileName}`
+      default: `./block-pack/${ManifestFileName}`,
     }),
 
     'version-override': Flags.file({
       char: 'v',
-      summary: 'override package version'
+      summary: 'override package version',
     }),
 
-    refresh: Flags.boolean({
+    'refresh': Flags.boolean({
       summary: 'refresh repository after adding the package',
       default: true,
       allowNo: true,
-      env: 'PL_REGISTRY_REFRESH'
+      env: 'PL_REGISTRY_REFRESH',
     }),
 
-    unstable: Flags.boolean({
+    'unstable': Flags.boolean({
       summary: 'do not add the published package to stable channel',
       default: false,
-      env: 'PL_PUBLISH_UNSTABLE'
-    })
+      env: 'PL_PUBLISH_UNSTABLE',
+    }),
   };
 
   public async run(): Promise<void> {
     const { flags } = await this.parse(Publish);
 
     const manifestPath = path.resolve(flags.manifest);
-    const rawManifest = JSON.parse(await fs.promises.readFile(manifestPath, { encoding: 'utf-8' }));
+    const rawManifest = JSON.parse(await fs.promises.readFile(manifestPath, { encoding: 'utf-8' })) as Record<string, unknown>;
     let manifest = BlockPackManifest.parse(rawManifest);
     // To keep extra fields from the manifest and keep coerced fields
-    manifest = simpleDeepMerge(rawManifest, manifest);
+    manifest = simpleDeepMerge(rawManifest, manifest as BlockPackManifest & Record<string, unknown>);
     const manifestRoot = path.dirname(manifestPath);
 
     this.log(`Manifest root = ${manifestRoot}`);
@@ -86,7 +86,7 @@ export default class Publish extends Command {
     const registry = new BlockRegistryV2(storage, new OclifLoggerAdapter(this));
 
     await registry.publishPackage(manifest, async (file) =>
-      Buffer.from(await fs.promises.readFile(path.resolve(manifestRoot, file)))
+      Buffer.from(await fs.promises.readFile(path.resolve(manifestRoot, file))),
     );
 
     if (!flags.unstable) {

package/src/cmd/refresh-registry.ts

@@ -1,11 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { BlockRegistryV2, loadPackDescriptionRaw } from '../v2';
-import path from 'path';
-import {
-  overrideDescriptionVersion,
-  overrideManifestVersion,
-  StableChannel
-} from '@milaboratories/pl-model-middle-layer';
+import { BlockRegistryV2 } from '../v2';
 import { storageByUrl } from '../io';
 import { OclifLoggerAdapter } from '@milaboratories/ts-helpers-oclif';
 
@@ -18,7 +12,7 @@ export default class RefreshRegistry extends Command {
       summary: 'full address of the registry',
       helpValue: '<address>',
       env: 'PL_REGISTRY',
-      required: true
+      required: true,
     }),
 
     mode: Flags.string({
@@ -27,8 +21,8 @@ export default class RefreshRegistry extends Command {
       helpValue: '<mode>',
       options: ['force', 'normal', 'dry-run'],
       env: 'PL_REGISTRY_REFRESH_DRY_RUN',
-      default: 'normal'
-    })
+      default: 'normal',
+    }),
   };
 
   public async run(): Promise<void> {

package/src/cmd/restore-overview-from-snapshot.ts

@@ -7,39 +7,39 @@ export default class RestoreOverviewFromSnapshot extends Command {
   static description = 'Restore global overview from a snapshot';
 
   static flags = {
-    registry: Flags.string({
+    'registry': Flags.string({
       char: 'r',
       summary: 'full address of the registry',
       helpValue: '<address>',
       env: 'PL_REGISTRY',
-      required: true
+      required: true,
     }),
 
-    snapshot: Flags.string({
+    'snapshot': Flags.string({
       char: 's',
       summary: 'snapshot timestamp ID to restore from',
       helpValue: '<timestamp>',
-      required: true
+      required: true,
     }),
 
     'skip-confirmation': Flags.boolean({
       summary: 'skip confirmation prompt (use with caution)',
-      default: false
-    })
+      default: false,
+    }),
   };
 
   public async run(): Promise<void> {
     const { flags } = await this.parse(RestoreOverviewFromSnapshot);
     const storage = storageByUrl(flags.registry);
     const registry = new BlockRegistryV2(storage, new OclifLoggerAdapter(this));
-    
+
     // Check if snapshot exists
     const snapshots = await registry.listGlobalOverviewSnapshots();
-    const targetSnapshot = snapshots.find(s => s.timestamp === flags.snapshot);
-    
+    const targetSnapshot = snapshots.find((s) => s.timestamp === flags.snapshot);
+
     if (!targetSnapshot) {
       this.error(`Snapshot '${flags.snapshot}' not found. Available snapshots:\n${
-        snapshots.map(s => `  - ${s.timestamp}`).join('\n') || '  (none)'
+        snapshots.map((s) => `  - ${s.timestamp}`).join('\n') || '  (none)'
       }`);
     }
 
@@ -48,17 +48,17 @@ export default class RestoreOverviewFromSnapshot extends Command {
       const readline = await import('node:readline');
       const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout
+        output: process.stdout,
       });
 
       const answer = await new Promise<string>((resolve) => {
         rl.question(
-          `⚠️  This will overwrite the current global overview with snapshot '${flags.snapshot}'.\n` +
-          `Are you sure you want to continue? (y/N): `,
-          resolve
+          `⚠️  This will overwrite the current global overview with snapshot '${flags.snapshot}'.\n`
+          + `Are you sure you want to continue? (y/N): `,
+          resolve,
         );
       });
-      
+
       rl.close();
 
       if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
@@ -72,7 +72,7 @@ export default class RestoreOverviewFromSnapshot extends Command {
       await registry.restoreGlobalOverviewFromSnapshot(flags.snapshot);
       this.log(`✅ Successfully restored global overview from snapshot '${flags.snapshot}'`);
     } catch (error) {
-      this.error(`Failed to restore from snapshot: ${error}`);
+      this.error(`Failed to restore from snapshot: ${String(error)}`);
     }
   }
 }

package/src/cmd/update-deps.ts

@@ -3,11 +3,12 @@ import { execFileSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 
 export default class UpdateDeps extends Command {
-  static override description =
-    'Updates @platforma-sdk and @milaboratories packages in pnpm-workspace.yaml catalog to their latest versions from npm registry.';
+  static override description
+    = 'Updates @platforma-sdk and @milaboratories packages in pnpm-workspace.yaml catalog to their latest versions from npm registry.';
 
   static override examples = ['<%= config.bin %> <%= command.id %>'];
 
+  // eslint-disable-next-line @typescript-eslint/require-await -- oclif requires async but implementation is sync
   public async run(): Promise<void> {
     const require = createRequire(import.meta.url);
     const updaterPath = require.resolve('@platforma-sdk/blocks-deps-updater/scripts/updater.js');

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

@@ -18,46 +18,46 @@ export default class UploadPackageV1 extends Command {
       char: 'r',
       summary: 'full address of the registry or alias from .pl.reg',
       helpValue: '<address|alias>',
-      env: 'PL_REGISTRY'
+      env: 'PL_REGISTRY',
     }),
 
     organization: Flags.string({
       char: 'o',
       summary: 'target organisation',
-      env: 'PL_PACKAGE_ORGANIZATION'
+      env: 'PL_PACKAGE_ORGANIZATION',
     }),
 
     package: Flags.string({
       char: 'p',
       summary: 'target package',
-      env: 'PL_PACKAGE_NAME'
+      env: 'PL_PACKAGE_NAME',
     }),
 
     version: Flags.string({
       char: 'v',
       summary: 'target version',
-      env: 'PL_PACKAGE_VERSION'
+      env: 'PL_PACKAGE_VERSION',
     }),
 
     meta: Flags.file({
       char: 'm',
       summary: 'json file containing meta information to associate with tha package',
-      exists: true
+      exists: true,
     }),
 
     file: targetFile({
       char: 'f',
       summary: 'package files',
       multiple: true,
-      default: []
+      default: [],
     }),
 
     refresh: Flags.boolean({
       summary: 'refresh repository after adding the package',
       default: true,
       allowNo: true,
-      env: 'PL_REGISTRY_REFRESH'
-    })
+      env: 'PL_REGISTRY_REFRESH',
+    }),
   };
 
   public async run(): Promise<void> {
@@ -69,12 +69,12 @@ export default class UploadPackageV1 extends Command {
     if (flags.meta) {
       if (flags.meta.endsWith('.json'))
         configFromFlags.meta = JSON.parse(
-          await fs.promises.readFile(flags.meta, { encoding: 'utf-8' })
-        );
+          await fs.promises.readFile(flags.meta, { encoding: 'utf-8' }),
+        ) as Record<string, unknown>;
       else if (flags.meta.endsWith('.yaml'))
         configFromFlags.meta = YAML.parse(
-          await fs.promises.readFile(flags.meta, { encoding: 'utf-8' })
-        );
+          await fs.promises.readFile(flags.meta, { encoding: 'utf-8' }),
+        ) as Record<string, unknown>;
     }
 
     for (const targetFile of flags.file) {

package/src/io/folder_reader.ts

@@ -1,5 +1,6 @@
-import { Dispatcher, request } from 'undici';
-import { RelativeContentReader } from '../v2';
+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';
@@ -15,13 +16,13 @@ export interface FolderReader {
 class HttpFolderReader implements FolderReader {
   constructor(
     public readonly rootUrl: URL,
-    private readonly httpDispatcher: Dispatcher
+    private readonly httpDispatcher: Dispatcher,
   ) {}
 
   public async readFile(file: string): Promise<Buffer> {
     const targetUrl = new URL(file, this.rootUrl);
     const response = await request(targetUrl, {
-      dispatcher: this.httpDispatcher
+      dispatcher: this.httpDispatcher,
     });
     return Buffer.from(await response.body.arrayBuffer());
   }
@@ -32,8 +33,9 @@ class HttpFolderReader implements FolderReader {
   }
 
   public getContentReader(relativePath?: string): RelativeContentReader {
-    let reader: HttpFolderReader = this;
-    if (relativePath !== undefined) reader = reader.relativeReader(relativePath);
+    const reader: HttpFolderReader = relativePath !== undefined
+      ? this.relativeReader(relativePath)
+      : this;
     return (path) => reader.readFile(path);
   }
 }
@@ -41,7 +43,7 @@ class HttpFolderReader implements FolderReader {
 class FSFolderReader implements FolderReader {
   constructor(
     public readonly rootUrl: URL,
-    private readonly root: string
+    private readonly root: string,
   ) {}
 
   public async readFile(file: string): Promise<Buffer> {
@@ -53,13 +55,14 @@ class FSFolderReader implements FolderReader {
     if (!relativePath.endsWith('/')) relativePath = relativePath + '/';
     return new FSFolderReader(
       new URL(relativePath, this.rootUrl),
-      path.join(this.root, ...relativePath.split(pathPosix.sep))
+      path.join(this.root, ...relativePath.split(pathPosix.sep)),
     );
   }
 
   public getContentReader(relativePath?: string): RelativeContentReader {
-    let reader: FSFolderReader = this;
-    if (relativePath !== undefined) reader = reader.relativeReader(relativePath);
+    const reader: FSFolderReader = relativePath !== undefined
+      ? this.relativeReader(relativePath)
+      : this;
     return (path) => reader.readFile(path);
   }
 }
@@ -76,9 +79,10 @@ export function folderReaderByUrl(address: string, httpDispatcher?: Dispatcher):
   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:':
       return new HttpFolderReader(url, httpDispatcher ?? defaultHttpDispatcher());

package/src/io/storage.ts

@@ -17,7 +17,7 @@ export class S3Storage implements RegistryStorage {
   constructor(
     public readonly client: S3,
     public readonly bucket: string,
-    public readonly root: string
+    public readonly root: string,
   ) {}
 
   async getFile(file: string): Promise<Buffer | undefined> {
@@ -26,12 +26,12 @@ export class S3Storage implements RegistryStorage {
         await (
           await this.client.getObject({
             Bucket: this.bucket,
-            Key: pathPosix.join(this.root, file)
+            Key: pathPosix.join(this.root, file),
           })
-        ).Body!.transformToByteArray()
+        ).Body!.transformToByteArray(),
       );
-    } catch (e: any) {
-      if (e.name === 'NoSuchKey') return undefined;
+    } catch (e: unknown) {
+      if (e instanceof Error && e.name === 'NoSuchKey') return undefined;
       else throw e;
     }
   }
@@ -42,8 +42,8 @@ export class S3Storage implements RegistryStorage {
       { client: this.client },
       {
         Bucket: this.bucket,
-        Prefix: listRoot
-      }
+        Prefix: listRoot,
+      },
     );
     const result: string[] = [];
     for await (const page of paginator)
@@ -55,7 +55,7 @@ export class S3Storage implements RegistryStorage {
     await this.client.putObject({
       Bucket: this.bucket,
       Key: pathPosix.join(this.root, file),
-      Body: buffer
+      Body: buffer,
     });
   }
 
@@ -65,12 +65,12 @@ export class S3Storage implements RegistryStorage {
       Bucket: this.bucket,
       Delete: {
         Objects: files.map((file) => ({
-          Key: pathPosix.join(this.root, 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')}`);
+      throw new Error(`Errors encountered while deleting files: ${results.Errors.map((e) => e.Message ?? e.Code ?? 'Unknown error').join('\n')}`);
   }
 }
 
@@ -90,9 +90,9 @@ export class FSStorage implements RegistryStorage {
   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 });
+    } catch (err: unknown) {
+      if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return undefined;
+      else throw err;
     }
   }
 
@@ -100,13 +100,13 @@ export class FSStorage implements RegistryStorage {
     try {
       const listRoot = this.toAbsolutePath(prefix);
       return (await fs.promises.readdir(listRoot, { recursive: true, withFileTypes: true }))
-        .filter((e: any) => e.isFile())
-        .map((e: any) =>
-          path.relative(listRoot, path.resolve(e.parentPath, e.name)).split(path.sep).join(pathPosix.sep)
+        .filter((e) => e.isFile())
+        .map((e) =>
+          path.relative(listRoot, path.resolve(e.parentPath, e.name)).split(path.sep).join(pathPosix.sep),
         );
-    } catch (err: any) {
-      if (err.code == 'ENOENT') return [];
-      else throw new Error('', { cause: err });
+    } catch (err: unknown) {
+      if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return [];
+      else throw err;
     }
   }
 
@@ -125,15 +125,17 @@ 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)}/`);
   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');
       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/registry_v1/config.ts

@@ -4,35 +4,35 @@ import {
   PlPackageJsonConfigFile,
   PlPackageYamlConfigFile,
   PlRegFullPackageConfigData,
-  PlRegPackageConfigDataShard
+  PlRegPackageConfigDataShard,
 } from './config_schema';
 import * as os from 'node:os';
 import { BlockRegistry } from './registry';
 import { storageByUrl } from '../io/storage';
-import { FullBlockPackageName } from './v1_repo_schema';
-import { MiLogger } from '@milaboratories/ts-helpers';
+import type { FullBlockPackageName } from './v1_repo_schema';
+import type { MiLogger } from '@milaboratories/ts-helpers';
 
 function mergeConfigs(
   c1: PlRegPackageConfigDataShard,
-  c2: PlRegPackageConfigDataShard | undefined
+  c2: PlRegPackageConfigDataShard | undefined,
 ): PlRegPackageConfigDataShard {
   if (c2 === undefined) return c1;
   return {
     ...c1,
     ...c2,
     registries: { ...c1.registries, ...c2.registries },
-    files: { ...c1.files, ...c2.files }
+    files: { ...c1.files, ...c2.files },
   };
 }
 
 async function tryLoadJsonConfigFromFile(
-  file: string
+  file: string,
 ): Promise<PlRegPackageConfigDataShard | undefined> {
   return tryLoadFile(file, (buf) => PlRegPackageConfigDataShard.parse(JSON.parse(buf.toString())));
 }
 
 async function tryLoadYamlConfigFromFile(
-  file: string
+  file: string,
 ): Promise<PlRegPackageConfigDataShard | undefined> {
   return tryLoadFile(file, (buf) => PlRegPackageConfigDataShard.parse(YAML.parse(buf.toString())));
 }
@@ -50,9 +50,10 @@ async function loadConfigShard(): Promise<PlRegPackageConfigDataShard> {
   return conf;
 }
 
-let conf: PlRegPackageConfigDataShard | undefined = undefined;
+const conf: PlRegPackageConfigDataShard | undefined = undefined;
 let confPromise: Promise<PlRegPackageConfigDataShard> | undefined = undefined;
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 async function getConfigShard() {
   if (conf !== undefined) return conf;
   if (confPromise !== undefined) return await confPromise;
@@ -77,7 +78,7 @@ export class PlRegPackageConfig {
     return {
       organization: this.conf.organization,
       package: this.conf.package,
-      version: this.conf.version
+      version: this.conf.version,
     };
   }
 }
@@ -85,6 +86,6 @@ export class PlRegPackageConfig {
 export async function getConfig(finalShard: PlRegPackageConfigDataShard) {
   const confShard = await loadConfigShard();
   return new PlRegPackageConfig(
-    PlRegFullPackageConfigData.parse(mergeConfigs(confShard, finalShard))
+    PlRegFullPackageConfigData.parse(mergeConfigs(confShard, finalShard)),
   );
 }

package/src/registry_v1/config_schema.ts

@@ -6,23 +6,23 @@ export const PlPackageConfigData = z.object({
   organization: z.string(),
   package: z.string(),
   version: SemVer.optional(),
-  files: z.record(z.string().regex(/^[^\/]+$/), z.string()).default({}),
-  meta: z.object({}).passthrough()
+  files: z.record(z.string().regex(/^[^/]+$/), z.string()).default({}),
+  meta: z.object({}).passthrough(),
 });
 
 export const PlRegCommonConfigData = z.object({
   registries: z.record(z.string(), PlRegAddress).default({}),
-  registry: z.string().optional()
+  registry: z.string().optional(),
 });
 export type PlRegCommonConfigData = z.infer<typeof PlRegCommonConfigData>;
 
 export const PlRegFullPackageConfigData = PlRegCommonConfigData.merge(PlPackageConfigData).required(
-  { registry: true, version: true }
+  { registry: true, version: true },
 );
 export type PlRegFullPackageConfigData = z.infer<typeof PlRegFullPackageConfigData>;
 export const PlRegPackageConfigDataShard = PlRegFullPackageConfigData.partial().required({
   registries: true,
-  files: true
+  files: true,
 });
 export type PlRegPackageConfigDataShard = z.infer<typeof PlRegPackageConfigDataShard>;
 

package/src/registry_v1/flags.ts

@@ -7,7 +7,7 @@ export interface TargetFile {
 }
 
 function parseTargetFile(arg: string): TargetFile {
-  const match = arg.match(/(?<destName>[^\/\\]+)=(?<src>.*)/);
+  const match = arg.match(/(?<destName>[^/\\]+)=(?<src>.*)/);
   if (match) {
     const { src, destName } = match.groups!;
     return { src, destName };
@@ -19,5 +19,6 @@ function parseTargetFile(arg: string): TargetFile {
 export const targetFile = Flags.custom<TargetFile>({
   summary: 'target files to upload',
   helpValue: 'file_path | package_name=file_path',
-  parse: async (arg) => parseTargetFile(arg)
+  // eslint-disable-next-line @typescript-eslint/require-await -- oclif requires async but parsing is sync
+  parse: async (arg) => parseTargetFile(arg),
 });