oc 0.49.21 → 0.49.23

package/src/globals.d.ts

@@ -1,103 +0,0 @@
-declare module 'oc-client';
-declare module 'try-require';
-declare module 'basic-auth-connect';
-
-declare module 'universalify' {
-  export function fromCallback<
-    Arguments extends readonly unknown[],
-    ErrorValue,
-    ReturnValue
-  >(
-    fn: (
-      ...arguments_: [
-        ...Arguments,
-        (error: ErrorValue, value: ReturnValue) => void
-      ]
-    ) => void
-  ): {
-    (...arguments_: Arguments): Promise<ReturnValue>;
-    (
-      ...arguments_: [
-        ...Arguments,
-        (error: ErrorValue, value: ReturnValue) => void
-      ]
-    ): void;
-  };
-
-  export function fromPromise<
-    Arguments extends readonly unknown[],
-    ReturnValue
-  >(
-    fn: (...arguments_: [...Arguments]) => Promise<ReturnValue>
-  ): {
-    (...arguments_: Arguments): Promise<ReturnValue>;
-    (
-      ...arguments_: [
-        ...Arguments,
-        (error: unknown, value: ReturnValue) => void
-      ]
-    ): void;
-  };
-}
-
-declare module 'semver-extra' {
-  interface SemverExtra {
-    max(versions: string[]): string;
-    maxStable(versions: string[]): string;
-    maxPrerelase(versions: string[], preRelease?: string): string;
-  }
-
-  const semverExtra: SemverExtra;
-
-  export = semverExtra;
-}
-
-declare module 'require-package-name' {
-  function requirePackageName(name: string): string;
-
-  export = requirePackageName;
-}
-declare module 'getport' {
-  function getPort(
-    start: number,
-    cb: (err: unknown, data: number) => void
-  ): void;
-
-  export = getPort;
-}
-
-declare module 'nice-cache' {
-  class Cache {
-    constructor(opt: { refreshInterval?: number; verbose?: boolean });
-
-    get(type: string, key: string): any;
-    set(type: string, key: string, data: unknown): void;
-  }
-
-  export = Cache;
-}
-
-declare module 'minimal-request' {
-  function request<T>(
-    opts: {
-      method?: string;
-      body?: unknown;
-      url: string;
-      headers?: Record<string, string | null | undefined | string[]>;
-      json?: boolean;
-    },
-    cb: (
-      err: Error | number | null,
-      body: T,
-      details: {
-        response: {
-          headers: Record<string, string>;
-        };
-      }
-    ) => void
-  ): void;
-
-  const request: Request;
-
-  export = request;
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { default as cli } from './cli/programmatic-api';
-export { default as Client } from 'oc-client';
-export { default as Registry } from './registry';

package/src/oc-cli.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-require('./cli');

package/src/registry/app-start.ts

@@ -1,75 +0,0 @@
-import colors from 'colors/safe';
-import path from 'path';
-import fs from 'fs-extra';
-import type { Repository } from './domain/repository';
-import { Config } from '../types';
-
-const packageInfo = fs.readJsonSync(
-  path.join(
-    __dirname,
-    '..',
-    'components',
-    'oc-client',
-    '_package',
-    'package.json'
-  )
-);
-
-export default async function appStart(
-  repository: Repository,
-  options: Config
-): Promise<void> {
-  if (options.local) {
-    return;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  const logger = options.verbosity ? console : { log: () => {} };
-
-  logger.log(
-    colors.yellow(
-      `Connecting to library: ${options.storage.options['bucket']}/${options.storage.options.componentsDir}`
-    )
-  );
-
-  try {
-    const componentInfo = await repository.getComponentVersions('oc-client');
-
-    logger.log(
-      colors.yellow(
-        `Ensuring oc-client@${packageInfo.version} is available on library...`
-      )
-    );
-
-    if (!componentInfo.includes(packageInfo.version)) {
-      logger.log(colors.yellow('Component not found. Publishing it...'));
-
-      const pkgInfo = {
-        outputFolder: path.resolve(
-          __dirname,
-          '../components/oc-client/_package'
-        ),
-        packageJson: packageInfo
-      };
-
-      try {
-        await repository.publishComponent(
-          pkgInfo,
-          'oc-client',
-          packageInfo.version
-        );
-        logger.log(colors.green('Component published.'));
-      } catch (err) {
-        logger.log(
-          colors.red(`Component not published: ${(err as Error).message}`)
-        );
-        throw err;
-      }
-    } else {
-      logger.log(colors.green('Component is available on library.'));
-    }
-  } catch (err) {
-    logger.log(colors.red(String(err)));
-    throw err;
-  }
-}

package/src/registry/domain/authentication.ts

@@ -1,59 +0,0 @@
-import basicAuth from 'basic-auth-connect';
-import { RequestHandler } from 'express';
-
-import strings from '../../resources/';
-import { Authentication, PublishAuthConfig } from '../../types';
-
-const basicAuthentication: Authentication<{
-  username: string;
-  password: string;
-}> = {
-  validate(authConfig) {
-    const isValid = !!authConfig.username && !!authConfig.password;
-
-    return {
-      isValid,
-      message: isValid
-        ? ''
-        : strings.errors.registry
-            .CONFIGURATION_PUBLISH_BASIC_AUTH_CREDENTIALS_MISSING
-    };
-  },
-  middleware(authConfig) {
-    return basicAuth(authConfig.username, authConfig.password);
-  }
-};
-
-const builtin: Record<string, Authentication> = {
-  basic: basicAuthentication
-};
-
-let scheme: Authentication;
-
-export function validate(authConfig: PublishAuthConfig) {
-  if (typeof authConfig.type !== 'string') {
-    scheme = authConfig.type;
-  } else if (builtin[authConfig.type]) {
-    scheme = builtin[authConfig.type];
-  } else {
-    const moduleName = `oc-auth-${authConfig.type}`;
-
-    try {
-      scheme = require(moduleName);
-    } catch (err) {
-      return {
-        isValid: false,
-        message:
-          strings.errors.registry.CONFIGURATION_PUBLISH_AUTH_MODULE_NOT_FOUND(
-            moduleName
-          )
-      };
-    }
-  }
-
-  return scheme.validate(authConfig);
-}
-
-export function middleware(authConfig: unknown): RequestHandler {
-  return scheme.middleware(authConfig);
-}

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

@@ -1,70 +0,0 @@
-import semver from 'semver';
-import pLimit from 'p-limit';
-import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
-import { ComponentsList, Config } from '../../../types';
-import { StorageAdapter } from 'oc-storage-adapters-utils';
-
-export default function componentsList(conf: Config, cdn: StorageAdapter) {
-  const filePath = (): string =>
-    `${conf.storage.options.componentsDir}/components.json`;
-
-  const componentsList = {
-    getFromJson: (): Promise<ComponentsList> => cdn.getJson(filePath(), true),
-
-    getFromDirectories: async (): Promise<ComponentsList> => {
-      const componentsInfo: Record<string, string[]> = {};
-
-      const getVersionsForComponent = async (
-        componentName: string
-      ): Promise<string[]> => {
-        const versions = await cdn.listSubDirectories(
-          `${conf.storage.options.componentsDir}/${componentName}`
-        );
-
-        return versions.sort(semver.compare);
-      };
-
-      try {
-        const components = await cdn.listSubDirectories(
-          conf.storage.options.componentsDir
-        );
-        const limit = pLimit(cdn.maxConcurrentRequests);
-
-        const versions = await Promise.all(
-          components.map(component =>
-            limit(() => getVersionsForComponent(component))
-          )
-        );
-
-        components.forEach((component, i) => {
-          componentsInfo[component] = versions[i];
-        });
-
-        return {
-          lastEdit: getUnixUTCTimestamp(),
-          components: componentsInfo
-        };
-      } catch (err: any) {
-        if (err.code === 'dir_not_found') {
-          return {
-            lastEdit: getUnixUTCTimestamp(),
-            components: {}
-          };
-        }
-        throw err;
-      }
-    },
-
-    async refresh(): Promise<ComponentsList> {
-      const components = await componentsList.getFromDirectories();
-      await componentsList.save(components);
-
-      return components;
-    },
-
-    save: (data: ComponentsList): Promise<unknown> =>
-      cdn.putFileContent(JSON.stringify(data), filePath(), true)
-  };
-
-  return componentsList;
-}

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

@@ -1,90 +0,0 @@
-import _ from 'lodash';
-import getComponentsList from './components-list';
-import eventsHandler from '../events-handler';
-import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
-import { ComponentsList, Config } from '../../../types';
-import { StorageAdapter } from 'oc-storage-adapters-utils';
-
-export default function componentsCache(conf: Config, cdn: StorageAdapter) {
-  let cachedComponentsList: ComponentsList;
-  let refreshLoop: NodeJS.Timeout;
-
-  const componentsList = getComponentsList(conf, cdn);
-
-  const poll = () =>
-    setTimeout(async () => {
-      try {
-        const data = await componentsList.getFromJson();
-
-        eventsHandler.fire('cache-poll', getUnixUTCTimestamp());
-
-        if (data.lastEdit > cachedComponentsList.lastEdit) {
-          cachedComponentsList = data;
-        }
-      } catch (err: any) {
-        eventsHandler.fire('error', {
-          code: 'components_list_get',
-          message: err?.message || String(err)
-        });
-      }
-      refreshLoop = poll();
-    }, conf.pollingInterval * 1000);
-
-  const cacheDataAndStartPolling = (data: ComponentsList) => {
-    cachedComponentsList = data;
-    refreshLoop = poll();
-
-    return data;
-  };
-
-  const throwError = (code: string, message: any) => {
-    eventsHandler.fire('error', { code, message: message?.message ?? message });
-    throw code;
-  };
-
-  return {
-    get(): ComponentsList {
-      if (!cachedComponentsList) {
-        return throwError(
-          'components_cache_empty',
-          `The component's cache was empty`
-        );
-      }
-
-      return cachedComponentsList;
-    },
-
-    async load(): Promise<ComponentsList> {
-      const dirComponents = await componentsList
-        .getFromDirectories()
-        .catch(err => throwError('components_list_get', err));
-      const jsonComponents = await componentsList
-        .getFromJson()
-        .catch(() => null);
-
-      if (
-        !jsonComponents ||
-        !_.isEqual(dirComponents.components, jsonComponents.components)
-      ) {
-        await componentsList
-          .save(dirComponents)
-          .catch(err => throwError('components_list_save', err));
-      }
-      cacheDataAndStartPolling(dirComponents);
-
-      return dirComponents;
-    },
-
-    async refresh(): Promise<ComponentsList> {
-      clearTimeout(refreshLoop);
-      try {
-        const components = await componentsList.refresh();
-        cacheDataAndStartPolling(components);
-
-        return components;
-      } catch (err) {
-        return throwError('components_cache_refresh', err);
-      }
-    }
-  };
-}

package/src/registry/domain/components-details.ts

@@ -1,96 +0,0 @@
-import pLimit from 'p-limit';
-import _ from 'lodash';
-import eventsHandler from './events-handler';
-import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
-import {
-  Component,
-  ComponentsDetails,
-  ComponentsList,
-  Config
-} from '../../types';
-import { StorageAdapter } from 'oc-storage-adapters-utils';
-
-export default function componentsDetails(conf: Config, cdn: StorageAdapter) {
-  const returnError = (code: string, message: string | Error) => {
-    eventsHandler.fire('error', {
-      code,
-      message: (message as Error)?.message ?? message
-    });
-    throw code;
-  };
-
-  const filePath = (): string =>
-    `${conf.storage.options.componentsDir}/components-details.json`;
-
-  const getFromJson = (): Promise<ComponentsDetails> =>
-    cdn.getJson(filePath(), true);
-
-  const getFromDirectories = async (options: {
-    componentsList: ComponentsList;
-    details?: ComponentsDetails;
-  }): Promise<ComponentsDetails> => {
-    const details = Object.assign({}, _.cloneDeep(options.details));
-    details.components = details.components || {};
-
-    const missing: Array<{ name: string; version: string }> = [];
-    _.each(options.componentsList.components, (versions, name) => {
-      details.components[name] = details.components[name] || {};
-      _.each(versions, version => {
-        if (!details.components[name][version]) {
-          missing.push({ name, version });
-        }
-      });
-    });
-
-    const limit = pLimit(cdn.maxConcurrentRequests);
-
-    await Promise.all(
-      missing.map(({ name, version }) =>
-        limit(async () => {
-          const content: Component = await cdn.getJson(
-            `${conf.storage.options.componentsDir}/${name}/${version}/package.json`,
-            true
-          );
-          details.components[name][version] = {
-            publishDate: content.oc.date || 0
-          };
-        })
-      )
-    );
-
-    return {
-      lastEdit: getUnixUTCTimestamp(),
-      components: details.components
-    };
-  };
-
-  const save = (data: ComponentsDetails): Promise<unknown> =>
-    cdn.putFileContent(JSON.stringify(data), filePath(), true);
-
-  const refresh = async (
-    componentsList: ComponentsList
-  ): Promise<ComponentsDetails> => {
-    const jsonDetails = await getFromJson().catch(() => undefined);
-    const dirDetails = await getFromDirectories({
-      componentsList,
-      details: jsonDetails
-    }).catch(err => returnError('components_details_get', err));
-
-    if (
-      !jsonDetails ||
-      !_.isEqual(dirDetails.components, jsonDetails.components)
-    ) {
-      await save(dirDetails).catch(err =>
-        returnError('components_details_save', err)
-      );
-      return dirDetails;
-    }
-
-    return jsonDetails;
-  };
-
-  return {
-    get: getFromJson,
-    refresh
-  };
-}

package/src/registry/domain/events-handler.ts

@@ -1,86 +0,0 @@
-import { IncomingHttpHeaders } from 'http';
-import strings from '../../resources';
-
-type Subscription<T = any> = (data: T) => void;
-let subscriptions: Record<string, Array<Subscription>> = {};
-
-export interface RequestData {
-  body: unknown;
-  duration: number;
-  headers: IncomingHttpHeaders;
-  method: string;
-  path: string;
-  relativeUrl: string;
-  query: Record<string, unknown>;
-  url: string;
-  statusCode: number;
-  errorDetails?: string;
-  errorCode?: string;
-}
-
-type Events = {
-  error: { code: string; message: string };
-  start: unknown;
-  'cache-poll': number;
-  request: RequestData;
-  'component-retrieved': {
-    headers: IncomingHttpHeaders;
-    name: string;
-    parameters: IncomingHttpHeaders;
-    requestVersion: string;
-    duration: number;
-  };
-};
-
-type EventsHandler = {
-  fire<T extends keyof Events>(eventName: T, data: Events[T]): void;
-  on<T extends keyof Events>(
-    eventName: T,
-    listener: Subscription<Events[T]>
-  ): void;
-  off<T extends keyof Events>(
-    eventName: T,
-    listener: Subscription<Events[T]>
-  ): void;
-  reset(): void;
-};
-
-const eventsHandler: EventsHandler = {
-  fire(eventName: string, eventData: unknown): void {
-    if (subscriptions[eventName]) {
-      subscriptions[eventName].forEach(callback => {
-        callback(eventData);
-      });
-    }
-  },
-
-  on(eventName: string, callback: Subscription): void {
-    if (typeof callback !== 'function') {
-      throw strings.errors.registry.CONFIGURATION_ONREQUEST_MUST_BE_FUNCTION;
-    }
-
-    if (!subscriptions[eventName]) {
-      subscriptions[eventName] = [];
-    }
-
-    subscriptions[eventName].push(callback);
-  },
-
-  off(eventName: string, callback: Subscription): void {
-    if (typeof callback !== 'function') {
-      throw strings.errors.registry.CONFIGURATION_OFFREQUEST_MUST_BE_FUNCTION;
-    }
-
-    if (subscriptions[eventName]) {
-      subscriptions[eventName] = subscriptions[eventName].filter(
-        sub => sub !== callback
-      );
-    }
-  },
-
-  reset(): void {
-    subscriptions = {};
-  }
-};
-
-export default eventsHandler;

package/src/registry/domain/extract-package.ts

@@ -1,45 +0,0 @@
-import path from 'path';
-import targz from 'targz';
-import { promisify } from 'util';
-
-import getPackageJsonFromTempDir from './get-package-json-from-temp-dir';
-import { Component } from '../../types';
-
-export default async function extractPackage(
-  files:
-    | Express.Multer.File[]
-    | {
-        [fieldname: string]: Express.Multer.File[];
-      },
-  tarExtractMode: number
-): Promise<{
-  outputFolder: string;
-  packageJson: Component;
-}> {
-  const packageFile = (files as Express.Multer.File[])[0];
-  const packagePath = path.resolve(packageFile.path);
-  const packageUntarOutput = path.resolve(
-    packageFile.path,
-    '..',
-    packageFile.filename.replace('.tar.gz', '')
-  );
-  const packageOutput = path.resolve(packageUntarOutput, '_package');
-
-  const decompress = promisify(targz.decompress);
-
-  await decompress({
-    src: packagePath,
-    dest: packageUntarOutput,
-    tar: {
-      dmode: tarExtractMode,
-      fmode: tarExtractMode
-    }
-  });
-
-  const packageJson = await getPackageJsonFromTempDir(packageOutput);
-
-  return {
-    outputFolder: packageOutput,
-    packageJson
-  };
-}

package/src/registry/domain/get-package-json-from-temp-dir.ts

@@ -1,9 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { Component } from '../../types';
-
-export default function getPackageJsonFromTempDir(
-  tempDirPath: string
-): Promise<Component> {
-  return fs.readJson(path.join(tempDirPath, 'package.json'));
-}