Infrastructure/verdaccio
0
Fork 0
mirror of https://github.com/verdaccio/verdaccio.git synced 2024-12-16 21:56:25 -05:00
Code Issues Activity

refactor: remove @verdaccio/commons-api in favor @verdaccio/core and remove duplication (#2455)

Browse source 
* migrate api package

* migrate auth

* migrate config

* refactor: remove @verdaccio/commons-api in favor @verdaccio/core

* fix lint

* relocate pkg

* relocate pkg

* fix tsconfig
This commit is contained in:
Juan Picado 2021-09-26 00:08:00 +02:00 committed by GitHub
parent cd7947adbc
commit 154b2ecd34
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
170 changed files with 534 additions and 955 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
.changeset/perfect-candles-clap.md Normal file
View file

@ -0,0 +1,35 @@
---
'@verdaccio/api': minor
'@verdaccio/auth': minor
'@verdaccio/cli': minor
'@verdaccio/config': minor
'@verdaccio/core': minor
'verdaccio-htpasswd': minor
'@verdaccio/local-storage': minor
'@verdaccio/fastify-migration': minor
'@verdaccio/tarball': minor
'@verdaccio/types': minor
'@verdaccio/url': minor
'@verdaccio/hooks': minor
'@verdaccio/loaders': minor
'@verdaccio/logger': minor
'@verdaccio/middleware': minor
'@verdaccio/mock': minor
'@verdaccio/node-api': minor
'@verdaccio/active-directory': minor
'verdaccio-auth-memory': minor
'verdaccio-aws-s3-storage': minor
'verdaccio-google-cloud': minor
'verdaccio-memory': minor
'@verdaccio/ui-theme': minor
'@verdaccio/proxy': minor
'@verdaccio/server': minor
'@verdaccio/cli-standalone': minor
'@verdaccio/store': minor
'@verdaccio/utils': minor
'verdaccio': minor
'@verdaccio/web': minor
'@verdaccio/e2e-ui': minor
---
refactor: remove @verdaccio/commons-api in favor @verdaccio/core and remove duplications

1
.changeset/pre.json
View file

@ -6,7 +6,6 @@
"@verdaccio/auth": "6.0.0-alpha.0",
"@verdaccio/cli": "6.0.0-alpha.0",
"@verdaccio/config": "6.0.0-alpha.0",
"@verdaccio/commons-api": "11.0.0-alpha.0",
"@verdaccio/file-locking": "11.0.0-alpha.0",
"verdaccio-htpasswd": "11.0.0-alpha.0",
"@verdaccio/local-storage": "11.0.0-alpha.0",

2
.vscode/settings.json vendored
View file

@ -2,7 +2,7 @@
{
"files.exclude": {
"**/.nyc_output": true,
"**/build": true,
"**/build": false,
"**/coverage": true,
".idea": true,
"storage_default_storage": true,

4
docs/migration-v5-to-v6.md
View file

@ -74,3 +74,7 @@ Introduce environment variables for legacy tokens.
- `VERDACCIO_LEGACY_ALGORITHM`: Allows to define the specific algorithm for the token signature which by default is `aes-256-ctr`
- `VERDACCIO_LEGACY_ENCRYPTION_KEY`: By default, the token stores in the database, but using this variable allows to get it from memory
#### @verdaccio/commons-api migration
The package has been removed in favor of `@verdaccio/core` with a similar API, check API documentation for further details.

2
packages/api/package.json
View file

@ -40,7 +40,6 @@
"license": "MIT",
"dependencies": {
"@verdaccio/auth": "workspace:6.0.0-6-next.12",
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/hooks": "workspace:6.0.0-6-next.7",
@ -60,6 +59,7 @@
"@types/node": "16.9.1",
"@verdaccio/server": "workspace:6.0.0-6-next.20",
"@verdaccio/types": "workspace:11.0.0-6-next.8",
"@verdaccio/helper": "1.0.0",
"body-parser": "1.19.0",
"lodash": "4.17.21",
"supertest": "6.1.6"

16
packages/api/src/dist-tags.ts
View file

@ -3,7 +3,7 @@ import _ from 'lodash';
import { Router } from 'express';
import { media, allow } from '@verdaccio/middleware';
import { API_MESSAGE, HTTP_STATUS, DIST_TAGS, VerdaccioError } from '@verdaccio/commons-api';
import { constants, VerdaccioError } from '@verdaccio/core';
import { Package } from '@verdaccio/types';
import { Storage } from '@verdaccio/store';
import { IAuth } from '@verdaccio/auth';
@ -26,8 +26,8 @@ export default function (route: Router, auth: IAuth, storage: Storage): void {
if (err) {
return next(err);
}
res.status(HTTP_STATUS.CREATED);
return next({ ok: API_MESSAGE.TAG_ADDED });
res.status(constants.HTTP_STATUS.CREATED);
return next({ ok: constants.API_MESSAGE.TAG_ADDED });
});
};
@ -58,9 +58,9 @@ export default function (route: Router, auth: IAuth, storage: Storage): void {
if (err) {
return next(err);
}
res.status(HTTP_STATUS.CREATED);
res.status(constants.HTTP_STATUS.CREATED);
return next({
ok: API_MESSAGE.TAG_REMOVED,
ok: constants.API_MESSAGE.TAG_REMOVED,
});
});
}
@ -79,7 +79,7 @@ export default function (route: Router, auth: IAuth, storage: Storage): void {
return next(err);
}
next(info[DIST_TAGS]);
next(info[constants.DIST_TAGS]);
},
});
}
@ -96,9 +96,9 @@ export default function (route: Router, auth: IAuth, storage: Storage): void {
if (err) {
return next(err);
}
res.status(HTTP_STATUS.CREATED);
res.status(constants.HTTP_STATUS.CREATED);
return next({
ok: API_MESSAGE.TAG_UPDATED,
ok: constants.API_MESSAGE.TAG_UPDATED,
});
}
);

6
packages/api/src/package.ts
View file

@ -3,8 +3,8 @@ import { Router } from 'express';
import buildDebug from 'debug';
import { allow } from '@verdaccio/middleware';
import { getVersion, ErrorCode } from '@verdaccio/utils';
import { HEADERS, DIST_TAGS, API_ERROR } from '@verdaccio/commons-api';
import { getVersion } from '@verdaccio/utils';
import { HEADERS, DIST_TAGS, API_ERROR, errorUtils } from '@verdaccio/core';
import { Config, Package } from '@verdaccio/types';
import { IAuth } from '@verdaccio/auth';
import { Storage } from '@verdaccio/store';
@ -80,7 +80,7 @@ export default function (route: Router, auth: IAuth, storage: Storage, config: C
}
debug('package version not found %o', queryVersion);
return next(ErrorCode.getNotFound(`${API_ERROR.VERSION_NOT_EXIST}: ${queryVersion}`));
return next(errorUtils.getNotFound(`${API_ERROR.VERSION_NOT_EXIST}: ${queryVersion}`));
};
debug('get package name %o', name);

15
packages/api/src/publish.ts
View file

@ -4,8 +4,15 @@ import mime from 'mime';
import { Router } from 'express';
import buildDebug from 'debug';
import { API_MESSAGE, HEADERS, DIST_TAGS, API_ERROR, HTTP_STATUS } from '@verdaccio/commons-api';
import { validateMetadata, isObject, ErrorCode, hasDiffOneKey } from '@verdaccio/utils';
import {
API_MESSAGE,
HEADERS,
DIST_TAGS,
API_ERROR,
HTTP_STATUS,
errorUtils,
} from '@verdaccio/core';
import { validateMetadata, isObject, hasDiffOneKey } from '@verdaccio/utils';
import { media, expectJson, allow } from '@verdaccio/middleware';
import { notify } from '@verdaccio/hooks';
import { Config, Callback, MergeTags, Version, Package, CallbackAction } from '@verdaccio/types';
@ -224,7 +231,7 @@ export function publishPackage(storage: Storage, config: Config, auth: IAuth): a
// if this happens in normal circumstances, report it as a bug
debug('invalid body format');
logger.info({ packageName }, `wrong package format on publish a package @{packageName}`);
return next(ErrorCode.getBadRequest(API_ERROR.UNSUPORTED_REGISTRY_CALL));
return next(errorUtils.getBadRequest(API_ERROR.UNSUPORTED_REGISTRY_CALL));
}
if (error && error.status !== HTTP_STATUS.CONFLICT) {
@ -322,7 +329,7 @@ export function publishPackage(storage: Storage, config: Config, auth: IAuth): a
} catch (error: any) {
debug('error on publish, bad package format %o', packageName);
logger.error({ packageName }, 'error on publish, bad package data for @{packageName}');
return next(ErrorCode.getBadData(API_ERROR.BAD_PACKAGE_DATA));
return next(errorUtils.getBadData(API_ERROR.BAD_PACKAGE_DATA));
}
};
}

2
packages/api/src/search.ts
View file

@ -1,4 +1,4 @@
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { HTTP_STATUS } from '@verdaccio/core';
import { logger } from '@verdaccio/logger';
export default function (route): void {

2
packages/api/src/star.ts
View file

@ -1,4 +1,4 @@
import { USERS, HTTP_STATUS } from '@verdaccio/commons-api';
import { USERS, HTTP_STATUS } from '@verdaccio/core';
import { Response } from 'express';
import _ from 'lodash';
import buildDebug from 'debug';

2
packages/api/src/stars.ts
View file

@ -1,7 +1,7 @@
import _ from 'lodash';
import { Response, Router } from 'express';
import { USERS, HTTP_STATUS } from '@verdaccio/commons-api';
import { USERS, HTTP_STATUS } from '@verdaccio/core';
import { Package } from '@verdaccio/types';
import { Storage } from '@verdaccio/store';

14
packages/api/src/user.ts
View file

@ -2,14 +2,14 @@ import _ from 'lodash';
import { Response, Router } from 'express';
import buildDebug from 'debug';
import { getAuthenticatedMessage, validatePassword, ErrorCode } from '@verdaccio/utils';
import { getAuthenticatedMessage, validatePassword } from '@verdaccio/utils';
import { getApiToken } from '@verdaccio/auth';
import { logger } from '@verdaccio/logger';
import { createRemoteUser } from '@verdaccio/config';
import { Config, RemoteUser } from '@verdaccio/types';
import { IAuth } from '@verdaccio/auth';
import { API_ERROR, API_MESSAGE, HTTP_STATUS } from '@verdaccio/commons-api';
import { API_ERROR, API_MESSAGE, HTTP_STATUS, errorUtils } from '@verdaccio/core';
import { $RequestExtend, $NextFunctionVer } from '../types/custom';
const debug = buildDebug('verdaccio:api:user');
@ -47,7 +47,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
'authenticating for user @{username} failed. Error: @{err.message}'
);
return next(
ErrorCode.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.BAD_USERNAME_PASSWORD)
errorUtils.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.BAD_USERNAME_PASSWORD)
);
}
@ -55,7 +55,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
const token = await getApiToken(auth, config, restoredRemoteUser, password);
debug('login: new token');
if (!token) {
return next(ErrorCode.getUnauthorized());
return next(errorUtils.getUnauthorized());
}
res.status(HTTP_STATUS.CREATED);
@ -73,7 +73,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
if (validatePassword(password) === false) {
debug('adduser: invalid password');
// eslint-disable-next-line new-cap
return next(ErrorCode.getCode(HTTP_STATUS.BAD_REQUEST, API_ERROR.PASSWORD_SHORT()));
return next(errorUtils.getCode(HTTP_STATUS.BAD_REQUEST, API_ERROR.PASSWORD_SHORT()));
}
auth.add_user(name, password, async function (err, user): Promise<void> {
@ -84,7 +84,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
// and npm accepts only an 409 error.
// So, changing status code here.
return next(
ErrorCode.getCode(err.status, err.message) || ErrorCode.getConflict(err.message)
errorUtils.getCode(err.status, err.message) || errorUtils.getConflict(err.message)
);
}
return next(err);
@ -94,7 +94,7 @@ export default function (route: Router, auth: IAuth, config: Config): void {
name && password ? await getApiToken(auth, config, user, password) : undefined;
debug('adduser: new token %o', token);
if (!token) {
return next(ErrorCode.getUnauthorized());
return next(errorUtils.getUnauthorized());
}
req.remote_user = user;

14
packages/api/src/v1/profile.ts
View file

@ -1,8 +1,8 @@
import _ from 'lodash';
import { Response, Router } from 'express';
import { API_ERROR, APP_ERROR, HTTP_STATUS, SUPPORT_ERRORS } from '@verdaccio/commons-api';
import { ErrorCode, validatePassword } from '@verdaccio/utils';
import { API_ERROR, APP_ERROR, HTTP_STATUS, SUPPORT_ERRORS, errorUtils } from '@verdaccio/core';
import { validatePassword } from '@verdaccio/utils';
import { IAuth } from '@verdaccio/auth';
import { $RequestExtend, $NextFunctionVer } from '../../types/custom';
@ -61,7 +61,7 @@ export default function (route: Router, auth: IAuth): void {
if (_.isNil(password) === false) {
if (validatePassword(password.new) === false) {
/* eslint new-cap:off */
return next(ErrorCode.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.PASSWORD_SHORT()));
return next(errorUtils.getCode(HTTP_STATUS.UNAUTHORIZED, API_ERROR.PASSWORD_SHORT()));
/* eslint new-cap:off */
}
@ -72,22 +72,22 @@ export default function (route: Router, auth: IAuth): void {
(err, isUpdated): $NextFunctionVer => {
if (_.isNull(err) === false) {
return next(
ErrorCode.getCode(err.status, err.message) || ErrorCode.getConflict(err.message)
errorUtils.getCode(err.status, err.message) || errorUtils.getConflict(err.message)
);
}
if (isUpdated) {
return next(buildProfile(req.remote_user.name));
}
return next(ErrorCode.getInternalError(API_ERROR.INTERNAL_SERVER_ERROR));
return next(errorUtils.getInternalError(API_ERROR.INTERNAL_SERVER_ERROR));
}
);
} else if (_.isNil(tfa) === false) {
return next(
ErrorCode.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.TFA_DISABLED)
errorUtils.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, SUPPORT_ERRORS.TFA_DISABLED)
);
} else {
return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, APP_ERROR.PROFILE_ERROR));
return next(errorUtils.getCode(HTTP_STATUS.INTERNAL_ERROR, APP_ERROR.PROFILE_ERROR));
}
}
);

3
packages/api/src/v1/search.ts
View file

@ -2,8 +2,7 @@ import _ from 'lodash';
import buildDebug from 'debug';
import { logger } from '@verdaccio/logger';
import { IAuth } from '@verdaccio/auth';
import { searchUtils } from '@verdaccio/core';
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { HTTP_STATUS, searchUtils } from '@verdaccio/core';
import { Storage } from '@verdaccio/store';
import { Package } from '@verdaccio/types';

22
packages/api/src/v1/token.ts
View file

@ -1,6 +1,6 @@
import _ from 'lodash';
import { HTTP_STATUS, SUPPORT_ERRORS, getInternalError } from '@verdaccio/commons-api';
import { ErrorCode, stringToMD5, mask } from '@verdaccio/utils';
import { errorUtils, HTTP_STATUS, SUPPORT_ERRORS } from '@verdaccio/core';
import { stringToMD5, mask } from '@verdaccio/utils';
import { getApiToken } from '@verdaccio/auth';
import { logger } from '@verdaccio/logger';
import { Response, Router } from 'express';
@ -43,10 +43,10 @@ export default function (route: Router, auth: IAuth, storage: Storage, config: C
});
} catch (error: any) {
logger.error({ error: error.msg }, 'token list has failed: @{error}');
return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));
return next(errorUtils.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));
}
}
return next(ErrorCode.getUnauthorized());
return next(errorUtils.getUnauthorized());
}
);
@ -57,27 +57,27 @@ export default function (route: Router, auth: IAuth, storage: Storage, config: C
const { name } = req.remote_user;
if (!_.isBoolean(readonly) || !_.isArray(cidr_whitelist)) {
return next(ErrorCode.getCode(HTTP_STATUS.BAD_DATA, SUPPORT_ERRORS.PARAMETERS_NOT_VALID));
return next(errorUtils.getCode(HTTP_STATUS.BAD_DATA, SUPPORT_ERRORS.PARAMETERS_NOT_VALID));
}
auth.authenticate(name, password, async (err, user: RemoteUser) => {
if (err) {
const errorCode = err.message ? HTTP_STATUS.UNAUTHORIZED : HTTP_STATUS.INTERNAL_ERROR;
return next(ErrorCode.getCode(errorCode, err.message));
return next(errorUtils.getCode(errorCode, err.message));
}
req.remote_user = user;
if (!_.isFunction(storage.saveToken)) {
return next(
ErrorCode.getCode(HTTP_STATUS.NOT_IMPLEMENTED, SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT)
errorUtils.getCode(HTTP_STATUS.NOT_IMPLEMENTED, SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT)
);
}
try {
const token = await getApiToken(auth, config, user, password);
if (!token) {
throw getInternalError();
throw errorUtils.getInternalError();
}
const key = stringToMD5(token);
@ -113,7 +113,7 @@ export default function (route: Router, auth: IAuth, storage: Storage, config: C
);
} catch (error: any) {
logger.error({ error: error.msg }, 'token creation has failed: @{error}');
return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));
return next(errorUtils.getInternalError(error.message));
}
});
}
@ -135,10 +135,10 @@ export default function (route: Router, auth: IAuth, storage: Storage, config: C
return next({});
} catch (error: any) {
logger.error({ error: error.msg }, 'token creation has failed: @{error}');
return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));
return next(errorUtils.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));
}
}
return next(ErrorCode.getUnauthorized());
return next(errorUtils.getUnauthorized());
}
);
}

1
packages/api/src/whoami.ts
View file

@ -1,7 +1,6 @@
import { Response, Router } from 'express';
import buildDebug from 'debug';
import { $RequestExtend, $NextFunctionVer } from '../types/custom';
// import { getUnauthorized } from '@verdaccio/commons-api';
const debug = buildDebug('verdaccio:api:user');

3
packages/api/test/integration/_helper.ts
View file

@ -5,9 +5,10 @@ import bodyParser from 'body-parser';
import { Config, parseConfigFile } from '@verdaccio/config';
import { Storage } from '@verdaccio/store';
import { generatePackageMetadata } from '@verdaccio/helper';
import { final, handleError, errorReportingMiddleware } from '@verdaccio/middleware';
import { Auth, IAuth } from '@verdaccio/auth';
import { HEADERS, HEADER_TYPE, HTTP_STATUS, generatePackageMetadata } from '@verdaccio/commons-api';
import { HEADERS, HEADER_TYPE, HTTP_STATUS } from '@verdaccio/core';
import apiEndpoints from '../../src';
const getConf = (conf) => {

2
packages/api/test/integration/package.spec.ts
View file

@ -1,6 +1,6 @@
import supertest from 'supertest';
import { HEADER_TYPE, HEADERS, HTTP_STATUS } from '@verdaccio/commons-api';
import { HEADER_TYPE, HEADERS, HTTP_STATUS } from '@verdaccio/core';
import { $ResponseExtend, $RequestExtend } from '../../types/custom';
import { initializeServer, publishTaggedVersion, publishVersion } from './_helper';

2
packages/api/test/integration/ping.spec.ts
View file

@ -1,6 +1,6 @@
import supertest from 'supertest';
import { HEADER_TYPE, HEADERS, HTTP_STATUS } from '@verdaccio/commons-api';
import { HEADER_TYPE, HEADERS, HTTP_STATUS } from '@verdaccio/core';
import { initializeServer } from './_helper';
describe('ping', () => {

11
packages/api/test/integration/publish.spec.ts
View file

@ -1,12 +1,7 @@
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { HTTP_STATUS } from '@verdaccio/core';
import supertest from 'supertest';
import {
API_ERROR,
API_MESSAGE,
generatePackageMetadata,
HEADER_TYPE,
HEADERS,
} from '@verdaccio/commons-api';
import { API_ERROR, API_MESSAGE, HEADER_TYPE, HEADERS } from '@verdaccio/core';
import { generatePackageMetadata } from '@verdaccio/helper';
import { $ResponseExtend, $RequestExtend } from '../../types/custom';
import { initializeServer, publishVersion } from './_helper';

14
packages/api/test/integration/user.spec.ts
View file

@ -2,15 +2,13 @@ import supertest from 'supertest';
import _ from 'lodash';
import {
getBadRequest,
getConflict,
getUnauthorized,
errorUtils,
HEADERS,
HEADER_TYPE,
API_MESSAGE,
HTTP_STATUS,
API_ERROR,
} from '@verdaccio/commons-api';
} from '@verdaccio/core';
import { $RequestExtend, $ResponseExtend } from '../../types/custom';
import { initializeServer } from './_helper';
@ -28,7 +26,7 @@ const mockAuthenticate = jest.fn(() => (_name, _password, callback): void => {
});
const mockAddUser = jest.fn(() => (_name, _password, callback): void => {
return callback(getConflict(API_ERROR.USERNAME_ALREADY_REGISTERED));
return callback(errorUtils.getConflict(API_ERROR.USERNAME_ALREADY_REGISTERED));
});
jest.mock('@verdaccio/auth', () => ({
@ -143,7 +141,7 @@ describe('user', () => {
}
);
mockAddUser.mockImplementationOnce(() => (_name, _password, callback): void => {
return callback(getBadRequest(API_ERROR.USERNAME_PASSWORD_REQUIRED));
return callback(errorUtils.getBadRequest(API_ERROR.USERNAME_PASSWORD_REQUIRED));
});
const credentialsShort = _.cloneDeep(credentials);
delete credentialsShort.name;
@ -208,7 +206,7 @@ describe('user', () => {
}
);
mockAuthenticate.mockImplementationOnce(() => (_name, _password, callback): void => {
return callback(getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD));
return callback(errorUtils.getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD));
});
const credentialsShort = _.cloneDeep(credentials);
credentialsShort.password = 'failPassword';
@ -240,7 +238,7 @@ describe('user', () => {
}
);
mockAuthenticate.mockImplementationOnce(() => (_name, _password, callback): void => {
return callback(getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD));
return callback(errorUtils.getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD));
});
const credentialsShort = _.cloneDeep(credentials);
credentialsShort.password = 'failPassword';

2
packages/api/test/integration/whoami.spec.ts
View file

@ -1,6 +1,6 @@
import supertest from 'supertest';
import { HEADERS, HTTP_STATUS } from '@verdaccio/commons-api';
import { HEADERS, HTTP_STATUS } from '@verdaccio/core';
import { $RequestExtend, $ResponseExtend } from '../../types/custom';
import { initializeServer } from './_helper';

7
packages/api/test/unit/publish.spec.ts
View file

@ -1,5 +1,4 @@
import { HTTP_STATUS, API_ERROR } from '@verdaccio/commons-api';
import { ErrorCode } from '@verdaccio/utils';
import { errorUtils, HTTP_STATUS, API_ERROR } from '@verdaccio/core';
import {
addVersion,
uploadPackageTarball,
@ -202,13 +201,13 @@ describe('Publish endpoints - un-publish package', () => {
const storage = {
removePackage(packageName) {
expect(packageName).toEqual(req.params.package);
return Promise.reject(ErrorCode.getInternalError());
return Promise.reject(errorUtils.getInternalError());
},
};
// @ts-ignore
await unPublishPackage(storage)(req, res, next);
expect(next).toHaveBeenCalledWith(ErrorCode.getInternalError());
expect(next).toHaveBeenCalledWith(errorUtils.getInternalError());
});
});

3
packages/api/tsconfig.json
View file

@ -13,9 +13,6 @@
{
"path": "../config"
},
{
"path": "../core/commons-api"
},
{
"path": "../core/core"
},

2
packages/auth/package.json
View file

@ -39,7 +39,7 @@
},
"license": "MIT",
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/loaders": "workspace:6.0.0-6-next.5",
"@verdaccio/logger": "workspace:6.0.0-6-next.5",

16
packages/auth/src/auth.ts
View file

@ -8,10 +8,8 @@ import {
TOKEN_BASIC,
TOKEN_BEARER,
VerdaccioError,
getBadRequest,
getInternalError,
getForbidden,
} from '@verdaccio/commons-api';
errorUtils,
} from '@verdaccio/core';
import { loadPlugin } from '@verdaccio/loaders';
import { HTPasswd, HTPasswdConfig } from 'verdaccio-htpasswd';
@ -153,7 +151,7 @@ class Auth implements IAuth {
const validPlugins = _.filter(this.plugins, (plugin) => isFunction(plugin.changePassword));
if (_.isEmpty(validPlugins)) {
return cb(getInternalError(SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
return cb(errorUtils.getInternalError(SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
}
for (const plugin of validPlugins) {
@ -425,7 +423,7 @@ class Auth implements IAuth {
if (!isAuthHeaderValid(authorization)) {
debug('api middleware authentication heather is invalid');
return next(getBadRequest(API_ERROR.BAD_AUTH_HEADER));
return next(errorUtils.getBadRequest(API_ERROR.BAD_AUTH_HEADER));
}
const { secret, security } = this.config;
@ -476,7 +474,7 @@ class Auth implements IAuth {
} else {
// with JWT throw 401
debug('jwt invalid token');
next(getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
next(errorUtils.getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
}
}
}
@ -510,7 +508,7 @@ class Auth implements IAuth {
} else {
// we force npm client to ask again with basic authentication
debug('legacy invalid header');
return next(getBadRequest(API_ERROR.BAD_AUTH_HEADER));
return next(errorUtils.getBadRequest(API_ERROR.BAD_AUTH_HEADER));
}
}
@ -544,7 +542,7 @@ class Auth implements IAuth {
}
if (!isAuthHeaderValid(authorization)) {
return next(getBadRequest(API_ERROR.BAD_AUTH_HEADER));
return next(errorUtils.getBadRequest(API_ERROR.BAD_AUTH_HEADER));
}
const token = (authorization || '').replace(`${TOKEN_BEARER} `, '');

23
packages/auth/src/utils.ts
View file

@ -13,12 +13,9 @@ import {
TOKEN_BASIC,
TOKEN_BEARER,
API_ERROR,
getForbidden,
getUnauthorized,
getConflict,
getCode,
} from '@verdaccio/commons-api';
import { VerdaccioError } from '@verdaccio/commons-api';
VerdaccioError,
errorUtils,
} from '@verdaccio/core';
import { createAnonymousRemoteUser } from '@verdaccio/config';
import { TokenEncryption, AESPayload } from './auth';
@ -155,7 +152,7 @@ export function verifyJWTPayload(token: string, secret: string): RemoteUser {
// we return an anonymous user to force log in.
return createAnonymousRemoteUser();
}
throw getCode(HTTP_STATUS.UNAUTHORIZED, error.message);
throw errorUtils.getCode(HTTP_STATUS.UNAUTHORIZED, error.message);
}
}
@ -166,11 +163,11 @@ export function isAuthHeaderValid(authorization: string): boolean {
export function getDefaultPlugins(logger: any): IPluginAuth<Config> {
return {
authenticate(user: string, password: string, cb: Callback): void {
cb(getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
cb(errorUtils.getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
},
adduser(user: string, password: string, cb: Callback): void {
return cb(getConflict(API_ERROR.BAD_USERNAME_PASSWORD));
return cb(errorUtils.getConflict(API_ERROR.BAD_USERNAME_PASSWORD));
},
// FIXME: allow_action and allow_publish should be in the @verdaccio/types
@ -205,9 +202,13 @@ export function allow_action(action: ActionsAllowed, logger): AllowAction {
}
if (name) {
callback(getForbidden(`user ${name} is not allowed to ${action} package ${pkg.name}`));
callback(
errorUtils.getForbidden(`user ${name} is not allowed to ${action} package ${pkg.name}`)
);
} else {
callback(getUnauthorized(`authorization required to ${action} package ${pkg.name}`));
callback(
errorUtils.getUnauthorized(`authorization required to ${action} package ${pkg.name}`)
);
}
};
}

14
packages/auth/test/auth-utils.spec.ts
View file

@ -1,8 +1,6 @@
import path from 'path';
import _ from 'lodash';
import { CHARACTER_ENCODING, TOKEN_BEARER, API_ERROR } from '@verdaccio/commons-api';
import { configExample } from '@verdaccio/mock';
import {
Config as AppConfig,
@ -20,7 +18,13 @@ import {
} from '@verdaccio/utils';
import { Config, Security, RemoteUser } from '@verdaccio/types';
import { VerdaccioError, getForbidden } from '@verdaccio/commons-api';
import {
VerdaccioError,
CHARACTER_ENCODING,
TOKEN_BEARER,
API_ERROR,
errorUtils,
} from '@verdaccio/core';
import { setup } from '@verdaccio/logger';
import {
IAuth,
@ -110,7 +114,7 @@ describe('Auth utilities', () => {
test('authentication should fail by default (default)', () => {
const plugin = getDefaultPlugins({ trace: jest.fn() });
plugin.authenticate('foo', 'bar', (error: any) => {
expect(error).toEqual(getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
expect(error).toEqual(errorUtils.getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
});
});
@ -118,7 +122,7 @@ describe('Auth utilities', () => {
const plugin = getDefaultPlugins({ trace: jest.fn() });
// @ts-ignore
plugin.adduser('foo', 'bar', (error: any) => {
expect(error).toEqual(getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
expect(error).toEqual(errorUtils.getForbidden(API_ERROR.BAD_USERNAME_PASSWORD));
});
});
});

4
packages/auth/test/auth.spec.ts
View file

@ -3,7 +3,7 @@ import { ROLES, Config as AppConfig } from '@verdaccio/config';
import { setup } from '@verdaccio/logger';
import { IAuth } from '@verdaccio/auth';
import { Config } from '@verdaccio/types';
import { getInternalError } from '@verdaccio/commons-api';
import { errorUtils } from '@verdaccio/core';
import { Auth } from '../src';
@ -57,7 +57,7 @@ describe('AuthTest', () => {
auth.authenticate('foo', 'bar', callback);
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith(getInternalError());
expect(callback).toHaveBeenCalledWith(errorUtils.getInternalError());
});
});

3
packages/auth/tsconfig.json
View file

@ -10,9 +10,6 @@
{
"path": "../config"
},
{
"path": "../core/commons-api"
},
{
"path": "../core/htpasswd"
},

2
packages/config/package.json
View file

@ -39,7 +39,7 @@
"build": "pnpm run build:js && pnpm run build:types"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/utils": "workspace:6.0.0-6-next.6",
"debug": "4.3.2",
"js-yaml": "3.14.1",

2
packages/config/src/config-path.ts
View file

@ -3,7 +3,7 @@ import path from 'path';
import _ from 'lodash';
import buildDebug from 'debug';
import { CHARACTER_ENCODING } from '@verdaccio/commons-api';
import { CHARACTER_ENCODING } from '@verdaccio/core';
import { folderExists, fileExists } from './config-utils';
const CONFIG_FILE = 'config.yaml';

2
packages/config/src/config.ts
View file

@ -3,7 +3,7 @@ import _ from 'lodash';
import buildDebug from 'debug';
import { getMatchedPackagesSpec, generateRandomHexString, isObject } from '@verdaccio/utils';
import { APP_ERROR } from '@verdaccio/commons-api';
import { APP_ERROR } from '@verdaccio/core';
import {
PackageList,
Config as AppConfig,

4
packages/config/src/package-access.ts
View file

@ -1,7 +1,7 @@
import assert from 'assert';
import _ from 'lodash';
import { PackageAccess } from '@verdaccio/types';
import { ErrorCode } from '@verdaccio/utils';
import { errorUtils } from '@verdaccio/core';
export interface LegacyPackageList {
[key: string]: PackageAccess;
}
@ -35,7 +35,7 @@ export function normalizeUserList(groupsList: any): any {
} else if (Array.isArray(groupsList)) {
result.push(groupsList);
} else {
throw ErrorCode.getInternalError(
throw errorUtils.getInternalError(
'CONFIG: bad package acl (array or string expected): ' + JSON.stringify(groupsList)
);
}

2
packages/config/src/parse.ts
View file

@ -1,6 +1,6 @@
import fs from 'fs';
import YAML from 'js-yaml';
import { APP_ERROR } from '@verdaccio/commons-api';
import { APP_ERROR } from '@verdaccio/core';
import { ConfigRuntime, ConfigYaml } from '@verdaccio/types';
/**

3
packages/config/tsconfig.json
View file

@ -7,9 +7,6 @@
"include": ["src/**/*.ts"],
"exclude": ["src/**/*.test.ts"],
"references": [
{
"path": "../core/commons-api"
},
{
"path": "../utils"
}

15
packages/core/commons-api/README.md
View file

@ -1,15 +0,0 @@
# @verdaccio/commons-api
commons api utilities for verdaccio
[![verdaccio (latest)](https://img.shields.io/npm/v/@verdaccio/commons-api/latest.svg)](https://www.npmjs.com/package/@verdaccio/commons-api)
[![docker pulls](https://img.shields.io/docker/pulls/verdaccio/verdaccio.svg?maxAge=43200)](https://verdaccio.org/docs/en/docker.html)
[![backers](https://opencollective.com/verdaccio/tiers/backer/badge.svg?label=Backer&color=brightgreen)](https://opencollective.com/verdaccio)
[![stackshare](https://img.shields.io/badge/Follow%20on-StackShare-blue.svg?logo=stackshare&style=flat)](https://stackshare.io/verdaccio)
[![discord](https://img.shields.io/discord/388674437219745793.svg)](http://chat.verdaccio.org/)
[![node](https://img.shields.io/node/v/@verdaccio/commons-api/latest.svg)](https://www.npmjs.com/package/@verdaccio/commons-api)
![MIT](https://img.shields.io/github/license/mashape/apistatus.svg)
[![Crowdin](https://d322cqt584bo4o.cloudfront.net/verdaccio/localized.svg)](https://crowdin.com/project/verdaccio)
[![Twitter followers](https://img.shields.io/twitter/follow/verdaccio_npm.svg?style=social&label=Follow)](https://twitter.com/verdaccio_npm)
[![Github](https://img.shields.io/github/stars/verdaccio/verdaccio.svg?style=social&label=Stars)](https://github.com/verdaccio/verdaccio/stargazers)

3
packages/core/commons-api/jest.config.js
View file

@ -1,3 +0,0 @@
const config = require('../../../jest/config');
module.exports = Object.assign({}, config, {});

55
packages/core/commons-api/package.json
View file

@ -1,55 +0,0 @@
{
"name": "@verdaccio/commons-api",
"version": "11.0.0-6-next.4",
"description": "Commons API utilities for Verdaccio",
"keywords": [
"private",
"package",
"repository",
"registry",
"enterprise",
"modules",
"proxy",
"server",
"verdaccio"
],
"author": "Juan Picado <juanpicado19@gmail.com>",
"license": "MIT",
"homepage": "https://verdaccio.org",
"repository": {
"type": "https",
"url": "https://github.com/verdaccio/verdaccio",
"directory": "packages/core/commons-api"
},
"bugs": {
"url": "https://github.com/verdaccio/verdaccio/issues"
},
"publishConfig": {
"access": "public"
},
"main": "build/index.js",
"types": "build/index.d.ts",
"files": [
"build"
],
"engines": {
"node": ">=10",
"npm": ">=6"
},
"dependencies": {
"http-errors": "1.8.0",
"http-status-codes": "2.1.4"
},
"scripts": {
"clean": "rimraf ./build",
"test": "cross-env NODE_ENV=test BABEL_ENV=test jest",
"build:types": "tsc --emitDeclarationOnly -p tsconfig.build.json",
"build:js": "babel src/ --out-dir build/ --copy-files --extensions \".ts,.tsx\" --source-maps",
"watch": "pnpm build:js -- --watch",
"build": "pnpm run build:js && pnpm run build:types"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/verdaccio"
}
}

200
packages/core/commons-api/src/index.ts
View file

@ -1,200 +0,0 @@
import createError, { HttpError } from 'http-errors';
import httpCodes from 'http-status-codes';
export const DEFAULT_MIN_LIMIT_PASSWORD = 3;
export const HEADER_TYPE = {
CONTENT_ENCODING: 'content-encoding',
CONTENT_TYPE: 'content-type',
CONTENT_LENGTH: 'content-length',
ACCEPT_ENCODING: 'accept-encoding',
};
export const HTTP_STATUS = {
OK: httpCodes.OK,
CREATED: httpCodes.CREATED,
MULTIPLE_CHOICES: httpCodes.MULTIPLE_CHOICES,
NOT_MODIFIED: httpCodes.NOT_MODIFIED,
BAD_REQUEST: httpCodes.BAD_REQUEST,
UNAUTHORIZED: httpCodes.UNAUTHORIZED,
FORBIDDEN: httpCodes.FORBIDDEN,
NOT_FOUND: httpCodes.NOT_FOUND,
CONFLICT: httpCodes.CONFLICT,
NOT_IMPLEMENTED: httpCodes.NOT_IMPLEMENTED,
UNSUPPORTED_MEDIA: httpCodes.UNSUPPORTED_MEDIA_TYPE,
BAD_DATA: httpCodes.UNPROCESSABLE_ENTITY,
INTERNAL_ERROR: httpCodes.INTERNAL_SERVER_ERROR,
SERVICE_UNAVAILABLE: httpCodes.SERVICE_UNAVAILABLE,
LOOP_DETECTED: 508,
};
export const CHARACTER_ENCODING = {
UTF8: 'utf8',
};
export const ERROR_CODE = {
token_required: 'token is required',
};
export const TOKEN_BASIC = 'Basic';
export const TOKEN_BEARER = 'Bearer';
export const HEADERS = {
ACCEPT: 'Accept',
ACCEPT_ENCODING: 'Accept-Encoding',
USER_AGENT: 'User-Agent',
JSON: 'application/json',
CONTENT_TYPE: 'Content-type',
CONTENT_LENGTH: 'content-length',
TEXT_PLAIN: 'text/plain',
TEXT_PLAIN_UTF8: 'text/plain; charset=utf-8',
TEXT_HTML_UTF8: 'text/html; charset=utf-8',
TEXT_HTML: 'text/html',
AUTHORIZATION: 'authorization',
// only set with proxy that setup HTTPS
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto
FORWARDED_PROTO: 'X-Forwarded-Proto',
FORWARDED_FOR: 'X-Forwarded-For',
FRAMES_OPTIONS: 'X-Frame-Options',
CSP: 'Content-Security-Policy',
CTO: 'X-Content-Type-Options',
XSS: 'X-XSS-Protection',
ETAG: 'ETag',
JSON_CHARSET: 'application/json; charset=utf-8',
OCTET_STREAM: 'application/octet-stream; charset=utf-8',
TEXT_CHARSET: 'text/plain; charset=utf-8',
WWW_AUTH: 'WWW-Authenticate',
GZIP: 'gzip',
};
export const API_MESSAGE = {
PKG_CREATED: 'created new package',
PKG_CHANGED: 'package changed',
PKG_REMOVED: 'package removed',
PKG_PUBLISHED: 'package published',
TARBALL_UPLOADED: 'tarball uploaded successfully',
TARBALL_REMOVED: 'tarball removed',
TAG_UPDATED: 'tags updated',
TAG_REMOVED: 'tag removed',
TAG_ADDED: 'package tagged',
LOGGED_OUT: 'Logged out',
};
// @deprecated
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',
};
// @deprecated
export const API_ERROR = {
PASSWORD_SHORT: (passLength = DEFAULT_MIN_LIMIT_PASSWORD): string =>
`The provided password is too short. Please pick a password longer than ` +
`${passLength} characters.`,
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',
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",
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',
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',
};
// @deprecated
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',
};
// @deprecated
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);
}
export const TIME_EXPIRATION_24H = '24h';
export const TIME_EXPIRATION_7D = '7d';
export const DIST_TAGS = 'dist-tags';
export const LATEST = 'latest';
export const USERS = 'users';
export const DEFAULT_USER = 'Anonymous';
export const LOG_STATUS_MESSAGE =
"@{status}, user: @{user}(@{remoteIP}), req: '@{request.method} @{request.url}'";
export const LOG_VERDACCIO_ERROR = `${LOG_STATUS_MESSAGE}, error: @{!error}`;
export const LOG_VERDACCIO_BYTES = `${LOG_STATUS_MESSAGE}, bytes: @{bytes.in}/@{bytes.out}`;
export * from './helpers/pkg';

108
packages/core/commons-api/test/errors.spec.ts
View file

@ -1,108 +0,0 @@
import _ from 'lodash';
import {
getNotFound,
VerdaccioError,
HTTP_STATUS,
getConflict,
getBadData,
getInternalError,
API_ERROR,
getUnauthorized,
getForbidden,
getServiceUnavailable,
getCode,
} from '../src/index';
describe('testing errors', () => {
test('should qualify as an native error', () => {
expect(_.isError(getNotFound())).toBeTruthy();
expect(_.isError(getConflict())).toBeTruthy();
expect(_.isError(getBadData())).toBeTruthy();
expect(_.isError(getInternalError())).toBeTruthy();
expect(_.isError(getUnauthorized())).toBeTruthy();
expect(_.isError(getForbidden())).toBeTruthy();
expect(_.isError(getServiceUnavailable())).toBeTruthy();
expect(_.isError(getCode(400, 'fooError'))).toBeTruthy();
});
test('should test not found', () => {
const err: VerdaccioError = getNotFound('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.NOT_FOUND);
expect(err.statusCode).toEqual(HTTP_STATUS.NOT_FOUND);
expect(err.message).toEqual('foo');
});
test('should test conflict', () => {
const err: VerdaccioError = getConflict('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.CONFLICT);
expect(err.message).toEqual('foo');
});
test('should test bad data', () => {
const err: VerdaccioError = getBadData('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.BAD_DATA);
expect(err.message).toEqual('foo');
});
test('should test internal error custom message', () => {
const err: VerdaccioError = getInternalError('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.INTERNAL_ERROR);
expect(err.message).toEqual('foo');
});
test('should test internal error', () => {
const err: VerdaccioError = getInternalError();
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.INTERNAL_ERROR);
expect(err.message).toEqual(API_ERROR.UNKNOWN_ERROR);
});
test('should test Unauthorized message', () => {
const err: VerdaccioError = getUnauthorized('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.UNAUTHORIZED);
expect(err.message).toEqual('foo');
});
test('should test forbidden message', () => {
const err: VerdaccioError = getForbidden('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.FORBIDDEN);
expect(err.message).toEqual('foo');
});
test('should test service unavailable message', () => {
const err: VerdaccioError = getServiceUnavailable('foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.SERVICE_UNAVAILABLE);
expect(err.message).toEqual('foo');
});
test('should test custom code error message', () => {
const err: VerdaccioError = getCode(HTTP_STATUS.NOT_FOUND, 'foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.NOT_FOUND);
expect(err.message).toEqual('foo');
});
test('should test custom code ok message', () => {
const err: VerdaccioError = getCode(HTTP_STATUS.OK, 'foo');
expect(err.code).toBeDefined();
expect(err.code).toEqual(HTTP_STATUS.OK);
});
});

20
packages/core/commons-api/types/lockfile.d.ts vendored
View file

@ -1,20 +0,0 @@
declare module 'lockfile' {
type Callback = (err?: Error) => void;
interface LockOptions {
wait?: number;
pollPeriod?: number;
stale?: number;
retries?: number;
retryWait?: number;
}
interface LockFileExport {
lock(fileName: string, opts: LockOptions, cb: Callback): void;
unlock(fileName: string, cb: Callback): void;
}
const lockFileExport: LockFileExport;
export default lockFileExport;
}

42
packages/core/core/src/constants.ts
View file

@ -1,3 +1,5 @@
import httpCodes from 'http-status-codes';
export const DEFAULT_MIN_LIMIT_PASSWORD = 3;
export const TIME_EXPIRATION_24H = '24h';
export const TIME_EXPIRATION_7D = '7d';
@ -47,3 +49,43 @@ export const HEADERS = {
WWW_AUTH: 'WWW-Authenticate',
GZIP: 'gzip',
};
export const HTTP_STATUS = {
OK: httpCodes.OK,
CREATED: httpCodes.CREATED,
MULTIPLE_CHOICES: httpCodes.MULTIPLE_CHOICES,
NOT_MODIFIED: httpCodes.NOT_MODIFIED,
BAD_REQUEST: httpCodes.BAD_REQUEST,
UNAUTHORIZED: httpCodes.UNAUTHORIZED,
FORBIDDEN: httpCodes.FORBIDDEN,
NOT_FOUND: httpCodes.NOT_FOUND,
CONFLICT: httpCodes.CONFLICT,
NOT_IMPLEMENTED: httpCodes.NOT_IMPLEMENTED,
UNSUPPORTED_MEDIA: httpCodes.UNSUPPORTED_MEDIA_TYPE,
BAD_DATA: httpCodes.UNPROCESSABLE_ENTITY,
INTERNAL_ERROR: httpCodes.INTERNAL_SERVER_ERROR,
SERVICE_UNAVAILABLE: httpCodes.SERVICE_UNAVAILABLE,
LOOP_DETECTED: 508,
};
export const ERROR_CODE = {
token_required: 'token is required',
};
export const API_MESSAGE = {
PKG_CREATED: 'created new package',
PKG_CHANGED: 'package changed',
PKG_REMOVED: 'package removed',
PKG_PUBLISHED: 'package published',
TARBALL_UPLOADED: 'tarball uploaded successfully',
TARBALL_REMOVED: 'tarball removed',
TAG_UPDATED: 'tags updated',
TAG_REMOVED: 'tag removed',
TAG_ADDED: 'package tagged',
LOGGED_OUT: 'Logged out',
};
export const LOG_STATUS_MESSAGE =
"@{status}, user: @{user}(@{remoteIP}), req: '@{request.method} @{request.url}'";
export const LOG_VERDACCIO_ERROR = `${LOG_STATUS_MESSAGE}, error: @{!error}`;
export const LOG_VERDACCIO_BYTES = `${LOG_STATUS_MESSAGE}, bytes: @{bytes.in}/@{bytes.out}`;

57
packages/core/core/src/error-utils.ts
View file

@ -1,48 +1,5 @@
import createError, { HttpError } from 'http-errors';
import httpCodes from 'http-status-codes';
import { DEFAULT_MIN_LIMIT_PASSWORD } from './constants';
export const HTTP_STATUS = {
OK: httpCodes.OK,
CREATED: httpCodes.CREATED,
MULTIPLE_CHOICES: httpCodes.MULTIPLE_CHOICES,
NOT_MODIFIED: httpCodes.NOT_MODIFIED,
BAD_REQUEST: httpCodes.BAD_REQUEST,
UNAUTHORIZED: httpCodes.UNAUTHORIZED,
FORBIDDEN: httpCodes.FORBIDDEN,
NOT_FOUND: httpCodes.NOT_FOUND,
CONFLICT: httpCodes.CONFLICT,
NOT_IMPLEMENTED: httpCodes.NOT_IMPLEMENTED,
UNSUPPORTED_MEDIA: httpCodes.UNSUPPORTED_MEDIA_TYPE,
BAD_DATA: httpCodes.UNPROCESSABLE_ENTITY,
INTERNAL_ERROR: httpCodes.INTERNAL_SERVER_ERROR,
SERVICE_UNAVAILABLE: httpCodes.SERVICE_UNAVAILABLE,
LOOP_DETECTED: 508,
};
export const ERROR_CODE = {
token_required: 'token is required',
};
export const API_MESSAGE = {
PKG_CREATED: 'created new package',
PKG_CHANGED: 'package changed',
PKG_REMOVED: 'package removed',
PKG_PUBLISHED: 'package published',
TARBALL_UPLOADED: 'tarball uploaded successfully',
TARBALL_REMOVED: 'tarball removed',
TAG_UPDATED: 'tags updated',
TAG_REMOVED: 'tag removed',
TAG_ADDED: 'package tagged',
LOGGED_OUT: 'Logged out',
};
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',
};
import { DEFAULT_MIN_LIMIT_PASSWORD, HTTP_STATUS } from './constants';
export const API_ERROR = {
PASSWORD_SHORT: (passLength = DEFAULT_MIN_LIMIT_PASSWORD): string =>
@ -82,6 +39,13 @@ export const API_ERROR = {
USERNAME_ALREADY_REGISTERED: 'username is already registered',
};
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',
@ -137,8 +101,3 @@ export function getNotFound(customMessage?: string): VerdaccioError {
export function getCode(statusCode: number, customMessage: string): VerdaccioError {
return getError(statusCode, customMessage);
}
export const LOG_STATUS_MESSAGE =
"@{status}, user: @{user}(@{remoteIP}), req: '@{request.method} @{request.url}'";
export const LOG_VERDACCIO_ERROR = `${LOG_STATUS_MESSAGE}, error: @{!error}`;
export const LOG_VERDACCIO_BYTES = `${LOG_STATUS_MESSAGE}, bytes: @{bytes.in}/@{bytes.out}`;

16
packages/core/core/src/index.ts
View file

@ -7,6 +7,22 @@ import * as pluginUtils from './plugin-utils';
import * as fileUtils from './file-utils';
import * as pkgUtils from './pkg-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_MIN_LIMIT_PASSWORD,
DEFAULT_USER,
USERS,
} from './constants';
export {
fileUtils,
pkgUtils,

2
packages/core/core/test/errors.spec.ts
View file

@ -1,9 +1,9 @@
import _ from 'lodash';
import { HTTP_STATUS } from '../src/constants';
import {
getNotFound,
VerdaccioError,
HTTP_STATUS,
getConflict,
getBadData,
getInternalError,

2
packages/core/htpasswd/package.json
View file

@ -34,7 +34,7 @@
"npm": ">=6"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/file-locking": "workspace:11.0.0-alpha.3",
"apache-md5": "1.1.7",
"bcryptjs": "2.4.3",

2
packages/core/htpasswd/src/utils.ts
View file

@ -5,7 +5,7 @@ import bcrypt from 'bcryptjs';
import createError, { HttpError } from 'http-errors';
import { readFile } from '@verdaccio/file-locking';
import { Callback } from '@verdaccio/types';
import { API_ERROR, HTTP_STATUS } from '@verdaccio/commons-api';
import { API_ERROR, HTTP_STATUS } from '@verdaccio/core';
import crypt3 from './crypt3';

3
packages/core/htpasswd/tsconfig.json
View file

@ -7,9 +7,6 @@
"include": ["src/**/*"],
"exclude": ["src/**/*.test.ts"],
"references": [
{
"path": "../commons-api"
},
{
"path": "../file-locking"
}

1
packages/core/local-storage/package.json
View file

@ -37,7 +37,6 @@
"npm": ">=7"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/file-locking": "workspace:11.0.0-alpha.3",
"@verdaccio/streams": "workspace:11.0.0-6-next.4",

8
packages/core/local-storage/src/local-fs.ts
View file

@ -8,7 +8,7 @@ import _ from 'lodash';
import { UploadTarball, ReadTarball } from '@verdaccio/streams';
import { unlockFile, readFile } from '@verdaccio/file-locking';
import { Callback, Logger, Package, ILocalPackageManager, IUploadTarball } from '@verdaccio/types';
import { getCode, getInternalError, getNotFound, VerdaccioError } from '@verdaccio/commons-api';
import { VerdaccioError, errorUtils } from '@verdaccio/core';
import { unlinkPromise, rmdirPromise, readFilePromise } from './fs';
export const fileExist = 'EEXISTS';
@ -19,7 +19,7 @@ export const packageJSONFileName = 'package.json';
const debug = buildDebug('verdaccio:plugin:local-storage:local-fs');
export const fSError = function (message: string, code = 409): VerdaccioError {
const err: VerdaccioError = getCode(code, message);
const err: VerdaccioError = errorUtils.getCode(code, message);
// FIXME: we should return http-status codes here instead, future improvement
// @ts-ignore
err.code = message;
@ -118,9 +118,9 @@ export default class LocalFS implements ILocalFSPackageManager {
if (_.isNil(err) === false) {
if (err.code === resourceNotAvailable) {
return unLockCallback(getInternalError('resource temporarily unavailable'));
return unLockCallback(errorUtils.getInternalError('resource temporarily unavailable'));
} else if (err.code === noSuchFile) {
return unLockCallback(getNotFound());
return unLockCallback(errorUtils.getNotFound());
} else {
return unLockCallback(err);
}

3
packages/core/local-storage/tsconfig.json
View file

@ -7,9 +7,6 @@
"include": ["src/**/*"],
"exclude": ["src/**/*.test.ts"],
"references": [
{
"path": "../commons-api"
},
{
"path": "../file-locking"
},

2
packages/core/tarball/package.json
View file

@ -34,7 +34,7 @@
"access": "public"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/url": "workspace:11.0.0-6-next.5",
"@verdaccio/utils": "workspace:6.0.0-6-next.6",
"lodash": "4.17.21"

2
packages/core/tarball/tests/convertDistRemoteToLocalTarballUrls.spec.ts
View file

@ -1,5 +1,5 @@
import * as httpMocks from 'node-mocks-http';
import { HEADERS } from '@verdaccio/commons-api';
import { HEADERS } from '@verdaccio/core';
import { convertDistRemoteToLocalTarballUrls } from '../src';
describe('convertDistRemoteToLocalTarballUrls', () => {

3
packages/core/tarball/tsconfig.json
View file

@ -10,9 +10,6 @@
{
"path": "../../utils"
},
{
"path": "../commons-api"
},
{
"path": "../url"
}

2
packages/core/types/index.d.ts vendored
View file

@ -532,7 +532,7 @@ declare module '@verdaccio/types' {
// FIXME: error should be export type `VerdaccioError = HttpError & { code: number };`
// instead of AuthError
// but this type is on @verdaccio/commons-api and cannot be used here yet (I don't know why)
// but this type is on @verdaccio/core and cannot be used here yet (I don't know why)
interface HttpError extends Error {
status: number;
statusCode: number;

2
packages/core/url/package.json
View file

@ -34,7 +34,7 @@
"access": "public"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"debug": "4.3.2",
"lodash": "4.17.21",
"validator": "13.6.0"

2
packages/core/url/src/index.ts
View file

@ -1,7 +1,7 @@
import { URL } from 'url';
import buildDebug from 'debug';
import isURLValidator from 'validator/lib/isURL';
import { HEADERS } from '@verdaccio/commons-api';
import { HEADERS } from '@verdaccio/core';
const debug = buildDebug('verdaccio:core:url');

2
packages/core/url/tests/getPublicUrl.spec.ts
View file

@ -1,6 +1,6 @@
import * as httpMocks from 'node-mocks-http';
import { HEADERS } from '@verdaccio/commons-api';
import { HEADERS } from '@verdaccio/core';
import { getPublicUrl } from '../src';
describe('host', () => {

7
packages/core/url/tsconfig.json
View file

@ -5,10 +5,5 @@
"outDir": "./build"
},
"include": ["src/**/*"],
"exclude": ["src/**/*.test.ts"],
"references": [
{
"path": "../commons-api"
}
]
"exclude": ["src/**/*.test.ts"]
}

3
packages/hooks/package.json
View file

@ -30,7 +30,7 @@
"npm": ">=6"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/logger": "workspace:6.0.0-6-next.5",
"core-js": "3.17.2",
"debug": "4.3.2",
@ -41,7 +41,6 @@
"devDependencies": {
"@types/node": "16.9.1",
"@verdaccio/auth": "workspace:6.0.0-6-next.12",
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/types": "workspace:11.0.0-6-next.8"
},

2
packages/hooks/src/notify-request.ts
View file

@ -1,7 +1,7 @@
import buildDebug from 'debug';
import { logger } from '@verdaccio/logger';
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { HTTP_STATUS } from '@verdaccio/core';
const debug = buildDebug('verdaccio:hooks:request');
const fetch = require('undici-fetch');

3
packages/hooks/tsconfig.json
View file

@ -13,9 +13,6 @@
{
"path": "../config"
},
{
"path": "../core/commons-api"
},
{
"path": "../logger"
}

2
packages/loaders/package.json
View file

@ -18,7 +18,7 @@
"lodash": "4.17.21"
},
"devDependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/mock": "workspace:6.0.0-6-next.9",
"@verdaccio/types": "workspace:11.0.0-6-next.8"

2
packages/loaders/tsconfig.json
View file

@ -11,7 +11,7 @@
"path": "../config"
},
{
"path": "../core/commons-api"
"path": "../core/core"
},
{
"path": "../logger"

2
packages/middleware/package.json
View file

@ -40,7 +40,7 @@
"dependencies": {
"debug": "4.3.2",
"@verdaccio/auth": "workspace:6.0.0-6-next.12",
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/logger": "workspace:6.0.0-6-next.5",
"@verdaccio/utils": "workspace:6.0.0-6-next.6",
"lodash": "4.17.21"

16
packages/middleware/src/middleware.ts
View file

@ -6,7 +6,6 @@ import {
validatePackage as utilValidatePackage,
isObject,
stringToMD5,
ErrorCode,
} from '@verdaccio/utils';
import { NextFunction, Request, Response } from 'express';
@ -15,6 +14,7 @@ import { Config, Package, RemoteUser, Logger } from '@verdaccio/types';
import { logger } from '@verdaccio/logger';
import { IAuth } from '@verdaccio/auth';
import {
errorUtils,
API_ERROR,
HEADER_TYPE,
HEADERS,
@ -22,7 +22,7 @@ import {
TOKEN_BASIC,
TOKEN_BEARER,
VerdaccioError,
} from '@verdaccio/commons-api';
} from '@verdaccio/core';
import { HttpError } from 'http-errors';
import { getVersionFromTarball } from './middleware-utils';
@ -78,7 +78,7 @@ export function validateName(
} else if (utilValidateName(value)) {
next();
} else {
next(ErrorCode.getForbidden('invalid ' + name));
next(errorUtils.getForbidden('invalid ' + name));
}
}
@ -95,7 +95,7 @@ export function validatePackage(
} else if (utilValidatePackage(value)) {
next();
} else {
next(ErrorCode.getForbidden('invalid ' + name));
next(errorUtils.getForbidden('invalid ' + name));
}
}
@ -103,7 +103,7 @@ export function media(expect: string | null): any {
return function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer): void {
if (req.headers[HEADER_TYPE.CONTENT_TYPE] !== expect) {
next(
ErrorCode.getCode(
errorUtils.getCode(
HTTP_STATUS.UNSUPPORTED_MEDIA,
'wrong content-type, expect: ' +
expect +
@ -135,7 +135,7 @@ export function expectJson(
next: $NextFunctionVer
): void {
if (!isObject(req.body)) {
return next(ErrorCode.getBadRequest("can't parse incoming json"));
return next(errorUtils.getBadRequest("can't parse incoming json"));
}
next();
}
@ -148,7 +148,7 @@ export function antiLoop(config: Config): Function {
for (let i = 0; i < arr.length; i++) {
const m = arr[i].match(/\s*(\S+)\s+(\S+)/);
if (m && m[2] === config.server_id) {
return next(ErrorCode.getCode(HTTP_STATUS.LOOP_DETECTED, 'loop detected'));
return next(errorUtils.getCode(HTTP_STATUS.LOOP_DETECTED, 'loop detected'));
}
}
}
@ -183,7 +183,7 @@ export function allow(auth: IAuth): Function {
} else {
// last plugin (that's our built-in one) returns either
// cb(err) or cb(null, true), so this should never happen
throw ErrorCode.getInternalError(API_ERROR.PLUGIN_ERROR);
throw errorUtils.getInternalError(API_ERROR.PLUGIN_ERROR);
}
}
);

2
packages/mock/package.json
View file

@ -39,7 +39,7 @@
"build": "pnpm run build:js && pnpm run build:types"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/utils": "workspace:6.0.0-6-next.6",
"core-js": "3.17.2",

2
packages/mock/src/mock-api.ts
View file

@ -9,7 +9,7 @@ import {
HEADERS,
HTTP_STATUS,
TOKEN_BEARER,
} from '@verdaccio/commons-api';
} from '@verdaccio/core';
import { buildToken } from '@verdaccio/utils';
import { generateRandomHexString } from '@verdaccio/utils';
import { Package } from '@verdaccio/types';

2
packages/mock/src/server.ts
View file

@ -2,7 +2,7 @@ import assert from 'assert';
import _ from 'lodash';
import buildDebug from 'debug';
import { API_MESSAGE, HEADERS, HTTP_STATUS, TOKEN_BASIC } from '@verdaccio/commons-api';
import { API_MESSAGE, HEADERS, HTTP_STATUS, TOKEN_BASIC } from '@verdaccio/core';
import { buildToken } from '@verdaccio/utils';
import smartRequest, { PromiseAssert } from './request';

2
packages/mock/src/server_process.ts
View file

@ -1,7 +1,7 @@
import assert from 'assert';
import { fork } from 'child_process';
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { HTTP_STATUS } from '@verdaccio/core';
import { CREDENTIALS } from './constants';
import { IVerdaccioConfig, IServerProcess } from './types';

2
packages/mock/test/request.spec.ts
View file

@ -1,5 +1,5 @@
import _ from 'lodash';
import { HTTP_STATUS, VerdaccioError } from '@verdaccio/commons-api';
import { HTTP_STATUS, VerdaccioError } from '@verdaccio/core';
import smartRequest, { PromiseAssert } from '../src/request';
import { mockServer } from '../src/mock';

2
packages/node-api/package.json
View file

@ -39,7 +39,7 @@
},
"license": "MIT",
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/logger": "workspace:6.0.0-6-next.5",
"@verdaccio/server": "workspace:6.0.0-6-next.20",

2
packages/node-api/src/server.ts
View file

@ -8,7 +8,7 @@ import fs from 'fs';
import url from 'url';
import { findConfigFile, parseConfigFile } from '@verdaccio/config';
import { API_ERROR } from '@verdaccio/commons-api';
import { API_ERROR } from '@verdaccio/core';
import { ConfigRuntime, HttpsConfKeyCert, HttpsConfPfx } from '@verdaccio/types';
import { setup, logger } from '@verdaccio/logger';
import server from '@verdaccio/server';

2
packages/plugins/active-directory/package.json
View file

@ -34,7 +34,7 @@
"npm": ">=6"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"activedirectory2": "2.1.0"
},
"devDependencies": {

10
packages/plugins/active-directory/src/active-directory.ts
View file

@ -1,4 +1,4 @@
import { getForbidden, getInternalError, getUnauthorized } from '@verdaccio/commons-api';
import { errorUtils } from '@verdaccio/core';
import { Callback, IPluginAuth, Logger } from '@verdaccio/types';
import ActiveDirectory from 'activedirectory2';
@ -35,12 +35,12 @@ class ActiveDirectoryPlugin implements IPluginAuth<ActiveDirectoryConfig> {
connection.authenticate(username, password, (err, isAuthenticated): void => {
if (err) {
this.logger.warn(`AD - Active Directory authentication failed with error: ${err}`);
return cb(getInternalError(err));
return cb(errorUtils.getInternalError(err));
}
if (!isAuthenticated) {
this.logger.warn(NotAuthMessage);
return cb(getUnauthorized(NotAuthMessage));
return cb(errorUtils.getUnauthorized(NotAuthMessage));
}
const { groupName } = this.config;
@ -51,7 +51,7 @@ class ActiveDirectoryPlugin implements IPluginAuth<ActiveDirectoryConfig> {
connection.getGroupMembershipForUser(username, (err, groups: object[]): void => {
if (err) {
this.logger.warn(`AD - Active Directory group check failed with error: ${err}`);
return cb(getInternalError(err as unknown as string));
return cb(errorUtils.getInternalError(err as unknown as string));
}
const requestedGroups = Array.isArray(groupName) ? groupName : [groupName];
@ -69,7 +69,7 @@ class ActiveDirectoryPlugin implements IPluginAuth<ActiveDirectoryConfig> {
)}`;
this.logger.warn(notMemberMessage);
cb(getForbidden(notMemberMessage));
cb(errorUtils.getForbidden(notMemberMessage));
} else {
this.logger.info(
`AD - Active Directory authentication succeeded in group(s): ${matchingGroups.join(

2
packages/plugins/active-directory/tests/active-directory.test.ts
View file

@ -1,5 +1,5 @@
import ActiveDirectory from 'activedirectory2';
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { HTTP_STATUS } from '@verdaccio/core';
import ActiveDirectoryPlugin, { NotAuthMessage } from '../src/active-directory';

2
packages/plugins/auth-memory/package.json
View file

@ -32,7 +32,7 @@
},
"dependencies": {
"debug": "4.3.2",
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4"
"@verdaccio/core": "workspace:6.0.0-6-next.1"
},
"devDependencies": {
"@verdaccio/types": "workspace:11.0.0-6-next.8"

22
packages/plugins/auth-memory/src/Memory.ts
View file

@ -7,13 +7,7 @@ import {
RemoteUser,
Logger,
} from '@verdaccio/types';
import {
getConflict,
getForbidden,
getNotFound,
getUnauthorized,
API_ERROR,
} from '@verdaccio/commons-api';
import { errorUtils, API_ERROR } from '@verdaccio/core';
import { VerdaccioMemoryConfig, Users, UserMemory } from './types';
@ -46,7 +40,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
}
if (password !== userCredentials.password) {
const err = getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD);
const err = errorUtils.getUnauthorized(API_ERROR.BAD_USERNAME_PASSWORD);
debug('password invalid for: %o', user);
return done(err);
@ -66,7 +60,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
if (this._app_config.max_users) {
if (Object.keys(this._users).length >= this._app_config.max_users) {
const err = getConflict(API_ERROR.MAX_USERS_REACHED);
const err = errorUtils.getConflict(API_ERROR.MAX_USERS_REACHED);
debug(API_ERROR.MAX_USERS_REACHED);
return done(err);
}
@ -93,7 +87,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
debug('user changed password succeeded for %o', user?.name);
cb(null, user);
} else {
const err = getNotFound('user not found');
const err = errorUtils.getNotFound('user not found');
this._logger.debug({ user: username }, 'change password user @{user} not found');
debug('change password user for %o not found', user?.name);
return cb(err);
@ -109,7 +103,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
}
if (!user?.name) {
const err = getForbidden('not allowed to access package');
const err = errorUtils.getForbidden('not allowed to access package');
this._logger.debug({ user: user.name }, 'user: @{user} not allowed to access package');
debug('%o not allowed to access package err', user?.name, err.message);
return cb(err);
@ -120,7 +114,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
return cb(null, true);
}
const err = getForbidden('not allowed to access package');
const err = errorUtils.getForbidden('not allowed to access package');
debug('%o not allowed to access package err', user?.name, err?.message);
return cb(err);
}
@ -132,7 +126,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
}
if (!user?.name) {
const err = getForbidden('not allowed to publish package');
const err = errorUtils.getForbidden('not allowed to publish package');
debug('%o not allowed to publish package err %o', user?.name, err.message);
return cb(err);
}
@ -141,7 +135,7 @@ export default class Memory implements IPluginAuth<VerdaccioMemoryConfig> {
return cb(null, true);
}
const err = getForbidden('not allowed to publish package');
const err = errorUtils.getForbidden('not allowed to publish package');
debug('%o not allowed to publish package err %o', user?.name, err.message);
return cb(err);

2
packages/plugins/aws-storage/package.json
View file

@ -31,7 +31,7 @@
"main": "build/index.js",
"types": "build/index.d.ts",
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/streams": "workspace:11.0.0-6-next.4",
"aws-sdk": "2.981.0"
},

10
packages/plugins/aws-storage/src/index.ts
View file

@ -7,7 +7,7 @@ import {
Token,
TokenFilter,
} from '@verdaccio/types';
import { getInternalError, VerdaccioError, getServiceUnavailable } from '@verdaccio/commons-api';
import { errorUtils, VerdaccioError } from '@verdaccio/core';
import { S3 } from 'aws-sdk';
import { S3Config } from './config';
@ -149,7 +149,7 @@ export default class S3Database implements IPluginStorage<S3Config> {
data = await this.get();
} catch (err) {
this.logger.error({ err }, 's3: [remove] error: @{err}');
throw getInternalError('something went wrong on remove a package');
throw errorUtils.getInternalError('something went wrong on remove a package');
}
const pkgName = data.indexOf(name);
@ -252,18 +252,18 @@ export default class S3Database implements IPluginStorage<S3Config> {
public saveToken(token: Token): Promise<void> {
this.logger.warn({ token }, 'save token has not been implemented yet @{token}');
return Promise.reject(getServiceUnavailable('[saveToken] method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('[saveToken] method not implemented'));
}
public deleteToken(user: string, tokenKey: string): Promise<void> {
this.logger.warn({ tokenKey, user }, 'delete token has not been implemented yet @{user}');
return Promise.reject(getServiceUnavailable('[deleteToken] method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('[deleteToken] method not implemented'));
}
public readTokens(filter: TokenFilter): Promise<Token[]> {
this.logger.warn({ filter }, 'read tokens has not been implemented yet @{filter}');
return Promise.reject(getServiceUnavailable('[readTokens] method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('[readTokens] method not implemented'));
}
}

24
packages/plugins/aws-storage/src/s3Errors.ts
View file

@ -1,20 +1,12 @@
import { AWSError } from 'aws-sdk';
import {
getNotFound,
getCode,
getInternalError,
getConflict,
API_ERROR,
HTTP_STATUS,
VerdaccioError,
} from '@verdaccio/commons-api';
import { errorUtils, API_ERROR, HTTP_STATUS, VerdaccioError } from '@verdaccio/core';
export function is404Error(err: VerdaccioError): boolean {
return err.code === HTTP_STATUS.NOT_FOUND;
}
export function create404Error(): VerdaccioError {
return getNotFound('no such package available');
return errorUtils.getNotFound('no such package available');
}
export function is409Error(err: VerdaccioError): boolean {
@ -22,7 +14,7 @@ export function is409Error(err: VerdaccioError): boolean {
}
export function create409Error(): VerdaccioError {
return getConflict('file already exists');
return errorUtils.getConflict('file already exists');
}
export function is503Error(err: VerdaccioError): boolean {
@ -30,19 +22,19 @@ export function is503Error(err: VerdaccioError): boolean {
}
export function create503Error(): VerdaccioError {
return getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, 'resource temporarily unavailable');
return errorUtils.getCode(HTTP_STATUS.SERVICE_UNAVAILABLE, 'resource temporarily unavailable');
}
export function convertS3Error(err: AWSError): VerdaccioError {
switch (err.code) {
case 'NoSuchKey':
case 'NotFound':
return getNotFound();
return errorUtils.getNotFound();
case 'StreamContentLengthMismatch':
return getInternalError(API_ERROR.CONTENT_MISMATCH);
return errorUtils.getInternalError(API_ERROR.CONTENT_MISMATCH);
case 'RequestAbortedError':
return getInternalError('request aborted');
return errorUtils.getInternalError('request aborted');
default:
return getCode(err.statusCode!, err.message);
return errorUtils.getCode(err.statusCode!, err.message);
}
}

2
packages/plugins/aws-storage/src/s3PackageManager.ts
View file

@ -1,6 +1,6 @@
import { S3, AWSError } from 'aws-sdk';
import { UploadTarball, ReadTarball } from '@verdaccio/streams';
import { HEADERS, HTTP_STATUS, VerdaccioError } from '@verdaccio/commons-api';
import { HEADERS, HTTP_STATUS, VerdaccioError } from '@verdaccio/core';
import { Callback, Logger, Package, ILocalPackageManager, CallbackAction } from '@verdaccio/types';
import { HttpError } from 'http-errors';

2
packages/plugins/google-cloud-storage/package.json
View file

@ -33,7 +33,7 @@
"dependencies": {
"@google-cloud/datastore": "6.5.0",
"@google-cloud/storage": "5.14.0",
"@verdaccio/commons-api": "11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/streams": "workspace:11.0.0-6-next.4"
},
"devDependencies": {

18
packages/plugins/google-cloud-storage/src/data-storage.ts
View file

@ -1,6 +1,6 @@
import { Storage } from '@google-cloud/storage';
import { Datastore, DatastoreOptions } from '@google-cloud/datastore';
import { getServiceUnavailable, getInternalError, VerdaccioError } from '@verdaccio/commons-api';
import { errorUtils, VerdaccioError } from '@verdaccio/core';
import {
Logger,
Callback,
@ -87,19 +87,19 @@ class GoogleCloudDatabase implements IPluginStorage<VerdaccioConfigGoogleStorage
public saveToken(token: Token): Promise<void> {
this.logger.warn({ token }, 'save token has not been implemented yet @{token}');
return Promise.reject(getServiceUnavailable('[saveToken] method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('[saveToken] method not implemented'));
}
public deleteToken(user: string, tokenKey: string): Promise<void> {
this.logger.warn({ tokenKey, user }, 'delete token has not been implemented yet @{user}');
return Promise.reject(getServiceUnavailable('[deleteToken] method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('[deleteToken] method not implemented'));
}
public readTokens(filter: TokenFilter): Promise<Token[]> {
this.logger.warn({ filter }, 'read tokens has not been implemented yet @{filter}');
return Promise.reject(getServiceUnavailable('[readTokens] method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('[readTokens] method not implemented'));
}
public getSecret(): Promise<string> {
@ -119,10 +119,10 @@ class GoogleCloudDatabase implements IPluginStorage<VerdaccioConfigGoogleStorage
return entities.secret;
})
.catch((err: Error): Promise<string> => {
const error: VerdaccioError = getInternalError(err.message);
const error: VerdaccioError = errorUtils.getInternalError(err.message);
this.logger.warn({ error }, 'gcloud: [datastore getSecret] init error @{error}');
return Promise.reject(getServiceUnavailable('[getSecret] permissions error'));
return Promise.reject(errorUtils.getServiceUnavailable('[getSecret] permissions error'));
});
}
@ -160,10 +160,10 @@ class GoogleCloudDatabase implements IPluginStorage<VerdaccioConfigGoogleStorage
resolve();
})
.catch((err: Error): void => {
const error: VerdaccioError = getInternalError(err.message);
const error: VerdaccioError = errorUtils.getInternalError(err.message);
this.logger.debug({ error }, 'gcloud: [datastore add] @{name} error @{error}');
reject(getInternalError(error.message));
reject(errorUtils.getInternalError(error.message));
});
});
}
@ -174,7 +174,7 @@ class GoogleCloudDatabase implements IPluginStorage<VerdaccioConfigGoogleStorage
const key = datastore.key([this.kind, datastore.int(item.id)]);
await datastore.delete(key);
} catch (err: any) {
return getInternalError(err.message);
return errorUtils.getInternalError(err.message);
}
}

45
packages/plugins/google-cloud-storage/src/storage.ts
View file

@ -13,14 +13,7 @@ import {
ReadPackageCallback,
} from '@verdaccio/types';
import { File, DownloadResponse } from '@google-cloud/storage';
import {
VerdaccioError,
getInternalError,
getBadRequest,
getNotFound,
getConflict,
HTTP_STATUS,
} from '@verdaccio/commons-api';
import { errorUtils, VerdaccioError, HTTP_STATUS } from '@verdaccio/core';
import { Response } from 'request';
import { IStorageHelper } from './storage-helper';
@ -30,7 +23,7 @@ export const pkgFileName = 'package.json';
export const defaultValidation = 'crc32c';
const packageAlreadyExist = function (name: string): VerdaccioError {
return getConflict(`${name} package already exist`);
return errorUtils.getConflict(`${name} package already exist`);
};
class GoogleCloudStorageHandler implements IPackageStorageManager {
@ -78,7 +71,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
{ name: name, err: err.message },
'gcloud: on write update @{name} package has failed err: @{err}'
);
return onEnd(getInternalError(err.message));
return onEnd(errorUtils.getInternalError(err.message));
}
});
},
@ -87,7 +80,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
{ name: name, err: err.message },
'gcloud: update @{name} package has failed err: @{err}'
);
onEnd(getInternalError(err.message));
onEnd(errorUtils.getInternalError(err.message));
}
)
.catch((err: Error): Callback => {
@ -96,7 +89,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
'gcloud: trying to update @{name} and was not found on storage err: @{error}'
);
// @ts-ignore
return onEnd(getNotFound());
return onEnd(errorUtils.getNotFound());
});
}
@ -123,14 +116,14 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
{ name: file.name, err: err.message },
'gcloud: delete @{name} file has failed err: @{err}'
);
reject(getInternalError(err.message));
reject(errorUtils.getInternalError(err.message));
});
} catch (err: any) {
this.logger.error(
{ name: file.name, err: err.message },
'gcloud: delete @{name} file has failed err: @{err}'
);
reject(getInternalError('something went wrong'));
reject(errorUtils.getInternalError('something went wrong'));
}
});
}
@ -154,7 +147,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
{ name: file.name, err: err.message },
'gcloud: delete @{name} package has failed err: @{err}'
);
reject(getInternalError(err.message));
reject(errorUtils.getInternalError(err.message));
}
);
});
@ -177,7 +170,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
{ name: name, err: err.message },
'gcloud: create package @{name} has failed err: @{err}'
);
cb(getInternalError(err.message));
cb(errorUtils.getInternalError(err.message));
}
);
}
@ -217,7 +210,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
});
resolve(null);
} catch (err: any) {
reject(getInternalError(err.message));
reject(errorUtils.getInternalError(err.message));
}
});
}
@ -263,7 +256,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
'gcloud: check exist package @{name} has failed, cause: @{err}'
);
reject(getInternalError(err.message));
reject(errorUtils.getInternalError(err.message));
}
});
}
@ -280,7 +273,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
resolve(response);
} catch (err: any) {
this.logger.debug({ name: this.name }, 'gcloud: @{name} package not found on storage');
reject(getNotFound());
reject(errorUtils.getNotFound());
}
});
}
@ -324,7 +317,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
// [BadRequestError: Could not authenticate request
// getaddrinfo ENOTFOUND www.googleapis.com www.googleapis.com:443]
if (err) {
uploadStream.emit('error', getBadRequest(err.message));
uploadStream.emit('error', errorUtils.getBadRequest(err.message));
fileStream.emit('close');
}
};
@ -340,7 +333,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
fileStream.on('error', (err: Error): void => {
this.logger.error({ url: file.name }, 'gcloud: upload stream has failed for @{url}');
fileStream.end();
uploadStream.emit('error', getBadRequest(err.message));
uploadStream.emit('error', errorUtils.getBadRequest(err.message));
});
uploadStream.abort = (): void => {
@ -356,7 +349,7 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
}
},
(err: Error): void => {
uploadStream.emit('error', getInternalError(err.message));
uploadStream.emit('error', errorUtils.getInternalError(err.message));
}
);
} catch (err: any) {
@ -379,13 +372,13 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
.on('error', (err: VerdaccioError): void => {
if (err.code === HTTP_STATUS.NOT_FOUND) {
this.logger.debug({ url: file.name }, 'gcloud: tarball @{url} do not found on storage');
localReadStream.emit('error', getNotFound());
localReadStream.emit('error', errorUtils.getNotFound());
} else {
this.logger.error(
{ url: file.name },
'gcloud: tarball @{url} has failed to be retrieved from storage'
);
localReadStream.emit('error', getBadRequest(err.message));
localReadStream.emit('error', errorUtils.getBadRequest(err.message));
}
})
.on('response', (response): void => {
@ -401,13 +394,13 @@ class GoogleCloudStorageHandler implements IPackageStorageManager {
{ url: file.name },
'gcloud: tarball @{url} was fetched from storage and it is empty'
);
localReadStream.emit('error', getInternalError('file content empty'));
localReadStream.emit('error', errorUtils.getInternalError('file content empty'));
} else if (parseInt(size, 10) > 0 && statusCode === HTTP_STATUS.OK) {
localReadStream.emit('content-length', response.headers['content-length']);
}
} else {
this.logger.debug({ url: file.name }, 'gcloud: tarball @{url} do not found on storage');
localReadStream.emit('error', getNotFound());
localReadStream.emit('error', errorUtils.getNotFound());
}
})
.pipe(localReadStream);

3
packages/plugins/google-cloud-storage/tests/datastore.spec.ts
View file

@ -1,7 +1,6 @@
import _ from 'lodash';
import { Logger, ILocalPackageManager } from '@verdaccio/types';
import { VerdaccioError } from '@verdaccio/commons-api';
import { HTTP_STATUS } from '@verdaccio/commons-api';
import { VerdaccioError, HTTP_STATUS } from '@verdaccio/core';
import { ERROR_MISSING_CONFIG } from '../src/data-storage';
import { VerdaccioConfigGoogleStorage } from '../src/types';

2
packages/plugins/google-cloud-storage/tests/storage.spec.ts
View file

@ -5,7 +5,7 @@ import { Writable } from 'stream';
import { DownloadResponse } from '@google-cloud/storage';
import { IPackageStorageManager } from '@verdaccio/types';
import { Logger, ILocalData, Callback, Package, IPackageStorage } from '@verdaccio/types';
import { HTTP_STATUS, API_ERROR, VerdaccioError } from '@verdaccio/commons-api';
import { HTTP_STATUS, API_ERROR, VerdaccioError } from '@verdaccio/core';
import { pkgFileName } from '../src/storage';
import { VerdaccioConfigGoogleStorage } from '../src/types';

2
packages/plugins/memory/package.json
View file

@ -31,7 +31,7 @@
"npm": ">=6"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/streams": "workspace:11.0.0-6-next.4",
"memory-fs": "0.5.0",
"debug": "4.3.2",

8
packages/plugins/memory/src/local-memory.ts
View file

@ -1,4 +1,4 @@
import { getServiceUnavailable } from '@verdaccio/commons-api';
import { errorUtils } from '@verdaccio/core';
import { Logger, Callback, Config, IPluginStorage, Token, PluginOptions } from '@verdaccio/types';
import buildDebug from 'debug';
@ -107,7 +107,7 @@ class LocalMemory implements IPluginStorage<ConfigMemory> {
public saveToken(): Promise<void> {
this.logger.warn('[verdaccio/memory][saveToken] save token has not been implemented yet');
return Promise.reject(getServiceUnavailable('method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('method not implemented'));
}
public deleteToken(user: string, tokenKey: string): Promise<void> {
@ -116,13 +116,13 @@ class LocalMemory implements IPluginStorage<ConfigMemory> {
'[verdaccio/memory][deleteToken] delete token has not been implemented yet @{user}'
);
return Promise.reject(getServiceUnavailable('method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('method not implemented'));
}
public readTokens(): Promise<Token[]> {
this.logger.warn('[verdaccio/memory][readTokens] read tokens has not been implemented yet ');
return Promise.reject(getServiceUnavailable('method not implemented'));
return Promise.reject(errorUtils.getServiceUnavailable('method not implemented'));
}
}

24
packages/plugins/memory/src/memory-handler.ts
View file

@ -1,11 +1,5 @@
import buildDebug from 'debug';
import {
VerdaccioError,
getBadRequest,
getInternalError,
getConflict,
getNotFound,
} from '@verdaccio/commons-api';
import { VerdaccioError, errorUtils } from '@verdaccio/core';
import { fs } from 'memfs';
import { UploadTarball, ReadTarball } from '@verdaccio/streams';
import {
@ -67,7 +61,7 @@ class MemoryHandler implements IPackageStorageManager {
try {
onWrite(pkgFileName, transformPackage(pkg), onEnd);
} catch (err: any) {
return onEnd(getInternalError('error on parse the metadata'));
return onEnd(errorUtils.getInternalError('error on parse the metadata'));
}
});
}
@ -92,7 +86,7 @@ class MemoryHandler implements IPackageStorageManager {
this.data[name] = stringifyPackage(value);
return cb(null);
} catch (err: any) {
return cb(getInternalError(err.message));
return cb(errorUtils.getInternalError(err.message));
}
}
@ -102,9 +96,9 @@ class MemoryHandler implements IPackageStorageManager {
const isJson = typeof json === 'undefined';
try {
return cb(isJson ? getNotFound() : null, parsePackage(json));
return cb(isJson ? errorUtils.getNotFound() : null, parsePackage(json));
} catch (err: any) {
return cb(getNotFound());
return cb(errorUtils.getNotFound());
}
}
@ -116,7 +110,7 @@ class MemoryHandler implements IPackageStorageManager {
process.nextTick(function () {
fs.stat(temporalName, function (fileError, stats) {
if (!fileError && stats) {
return uploadStream.emit('error', getConflict());
return uploadStream.emit('error', errorUtils.getConflict());
}
try {
@ -133,7 +127,7 @@ class MemoryHandler implements IPackageStorageManager {
};
uploadStream.abort = function (): void {
uploadStream.emit('error', getBadRequest('transmision aborted'));
uploadStream.emit('error', errorUtils.getBadRequest('transmision aborted'));
file.end();
};
@ -158,7 +152,7 @@ class MemoryHandler implements IPackageStorageManager {
process.nextTick(function () {
fs.stat(pathName, function (error, stats) {
if (error && !stats) {
return readTarballStream.emit('error', getNotFound());
return readTarballStream.emit('error', errorUtils.getNotFound());
}
try {
@ -172,7 +166,7 @@ class MemoryHandler implements IPackageStorageManager {
});
readTarballStream.abort = function (): void {
readStream.destroy(getBadRequest('read has been aborted'));
readStream.destroy(errorUtils.getBadRequest('read has been aborted'));
};
return;
} catch (err: any) {

12
packages/plugins/memory/test/memory.spec.ts
View file

@ -1,5 +1,5 @@
import { Logger, IPluginStorage, IPackageStorage, ILocalPackageManager } from '@verdaccio/types';
import { getInternalError } from '@verdaccio/commons-api';
import { errorUtils } from '@verdaccio/core';
import { ConfigMemory } from '../src/local-memory';
import MemoryHandler from '../src/memory-handler';
@ -76,7 +76,7 @@ describe('memory unit test .', () => {
const handler: IPackageStorage = localMemory.getPackageStorage(pkgName) as ILocalPackageManager;
handler.savePackage(pkgName, pkgExample, (err) => {
expect(err).toEqual(getInternalError('error on parse'));
expect(err).toEqual(errorUtils.getInternalError('error on parse'));
done();
});
});
@ -146,7 +146,7 @@ describe('memory unit test .', () => {
expect(handler).toBeDefined();
const onEnd = jest.fn((err) => {
expect(err).not.toBeNull();
expect(err).toEqual(getInternalError('error on parse'));
expect(err).toEqual(errorUtils.getInternalError('error on parse'));
done();
});
@ -173,7 +173,7 @@ describe('memory unit test .', () => {
expect(handler).toBeDefined();
const onEnd = jest.fn((err) => {
expect(err).not.toBeNull();
expect(err).toEqual(getInternalError('some error'));
expect(err).toEqual(errorUtils.getInternalError('some error'));
done();
});
@ -187,7 +187,7 @@ describe('memory unit test .', () => {
expect(json).toBeDefined();
expect(json.name).toBe(pkgExample.name);
expect(callback).toBeDefined();
callback(getInternalError('some error'));
callback(errorUtils.getInternalError('some error'));
},
() => {},
// @ts-ignore
@ -206,7 +206,7 @@ describe('memory unit test .', () => {
expect(handler).toBeDefined();
const onEnd = jest.fn((err) => {
expect(err).not.toBeNull();
expect(err).toEqual(getInternalError('error on parse the metadata'));
expect(err).toEqual(errorUtils.getInternalError('error on parse the metadata'));
done();
});

1
packages/proxy/package.json
View file

@ -39,7 +39,6 @@
"build": "pnpm run build:js && pnpm run build:types"
},
"dependencies": {
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/local-storage": "workspace:11.0.0-6-next.8",

13
packages/proxy/src/up-storage.ts
View file

@ -10,15 +10,18 @@ import request from 'request';
import { buildToken } from '@verdaccio/utils';
import { ReadTarball } from '@verdaccio/streams';
import {
constants,
errorUtils,
validatioUtils,
searchUtils,
TOKEN_BASIC,
TOKEN_BEARER,
HEADERS,
HTTP_STATUS,
HEADER_TYPE,
CHARACTER_ENCODING,
} from '@verdaccio/commons-api';
} from '@verdaccio/core';
import { Config, Callback, Logger, UpLinkConf, IReadTarball } from '@verdaccio/types';
import { errorUtils, validatioUtils, searchUtils } from '@verdaccio/core';
import { parseInterval } from './proxy-utils';
const LoggerApi = require('@verdaccio/logger');
@ -358,15 +361,15 @@ class ProxyStorage implements IProxy {
} else if (_.isBoolean(tokenConf.token_env) && tokenConf.token_env) {
token = process.env.NPM_TOKEN;
} else {
this.logger.error(errorUtils.ERROR_CODE.token_required);
this._throwErrorAuth(errorUtils.ERROR_CODE.token_required);
this.logger.error(constants.ERROR_CODE.token_required);
this._throwErrorAuth(constants.ERROR_CODE.token_required);
}
} else {
token = process.env.NPM_TOKEN;
}
if (_.isNil(token)) {
this._throwErrorAuth(errorUtils.ERROR_CODE.token_required);
this._throwErrorAuth(constants.ERROR_CODE.token_required);
}
// define type Auth allow basic and bearer

4
packages/proxy/test/headers.auth.spec.ts
View file

@ -1,6 +1,6 @@
import { buildToken } from '@verdaccio/utils';
import { ERROR_CODE, TOKEN_BASIC, TOKEN_BEARER, HEADERS } from '@verdaccio/commons-api';
import { constants, TOKEN_BASIC, TOKEN_BEARER, HEADERS } from '@verdaccio/core';
import { setup } from '@verdaccio/logger';
import { DEFAULT_REGISTRY } from '@verdaccio/config';
@ -150,6 +150,6 @@ describe('uplink headers auth test', () => {
expect(function () {
fnError();
}).toThrow(ERROR_CODE.token_required);
}).toThrow(constants.ERROR_CODE.token_required);
});
});

9
packages/proxy/test/proxy.error.spec.ts
View file

@ -1,8 +1,7 @@
import path from 'path';
import nock from 'nock';
import { Config, parseConfigFile } from '@verdaccio/config';
import { ErrorCode } from '@verdaccio/utils';
import { API_ERROR, HEADER_TYPE, HTTP_STATUS, VerdaccioError } from '@verdaccio/commons-api';
import { API_ERROR, HEADER_TYPE, HTTP_STATUS, VerdaccioError, errorUtils } from '@verdaccio/core';
import { ProxyStorage } from '../src/up-storage';
const getConf = (name) => path.join(__dirname, '/conf', name);
@ -81,7 +80,7 @@ describe('proxy', () => {
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
stream.on('error', (response) => {
expect(response).toEqual(ErrorCode.getNotFound(API_ERROR.NOT_FILE_UPLINK));
expect(response).toEqual(errorUtils.getNotFound(API_ERROR.NOT_FILE_UPLINK));
done();
});
});
@ -101,7 +100,7 @@ describe('proxy', () => {
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
stream.on('error', (response) => {
expect(response).toEqual(ErrorCode.getInternalError(`bad uplink status code: 409`));
expect(response).toEqual(errorUtils.getInternalError(`bad uplink status code: 409`));
done();
});
});
@ -117,7 +116,7 @@ describe('proxy', () => {
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
stream.on('error', (response) => {
expect(response).toEqual(ErrorCode.getInternalError(API_ERROR.CONTENT_MISMATCH));
expect(response).toEqual(errorUtils.getInternalError(API_ERROR.CONTENT_MISMATCH));
done();
});
});

5
packages/proxy/test/proxy.metadata.ts
View file

@ -1,8 +1,7 @@
import path from 'path';
import nock from 'nock';
import { Config, parseConfigFile } from '@verdaccio/config';
import { ErrorCode } from '@verdaccio/utils';
import { API_ERROR } from '@verdaccio/commons-api';
import { API_ERROR, errorUtils } from '@verdaccio/core';
import { ProxyStorage } from '../src/up-storage';
const getConf = (name) => path.join(__dirname, '/conf', name);
@ -82,7 +81,7 @@ describe('proxy', () => {
nock(domain).get('/jquery').reply(404);
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
prox1.getRemoteMetadata('jquery', { etag: 'rev_3333' }, (error) => {
expect(error).toEqual(ErrorCode.getNotFound(API_ERROR.NOT_PACKAGE_UPLINK));
expect(error).toEqual(errorUtils.getNotFound(API_ERROR.NOT_PACKAGE_UPLINK));
done();
});
});

11
packages/proxy/test/proxy.tarball.spec.ts
View file

@ -1,8 +1,7 @@
import path from 'path';
import nock from 'nock';
import { Config, parseConfigFile } from '@verdaccio/config';
import { ErrorCode } from '@verdaccio/utils';
import { API_ERROR, HEADER_TYPE, HTTP_STATUS, VerdaccioError } from '@verdaccio/commons-api';
import { errorUtils, API_ERROR, HEADER_TYPE, HTTP_STATUS, VerdaccioError } from '@verdaccio/core';
import { ProxyStorage } from '../src/up-storage';
const getConf = (name) => path.join(__dirname, '/conf', name);
@ -112,7 +111,7 @@ describe('proxy', () => {
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
stream.on('error', (response) => {
expect(response).toEqual(ErrorCode.getNotFound(API_ERROR.NOT_FILE_UPLINK));
expect(response).toEqual(errorUtils.getNotFound(API_ERROR.NOT_FILE_UPLINK));
done();
});
});
@ -132,7 +131,7 @@ describe('proxy', () => {
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
stream.on('error', (response) => {
expect(response).toEqual(ErrorCode.getInternalError(`bad uplink status code: 409`));
expect(response).toEqual(errorUtils.getInternalError(`bad uplink status code: 409`));
done();
});
});
@ -148,7 +147,7 @@ describe('proxy', () => {
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
const stream = prox1.fetchTarball('https://registry.npmjs.org/jquery/-/jquery-0.0.1.tgz');
stream.on('error', (response) => {
expect(response).toEqual(ErrorCode.getInternalError(API_ERROR.CONTENT_MISMATCH));
expect(response).toEqual(errorUtils.getInternalError(API_ERROR.CONTENT_MISMATCH));
done();
});
});
@ -197,7 +196,7 @@ describe('proxy', () => {
nock(domain).get('/jquery').reply(404);
const prox1 = new ProxyStorage(defaultRequestOptions, conf);
prox1.getRemoteMetadata('jquery', { etag: 'rev_3333' }, (error) => {
expect(error).toEqual(ErrorCode.getNotFound(API_ERROR.NOT_PACKAGE_UPLINK));
expect(error).toEqual(errorUtils.getNotFound(API_ERROR.NOT_PACKAGE_UPLINK));
done();
});
});

3
packages/server/package.json
View file

@ -32,7 +32,7 @@
"dependencies": {
"@verdaccio/api": "workspace:6.0.0-6-next.15",
"@verdaccio/auth": "workspace:6.0.0-6-next.12",
"@verdaccio/commons-api": "workspace:11.0.0-6-next.4",
"@verdaccio/core": "workspace:6.0.0-6-next.1",
"@verdaccio/config": "workspace:6.0.0-6-next.8",
"@verdaccio/loaders": "workspace:6.0.0-6-next.5",
"@verdaccio/logger": "workspace:6.0.0-6-next.5",
@ -52,6 +52,7 @@
"@types/node": "16.9.1",
"@verdaccio/mock": "workspace:6.0.0-6-next.9",
"@verdaccio/proxy": "workspace:6.0.0-6-next.12",
"@verdaccio/helper": "1.0.0",
"http-errors": "1.8.0",
"request": "2.87.0"
},

7
packages/server/src/server.ts
View file

@ -9,8 +9,7 @@ import { HttpError } from 'http-errors';
import { loadPlugin } from '@verdaccio/loaders';
import { Auth } from '@verdaccio/auth';
import apiEndpoint from '@verdaccio/api';
import { ErrorCode } from '@verdaccio/utils';
import { API_ERROR, HTTP_STATUS } from '@verdaccio/commons-api';
import { API_ERROR, HTTP_STATUS, errorUtils } from '@verdaccio/core';
import { Config as AppConfig } from '@verdaccio/config';
import webMiddleware from '@verdaccio/web';
@ -103,13 +102,13 @@ const defineAPI = function (config: IConfig, storage: Storage): any {
app.use(webMiddleware(config, auth, storage));
} else {
app.get('/', function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) {
next(ErrorCode.getNotFound(API_ERROR.WEB_DISABLED));
next(errorUtils.getNotFound(API_ERROR.WEB_DISABLED));
});
}
// Catch 404
app.get('/*', function (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) {
next(ErrorCode.getNotFound(API_ERROR.FILE_NOT_FOUND));
next(errorUtils.getNotFound(API_ERROR.FILE_NOT_FOUND));
});
app.use(function (

Some files were not shown because too many files have changed in this diff Show more