Update types

Author: ricardo-devis-agullo

src/registry/domain/components-cache/components-list.ts

@@ -8,11 +8,11 @@ export default function componentsList(conf: Config, cdn: Cdn) {
     `${conf.storage.options.componentsDir}/components.json`;
 
   const componentsList = {
-    getFromJson: (callback: Callback<any>) =>
+    getFromJson: (callback: Callback<any, string>) =>
       cdn.getJson(filePath(), true, callback),
 
     getFromDirectories: (callback: Callback<ComponentsList, string>) => {
-      const componentsInfo = {};
+      const componentsInfo: Dictionary<string[]> = {};
 
       const getVersionsForComponent = (
         componentName: string,
@@ -49,11 +49,11 @@ export default function componentsList(conf: Config, cdn: Cdn) {
             getVersionsForComponent,
             (errors, versions) => {
               if (errors) {
-                return callback(errors, undefined as any);
+                return callback(errors as any, undefined as any);
               }
 
               components.forEach((component, i) => {
-                componentsInfo[component] = versions[i];
+                componentsInfo[component] = (versions as any)[i];
               });
 
               callback(null, {

src/registry/domain/components-cache/index.ts

@@ -5,7 +5,8 @@ import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
 import { Cdn, ComponentsList, Config } from '../../../types';
 
 export default function componentsCache(conf: Config, cdn: Cdn) {
-  let cachedComponentsList: ComponentsList, refreshLoop;
+  let cachedComponentsList: ComponentsList;
+  let refreshLoop: NodeJS.Timeout;
 
   const componentsList = getComponentsList(conf, cdn);
 
@@ -37,9 +38,13 @@ export default function componentsCache(conf: Config, cdn: Cdn) {
     callback(null, data);
   };
 
-  const returnError = (code, message, callback) => {
+  const returnError = (
+    code: string,
+    message: string,
+    callback: Callback<any, any>
+  ) => {
     eventsHandler.fire('error', { code, message });
-    return callback(code);
+    return callback(code, undefined as any);
   };
 
   return {
@@ -55,7 +60,7 @@ export default function componentsCache(conf: Config, cdn: Cdn) {
       callback(null, cachedComponentsList);
     },
 
-    load(callback) {
+    load(callback: Callback<ComponentsList>) {
       componentsList.getFromJson((jsonErr, jsonComponents) => {
         componentsList.getFromDirectories((dirErr, dirComponents) => {
           if (dirErr) {
@@ -76,7 +81,7 @@ export default function componentsCache(conf: Config, cdn: Cdn) {
         });
       });
     },
-    refresh(callback) {
+    refresh(callback: Callback<ComponentsList>) {
       clearTimeout(refreshLoop);
       componentsList.refresh((err, components) => {
         if (err) {

src/registry/domain/components-details.ts

@@ -13,7 +13,7 @@ import {
 export default function componentsDetails(conf: Config, cdn: Cdn) {
   const returnError = (
     code: string,
-    message: string,
+    message: string | Error,
     callback: (code: string) => void
   ) => {
     eventsHandler.fire('error', { code, message });
@@ -23,12 +23,12 @@ export default function componentsDetails(conf: Config, cdn: Cdn) {
   const filePath = (): string =>
     `${conf.storage.options.componentsDir}/components-details.json`;
 
-  const getFromJson = (callback: Callback<ComponentsDetails>) =>
+  const getFromJson = (callback: Callback<ComponentsDetails, string>) =>
     cdn.getJson<ComponentsDetails>(filePath(), true, callback);
 
   const getFromDirectories = (
     options: { componentsList: ComponentsList; details: ComponentsDetails },
-    callback
+    callback: Callback<ComponentsDetails, Error | undefined>
   ) => {
     const details = _.extend({}, _.cloneDeep(options.details));
     details.components = details.components || {};
@@ -52,7 +52,7 @@ export default function componentsDetails(conf: Config, cdn: Cdn) {
           true,
           (err, content) => {
             if (err) {
-              return next(err);
+              return next(err as any);
             }
             details.components[name][version] = {
               publishDate: content.oc.date || 0

src/registry/domain/extract-package.ts

@@ -13,15 +13,15 @@ export default function extractPackage(
     outputFolder: string;
     packageJson: any;
   }>
-) {
-  const packageFile = files[0],
-    packagePath = path.resolve(packageFile.path),
-    packageUntarOutput = path.resolve(
-      packageFile.path,
-      '..',
-      packageFile.filename.replace('.tar.gz', '')
-    ),
-    packageOutput = path.resolve(packageUntarOutput, '_package');
+): void {
+  const packageFile: Express.Multer.File = (files as any)[0];
+  const packagePath = path.resolve(packageFile.path);
+  const packageUntarOutput = path.resolve(
+    packageFile.path,
+    '..',
+    packageFile.filename.replace('.tar.gz', '')
+  );
+  const packageOutput = path.resolve(packageUntarOutput, '_package');
 
   targz.decompress(
     {

src/registry/domain/options-sanitiser.ts

@@ -9,7 +9,7 @@ interface Input extends Partial<Omit<Config, 'beforePublish'>> {
   baseUrl: string;
 }
 
-export default function optionsSanitiser(input: Input) {
+export default function optionsSanitiser(input: Input): Config {
   const options = _.clone(input);
 
   if (!options.publishAuth) {
@@ -107,5 +107,5 @@ export default function optionsSanitiser(input: Input) {
     options.env = {};
   }
 
-  return options;
+  return options as Config;
 }

src/registry/domain/plugins-initialiser.ts

@@ -17,7 +17,9 @@ function validatePlugins(plugins: unknown[]): asserts plugins is Plugin[] {
       !_.isString((plugin as Plugin).name)
     ) {
       throw new Error(
-        strings.errors.registry.PLUGIN_NOT_VALID((plugin as Plugin).name || c)
+        strings.errors.registry.PLUGIN_NOT_VALID(
+          (plugin as Plugin).name || String(c)
+        )
       );
     }
   });
@@ -51,14 +53,17 @@ const defer = function(plugin: Plugin, cb: (err?: Error) => void) {
   return cb();
 };
 
-export function init(pluginsToRegister: unknown[], callback) {
-  const registered = {};
+export function init(
+  pluginsToRegister: unknown[],
+  callback: Callback<Dictionary<(...args: unknown[]) => void>, unknown>
+): void {
+  const registered: Dictionary<(...args: unknown[]) => void> = {};
 
   try {
     validatePlugins(pluginsToRegister);
     checkDependencies(pluginsToRegister);
   } catch (err) {
-    return callback(err);
+    return callback(err, undefined as any);
   }
 
   const dependenciesRegistered = (dependencies: string[]) => {
@@ -93,27 +98,31 @@ export function init(pluginsToRegister: unknown[], callback) {
 
     const dependencies = _.pick(registered, plugin.register.dependencies);
 
-    plugin.register.register(plugin.options || {}, dependencies, err => {
-      const pluginCallback = plugin.callback || _.noop;
-      pluginCallback(err);
-      // Overriding toString so implementation details of plugins do not
-      // leak to OC consumers
-      plugin.register.execute.toString = () => plugin.description || '';
-      registered[plugin.name] = plugin.register.execute;
-      done(err);
-    });
+    plugin.register.register(
+      plugin.options || {},
+      dependencies,
+      (err?: Error) => {
+        const pluginCallback = plugin.callback || _.noop;
+        pluginCallback(err);
+        // Overriding toString so implementation details of plugins do not
+        // leak to OC consumers
+        plugin.register.execute.toString = () => plugin.description || '';
+        registered[plugin.name] = plugin.register.execute;
+        done(err);
+      }
+    );
   };
 
   const terminator = function(err: Error) {
     if (deferredLoads.length > 0) {
       const deferredPlugins = _.clone(deferredLoads);
       deferredLoads = [];
 
-      return async.mapSeries(deferredPlugins, loadPlugin, terminator);
+      return async.mapSeries(deferredPlugins, loadPlugin, terminator as any);
     }
 
     callback(err, registered);
   };
 
-  async.mapSeries(pluginsToRegister, loadPlugin, terminator);
+  async.mapSeries(pluginsToRegister, loadPlugin, terminator as any);
 }

src/registry/domain/register-templates.ts

@@ -6,29 +6,24 @@ import _ from 'lodash';
 
 export default function registerTemplates(
   extraTemplates: Template[]
-): { templatesHash: Dictionary<Template>; templatesInfo: TemplateInfo[] } {
+): {
+  templatesHash: Dictionary<Template>;
+  templatesInfo: TemplateInfo[];
+} {
   const coreTemplates: Template[] = [
     es6Template,
     jadeTemplate,
     handlebarsTemplate
   ];
   const templates = _.union(coreTemplates, extraTemplates);
   const templatesHash = templates.reduce((hash, template) => {
-    try {
-      const type = template.getInfo().type;
-      hash[type] = template;
-      return hash;
-    } catch (err) {
-      throw err;
-    }
+    const type = template.getInfo().type;
+    hash[type] = template;
+    return hash;
   }, {} as Dictionary<Template>);
 
   const templatesInfo = templates.map(template => {
-    try {
-      return template.getInfo();
-    } catch (err) {
-      throw err;
-    }
+    return template.getInfo();
   });
 
   return {

src/registry/domain/sanitiser.ts

@@ -37,13 +37,14 @@ export function sanitiseComponentParameters(
   requestParameters: Dictionary<string | number | boolean>,
   expectedParameters: Dictionary<OcParameter>
 ): Dictionary<string | number | boolean> {
-  const result = {};
+  const result: Dictionary<string | number | boolean> = {};
 
   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;

src/registry/domain/version-handler.ts

@@ -4,7 +4,7 @@ import semverExtra from 'semver-extra';
 export function getAvailableVersion(
   requestedVersion: string | undefined,
   availableVersions: string[]
-) {
+): string | undefined {
   if (typeof requestedVersion === 'undefined') {
     requestedVersion = '';
   }
@@ -20,6 +20,6 @@ export function getAvailableVersion(
 export function validateNewVersion(
   requestedVersion: string,
   availableVersions: string[]
-) {
+): boolean {
   return !availableVersions.includes(requestedVersion);
 }

src/types.ts

@@ -168,7 +168,11 @@ export interface Config {
 }
 
 export interface Cdn {
-  getJson: <T>(filePath: string, force: boolean, cb: Callback<T>) => void;
+  getJson: <T>(
+    filePath: string,
+    force: boolean,
+    cb: Callback<T, string>
+  ) => void;
   listSubDirectories: (
     dir: string,
     cb: Callback<string[], Error & { code?: string }>
@@ -192,13 +196,17 @@ export interface Template {
 export interface Plugin {
   name: string;
   register: {
-    register: Function;
-    execute: Function;
+    register: (
+      options: unknown,
+      dependencies: unknown,
+      next: () => void
+    ) => void;
+    execute: (...args: unknown[]) => unknown;
     dependencies: string[];
   };
   description?: string;
   options?: any;
-  callback: Function;
+  callback?: (...args: unknown[]) => void;
 }
 
 declare global {