@push.rocks/smartregistry 1.4.1 → 1.6.0

package/dist_ts/rubygems/classes.rubygemsregistry.js

@@ -0,0 +1,475 @@
+import { Smartlog } from '@push.rocks/smartlog';
+import { BaseRegistry } from '../core/classes.baseregistry.js';
+import { RegistryStorage } from '../core/classes.registrystorage.js';
+import { AuthManager } from '../core/classes.authmanager.js';
+import * as helpers from './helpers.rubygems.js';
+/**
+ * RubyGems registry implementation
+ * Implements Compact Index API and RubyGems protocol
+ */
+export class RubyGemsRegistry extends BaseRegistry {
+    storage;
+    authManager;
+    basePath = '/rubygems';
+    registryUrl;
+    logger;
+    constructor(storage, authManager, basePath = '/rubygems', registryUrl = 'http://localhost:5000/rubygems') {
+        super();
+        this.storage = storage;
+        this.authManager = authManager;
+        this.basePath = basePath;
+        this.registryUrl = registryUrl;
+        // Initialize logger
+        this.logger = new Smartlog({
+            logContext: {
+                company: 'push.rocks',
+                companyunit: 'smartregistry',
+                containerName: 'rubygems-registry',
+                environment: process.env.NODE_ENV || 'development',
+                runtime: 'node',
+                zone: 'rubygems'
+            }
+        });
+        this.logger.enableConsole();
+    }
+    async init() {
+        // Initialize Compact Index files if not exist
+        const existingVersions = await this.storage.getRubyGemsVersions();
+        if (!existingVersions) {
+            const versions = helpers.generateCompactIndexVersions([]);
+            await this.storage.putRubyGemsVersions(versions);
+            this.logger.log('info', 'Initialized RubyGems Compact Index');
+        }
+        const existingNames = await this.storage.getRubyGemsNames();
+        if (!existingNames) {
+            const names = helpers.generateNamesFile([]);
+            await this.storage.putRubyGemsNames(names);
+            this.logger.log('info', 'Initialized RubyGems names file');
+        }
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+    async handleRequest(context) {
+        let path = context.path.replace(this.basePath, '');
+        // Extract token (Authorization header)
+        const token = await this.extractToken(context);
+        this.logger.log('debug', `handleRequest: ${context.method} ${path}`, {
+            method: context.method,
+            path,
+            hasAuth: !!token
+        });
+        // Compact Index endpoints
+        if (path === '/versions' && context.method === 'GET') {
+            return this.handleVersionsFile();
+        }
+        if (path === '/names' && context.method === 'GET') {
+            return this.handleNamesFile();
+        }
+        // Info file: GET /info/{gem}
+        const infoMatch = path.match(/^\/info\/([^\/]+)$/);
+        if (infoMatch && context.method === 'GET') {
+            return this.handleInfoFile(infoMatch[1]);
+        }
+        // Gem download: GET /gems/{gem}-{version}[-{platform}].gem
+        const downloadMatch = path.match(/^\/gems\/(.+\.gem)$/);
+        if (downloadMatch && context.method === 'GET') {
+            return this.handleDownload(downloadMatch[1]);
+        }
+        // API v1 endpoints
+        if (path.startsWith('/api/v1/')) {
+            return this.handleApiRequest(path.substring(8), context, token);
+        }
+        return {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+            body: Buffer.from(JSON.stringify({ message: 'Not Found' })),
+        };
+    }
+    /**
+     * Check if token has permission for resource
+     */
+    async checkPermission(token, resource, action) {
+        if (!token)
+            return false;
+        return this.authManager.authorize(token, `rubygems:gem:${resource}`, action);
+    }
+    /**
+     * Extract authentication token from request
+     */
+    async extractToken(context) {
+        const authHeader = context.headers['authorization'] || context.headers['Authorization'];
+        if (!authHeader)
+            return null;
+        // RubyGems typically uses plain API key in Authorization header
+        return this.authManager.validateToken(authHeader, 'rubygems');
+    }
+    /**
+     * Handle /versions endpoint (Compact Index)
+     */
+    async handleVersionsFile() {
+        const content = await this.storage.getRubyGemsVersions();
+        if (!content) {
+            return this.errorResponse(500, 'Versions file not initialized');
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'public, max-age=60',
+                'ETag': `"${await helpers.calculateMD5(content)}"`
+            },
+            body: Buffer.from(content),
+        };
+    }
+    /**
+     * Handle /names endpoint (Compact Index)
+     */
+    async handleNamesFile() {
+        const content = await this.storage.getRubyGemsNames();
+        if (!content) {
+            return this.errorResponse(500, 'Names file not initialized');
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'public, max-age=300'
+            },
+            body: Buffer.from(content),
+        };
+    }
+    /**
+     * Handle /info/{gem} endpoint (Compact Index)
+     */
+    async handleInfoFile(gemName) {
+        const content = await this.storage.getRubyGemsInfo(gemName);
+        if (!content) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'text/plain' },
+                body: Buffer.from('Not Found'),
+            };
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'public, max-age=300',
+                'ETag': `"${await helpers.calculateMD5(content)}"`
+            },
+            body: Buffer.from(content),
+        };
+    }
+    /**
+     * Handle gem file download
+     */
+    async handleDownload(filename) {
+        const parsed = helpers.parseGemFilename(filename);
+        if (!parsed) {
+            return this.errorResponse(400, 'Invalid gem filename');
+        }
+        const gemData = await this.storage.getRubyGemsGem(parsed.name, parsed.version, parsed.platform);
+        if (!gemData) {
+            return this.errorResponse(404, 'Gem not found');
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Disposition': `attachment; filename="${filename}"`,
+                'Content-Length': gemData.length.toString()
+            },
+            body: gemData,
+        };
+    }
+    /**
+     * Handle API v1 requests
+     */
+    async handleApiRequest(path, context, token) {
+        // Upload gem: POST /gems
+        if (path === '/gems' && context.method === 'POST') {
+            return this.handleUpload(context, token);
+        }
+        // Yank gem: DELETE /gems/yank
+        if (path === '/gems/yank' && context.method === 'DELETE') {
+            return this.handleYank(context, token);
+        }
+        // Unyank gem: PUT /gems/unyank
+        if (path === '/gems/unyank' && context.method === 'PUT') {
+            return this.handleUnyank(context, token);
+        }
+        // Version list: GET /versions/{gem}.json
+        const versionsMatch = path.match(/^\/versions\/([^\/]+)\.json$/);
+        if (versionsMatch && context.method === 'GET') {
+            return this.handleVersionsJson(versionsMatch[1]);
+        }
+        // Dependencies: GET /dependencies?gems={list}
+        if (path.startsWith('/dependencies') && context.method === 'GET') {
+            const gemsParam = context.query?.gems || '';
+            return this.handleDependencies(gemsParam);
+        }
+        return this.errorResponse(404, 'API endpoint not found');
+    }
+    /**
+     * Handle gem upload
+     * POST /api/v1/gems
+     */
+    async handleUpload(context, token) {
+        if (!token) {
+            return this.errorResponse(401, 'Authentication required');
+        }
+        try {
+            // Extract gem data from request body
+            const gemData = context.body;
+            if (!gemData || gemData.length === 0) {
+                return this.errorResponse(400, 'No gem file provided');
+            }
+            // For now, we expect metadata in query params or headers
+            // Full implementation would parse .gem file (tar + gzip + Marshal)
+            const gemName = context.query?.name || context.headers['x-gem-name'];
+            const version = context.query?.version || context.headers['x-gem-version'];
+            const platform = context.query?.platform || context.headers['x-gem-platform'];
+            if (!gemName || !version) {
+                return this.errorResponse(400, 'Gem name and version required');
+            }
+            // Validate gem name
+            if (!helpers.isValidGemName(gemName)) {
+                return this.errorResponse(400, 'Invalid gem name');
+            }
+            // Check permission
+            if (!(await this.checkPermission(token, gemName, 'write'))) {
+                return this.errorResponse(403, 'Insufficient permissions');
+            }
+            // Calculate checksum
+            const checksum = await helpers.calculateSHA256(gemData);
+            // Store gem file
+            await this.storage.putRubyGemsGem(gemName, version, gemData, platform);
+            // Update metadata
+            let metadata = await this.storage.getRubyGemsMetadata(gemName) || {
+                name: gemName,
+                versions: {},
+            };
+            const versionKey = platform ? `${version}-${platform}` : version;
+            metadata.versions[versionKey] = {
+                version,
+                platform,
+                checksum,
+                size: gemData.length,
+                'upload-time': new Date().toISOString(),
+                'uploaded-by': token.userId,
+                dependencies: [], // Would extract from gem spec
+                requirements: [],
+            };
+            metadata['last-modified'] = new Date().toISOString();
+            await this.storage.putRubyGemsMetadata(gemName, metadata);
+            // Update Compact Index info file
+            await this.updateCompactIndexForGem(gemName, metadata);
+            // Update versions file
+            await this.updateVersionsFile(gemName, version, platform || 'ruby', false);
+            // Update names file
+            await this.updateNamesFile(gemName);
+            this.logger.log('info', `Gem uploaded: ${gemName} ${version}`, {
+                platform,
+                size: gemData.length
+            });
+            return {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+                body: Buffer.from(JSON.stringify({
+                    message: 'Gem uploaded successfully',
+                    name: gemName,
+                    version,
+                })),
+            };
+        }
+        catch (error) {
+            this.logger.log('error', 'Upload failed', { error: error.message });
+            return this.errorResponse(500, 'Upload failed: ' + error.message);
+        }
+    }
+    /**
+     * Handle gem yanking
+     * DELETE /api/v1/gems/yank
+     */
+    async handleYank(context, token) {
+        if (!token) {
+            return this.errorResponse(401, 'Authentication required');
+        }
+        const gemName = context.query?.gem_name;
+        const version = context.query?.version;
+        const platform = context.query?.platform;
+        if (!gemName || !version) {
+            return this.errorResponse(400, 'Gem name and version required');
+        }
+        if (!(await this.checkPermission(token, gemName, 'yank'))) {
+            return this.errorResponse(403, 'Insufficient permissions');
+        }
+        // Update metadata to mark as yanked
+        const metadata = await this.storage.getRubyGemsMetadata(gemName);
+        if (!metadata) {
+            return this.errorResponse(404, 'Gem not found');
+        }
+        const versionKey = platform ? `${version}-${platform}` : version;
+        if (!metadata.versions[versionKey]) {
+            return this.errorResponse(404, 'Version not found');
+        }
+        metadata.versions[versionKey].yanked = true;
+        await this.storage.putRubyGemsMetadata(gemName, metadata);
+        // Update Compact Index
+        await this.updateCompactIndexForGem(gemName, metadata);
+        await this.updateVersionsFile(gemName, version, platform || 'ruby', true);
+        this.logger.log('info', `Gem yanked: ${gemName} ${version}`);
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: Buffer.from(JSON.stringify({
+                success: true,
+                message: 'Gem yanked successfully'
+            })),
+        };
+    }
+    /**
+     * Handle gem unyanking
+     * PUT /api/v1/gems/unyank
+     */
+    async handleUnyank(context, token) {
+        if (!token) {
+            return this.errorResponse(401, 'Authentication required');
+        }
+        const gemName = context.query?.gem_name;
+        const version = context.query?.version;
+        const platform = context.query?.platform;
+        if (!gemName || !version) {
+            return this.errorResponse(400, 'Gem name and version required');
+        }
+        if (!(await this.checkPermission(token, gemName, 'write'))) {
+            return this.errorResponse(403, 'Insufficient permissions');
+        }
+        const metadata = await this.storage.getRubyGemsMetadata(gemName);
+        if (!metadata) {
+            return this.errorResponse(404, 'Gem not found');
+        }
+        const versionKey = platform ? `${version}-${platform}` : version;
+        if (!metadata.versions[versionKey]) {
+            return this.errorResponse(404, 'Version not found');
+        }
+        metadata.versions[versionKey].yanked = false;
+        await this.storage.putRubyGemsMetadata(gemName, metadata);
+        // Update Compact Index
+        await this.updateCompactIndexForGem(gemName, metadata);
+        await this.updateVersionsFile(gemName, version, platform || 'ruby', false);
+        this.logger.log('info', `Gem unyanked: ${gemName} ${version}`);
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: Buffer.from(JSON.stringify({
+                success: true,
+                message: 'Gem unyanked successfully'
+            })),
+        };
+    }
+    /**
+     * Handle versions JSON API
+     */
+    async handleVersionsJson(gemName) {
+        const metadata = await this.storage.getRubyGemsMetadata(gemName);
+        if (!metadata) {
+            return this.errorResponse(404, 'Gem not found');
+        }
+        const versions = Object.values(metadata.versions).map((v) => ({
+            version: v.version,
+            platform: v.platform,
+            uploadTime: v['upload-time'],
+        }));
+        const response = helpers.generateVersionsJson(gemName, versions);
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'public, max-age=300'
+            },
+            body: Buffer.from(JSON.stringify(response)),
+        };
+    }
+    /**
+     * Handle dependencies query
+     */
+    async handleDependencies(gemsParam) {
+        const gemNames = gemsParam.split(',').filter(n => n.trim());
+        const result = new Map();
+        for (const gemName of gemNames) {
+            const metadata = await this.storage.getRubyGemsMetadata(gemName);
+            if (metadata) {
+                const versions = Object.values(metadata.versions).map((v) => ({
+                    version: v.version,
+                    platform: v.platform,
+                    dependencies: v.dependencies || [],
+                }));
+                result.set(gemName, versions);
+            }
+        }
+        const response = helpers.generateDependenciesJson(result);
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: Buffer.from(JSON.stringify(response)),
+        };
+    }
+    /**
+     * Update Compact Index info file for a gem
+     */
+    async updateCompactIndexForGem(gemName, metadata) {
+        const entries = Object.values(metadata.versions)
+            .filter(v => !v.yanked) // Exclude yanked from info file
+            .map(v => ({
+            version: v.version,
+            platform: v.platform,
+            dependencies: v.dependencies || [],
+            requirements: v.requirements || [],
+            checksum: v.checksum,
+        }));
+        const content = helpers.generateCompactIndexInfo(entries);
+        await this.storage.putRubyGemsInfo(gemName, content);
+    }
+    /**
+     * Update versions file with new/updated gem
+     */
+    async updateVersionsFile(gemName, version, platform, yanked) {
+        const existingVersions = await this.storage.getRubyGemsVersions();
+        if (!existingVersions)
+            return;
+        // Calculate info file checksum
+        const infoContent = await this.storage.getRubyGemsInfo(gemName) || '';
+        const infoChecksum = await helpers.calculateMD5(infoContent);
+        const updated = helpers.updateCompactIndexVersions(existingVersions, gemName, { version, platform: platform !== 'ruby' ? platform : undefined, yanked }, infoChecksum);
+        await this.storage.putRubyGemsVersions(updated);
+    }
+    /**
+     * Update names file with new gem
+     */
+    async updateNamesFile(gemName) {
+        const existingNames = await this.storage.getRubyGemsNames();
+        if (!existingNames)
+            return;
+        const lines = existingNames.split('\n').filter(l => l !== '---');
+        if (!lines.includes(gemName)) {
+            lines.push(gemName);
+            lines.sort();
+            const updated = helpers.generateNamesFile(lines);
+            await this.storage.putRubyGemsNames(updated);
+        }
+    }
+    /**
+     * Helper: Create error response
+     */
+    errorResponse(status, message) {
+        const error = { message, status };
+        return {
+            status,
+            headers: { 'Content-Type': 'application/json' },
+            body: Buffer.from(JSON.stringify(error)),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rubygemsregistry.js","sourceRoot":"","sources":["../../ts/rubygems/classes.rubygemsregistry.ts"],"names":[],"mappings":"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"}

package/dist_ts/rubygems/helpers.rubygems.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Helper functions for RubyGems registry
+ * Compact Index generation, dependency formatting, etc.
+ */
+import type { IRubyGemsDependency, ICompactIndexVersionsEntry, ICompactIndexInfoEntry } from './interfaces.rubygems.js';
+/**
+ * Generate Compact Index versions file
+ * Format: GEMNAME [-]VERSION_PLATFORM[,VERSION_PLATFORM,...] MD5
+ * @param entries - Version entries for all gems
+ * @returns Compact Index versions file content
+ */
+export declare function generateCompactIndexVersions(entries: ICompactIndexVersionsEntry[]): string;
+/**
+ * Generate Compact Index info file for a gem
+ * Format: VERSION[-PLATFORM] [DEP[,DEP,...]]|REQ[,REQ,...]
+ * @param entries - Info entries for gem versions
+ * @returns Compact Index info file content
+ */
+export declare function generateCompactIndexInfo(entries: ICompactIndexInfoEntry[]): string;
+/**
+ * Format a dependency for Compact Index
+ * Format: GEM:CONSTRAINT[&CONSTRAINT]
+ * @param dep - Dependency object
+ * @returns Formatted dependency string
+ */
+export declare function formatDependency(dep: IRubyGemsDependency): string;
+/**
+ * Parse dependency string from Compact Index
+ * @param depStr - Dependency string
+ * @returns Dependency object
+ */
+export declare function parseDependency(depStr: string): IRubyGemsDependency;
+/**
+ * Generate names file (newline-separated gem names)
+ * @param names - List of gem names
+ * @returns Names file content
+ */
+export declare function generateNamesFile(names: string[]): string;
+/**
+ * Calculate MD5 hash for Compact Index checksum
+ * @param content - Content to hash
+ * @returns MD5 hash (hex)
+ */
+export declare function calculateMD5(content: string): Promise<string>;
+/**
+ * Calculate SHA256 hash for gem files
+ * @param data - Data to hash
+ * @returns SHA256 hash (hex)
+ */
+export declare function calculateSHA256(data: Buffer): Promise<string>;
+/**
+ * Parse gem filename to extract name, version, and platform
+ * @param filename - Gem filename (e.g., "rails-7.0.0-x86_64-linux.gem")
+ * @returns Parsed info or null
+ */
+export declare function parseGemFilename(filename: string): {
+    name: string;
+    version: string;
+    platform?: string;
+} | null;
+/**
+ * Validate gem name
+ * Must contain only ASCII letters, numbers, _, and -
+ * @param name - Gem name
+ * @returns true if valid
+ */
+export declare function isValidGemName(name: string): boolean;
+/**
+ * Validate version string
+ * Basic semantic versioning check
+ * @param version - Version string
+ * @returns true if valid
+ */
+export declare function isValidVersion(version: string): boolean;
+/**
+ * Build version list entry for Compact Index
+ * @param versions - Version info
+ * @returns Version list string
+ */
+export declare function buildVersionList(versions: Array<{
+    version: string;
+    platform?: string;
+    yanked: boolean;
+}>): string;
+/**
+ * Parse version list from Compact Index
+ * @param versionStr - Version list string
+ * @returns Parsed versions
+ */
+export declare function parseVersionList(versionStr: string): Array<{
+    version: string;
+    platform?: string;
+    yanked: boolean;
+}>;
+/**
+ * Generate JSON response for /api/v1/versions/{gem}.json
+ * @param gemName - Gem name
+ * @param versions - Version list
+ * @returns JSON response object
+ */
+export declare function generateVersionsJson(gemName: string, versions: Array<{
+    version: string;
+    platform?: string;
+    uploadTime?: string;
+}>): any;
+/**
+ * Generate JSON response for /api/v1/dependencies
+ * @param gems - Map of gem names to version dependencies
+ * @returns JSON response array
+ */
+export declare function generateDependenciesJson(gems: Map<string, Array<{
+    version: string;
+    platform?: string;
+    dependencies: IRubyGemsDependency[];
+}>>): any;
+/**
+ * Update Compact Index versions file with new gem version
+ * Handles append-only semantics for the current month
+ * @param existingContent - Current versions file content
+ * @param gemName - Gem name
+ * @param newVersion - New version info
+ * @param infoChecksum - MD5 of info file
+ * @returns Updated versions file content
+ */
+export declare function updateCompactIndexVersions(existingContent: string, gemName: string, newVersion: {
+    version: string;
+    platform?: string;
+    yanked: boolean;
+}, infoChecksum: string): string;
+/**
+ * Update Compact Index info file with new version
+ * @param existingContent - Current info file content
+ * @param newEntry - New version entry
+ * @returns Updated info file content
+ */
+export declare function updateCompactIndexInfo(existingContent: string, newEntry: ICompactIndexInfoEntry): string;
+/**
+ * Extract gem specification from .gem file
+ * Note: This is a simplified version. Full implementation would use tar + gzip + Marshal
+ * @param gemData - Gem file data
+ * @returns Extracted spec or null
+ */
+export declare function extractGemSpec(gemData: Buffer): Promise<any | null>;