@verdaccio/core 8.0.0-next-8.11 → 8.0.0-next-8.13

package/src/error-utils.ts

@@ -1,106 +0,0 @@
-import createError, { HttpError } from 'http-errors';
-
-import { HTTP_STATUS } from './constants';
-
-export const API_ERROR = {
-  PASSWORD_SHORT: 'The provided password does not pass the validation',
-  MUST_BE_LOGGED: 'You must be logged in to publish packages.',
-  PLUGIN_ERROR: 'bug in the auth plugin system',
-  CONFIG_BAD_FORMAT: 'config file must be an object',
-  BAD_USERNAME_PASSWORD: 'bad username/password, access denied',
-  NO_PACKAGE: 'no such package available',
-  PACKAGE_CANNOT_BE_ADDED: 'this package cannot be added',
-  BAD_DATA: 'bad data',
-  NOT_ALLOWED: 'not allowed to access package',
-  NOT_ALLOWED_PUBLISH: 'not allowed to publish package',
-  INTERNAL_SERVER_ERROR: 'internal server error',
-  UNKNOWN_ERROR: 'unknown error',
-  NOT_PACKAGE_UPLINK: 'package does not exist on uplink',
-  UPLINK_OFFLINE_PUBLISH: 'one of the uplinks is down, refuse to publish',
-  UPLINK_OFFLINE: 'uplink is offline',
-  NOT_MODIFIED_NO_DATA: 'no data',
-  CONTENT_MISMATCH: 'content length mismatch',
-  NOT_FILE_UPLINK: "file doesn't exist on uplink",
-  MAX_USERS_REACHED: 'maximum amount of users reached',
-  VERSION_NOT_EXIST: "this version doesn't exist",
-  NO_SUCH_FILE: 'no such file available',
-  UNSUPORTED_REGISTRY_CALL: 'unsupported registry call',
-  FILE_NOT_FOUND: 'File not found',
-  REGISTRATION_DISABLED: 'user registration disabled',
-  UNAUTHORIZED_ACCESS: 'unauthorized access',
-  BAD_STATUS_CODE: 'bad status code',
-  SERVER_TIME_OUT: 'looks like the server is taking to long to respond',
-  PACKAGE_EXIST: 'this package is already present',
-  BAD_AUTH_HEADER: 'bad authorization header',
-  WEB_DISABLED: 'Web interface is disabled in the config file',
-  DEPRECATED_BASIC_HEADER: 'basic authentication is deprecated, please use JWT instead',
-  BAD_FORMAT_USER_GROUP: 'user groups is different than an array',
-  RESOURCE_UNAVAILABLE: 'resource unavailable',
-  BAD_PACKAGE_DATA: 'bad incoming package data',
-  USERNAME_PASSWORD_REQUIRED: 'username and password is required',
-  USERNAME_ALREADY_REGISTERED: 'username is already registered',
-  USERNAME_MISMATCH: 'username does not match logged in user',
-};
-
-export const SUPPORT_ERRORS = {
-  PLUGIN_MISSING_INTERFACE: 'the plugin does not provide implementation of the requested feature',
-  TFA_DISABLED: 'the two-factor authentication is not yet supported',
-  STORAGE_NOT_IMPLEMENT: 'the storage does not support token saving',
-  PARAMETERS_NOT_VALID: 'the parameters are not valid',
-};
-
-export const APP_ERROR = {
-  CONFIG_NOT_VALID: 'CONFIG: it does not look like a valid config file',
-  PROFILE_ERROR: 'profile unexpected error',
-  PASSWORD_VALIDATION: 'not valid password',
-};
-
-export type VerdaccioError = HttpError & { code: number };
-
-function getError(code: number, message: string): VerdaccioError {
-  const httpError = createError(code, message);
-
-  httpError.code = code;
-
-  return httpError as VerdaccioError;
-}
-
-export function getConflict(message: string = API_ERROR.PACKAGE_EXIST): VerdaccioError {
-  return getError(HTTP_STATUS.CONFLICT, message);
-}
-
-export function getBadData(customMessage?: string): VerdaccioError {
-  return getError(HTTP_STATUS.BAD_DATA, customMessage || API_ERROR.BAD_DATA);
-}
-
-export function getBadRequest(customMessage: string): VerdaccioError {
-  return getError(HTTP_STATUS.BAD_REQUEST, customMessage);
-}
-
-export function getInternalError(customMessage?: string): VerdaccioError {
-  return customMessage
-    ? getError(HTTP_STATUS.INTERNAL_ERROR, customMessage)
-    : getError(HTTP_STATUS.INTERNAL_ERROR, API_ERROR.UNKNOWN_ERROR);
-}
-
-export function getUnauthorized(message = 'no credentials provided'): VerdaccioError {
-  return getError(HTTP_STATUS.UNAUTHORIZED, message);
-}
-
-export function getForbidden(message = "can't use this filename"): VerdaccioError {
-  return getError(HTTP_STATUS.FORBIDDEN, message);
-}
-
-export function getServiceUnavailable(
-  message: string = API_ERROR.RESOURCE_UNAVAILABLE
-): VerdaccioError {
-  return getError(HTTP_STATUS.SERVICE_UNAVAILABLE, message);
-}
-
-export function getNotFound(customMessage?: string): VerdaccioError {
-  return getError(HTTP_STATUS.NOT_FOUND, customMessage || API_ERROR.NO_PACKAGE);
-}
-
-export function getCode(statusCode: number, customMessage: string): VerdaccioError {
-  return getError(statusCode, customMessage);
-}

package/src/file-utils.ts

@@ -1,31 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-export const Files = {
-  DatabaseName: '.verdaccio-db.json',
-};
-
-const { mkdir, mkdtemp } = fs.promises ? fs.promises : require('fs/promises');
-
-/**
- * Create a temporary folder.
- * @param prefix The prefix of the folder name.
- * @returns string
- */
-export async function createTempFolder(prefix: string): Promise<string> {
-  return await mkdtemp(path.join(os.tmpdir(), 'verdaccio-' + prefix + '-'));
-}
-
-/**
- * Create temporary folder for an asset.
- * @param prefix
- * @param folder name
- * @returns
- */
-export async function createTempStorageFolder(prefix: string, folder = 'storage'): Promise<string> {
-  const tempFolder = await createTempFolder(prefix);
-  const storageFolder = path.join(tempFolder, folder);
-  await mkdir(storageFolder);
-  return storageFolder;
-}

package/src/index.ts

@@ -1,46 +0,0 @@
-import * as constants from './constants';
-import * as errorUtils from './error-utils';
-import * as fileUtils from './file-utils';
-import * as pkgUtils from './pkg-utils';
-import * as pluginUtils from './plugin-utils';
-import * as searchUtils from './search-utils';
-import * as streamUtils from './stream-utils';
-import * as stringUtils from './string-utils';
-import * as tarballUtils from './tarball-utils';
-import * as validatioUtils from './validation-utils';
-import * as warningUtils from './warning-utils';
-
-export { VerdaccioError, API_ERROR, SUPPORT_ERRORS, APP_ERROR } from './error-utils';
-export {
-  TOKEN_BASIC,
-  TOKEN_BEARER,
-  HTTP_STATUS,
-  API_MESSAGE,
-  HEADERS,
-  DIST_TAGS,
-  CHARACTER_ENCODING,
-  HEADER_TYPE,
-  LATEST,
-  DEFAULT_PASSWORD_VALIDATION,
-  DEFAULT_USER,
-  USERS,
-  MAINTAINERS,
-  PLUGIN_CATEGORY,
-  HtpasswdHashAlgorithm,
-} from './constants';
-const validationUtils = validatioUtils;
-export {
-  fileUtils,
-  pkgUtils,
-  searchUtils,
-  streamUtils,
-  errorUtils,
-  // TODO: remove this typo
-  validatioUtils,
-  validationUtils,
-  stringUtils,
-  constants,
-  pluginUtils,
-  warningUtils,
-  tarballUtils,
-};

package/src/pkg-utils.ts

@@ -1,68 +0,0 @@
-import semver from 'semver';
-
-import { Manifest } from '@verdaccio/types';
-
-import { DIST_TAGS } from './constants';
-
-/**
- * Function filters out bad semver versions and sorts the array.
- * @return {Array} sorted Array
- */
-export function semverSort(listVersions: string[]): string[] {
-  return listVersions
-    .filter(function (x): boolean {
-      if (!semver.parse(x, true)) {
-        return false;
-      }
-      return true;
-    })
-    .sort(semver.compareLoose)
-    .map(String);
-}
-
-/**
- * Get the latest publihsed version of a package.
- * @param package metadata
- **/
-export function getLatest(pkg: Manifest): string {
-  const listVersions: string[] = Object.keys(pkg.versions);
-  if (listVersions.length < 1) {
-    throw Error('cannot get lastest version of none');
-  }
-
-  const versions: string[] = semverSort(listVersions);
-  const latest: string | undefined = pkg[DIST_TAGS]?.latest ? pkg[DIST_TAGS].latest : versions[0];
-
-  return latest;
-}
-
-/**
- * Function gets a local info and an info from uplinks and tries to merge it
- exported for unit tests only.
-  * @param {*} local
-  * @param {*} upstream
-  * @param {*} config sds
-  * @deprecated use @verdaccio/storage mergeVersions method
-  */
-// @deprecated
-export function mergeVersions(local: Manifest, upstream: Manifest) {
-  // copy new versions to a cache
-  // NOTE: if a certain version was updated, we can't refresh it reliably
-  for (const i in upstream.versions) {
-    if (typeof local.versions[i] === 'undefined') {
-      local.versions[i] = upstream.versions[i];
-    }
-  }
-
-  for (const i in upstream[DIST_TAGS]) {
-    if (local[DIST_TAGS][i] !== upstream[DIST_TAGS][i]) {
-      if (!local[DIST_TAGS][i] || semver.lte(local[DIST_TAGS][i], upstream[DIST_TAGS][i])) {
-        local[DIST_TAGS][i] = upstream[DIST_TAGS][i];
-      }
-      if (i === 'latest' && local[DIST_TAGS][i] === upstream[DIST_TAGS][i]) {
-        // if remote has more fresh package, we should borrow its readme
-        local.readme = upstream.readme;
-      }
-    }
-  }
-}

package/src/plugin-utils.ts

@@ -1,205 +0,0 @@
-import { Express, RequestHandler } from 'express';
-import { Readable, Writable } from 'stream';
-
-import {
-  AllowAccess,
-  Callback,
-  Config,
-  Logger,
-  Manifest,
-  PackageAccess,
-  RemoteUser,
-  Token,
-  TokenFilter,
-} from '@verdaccio/types';
-
-import { VerdaccioError, searchUtils } from '.';
-
-export interface PluginOptions {
-  config: Config;
-  logger: Logger;
-}
-
-/**
- * Base Plugin Class
- *
- * Set of utilities for developing plugins.
- */
-export class Plugin<PluginConfig> {
-  static version = 1;
-  public readonly version: number;
-  public readonly config: PluginConfig | unknown;
-  public readonly options: PluginOptions;
-  public constructor(config: PluginConfig, options: PluginOptions) {
-    this.version = Plugin.version;
-    this.config = config;
-    this.options = options;
-  }
-
-  public getVersion() {
-    return this.version;
-  }
-}
-
-// --- STORAGE PLUGIN ---
-
-/**
- * Storage Handler
- *
- * Used in storage plugin for managing packages and tarballs.
- */
-export interface StorageHandler {
-  logger: Logger;
-  deletePackage(fileName: string): Promise<void>;
-  removePackage(): Promise<void>;
-  //  next packages migration (this list is meant to replace the callback parent functions)
-  updatePackage(
-    packageName: string,
-    handleUpdate: (manifest: Manifest) => Promise<Manifest>
-  ): Promise<Manifest>;
-  readPackage(packageName: string): Promise<Manifest>;
-  savePackage(packageName: string, manifest: Manifest): Promise<void>;
-  readTarball(fileName: string, { signal }: { signal: AbortSignal }): Promise<Readable>;
-  createPackage(packageName: string, manifest: Manifest): Promise<void>;
-  writeTarball(fileName: string, { signal }: { signal: AbortSignal }): Promise<Writable>;
-  // verify if tarball exist in the storage
-  hasTarball(fileName: string): Promise<boolean>;
-  // verify if package exist in the storage
-  hasPackage(): Promise<boolean>;
-}
-
-/**
- * Storage Plugin interface
- *
- * https://verdaccio.org/docs/next/plugin-storage
- */
-export interface Storage<PluginConfig> extends Plugin<PluginConfig> {
-  add(packageName: string): Promise<void>;
-  remove(packageName: string): Promise<void>;
-  get(): Promise<string[]>;
-  init(): Promise<void>;
-  getSecret(): Promise<string>;
-  setSecret(secret: string): Promise<any>;
-  getPackageStorage(packageName: string): StorageHandler;
-  search(query: searchUtils.SearchQuery): Promise<searchUtils.SearchItem[]>;
-  saveToken(token: Token): Promise<any>;
-  deleteToken(user: string, tokenKey: string): Promise<any>;
-  readTokens(filter: TokenFilter): Promise<Token[]>;
-}
-
-// --- MIDDLEWARE PLUGIN ---
-
-/**
- * Middleware Plugin Interface
- *
- * https://verdaccio.org/docs/next/plugin-middleware
- *
- * This function allow add middleware to the application.
- *
- *  ```ts
- *  import express, { Request, Response } from 'express';
- * 
- *  class Middleware extends Plugin {
- *    // instances of auth and storage are injected
- *    register_middlewares(app, auth, storage) {
- *      const router = express.Router();
- *      router.post('/my-endpoint', (req: Request, res: Response): void => {
-        res.status(200).end();
-      });
- *    }
- *  }
- *
- *  const [plugin] = await asyncLoadPlugin(...);
- *  plugin.register_middlewares(app, auth, storage);
- *  ```
- */
-export interface ExpressMiddleware<PluginConfig, Storage, Auth> extends Plugin<PluginConfig> {
-  register_middlewares(app: Express, auth: Auth, storage: Storage): void;
-}
-
-// --- AUTH PLUGIN ---
-
-export type AuthCallback = (error: VerdaccioError | null, groups?: string[] | false) => void;
-
-export type AuthAccessCallback = (error: VerdaccioError | null, access?: boolean) => void;
-export type AuthUserCallback = (error: VerdaccioError | null, access?: boolean | string) => void;
-export type AuthChangePasswordCallback = (error: VerdaccioError | null, access?: boolean) => void;
-export type AccessCallback = (error: VerdaccioError | null, ok?: boolean) => void;
-
-export interface AuthPluginPackage {
-  packageName: string;
-  packageVersion?: string;
-  tag?: string;
-}
-
-/**
- * Authentication Plugin Interface
- *
- * https://verdaccio.org/docs/next/plugin-auth
- */
-export interface Auth<T> extends Plugin<T> {
-  /**
-   * Handles the authenticated method.
-   * ```ts
-   *  class Auth {
-      public authenticate(user: string, password: string, done: AuthCallback): void {
-        if (!password) {
-          return done(errorUtils.getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD));
-        }
-        // always return an array of users
-        return done(null, [user]);      
-   *  }
-   * ```
-   */
-  authenticate(user: string, password: string, cb: AuthCallback): void;
-  /**
-   * Handles the authenticated method.
-   * ```ts
-   *  class Auth {
-      public adduser(user: string, password: string, done: AuthCallback): void {
-        if (!password) {
-          return done(errorUtils.getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD));
-        }
-        // return boolean
-        return done(null, true);      
-   *  }
-   * ```
-   */
-  adduser?(user: string, password: string, cb: AuthUserCallback): void;
-  changePassword?(
-    user: string,
-    password: string,
-    newPassword: string,
-    cb: AuthChangePasswordCallback
-  ): void;
-  allow_publish?(user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
-  allow_publish?(user: RemoteUser, pkg: AllowAccess & PackageAccess, cb: AuthAccessCallback): void;
-  allow_access?(user: RemoteUser, pkg: T & PackageAccess, cb: AccessCallback): void;
-  allow_access?(user: RemoteUser, pkg: AllowAccess & PackageAccess, cb: AccessCallback): void;
-  allow_unpublish?(user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
-  allow_unpublish?(
-    user: RemoteUser,
-    pkg: AllowAccess & PackageAccess,
-    cb: AuthAccessCallback
-  ): void;
-  apiJWTmiddleware?(helpers: any): RequestHandler;
-}
-
-export interface IBasicAuth {
-  authenticate(user: string, password: string, cb: Callback): void;
-  invalidateToken?(token: string): Promise<void>;
-  changePassword(user: string, password: string, newPassword: string, cb: Callback): void;
-  allow_access(pkg: AuthPluginPackage, user: RemoteUser, callback: Callback): void;
-  add_user(user: string, password: string, cb: Callback): any;
-}
-
-// --- FILTER PLUGIN ---
-
-/**
- * Filter Plugin Interface
- *
- * https://verdaccio.org/docs/next/plugin-filter
- */
-export interface ManifestFilter<T> extends Plugin<T> {
-  filter_metadata(manifest: Manifest): Promise<Manifest>;
-}

package/src/schemes/publish-manifest.ts

@@ -1,38 +0,0 @@
-import Ajv, { JSONSchemaType } from 'ajv';
-
-const ajv = new Ajv();
-
-// FIXME: this could extend from @verdaccio/types but we need
-// schemas from @verdaccio/types to be able to validate them
-interface Manifest {
-  name: string;
-  versions: object;
-  _attachments: object;
-}
-
-const schema: JSONSchemaType<Manifest> = {
-  type: 'object',
-  properties: {
-    name: { type: 'string' },
-    versions: { type: 'object', maxProperties: 1 },
-    _attachments: { type: 'object', maxProperties: 1 },
-  },
-  required: ['name', 'versions', '_attachments'],
-  additionalProperties: true,
-};
-
-// validate is a type guard for MyData - type is inferred from schema type
-const validate = ajv.compile(schema);
-
-/**
- * Validate if a manifest has the correct structure when a new package
- * is being created. The properties name, versions and _attachments must contain 1 element.
- * @param data a manifest object
- * @returns boolean
- */
-export function validatePublishSingleVersion(manifest: any) {
-  if (!manifest) {
-    return false;
-  }
-  return validate(manifest);
-}

package/src/schemes/unpublish-manifest.ts

@@ -1,69 +0,0 @@
-import Ajv, { JSONSchemaType } from 'ajv';
-
-const ajv = new Ajv();
-
-interface Manifest {
-  name: string;
-  versions: Record<string, unknown>;
-  _rev: string;
-  _id: string;
-  time: {
-    created: string;
-    modified: string;
-    [key: string]: string; // Allows pattern properties such as version numbers
-  };
-  readme: string;
-  'dist-tags': {
-    latest: string;
-    [key: string]: unknown; // Allows additional properties
-  };
-}
-
-// @ts-ignore
-const schema: JSONSchemaType<Manifest> = {
-  type: 'object',
-  properties: {
-    name: { type: 'string' },
-    versions: { type: 'object', minProperties: 1 },
-    _rev: { type: 'string' },
-    _id: { type: 'string' },
-    time: {
-      type: 'object',
-      properties: {
-        created: { type: 'string' },
-        modified: { type: 'string' },
-      },
-      patternProperties: {
-        '^[0-9]+\\.[0-9]+\\.[0-9]+-\\d+$': { type: 'string' },
-      },
-      additionalProperties: true,
-    },
-    readme: { type: 'string' },
-    'dist-tags': {
-      type: 'object',
-      properties: {
-        latest: { type: 'string' },
-      },
-      required: ['latest'],
-      additionalProperties: true,
-    },
-  },
-  required: ['name', 'versions', 'dist-tags', '_rev', '_id', 'readme', 'time'],
-  additionalProperties: true,
-};
-
-// validate is a type guard for MyData - type is inferred from schema type
-const validate = ajv.compile(schema);
-
-/**
- * Validate if a manifest has the correct structure when a new package
- * is being created. The properties name, versions and _attachments must contain 1 element.
- * @param data a manifest object
- * @returns boolean
- */
-export function validateUnPublishSingleVersion(manifest: any) {
-  if (!manifest) {
-    return false;
-  }
-  return validate(manifest);
-}

package/src/search-utils.ts

@@ -1,81 +0,0 @@
-export type SearchMetrics = {
-  quality: number;
-  popularity: number;
-  maintenance: number;
-};
-export type UnStable = {
-  flags?: {
-    // if is false is not be included in search results (majority are stable)
-    unstable?: boolean;
-  };
-};
-export type SearchItemPkg = {
-  name: string;
-  scoped?: string;
-  path?: string;
-  time?: number | Date;
-};
-
-type PrivatePackage = {
-  // note: prefixed to avoid external conflicts
-
-  // the package is published as private
-  verdaccioPrivate?: boolean;
-  // if the package is not private but is cached
-  verdaccioPkgCached?: boolean;
-};
-
-export interface SearchItem extends UnStable, PrivatePackage {
-  package: SearchItemPkg;
-  score: Score;
-}
-
-export type Score = {
-  final: number;
-  detail: SearchMetrics;
-};
-
-export type SearchResults = {
-  objects: SearchItemPkg[];
-  total: number;
-  time: string;
-};
-
-// @deprecated use @verdaccio/types
-type PublisherMaintainer = {
-  username: string;
-  email: string;
-};
-
-// @deprecated use @verdaccio/types
-export type SearchPackageBody = {
-  name: string;
-  scope: string;
-  description: string;
-  author: string | PublisherMaintainer;
-  version: string;
-  keywords: string | string[] | undefined;
-  date: string;
-  links?: {
-    npm: string; // only include placeholder for URL eg: {url}/{packageName}
-    homepage?: string;
-    repository?: string;
-    bugs?: string;
-  };
-  publisher?: any;
-  maintainers?: PublisherMaintainer[];
-};
-
-export interface SearchPackageItem extends UnStable, PrivatePackage {
-  package: SearchPackageBody;
-  score: Score;
-  searchScore?: number;
-}
-
-export const UNSCOPED = 'unscoped';
-
-export type SearchQuery = {
-  text: string;
-  size?: number;
-  from?: number;
-} & SearchMetrics;

package/src/stream-utils.ts

@@ -1,28 +0,0 @@
-import { Readable, Transform } from 'stream';
-
-/**
- * Converts a buffer stream to a string.
- */
-const readableToString = async (stream: Readable) => {
-  const chunks: Buffer[] = [];
-  for await (let chunk of stream) {
-    chunks.push(Buffer.from(chunk));
-  }
-  const buffer = Buffer.concat(chunks);
-  const str = buffer.toString('utf-8');
-  return str;
-};
-
-/**
- * Transform stream object  mode to string
- **/
-const transformObjectToString = () => {
-  return new Transform({
-    objectMode: true,
-    transform: (chunk, encoding, callback) => {
-      callback(null, JSON.stringify(chunk));
-    },
-  });
-};
-
-export { readableToString, transformObjectToString };