@push.rocks/smartregistry 1.1.1 → 1.4.0

package/dist_ts/composer/classes.composerregistry.js

@@ -0,0 +1,366 @@
+/**
+ * Composer Registry Implementation
+ * Compliant with Composer v2 repository API
+ */
+import { BaseRegistry } from '../core/classes.baseregistry.js';
+import { normalizeVersion, validateComposerJson, extractComposerJsonFromZip, calculateSha1, parseVendorPackage, generatePackagesJson, sortVersions, } from './helpers.composer.js';
+export class ComposerRegistry extends BaseRegistry {
+    storage;
+    authManager;
+    basePath = '/composer';
+    registryUrl;
+    constructor(storage, authManager, basePath = '/composer', registryUrl = 'http://localhost:5000/composer') {
+        super();
+        this.storage = storage;
+        this.authManager = authManager;
+        this.basePath = basePath;
+        this.registryUrl = registryUrl;
+    }
+    async init() {
+        // Composer registry initialization
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+    async handleRequest(context) {
+        const path = context.path.replace(this.basePath, '');
+        // Extract token from Authorization header
+        const authHeader = context.headers['authorization'] || context.headers['Authorization'];
+        let token = null;
+        if (authHeader) {
+            if (authHeader.startsWith('Bearer ')) {
+                const tokenString = authHeader.replace(/^Bearer\s+/i, '');
+                token = await this.authManager.validateToken(tokenString, 'composer');
+            }
+            else if (authHeader.startsWith('Basic ')) {
+                // Handle HTTP Basic Auth
+                const credentials = Buffer.from(authHeader.replace(/^Basic\s+/i, ''), 'base64').toString('utf-8');
+                const [username, password] = credentials.split(':');
+                const userId = await this.authManager.authenticate({ username, password });
+                if (userId) {
+                    // Create temporary token for this request
+                    token = {
+                        type: 'composer',
+                        userId,
+                        scopes: ['composer:*:*:read'],
+                        readonly: true,
+                    };
+                }
+            }
+        }
+        // Root packages.json
+        if (path === '/packages.json' || path === '' || path === '/') {
+            return this.handlePackagesJson();
+        }
+        // Package metadata: /p2/{vendor}/{package}.json or /p2/{vendor}/{package}~dev.json
+        const metadataMatch = path.match(/^\/p2\/([^\/]+\/[^\/]+?)(~dev)?\.json$/);
+        if (metadataMatch) {
+            const [, vendorPackage, devSuffix] = metadataMatch;
+            const includeDev = !!devSuffix;
+            return this.handlePackageMetadata(vendorPackage, includeDev, token);
+        }
+        // Package list: /packages/list.json?filter=vendor/*
+        if (path.startsWith('/packages/list.json')) {
+            const filter = context.query['filter'];
+            return this.handlePackageList(filter, token);
+        }
+        // Package ZIP download: /dists/{vendor}/{package}/{reference}.zip
+        const distMatch = path.match(/^\/dists\/([^\/]+\/[^\/]+)\/([^\/]+)\.zip$/);
+        if (distMatch) {
+            const [, vendorPackage, reference] = distMatch;
+            return this.handlePackageDownload(vendorPackage, reference, token);
+        }
+        // Package upload: PUT /packages/{vendor}/{package}
+        const uploadMatch = path.match(/^\/packages\/([^\/]+\/[^\/]+)$/);
+        if (uploadMatch && context.method === 'PUT') {
+            const vendorPackage = uploadMatch[1];
+            return this.handlePackageUpload(vendorPackage, context.body, token);
+        }
+        // Package delete: DELETE /packages/{vendor}/{package}
+        if (uploadMatch && context.method === 'DELETE') {
+            const vendorPackage = uploadMatch[1];
+            return this.handlePackageDelete(vendorPackage, token);
+        }
+        // Version delete: DELETE /packages/{vendor}/{package}/{version}
+        const versionDeleteMatch = path.match(/^\/packages\/([^\/]+\/[^\/]+)\/(.+)$/);
+        if (versionDeleteMatch && context.method === 'DELETE') {
+            const [, vendorPackage, version] = versionDeleteMatch;
+            return this.handleVersionDelete(vendorPackage, version, token);
+        }
+        return {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+            body: { status: 'error', message: 'Not found' },
+        };
+    }
+    async checkPermission(token, resource, action) {
+        if (!token)
+            return false;
+        return this.authManager.authorize(token, `composer:package:${resource}`, action);
+    }
+    // ========================================================================
+    // REQUEST HANDLERS
+    // ========================================================================
+    async handlePackagesJson() {
+        const availablePackages = await this.storage.listComposerPackages();
+        const packagesJson = generatePackagesJson(this.registryUrl, availablePackages);
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: packagesJson,
+        };
+    }
+    async handlePackageMetadata(vendorPackage, includeDev, token) {
+        // Check read permission
+        if (!await this.checkPermission(token, vendorPackage, 'read')) {
+            return {
+                status: 401,
+                headers: { 'WWW-Authenticate': 'Bearer realm="composer"' },
+                body: { status: 'error', message: 'Authentication required' },
+            };
+        }
+        const metadata = await this.storage.getComposerPackageMetadata(vendorPackage);
+        if (!metadata) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+                body: { status: 'error', message: 'Package not found' },
+            };
+        }
+        // Filter dev versions if needed
+        let packages = metadata.packages[vendorPackage] || [];
+        if (!includeDev) {
+            packages = packages.filter((pkg) => !pkg.version.includes('dev') && !pkg.version.includes('alpha') && !pkg.version.includes('beta'));
+        }
+        const response = {
+            minified: 'composer/2.0',
+            packages: {
+                [vendorPackage]: packages,
+            },
+        };
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json',
+                'Last-Modified': metadata.lastModified || new Date().toUTCString(),
+            },
+            body: response,
+        };
+    }
+    async handlePackageList(filter, token) {
+        let packages = await this.storage.listComposerPackages();
+        // Apply filter if provided
+        if (filter) {
+            const regex = new RegExp('^' + filter.replace(/\*/g, '.*') + '$');
+            packages = packages.filter(pkg => regex.test(pkg));
+        }
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: { packageNames: packages },
+        };
+    }
+    async handlePackageDownload(vendorPackage, reference, token) {
+        // Check read permission
+        if (!await this.checkPermission(token, vendorPackage, 'read')) {
+            return {
+                status: 401,
+                headers: { 'WWW-Authenticate': 'Bearer realm="composer"' },
+                body: { status: 'error', message: 'Authentication required' },
+            };
+        }
+        const zipData = await this.storage.getComposerPackageZip(vendorPackage, reference);
+        if (!zipData) {
+            return {
+                status: 404,
+                headers: {},
+                body: { status: 'error', message: 'Package file not found' },
+            };
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/zip',
+                'Content-Length': zipData.length.toString(),
+                'Content-Disposition': `attachment; filename="${reference}.zip"`,
+            },
+            body: zipData,
+        };
+    }
+    async handlePackageUpload(vendorPackage, body, token) {
+        // Check write permission
+        if (!await this.checkPermission(token, vendorPackage, 'write')) {
+            return {
+                status: 401,
+                headers: {},
+                body: { status: 'error', message: 'Write permission required' },
+            };
+        }
+        if (!body || !Buffer.isBuffer(body)) {
+            return {
+                status: 400,
+                headers: {},
+                body: { status: 'error', message: 'ZIP file required' },
+            };
+        }
+        // Extract and validate composer.json from ZIP
+        const composerJson = await extractComposerJsonFromZip(body);
+        if (!composerJson || !validateComposerJson(composerJson)) {
+            return {
+                status: 400,
+                headers: {},
+                body: { status: 'error', message: 'Invalid composer.json in ZIP' },
+            };
+        }
+        // Verify package name matches
+        if (composerJson.name !== vendorPackage) {
+            return {
+                status: 400,
+                headers: {},
+                body: { status: 'error', message: 'Package name mismatch' },
+            };
+        }
+        const version = composerJson.version;
+        if (!version) {
+            return {
+                status: 400,
+                headers: {},
+                body: { status: 'error', message: 'Version required in composer.json' },
+            };
+        }
+        // Calculate SHA-1 hash
+        const shasum = await calculateSha1(body);
+        // Generate reference (use version or commit hash)
+        const reference = composerJson.source?.reference || version.replace(/[^a-zA-Z0-9.-]/g, '-');
+        // Store ZIP file
+        await this.storage.putComposerPackageZip(vendorPackage, reference, body);
+        // Get or create metadata
+        let metadata = await this.storage.getComposerPackageMetadata(vendorPackage);
+        if (!metadata) {
+            metadata = {
+                packages: {
+                    [vendorPackage]: [],
+                },
+                lastModified: new Date().toUTCString(),
+            };
+        }
+        // Build package entry
+        const packageEntry = {
+            ...composerJson,
+            version_normalized: normalizeVersion(version),
+            dist: {
+                type: 'zip',
+                url: `${this.registryUrl}/dists/${vendorPackage}/${reference}.zip`,
+                reference,
+                shasum,
+            },
+            time: new Date().toISOString(),
+        };
+        // Add to metadata (check if version already exists)
+        const packages = metadata.packages[vendorPackage] || [];
+        const existingIndex = packages.findIndex((p) => p.version === version);
+        if (existingIndex >= 0) {
+            return {
+                status: 409,
+                headers: {},
+                body: { status: 'error', message: 'Version already exists' },
+            };
+        }
+        packages.push(packageEntry);
+        // Sort by version
+        const sortedVersions = sortVersions(packages.map((p) => p.version));
+        packages.sort((a, b) => {
+            return sortedVersions.indexOf(a.version) - sortedVersions.indexOf(b.version);
+        });
+        metadata.packages[vendorPackage] = packages;
+        metadata.lastModified = new Date().toUTCString();
+        // Store updated metadata
+        await this.storage.putComposerPackageMetadata(vendorPackage, metadata);
+        return {
+            status: 201,
+            headers: {},
+            body: {
+                status: 'success',
+                message: 'Package uploaded successfully',
+                package: vendorPackage,
+                version,
+            },
+        };
+    }
+    async handlePackageDelete(vendorPackage, token) {
+        // Check delete permission
+        if (!await this.checkPermission(token, vendorPackage, 'delete')) {
+            return {
+                status: 401,
+                headers: {},
+                body: { status: 'error', message: 'Delete permission required' },
+            };
+        }
+        const metadata = await this.storage.getComposerPackageMetadata(vendorPackage);
+        if (!metadata) {
+            return {
+                status: 404,
+                headers: {},
+                body: { status: 'error', message: 'Package not found' },
+            };
+        }
+        // Delete all ZIP files
+        const packages = metadata.packages[vendorPackage] || [];
+        for (const pkg of packages) {
+            if (pkg.dist?.reference) {
+                await this.storage.deleteComposerPackageZip(vendorPackage, pkg.dist.reference);
+            }
+        }
+        // Delete metadata
+        await this.storage.deleteComposerPackageMetadata(vendorPackage);
+        return {
+            status: 204,
+            headers: {},
+            body: null,
+        };
+    }
+    async handleVersionDelete(vendorPackage, version, token) {
+        // Check delete permission
+        if (!await this.checkPermission(token, vendorPackage, 'delete')) {
+            return {
+                status: 401,
+                headers: {},
+                body: { status: 'error', message: 'Delete permission required' },
+            };
+        }
+        const metadata = await this.storage.getComposerPackageMetadata(vendorPackage);
+        if (!metadata) {
+            return {
+                status: 404,
+                headers: {},
+                body: { status: 'error', message: 'Package not found' },
+            };
+        }
+        const packages = metadata.packages[vendorPackage] || [];
+        const versionIndex = packages.findIndex((p) => p.version === version);
+        if (versionIndex === -1) {
+            return {
+                status: 404,
+                headers: {},
+                body: { status: 'error', message: 'Version not found' },
+            };
+        }
+        // Delete ZIP file
+        const pkg = packages[versionIndex];
+        if (pkg.dist?.reference) {
+            await this.storage.deleteComposerPackageZip(vendorPackage, pkg.dist.reference);
+        }
+        // Remove from metadata
+        packages.splice(versionIndex, 1);
+        metadata.packages[vendorPackage] = packages;
+        metadata.lastModified = new Date().toUTCString();
+        // Save updated metadata
+        await this.storage.putComposerPackageMetadata(vendorPackage, metadata);
+        return {
+            status: 204,
+            headers: {},
+            body: null,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.composerregistry.js","sourceRoot":"","sources":["../../ts/composer/classes.composerregistry.ts"],"names":[],"mappings":"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"}

package/dist_ts/composer/helpers.composer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Composer Registry Helper Functions
+ */
+/**
+ * Normalize version string to Composer format
+ * Example: "1.0.0" -> "1.0.0.0", "v2.3.1" -> "2.3.1.0"
+ */
+export declare function normalizeVersion(version: string): string;
+/**
+ * Validate composer.json structure
+ */
+export declare function validateComposerJson(composerJson: any): boolean;
+/**
+ * Extract composer.json from ZIP buffer
+ */
+export declare function extractComposerJsonFromZip(zipBuffer: Buffer): Promise<any | null>;
+/**
+ * Calculate SHA-1 hash for ZIP file
+ */
+export declare function calculateSha1(data: Buffer): Promise<string>;
+/**
+ * Parse vendor/package format
+ */
+export declare function parseVendorPackage(name: string): {
+    vendor: string;
+    package: string;
+} | null;
+/**
+ * Generate packages.json root repository file
+ */
+export declare function generatePackagesJson(registryUrl: string, availablePackages: string[]): any;
+/**
+ * Sort versions in semantic version order
+ */
+export declare function sortVersions(versions: string[]): string[];

package/dist_ts/composer/helpers.composer.js

@@ -0,0 +1,120 @@
+/**
+ * Composer Registry Helper Functions
+ */
+/**
+ * Normalize version string to Composer format
+ * Example: "1.0.0" -> "1.0.0.0", "v2.3.1" -> "2.3.1.0"
+ */
+export function normalizeVersion(version) {
+    // Remove 'v' prefix if present
+    let normalized = version.replace(/^v/i, '');
+    // Handle special versions (dev, alpha, beta, rc)
+    if (normalized.includes('dev') || normalized.includes('alpha') || normalized.includes('beta') || normalized.includes('RC')) {
+        // For dev versions, just return as-is with .0 appended if needed
+        const parts = normalized.split(/[-+]/)[0].split('.');
+        while (parts.length < 4) {
+            parts.push('0');
+        }
+        return parts.slice(0, 4).join('.');
+    }
+    // Split by dots
+    const parts = normalized.split('.');
+    // Ensure 4 parts (major.minor.patch.build)
+    while (parts.length < 4) {
+        parts.push('0');
+    }
+    return parts.slice(0, 4).join('.');
+}
+/**
+ * Validate composer.json structure
+ */
+export function validateComposerJson(composerJson) {
+    return !!(composerJson &&
+        typeof composerJson.name === 'string' &&
+        composerJson.name.includes('/') &&
+        (composerJson.version || composerJson.require));
+}
+/**
+ * Extract composer.json from ZIP buffer
+ */
+export async function extractComposerJsonFromZip(zipBuffer) {
+    try {
+        const AdmZip = (await import('adm-zip')).default;
+        const zip = new AdmZip(zipBuffer);
+        const entries = zip.getEntries();
+        // Look for composer.json in root or first-level directory
+        for (const entry of entries) {
+            if (entry.entryName.endsWith('composer.json')) {
+                const parts = entry.entryName.split('/');
+                if (parts.length <= 2) { // Root or first-level dir
+                    const content = entry.getData().toString('utf-8');
+                    return JSON.parse(content);
+                }
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Calculate SHA-1 hash for ZIP file
+ */
+export async function calculateSha1(data) {
+    const crypto = await import('crypto');
+    return crypto.createHash('sha1').update(data).digest('hex');
+}
+/**
+ * Parse vendor/package format
+ */
+export function parseVendorPackage(name) {
+    const parts = name.split('/');
+    if (parts.length !== 2) {
+        return null;
+    }
+    return { vendor: parts[0], package: parts[1] };
+}
+/**
+ * Generate packages.json root repository file
+ */
+export function generatePackagesJson(registryUrl, availablePackages) {
+    return {
+        'metadata-url': `${registryUrl}/p2/%package%.json`,
+        'available-packages': availablePackages,
+    };
+}
+/**
+ * Sort versions in semantic version order
+ */
+export function sortVersions(versions) {
+    return versions.sort((a, b) => {
+        const aParts = a.replace(/^v/i, '').split(/[.-]/).map(part => {
+            const num = parseInt(part, 10);
+            return isNaN(num) ? part : num;
+        });
+        const bParts = b.replace(/^v/i, '').split(/[.-]/).map(part => {
+            const num = parseInt(part, 10);
+            return isNaN(num) ? part : num;
+        });
+        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+            const aPart = aParts[i] ?? 0;
+            const bPart = bParts[i] ?? 0;
+            // Compare numbers numerically, strings lexicographically
+            if (typeof aPart === 'number' && typeof bPart === 'number') {
+                if (aPart !== bPart) {
+                    return aPart - bPart;
+                }
+            }
+            else {
+                const aStr = String(aPart);
+                const bStr = String(bPart);
+                if (aStr !== bStr) {
+                    return aStr.localeCompare(bStr);
+                }
+            }
+        }
+        return 0;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/composer/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Composer Registry Module
+ * Export all public interfaces, classes, and helpers
+ */
+export { ComposerRegistry } from './classes.composerregistry.js';
+export * from './interfaces.composer.js';
+export * from './helpers.composer.js';

package/dist_ts/composer/index.js

@@ -0,0 +1,8 @@
+/**
+ * Composer Registry Module
+ * Export all public interfaces, classes, and helpers
+ */
+export { ComposerRegistry } from './classes.composerregistry.js';
+export * from './interfaces.composer.js';
+export * from './helpers.composer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb21wb3Nlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNqRSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUMifQ==

package/dist_ts/composer/interfaces.composer.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Composer Registry Type Definitions
+ * Compliant with Composer v2 repository API
+ */
+/**
+ * Composer package metadata
+ */
+export interface IComposerPackage {
+    name: string;
+    version: string;
+    version_normalized: string;
+    type?: string;
+    description?: string;
+    keywords?: string[];
+    homepage?: string;
+    license?: string[];
+    authors?: IComposerAuthor[];
+    require?: Record<string, string>;
+    'require-dev'?: Record<string, string>;
+    suggest?: Record<string, string>;
+    provide?: Record<string, string>;
+    conflict?: Record<string, string>;
+    replace?: Record<string, string>;
+    autoload?: IComposerAutoload;
+    'autoload-dev'?: IComposerAutoload;
+    dist?: IComposerDist;
+    source?: IComposerSource;
+    time?: string;
+    support?: Record<string, string>;
+    funding?: IComposerFunding[];
+    extra?: Record<string, any>;
+}
+/**
+ * Author information
+ */
+export interface IComposerAuthor {
+    name: string;
+    email?: string;
+    homepage?: string;
+    role?: string;
+}
+/**
+ * PSR-4/PSR-0 autoloading configuration
+ */
+export interface IComposerAutoload {
+    'psr-4'?: Record<string, string | string[]>;
+    'psr-0'?: Record<string, string | string[]>;
+    classmap?: string[];
+    files?: string[];
+    'exclude-from-classmap'?: string[];
+}
+/**
+ * Distribution information (ZIP download)
+ */
+export interface IComposerDist {
+    type: 'zip' | 'tar' | 'phar';
+    url: string;
+    reference?: string;
+    shasum?: string;
+}
+/**
+ * Source repository information
+ */
+export interface IComposerSource {
+    type: 'git' | 'svn' | 'hg';
+    url: string;
+    reference: string;
+}
+/**
+ * Funding information
+ */
+export interface IComposerFunding {
+    type: string;
+    url: string;
+}
+/**
+ * Repository metadata (packages.json)
+ */
+export interface IComposerRepository {
+    packages?: Record<string, Record<string, IComposerPackage>>;
+    'metadata-url'?: string;
+    'available-packages'?: string[];
+    'available-package-patterns'?: string[];
+    'providers-url'?: string;
+    'notify-batch'?: string;
+    minified?: string;
+}
+/**
+ * Package metadata response (/p2/vendor/package.json)
+ */
+export interface IComposerPackageMetadata {
+    packages: Record<string, IComposerPackage[]>;
+    minified?: string;
+    lastModified?: string;
+}
+/**
+ * Error structure
+ */
+export interface IComposerError {
+    status: string;
+    message: string;
+}