Merge branch 'master' into handle-dependencies-ts

Author: ricardo-devis-agullo

src/registry/domain/validators/component-parameters.js

@@ -0,0 +1,113 @@
+import strings from '../../../resources';
+import { OcParameter } from '../../../types';
+
+const validateParameter = function(
+  parameter: string | number | boolean,
+  expectedType: string
+): boolean {
+  const expected = expectedType.toLowerCase();
+
+  if (expected === 'boolean') {
+    return typeof parameter === 'boolean';
+  } else if (expected === 'number') {
+    return typeof parameter === 'number';
+  } else if (expected === 'string') {
+    return typeof parameter === 'string';
+  }
+
+  return false;
+};
+
+interface ValidationResult {
+  isValid: boolean;
+  errors: {
+    mandatory?: Dictionary<string>;
+    types?: Dictionary<string>;
+    message?: string;
+  };
+}
+
+export default function componentParameters(
+  requestParameters: Dictionary<string | number | boolean>,
+  expectedParameters: Dictionary<OcParameter> = {}
+): ValidationResult {
+  const result: ValidationResult = { isValid: true, errors: {} };
+  const mandatoryParameters: string[] = [];
+
+  for (const [expectedParameterName, expectedParameter] of Object.entries(
+    expectedParameters
+  )) {
+    if (expectedParameter.mandatory) {
+      mandatoryParameters.push(expectedParameterName);
+    }
+  }
+
+  for (const mandatoryParameterName of mandatoryParameters) {
+    if (
+      typeof requestParameters === 'object' &&
+      // eslint-disable-next-line no-prototype-builtins
+      !requestParameters.hasOwnProperty(mandatoryParameterName)
+    ) {
+      if (!result.errors.mandatory) {
+        result.errors.mandatory = {};
+        result.isValid = false;
+      }
+
+      result.errors.mandatory[mandatoryParameterName] =
+        strings.errors.registry.MANDATORY_PARAMETER_MISSING_CODE;
+    }
+  }
+
+  for (const [requestParameterName, requestParameter] of Object.entries(
+    requestParameters
+  )) {
+    if (
+      typeof expectedParameters === 'object' &&
+      // eslint-disable-next-line no-prototype-builtins
+      expectedParameters.hasOwnProperty(requestParameterName)
+    ) {
+      const expectedType = expectedParameters[requestParameterName].type;
+
+      if (!validateParameter(requestParameter, expectedType)) {
+        if (!result.errors.types) {
+          result.errors.types = {};
+          result.isValid = false;
+        }
+
+        result.errors.types[requestParameterName] =
+          strings.errors.registry.PARAMETER_WRONG_FORMAT_CODE;
+      }
+    }
+  }
+
+  result.errors.message = (function() {
+    let errorString = '';
+
+    if (Object.keys(result.errors.mandatory || {}).length > 0) {
+      const missingParams = Object.keys(result.errors.mandatory || {})
+        .map(mandatoryParameterName => mandatoryParameterName + ', ')
+        .join('')
+        .slice(0, -2);
+
+      errorString += strings.errors.registry.MANDATORY_PARAMETER_MISSING(
+        missingParams
+      );
+    }
+
+    if (Object.keys(result.errors.types || {}).length > 0) {
+      if (errorString.length > 0) {
+        errorString += '; ';
+      }
+
+      const badParams = Object.keys(result.errors.types || {})
+        .map(parameterName => parameterName + ', ')
+        .join('')
+        .slice(0, -2);
+
+      errorString += strings.errors.registry.PARAMETER_WRONG_FORMAT(badParams);
+    }
+    return errorString;
+  })();
+
+  return result;
+}

src/registry/domain/validators/component-parameters.ts

@@ -0,0 +1,24 @@
+import semver from 'semver';
+
+import ocCliVersionValidator from './oc-cli-version';
+import componentParametersValidator from './component-parameters';
+import packageJsonValidator from './package-json-validator';
+import pluginsRequirementsValidator from './plugins-requirements';
+import registryConfigurationValidator from './registry-configuration';
+
+import uploadedPackageValidator from './uploaded-package';
+import nodeVersionValidator from './node-version';
+
+export function validateComponentName(componentName: string): boolean {
+  return !/[^a-zA-Z0-9\-_]/.test(componentName) && componentName !== '_package';
+}
+export const validateComponentParameters = componentParametersValidator;
+export const validateNodeVersion = nodeVersionValidator;
+export const validateOcCliVersion = ocCliVersionValidator;
+export const validatePackage = uploadedPackageValidator;
+export const validatePackageJson = packageJsonValidator;
+export const validatePluginsRequirements = pluginsRequirementsValidator;
+export const validateRegistryConfiguration = registryConfigurationValidator;
+export function validateVersion(version: string): boolean {
+  return !!semver.valid(version);
+}

src/registry/domain/validators/index.js

@@ -2,7 +2,7 @@ import semver from 'semver';
 import fs from 'fs-extra';
 import path from 'path';
 
-const packageInfo = fs.readJSONSync(
+const packageInfo = fs.readJsonSync(
   path.join(__dirname, '..', '..', '..', '..', 'package.json')
 );
 
@@ -19,7 +19,7 @@ type ErrorResult = {
 type Result = OkResult | ErrorResult;
 
 export default function nodeVersion(
-  userAgent: string,
+  userAgent: string | undefined,
   nodeVersion: string
 ): Result {
   const baseError = (

src/registry/domain/validators/index.ts

@@ -2,7 +2,7 @@ import semver from 'semver';
 import fs from 'fs-extra';
 import path from 'path';
 
-const packageInfo = fs.readJSONSync(
+const packageInfo = fs.readJsonSync(
   path.join(__dirname, '..', '..', '..', '..', 'package.json')
 );
 
@@ -18,7 +18,7 @@ type ErrorResult = {
 };
 type Result = OkResult | ErrorResult;
 
-export default function ocCliVersion(userAgent: string): Result {
+export default function ocCliVersion(userAgent?: string): Result {
   const baseError = (
     opts: Partial<ErrorResult['error']> = {}
   ): ErrorResult => ({

src/registry/domain/validators/node-version.ts

@@ -0,0 +1,35 @@
+import strings from '../../../resources';
+
+interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+interface PkgDetails {
+  componentName: string;
+  packageJson: { name: string };
+  customValidator: (data: unknown) => ValidationResult | boolean;
+}
+
+export default function packageJsonValidator(
+  pkgDetails: PkgDetails
+): ValidationResult {
+  if (pkgDetails.packageJson.name !== pkgDetails.componentName) {
+    return {
+      isValid: false,
+      error: strings.errors.registry.COMPONENT_PUBLISHNAME_CONFLICT
+    };
+  }
+
+  let result = pkgDetails.customValidator(pkgDetails.packageJson);
+
+  if (typeof result === 'boolean') {
+    result = { isValid: result };
+
+    if (!result.isValid) {
+      result.error = 'unknown';
+    }
+  }
+
+  return result;
+}