@push.rocks/smartregistry 1.5.0 → 1.6.0

package/dist_ts/rubygems/helpers.rubygems.js

@@ -0,0 +1,312 @@
+/**
+ * Helper functions for RubyGems registry
+ * Compact Index generation, dependency formatting, etc.
+ */
+/**
+ * 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 function generateCompactIndexVersions(entries) {
+    const lines = [];
+    // Add metadata header
+    lines.push(`created_at: ${new Date().toISOString()}`);
+    lines.push('---');
+    // Add gem entries
+    for (const entry of entries) {
+        const versions = entry.versions
+            .map(v => {
+            const yanked = v.yanked ? '-' : '';
+            const platform = v.platform && v.platform !== 'ruby' ? `_${v.platform}` : '';
+            return `${yanked}${v.version}${platform}`;
+        })
+            .join(',');
+        lines.push(`${entry.name} ${versions} ${entry.infoChecksum}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * 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 function generateCompactIndexInfo(entries) {
+    const lines = ['---']; // Info files start with ---
+    for (const entry of entries) {
+        // Build version string with optional platform
+        const versionStr = entry.platform && entry.platform !== 'ruby'
+            ? `${entry.version}-${entry.platform}`
+            : entry.version;
+        // Build dependencies string
+        const depsStr = entry.dependencies.length > 0
+            ? entry.dependencies.map(formatDependency).join(',')
+            : '';
+        // Build requirements string (checksum is always required)
+        const reqParts = [`checksum:${entry.checksum}`];
+        for (const req of entry.requirements) {
+            reqParts.push(`${req.type}:${req.requirement}`);
+        }
+        const reqStr = reqParts.join(',');
+        // Combine: VERSION[-PLATFORM] [DEPS]|REQS
+        const depPart = depsStr ? ` ${depsStr}` : '';
+        lines.push(`${versionStr}${depPart}|${reqStr}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format a dependency for Compact Index
+ * Format: GEM:CONSTRAINT[&CONSTRAINT]
+ * @param dep - Dependency object
+ * @returns Formatted dependency string
+ */
+export function formatDependency(dep) {
+    return `${dep.name}:${dep.requirement}`;
+}
+/**
+ * Parse dependency string from Compact Index
+ * @param depStr - Dependency string
+ * @returns Dependency object
+ */
+export function parseDependency(depStr) {
+    const [name, ...reqParts] = depStr.split(':');
+    const requirement = reqParts.join(':'); // Handle :: in gem names
+    return { name, requirement };
+}
+/**
+ * Generate names file (newline-separated gem names)
+ * @param names - List of gem names
+ * @returns Names file content
+ */
+export function generateNamesFile(names) {
+    return `---\n${names.sort().join('\n')}`;
+}
+/**
+ * Calculate MD5 hash for Compact Index checksum
+ * @param content - Content to hash
+ * @returns MD5 hash (hex)
+ */
+export async function calculateMD5(content) {
+    const crypto = await import('crypto');
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+/**
+ * Calculate SHA256 hash for gem files
+ * @param data - Data to hash
+ * @returns SHA256 hash (hex)
+ */
+export async function calculateSHA256(data) {
+    const crypto = await import('crypto');
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+/**
+ * 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 function parseGemFilename(filename) {
+    if (!filename.endsWith('.gem'))
+        return null;
+    const withoutExt = filename.slice(0, -4); // Remove .gem
+    // Try to match: name-version-platform
+    // Platform can contain hyphens (e.g., x86_64-linux)
+    const parts = withoutExt.split('-');
+    if (parts.length < 2)
+        return null;
+    // Find version (first part that starts with a digit)
+    let versionIndex = -1;
+    for (let i = 1; i < parts.length; i++) {
+        if (/^\d/.test(parts[i])) {
+            versionIndex = i;
+            break;
+        }
+    }
+    if (versionIndex === -1)
+        return null;
+    const name = parts.slice(0, versionIndex).join('-');
+    const version = parts[versionIndex];
+    const platform = versionIndex + 1 < parts.length
+        ? parts.slice(versionIndex + 1).join('-')
+        : undefined;
+    return {
+        name,
+        version,
+        platform: platform && platform !== 'ruby' ? platform : undefined,
+    };
+}
+/**
+ * Validate gem name
+ * Must contain only ASCII letters, numbers, _, and -
+ * @param name - Gem name
+ * @returns true if valid
+ */
+export function isValidGemName(name) {
+    return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+/**
+ * Validate version string
+ * Basic semantic versioning check
+ * @param version - Version string
+ * @returns true if valid
+ */
+export function isValidVersion(version) {
+    // Allow semver and other common Ruby version formats
+    return /^[\d.a-zA-Z_-]+$/.test(version);
+}
+/**
+ * Build version list entry for Compact Index
+ * @param versions - Version info
+ * @returns Version list string
+ */
+export function buildVersionList(versions) {
+    return versions
+        .map(v => {
+        const yanked = v.yanked ? '-' : '';
+        const platform = v.platform && v.platform !== 'ruby' ? `_${v.platform}` : '';
+        return `${yanked}${v.version}${platform}`;
+    })
+        .join(',');
+}
+/**
+ * Parse version list from Compact Index
+ * @param versionStr - Version list string
+ * @returns Parsed versions
+ */
+export function parseVersionList(versionStr) {
+    return versionStr.split(',').map(v => {
+        const yanked = v.startsWith('-');
+        const withoutYank = yanked ? v.substring(1) : v;
+        // Split on _ to separate version from platform
+        const [version, ...platformParts] = withoutYank.split('_');
+        const platform = platformParts.length > 0 ? platformParts.join('_') : undefined;
+        return {
+            version,
+            platform: platform && platform !== 'ruby' ? platform : undefined,
+            yanked,
+        };
+    });
+}
+/**
+ * Generate JSON response for /api/v1/versions/{gem}.json
+ * @param gemName - Gem name
+ * @param versions - Version list
+ * @returns JSON response object
+ */
+export function generateVersionsJson(gemName, versions) {
+    return {
+        name: gemName,
+        versions: versions.map(v => ({
+            number: v.version,
+            platform: v.platform || 'ruby',
+            built_at: v.uploadTime,
+        })),
+    };
+}
+/**
+ * Generate JSON response for /api/v1/dependencies
+ * @param gems - Map of gem names to version dependencies
+ * @returns JSON response array
+ */
+export function generateDependenciesJson(gems) {
+    const result = [];
+    for (const [name, versions] of gems) {
+        for (const v of versions) {
+            result.push({
+                name,
+                number: v.version,
+                platform: v.platform || 'ruby',
+                dependencies: v.dependencies.map(d => ({
+                    name: d.name,
+                    requirements: d.requirement,
+                })),
+            });
+        }
+    }
+    return result;
+}
+/**
+ * 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 function updateCompactIndexVersions(existingContent, gemName, newVersion, infoChecksum) {
+    const lines = existingContent.split('\n');
+    const headerEndIndex = lines.findIndex(l => l === '---');
+    if (headerEndIndex === -1) {
+        throw new Error('Invalid Compact Index versions file');
+    }
+    const header = lines.slice(0, headerEndIndex + 1);
+    const entries = lines.slice(headerEndIndex + 1).filter(l => l.trim());
+    // Find existing entry for gem
+    const gemLineIndex = entries.findIndex(l => l.startsWith(`${gemName} `));
+    const versionStr = buildVersionList([newVersion]);
+    if (gemLineIndex >= 0) {
+        // Append to existing entry
+        const parts = entries[gemLineIndex].split(' ');
+        const existingVersions = parts[1];
+        const updatedVersions = `${existingVersions},${versionStr}`;
+        entries[gemLineIndex] = `${gemName} ${updatedVersions} ${infoChecksum}`;
+    }
+    else {
+        // Add new entry
+        entries.push(`${gemName} ${versionStr} ${infoChecksum}`);
+        entries.sort(); // Keep alphabetical
+    }
+    return [...header, ...entries].join('\n');
+}
+/**
+ * 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 function updateCompactIndexInfo(existingContent, newEntry) {
+    const lines = existingContent ? existingContent.split('\n').filter(l => l !== '---') : [];
+    // Build version string
+    const versionStr = newEntry.platform && newEntry.platform !== 'ruby'
+        ? `${newEntry.version}-${newEntry.platform}`
+        : newEntry.version;
+    // Build dependencies string
+    const depsStr = newEntry.dependencies.length > 0
+        ? newEntry.dependencies.map(formatDependency).join(',')
+        : '';
+    // Build requirements string
+    const reqParts = [`checksum:${newEntry.checksum}`];
+    for (const req of newEntry.requirements) {
+        reqParts.push(`${req.type}:${req.requirement}`);
+    }
+    const reqStr = reqParts.join(',');
+    // Combine
+    const depPart = depsStr ? ` ${depsStr}` : '';
+    const newLine = `${versionStr}${depPart}|${reqStr}`;
+    lines.push(newLine);
+    return `---\n${lines.join('\n')}`;
+}
+/**
+ * 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 async function extractGemSpec(gemData) {
+    try {
+        // .gem files are gzipped tar archives
+        // They contain metadata.gz which has Marshal-encoded spec
+        // This is a placeholder - full implementation would need:
+        // 1. Unzip outer gzip
+        // 2. Untar to find metadata.gz
+        // 3. Unzip metadata.gz
+        // 4. Parse Ruby Marshal format
+        // For now, return null and expect metadata to be provided
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.rubygems.js","sourceRoot":"","sources":["../../ts/rubygems/helpers.rubygems.ts"],"names":[],"mappings":"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"}

package/dist_ts/rubygems/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RubyGems Registry Module
+ * RubyGems/Bundler Compact Index implementation
+ */
+export * from './interfaces.rubygems.js';
+export * from './classes.rubygemsregistry.js';
+export * as rubygemsHelpers from './helpers.rubygems.js';

package/dist_ts/rubygems/index.js

@@ -0,0 +1,8 @@
+/**
+ * RubyGems Registry Module
+ * RubyGems/Bundler Compact Index implementation
+ */
+export * from './interfaces.rubygems.js';
+export * from './classes.rubygemsregistry.js';
+export * as rubygemsHelpers from './helpers.rubygems.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ydWJ5Z2Vtcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsT0FBTyxLQUFLLGVBQWUsTUFBTSx1QkFBdUIsQ0FBQyJ9

package/dist_ts/rubygems/interfaces.rubygems.d.ts

@@ -0,0 +1,236 @@
+/**
+ * RubyGems Registry Type Definitions
+ * Compliant with Compact Index API and RubyGems protocol
+ */
+/**
+ * Gem version entry in compact index
+ */
+export interface IRubyGemsVersion {
+    /** Version number */
+    version: string;
+    /** Platform (e.g., ruby, x86_64-linux) */
+    platform?: string;
+    /** Dependencies */
+    dependencies?: IRubyGemsDependency[];
+    /** Requirements */
+    requirements?: IRubyGemsRequirement[];
+    /** Whether this version is yanked */
+    yanked?: boolean;
+    /** SHA256 checksum of .gem file */
+    checksum?: string;
+}
+/**
+ * Gem dependency specification
+ */
+export interface IRubyGemsDependency {
+    /** Gem name */
+    name: string;
+    /** Version requirement (e.g., ">= 1.0", "~> 2.0") */
+    requirement: string;
+}
+/**
+ * Gem requirements (ruby version, rubygems version, etc.)
+ */
+export interface IRubyGemsRequirement {
+    /** Requirement type (ruby, rubygems) */
+    type: 'ruby' | 'rubygems';
+    /** Version requirement */
+    requirement: string;
+}
+/**
+ * Complete gem metadata
+ */
+export interface IRubyGemsMetadata {
+    /** Gem name */
+    name: string;
+    /** All versions */
+    versions: Record<string, IRubyGemsVersionMetadata>;
+    /** Last modified timestamp */
+    'last-modified'?: string;
+}
+/**
+ * Version-specific metadata
+ */
+export interface IRubyGemsVersionMetadata {
+    /** Version number */
+    version: string;
+    /** Platform */
+    platform?: string;
+    /** Authors */
+    authors?: string[];
+    /** Description */
+    description?: string;
+    /** Summary */
+    summary?: string;
+    /** Homepage */
+    homepage?: string;
+    /** License */
+    license?: string;
+    /** Dependencies */
+    dependencies?: IRubyGemsDependency[];
+    /** Requirements */
+    requirements?: IRubyGemsRequirement[];
+    /** SHA256 checksum */
+    checksum: string;
+    /** File size */
+    size: number;
+    /** Upload timestamp */
+    'upload-time': string;
+    /** Uploader */
+    'uploaded-by': string;
+    /** Yanked status */
+    yanked?: boolean;
+    /** Yank reason */
+    'yank-reason'?: string;
+}
+/**
+ * Compact index versions file entry
+ * Format: GEMNAME [-]VERSION_PLATFORM[,VERSION_PLATFORM,...] MD5
+ */
+export interface ICompactIndexVersionsEntry {
+    /** Gem name */
+    name: string;
+    /** Versions (with optional platform and yank flag) */
+    versions: Array<{
+        version: string;
+        platform?: string;
+        yanked: boolean;
+    }>;
+    /** MD5 checksum of info file */
+    infoChecksum: string;
+}
+/**
+ * Compact index info file entry
+ * Format: VERSION[-PLATFORM] [DEP[,DEP,...]]|REQ[,REQ,...]
+ */
+export interface ICompactIndexInfoEntry {
+    /** Version number */
+    version: string;
+    /** Platform (optional) */
+    platform?: string;
+    /** Dependencies */
+    dependencies: IRubyGemsDependency[];
+    /** Requirements */
+    requirements: IRubyGemsRequirement[];
+    /** SHA256 checksum */
+    checksum: string;
+}
+/**
+ * Gem upload request
+ */
+export interface IRubyGemsUploadRequest {
+    /** Gem file data */
+    gemData: Buffer;
+    /** Gem filename */
+    filename: string;
+}
+/**
+ * Gem upload response
+ */
+export interface IRubyGemsUploadResponse {
+    /** Success message */
+    message?: string;
+    /** Gem name */
+    name?: string;
+    /** Version */
+    version?: string;
+}
+/**
+ * Yank request
+ */
+export interface IRubyGemsYankRequest {
+    /** Gem name */
+    gem_name: string;
+    /** Version to yank */
+    version: string;
+    /** Platform (optional) */
+    platform?: string;
+}
+/**
+ * Yank response
+ */
+export interface IRubyGemsYankResponse {
+    /** Success indicator */
+    success: boolean;
+    /** Message */
+    message?: string;
+}
+/**
+ * Version info response (JSON)
+ */
+export interface IRubyGemsVersionInfo {
+    /** Gem name */
+    name: string;
+    /** Versions list */
+    versions: Array<{
+        /** Version number */
+        number: string;
+        /** Platform */
+        platform?: string;
+        /** Build date */
+        built_at?: string;
+        /** Download count */
+        downloads_count?: number;
+    }>;
+}
+/**
+ * Dependencies query response
+ */
+export interface IRubyGemsDependenciesResponse {
+    /** Dependencies for requested gems */
+    dependencies: Array<{
+        /** Gem name */
+        name: string;
+        /** Version */
+        number: string;
+        /** Platform */
+        platform?: string;
+        /** Dependencies */
+        dependencies: Array<{
+            name: string;
+            requirements: string;
+        }>;
+    }>;
+}
+/**
+ * Error response structure
+ */
+export interface IRubyGemsError {
+    /** Error message */
+    message: string;
+    /** HTTP status code */
+    status?: number;
+}
+/**
+ * Gem specification (extracted from .gem file)
+ */
+export interface IRubyGemsSpec {
+    /** Gem name */
+    name: string;
+    /** Version */
+    version: string;
+    /** Platform */
+    platform?: string;
+    /** Authors */
+    authors?: string[];
+    /** Email */
+    email?: string;
+    /** Homepage */
+    homepage?: string;
+    /** Summary */
+    summary?: string;
+    /** Description */
+    description?: string;
+    /** License */
+    license?: string;
+    /** Dependencies */
+    dependencies?: IRubyGemsDependency[];
+    /** Required Ruby version */
+    required_ruby_version?: string;
+    /** Required RubyGems version */
+    required_rubygems_version?: string;
+    /** Files */
+    files?: string[];
+    /** Requirements */
+    requirements?: string[];
+}

package/dist_ts/rubygems/interfaces.rubygems.js

@@ -0,0 +1,6 @@
+/**
+ * RubyGems Registry Type Definitions
+ * Compliant with Compact Index API and RubyGems protocol
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5ydWJ5Z2Vtcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3J1YnlnZW1zL2ludGVyZmFjZXMucnVieWdlbXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHIn0=

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartregistry",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "private": false,
-  "description": "a registry for npm modules and oci images",
+  "description": "A composable TypeScript library implementing OCI, NPM, Maven, Cargo, Composer, PyPI, and RubyGems registries for building unified container and package registries",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",