@verdaccio/core 6.0.0-6-next.3 → 6.0.0-6-next.6

package/src/plugin-utils.ts

@@ -1,4 +1,5 @@
 import { Config, IPackageStorage, Token, TokenFilter } from '@verdaccio/types';
+
 import { searchUtils } from '.';
 
 interface IPlugin {

package/src/schemes/publish-manifest.ts

@@ -0,0 +1,38 @@
+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/search-utils.ts

@@ -16,10 +16,19 @@ export type SearchItemPkg = {
   time?: number | Date;
 };
 
-export type SearchItem = {
+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;
-} & UnStable;
+}
 
 export type Score = {
   final: number;
@@ -32,11 +41,13 @@ export type SearchResults = {
   time: string;
 };
 
+// @deprecated use @verdaccio/types
 type PublisherMaintainer = {
   username: string;
   email: string;
 };
 
+// @deprecated use @verdaccio/types
 export type SearchPackageBody = {
   name: string;
   scope: string;
@@ -55,11 +66,11 @@ export type SearchPackageBody = {
   maintainers?: PublisherMaintainer[];
 };
 
-export type SearchPackageItem = {
+export interface SearchPackageItem extends UnStable, PrivatePackage {
   package: SearchPackageBody;
   score: Score;
   searchScore?: number;
-} & UnStable;
+}
 
 export const UNSCOPED = 'unscoped';
 

package/src/stream-utils.ts

@@ -1,4 +1,4 @@
-import { PassThrough, TransformOptions, Transform } from 'stream';
+import { PassThrough, Transform, TransformOptions } from 'stream';
 
 export interface IReadTarball {
   abort?: () => void;

package/src/validation-utils.ts

@@ -1,7 +1,11 @@
 import assert from 'assert';
-import { Package } from '@verdaccio/types';
+
+import { Manifest } from '@verdaccio/types';
+
 import { DIST_TAGS } from './constants';
 
+export { validatePublishSingleVersion } from './schemes/publish-manifest';
+
 export function isPackageNameScoped(name: string): boolean {
   return name.startsWith('@');
 }
@@ -60,27 +64,29 @@ export function validatePackage(name: string): boolean {
 /**
  * Validate the package metadata, add additional properties whether are missing within
  * the metadata properties.
- * @param {*} object
+ * @param {*} manifest
  * @param {*} name
  * @return {Object} the object with additional properties as dist-tags ad versions
+ * FUTURE: rename to normalizeMetadata
  */
-export function validateMetadata(object: Package, name: string): Package {
-  assert(isObject(object), 'not a json object');
-  assert.strictEqual(object.name, name);
+export function normalizeMetadata(manifest: Manifest, name: string): Manifest {
+  assert.strictEqual(manifest.name, name);
+  const _manifest = { ...manifest };
 
-  if (!isObject(object[DIST_TAGS])) {
-    object[DIST_TAGS] = {};
+  if (!isObject(manifest[DIST_TAGS])) {
+    _manifest[DIST_TAGS] = {};
   }
 
-  if (!isObject(object['versions'])) {
-    object['versions'] = {};
+  // This may not be nee dit
+  if (!isObject(manifest['versions'])) {
+    _manifest['versions'] = {};
   }
 
-  if (!isObject(object['time'])) {
-    object['time'] = {};
+  if (!isObject(manifest['time'])) {
+    _manifest['time'] = {};
   }
 
-  return object;
+  return _manifest;
 }
 
 /**
@@ -89,7 +95,7 @@ export function validateMetadata(object: Package, name: string): Package {
  * @return {Boolean}
  */
 export function isObject(obj: any): boolean {
-  if (obj === null || typeof obj === 'undefined') {
+  if (obj === null || typeof obj === 'undefined' || typeof obj === 'string') {
     return false;
   }
 

package/src/warning-utils.ts

@@ -1,4 +1,4 @@
-import warning from 'fastify-warning';
+import warning from 'process-warning';
 
 const warningInstance = warning();
 const verdaccioWarning = 'VerdaccioWarning';
@@ -6,11 +6,9 @@ const verdaccioDeprecation = 'VerdaccioDeprecation';
 
 export enum Codes {
   VERWAR001 = 'VERWAR001',
-  VERWAR002 = 'VERWAR002',
   VERWAR003 = 'VERWAR003',
   VERWAR004 = 'VERWAR004',
-  VERDEP001 = 'VERDEP001',
-  VERDEP002 = 'VERDEP002',
+  // deprecation warnings
   VERDEP003 = 'VERDEP003',
 }
 
@@ -20,8 +18,6 @@ warningInstance.create(
   `Verdaccio doesn't need superuser privileges. don't run it under root`
 );
 
-warningInstance.create(verdaccioWarning, Codes.VERWAR002, 'logger is not defined');
-
 warningInstance.create(
   verdaccioWarning,
   Codes.VERWAR003,
@@ -36,18 +32,6 @@ host:port (e.g. "localhost:4873") or full url '(e.g. "http://localhost:4873/")
 https://verdaccio.org/docs/en/configuration#listen-port`
 );
 
-warningInstance.create(
-  verdaccioDeprecation,
-  Codes.VERDEP001,
-  'config.logs is deprecated, rename configuration to "config.log" in singular'
-);
-
-warningInstance.create(
-  verdaccioDeprecation,
-  Codes.VERDEP002,
-  'deprecate: multiple logger configuration is deprecated, please check the migration guide.'
-);
-
 warningInstance.create(
   verdaccioDeprecation,
   Codes.VERDEP003,

package/test/errors.spec.ts

@@ -1,17 +1,17 @@
 import _ from 'lodash';
-import { HTTP_STATUS } from '../src/constants';
 
+import { HTTP_STATUS } from '../src/constants';
 import {
-  getNotFound,
+  API_ERROR,
   VerdaccioError,
-  getConflict,
   getBadData,
-  getInternalError,
-  API_ERROR,
-  getUnauthorized,
+  getCode,
+  getConflict,
   getForbidden,
+  getInternalError,
+  getNotFound,
   getServiceUnavailable,
-  getCode,
+  getUnauthorized,
 } from '../src/error-utils';
 
 describe('testing errors', () => {

package/test/merge.dist.tags.spec.ts

@@ -1,4 +1,4 @@
-import { semverSort, mergeVersions } from '../src/pkg-utils';
+import { mergeVersions, semverSort } from '../src/pkg-utils';
 
 describe('Storage._merge_versions versions', () => {
   test('simple', () => {

package/test/mystreams.spec.ts

@@ -1,5 +1,6 @@
 import { Stream } from 'stream';
-import { readableToString, ReadTarball, UploadTarball } from '../src/stream-utils';
+
+import { ReadTarball, UploadTarball, readableToString } from '../src/stream-utils';
 
 describe('mystreams', () => {
   test('should delay events on ReadTarball abort', (cb) => {

package/test/pkg-utils.spec.ts

@@ -0,0 +1,42 @@
+import { DIST_TAGS, pkgUtils } from '../src';
+
+describe('pkg-utils', () => {
+  test('extractTarballName', () => {
+    expect(pkgUtils.extractTarballName('https://registry.npmjs.org/test/-/test-0.0.2.tgz')).toBe(
+      'test-0.0.2.tgz'
+    );
+  });
+
+  test('extractTarballName with no tarball should not fails', () => {
+    expect(pkgUtils.extractTarballName('https://registry.npmjs.org/')).toBe('');
+  });
+
+  test('extractTarballName fails', () => {
+    expect(() =>
+      pkgUtils.extractTarballName('xxxxregistry.npmjs.org/test/-/test-0.0.2.tgz')
+    ).toThrow();
+  });
+
+  test('getLatest fails if no versions', () => {
+    expect(() =>
+      // @ts-expect-error
+      pkgUtils.getLatest({
+        versions: {},
+      })
+    ).toThrow('cannot get lastest version of none');
+  });
+
+  test('getLatest get latest', () => {
+    expect(
+      pkgUtils.getLatest({
+        versions: {
+          // @ts-expect-error
+          '1.0.0': {},
+        },
+        [DIST_TAGS]: {
+          latest: '1.0.0',
+        },
+      })
+    ).toBe('1.0.0');
+  });
+});

package/test/validation-utilts.spec.ts

@@ -1,4 +1,11 @@
-import { validateName, validatePackage, isObject } from '../src/validation-utils';
+import { DIST_TAGS } from '../src/constants';
+import { validatePublishSingleVersion } from '../src/schemes/publish-manifest';
+import {
+  isObject,
+  normalizeMetadata,
+  validateName,
+  validatePackage,
+} from '../src/validation-utils';
 
 describe('validatePackage', () => {
   test('should validate package names', () => {
@@ -19,13 +26,41 @@ describe('validatePackage', () => {
 describe('isObject', () => {
   test('isObject metadata', () => {
     expect(isObject({ foo: 'bar' })).toBeTruthy();
-    expect(isObject('foo')).toBeTruthy();
+    // expect(isObject('foo')).toBeTruthy();
     expect(isObject(['foo'])).toBeFalsy();
     expect(isObject(null)).toBeFalsy();
     expect(isObject(undefined)).toBeFalsy();
   });
 });
 
+describe('normalizeMetadata', () => {
+  test('should fills an empty metadata object', () => {
+    // intended to fail with flow, do not remove
+    // @ts-ignore
+    expect(Object.keys(normalizeMetadata({}))).toContain(DIST_TAGS);
+    // @ts-ignore
+    expect(Object.keys(normalizeMetadata({}))).toContain('versions');
+    // @ts-ignore
+    expect(Object.keys(normalizeMetadata({}))).toContain('time');
+  });
+
+  test.skip('should fails the assertions is not an object', () => {
+    expect(function () {
+      // @ts-ignore
+      normalizeMetadata('');
+      // @ts-ignore
+    }).toThrow(expect.hasAssertions());
+  });
+
+  test('should fails the assertions is name does not match', () => {
+    expect(function () {
+      // @ts-ignore
+      normalizeMetadata({}, 'no-name');
+      // @ts-ignore
+    }).toThrow(expect.hasAssertions());
+  });
+});
+
 describe('validateName', () => {
   test('should fails with no string', () => {
     // intended to fail with Typescript, do not remove
@@ -72,3 +107,62 @@ describe('validateName', () => {
     expect(validateName('pk:g')).toBeFalsy();
   });
 });
+
+describe('validatePublishSingleVersion', () => {
+  test('should be valid', () => {
+    expect(
+      validatePublishSingleVersion({
+        name: 'foo-pkg',
+        _attachments: { '2': {} },
+        versions: { '1': {} },
+      })
+    ).toBeTruthy();
+  });
+
+  test('should be invalid if name is missing', () => {
+    expect(
+      validatePublishSingleVersion({
+        _attachments: { '2': {} },
+        versions: { '1': {} },
+      })
+    ).toBeFalsy();
+  });
+
+  test('should be invalid if _attachments is missing', () => {
+    expect(
+      validatePublishSingleVersion({
+        name: 'foo-pkg',
+        versions: { '1': {} },
+      })
+    ).toBeFalsy();
+  });
+
+  test('should be invalid if versions is missing', () => {
+    expect(
+      validatePublishSingleVersion({
+        name: 'foo-pkg',
+        _attachments: { '1': {} },
+      })
+    ).toBeFalsy();
+  });
+
+  test('should be invalid if versions is more than 1', () => {
+    expect(
+      validatePublishSingleVersion({
+        name: 'foo-pkg',
+        versions: { '1': {}, '2': {} },
+        _attachments: { '1': {} },
+      })
+    ).toBeFalsy();
+  });
+
+  test('should be invalid if _attachments is more than 1', () => {
+    expect(
+      validatePublishSingleVersion({
+        name: 'foo-pkg',
+        _attachments: { '1': {}, '2': {} },
+        versions: { '1': {} },
+      })
+    ).toBeFalsy();
+  });
+});