cnpmcore/dist/app/core/service/PackageManagerService.d.ts

Private NPM Registry for Enterprise

import { JSONBuilder } from '@cnpmjs/packument';
import type { RequireAtLeastOne } from 'type-fest';
import { AbstractService } from '../../common/AbstractService.ts';
import type { AbbreviatedPackageManifestType, AuthorType, PackageJSONType, PackageManifestType } from '../../repository/PackageRepository.ts';
import { Package } from '../entity/Package.ts';
import { PackageVersion } from '../entity/PackageVersion.ts';
import { PackageVersionBlock } from '../entity/PackageVersionBlock.ts';
import type { Registry } from '../entity/Registry.ts';
import type { User } from '../entity/User.ts';
export interface PublishPackageCmd {
    scope: string;
    name: string;
    version: string;
    description?: string;
    packageJson: PackageJSONType;
    registryId?: string;
    readme: string;
    dist: RequireAtLeastOne<{
        content?: Uint8Array;
        localFile?: string;
    }, 'content' | 'localFile'>;
    tags?: string[];
    /**
     * private package or not
     */
    isPrivate: boolean;
    publishTime?: Date;
    skipRefreshPackageManifests?: boolean;
}
export declare class PackageManagerService extends AbstractService {
    private readonly eventBus;
    private readonly packageRepository;
    private readonly packageVersionBlockRepository;
    private readonly packageVersionDownloadRepository;
    private readonly bugVersionService;
    private readonly distRepository;
    private readonly registryManagerService;
    private readonly packageVersionService;
    private static downloadCounters;
    static resetDownloadCounters(): void;
    publish(cmd: PublishPackageCmd, publisher: User): Promise<PackageVersion>;
    blockPackageByFullname(name: string, reason: string): Promise<PackageVersionBlock>;
    blockPackage(pkg: Package, reason: string): Promise<PackageVersionBlock>;
    unblockPackageByFullname(name: string): Promise<void>;
    unblockPackage(pkg: Package): Promise<void>;
    replacePackageMaintainersAndDist(pkg: Package, maintainers: User[]): Promise<void>;
    savePackageMaintainers(pkg: Package, maintainers: User[]): Promise<boolean>;
    removePackageMaintainer(pkg: Package, maintainer: User): Promise<void>;
    refreshPackageMaintainersToDists(pkg: Package): Promise<void>;
    refreshPackageDistTagsToDists(pkg: Package): Promise<void>;
    listPackageFullManifests(scope: string, name: string, isSync?: boolean): Promise<{
        etag: string;
        data: null;
        blockReason: string;
    } | {
        etag: string;
        data: PackageManifestType;
        blockReason: string;
    }>;
    listPackageFullManifestsBuffer(scope: string, name: string): Promise<{
        etag: string;
        data: null;
        blockReason: string;
    } | {
        etag: string;
        data: Buffer<ArrayBufferLike>;
        blockReason: string;
    }>;
    listPackageAbbreviatedManifests(scope: string, name: string, isSync?: boolean): Promise<{
        etag: string;
        data: null;
        blockReason: string;
    } | {
        etag: string;
        data: PackageManifestType | AbbreviatedPackageManifestType;
        blockReason: string;
    }>;
    listPackageAbbreviatedManifestsBuffer(scope: string, name: string): Promise<{
        etag: string;
        data: null;
        blockReason: string;
    } | {
        etag: string;
        data: Buffer<ArrayBufferLike>;
        blockReason: string;
    }>;
    showPackageVersionByVersionOrTag(scope: string, name: string, spec: string): Promise<{
        blockReason?: string;
        pkg?: Package;
        packageVersion?: PackageVersion | null;
    }>;
    showPackageVersionManifest(scope: string, name: string, spec: string, isSync?: boolean, isFullManifests?: boolean): Promise<{
        blockReason?: undefined;
        pkg?: undefined;
        manifest?: undefined;
    } | {
        blockReason: string;
        pkg: Package;
        manifest?: undefined;
    } | {
        manifest: PackageJSONType | undefined;
        blockReason: null;
        pkg: Package;
    }>;
    downloadPackageVersionTar(packageVersion: PackageVersion): Promise<string | import("stream").Readable | undefined>;
    plusPackageVersionCounter(fullname: string, version: string): void;
    savePackageVersionCounters(): Promise<void>;
    saveDeprecatedVersions(pkg: Package, deprecatedList: {
        version: string;
        deprecated?: string;
    }[]): Promise<void>;
    savePackageVersionManifest(pkgVersion: PackageVersion, mergeManifest: object, mergeAbbreviated: object): Promise<void>;
    savePackageVersionManifestWithBuilder(pkgVersion: PackageVersion, manifestBuilder: JSONBuilder, abbreviatedBuilder?: JSONBuilder): Promise<void>;
    /**
     * save package version readme
     */
    savePackageVersionReadme(pkgVersion: PackageVersion, readmeFile: string): Promise<void>;
    savePackageReadme(pkg: Package, readmeFile: string): Promise<void>;
    private _removePackageVersionAndDist;
    unpublishPackage(pkg: Package): Promise<void>;
    removePackageVersion(pkg: Package, pkgVersion: PackageVersion, skipRefreshPackageManifests?: boolean): Promise<void>;
    savePackageTag(pkg: Package, tag: string, version: string, skipEvent?: boolean): Promise<boolean>;
    removePackageTag(pkg: Package, tag: string): Promise<boolean>;
    refreshPackageChangeVersionsToDists(pkg: Package, updateVersions?: string[], removeVersions?: string[]): Promise<void>;
    private _refreshPackageChangeVersionsToDistsWithBuilder;
    getSourceRegistry(pkg: Package): Promise<Registry | null>;
    distTags(pkg: Package): Promise<PackageManifestType['dist-tags']>;
    private _refreshPackageManifestsToDists;
    private _refreshPackageManifestRootAttributeOnlyToDists;
    private _refreshPackageManifestRootAttributeOnlyToDistsWithBuilder;
    private _mergeLatestManifestFields;
    private _mergeLatestManifestFieldsWithBuilder;
    private _setPackageDistTagsAndLatestInfos;
    private _setPackageDistTagsAndLatestInfosWithBuilder;
    private _mergeManifestDist;
    private _updatePackageManifestsToDists;
    private _updatePackageManifestsToDistsWithBuilder;
    private _listPackageFullOrAbbreviatedManifests;
    private _listPackageFullOrAbbreviatedManifestsBuffer;
    maintainers(pkg: Package): Promise<AuthorType[]>;
    private _listPackageFullManifests;
    private _listPackageAbbreviatedManifests;
    private _checkPackageDepsVersion;
}