fix(@schematics/angular): add injectable schematic

Adds a schematic to generate an `@Injectable` after `service` was re-purposed.

Author: crisbeto

packages/schematics/angular/collection.json

@@ -64,6 +64,11 @@
       "description": "Create an interceptor.",
       "schema": "./interceptor/schema.json"
     },
+    "injectable": {
+      "factory": "./injectable",
+      "description": "Create an Angular injectable.",
+      "schema": "./injectable/schema.json"
+    },
     "interface": {
       "aliases": ["i"],
       "factory": "./interface",

packages/schematics/angular/injectable/files/__name@dasherize__.__type@dasherize__.spec.ts.template

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { <%= classifiedName %> } from './<%= dasherize(name) %><%= type ? '.' + dasherize(type) : '' %>';
+
+describe('<%= classifiedName %>', () => {
+  let service: <%= classifiedName %>;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(<%= classifiedName %>);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

packages/schematics/angular/injectable/files/__name@dasherize__.__type@dasherize__.ts.template

@@ -0,0 +1,8 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class <%= classifiedName %> {
+  
+}

packages/schematics/angular/injectable/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import { RuleFactory, strings } from '@angular-devkit/schematics';
+import { generateFromFiles } from '../utility/generate-from-files';
+import { parseName } from '../utility/parse-name';
+import { createProjectSchematic } from '../utility/project';
+import { validateClassName } from '../utility/validation';
+import { buildDefaultPath } from '../utility/workspace';
+import { Schema as ServiceOptions } from './schema';
+
+const serviceSchematic: RuleFactory<ServiceOptions> = createProjectSchematic(
+  (options, { project, tree }) => {
+    if (options.path === undefined) {
+      options.path = buildDefaultPath(project);
+    }
+
+    const parsedPath = parseName(options.path, options.name);
+    options.name = parsedPath.name;
+    options.path = parsedPath.path;
+
+    const classifiedName =
+      strings.classify(options.name) +
+      (options.addTypeToClassName && options.type ? strings.classify(options.type) : '');
+    validateClassName(classifiedName);
+
+    return generateFromFiles({
+      ...options,
+      classifiedName,
+    });
+  },
+);
+
+export default serviceSchematic;

packages/schematics/angular/injectable/index_spec.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import { SchematicTestRunner, UnitTestTree } from '@angular-devkit/schematics/testing';
+import { Schema as ApplicationOptions } from '../application/schema';
+import { Schema as WorkspaceOptions } from '../workspace/schema';
+import { Schema as ServiceOptions } from './schema';
+
+describe('Injectable Schematic', () => {
+  const schematicRunner = new SchematicTestRunner(
+    '@schematics/angular',
+    require.resolve('../collection.json'),
+  );
+  const defaultOptions: ServiceOptions = {
+    name: 'foo',
+    flat: false,
+    project: 'bar',
+  };
+
+  const workspaceOptions: WorkspaceOptions = {
+    name: 'workspace',
+    newProjectRoot: 'projects',
+    version: '6.0.0',
+  };
+
+  const appOptions: ApplicationOptions = {
+    name: 'bar',
+    inlineStyle: false,
+    inlineTemplate: false,
+    routing: false,
+    skipPackageJson: false,
+  };
+  let appTree: UnitTestTree;
+  beforeEach(async () => {
+    appTree = await schematicRunner.runSchematic('workspace', workspaceOptions);
+    appTree = await schematicRunner.runSchematic('application', appOptions, appTree);
+  });
+
+  it('should create an injectable', async () => {
+    const options = { ...defaultOptions };
+
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const files = tree.files;
+    expect(files).toContain('/projects/bar/src/app/foo/foo.spec.ts');
+    expect(files).toContain('/projects/bar/src/app/foo/foo.ts');
+  });
+
+  it('should use @Injectable decorator', async () => {
+    const options = { ...defaultOptions };
+
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.ts');
+    expect(content).toMatch(/@Injectable\(\)/);
+    expect(content).toMatch(/import \{ Injectable \} from '@angular\/core'/);
+  });
+
+  it('injectable should be tree-shakeable', async () => {
+    const options = { ...defaultOptions };
+
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.ts');
+    expect(content).toMatch(/providedIn: 'root',/);
+  });
+
+  it('should respect the skipTests flag', async () => {
+    const options = { ...defaultOptions, skipTests: true };
+
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const files = tree.files;
+    expect(files).toContain('/projects/bar/src/app/foo/foo.ts');
+    expect(files).not.toContain('/projects/bar/src/app/foo/foo.spec.ts');
+  });
+
+  it('should respect the sourceRoot value', async () => {
+    const config = JSON.parse(appTree.readContent('/angular.json'));
+    config.projects.bar.sourceRoot = 'projects/bar/custom';
+    appTree.overwrite('/angular.json', JSON.stringify(config, null, 2));
+    appTree = await schematicRunner.runSchematic('injectable', defaultOptions, appTree);
+    expect(appTree.files).toContain('/projects/bar/custom/app/foo/foo.ts');
+  });
+
+  it('should respect the type option', async () => {
+    const options = { ...defaultOptions, type: 'Service' };
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.service.ts');
+    const testContent = tree.readContent('/projects/bar/src/app/foo/foo.service.spec.ts');
+    expect(content).toContain('export class FooService');
+    expect(testContent).toContain("describe('FooService'");
+  });
+
+  it('should allow empty string in the type option', async () => {
+    const options = { ...defaultOptions, type: '' };
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.ts');
+    const testContent = tree.readContent('/projects/bar/src/app/foo/foo.spec.ts');
+    expect(content).toContain('export class Foo');
+    expect(testContent).toContain("describe('Foo'");
+  });
+
+  it('should not add type to class name when addTypeToClassName is false', async () => {
+    const options = { ...defaultOptions, type: 'Service', addTypeToClassName: false };
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.service.ts');
+    const testContent = tree.readContent('/projects/bar/src/app/foo/foo.service.spec.ts');
+    expect(content).toContain('export class Foo {');
+    expect(content).not.toContain('export class FooService {');
+    expect(testContent).toContain("describe('Foo', () => {");
+    expect(testContent).not.toContain("describe('FooService', () => {");
+  });
+
+  it('should add type to class name when addTypeToClassName is true', async () => {
+    const options = { ...defaultOptions, type: 'Service', addTypeToClassName: true };
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.service.ts');
+    const testContent = tree.readContent('/projects/bar/src/app/foo/foo.service.spec.ts');
+    expect(content).toContain('export class FooService {');
+    expect(testContent).toContain("describe('FooService', () => {");
+  });
+
+  it('should add type to class name by default', async () => {
+    const options = { ...defaultOptions, type: 'Service', addTypeToClassName: undefined };
+    const tree = await schematicRunner.runSchematic('injectable', options, appTree);
+    const content = tree.readContent('/projects/bar/src/app/foo/foo.service.ts');
+    const testContent = tree.readContent('/projects/bar/src/app/foo/foo.service.spec.ts');
+    expect(content).toContain('export class FooService {');
+    expect(testContent).toContain("describe('FooService', () => {");
+  });
+});

packages/schematics/angular/injectable/schema.json

@@ -0,0 +1,54 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "SchematicsAngularService",
+  "title": "Angular Service Options Schema",
+  "type": "object",
+  "additionalProperties": false,
+  "description": "Creates a new service in your project. Services are used to encapsulate reusable logic, such as data access, API calls, or utility functions. This schematic simplifies the process of generating a new service with the necessary files and boilerplate code.",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name for the new service. This will be used to create the service's class and spec files (e.g., `my-service.service.ts` and `my-service.service.spec.ts`).",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the service?"
+    },
+    "path": {
+      "type": "string",
+      "$default": {
+        "$source": "workingDirectory"
+      },
+      "description": "The path where the service files should be created, relative to the workspace root. If not provided, the service will be created in the project's `src/app` directory.",
+      "visible": false
+    },
+    "project": {
+      "type": "string",
+      "description": "The name of the project where the service should be added. If not specified, the CLI will determine the project from the current directory.",
+      "$default": {
+        "$source": "projectName"
+      }
+    },
+    "flat": {
+      "type": "boolean",
+      "default": true,
+      "description": "Creates files at the top level of the project or the given path. If set to false, a new folder with the service's name will be created to contain the files."
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Skip the generation of a unit test file `spec.ts` for the service.",
+      "default": false
+    },
+    "type": {
+      "type": "string",
+      "description": "Append a custom type to the service's filename. For example, if you set the type to `service`, the file will be named `my-service.service.ts`."
+    },
+    "addTypeToClassName": {
+      "type": "boolean",
+      "default": true,
+      "description": "When true, the 'type' option will be appended to the generated class name. When false, only the file name will include the type."
+    }
+  },
+  "required": ["name", "project"]
+}