oc 0.49.21 → 0.49.22

package/src/cli/domain/handle-dependencies/ensure-compiler-is-declared-as-devDependency.ts

@@ -1,17 +0,0 @@
-import strings from '../../../resources';
-import { Component } from '../../../types';
-
-export default function ensureCompilerIsDeclaredAsDevDependency(options: {
-  componentPath: string;
-  pkg: Component;
-  template: string;
-}): string {
-  const { componentPath, pkg, template } = options;
-  const compilerDep = `${template}-compiler`;
-  const isOk = pkg.devDependencies?.[compilerDep];
-
-  if (!isOk)
-    throw strings.errors.cli.TEMPLATE_DEP_MISSING(template, componentPath);
-
-  return compilerDep;
-}

package/src/cli/domain/handle-dependencies/get-compiler.ts

@@ -1,35 +0,0 @@
-import path from 'path';
-import { Template } from '../../../types';
-
-import cleanRequire from '../../../utils/clean-require';
-import { Logger } from '../../logger';
-import installCompiler from './install-compiler';
-
-export default function getCompiler(options: {
-  compilerDep: string;
-  componentPath: string;
-  logger: Logger;
-  pkg: { devDependencies: Record<string, string> };
-}): Promise<Template> {
-  const { compilerDep, componentPath, logger, pkg } = options;
-  const compilerPath = path.join(componentPath, 'node_modules', compilerDep);
-  const compiler = cleanRequire<Template>(compilerPath, { justTry: true });
-
-  if (compiler) {
-    return Promise.resolve(compiler);
-  }
-
-  let dependency = compilerDep;
-  if (pkg.devDependencies[compilerDep]) {
-    dependency += `@${pkg.devDependencies[compilerDep]}`;
-  }
-
-  const installOptions = {
-    compilerPath,
-    componentPath,
-    dependency,
-    logger
-  };
-
-  return installCompiler(installOptions);
-}

package/src/cli/domain/handle-dependencies/get-missing-dependencies.ts

@@ -1,17 +0,0 @@
-import path from 'path';
-import moduleExists from '../../../utils/module-exists';
-
-export default function getMissingDependencies(
-  dependencies: Record<string, string> = {}
-): string[] {
-  const missing: string[] = [];
-
-  Object.entries(dependencies).forEach(([dependency, version]) => {
-    const pathToModule = path.resolve('node_modules/', dependency);
-    if (!moduleExists(pathToModule)) {
-      missing.push(`${dependency}@${version || 'latest'}`);
-    }
-  });
-
-  return missing;
-}

package/src/cli/domain/handle-dependencies/index.ts

@@ -1,93 +0,0 @@
-import coreModules from 'builtin-modules';
-import fs from 'fs-extra';
-import path from 'path';
-
-import ensureCompilerIsDeclaredAsDevDependency from './ensure-compiler-is-declared-as-devDependency';
-import getCompiler from './get-compiler';
-import installMissingDependencies from './install-missing-dependencies';
-import linkMissingDependencies from './link-missing-dependencies';
-import isTemplateLegacy from '../../../utils/is-template-legacy';
-import strings from '../../../resources';
-import { Logger } from '../../logger';
-import { Component, Template } from '../../../types';
-
-const getComponentPackageJson = (componentPath: string): Promise<Component> =>
-  fs.readJson(path.join(componentPath, 'package.json'));
-
-const union = (a: ReadonlyArray<string>, b: ReadonlyArray<string>) => [
-  ...new Set([...a, ...b])
-];
-
-export default async function handleDependencies(options: {
-  components: string[];
-  logger: Logger;
-  useComponentDependencies?: boolean;
-}): Promise<{
-  modules: string[];
-  templates: Array<Template>;
-}> {
-  const { components, logger, useComponentDependencies } = options;
-
-  const dependencies: Record<string, string> = {};
-  const addDependencies = (componentDependencies?: Record<string, string>) =>
-    Object.entries(componentDependencies || {}).forEach(
-      ([dependency, version]) => {
-        dependencies[dependency] = version;
-      }
-    );
-
-  const templates: Record<string, Template> = {};
-  const addTemplate = (templateName: string, template: Template) => {
-    templates[templateName] = template;
-  };
-
-  const setupComponentDependencies = async (
-    componentPath: string
-  ): Promise<void> => {
-    const pkg = await getComponentPackageJson(componentPath);
-    addDependencies(pkg.dependencies);
-
-    const template = pkg.oc.files.template.type;
-    if (isTemplateLegacy(template)) {
-      return;
-    }
-
-    const compilerDep = ensureCompilerIsDeclaredAsDevDependency({
-      componentPath,
-      pkg,
-      template
-    });
-    Object.assign(options, { compilerDep });
-
-    const compiler = await getCompiler({
-      compilerDep,
-      componentPath,
-      logger,
-      pkg: pkg as { devDependencies: Record<string, string> }
-    });
-    Object.assign(options, { compiler });
-    addTemplate(template, compiler);
-  };
-
-  logger.warn(strings.messages.cli.CHECKING_DEPENDENCIES);
-
-  for (const component of components) {
-    await setupComponentDependencies(component);
-  }
-
-  const result = {
-    modules: union(coreModules, Object.keys(dependencies)).sort(),
-    templates: Object.values(templates)
-  };
-  if (useComponentDependencies) {
-    linkMissingDependencies({
-      componentPath: components[0],
-      dependencies,
-      logger
-    });
-    return result;
-  }
-
-  await installMissingDependencies({ dependencies, logger });
-  return result;
-}

package/src/cli/domain/handle-dependencies/install-compiler.ts

@@ -1,43 +0,0 @@
-import cleanRequire from '../../../utils/clean-require';
-import isTemplateValid from '../../../utils/is-template-valid';
-import * as npm from '../../../utils/npm-utils';
-import strings from '../../../resources/index';
-import { Logger } from '../../logger';
-import { Template } from '../../../types';
-
-export default async function installCompiler(options: {
-  compilerPath: string;
-  componentPath: string;
-  dependency: string;
-  logger: Logger;
-}): Promise<Template> {
-  const { compilerPath, componentPath, dependency, logger } = options;
-
-  logger.warn(strings.messages.cli.INSTALLING_DEPS(dependency, componentPath));
-
-  const npmOptions = {
-    dependency,
-    installPath: componentPath,
-    save: false,
-    silent: true,
-    usePrefix: false
-  };
-  const errorMsg = 'There was a problem while installing the compiler';
-
-  try {
-    await npm.installDependency(npmOptions);
-    logger.ok('OK');
-
-    const compiler = cleanRequire<Template>(compilerPath, { justTry: true });
-
-    if (!isTemplateValid(compiler)) {
-      throw errorMsg;
-    }
-
-    return compiler;
-  } catch (err) {
-    logger.err('FAIL');
-
-    throw errorMsg;
-  }
-}

package/src/cli/domain/handle-dependencies/install-missing-dependencies.ts

@@ -1,48 +0,0 @@
-import path from 'path';
-
-import getMissingDependencies from './get-missing-dependencies';
-import * as npm from '../../../utils/npm-utils';
-import strings from '../../../resources/index';
-import { Logger } from '../../logger';
-
-export default async function installMissingDependencies(options: {
-  dependencies: Record<string, string>;
-  logger: Logger;
-}): Promise<void> {
-  const { dependencies, logger } = options;
-
-  const missing = getMissingDependencies(dependencies);
-
-  if (!missing.length) {
-    return;
-  }
-
-  const installPath = path.resolve('.');
-
-  logger.warn(
-    strings.messages.cli.INSTALLING_DEPS(missing.join(', '), installPath)
-  );
-
-  const npmOptions = {
-    dependencies: missing,
-    installPath,
-    save: false,
-    silent: false,
-    usePrefix: true
-  };
-
-  try {
-    await npm.installDependencies(npmOptions);
-
-    if (getMissingDependencies(dependencies).length) {
-      logger.err('FAIL');
-      throw strings.errors.cli.DEPENDENCIES_INSTALL_FAIL;
-    }
-
-    logger.ok('OK');
-  } catch (err) {
-    logger.err('FAIL');
-    if (err) logger.err(String(err));
-    throw strings.errors.cli.DEPENDENCIES_INSTALL_FAIL;
-  }
-}

package/src/cli/domain/handle-dependencies/link-missing-dependencies.ts

@@ -1,45 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import getMissingDependencies from './get-missing-dependencies';
-import strings from '../../../resources/index';
-import stripVersion from '../../../utils/strip-version';
-import { Logger } from '../../logger';
-
-export default async function linkMissingDependencies(options: {
-  componentPath: string;
-  dependencies: Record<string, string>;
-  logger: Logger;
-}): Promise<void> {
-  const { componentPath, dependencies, logger } = options;
-
-  const missingDependencies = getMissingDependencies(dependencies);
-
-  if (!missingDependencies.length) {
-    return;
-  }
-
-  logger.warn(
-    strings.messages.cli.LINKING_DEPENDENCIES(missingDependencies.join(', ')),
-    true
-  );
-
-  const symLinkType = 'dir';
-
-  for (const dependency of missingDependencies) {
-    const moduleName = stripVersion(dependency);
-    const pathToComponentModule = path.resolve(
-      componentPath,
-      'node_modules',
-      moduleName
-    );
-    const pathToModule = path.resolve('.', 'node_modules', moduleName);
-    try {
-      await fs.ensureSymlink(pathToComponentModule, pathToModule, symLinkType);
-    } catch (err) {
-      logger.err(
-        strings.errors.cli.DEPENDENCY_LINK_FAIL(moduleName, String(err))
-      );
-      throw strings.errors.cli.DEPENDENCIES_LINK_FAIL;
-    }
-  }
-}

package/src/cli/domain/handle-dependencies/require-template.ts

@@ -1,62 +0,0 @@
-import path from 'path';
-
-import cleanRequire from '../../../utils/clean-require';
-import isTemplateLegacy from '../../../utils/is-template-legacy';
-import isTemplateValid from '../../../utils/is-template-valid';
-import strings from '../../../resources';
-import { Component } from '../../../types';
-
-interface Template {
-  compile: (
-    opts: {
-      publishPath: string;
-      componentPath: string;
-      componentPackage: any;
-      ocPackage: any;
-      minify: boolean;
-      verbose: boolean;
-      production: boolean | undefined;
-    },
-    cb: (err: Error | null, data: Component) => void
-  ) => void;
-}
-
-export default function requireTemplate(
-  template: string,
-  options: { compiler: boolean; componentPath: string }
-): Template {
-  const requireOptions = options || {};
-  let ocTemplate: Template | undefined;
-
-  if (isTemplateLegacy(template)) {
-    template = `oc-template-${template}`;
-  }
-
-  if (requireOptions.compiler) {
-    template = `${template}-compiler`;
-  }
-
-  const localTemplate = path.join(__dirname, '../../node_modules', template);
-  const relativeTemplate = path.resolve('.', 'node_modules', template);
-  const componentRelativePath = path.join(
-    requireOptions.componentPath,
-    'node_modules',
-    template
-  );
-
-  [componentRelativePath, template, localTemplate, relativeTemplate].forEach(
-    pathToTry => {
-      ocTemplate = ocTemplate || cleanRequire(pathToTry, { justTry: true });
-    }
-  );
-
-  if (!ocTemplate) {
-    throw new Error(strings.errors.cli.TEMPLATE_NOT_FOUND(template));
-  }
-
-  if (!isTemplateValid(ocTemplate, requireOptions)) {
-    throw new Error(strings.errors.cli.TEMPLATE_TYPE_NOT_VALID(template));
-  }
-
-  return ocTemplate;
-}

package/src/cli/domain/init-template/index.ts

@@ -1,26 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-
-import installTemplate from './install-template';
-import * as npm from '../../../utils/npm-utils';
-import scaffold from './scaffold';
-import { Logger } from '../../logger';
-
-export default async function initTemplate(options: {
-  componentPath: string;
-  templateType: string;
-  componentName: string;
-  compiler: string;
-  logger: Logger;
-}): Promise<{ ok: true }> {
-  const { compiler, componentPath } = options;
-  const compilerPath = path.join(componentPath, 'node_modules', compiler);
-  const npmOptions = { initPath: componentPath, silent: true };
-
-  await fs.ensureDir(componentPath);
-  await npm.init(npmOptions);
-  await installTemplate(options);
-  await scaffold(Object.assign(options, { compilerPath }));
-
-  return { ok: true };
-}

package/src/cli/domain/init-template/install-template.ts

@@ -1,52 +0,0 @@
-import tryRequire from 'try-require';
-
-import isTemplateValid from '../../../utils/is-template-valid';
-import * as npm from '../../../utils/npm-utils';
-import strings from '../../../resources';
-import { Logger } from '../../logger';
-
-interface Options {
-  componentPath: string;
-  templateType: string;
-  compiler: string;
-  logger: Logger;
-}
-
-export default async function installTemplate(
-  options: Options
-): Promise<{ ok: true }> {
-  const { compiler, componentPath, logger, templateType } = options;
-  const errorMessage = 'template type not valid';
-
-  const npmOptions = {
-    dependency: compiler,
-    installPath: componentPath,
-    isDev: true,
-    save: true,
-    usePrefix: false
-  };
-
-  logger.log(strings.messages.cli.installCompiler(compiler));
-
-  try {
-    const result = await npm.installDependency(npmOptions);
-
-    const installedCompiler = tryRequire(result.dest);
-
-    if (!isTemplateValid(installedCompiler, { compiler: true })) {
-      throw errorMessage;
-    }
-    const version = installedCompiler.getInfo().version;
-    logger.log(
-      strings.messages.cli.installCompilerSuccess(
-        templateType,
-        compiler,
-        version
-      )
-    );
-
-    return { ok: true };
-  } catch (err) {
-    throw errorMessage;
-  }
-}

package/src/cli/domain/init-template/scaffold.ts

@@ -1,45 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-
-import strings from '../../../resources';
-
-interface ScaffoldOptions {
-  compiler: string;
-  compilerPath: string;
-  componentName: string;
-  componentPath: string;
-  templateType: string;
-}
-
-export default async function scaffold(
-  options: ScaffoldOptions
-): Promise<{ ok: true }> {
-  const { compiler, compilerPath, componentName, componentPath, templateType } =
-    options;
-
-  const baseComponentPath = path.join(compilerPath, 'scaffold');
-  const baseComponentFiles = path.join(baseComponentPath, 'src');
-  const compilerPackage = await fs.readJson(
-    path.join(compilerPath, 'package.json')
-  );
-
-  try {
-    await fs.copy(baseComponentFiles, componentPath);
-
-    const componentPackage = await fs.readJson(
-      path.join(componentPath, 'package.json')
-    );
-    componentPackage.name = componentName;
-    componentPackage.devDependencies[compiler] = compilerPackage.version;
-    await fs.writeJson(componentPath + '/package.json', componentPackage, {
-      spaces: 2
-    });
-
-    return { ok: true };
-  } catch (error) {
-    const url =
-      (compilerPackage.bugs && compilerPackage.bugs.url) ||
-      `the ${templateType} repo`;
-    throw strings.errors.cli.scaffoldError(url, String(error));
-  }
-}

package/src/cli/domain/local.ts

@@ -1,77 +0,0 @@
-import fs from 'fs-extra';
-import targz from 'targz';
-import { promisify } from 'util';
-
-import * as clean from './clean';
-import getComponentsByDir from './get-components-by-dir';
-import initTemplate from './init-template';
-import isTemplateLegacy from '../../utils/is-template-legacy';
-import mock from './mock';
-import packageComponents from './package-components';
-import strings from '../../resources';
-import * as validator from '../../registry/domain/validators';
-import { Logger } from '../logger';
-
-export default function local() {
-  return {
-    clean,
-    cleanup(compressedPackagePath: string): Promise<void> {
-      return fs.unlink(compressedPackagePath);
-    },
-    compress(input: string, output: string): Promise<void> {
-      return promisify(targz.compress)({
-        src: input,
-        dest: output,
-        tar: {
-          map: function (file) {
-            return Object.assign(file, {
-              name: `_package/${file.name}`
-            });
-          }
-        }
-      });
-    },
-    getComponentsByDir: getComponentsByDir(),
-    async init(options: {
-      componentName: string;
-      logger: Logger;
-      componentPath: string;
-      templateType: string;
-    }): Promise<void> {
-      const { componentName, logger } = options;
-      let { templateType } = options;
-      if (!validator.validateComponentName(componentName)) {
-        throw 'name not valid';
-      }
-
-      // LEGACY TEMPLATES WARNING
-      if (isTemplateLegacy(templateType)) {
-        const legacyName = templateType;
-        templateType = legacyName.replace(
-          legacyName,
-          `oc-template-${legacyName}`
-        );
-        logger.warn(
-          strings.messages.cli.legacyTemplateDeprecationWarning(
-            legacyName,
-            templateType
-          )
-        );
-      }
-      try {
-        await initTemplate(
-          Object.assign(options, {
-            templateType,
-            compiler: `${templateType}-compiler`
-          })
-        );
-      } catch (e) {
-        throw 'template type not valid';
-      }
-    },
-    mock: mock(),
-    package: packageComponents()
-  };
-}
-
-export type Local = ReturnType<typeof local>;

package/src/cli/domain/mock.ts

@@ -1,40 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-
-import settings from '../../resources/settings';
-
-export default function mock() {
-  return async function (params: {
-    targetType: string;
-    targetValue: string;
-    targetName: string;
-  }): Promise<void> {
-    const localConfig = await fs
-      .readJson(settings.configFile.src)
-      .catch(() => ({}));
-
-    const mockType = params.targetType + 's';
-
-    if (!localConfig.mocks) {
-      localConfig.mocks = {};
-    }
-
-    if (!localConfig.mocks[mockType]) {
-      localConfig.mocks[mockType] = {};
-    }
-
-    let pluginType = 'static';
-    if (fs.existsSync(path.resolve(params.targetValue.toString()))) {
-      pluginType = 'dynamic';
-    }
-
-    if (!localConfig.mocks[mockType][pluginType]) {
-      localConfig.mocks[mockType][pluginType] = {};
-    }
-
-    localConfig.mocks[mockType][pluginType][params.targetName] =
-      params.targetValue;
-
-    return fs.writeJson(settings.configFile.src, localConfig, { spaces: 2 });
-  };
-}

package/src/cli/domain/package-components.ts

@@ -1,61 +0,0 @@
-import fs from 'fs-extra';
-import { promisify } from 'util';
-import path from 'path';
-
-import requireTemplate from './handle-dependencies/require-template';
-import * as validator from '../../registry/domain/validators';
-import { Component } from '../../types';
-
-export interface PackageOptions {
-  componentPath: string;
-  minify?: boolean;
-  verbose?: boolean;
-  production?: boolean;
-}
-
-const packageComponents =
-  () =>
-  async (options: PackageOptions): Promise<Component> => {
-    const production = options.production;
-    const componentPath = options.componentPath;
-    const minify = options.minify === true;
-    const verbose = options.verbose === true;
-    const publishPath = path.join(componentPath, '_package');
-    const componentPackagePath = path.join(componentPath, 'package.json');
-    const ocPackagePath = path.join(__dirname, '../../../package.json');
-
-    if (!fs.existsSync(componentPackagePath)) {
-      throw new Error('component does not contain package.json');
-    } else if (!fs.existsSync(ocPackagePath)) {
-      throw new Error('error resolving oc internal dependencies');
-    }
-
-    await fs.emptyDir(publishPath);
-
-    const componentPackage: Component = await fs.readJson(componentPackagePath);
-    const ocPackage: Component = await fs.readJson(ocPackagePath);
-
-    if (!validator.validateComponentName(componentPackage.name)) {
-      throw new Error('name not valid');
-    }
-
-    const type = componentPackage.oc.files.template.type;
-    const compileOptions = {
-      publishPath,
-      componentPath,
-      componentPackage,
-      ocPackage,
-      minify,
-      verbose,
-      production
-    };
-
-    const ocTemplate = requireTemplate(type, {
-      compiler: true,
-      componentPath
-    });
-    const compile = promisify(ocTemplate.compile);
-    return compile(compileOptions);
-  };
-
-export default packageComponents;