@push.rocks/smartregistry 1.5.0 → 1.7.0

package/ts/core/classes.registrystorage.ts

@@ -18,14 +18,8 @@ export class RegistryStorage implements IStorageBackend {
    * Initialize the storage backend
    */
   public async init(): Promise<void> {
-    this.smartBucket = new plugins.smartbucket.SmartBucket({
-      accessKey: this.config.accessKey,
-      accessSecret: this.config.accessSecret,
-      endpoint: this.config.endpoint,
-      port: this.config.port || 443,
-      useSsl: this.config.useSsl !== false,
-      region: this.config.region || 'us-east-1',
-    });
+    // Pass config as IS3Descriptor to SmartBucket (bucketName is extra, SmartBucket ignores it)
+    this.smartBucket = new plugins.smartbucket.SmartBucket(this.config as plugins.tsclass.storage.IS3Descriptor);
 
     // Ensure bucket exists
     await this.smartBucket.createBucket(this.bucketName).catch(() => {
@@ -828,4 +822,240 @@ export class RegistryStorage implements IStorageBackend {
   private getPypiPackageFilePath(packageName: string, filename: string): string {
     return `pypi/packages/${packageName}/${filename}`;
   }
+
+  // ========================================================================
+  // RUBYGEMS STORAGE METHODS
+  // ========================================================================
+
+  /**
+   * Get RubyGems versions file (compact index)
+   */
+  public async getRubyGemsVersions(): Promise<string | null> {
+    const path = this.getRubyGemsVersionsPath();
+    const data = await this.getObject(path);
+    return data ? data.toString('utf-8') : null;
+  }
+
+  /**
+   * Store RubyGems versions file (compact index)
+   */
+  public async putRubyGemsVersions(content: string): Promise<void> {
+    const path = this.getRubyGemsVersionsPath();
+    const data = Buffer.from(content, 'utf-8');
+    return this.putObject(path, data, { 'Content-Type': 'text/plain; charset=utf-8' });
+  }
+
+  /**
+   * Get RubyGems info file for a gem (compact index)
+   */
+  public async getRubyGemsInfo(gemName: string): Promise<string | null> {
+    const path = this.getRubyGemsInfoPath(gemName);
+    const data = await this.getObject(path);
+    return data ? data.toString('utf-8') : null;
+  }
+
+  /**
+   * Store RubyGems info file for a gem (compact index)
+   */
+  public async putRubyGemsInfo(gemName: string, content: string): Promise<void> {
+    const path = this.getRubyGemsInfoPath(gemName);
+    const data = Buffer.from(content, 'utf-8');
+    return this.putObject(path, data, { 'Content-Type': 'text/plain; charset=utf-8' });
+  }
+
+  /**
+   * Get RubyGems names file
+   */
+  public async getRubyGemsNames(): Promise<string | null> {
+    const path = this.getRubyGemsNamesPath();
+    const data = await this.getObject(path);
+    return data ? data.toString('utf-8') : null;
+  }
+
+  /**
+   * Store RubyGems names file
+   */
+  public async putRubyGemsNames(content: string): Promise<void> {
+    const path = this.getRubyGemsNamesPath();
+    const data = Buffer.from(content, 'utf-8');
+    return this.putObject(path, data, { 'Content-Type': 'text/plain; charset=utf-8' });
+  }
+
+  /**
+   * Get RubyGems .gem file
+   */
+  public async getRubyGemsGem(gemName: string, version: string, platform?: string): Promise<Buffer | null> {
+    const path = this.getRubyGemsGemPath(gemName, version, platform);
+    return this.getObject(path);
+  }
+
+  /**
+   * Store RubyGems .gem file
+   */
+  public async putRubyGemsGem(
+    gemName: string,
+    version: string,
+    data: Buffer,
+    platform?: string
+  ): Promise<void> {
+    const path = this.getRubyGemsGemPath(gemName, version, platform);
+    return this.putObject(path, data, { 'Content-Type': 'application/octet-stream' });
+  }
+
+  /**
+   * Check if RubyGems .gem file exists
+   */
+  public async rubyGemsGemExists(gemName: string, version: string, platform?: string): Promise<boolean> {
+    const path = this.getRubyGemsGemPath(gemName, version, platform);
+    return this.objectExists(path);
+  }
+
+  /**
+   * Delete RubyGems .gem file
+   */
+  public async deleteRubyGemsGem(gemName: string, version: string, platform?: string): Promise<void> {
+    const path = this.getRubyGemsGemPath(gemName, version, platform);
+    return this.deleteObject(path);
+  }
+
+  /**
+   * Get RubyGems metadata
+   */
+  public async getRubyGemsMetadata(gemName: string): Promise<any | null> {
+    const path = this.getRubyGemsMetadataPath(gemName);
+    const data = await this.getObject(path);
+    return data ? JSON.parse(data.toString('utf-8')) : null;
+  }
+
+  /**
+   * Store RubyGems metadata
+   */
+  public async putRubyGemsMetadata(gemName: string, metadata: any): Promise<void> {
+    const path = this.getRubyGemsMetadataPath(gemName);
+    const data = Buffer.from(JSON.stringify(metadata, null, 2), 'utf-8');
+    return this.putObject(path, data, { 'Content-Type': 'application/json' });
+  }
+
+  /**
+   * Check if RubyGems metadata exists
+   */
+  public async rubyGemsMetadataExists(gemName: string): Promise<boolean> {
+    const path = this.getRubyGemsMetadataPath(gemName);
+    return this.objectExists(path);
+  }
+
+  /**
+   * Delete RubyGems metadata
+   */
+  public async deleteRubyGemsMetadata(gemName: string): Promise<void> {
+    const path = this.getRubyGemsMetadataPath(gemName);
+    return this.deleteObject(path);
+  }
+
+  /**
+   * List all RubyGems
+   */
+  public async listRubyGems(): Promise<string[]> {
+    const prefix = 'rubygems/metadata/';
+    const objects = await this.listObjects(prefix);
+    const gems = new Set<string>();
+
+    // Extract gem names from paths like: rubygems/metadata/gem-name/metadata.json
+    for (const obj of objects) {
+      const match = obj.match(/^rubygems\/metadata\/([^\/]+)\/metadata\.json$/);
+      if (match) {
+        gems.add(match[1]);
+      }
+    }
+
+    return Array.from(gems).sort();
+  }
+
+  /**
+   * List all versions of a RubyGem
+   */
+  public async listRubyGemsVersions(gemName: string): Promise<string[]> {
+    const prefix = `rubygems/gems/`;
+    const objects = await this.listObjects(prefix);
+    const versions = new Set<string>();
+
+    // Extract versions from filenames: gem-name-version[-platform].gem
+    const gemPrefix = `${gemName}-`;
+    for (const obj of objects) {
+      const filename = obj.split('/').pop();
+      if (!filename || !filename.startsWith(gemPrefix) || !filename.endsWith('.gem')) continue;
+
+      // Remove gem name prefix and .gem suffix
+      const versionPart = filename.substring(gemPrefix.length, filename.length - 4);
+
+      // Split on last hyphen to separate version from platform
+      const lastHyphen = versionPart.lastIndexOf('-');
+      const version = lastHyphen > 0 ? versionPart.substring(0, lastHyphen) : versionPart;
+
+      versions.add(version);
+    }
+
+    return Array.from(versions).sort();
+  }
+
+  /**
+   * Delete entire RubyGem (all versions and files)
+   */
+  public async deleteRubyGem(gemName: string): Promise<void> {
+    // Delete metadata
+    await this.deleteRubyGemsMetadata(gemName);
+
+    // Delete all gem files
+    const prefix = `rubygems/gems/`;
+    const objects = await this.listObjects(prefix);
+    const gemPrefix = `${gemName}-`;
+
+    for (const obj of objects) {
+      const filename = obj.split('/').pop();
+      if (filename && filename.startsWith(gemPrefix) && filename.endsWith('.gem')) {
+        await this.deleteObject(obj);
+      }
+    }
+  }
+
+  /**
+   * Delete specific version of a RubyGem
+   */
+  public async deleteRubyGemsVersion(gemName: string, version: string, platform?: string): Promise<void> {
+    // Delete gem file
+    await this.deleteRubyGemsGem(gemName, version, platform);
+
+    // Update metadata to remove this version
+    const metadata = await this.getRubyGemsMetadata(gemName);
+    if (metadata && metadata.versions) {
+      const versionKey = platform ? `${version}-${platform}` : version;
+      delete metadata.versions[versionKey];
+      await this.putRubyGemsMetadata(gemName, metadata);
+    }
+  }
+
+  // ========================================================================
+  // RUBYGEMS PATH HELPERS
+  // ========================================================================
+
+  private getRubyGemsVersionsPath(): string {
+    return 'rubygems/versions';
+  }
+
+  private getRubyGemsInfoPath(gemName: string): string {
+    return `rubygems/info/${gemName}`;
+  }
+
+  private getRubyGemsNamesPath(): string {
+    return 'rubygems/names';
+  }
+
+  private getRubyGemsGemPath(gemName: string, version: string, platform?: string): string {
+    const filename = platform ? `${gemName}-${version}-${platform}.gem` : `${gemName}-${version}.gem`;
+    return `rubygems/gems/${filename}`;
+  }
+
+  private getRubyGemsMetadataPath(gemName: string): string {
+    return `rubygems/metadata/${gemName}/metadata.json`;
+  }
 }

package/ts/core/interfaces.core.ts

@@ -2,6 +2,8 @@
  * Core interfaces for the composable registry system
  */
 
+import type * as plugins from '../plugins.js';
+
 /**
  * Registry protocol types
  */
@@ -40,14 +42,9 @@ export interface ICredentials {
 
 /**
  * Storage backend configuration
+ * Extends IS3Descriptor from @tsclass/tsclass with bucketName
  */
-export interface IStorageConfig {
-  accessKey: string;
-  accessSecret: string;
-  endpoint: string;
-  port?: number;
-  useSsl?: boolean;
-  region?: string;
+export interface IStorageConfig extends plugins.tsclass.storage.IS3Descriptor {
   bucketName: string;
 }
 

package/ts/index.ts

@@ -1,6 +1,6 @@
 /**
  * @push.rocks/smartregistry
- * Composable registry supporting OCI, NPM, Maven, Cargo, and Composer protocols
+ * Composable registry supporting OCI, NPM, Maven, Cargo, Composer, PyPI, and RubyGems protocols
  */
 
 // Main orchestrator
@@ -23,3 +23,9 @@ export * from './cargo/index.js';
 
 // Composer Registry
 export * from './composer/index.js';
+
+// PyPI Registry
+export * from './pypi/index.js';
+
+// RubyGems Registry
+export * from './rubygems/index.js';

package/ts/plugins.ts

@@ -9,3 +9,8 @@ import * as smartlog from '@push.rocks/smartlog';
 import * as smartpath from '@push.rocks/smartpath';
 
 export { smartbucket, smartlog, smartpath };
+
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };

package/ts/pypi/classes.pypiregistry.ts

@@ -351,22 +351,38 @@ export class PypiRegistry extends BaseRegistry {
         return this.errorResponse(403, 'Insufficient permissions');
       }
 
-      // Calculate hashes
+      // Calculate and verify hashes
       const hashes: Record<string, string> = {};
 
-      if (formData.sha256_digest) {
-        hashes.sha256 = formData.sha256_digest;
-      } else {
-        hashes.sha256 = await helpers.calculateHash(fileData, 'sha256');
+      // Always calculate SHA256
+      const actualSha256 = await helpers.calculateHash(fileData, 'sha256');
+      hashes.sha256 = actualSha256;
+
+      // Verify client-provided SHA256 if present
+      if (formData.sha256_digest && formData.sha256_digest !== actualSha256) {
+        return this.errorResponse(400, 'SHA256 hash mismatch');
       }
 
+      // Calculate MD5 if requested
       if (formData.md5_digest) {
-        // MD5 digest in PyPI is urlsafe base64, convert to hex
-        hashes.md5 = await helpers.calculateHash(fileData, 'md5');
+        const actualMd5 = await helpers.calculateHash(fileData, 'md5');
+        hashes.md5 = actualMd5;
+
+        // Verify if client provided MD5
+        if (formData.md5_digest !== actualMd5) {
+          return this.errorResponse(400, 'MD5 hash mismatch');
+        }
       }
 
+      // Calculate Blake2b if requested
       if (formData.blake2_256_digest) {
-        hashes.blake2b = formData.blake2_256_digest;
+        const actualBlake2b = await helpers.calculateHash(fileData, 'blake2b');
+        hashes.blake2b = actualBlake2b;
+
+        // Verify if client provided Blake2b
+        if (formData.blake2_256_digest !== actualBlake2b) {
+          return this.errorResponse(400, 'Blake2b hash mismatch');
+        }
       }
 
       // Store file