aberlaas 2.2.0 → 2.4.0

package/commands/init/index.js

@@ -1,43 +1,189 @@
 import _ from 'golgoth/lodash.js';
-import pMapSeries from 'golgoth/pMapSeries.js';
 import isFile from 'firost/isFile.js';
 import copy from 'firost/copy.js';
+import move from 'firost/move.js';
 import readJson from 'firost/readJson.js';
 import writeJson from 'firost/writeJson.js';
-import exists from 'firost/exists.js';
+import firostError from 'firost/error.js';
 import read from 'firost/read.js';
 import write from 'firost/write.js';
 import run from 'firost/run.js';
 import spinner from 'firost/spinner.js';
 import helper from '../../helper.js';
-import path from 'path';
 import nodeConfig from '../../configs/node.cjs';
 import consoleInfo from 'firost/consoleInfo.js';
 import Gilmore from 'gilmore';
 
 export default {
   /**
-   * Copy a config template to the host
-   * @param {string} source Path to source file, relative to aberlaas
-   * @param {string} destination Path to destination file, relative to the host
-   * @returns {boolean} False if can't copy file, true otherwise
+   * Configure git hooks to use scripts/hooks instead of .git/hooks
    **/
-  async copyToHost(source, destination) {
-    const absoluteSource = helper.aberlaasPath(source);
-    const absoluteDestination = helper.hostPath(destination);
+  async configureGit() {
+    const repo = new Gilmore(helper.hostRoot());
+    await repo.setConfig('core.hooksPath', 'scripts/hooks');
+  },
+  /**
+   * Pin the node version through nvm
+   **/
+  async configureNode() {
+    const nvmrcPath = helper.hostPath('.nvmrc');
+    await write(nodeConfig.nodeVersion, nvmrcPath);
+  },
+  /**
+   * Create the top-level monorepo root workspace
+   **/
+  async createRootWorkspace() {
+    const aberlaasData = await readJson(helper.aberlaasPath('./package.json'));
+    const sharedProjectData = await this.getSharedProjectData();
 
-    // Source file does not exist
-    if (!(await isFile(absoluteSource))) {
-      return false;
-    }
-    // Destination file already exist
-    if (await isFile(absoluteDestination)) {
-      return false;
-    }
+    const packageContent = {
+      // Visibility
+      private: true,
+      workspaces: ['docs', 'lib'],
 
-    await copy(absoluteSource, absoluteDestination);
+      // Name and version
+      name: `${sharedProjectData.name}-monorepo`,
+      version: '0.0.1',
 
-    return true;
+      // Metadata
+      author: sharedProjectData.author,
+      description: `${sharedProjectData.name} monorepo`,
+      repository: sharedProjectData.repository,
+      homepage: sharedProjectData.homepage,
+
+      // Compatibility
+      type: 'module',
+      license: sharedProjectData.license,
+      packageManager: `yarn@${nodeConfig.yarnVersion}`,
+
+      // Exports
+
+      // Dependencies
+      dependencies: {},
+      devDependencies: {
+        aberlaas: aberlaasData.version,
+        lerna: nodeConfig.lernaVersion,
+      },
+
+      // Scripts
+      scripts: {
+        // ==> Docs-specific
+        build: './scripts/docs/build',
+        'build:prod': './scripts/docs/build-prod',
+        cms: './scripts/docs/cms',
+        serve: './scripts/docs/serve',
+        // ==> Lib-specific
+        release: './scripts/lib/release',
+        test: './scripts/lib/test',
+        'test:watch': './scripts/lib/test-watch',
+        // Common
+        ci: './scripts/ci',
+        compress: './scripts/compress',
+        lint: './scripts/lint',
+        'lint:fix': './scripts/lint-fix',
+
+        // Global (called as aliases from any workspace)
+        // ==> Docs-specific
+        'g:build': './scripts/docs/build',
+        'g:build:prod': './scripts/docs/build-prod',
+        'g:cms': './scripts/docs/cms',
+        'g:serve': './scripts/docs/serve',
+        // ==> Lib-specific
+        'g:release': './scripts/lib/release',
+        'g:test': './scripts/lib/test',
+        'g:test:watch': './scripts/lib/test-watch',
+        // Common
+        'g:compress': './scripts/compress',
+        'g:lint': './scripts/lint',
+        'g:lint:fix': './scripts/lint-fix',
+      },
+    };
+    await writeJson(packageContent, helper.hostPath('./package.json'), {
+      sort: false,
+    });
+  },
+  /**
+   * Create the docs workspace
+   **/
+  async createDocsWorkspace() {
+    const sharedProjectData = await this.getSharedProjectData();
+
+    const packageContent = {
+      // Visibility
+      private: true,
+
+      // Name & Version
+      name: `${sharedProjectData.name}-docs`,
+      version: '0.0.1',
+
+      // Metadata
+      author: sharedProjectData.author,
+      description: `${sharedProjectData.name} docs`,
+      repository: sharedProjectData.repository,
+      homepage: sharedProjectData.homepage,
+
+      // Compatibility
+      license: sharedProjectData.license,
+
+      // Exports
+
+      // Dependencies
+      dependencies: {
+        norska: nodeConfig.norskaVersion,
+        'norska-theme-docs': nodeConfig.norskaThemeDocsVersion,
+      },
+      devDependencies: {},
+
+      // Scripts
+      scripts: sharedProjectData.scripts,
+    };
+    await writeJson(packageContent, helper.hostPath('./docs/package.json'), {
+      sort: false,
+    });
+  },
+  /**
+   * Create the lib workspace
+   **/
+  async createLibWorkspace() {
+    const sharedProjectData = await this.getSharedProjectData();
+
+    const packageContent = {
+      // Visibility
+      private: false,
+
+      // Name and version
+      name: sharedProjectData.name,
+      version: '0.0.1',
+
+      // Metadata
+      author: sharedProjectData.author,
+      description: '',
+      keywords: [],
+      repository: sharedProjectData.repository,
+      homepage: sharedProjectData.homepage,
+
+      // Compatibility
+      type: 'module',
+      license: sharedProjectData.license,
+      engines: sharedProjectData.engines,
+
+      // Exports
+      files: ['*.js'],
+      exports: {
+        '.': './main.js',
+      },
+      main: './main.js',
+
+      // Dependencies
+      dependencies: {},
+      devDependencies: {},
+
+      // Scripts
+      scripts: sharedProjectData.scripts,
+    };
+    await writeJson(packageContent, helper.hostPath('./lib/package.json'), {
+      sort: false,
+    });
   },
   /**
    * Add config files to the host. Each config files reference the default
@@ -45,24 +191,37 @@ export default {
    * default rules and overwrite them as they see fit
    **/
   async addConfigFiles() {
+    // Git
+    await this.copyToHost('./templates/_gitignore', './.gitignore');
+    await this.copyToHost('./templates/_gitattributes', './.gitattributes');
+
     // Yarn
     await this.copyToHost('templates/_yarnrc.yml', '.yarnrc.yml');
 
+    // Lerna
+    await this.copyToHost('templates/lerna.json', 'lerna.json');
+
     // ESLint
     await this.copyToHost('templates/_eslintrc.cjs', '.eslintrc.cjs');
     await this.copyToHost('templates/_eslintignore.conf', '.eslintignore');
 
     // Lint-staged
-    await this.copyToHost('templates/_lintstagedrc.cjs', '.lintstagedrc.cjs');
+    await this.copyToHost(
+      'templates/lintstaged.config.js',
+      'lintstaged.config.js',
+    );
 
     // Vite
     await this.copyToHost('templates/vite.config.js', 'vite.config.js');
 
     // Prettier
-    await this.copyToHost('templates/_prettierrc.cjs', '.prettierrc.cjs');
+    await this.copyToHost('templates/prettier.config.js', 'prettier.config.js');
 
     // Stylelint
-    await this.copyToHost('templates/_stylelintrc.cjs', '.stylelintrc.cjs');
+    await this.copyToHost(
+      'templates/stylelint.config.js',
+      'stylelint.config.js',
+    );
 
     // Renovate
     await this.copyToHost(
@@ -77,196 +236,162 @@ export default {
     );
   },
   /**
-   * Add scripts entry to the host package.json with specified command.
-   * @param {string} scriptName Script name
-   * @param {string} scriptPath Path to the script to run, must be a path
-   * relative to the templates/ directory
-   * @returns {boolean} False if can't add entry, true otherwise
+   * Add default script files
    **/
-  async addPackageScript(scriptName, scriptPath) {
-    const packagePath = helper.hostPath('package.json');
-    const currentPackage = await readJson(packagePath);
-    const currentScripts = _.get(currentPackage, 'scripts', {});
-
-    if (currentScripts[scriptName]) {
-      return false;
-    }
-
-    await this.copyToHost(`./templates/${scriptPath}`, scriptPath);
+  async addScripts() {
+    // Docs
+    await this.copyToHost('templates/scripts/docs/build', 'scripts/docs/build');
+    await this.copyToHost(
+      'templates/scripts/docs/build-prod',
+      'scripts/docs/build-prod',
+    );
+    await this.copyToHost('templates/scripts/docs/cms', 'scripts/docs/cms');
+    await this.copyToHost('templates/scripts/docs/serve', 'scripts/docs/serve');
 
-    const newPackage = _.set(
-      _.clone(currentPackage),
-      `scripts.${scriptName}`,
-      `./${scriptPath}`,
+    // Hooks
+    await this.copyToHost(
+      './templates/scripts/hooks/pre-commit',
+      './scripts/hooks/pre-commit',
     );
-    await writeJson(newPackage, packagePath);
-    return true;
-  },
-  /**
-   * Add default scripts to the package.json scripts entry and copy scripts to
-   * ./scripts if needed
-   **/
-  async addScripts() {
-    const defaultScripts = [
-      { key: 'ci', value: 'scripts/ci' },
-      { key: 'compress', value: 'scripts/compress' },
-      { key: 'lint', value: 'scripts/lint' },
-      { key: 'lint:fix', value: 'scripts/lint-fix' },
-      { key: 'release', value: 'scripts/release' },
-      { key: 'test', value: 'scripts/test' },
-      { key: 'test:watch', value: 'scripts/test-watch' },
-    ];
-
-    await pMapSeries(defaultScripts, async (script) => {
-      await this.addPackageScript(script.key, script.value);
-    });
-  },
-  /**
-   * Update package.json with .main and .files keys to use files in ./lib
-   * directory by default
-   * TODO: Update this to use exports instead of main
-   **/
-  async setDefaultReleaseFiles() {
-    const packagePath = helper.hostPath('package.json');
-    const currentPackage = await readJson(packagePath);
-
-    // Update .main
-    const currentMain = currentPackage.main;
-    const currentMainIsDefault = currentMain === 'index.js';
-    if (!currentMain || currentMainIsDefault) {
-      currentPackage.main = 'lib/main.js';
-      await this.copyToHost('templates/lib/main.js', 'lib/main.js');
-      await this.copyToHost(
-        'templates/lib/__tests__/main.js',
-        'lib/__tests__/main.js',
-      );
-    }
 
-    const currentFiles = currentPackage.files;
-    const currentFilesIsEmpty = _.isEmpty(currentFiles);
-    if (!currentFiles || currentFilesIsEmpty) {
-      currentPackage.files = ['lib/*.js'];
-    }
+    // Lib
+    await this.copyToHost(
+      'templates/scripts/lib/release',
+      'scripts/lib/release',
+    );
+    await this.copyToHost('templates/scripts/lib/test', 'scripts/lib/test');
+    await this.copyToHost(
+      'templates/scripts/lib/test-watch',
+      'scripts/lib/test-watch',
+    );
 
-    await writeJson(currentPackage, packagePath);
+    // Common
+    await this.copyToHost('templates/scripts/ci', 'scripts/ci');
+    await this.copyToHost('templates/scripts/compress', 'scripts/compress');
+    await this.copyToHost('templates/scripts/lint', 'scripts/lint');
+    await this.copyToHost('templates/scripts/lint-fix', 'scripts/lint-fix');
   },
   /**
-   * Add an MIT LICENSE file to the repository
+   * Add MIT license files to the repository
    **/
-  async addLicenseFile() {
-    const licensePath = helper.hostPath('LICENSE');
-
-    if (await exists(licensePath)) {
-      return;
-    }
-
-    const template = await read(helper.aberlaasPath('./templates/LICENSE'));
-    const currentPackage = await readJson(helper.hostPath('package.json'));
+  async addLicenseFiles() {
+    // Add the LICENSE template to the root
+    await this.copyToHost('templates/LICENSE', 'LICENSE');
 
-    const content = _.replace(template, '{author}', currentPackage.author);
+    // Replace placeholder with real value
+    const sharedProjectData = await this.getSharedProjectData();
+    const licensePath = helper.hostPath('LICENSE');
+    const templateContent = await read(licensePath);
+    const actualContent = _.replace(
+      templateContent,
+      '{author}',
+      sharedProjectData.author,
+    );
 
-    await write(content, licensePath);
+    // Write the LICENSE to root and lib
+    await write(actualContent, licensePath);
+    await write(actualContent, helper.hostPath('lib/LICENSE'));
   },
   /**
-   * Sets license to MIT in package.json
+   * Add default files required to have the minimum lib module
    **/
-  async addLicenseField() {
-    const packagePath = helper.hostPath('package.json');
-    const currentPackage = await readJson(packagePath);
-
-    if (currentPackage.license) {
-      return;
-    }
-
-    const newPackage = {
-      ...currentPackage,
-      license: 'MIT',
-    };
-
-    await writeJson(newPackage, packagePath);
+  async addLibFiles() {
+    await this.copyToHost('templates/lib/main.js', 'lib/main.js');
+    await this.copyToHost(
+      'templates/lib/__tests__/main.js',
+      'lib/__tests__/main.js',
+    );
   },
   /**
-   * Sets a default 0.0.1 version if none is defined
+   * Copy a config template to the host
+   * @param {string} source Path to source file, relative to aberlaas
+   * @param {string} destination Path to destination file, relative to the host
+   * @returns {boolean} False if can't copy file, true otherwise
    **/
-  async addDefaultVersion() {
-    const packagePath = helper.hostPath('package.json');
-    const currentPackage = await readJson(packagePath);
+  async copyToHost(source, destination) {
+    const absoluteSource = helper.aberlaasPath(source);
+    const absoluteDestination = helper.hostPath(destination);
 
-    if (currentPackage.version) {
-      return;
+    // Source file does not exist
+    if (!(await isFile(absoluteSource))) {
+      throw firostError(
+        'ERROR_INIT_COPY_FILE',
+        `Unable to locate ${absoluteSource} file`,
+      );
     }
-
-    const newPackage = {
-      ...currentPackage,
-      version: '0.0.1',
-    };
-
-    await writeJson(newPackage, packagePath);
-  },
-  /**
-   * Sets the minimum node version to run this module
-   * Which is the same version it has been tested on
-   **/
-  async addEngineNodeVersion() {
-    const packagePath = helper.hostPath('package.json');
-    const currentPackage = await readJson(packagePath);
-
-    if (_.has(currentPackage, 'engines')) {
-      return;
+    // Destination file already exist
+    if (await isFile(absoluteDestination)) {
+      // Do nothing if content is already the same
+      const sourceContent = await read(absoluteSource);
+      const destinationContent = await read(absoluteDestination);
+      if (sourceContent === destinationContent) {
+        return true;
+      }
+
+      // Otherwise create a backup
+      const backupDestination = `${absoluteDestination}.backup`;
+      await move(absoluteDestination, backupDestination);
     }
 
-    const newPackage = {
-      ...currentPackage,
-      engines: {
-        node: `>=${nodeConfig.nodeVersion}`,
-      },
-    };
+    await copy(absoluteSource, absoluteDestination);
 
-    await writeJson(newPackage, packagePath);
+    return true;
   },
   /**
-   * Sets the dirname as package name if none is defined
+   * Return name of the current project based on the GitHub project name
+   * @returns {string} Name of the project
    **/
-  async addDefaultName() {
-    const packagePath = helper.hostPath('package.json');
-    const currentPackage = await readJson(packagePath);
-
-    if (currentPackage.name) {
-      return;
-    }
-
-    const newPackage = {
-      ...currentPackage,
-      name: path.basename(helper.hostPath()),
-    };
-
-    await writeJson(newPackage, packagePath);
+  async getProjectName() {
+    const repo = new Gilmore(helper.hostRoot());
+    return await repo.githubRepoName();
   },
   /**
-   * Pin the node version through nvm and yarn through yarnrc
-   * This allows us to run the same version locally as we do in CI
+   * Return the name of the current author based on the GitHub project owner
+   * @returns {string} Name of the author
    **/
-  async pinNodeAndYarn() {
-    // Set .nvmrc
-    const nvmrcPath = helper.hostPath('.nvmrc');
-    await write(nodeConfig.nodeVersion, nvmrcPath);
-
-    // Download latest yarn version
-    await this.__run('yarn set version', { stdout: false });
+  async getProjectAuthor() {
+    const repo = new Gilmore(helper.hostRoot());
+    return await repo.githubRepoOwner();
   },
   /**
-   * Configure git hooks to use scripts/hooks instead of .git/hooks
+   * Returns shared project data, like name, author, scripts, etc
+   * @returns {object} Object of common keys
    **/
-  async configureGitHooks() {
-    // Copy the scripts into ./scripts/hooks
-    await this.copyToHost(
-      './templates/scripts/hooks/pre-commit',
-      './scripts/hooks/pre-commit',
-    );
-
-    // Configure git to use this directory for hooks
-    const repo = new Gilmore(helper.hostRoot());
-    await repo.setConfig('core.hooksPath', 'scripts/hooks');
+  async getSharedProjectData() {
+    const name = await this.getProjectName();
+    const author = await this.getProjectAuthor();
+    const homepage = `https://projects.pixelastic.com/${name}`;
+    const repository = `${author}/${name}`;
+    const license = 'MIT';
+    const engines = {
+      node: `>=${nodeConfig.nodeVersion}`,
+    };
+    const scripts = {
+      // Docs
+      build: 'ABERLAAS_CWD=$INIT_CWD yarn g:build',
+      'build:prod': 'ABERLAAS_CWD=$INIT_CWD yarn g:build:prod',
+      cms: 'ABERLAAS_CWD=$INIT_CWD yarn g:cms',
+      serve: 'ABERLAAS_CWD=$INIT_CWD yarn g:serve',
+
+      // Lib
+      release: 'ABERLAAS_CWD=$INIT_CWD yarn g:release',
+      test: 'ABERLAAS_CWD=$INIT_CWD yarn g:test',
+      'test:watch': 'ABERLAAS_CWD=$INIT_CWD yarn g:test:watch',
+
+      // Common
+      compress: 'ABERLAAS_CWD=$INIT_CWD yarn g:compress',
+      lint: 'ABERLAAS_CWD=$INIT_CWD yarn g:lint',
+      'lint:fix': 'ABERLAAS_CWD=$INIT_CWD yarn g:lint:fix',
+    };
+    return {
+      author,
+      engines,
+      homepage,
+      license,
+      name,
+      repository,
+      scripts,
+    };
   },
   /**
    * Copy all config files and configure the scripts
@@ -274,34 +399,26 @@ export default {
   async run() {
     const progress = spinner();
 
-    progress.tick('Pinning node and yarn versions');
-    await this.pinNodeAndYarn();
-    await this.addEngineNodeVersion();
+    progress.tick('Configuring Git & Node');
+    await this.configureGit();
+    await this.configureNode();
 
-    progress.tick('Adding config files');
-    await this.addConfigFiles();
+    progress.tick('Configuring workspaces');
+    await this.createRootWorkspace();
+    await this.createDocsWorkspace();
+    await this.createLibWorkspace();
 
-    progress.tick('Adding yarn scripts');
+    progress.tick('Adding files');
+    await this.addLicenseFiles();
+    await this.addConfigFiles();
     await this.addScripts();
-
-    progress.tick('Configuring git hooks');
-    await this.configureGitHooks();
-
-    progress.tick('Updating LICENSE');
-    await this.addLicenseFile();
-    await this.addLicenseField();
-
-    progress.tick('Setting default version');
-    await this.addDefaultVersion();
-
-    progress.tick('Setting default name');
-    await this.addDefaultName();
-
-    progress.tick('Setting default release files');
-    await this.setDefaultReleaseFiles();
+    await this.addLibFiles();
 
     progress.success('aberlaas project initialized');
 
+    this.__consoleInfo('Synchronizing dependencies');
+    await run('yarn install');
+
     this.__consoleInfo(
       "Don't forget to run aberlaas setup after pushing your repository",
     );

package/commands/lint/css.js

@@ -36,8 +36,8 @@ export default {
     // Config
     const configFile = await helper.configFile(
       userConfigFile,
-      '.stylelintrc.cjs',
-      'configs/stylelint.cjs',
+      'stylelint.config.js',
+      'configs/stylelint.js',
     );
     const config = await helper.import(configFile);
 

package/commands/lint/helpers/prettier.js

@@ -14,8 +14,8 @@ export async function fix(inputFiles) {
   // Config file
   const configFile = await helper.configFile(
     null,
-    '.prettierrc.cjs',
-    'lib/configs/prettier.cjs',
+    'prettier.config.js',
+    'configs/prettier.js',
   );
   const config = await prettier.resolveConfig(configFile);
 

package/commands/lint/index.js

@@ -21,7 +21,7 @@ export default {
    * @param {object} cliArgs CLI Argument object, as created by minimist
    * @returns {boolean} True on success
    **/
-  async run(cliArgs) {
+  async run(cliArgs = {}) {
     const allTypesKeys = _.keys(this.linters);
     const userTypes = _.intersection(_.keys(cliArgs), allTypesKeys);
     const typesToLint = _.isEmpty(userTypes) ? allTypesKeys : userTypes;
@@ -30,9 +30,10 @@ export default {
     await pMap(typesToLint, async (type) => {
       const methodName = cliArgs.fix ? 'fix' : 'run';
       try {
+        const linter = this.linters[type];
+
         const configFile = _.get(cliArgs, `config.${type}`);
         const userPatterns = _.get(cliArgs, '_');
-        const linter = this.linters[type];
 
         await linter[methodName](userPatterns, configFile);
       } catch (error) {

package/commands/lint/js.js

@@ -34,7 +34,7 @@ export default {
     const configFile = await helper.configFile(
       userConfigFile,
       '.eslintrc.cjs',
-      'lib/configs/eslint.cjs',
+      'configs/eslint.cjs',
     );
 
     // Run the actual lint