@push.rocks/smartregistry 1.1.1

package/ts/core/classes.registrystorage.ts

@@ -0,0 +1,270 @@
+import * as plugins from '../plugins.js';
+import type { IStorageConfig, IStorageBackend } from './interfaces.core.js';
+
+/**
+ * Storage abstraction layer for registry
+ * Provides a unified interface over SmartBucket
+ */
+export class RegistryStorage implements IStorageBackend {
+  private smartBucket: plugins.smartbucket.SmartBucket;
+  private bucket: plugins.smartbucket.Bucket;
+  private bucketName: string;
+
+  constructor(private config: IStorageConfig) {
+    this.bucketName = config.bucketName;
+  }
+
+  /**
+   * 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',
+    });
+
+    // Ensure bucket exists
+    await this.smartBucket.createBucket(this.bucketName).catch(() => {
+      // Bucket may already exist
+    });
+
+    this.bucket = await this.smartBucket.getBucketByName(this.bucketName);
+  }
+
+  /**
+   * Get an object from storage
+   */
+  public async getObject(key: string): Promise<Buffer | null> {
+    try {
+      return await this.bucket.fastGet({ path: key });
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Store an object
+   */
+  public async putObject(
+    key: string,
+    data: Buffer,
+    metadata?: Record<string, string>
+  ): Promise<void> {
+    // Note: SmartBucket doesn't support metadata yet
+    await this.bucket.fastPut({
+      path: key,
+      contents: data,
+      overwrite: true, // Always overwrite existing objects
+    });
+  }
+
+  /**
+   * Delete an object
+   */
+  public async deleteObject(key: string): Promise<void> {
+    await this.bucket.fastRemove({ path: key });
+  }
+
+  /**
+   * List objects with a prefix (recursively)
+   */
+  public async listObjects(prefix: string): Promise<string[]> {
+    const paths: string[] = [];
+    for await (const path of this.bucket.listAllObjects(prefix)) {
+      paths.push(path);
+    }
+    return paths;
+  }
+
+  /**
+   * Check if an object exists
+   */
+  public async objectExists(key: string): Promise<boolean> {
+    return await this.bucket.fastExists({ path: key });
+  }
+
+  /**
+   * Get object metadata
+   * Note: SmartBucket may not support metadata retrieval, returning empty object
+   */
+  public async getMetadata(key: string): Promise<Record<string, string> | null> {
+    // SmartBucket doesn't expose metadata retrieval directly
+    // This is a limitation we'll document
+    const exists = await this.objectExists(key);
+    return exists ? {} : null;
+  }
+
+  // ========================================================================
+  // OCI-SPECIFIC HELPERS
+  // ========================================================================
+
+  /**
+   * Get OCI blob by digest
+   */
+  public async getOciBlob(digest: string): Promise<Buffer | null> {
+    const path = this.getOciBlobPath(digest);
+    return this.getObject(path);
+  }
+
+  /**
+   * Store OCI blob
+   */
+  public async putOciBlob(digest: string, data: Buffer): Promise<void> {
+    const path = this.getOciBlobPath(digest);
+    return this.putObject(path, data);
+  }
+
+  /**
+   * Check if OCI blob exists
+   */
+  public async ociBlobExists(digest: string): Promise<boolean> {
+    const path = this.getOciBlobPath(digest);
+    return this.objectExists(path);
+  }
+
+  /**
+   * Delete OCI blob
+   */
+  public async deleteOciBlob(digest: string): Promise<void> {
+    const path = this.getOciBlobPath(digest);
+    return this.deleteObject(path);
+  }
+
+  /**
+   * Get OCI manifest
+   */
+  public async getOciManifest(repository: string, digest: string): Promise<Buffer | null> {
+    const path = this.getOciManifestPath(repository, digest);
+    return this.getObject(path);
+  }
+
+  /**
+   * Store OCI manifest
+   */
+  public async putOciManifest(
+    repository: string,
+    digest: string,
+    data: Buffer,
+    contentType: string
+  ): Promise<void> {
+    const path = this.getOciManifestPath(repository, digest);
+    return this.putObject(path, data, { 'Content-Type': contentType });
+  }
+
+  /**
+   * Check if OCI manifest exists
+   */
+  public async ociManifestExists(repository: string, digest: string): Promise<boolean> {
+    const path = this.getOciManifestPath(repository, digest);
+    return this.objectExists(path);
+  }
+
+  /**
+   * Delete OCI manifest
+   */
+  public async deleteOciManifest(repository: string, digest: string): Promise<void> {
+    const path = this.getOciManifestPath(repository, digest);
+    return this.deleteObject(path);
+  }
+
+  // ========================================================================
+  // NPM-SPECIFIC HELPERS
+  // ========================================================================
+
+  /**
+   * Get NPM packument (package document)
+   */
+  public async getNpmPackument(packageName: string): Promise<any | null> {
+    const path = this.getNpmPackumentPath(packageName);
+    const data = await this.getObject(path);
+    return data ? JSON.parse(data.toString('utf-8')) : null;
+  }
+
+  /**
+   * Store NPM packument
+   */
+  public async putNpmPackument(packageName: string, packument: any): Promise<void> {
+    const path = this.getNpmPackumentPath(packageName);
+    const data = Buffer.from(JSON.stringify(packument, null, 2), 'utf-8');
+    return this.putObject(path, data, { 'Content-Type': 'application/json' });
+  }
+
+  /**
+   * Check if NPM packument exists
+   */
+  public async npmPackumentExists(packageName: string): Promise<boolean> {
+    const path = this.getNpmPackumentPath(packageName);
+    return this.objectExists(path);
+  }
+
+  /**
+   * Delete NPM packument
+   */
+  public async deleteNpmPackument(packageName: string): Promise<void> {
+    const path = this.getNpmPackumentPath(packageName);
+    return this.deleteObject(path);
+  }
+
+  /**
+   * Get NPM tarball
+   */
+  public async getNpmTarball(packageName: string, version: string): Promise<Buffer | null> {
+    const path = this.getNpmTarballPath(packageName, version);
+    return this.getObject(path);
+  }
+
+  /**
+   * Store NPM tarball
+   */
+  public async putNpmTarball(
+    packageName: string,
+    version: string,
+    tarball: Buffer
+  ): Promise<void> {
+    const path = this.getNpmTarballPath(packageName, version);
+    return this.putObject(path, tarball, { 'Content-Type': 'application/octet-stream' });
+  }
+
+  /**
+   * Check if NPM tarball exists
+   */
+  public async npmTarballExists(packageName: string, version: string): Promise<boolean> {
+    const path = this.getNpmTarballPath(packageName, version);
+    return this.objectExists(path);
+  }
+
+  /**
+   * Delete NPM tarball
+   */
+  public async deleteNpmTarball(packageName: string, version: string): Promise<void> {
+    const path = this.getNpmTarballPath(packageName, version);
+    return this.deleteObject(path);
+  }
+
+  // ========================================================================
+  // PATH HELPERS
+  // ========================================================================
+
+  private getOciBlobPath(digest: string): string {
+    const hash = digest.split(':')[1];
+    return `oci/blobs/sha256/${hash}`;
+  }
+
+  private getOciManifestPath(repository: string, digest: string): string {
+    const hash = digest.split(':')[1];
+    return `oci/manifests/${repository}/${hash}`;
+  }
+
+  private getNpmPackumentPath(packageName: string): string {
+    return `npm/packages/${packageName}/index.json`;
+  }
+
+  private getNpmTarballPath(packageName: string, version: string): string {
+    const safeName = packageName.replace('@', '').replace('/', '-');
+    return `npm/packages/${packageName}/${safeName}-${version}.tgz`;
+  }
+}

package/ts/core/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Core registry infrastructure exports
+ */
+
+// Interfaces
+export * from './interfaces.core.js';
+
+// Classes
+export { BaseRegistry } from './classes.baseregistry.js';
+export { RegistryStorage } from './classes.registrystorage.js';
+export { AuthManager } from './classes.authmanager.js';

package/ts/core/interfaces.core.ts

@@ -0,0 +1,159 @@
+/**
+ * Core interfaces for the composable registry system
+ */
+
+/**
+ * Registry protocol types
+ */
+export type TRegistryProtocol = 'oci' | 'npm';
+
+/**
+ * Unified action types across protocols
+ */
+export type TRegistryAction = 'pull' | 'push' | 'delete' | 'read' | 'write' | '*';
+
+/**
+ * Unified authentication token
+ */
+export interface IAuthToken {
+  /** Token type/protocol */
+  type: TRegistryProtocol;
+  /** User ID */
+  userId: string;
+  /** Permission scopes (e.g., "npm:package:foo:write", "oci:repository:bar:push") */
+  scopes: string[];
+  /** Token expiration */
+  expiresAt?: Date;
+  /** Read-only flag */
+  readonly?: boolean;
+  /** Additional metadata */
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Credentials for authentication
+ */
+export interface ICredentials {
+  username: string;
+  password: string;
+}
+
+/**
+ * Storage backend configuration
+ */
+export interface IStorageConfig {
+  accessKey: string;
+  accessSecret: string;
+  endpoint: string;
+  port?: number;
+  useSsl?: boolean;
+  region?: string;
+  bucketName: string;
+}
+
+/**
+ * Authentication configuration
+ */
+export interface IAuthConfig {
+  /** JWT secret for OCI tokens */
+  jwtSecret: string;
+  /** Token storage type */
+  tokenStore: 'memory' | 'redis' | 'database';
+  /** NPM token settings */
+  npmTokens: {
+    enabled: boolean;
+    defaultReadonly?: boolean;
+  };
+  /** OCI token settings */
+  ociTokens: {
+    enabled: boolean;
+    realm: string;
+    service: string;
+  };
+}
+
+/**
+ * Protocol-specific configuration
+ */
+export interface IProtocolConfig {
+  enabled: boolean;
+  basePath: string;
+  features?: Record<string, boolean>;
+}
+
+/**
+ * Main registry configuration
+ */
+export interface IRegistryConfig {
+  storage: IStorageConfig;
+  auth: IAuthConfig;
+  oci?: IProtocolConfig;
+  npm?: IProtocolConfig;
+}
+
+/**
+ * Storage backend interface
+ */
+export interface IStorageBackend {
+  /**
+   * Get an object from storage
+   */
+  getObject(key: string): Promise<Buffer | null>;
+
+  /**
+   * Store an object
+   */
+  putObject(key: string, data: Buffer, metadata?: Record<string, string>): Promise<void>;
+
+  /**
+   * Delete an object
+   */
+  deleteObject(key: string): Promise<void>;
+
+  /**
+   * List objects with a prefix
+   */
+  listObjects(prefix: string): Promise<string[]>;
+
+  /**
+   * Check if an object exists
+   */
+  objectExists(key: string): Promise<boolean>;
+
+  /**
+   * Get object metadata
+   */
+  getMetadata(key: string): Promise<Record<string, string> | null>;
+}
+
+/**
+ * Error response structure
+ */
+export interface IRegistryError {
+  errors: Array<{
+    code: string;
+    message: string;
+    detail?: any;
+  }>;
+}
+
+/**
+ * Base request context
+ */
+export interface IRequestContext {
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  body?: any;
+  token?: string;
+}
+
+/**
+ * Base response structure
+ */
+export interface IResponse {
+  status: number;
+  headers: Record<string, string>;
+  body?: any;
+}

package/ts/index.ts

@@ -0,0 +1,16 @@
+/**
+ * @push.rocks/smartregistry
+ * Composable registry supporting OCI and NPM protocols
+ */
+
+// Main orchestrator
+export { SmartRegistry } from './classes.smartregistry.js';
+
+// Core infrastructure
+export * from './core/index.js';
+
+// OCI Registry
+export * from './oci/index.js';
+
+// NPM Registry
+export * from './npm/index.js';