Nx Generators Guide

import { Tree, formatFiles, generateFiles, joinPathSegments } from '@nx/devkit';
import * as path from 'path';
import { GeneratorSchema } from './schema';

export async function myGenerator(tree: Tree, options: GeneratorSchema) {
  const projectRoot = `libs/${options.name}`;
  
  generateFiles(
    tree,
    path.join(__dirname, 'files'),
    projectRoot,
    options
  );
  
  await formatFiles(tree);
}

export default myGenerator;

tree.write('path/to/file.ts', 'content');

const content = tree.read('path/to/file.ts', 'utf-8');

if (tree.exists('path/to/file.ts')) {
  // file exists
}

tree.delete('path/to/file.ts');

tree.children('libs/my-lib/src');

import { updateJson } from '@nx/devkit';

updateJson(tree, 'package.json', (json) => {
  json.scripts.build = 'nx build';
  return json;
});

import { readProjectConfiguration } from '@nx/devkit';

const project = readProjectConfiguration(tree, 'my-lib');
console.log(project.root); // libs/my-lib
console.log(project.targets); // { build: {...}, test: {...} }

import { updateProjectConfiguration } from '@nx/devkit';

const project = readProjectConfiguration(tree, 'my-lib');
project.targets.lint = {
  executor: '@nx/linter:eslint',
  options: {
    lintFilePatterns: [`${project.root}/**/*.ts`]
  }
};
updateProjectConfiguration(tree, 'my-lib', project);

import { addProjectConfiguration } from '@nx/devkit';

addProjectConfiguration(tree, 'my-lib', {
  root: 'libs/my-lib',
  projectType: 'library',
  sourceRoot: 'libs/my-lib/src',
  targets: {
    build: {
      executor: '@nx/js:tsc',
      outputs: ['{options.outputPath}'],
      options: {
        outputPath: 'dist/libs/my-lib',
        main: 'libs/my-lib/src/index.ts',
        tsConfig: 'libs/my-lib/tsconfig.lib.json'
      }
    }
  }
});

src/generators/my-generator/
├── generator.ts
├── schema.json
├── schema.d.ts
└── files/
    ├── src/
    │   └── index.ts.template
    ├── README.md.template
    └── __name__/
        └── __fileName__.ts.template

// files/src/index.ts.template
export * from './<%= name %>';

export function <%= propertyName %>(): string {
  return '<%= name %> works!';
}

import { generateFiles } from '@nx/devkit';
import * as path from 'path';

generateFiles(
  tree,
  path.join(__dirname, 'files'),
  `libs/${options.name}`,
  {
    ...options,
    template: '', // removes .template extension
    propertyName: names(options.name).propertyName
  }
);

{
  "$schema": "http://json-schema.org/schema",
  "cli": "nx",
  "id": "my-generator",
  "title": "My Generator",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Library name",
      "$default": {
        "$source": "argv",
        "index": 0
      },
      "x-prompt": "What name would you like to use?"
    },
    "directory": {
      "type": "string",
      "description": "Directory where the library is placed"
    },
    "tags": {
      "type": "string",
      "description": "Tags to add to project (comma-delimited)"
    },
    "skipFormat": {
      "type": "boolean",
      "description": "Skip formatting files",
      "default": false
    }
  },
  "required": ["name"]
}

export interface GeneratorSchema {
  name: string;
  directory?: string;
  tags?: string;
  skipFormat?: boolean;
}

import { names } from '@nx/devkit';

const result = names('my-lib');
// {
//   name: 'my-lib',
//   className: 'MyLib',
//   propertyName: 'myLib',
//   constantName: 'MY_LIB',
//   fileName: 'my-lib'
// }

import { joinPathSegments, normalizePath } from '@nx/devkit';

const fullPath = joinPathSegments('libs', options.name, 'src');
const normalized = normalizePath('libs\\my-lib\\src'); // libs/my-lib/src

import { addDependenciesToPackageJson } from '@nx/devkit';

addDependenciesToPackageJson(
  tree,
  { '@my-org/shared': '^1.0.0' },
  { '@my-org/build-tools': '^1.0.0' }
);

npx nx g @my-org/my-plugin:library test --dry-run

import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
import { Tree, readProjectConfiguration } from '@nx/devkit';
import { libraryGenerator } from './generator';

describe('library generator', () => {
  let tree: Tree;

  beforeEach(() => {
    tree = createTreeWithEmptyWorkspace();
  });

  it('should create library', async () => {
    await libraryGenerator(tree, { name: 'test' });
    
    const config = readProjectConfiguration(tree, 'test');
    expect(config.root).toBe('libs/test');
    expect(tree.exists('libs/test/src/index.ts')).toBeTruthy();
    expect(tree.exists('libs/test/README.md')).toBeTruthy();
  });

  it('should add tags', async () => {
    await libraryGenerator(tree, { name: 'test', tags: 'scope:shared,type:util' });
    
    const config = readProjectConfiguration(tree, 'test');
    expect(config.tags).toEqual(['scope:shared', 'type:util']);
  });
});