@aligent/nx-cdk 0.0.1

package/src/generators/preset/files/application/_internal/step-function-defaults-injector.ts.template

@@ -0,0 +1,126 @@
+import { type InjectionContext, type IPropertyInjector } from 'aws-cdk-lib';
+import { LogGroup } from 'aws-cdk-lib/aws-logs';
+import {
+    LogLevel,
+    StateMachine,
+    StateMachineType,
+    type StateMachineProps,
+} from 'aws-cdk-lib/aws-stepfunctions';
+import type { Construct } from 'constructs';
+
+type StepFunctionDefaults = Omit<StateMachineProps, 'definition' | 'definitionSubstitutions'>;
+
+/**
+ * Property injector for Step Functions with configuration-aware defaults
+ *
+ * Applies configuration-specific settings to Step Functions. All configurations enable
+ * X-Ray tracing by default for observability. For EXPRESS state machines, automatically
+ * creates log groups and configures comprehensive logging.
+ *
+ * @example
+ * ```typescript
+ * // Apply configuration-specific defaults
+ * PropertyInjectors.of(scope).add(
+ *   new StepFunctionDefaultsInjector('dev').withProps({
+ *     timeout: Duration.minutes(30),
+ *   })
+ * );
+ *
+ * // Step Functions automatically inherit defaults
+ * new StateMachine(stack, 'MyWorkflow', {
+ *   stateMachineType: StateMachineType.EXPRESS,
+ *   definitionBody: DefinitionBody.fromFile('workflow.asl.yaml'),
+ *   // tracing enabled and logging configured automatically for EXPRESS
+ * });
+ * ```
+ *
+ * @see https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.StateMachine.html
+ */
+export class StepFunctionDefaultsInjector implements IPropertyInjector {
+    public readonly constructUniqueId = StateMachine.PROPERTY_INJECTION_ID;
+    private readonly config: Record<string, never>;
+    private defaultProps: StateMachineProps;
+
+    /**
+     * Creates a new StepFunctionDefaultsInjector
+     *
+     * @param config - Configuration identifier (currently unused but maintained for consistency).
+     *                 All configurations enable tracing by default.
+     */
+    constructor(config: Record<string, never> = {}) {
+        this.config = { ...config };
+        this.defaultProps = { tracingEnabled: true };
+    }
+
+    /**
+     * Creates a new injector instance with additional properties
+     *
+     * Returns a new injector that inherits the current configuration but includes
+     * additional properties that override the configuration defaults.
+     *
+     * @param props - Additional properties to merge with configuration defaults
+     * @returns A new injector instance with merged properties
+     *
+     * @example
+     * ```typescript
+     * const customInjector = new StepFunctionDefaultsInjector('prod')
+     *   .withProps({
+     *     timeout: Duration.hours(1),
+     *     stateMachineName: 'custom-workflow',
+     *   });
+     * ```
+     */
+    public withProps(props: StateMachineProps) {
+        const modifiedInjector = new StepFunctionDefaultsInjector(this.config);
+        modifiedInjector.defaultProps = { ...this.defaultProps, ...props };
+        return modifiedInjector;
+    }
+
+    /**
+     * Injects configuration-appropriate defaults into Step Function properties
+     *
+     * Enables X-Ray tracing for all state machines. For EXPRESS state machines,
+     * automatically creates log groups and configures comprehensive logging.
+     *
+     * @param originalProps - Properties provided when creating the state machine
+     * @param context - CDK injection context containing construct information
+     * @returns Merged properties with injected defaults and logging configuration
+     */
+    public inject(originalProps: StateMachineProps, context: InjectionContext) {
+        // Prepare logging configuration for EXPRESS step functions
+        const logging = expressLogProperties(context.scope, context.id, originalProps);
+        return { ...this.defaultProps, ...originalProps, ...logging };
+    }
+}
+
+/**
+ * Build the logging configuration for an express step function, respecting
+ * existing logging configuration.
+ *
+ * @param machineScope - The scope of the step function.
+ * @param machineId - The id of the step function.
+ * @param props - The properties for the step function.
+ * @returns The logging configuration for an express step function
+ */
+function expressLogProperties(
+    machineScope: Construct,
+    machineId: string,
+    props: StepFunctionDefaults
+) {
+    if (props.stateMachineType !== StateMachineType.EXPRESS) {
+        return {};
+    }
+
+    // Create a new log group if one is not provided
+    const logGroup =
+        props.logs?.destination ?? new LogGroup(machineScope, `/aws/states/${machineId}`);
+
+    return {
+        logs: {
+            destination: logGroup,
+            level: LogLevel.ALL,
+            includeExecutionData: true,
+            ...props.logs,
+        },
+    };
+}

package/src/generators/preset/files/application/_internal/version-functions-aspect.ts.template

@@ -0,0 +1,74 @@
+import type { IAspect } from 'aws-cdk-lib';
+import { Function } from 'aws-cdk-lib/aws-lambda';
+import {
+    CfnStateMachineAlias,
+    CfnStateMachineVersion,
+    StateMachine,
+} from 'aws-cdk-lib/aws-stepfunctions';
+import { IConstruct } from 'constructs';
+
+/**
+ * Aspect that automatically adds versioning and aliases to Lambda and Step Functions
+ *
+ * Visits all constructs in the scope and automatically creates versions and aliases
+ * for supported resource types. This enables blue-green deployments, traffic shifting,
+ * and provides stable ARNs for external integrations.
+ *
+ * Currently supports:
+ * - Lambda Functions: Creates function aliases
+ * - Step Functions: Creates versions and aliases with 100% traffic routing
+ *
+ * @example
+ * ```typescript
+ * // Apply to entire app for automatic versioning
+ * Aspects.of(app).add(new VersionFunctionsAspect());
+ *
+ * // Or with custom alias name
+ * Aspects.of(app).add(new VersionFunctionsAspect({ alias: 'PROD' }));
+ * ```
+ */
+export class VersionFunctionsAspect implements IAspect {
+    /**
+     * Creates a new VersionFunctionsAspect
+     *
+     * @param props - Configuration for the aspect
+     * @param props.alias - Name for the alias to create. Defaults to 'LATEST'
+     */
+    constructor(
+        private readonly props: {
+            alias: string;
+        } = {
+            alias: 'LATEST',
+        }
+    ) {}
+
+    /**
+     * Visits a construct and applies versioning if it's a supported resource type
+     *
+     * For Lambda Functions: Adds a function alias pointing to $LATEST
+     * For Step Functions: Creates a version and alias with 100% traffic routing
+     *
+     * @param node - The construct to potentially add versioning to
+     */
+    visit(node: IConstruct): void {
+        if (node instanceof StateMachine) {
+            const version = new CfnStateMachineVersion(node, `Version`, {
+                stateMachineArn: node.stateMachineArn,
+            });
+
+            new CfnStateMachineAlias(node, `Alias`, {
+                name: this.props.alias,
+                routingConfiguration: [
+                    {
+                        stateMachineVersionArn: version.attrArn,
+                        weight: 100,
+                    },
+                ],
+            });
+        }
+
+        if (node instanceof Function) {
+            node.addAlias(this.props.alias);
+        }
+    }
+}

package/src/generators/preset/files/application/bin/main.ts.template

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { App, Aspects, Tags } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import { ApplicationStage } from '../lib/service-stacks.js';
+
+// TODO [MI-277] Pull this out to constructs repo so we can import and use later
+import { LogGroupDefaultsInjector } from '../_internal/log-group-defaults-injector.js';
+import { MicroserviceChecks } from '../_internal/microservice-checks.js';
+import { NodeJsFunctionDefaultsInjector } from '../_internal/nodejs-function-defaults-injector.js';
+import { StepFunctionDefaultsInjector } from '../_internal/step-function-defaults-injector.ts';
+import { VersionFunctionsAspect } from '../_internal/version-functions-aspect.js';
+
+const APPLICATION_CONTEXT = { APPLICATION_OWNER: 'aligent' } as const;
+
+const app = new App({
+    context: APPLICATION_CONTEXT,
+    propertyInjectors: [
+        new NodeJsFunctionDefaultsInjector({ runtime: <%= nodeRuntime %> }),
+        new StepFunctionDefaultsInjector(),
+    ],
+});
+Tags.of(app).add('OWNER', APPLICATION_CONTEXT.APPLICATION_OWNER);
+
+/**
+ * Static Stage Creation Approach
+ *
+ * We use static stage creation (explicitly defining development, staging, production) for several reasons:
+ *
+ * 1. **Predictability**: All stages are known at synthesis time, making the CDK app
+ *    behavior deterministic and easier to reason about.
+ *
+ * 2. **Type Safety**: Static definitions provide better IDE support, autocompletion,
+ *    and compile-time type checking for stage-specific configurations.
+ *
+ * 3. **Explicit Configuration**: Each stage's unique settings (e.g., log retention
+ *    durations, aspects, property injectors) are clearly visible in the code without
+ *    needing to trace through dynamic logic.
+ *
+ * 4. **Simpler Deployment**: CDK can synthesize all stages in a single pass without
+ *    requiring runtime context lookups or conditional logic.
+ *
+ * 5. **CI/CD Integration**: Static stages integrate seamlessly with standard CI/CD
+ *    pipelines where environment configuration is managed externally.
+ *
+ * @see {@link https://dev.to/aws-heroes/how-to-use-aws-cdk-stage-and-when-to-choose-static-vs-dynamic-stack-creation-35h|Static vs Dynamic Stack Creation}
+ *
+ * @remarks Property Injector Behavior
+ * Property injectors are applied based on their class type and will only execute once per
+ * construct tree. When the same injector type is defined at both app and stage levels, the
+ * stage-level injector takes precedence and overrides the app-level configuration.
+ */
+const development = new ApplicationStage(app, 'development', {
+    propertyInjectors: [new LogGroupDefaultsInjector({ duration: 'SHORT' })],
+});
+Aspects.of(development).add(new MicroserviceChecks());
+
+const staging = new ApplicationStage(app, 'staging', {
+    propertyInjectors: [new LogGroupDefaultsInjector({ duration: 'MEDIUM' })],
+});
+Aspects.of(staging).add(new MicroserviceChecks());
+
+const production = new ApplicationStage(app, 'production', {
+    propertyInjectors: [new LogGroupDefaultsInjector({ duration: 'LONG' })],
+});
+Aspects.of(production).add(new MicroserviceChecks());
+
+/**
+ * This aspect ensures all Lambda functions and Step Functions in production
+ * are automatically versioned and have a stable 'live' alias pointing to the
+ * current version, enabling zero-downtime deployments.
+ */
+Aspects.of(production).add(new VersionFunctionsAspect());

package/src/generators/preset/files/application/cdk.context.json.template

@@ -0,0 +1,4 @@
+{
+    "cli-telemetry": false,
+    "acknowledged-issue-numbers": [34892]
+}

package/src/generators/preset/files/application/cdk.json.template

@@ -0,0 +1,92 @@
+{
+    "app": "npx tsx bin/main.ts",
+    "watch": {
+        "include": ["**"],
+        "exclude": [
+            "README.md",
+            "cdk*.json",
+            "**/*.d.ts",
+            "**/*.js",
+            "tsconfig.json",
+            "package*.json",
+            "yarn.lock",
+            "node_modules",
+            "test"
+        ]
+    },
+    "context": {
+        "@aws-cdk/aws-lambda:recognizeLayerVersion": true,
+        "@aws-cdk/core:checkSecretUsage": true,
+        "@aws-cdk/core:target-partitions": ["aws", "aws-cn"],
+        "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+        "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
+        "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true,
+        "@aws-cdk/aws-iam:minimizePolicies": true,
+        "@aws-cdk/core:validateSnapshotRemovalPolicy": true,
+        "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true,
+        "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true,
+        "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true,
+        "@aws-cdk/aws-apigateway:disableCloudWatchRole": true,
+        "@aws-cdk/core:enablePartitionLiterals": true,
+        "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true,
+        "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true,
+        "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true,
+        "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true,
+        "@aws-cdk/aws-route53-patters:useCertificate": true,
+        "@aws-cdk/customresources:installLatestAwsSdkDefault": false,
+        "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true,
+        "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true,
+        "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true,
+        "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true,
+        "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true,
+        "@aws-cdk/aws-redshift:columnId": true,
+        "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true,
+        "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true,
+        "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true,
+        "@aws-cdk/aws-kms:aliasNameRef": true,
+        "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true,
+        "@aws-cdk/core:includePrefixInUniqueNameGeneration": true,
+        "@aws-cdk/aws-efs:denyAnonymousAccess": true,
+        "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": true,
+        "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true,
+        "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": true,
+        "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": true,
+        "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": true,
+        "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true,
+        "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": true,
+        "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true,
+        "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": true,
+        "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": true,
+        "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": true,
+        "@aws-cdk/aws-eks:nodegroupNameAttribute": true,
+        "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": true,
+        "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true,
+        "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false,
+        "@aws-cdk/aws-s3:keepNotificationInImportedBucket": false,
+        "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature": false,
+        "@aws-cdk/aws-ecs:disableEcsImdsBlocking": true,
+        "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": true,
+        "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": true,
+        "@aws-cdk/aws-ec2:ec2SumTImeoutEnabled": true,
+        "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission": true,
+        "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId": true,
+        "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics": true,
+        "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages": true,
+        "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy": true,
+        "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault": true,
+        "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource": true,
+        "@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault": true,
+        "@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections": true,
+        "@aws-cdk/core:enableAdditionalMetadataCollection": true,
+        "@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy": false,
+        "@aws-cdk/aws-s3:setUniqueReplicationRoleName": true,
+        "@aws-cdk/aws-events:requireEventBusPolicySid": true,
+        "@aws-cdk/core:aspectPrioritiesMutating": true,
+        "@aws-cdk/aws-dynamodb:retainTableReplica": true,
+        "@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2": true,
+        "@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions": true,
+        "@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway": true,
+        "@aws-cdk/aws-s3:publicAccessBlockedByDefault": true,
+        "@aws-cdk/aws-lambda:useCdkManagedLogGroup": true
+    }
+}

package/src/generators/preset/files/application/eslint.config.mjs.template

@@ -0,0 +1,3 @@
+import baseConfig from '../eslint.config.mjs';
+
+export default [...baseConfig];

package/src/generators/preset/files/application/lib/service-stacks.ts.template

@@ -0,0 +1,21 @@
+import { Stage, Tags, type StageProps } from 'aws-cdk-lib';
+import type { Construct } from 'constructs';
+
+/**
+ * Application Stage
+ *
+ * This is the main entry point for the application.
+ * It is used to define context and compose service stacks.
+ *
+ * Service stacks are automatically instantiated here when generated using the service generator.
+ * Each service stack will be initialized with this stage as the parent scope, ensuring proper
+ * stack composition and resource organization within the CDK application.
+ */
+export class ApplicationStage extends Stage {
+    constructor(scope: Construct, id: string, props?: StageProps) {
+        super(scope, id, props);
+        Tags.of(this).add('STAGE', id);
+
+        // Service stacks initialization
+    }
+}

package/src/generators/preset/files/application/package.json.template

@@ -0,0 +1,27 @@
+{
+  "name": "application",
+  "type": "module",
+  "main": "./bin/main.ts",
+  "types": "./bin/main.ts",
+  "nx": {
+    "tags": [
+      "scope:application"
+    ],
+    "targets": {
+      "cdk": {
+        "executor": "nx:run-commands",
+        "options": {
+          "color": true,
+          "command": "cdk",
+          "cwd": "{projectRoot}"
+        }
+      },
+      "parameters": {
+        "executor": "nx:run-commands",
+        "options": {
+          "path": "/application/dev"
+        }
+      }
+    }
+  }
+}

package/src/generators/preset/files/cdk-config.yml.template

@@ -0,0 +1,16 @@
+cdk-pipe:
+  commands:
+    cdk:
+      bootstrap: yarn nx run application:cdk bootstrap
+      deploy: yarn nx run application:cdk deploy
+      synth: yarn nx run application:cdk synth
+      diff: yarn nx run application:cdk diff
+    npm:
+      checks:
+        lint: yarn lint
+        format: yarn lint # Formatting is controlled by the lint step, we turn this off in the pipeline anyway
+      install: yarn install --immutable
+  beforeScripts:
+    - yarn --version
+  afterScripts:
+    - echo "Deployment is completed"

package/src/generators/preset/files/eslint.config.mjs.template

@@ -0,0 +1,54 @@
+import { eslintConfigs } from '@aligent/ts-code-standards';
+import nxEslintPlugin from '@nx/eslint-plugin';
+import jsonParser from 'jsonc-eslint-parser';
+
+const eslintBaseConfig = [
+    ...eslintConfigs.base,
+    {
+        ignores: [
+            '**/*.js',
+            '**/*.cjs',
+            '**/*.mjs',
+            '**/coverage',
+            '**/cdk.out',
+            '**/dist',
+            '**/out-tsc',
+            '**/vite.config.*.timestamp*',
+            '**/vitest.config.*.timestamp*',
+        ],
+    },
+    {
+        files: ['**/*.ts'],
+        plugins: { '@nx': nxEslintPlugin },
+        rules: {
+            '@nx/enforce-module-boundaries': [
+                'error',
+                {
+                    allow: ['^.*/eslint(\\.base)?\\.config\\.[cm]?[jt]s$'],
+                    enforceBuildableLibDependency: true,
+                    depConstraints: [
+                        {
+                            sourceTag: 'scope:application',
+                            onlyDependOnLibsWithTags: ['scope:libs', 'scope:services'],
+                        },
+                        {
+                            sourceTag: 'scope:services',
+                            onlyDependOnLibsWithTags: ['scope:libs', 'scope:services'],
+                        },
+                        {
+                            sourceTag: 'scope:libs',
+                            onlyDependOnLibsWithTags: ['scope:libs'],
+                        },
+                    ],
+                },
+            ],
+            'no-console': 'warn',
+        },
+    },
+    {
+        files: ['**/*.json'],
+        languageOptions: { parser: jsonParser },
+    },
+];
+
+export default eslintBaseConfig;

package/src/generators/preset/files/prettier.config.mjs.template

@@ -0,0 +1,3 @@
+import { prettierConfig } from '@aligent/ts-code-standards';
+
+export default prettierConfig;

package/src/generators/preset/files/rolldown.config.base.mjs.template

@@ -0,0 +1,46 @@
+import fg from 'fast-glob';
+import { builtinModules } from 'node:module';
+import { extname, resolve } from 'node:path';
+import { defineConfig } from 'rolldown';
+
+/**
+ * Prepare Rolldown config that bundles all typescript files in a single directory in to separate files
+ * This is used to bundle lambda handlers with their own dependencies for separate upload to AWS Lambda
+ *
+ * @param {string} subPath Relative path to the handlers directory
+ * @returns Rolldown config for multiple lambda handlers
+ */
+export function defineLambdaConfig(subPath) {
+    if (subPath.includes('..')) throw new Error('Invalid path provided');
+    const handlersPath = resolve(process.cwd(), subPath);
+    const handlers = fg.sync(`${handlersPath}/**/*.ts`);
+
+    return handlers.map(handler => {
+        const bundledPath = handler.replace(`${handlersPath}/`, '');
+        const entryName = bundledPath.replace(extname(bundledPath), '');
+
+        return defineConfig({
+            input: { [entryName]: handler },
+            platform: 'node',
+            tsconfig: 'tsconfig.lib.json',
+            logLevel: 'info',
+            watch: false,
+            external: [...builtinModules],
+            output: {
+                entryFileNames: '[name]/index.mjs',
+                format: 'esm',
+                // TODO: [MI-251] Support sourcemap enable/disable base on environment
+                sourcemap: true,
+                // FIXME: [MI-251] Rolldown is still in Beta and built-in minification is not production ready yet
+                minify: false,
+                legalComments: 'none',
+                inlineDynamicImports: true,
+                // TODO: [MI-251] Support shims only when needed instead consider looking at tsup, tsdown and rollup shims plugins
+                banner: `import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);`,
+            },
+        });
+    });
+}

package/src/generators/preset/files/tsconfig.json.template

@@ -0,0 +1,6 @@
+{
+    "extends": "@aligent/ts-code-standards/tsconfigs-extend",
+    "compileOnSave": false,
+    "files": [],
+    "references": [{"path": "./application"}]
+}

package/src/generators/preset/files/vitest.config.base.mjs.template

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+// More information about mode: https://vite.dev/guide/env-and-mode.html#node-env-and-modes
+export const vitestBaseConfig = defineConfig(({ command, mode }) => {
+    return {
+        test: {
+            globals: true,
+            watch: false,
+            environment: 'node',
+            reporters: ['default'],
+            coverage: {
+                provider: 'v8',
+                exclude: [
+                    'node_modules/',
+                    '**/types',
+                    '*.mjs',
+                    '**/__data__',
+                    '**/dist',
+                    '**/out-tsc',
+                ],
+                thresholds: {
+                    branches: 80,
+                    functions: 80,
+                    lines: 80,
+                    statements: 80,
+                },
+            },
+            include: [
+                'src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}',
+                'tests/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}',
+            ],
+            setupFiles: [
+                // Include the root setup file in all tests that extend this config
+                resolve(import.meta.dirname, './vitest.global.setup.mjs'),
+            ],
+        },
+    };
+});