@push.rocks/smartregistry 1.4.0 → 1.5.0

package/dist_ts/pypi/classes.pypiregistry.js

@@ -0,0 +1,470 @@
+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.pypi.js';
+/**
+ * PyPI registry implementation
+ * Implements PEP 503 (Simple API), PEP 691 (JSON API), and legacy upload API
+ */
+export class PypiRegistry extends BaseRegistry {
+    storage;
+    authManager;
+    basePath = '/pypi';
+    registryUrl;
+    logger;
+    constructor(storage, authManager, basePath = '/pypi', registryUrl = 'http://localhost:5000') {
+        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: 'pypi-registry',
+                environment: process.env.NODE_ENV || 'development',
+                runtime: 'node',
+                zone: 'pypi'
+            }
+        });
+        this.logger.enableConsole();
+    }
+    async init() {
+        // Initialize root Simple API index if not exists
+        const existingIndex = await this.storage.getPypiSimpleRootIndex();
+        if (!existingIndex) {
+            const html = helpers.generateSimpleRootHtml([]);
+            await this.storage.putPypiSimpleRootIndex(html);
+            this.logger.log('info', 'Initialized PyPI root index');
+        }
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+    async handleRequest(context) {
+        let path = context.path.replace(this.basePath, '');
+        // Also handle /simple path prefix
+        if (path.startsWith('/simple')) {
+            path = path.replace('/simple', '');
+            return this.handleSimpleRequest(path, context);
+        }
+        // Extract token (Basic Auth or Bearer)
+        const token = await this.extractToken(context);
+        this.logger.log('debug', `handleRequest: ${context.method} ${path}`, {
+            method: context.method,
+            path,
+            hasAuth: !!token
+        });
+        // Root upload endpoint (POST /)
+        if ((path === '/' || path === '') && context.method === 'POST') {
+            return this.handleUpload(context, token);
+        }
+        // Package metadata JSON API: GET /pypi/{package}/json
+        const jsonMatch = path.match(/^\/pypi\/([^\/]+)\/json$/);
+        if (jsonMatch && context.method === 'GET') {
+            return this.handlePackageJson(jsonMatch[1]);
+        }
+        // Version-specific JSON API: GET /pypi/{package}/{version}/json
+        const versionJsonMatch = path.match(/^\/pypi\/([^\/]+)\/([^\/]+)\/json$/);
+        if (versionJsonMatch && context.method === 'GET') {
+            return this.handleVersionJson(versionJsonMatch[1], versionJsonMatch[2]);
+        }
+        // Package file download: GET /packages/{package}/{filename}
+        const downloadMatch = path.match(/^\/packages\/([^\/]+)\/(.+)$/);
+        if (downloadMatch && context.method === 'GET') {
+            return this.handleDownload(downloadMatch[1], downloadMatch[2]);
+        }
+        // Delete package: DELETE /packages/{package}
+        if (path.match(/^\/packages\/([^\/]+)$/) && context.method === 'DELETE') {
+            const packageName = path.match(/^\/packages\/([^\/]+)$/)?.[1];
+            return this.handleDeletePackage(packageName, token);
+        }
+        // Delete version: DELETE /packages/{package}/{version}
+        const deleteVersionMatch = path.match(/^\/packages\/([^\/]+)\/([^\/]+)$/);
+        if (deleteVersionMatch && context.method === 'DELETE') {
+            return this.handleDeleteVersion(deleteVersionMatch[1], deleteVersionMatch[2], 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, `pypi:package:${resource}`, action);
+    }
+    /**
+     * Handle Simple API requests (PEP 503 HTML or PEP 691 JSON)
+     */
+    async handleSimpleRequest(path, context) {
+        // Ensure path ends with / (PEP 503 requirement)
+        if (!path.endsWith('/') && !path.includes('.')) {
+            return {
+                status: 301,
+                headers: { 'Location': `${this.basePath}/simple${path}/` },
+                body: Buffer.from(''),
+            };
+        }
+        // Root index: /simple/
+        if (path === '/' || path === '') {
+            return this.handleSimpleRoot(context);
+        }
+        // Package index: /simple/{package}/
+        const packageMatch = path.match(/^\/([^\/]+)\/$/);
+        if (packageMatch) {
+            return this.handleSimplePackage(packageMatch[1], context);
+        }
+        return {
+            status: 404,
+            headers: { 'Content-Type': 'text/html; charset=utf-8' },
+            body: Buffer.from('<html><body><h1>404 Not Found</h1></body></html>'),
+        };
+    }
+    /**
+     * Handle Simple API root index
+     * Returns HTML (PEP 503) or JSON (PEP 691) based on Accept header
+     */
+    async handleSimpleRoot(context) {
+        const acceptHeader = context.headers['accept'] || context.headers['Accept'] || '';
+        const preferJson = acceptHeader.includes('application/vnd.pypi.simple') &&
+            acceptHeader.includes('json');
+        const packages = await this.storage.listPypiPackages();
+        if (preferJson) {
+            // PEP 691: JSON response
+            const response = helpers.generateJsonRootResponse(packages);
+            return {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/vnd.pypi.simple.v1+json',
+                    'Cache-Control': 'public, max-age=600'
+                },
+                body: Buffer.from(JSON.stringify(response)),
+            };
+        }
+        else {
+            // PEP 503: HTML response
+            const html = helpers.generateSimpleRootHtml(packages);
+            // Update stored index
+            await this.storage.putPypiSimpleRootIndex(html);
+            return {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html; charset=utf-8',
+                    'Cache-Control': 'public, max-age=600'
+                },
+                body: Buffer.from(html),
+            };
+        }
+    }
+    /**
+     * Handle Simple API package index
+     * Returns HTML (PEP 503) or JSON (PEP 691) based on Accept header
+     */
+    async handleSimplePackage(packageName, context) {
+        const normalized = helpers.normalizePypiPackageName(packageName);
+        // Get package metadata
+        const metadata = await this.storage.getPypiPackageMetadata(normalized);
+        if (!metadata) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'text/html; charset=utf-8' },
+                body: Buffer.from('<html><body><h1>404 Not Found</h1></body></html>'),
+            };
+        }
+        // Build file list from all versions
+        const files = [];
+        for (const [version, versionMeta] of Object.entries(metadata.versions || {})) {
+            for (const file of versionMeta.files || []) {
+                files.push({
+                    filename: file.filename,
+                    url: `${this.registryUrl}/pypi/packages/${normalized}/${file.filename}`,
+                    hashes: file.hashes,
+                    'requires-python': file['requires-python'],
+                    yanked: file.yanked || versionMeta.yanked,
+                    size: file.size,
+                    'upload-time': file['upload-time'],
+                });
+            }
+        }
+        const acceptHeader = context.headers['accept'] || context.headers['Accept'] || '';
+        const preferJson = acceptHeader.includes('application/vnd.pypi.simple') &&
+            acceptHeader.includes('json');
+        if (preferJson) {
+            // PEP 691: JSON response
+            const response = helpers.generateJsonPackageResponse(normalized, files);
+            return {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/vnd.pypi.simple.v1+json',
+                    'Cache-Control': 'public, max-age=300'
+                },
+                body: Buffer.from(JSON.stringify(response)),
+            };
+        }
+        else {
+            // PEP 503: HTML response
+            const html = helpers.generateSimplePackageHtml(normalized, files, this.registryUrl);
+            // Update stored index
+            await this.storage.putPypiSimpleIndex(normalized, html);
+            return {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html; charset=utf-8',
+                    'Cache-Control': 'public, max-age=300'
+                },
+                body: Buffer.from(html),
+            };
+        }
+    }
+    /**
+     * Extract authentication token from request
+     */
+    async extractToken(context) {
+        const authHeader = context.headers['authorization'] || context.headers['Authorization'];
+        if (!authHeader)
+            return null;
+        // Handle Basic Auth (username:password or __token__:token)
+        if (authHeader.startsWith('Basic ')) {
+            const base64 = authHeader.substring(6);
+            const decoded = Buffer.from(base64, 'base64').toString('utf-8');
+            const [username, password] = decoded.split(':');
+            // PyPI token authentication: username = __token__
+            if (username === '__token__') {
+                return this.authManager.validateToken(password, 'pypi');
+            }
+            // Username/password authentication (would need user lookup)
+            // For now, not implemented
+            return null;
+        }
+        // Handle Bearer token
+        if (authHeader.startsWith('Bearer ')) {
+            const token = authHeader.substring(7);
+            return this.authManager.validateToken(token, 'pypi');
+        }
+        return null;
+    }
+    /**
+     * Handle package upload (multipart/form-data)
+     * POST / with :action=file_upload
+     */
+    async handleUpload(context, token) {
+        if (!token) {
+            return {
+                status: 401,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'WWW-Authenticate': 'Basic realm="PyPI"'
+                },
+                body: Buffer.from(JSON.stringify({ message: 'Authentication required' })),
+            };
+        }
+        try {
+            // Parse multipart form data (context.body should be parsed by server)
+            const formData = context.body; // Assuming parsed multipart data
+            if (!formData || formData[':action'] !== 'file_upload') {
+                return this.errorResponse(400, 'Invalid upload request');
+            }
+            // Extract required fields
+            const packageName = formData.name;
+            const version = formData.version;
+            const filename = formData.content?.filename;
+            const fileData = formData.content?.data;
+            const filetype = formData.filetype; // 'bdist_wheel' or 'sdist'
+            const pyversion = formData.pyversion;
+            if (!packageName || !version || !filename || !fileData) {
+                return this.errorResponse(400, 'Missing required fields');
+            }
+            // Validate package name
+            if (!helpers.isValidPackageName(packageName)) {
+                return this.errorResponse(400, 'Invalid package name');
+            }
+            const normalized = helpers.normalizePypiPackageName(packageName);
+            // Check permission
+            if (!(await this.checkPermission(token, normalized, 'write'))) {
+                return this.errorResponse(403, 'Insufficient permissions');
+            }
+            // Calculate hashes
+            const hashes = {};
+            if (formData.sha256_digest) {
+                hashes.sha256 = formData.sha256_digest;
+            }
+            else {
+                hashes.sha256 = await helpers.calculateHash(fileData, 'sha256');
+            }
+            if (formData.md5_digest) {
+                // MD5 digest in PyPI is urlsafe base64, convert to hex
+                hashes.md5 = await helpers.calculateHash(fileData, 'md5');
+            }
+            if (formData.blake2_256_digest) {
+                hashes.blake2b = formData.blake2_256_digest;
+            }
+            // Store file
+            await this.storage.putPypiPackageFile(normalized, filename, fileData);
+            // Update metadata
+            let metadata = await this.storage.getPypiPackageMetadata(normalized);
+            if (!metadata) {
+                metadata = {
+                    name: normalized,
+                    versions: {},
+                };
+            }
+            if (!metadata.versions[version]) {
+                metadata.versions[version] = {
+                    version,
+                    files: [],
+                };
+            }
+            // Add file to version
+            metadata.versions[version].files.push({
+                filename,
+                path: `pypi/packages/${normalized}/${filename}`,
+                filetype,
+                python_version: pyversion,
+                hashes,
+                size: fileData.length,
+                'requires-python': formData.requires_python,
+                'upload-time': new Date().toISOString(),
+                'uploaded-by': token.userId,
+            });
+            // Store core metadata if provided
+            if (formData.summary || formData.description) {
+                metadata.versions[version].metadata = helpers.extractCoreMetadata(formData);
+            }
+            metadata['last-modified'] = new Date().toISOString();
+            await this.storage.putPypiPackageMetadata(normalized, metadata);
+            this.logger.log('info', `Package uploaded: ${normalized} ${version}`, {
+                filename,
+                size: fileData.length
+            });
+            return {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+                body: Buffer.from(JSON.stringify({
+                    message: 'Package uploaded successfully',
+                    url: `${this.registryUrl}/pypi/packages/${normalized}/${filename}`
+                })),
+            };
+        }
+        catch (error) {
+            this.logger.log('error', 'Upload failed', { error: error.message });
+            return this.errorResponse(500, 'Upload failed: ' + error.message);
+        }
+    }
+    /**
+     * Handle package download
+     */
+    async handleDownload(packageName, filename) {
+        const normalized = helpers.normalizePypiPackageName(packageName);
+        const fileData = await this.storage.getPypiPackageFile(normalized, filename);
+        if (!fileData) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+                body: Buffer.from(JSON.stringify({ message: 'File not found' })),
+            };
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Disposition': `attachment; filename="${filename}"`,
+                'Content-Length': fileData.length.toString()
+            },
+            body: fileData,
+        };
+    }
+    /**
+     * Handle package JSON API (all versions)
+     */
+    async handlePackageJson(packageName) {
+        const normalized = helpers.normalizePypiPackageName(packageName);
+        const metadata = await this.storage.getPypiPackageMetadata(normalized);
+        if (!metadata) {
+            return this.errorResponse(404, 'Package not found');
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'public, max-age=300'
+            },
+            body: Buffer.from(JSON.stringify(metadata)),
+        };
+    }
+    /**
+     * Handle version-specific JSON API
+     */
+    async handleVersionJson(packageName, version) {
+        const normalized = helpers.normalizePypiPackageName(packageName);
+        const metadata = await this.storage.getPypiPackageMetadata(normalized);
+        if (!metadata || !metadata.versions[version]) {
+            return this.errorResponse(404, 'Version not found');
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'public, max-age=300'
+            },
+            body: Buffer.from(JSON.stringify(metadata.versions[version])),
+        };
+    }
+    /**
+     * Handle package deletion
+     */
+    async handleDeletePackage(packageName, token) {
+        if (!token) {
+            return this.errorResponse(401, 'Authentication required');
+        }
+        const normalized = helpers.normalizePypiPackageName(packageName);
+        if (!(await this.checkPermission(token, normalized, 'delete'))) {
+            return this.errorResponse(403, 'Insufficient permissions');
+        }
+        await this.storage.deletePypiPackage(normalized);
+        this.logger.log('info', `Package deleted: ${normalized}`);
+        return {
+            status: 204,
+            headers: {},
+            body: Buffer.from(''),
+        };
+    }
+    /**
+     * Handle version deletion
+     */
+    async handleDeleteVersion(packageName, version, token) {
+        if (!token) {
+            return this.errorResponse(401, 'Authentication required');
+        }
+        const normalized = helpers.normalizePypiPackageName(packageName);
+        if (!(await this.checkPermission(token, normalized, 'delete'))) {
+            return this.errorResponse(403, 'Insufficient permissions');
+        }
+        await this.storage.deletePypiPackageVersion(normalized, version);
+        this.logger.log('info', `Version deleted: ${normalized} ${version}`);
+        return {
+            status: 204,
+            headers: {},
+            body: Buffer.from(''),
+        };
+    }
+    /**
+     * 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.pypiregistry.js","sourceRoot":"","sources":["../../ts/pypi/classes.pypiregistry.ts"],"names":[],"mappings":"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"}

package/dist_ts/pypi/helpers.pypi.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Helper functions for PyPI registry
+ * Package name normalization, HTML generation, etc.
+ */
+import type { IPypiFile } from './interfaces.pypi.js';
+/**
+ * Normalize package name according to PEP 503
+ * Lowercase and replace runs of [._-] with a single dash
+ * @param name - Package name
+ * @returns Normalized name
+ */
+export declare function normalizePypiPackageName(name: string): string;
+/**
+ * Escape HTML special characters to prevent XSS
+ * @param str - String to escape
+ * @returns Escaped string
+ */
+export declare function escapeHtml(str: string): string;
+/**
+ * Generate PEP 503 compliant HTML for root index (all packages)
+ * @param packages - List of package names
+ * @returns HTML string
+ */
+export declare function generateSimpleRootHtml(packages: string[]): string;
+/**
+ * Generate PEP 503 compliant HTML for package index (file list)
+ * @param packageName - Package name (normalized)
+ * @param files - List of files
+ * @param baseUrl - Base URL for downloads
+ * @returns HTML string
+ */
+export declare function generateSimplePackageHtml(packageName: string, files: IPypiFile[], baseUrl: string): string;
+/**
+ * Parse filename to extract package info
+ * Supports wheel and sdist formats
+ * @param filename - Package filename
+ * @returns Parsed info or null
+ */
+export declare function parsePackageFilename(filename: string): {
+    name: string;
+    version: string;
+    filetype: 'bdist_wheel' | 'sdist';
+    pythonVersion?: string;
+} | null;
+/**
+ * Calculate hash digest for a buffer
+ * @param data - Data to hash
+ * @param algorithm - Hash algorithm (sha256, md5, blake2b)
+ * @returns Hex-encoded hash
+ */
+export declare function calculateHash(data: Buffer, algorithm: 'sha256' | 'md5' | 'blake2b'): Promise<string>;
+/**
+ * Validate package name
+ * Must contain only ASCII letters, numbers, ., -, and _
+ * @param name - Package name
+ * @returns true if valid
+ */
+export declare function isValidPackageName(name: string): boolean;
+/**
+ * Validate version string (basic check)
+ * @param version - Version string
+ * @returns true if valid
+ */
+export declare function isValidVersion(version: string): boolean;
+/**
+ * Extract metadata from package metadata
+ * Filters and normalizes metadata fields
+ * @param metadata - Raw metadata object
+ * @returns Filtered metadata
+ */
+export declare function extractCoreMetadata(metadata: Record<string, any>): Record<string, any>;
+/**
+ * Generate JSON API response for package list (PEP 691)
+ * @param packages - List of package names
+ * @returns JSON object
+ */
+export declare function generateJsonRootResponse(packages: string[]): any;
+/**
+ * Generate JSON API response for package files (PEP 691)
+ * @param packageName - Package name (normalized)
+ * @param files - List of files
+ * @returns JSON object
+ */
+export declare function generateJsonPackageResponse(packageName: string, files: IPypiFile[]): any;