@digigov/cli-lab 1.0.1 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digigov/cli-lab",
-  "version": "1.0.1",
+  "version": "1.2.1",
   "description": "",
   "main": "index.js",
   "directories": {
@@ -15,6 +15,7 @@
     "zx": "~1.15.2",
     "zx-extra": "~0.0.4",
     "inquirer": "~8.1.2",
-    "glob": "7.1.6"
+    "glob": "7.1.6",
+    "fs-extra": "~10.0.0"
   }
 }

package/scripts/add-package-to-subtree-branch.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env zx
+import "zx-extra";
+import "../lib/extra/index.mjs";
+
+const dryRun = argv['dry']
+console.log(argv)
+const CI = process.env['CI']
+console.log('CI', CI)
+const configName = 'subtree.config.json'
+const subtreeConfigFileExists = await find(configName)
+console.log(subtreeConfigFileExists)
+
+if (!subtreeConfigFileExists.length) {
+  console.log('Creating subtree.config file')
+  await writeJSON(configName, {})
+}
+const subtreeConfigFile = process.cwd() + '/' + configName
+const subtreeConfig = await readJSON(subtreeConfigFile) || {}
+const tempFolder = 'common/temp/repo'
+await rm(tempFolder)
+await mkdir(tempFolder)
+cd(tempFolder)
+await cli.git.clone('../../.. .')
+await cli.git.checkout(`main`)
+const rushLib = require('@microsoft/rush-lib');
+const rushConfiguration = rushLib.RushConfiguration.loadFromDefaultLocation({
+  startingFolder: process.cwd()
+});
+const answers = subtreeConfig
+const cwd = process.cwd()
+const allPackages = rushConfiguration.projects.map(p => p.packageName)
+if (!CI) {
+  answers.remote = await question(`Enter the repository url you want to push`,
+    subtreeConfig.remote)
+  answers.packages = await checkbox(
+    `Select package to be published to Github`,
+    allPackages, subtreeConfig.packages)
+}
+const branchName = answers.remote.replace('https://', '')
+
+const notPublishedPackages = allPackages.filter((p) => !answers.packages.includes(p))
+answers.lastCommitID = await cli.git.log(`-1 --pretty=format:"%h"`, {stdout: true})
+await writeJSON(subtreeConfigFile, answers)
+// delete old git history before X months, based on Date
+
+const oneMonthSeconds = 1000 * 60 * 60 * 24 * 30;
+const d = Date.now();
+const beforeDateDate = new Date(d - oneMonthSeconds * 3);
+const afterDateDate = new Date(d - oneMonthSeconds * 4);
+const beforeDate = `${beforeDateDate.getFullYear()}-${beforeDateDate.getMonth()}-${beforeDateDate.getDay()}`;
+const afterDate = `${afterDateDate.getFullYear()}-${afterDateDate.getMonth()}-${afterDateDate.getDay()}`;
+const commitId = await cli.git.log(`-1 --before={${beforeDate}} --after={${afterDate}} --pretty=format:"%h"`, { stdout: true })
+await cli.git.checkout(`--orphan ${branchName} ${commitId}`)
+await cli.git.commit(`-m "chore: remove old commits from git history before ${afterDate}"`)
+await cli.git.rebase(`--onto ${branchName} ${commitId} main`)
+await cli.git.branch(`-D ${branchName}`)
+await cli.git.checkout(`-b ${branchName}`)
+const notPublishedProjects = notPublishedPackages.map(packageName =>
+  rushConfiguration
+    .findProjectByShorthandName(packageName)
+    .projectFolder
+    .replace(`${cwd}/`, '')
+).join(' ')
+process.env['FILTER_BRANCH_SQUELCH_WARNING'] = 1
+await cli.git['filter-branch'](`--force --index-filter \
+"git rm -r --cached --ignore-unmatch ${notPublishedProjects}" \
+--prune-empty --tag-name-filter cat -- --all`)
+const rushJSON = await readJSON(rushConfiguration.rushJsonFile)
+rushJSON.projects = rushJSON.projects.filter(project => !notPublishedPackages.includes(project.packageName))
+await writeJSON('rush.json', rushJSON)
+await cli.rush.update('--full --purge')
+await cli.git.commit('-am "chore: remove unpublished projects from rush json"')
+await cli.git.branch('-M main')
+await cli.git.remote('add partial ' + answers.remote)
+await cli.git.push('-f -u partial main')
+

package/scripts/generate-react-core.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env zx
+
+import '../lib/extra/index.mjs';
+
+const components = require('../misc/react-core-components')
+const htmlTypes = require('../misc/html-types')
+// uppercase the first letter of a word
+const ucFirst = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+function findRefInChildren(children){
+  for(const child of children){
+    if(child.props && child.props.ref){
+      return child.element
+    }
+  }
+}
+for(const componentName in components){
+  const component = components[componentName]
+  if(component.element){
+    let mainElement = component.element
+    if(component.children){
+      mainElement = findRefInChildren(component.children) || mainElement
+    }
+    const componentPath = `libs-ui/react-core/src/${componentName}/index.tsx`
+    const componentTestPath = `libs-ui/react-core/src/${componentName}/index.test.tsx`
+    const componentCode = `
+import React from 'react';
+import clsx from 'clsx';
+
+type ${ucFirst(mainElement)}ElementAttributes = JSX.IntrinsicElements['${mainElement}']
+export interface ${componentName}Props extends ${ucFirst(mainElement)}ElementAttributes {
+  ${
+    component.props && Object.keys(component.props).map(propName => {
+      const prop = component.props[propName]
+      return `
+  /**
+   * ${propName} is optional.
+   */
+  ${propName}?: ${prop.type ? prop.type: 
+          prop.values? Object.keys(prop.values).map(value=>`'${value}'`).join('|'): 'string'}`
+    }).join(';\n')
+  }
+}
+/**
+ * Details for the ${componentName}.
+ */
+export const ${componentName} = React.forwardRef<${htmlTypes[mainElement]}, ${componentName}Props>(
+  function ${componentName}({
+  ${
+    component.props && Object.keys(component.props).map(propName => {
+      const prop = component.props[propName]
+      return `${propName}${prop.default && (prop.type === 'boolean' || prop.type === 'number')? `=${prop.default},`: 
+          prop.default? `='${prop.default}',`: ','}`
+    }).join('\n')
+  }
+  className,
+  children,
+  ...props
+}, ref) {
+  return (
+    ${renderJsonToJsx(component, mainElement)}
+  );
+});
+
+export default ${componentName};
+`
+  const componentTestCode = `
+import React from 'react';
+import { mount } from 'enzyme';
+
+import ${componentName} from '@digigov/react-core/${componentName}';
+
+it('renders the ${componentName} with no props', () => {
+  expect(mount(<${componentName}${component.nochildren?`/>`:`>hello</${componentName}>`})).toMatchSnapshot();
+});
+${component.props && Object.keys(component.props).map(propName => {
+  const prop = component.props[propName]
+  if(prop.values && prop.type !== 'boolean'){
+    return Object.keys(prop.values).map(value=>{
+      return `
+it('renders the ${componentName} with ${propName}=${value}', () => {
+  expect(mount(<${componentName} ${propName}={${prop.type === 'number'? value: `'${value}'`}}${component.nochildren?`/>`:`>hello</${componentName}>`})).toMatchSnapshot();
+})`
+    }).join('\n')
+  }
+  if(prop.type === 'boolean'){
+      return `
+it('renders the ${componentName} with ${propName}=true', () => {
+  expect(mount(<${componentName} ${propName}={true}${component.nochildren?`/>`:`>hello</${componentName}>`})).toMatchSnapshot();
+})
+
+it('renders the ${componentName} with ${propName}=false', () => {
+  expect(mount(<${componentName} ${propName}={false}${component.nochildren?`/>`:`>hello</${componentName}>`})).toMatchSnapshot();
+})
+
+`
+  }
+  return ''
+}).join('\n')}
+  
+`
+  writeFile(componentPath, componentCode)
+  writeFile(componentTestPath, componentTestCode)
+  console.log(componentCode)
+  }
+}
+
+
+
+// render json to jsx 
+function renderJsonToJsx (json, mainElement) {
+    let topLevel = false
+    if(!Array.isArray(json)){
+      if(!json.children){
+        json.children = [{element: 'children'}]
+      }
+      json = [json]
+      topLevel = true
+
+    }
+    return json.map(component => {
+      if(mainElement === component.element){
+        component.props.ref = {
+          pass: true
+        }
+      }
+      if(component.element && component.element !== 'children'){
+        const elementCode = `<${component.element}
+        ${component.props ? Object.keys(component.props).map(propName => {
+          const prop = component.props[propName]
+          if(prop.pass){
+            return `${propName}={${propName}}`
+          }
+          return ''
+        }).filter(p=>p).join('\n'): ''}
+        className={clsx(${topLevel?'className,':''} {
+          ${component.classes ? component.classes.map(cl=>`'${cl}': true,`).filter(cl=>cl).join('\n'):''}
+          ${component.props ? Object.keys(component.props).map(propName => {
+            const prop = component.props[propName]
+            let classes = ''
+            if(prop.values && prop.type !== 'boolean' && prop.type!=='number'){
+              return Object.keys(prop.values).map(value=>{
+                const className = prop.values[value]
+                return `'${className}': ${propName} === '${value}',`
+              }).filter(t=>t).join('\n')
+            }
+            if(prop.values && prop.type === 'boolean'){
+              return Object.keys(prop.values).map(value=>{
+                const className = prop.values[value]
+                return `'${className}': ${propName} === ${value},`
+              }).filter(t=>t).join('\n')
+            }
+            if(prop.values && prop.type === 'number'){
+              return Object.keys(prop.values).map(value=>{
+                const className = prop.values[value]
+                return `'${className}': ${propName} === ${value},`
+              }).filter(t=>t).join('\n')
+            }
+            return ''
+          }).filter(t=>t).join(''): ''}
+        })}
+        ${mainElement === component.element? `{...props}`: ''}
+        >${
+          component.children? renderJsonToJsx(component.children, mainElement): ''
+        }</${component.element}>`
+        return elementCode
+      }else if(component.element === 'children'){
+        return `{children}`
+      }else if(component.text){
+        return `${component.text}`
+      }
+
+  }).join('').replace(
+/className=\{clsx\( \{\s*\}\)\}/g,'')
+}

package/scripts/merge-subtree.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env zx
+import "zx-extra";
+import "../lib/extra/index.mjs";
+
+// await cd('./common/temp/repo')
+const subtree = await readJSON('./subtree.config.json');
+const branchName = await question('Enter branch name: ')
+await cli.git.remote(`rm partial`)
+await cli.git.remote(`add partial ${subtree.remote}`)
+await cli.git.pull('partial')
+const commitIDs = (
+  await cli.git.log(
+   ` partial/main..partial/${branchName} --pretty=format:"%h"`,
+    {stdout: true})
+  )
+ .split('\n')
+await cli.git.branch(`-D github/${branchName}`)
+await cli.git.checkout(`-b github/${branchName} ${subtree.lastCommitID}`)
+commitIDs.reverse()
+for(const commitID of commitIDs) {
+  await cli.git['cherry-pick'](`${commitID}`)
+}

package/scripts/publish.mjs

@@ -2,18 +2,33 @@
 import "zx-extra";
 import "../lib/extra/index.mjs";
 
+const rushJSON = await readJSON(await findUp('rush.json'));
+const defaultBranch = rushJSON.repository.defaultBranch;
+const currentBranch = await cli.git.branch('--show-current', { stdout: true });
+
 const shouldPublishAll = await confirm('Do you want to publish all packages?');
 
 const featureVersion = await confirm('Is it a feature version?');
 const featureVersionName = featureVersion && await question('What is the feature name? ');
+let targetBranch = await select('Which target branch do you want to use?', [
+  defaultBranch,
+  currentBranch.trim(),
+  'other (specify)'
+]);
+
+if(targetBranch.indexOf('other (specify)') > -1) {
+  let branches = await cli.git.branch(`--format='%(refname:short)'`, {stdout: true});
+  branches = branches.split('\n').filter(i => i);
+  targetBranch = await select("Select the target branch where the changelogs will be commited", branches);
+}
 
 await requireEnv('NPM_AUTH_TOKEN', true);
 
 if(shouldPublishAll && !featureVersion) {
   await cli.rush.change();
-  await cli.rush.version('--bump');
+  await cli.rush.publish('-a');
   await cli.rush.build();
-  await cli.rush.publish('-p --include-all --set-access-level public');
+  await cli.rush.publish(`-p --include-all --target-branch ${targetBranch} --set-access-level public`);
 } else if(shouldPublishAll && featureVersion) {
   await cli.rush.publish(`--prerelease-name ${featureVersionName} -a`);
   await cli.rush.build();
@@ -21,7 +36,7 @@ if(shouldPublishAll && !featureVersion) {
 } else if(!shouldPublishAll && !featureVersion) {
   console.log('Not supported')
   process.exit()
-  const {projects} = await readJSON(await findUp('rush.json'));
+  const {projects} = rushJSON;
   const publishablePackages = projects.filter(project => project.shouldPublish);
   const publishPackages = await checkbox(
     'Select packages',
@@ -29,7 +44,6 @@ if(shouldPublishAll && !featureVersion) {
   );
   for(const packageName of publishPackages) {
     // cd(projects.find(({packageName}) => packageName===packageName).projectFolder))
-    
   }
   console.log(publishPackages)
 }

package/scripts/verify-and-update-local-package-versions.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env zx
+import "zx-extra";
+import "../lib/extra/index.mjs";
+
+const rushLib = require('@microsoft/rush-lib');
+const rushConfiguration = rushLib.RushConfiguration.loadFromDefaultLocation({
+  startingFolder: process.cwd()
+});
+
+const localPackageVersions = rushConfiguration.projects.reduce((versions, project) => {
+  return { ...versions, [project.packageJson.name]: project.packageJson.version };
+}, {});
+
+console.log(localPackageVersions);
+rushConfiguration.projects.forEach(project => {
+  for (const dependencyType of ['dependencies', 'devDependencies', 'peerDependencies']) {
+    const dependencies = project.packageJson[dependencyType];
+    if (dependencies) {
+      for (const dependencyName in dependencies) {
+        const dependencyVersion = dependencies[dependencyName];
+        if (localPackageVersions[dependencyName] && localPackageVersions[dependencyName] !== dependencyVersion) {
+          console.log(`${project.packageJson.name} ${dependencyType} ${dependencyName} ${dependencyVersion}`);
+          project.packageJsonEditor.addOrUpdateDependency(dependencyName, localPackageVersions[dependencyName], dependencyType);
+        }
+      }
+    }
+  }
+  project.packageJsonEditor.saveIfModified();
+});