@aligent/nx-cdk 0.0.1

package/README.md

@@ -0,0 +1,130 @@
+# Nx Cloud Development Kit
+
+The `@aligent/nx-cdk` package provides Nx generators for AWS CDK development. It helps you scaffold new CDK projects and services within an Nx monorepo structure.
+
+## Generators
+
+### Preset Generator
+
+The preset generator initializes a new CDK project with a complete workspace structure, including configuration files, build tools, and an application scaffold.
+
+#### Usage
+
+```bash
+npx create-nx-workspace@latest --preset=@aligent/nx-cdk
+```
+
+#### Options
+
+| Option        | Type   | Required | Default   | Description                                                                      |
+| ------------- | ------ | -------- | --------- | -------------------------------------------------------------------------------- |
+| `name`        | string | Yes      | -         | The name of the project/application (alphanumeric and dashes only)               |
+| `nodeVersion` | string | No       | `24.11.0` | The target Node.js version for the project (must be valid semver, e.g., 22.10.0) |
+
+#### What it creates
+
+The preset generator scaffolds:
+
+- **Root configuration files**:
+  - `eslint.config.mjs` - ESLint configuration
+  - `prettier.config.mjs` - Prettier configuration
+  - `rolldown.config.base.mjs` - Base Rolldown configuration
+  - `vitest.config.base.mjs` - Base Vitest configuration
+  - `vitest.global.setup.mjs` - Global Vitest setup
+  - `tsconfig.json` - Root TypeScript configuration
+  - `nx.json` - Nx workspace configuration
+  - `package.json` - Project dependencies and scripts
+  - `cdk-config.yml` - CDK configuration
+  - `LICENSE` - Project license
+
+- **Application folder** (`application/`):
+  - `cdk.json` - CDK app configuration
+  - `cdk.context.json` - CDK context
+  - `bin/main.ts` - CDK app entry point
+  - `lib/service-stacks.ts` - Service stacks definition
+  - TypeScript configurations (`tsconfig.json`, `tsconfig.lib.json`, `tsconfig.spec.json`)
+
+### Service Generator
+
+The service generator creates a new CDK service within the `services/` folder of your existing CDK project. Each service is configured as a separate package with its own build configuration and testing setup.
+
+#### Usage
+
+```bash
+npx nx g @aligent/nx-cdk:service <service-name>
+```
+
+#### Options
+
+| Option | Type   | Required | Description                                                               |
+| ------ | ------ | -------- | ------------------------------------------------------------------------- |
+| `name` | string | Yes      | The name of the service (cannot contain 'Stack' or 'Service' in the name) |
+
+#### What it creates
+
+The service generator creates a new service in `services/<service-name>/` with:
+
+- **Service files**:
+  - `src/index.ts` - Service entry point
+  - `package.json` - Service-specific dependencies
+  - `README.md` - Service documentation
+  - `eslint.config.mjs` - ESLint configuration
+  - `rolldown.config.mjs` - Rolldown configuration
+  - `vitest.config.mjs` - Vitest configuration
+  - TypeScript configurations (`tsconfig.json`, `tsconfig.lib.json`, `tsconfig.spec.json`)
+
+- **Root updates**:
+  - Adds the service to the root `tsconfig.json` references for proper TypeScript project references
+
+- **Application updates**:
+  - Adds the stack to the main CDK application
+
+#### Example
+
+```bash
+# Create a new service named "user-management"
+npx nx g @aligent/nx-cdk:service user-management
+
+# Create a new service named "payment-processing"
+npx nx g @aligent/nx-cdk:service payment-processing
+```
+
+## Project Structure
+
+After using both generators, your project structure will look like:
+
+```
+my-cdk-app/
+├── application/
+│   ├── bin/
+│   │   └── main.ts
+│   ├── lib/
+│   │   └── service-stacks.ts
+│   ├── _internal/
+│   │   ├── version-functions-aspect.ts
+│   │   ├── nodejs-function-defaults-injector.ts
+│   │   ├── step-function-defaults-injector.ts
+│   │   ├── log-group-defaults-injector.ts
+│   │   └── microservice-checks.ts
+│   ├── cdk.json
+│   ├── cdk.context.json
+│   └── package.json
+├── services/
+│   ├── user-management/
+│   │   ├── src/
+│   │   │   └── index.ts
+│   │   ├── package.json
+│   │   └── ...
+│   └── payment-processing/
+│       ├── src/
+│       │   └── index.ts
+│       ├── package.json
+│       └── ...
+├── nx.json
+├── package.json
+└── tsconfig.json
+```
+
+## License
+
+MIT

package/generators.json

@@ -0,0 +1,15 @@
+{
+    "generators": {
+        "preset": {
+            "factory": "./src/generators/preset/preset",
+            "schema": "./src/generators/preset/schema.json",
+            "description": "preset generator",
+            "x-use-standalone-layout": true
+        },
+        "service": {
+            "factory": "./src/generators/service/generator",
+            "schema": "./src/generators/service/schema.json",
+            "description": "Generate a new service"
+        }
+    }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@aligent/nx-cdk",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aligent/microservice-development-utilities.git",
+    "directory": "packages/nx-cdk"
+  },
+  "dependencies": {
+    "@nx/devkit": "20.8.1",
+    "ts-morph": "^27.0.2"
+  },
+  "generators": "./generators.json",
+  "author": "Aligent",
+  "license": "MIT",
+  "types": "./src/index.d.ts"
+}

package/src/generators/helpers/configs/nxJson.d.ts

@@ -0,0 +1,4 @@
+import { NxJsonConfiguration } from '@nx/devkit';
+export declare const NX_JSON: NxJsonConfiguration & {
+    $schema: string;
+};

package/src/generators/helpers/configs/nxJson.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_JSON = void 0;
+exports.NX_JSON = {
+    $schema: './node_modules/nx/schemas/nx-schema.json',
+    defaultBase: 'origin/staging',
+    plugins: [
+        { plugin: '@nx/eslint/plugin', options: {} },
+        { plugin: '@nx/vite/plugin', options: {} },
+        { plugin: '@nx/js/typescript', options: { build: false } },
+    ],
+    namedInputs: {
+        default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        production: [
+            'default',
+            '!{projectRoot}/.eslintrc.json',
+            '!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)',
+            '!{projectRoot}/tsconfig.spec.json',
+            '!{projectRoot}/vitest.config.m[jt]s',
+            '!{projectRoot}/src/test-setup.[jt]s',
+        ],
+        sharedGlobals: [],
+    },
+    targetDefaults: {
+        build: {
+            cache: true,
+            dependsOn: ['^build'],
+            inputs: ['production', '^production'],
+            outputs: ['{projectRoot}/dist'],
+        },
+        cdk: { dependsOn: ['^build', '^build:lambda'], inputs: ['production', '^production'] },
+        lint: { cache: true, inputs: ['default'] },
+        test: {
+            cache: true,
+            inputs: ['default', '^production'],
+            outputs: ['{projectRoot}/coverage'],
+            // Stack tests may require lambda handlers to be built first
+            dependsOn: ['^build', 'build:lambda'],
+            configurations: { coverage: { coverage: true } },
+        },
+        typecheck: { cache: true, dependsOn: ['^build'], inputs: ['production', '^production'] },
+        parameters: {
+            executor: 'nx:run-commands',
+            options: { color: true, cwd: '{projectRoot}/parameters', file: '.env.csv' },
+            defaultConfiguration: 'export',
+            configurations: {
+                import: { command: 'store-parameters import {args.file}' },
+                export: { command: 'store-parameters export {args.file} --path={args.path}' },
+            },
+        },
+    },
+};

package/src/generators/helpers/configs/packageJson.d.ts

@@ -0,0 +1,61 @@
+export declare const PACKAGE_JSON: {
+    readonly author: "Aligent";
+    readonly private: true;
+    readonly license: "MIT";
+    readonly type: "module";
+    readonly scripts: {
+        readonly test: "nx affected -t test --coverage";
+        readonly 'test:all': "nx run-many -t test --coverage";
+        readonly lint: "nx affected -t lint";
+        readonly 'lint:all': "nx run-many -t lint";
+        readonly typecheck: "nx affected -t typecheck";
+        readonly 'typecheck:all': "nx run-many -t typecheck";
+        readonly postinstall: "[ -d .git ] && git config core.hooksPath '.git-hooks' && chmod +x .git-hooks/* || true";
+        readonly 'pg:synth': "nx run application:cdk synth 'development/**' --exclusively --profile playground";
+        readonly 'pg:deploy': "nx run application:cdk deploy --method 'direct' 'development/**' --exclusively --require-approval never --profile playground";
+        readonly 'pg:destroy': "nx run application:cdk destroy 'development/**' --profile playground";
+        readonly audit: "nx run-many -t lint typecheck test --configuration coverage --skip-nx-cache";
+    };
+    readonly dependencies: {
+        readonly '@aligent/microservice-util-lib': "^1.2.0";
+    };
+    readonly devDependencies: {
+        readonly '@aligent/cdk-step-function-from-file': "^0.3.2";
+        readonly '@aligent/nx-openapi': "^1.0.0";
+        readonly '@aligent/ts-code-standards': "^4.1.0";
+        readonly '@nx/eslint': "22.1.3";
+        readonly '@nx/eslint-plugin': "22.1.3";
+        readonly '@nx/js': "22.1.3";
+        readonly '@nx/vite': "22.1.3";
+        readonly '@swc-node/register': "^1.10.10";
+        readonly '@swc/core': "^1.13.3";
+        readonly '@swc/helpers': "^0.5.17";
+        readonly '@types/aws-lambda': "^8.10.152";
+        readonly '@types/node': "^22.17.0";
+        readonly '@typescript-eslint/eslint-plugin': "8.44.0";
+        readonly '@typescript-eslint/parser': "8.44.0";
+        readonly '@vitest/coverage-v8': "^3.2.4";
+        readonly '@vitest/ui': "^3.2.4";
+        readonly 'aws-cdk': "^2.1033.0";
+        readonly 'aws-cdk-lib': "^2.230.0";
+        readonly 'cdk-nag': "^2.37.55";
+        readonly constructs: "^10.4.3";
+        readonly eslint: "^9.32.0";
+        readonly 'eslint-config-prettier': "^10.1.8";
+        readonly 'eslint-plugin-import': "^2.32.0";
+        readonly 'fast-glob': "^3.3.3";
+        readonly jiti: "2.5.1";
+        readonly 'jsonc-eslint-parser': "^2.4.0";
+        readonly nx: "22.1.3";
+        readonly prettier: "^3.6.2";
+        readonly rolldown: "1.0.0-beta.53";
+        readonly 'store-parameters': "^1.1.3";
+        readonly tslib: "^2.8.1";
+        readonly tsx: "^4.21.0";
+        readonly typescript: "~5.9.2";
+        readonly vite: "^7.2.6";
+        readonly vitest: "^3.2.4";
+    };
+    readonly workspaces: readonly ["application", "clients", "libs/*", "services/*"];
+    readonly packageManager: "yarn@4.12.0+sha512.f45ab632439a67f8bc759bf32ead036a1f413287b9042726b7cc4818b7b49e14e9423ba49b18f9e06ea4941c1ad062385b1d8760a8d5091a1a31e5f6219afca8";
+};

package/src/generators/helpers/configs/packageJson.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_JSON = void 0;
+exports.PACKAGE_JSON = {
+    author: 'Aligent',
+    private: true,
+    license: 'MIT',
+    type: 'module',
+    scripts: {
+        test: 'nx affected -t test --coverage',
+        'test:all': 'nx run-many -t test --coverage',
+        lint: 'nx affected -t lint',
+        'lint:all': 'nx run-many -t lint',
+        typecheck: 'nx affected -t typecheck',
+        'typecheck:all': 'nx run-many -t typecheck',
+        postinstall: `[ -d .git ] && git config core.hooksPath '.git-hooks' && chmod +x .git-hooks/* || true`,
+        'pg:synth': `nx run application:cdk synth 'development/**' --exclusively --profile playground`,
+        'pg:deploy': `nx run application:cdk deploy --method 'direct' 'development/**' --exclusively --require-approval never --profile playground`,
+        'pg:destroy': "nx run application:cdk destroy 'development/**' --profile playground",
+        audit: 'nx run-many -t lint typecheck test --configuration coverage --skip-nx-cache',
+    },
+    dependencies: {
+        '@aligent/microservice-util-lib': '^1.2.0',
+    },
+    devDependencies: {
+        '@aligent/cdk-step-function-from-file': '^0.3.2',
+        '@aligent/nx-openapi': '^1.0.0',
+        '@aligent/ts-code-standards': '^4.1.0',
+        '@nx/eslint': '22.1.3',
+        '@nx/eslint-plugin': '22.1.3',
+        '@nx/js': '22.1.3',
+        '@nx/vite': '22.1.3',
+        '@swc-node/register': '^1.10.10',
+        '@swc/core': '^1.13.3',
+        '@swc/helpers': '^0.5.17',
+        '@types/aws-lambda': '^8.10.152',
+        '@types/node': '^22.17.0',
+        '@typescript-eslint/eslint-plugin': '8.44.0',
+        '@typescript-eslint/parser': '8.44.0',
+        '@vitest/coverage-v8': '^3.2.4',
+        '@vitest/ui': '^3.2.4',
+        'aws-cdk': '^2.1033.0',
+        'aws-cdk-lib': '^2.230.0',
+        'cdk-nag': '^2.37.55',
+        constructs: '^10.4.3',
+        eslint: '^9.32.0',
+        'eslint-config-prettier': '^10.1.8',
+        'eslint-plugin-import': '^2.32.0',
+        'fast-glob': '^3.3.3',
+        jiti: '2.5.1',
+        'jsonc-eslint-parser': '^2.4.0',
+        nx: '22.1.3',
+        prettier: '^3.6.2',
+        // FIXME: [MI-251] Rolldown is still in beta. We pin the version and can upgrade with precaution.
+        rolldown: '1.0.0-beta.53',
+        'store-parameters': '^1.1.3',
+        tslib: '^2.8.1',
+        tsx: '^4.21.0',
+        typescript: '~5.9.2',
+        vite: '^7.2.6',
+        vitest: '^3.2.4',
+    },
+    workspaces: ['application', 'clients', 'libs/*', 'services/*'],
+    packageManager: 'yarn@4.12.0+sha512.f45ab632439a67f8bc759bf32ead036a1f413287b9042726b7cc4818b7b49e14e9423ba49b18f9e06ea4941c1ad062385b1d8760a8d5091a1a31e5f6219afca8',
+};

package/src/generators/helpers/configs/tsConfigs.d.ts

@@ -0,0 +1,12 @@
+interface TsConfig {
+    extends: string;
+    compilerOptions?: Record<string, unknown>;
+    files?: string[];
+    include: string[];
+    exclude?: string[];
+    references: Array<Record<string, string>>;
+}
+export declare const TS_CONFIG_JSON: TsConfig;
+export declare const TS_CONFIG_LIB_JSON: TsConfig;
+export declare const TS_CONFIG_SPEC_JSON: TsConfig;
+export {};

package/src/generators/helpers/configs/tsConfigs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TS_CONFIG_SPEC_JSON = exports.TS_CONFIG_LIB_JSON = exports.TS_CONFIG_JSON = void 0;
+const BASE_CONFIG = '@aligent/ts-code-standards/tsconfigs-extend';
+exports.TS_CONFIG_JSON = {
+    extends: BASE_CONFIG,
+    files: [],
+    include: [],
+    references: [],
+};
+exports.TS_CONFIG_LIB_JSON = {
+    extends: BASE_CONFIG,
+    compilerOptions: {
+        baseUrl: '.',
+        rootDir: 'src',
+        outDir: 'dist',
+        tsBuildInfoFile: 'dist/tsconfig.lib.tsbuildinfo',
+        types: ['node'],
+    },
+    include: ['src/**/*.ts'],
+    exclude: ['vite.config.mjs', 'src/**/*.spec.ts', 'src/**/*.test.ts'],
+    references: [],
+};
+exports.TS_CONFIG_SPEC_JSON = {
+    extends: BASE_CONFIG,
+    compilerOptions: {
+        outDir: './out-tsc/vitest',
+        types: ['vitest/globals', 'vitest/importMeta', 'vite/client', 'node', 'vitest'],
+    },
+    include: [
+        'vite.config.mjs',
+        'src/**/*.test.ts',
+        'src/**/*.spec.ts',
+        'src/**/*.d.ts',
+        'tests/**/*.test.ts',
+        'tests/**/*.spec.ts',
+        'tests/**/*.d.ts',
+    ],
+    references: [{ path: './tsconfig.lib.json' }],
+};

package/src/generators/helpers/utilities.d.ts

@@ -0,0 +1,82 @@
+import { Tree } from '@nx/devkit';
+interface PackageJsonInput {
+    name: string;
+    projectName: string;
+    version: string;
+    nodeVersion: string;
+}
+interface Service {
+    name: string;
+    constant: string;
+    stack: string;
+}
+export declare function constructPackageJsonFile(input: PackageJsonInput): {
+    [k: string]: string | true | readonly ["application", "clients", "libs/*", "services/*"] | {
+        readonly test: "nx affected -t test --coverage";
+        readonly 'test:all': "nx run-many -t test --coverage";
+        readonly lint: "nx affected -t lint";
+        readonly 'lint:all': "nx run-many -t lint";
+        readonly typecheck: "nx affected -t typecheck";
+        readonly 'typecheck:all': "nx run-many -t typecheck";
+        readonly postinstall: "[ -d .git ] && git config core.hooksPath '.git-hooks' && chmod +x .git-hooks/* || true";
+        readonly 'pg:synth': "nx run application:cdk synth 'development/**' --exclusively --profile playground";
+        readonly 'pg:deploy': "nx run application:cdk deploy --method 'direct' 'development/**' --exclusively --require-approval never --profile playground";
+        readonly 'pg:destroy': "nx run application:cdk destroy 'development/**' --profile playground";
+        readonly audit: "nx run-many -t lint typecheck test --configuration coverage --skip-nx-cache";
+    } | {
+        readonly '@aligent/microservice-util-lib': "^1.2.0";
+    } | {
+        [k: string]: string;
+    } | {
+        node: string;
+    };
+};
+export declare function constructProjectTsConfigFiles(type: 'application' | 'service'): {
+    tsConfig: {
+        extends: string;
+        compilerOptions?: Record<string, unknown>;
+        files?: string[];
+        include: string[];
+        exclude?: string[];
+        references: Array<Record<string, string>>;
+    };
+    tsConfigLib: {
+        extends: string;
+        compilerOptions?: Record<string, unknown>;
+        files?: string[];
+        include: string[];
+        exclude?: string[];
+        references: Array<Record<string, string>>;
+    };
+    tsConfigSpec: {
+        extends: string;
+        compilerOptions?: Record<string, unknown>;
+        files?: string[];
+        include: string[];
+        exclude?: string[];
+        references: Array<Record<string, string>>;
+    };
+};
+export declare function getGeneratorVersion(): string;
+/**
+ * Automatically registers a service stack to the main CDK application's ApplicationStage.
+ *
+ * This function modifies the service-stacks.ts file by:
+ * 1. Adding import statements for the service's stack class and constants
+ * 2. Instantiating the stack within the ApplicationStage constructor
+ *
+ * @param tree - The Nx virtual file system tree
+ * @param service - Service information containing name, constant, and stack class names
+ * @param projectName - The name of the main application project to register the service to
+ *
+ * @throws {Error} If the ApplicationStage constructor cannot be found in service-stacks.ts
+ */
+export declare function addServiceStackToMainApplication(tree: Tree, service: Service, projectName: string): Promise<void>;
+/**
+ * Splits a kebab-case name into an array of capitalized parts.
+ *
+ * @param name - The kebab-case string to split (e.g., "my-service-name")
+ * @returns An array of strings with each part capitalized (e.g., ["My", "Service", "Name"])
+ */
+export declare function splitInputName(name: string): string[];
+export {};

package/src/generators/helpers/utilities.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructPackageJsonFile = constructPackageJsonFile;
+exports.constructProjectTsConfigFiles = constructProjectTsConfigFiles;
+exports.getGeneratorVersion = getGeneratorVersion;
+exports.addServiceStackToMainApplication = addServiceStackToMainApplication;
+exports.splitInputName = splitInputName;
+/* v8 ignore start */
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ts_morph_1 = require("ts-morph");
+const packageJson_1 = require("./configs/packageJson");
+const tsConfigs_1 = require("./configs/tsConfigs");
+function constructPackageJsonFile(input) {
+    const devDependencies = Object.fromEntries(Object.entries({
+        '@aligent/nx-cdk': input.version,
+        ...packageJson_1.PACKAGE_JSON.devDependencies,
+    }).sort());
+    const packageJson = Object.fromEntries(Object.entries({
+        name: `@${input.name}/integrations`,
+        description: `${input.projectName} integrations mono-repository`,
+        version: input.version,
+        ...packageJson_1.PACKAGE_JSON,
+        devDependencies,
+        engines: { node: `^${input.nodeVersion}` },
+    }));
+    return packageJson;
+}
+function constructProjectTsConfigFiles(type) {
+    const tsConfig = { ...tsConfigs_1.TS_CONFIG_JSON };
+    if (type === 'service') {
+        tsConfig.references = [{ path: './tsconfig.lib.json' }, { path: './tsconfig.spec.json' }];
+    }
+    return {
+        tsConfig,
+        tsConfigLib: { ...tsConfigs_1.TS_CONFIG_LIB_JSON },
+        tsConfigSpec: { ...tsConfigs_1.TS_CONFIG_SPEC_JSON },
+    };
+}
+function isPackageJsonWithVersion(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'version' in obj &&
+        typeof obj.version === 'string');
+}
+function getGeneratorVersion() {
+    const packagePath = (0, path_1.join)(__dirname, '../../../package.json');
+    const packageJson = (0, devkit_1.readJsonFile)(packagePath);
+    if (isPackageJsonWithVersion(packageJson)) {
+        return packageJson.version;
+    }
+    throw new Error(`Unable to get generator version from ${packagePath}`);
+}
+/**
+ * Automatically registers a service stack to the main CDK application's ApplicationStage.
+ *
+ * This function modifies the service-stacks.ts file by:
+ * 1. Adding import statements for the service's stack class and constants
+ * 2. Instantiating the stack within the ApplicationStage constructor
+ *
+ * @param tree - The Nx virtual file system tree
+ * @param service - Service information containing name, constant, and stack class names
+ * @param projectName - The name of the main application project to register the service to
+ *
+ * @throws {Error} If the ApplicationStage constructor cannot be found in service-stacks.ts
+ */
+async function addServiceStackToMainApplication(tree, service, projectName) {
+    const application = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    if (application.root.includes('..')) {
+        throw new Error('Invalid application root path');
+    }
+    const stacksPath = (0, path_1.join)(tree.root, application.root, 'lib/service-stacks.ts');
+    if (!(0, fs_1.existsSync)(stacksPath)) {
+        console.log('Service Stacks does not exist, skipping service stacks registration.');
+        return;
+    }
+    const project = new ts_morph_1.Project();
+    const stackSource = project.addSourceFileAtPath(stacksPath);
+    const applicationStage = stackSource.getClassOrThrow('ApplicationStage');
+    const stageConstructors = applicationStage?.getConstructors();
+    if (!stageConstructors?.length) {
+        throw new Error('Unable to find main application stage constructor');
+    }
+    stackSource.addImportDeclaration({
+        moduleSpecifier: `@services/${service.name}`,
+        namedImports: [service.constant, service.stack],
+    });
+    stageConstructors[0]?.addStatements(`new ${service.stack}(this, ${service.constant}.NAME, { ...props, description: ${service.constant}.DESCRIPTION });`);
+    await stackSource?.save();
+}
+/**
+ * Splits a kebab-case name into an array of capitalized parts.
+ *
+ * @param name - The kebab-case string to split (e.g., "my-service-name")
+ * @returns An array of strings with each part capitalized (e.g., ["My", "Service", "Name"])
+ */
+function splitInputName(name) {
+    return name.split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1));
+}

package/src/generators/preset/files/.editorconfig.template

@@ -0,0 +1,18 @@
+# Editor configuration, see http://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+max_line_length = 100
+
+[{package.json,*.yml,*.md}]
+indent_size = 2
+indent_style = space
+
+[*.md]
+trim_trailing_whitespace = false