@agilecustoms/envctl 0.3.3 → 0.5.0

package/README.md

@@ -24,8 +24,8 @@ npm view @agilecustoms/envctl version # show latest version available (without i
    2. Repository access: `envctl` only
 
 ## History/motivation
-dev-env is a microservice hosted in 'maintenance' account and working as garbage collector: every environment first
-created in dev-env and then 'managed' by dev-env: it deletes env when it is not in use anymore OR can extend lifetime.
+`env-api` is a microservice hosted in 'maintenance' account and working as garbage collector: every environment first
+created in `env-api` and then 'managed' by `env-api`: it deletes env when it is not in use anymore OR can extend lifetime.
 Creation API yields unique ID, so you can safely manage env (delete, extend lifetime) via this ID. But creation API
 need to be secured. There are two main use cases:
 1. create environment from CI (mainly ephemeral envs)
@@ -35,7 +35,7 @@ I (Alex C) chosen IAM authorization as common denominator:
 1. on CI - use OIDC to assume role `/ci/deployer`                     
 2. on dev machine - use SSO and profile chaining to assume role `/ci/deployer`
 
-Then as `/ci/deployer` --call--> dev-env HTTP API (exposed with API Gateway with IAM authorizer)
+Then as `/ci/deployer` --call--> `env-api` HTTP API (exposed with API Gateway with IAM authorizer)
 
 Now problem is: any request needs to be signed with AWS signature v4. Originally I planned to use bash scripts, but it
 quickly became bulky and hard to maintain. Then I thought about Node.js - it is available on dev machines and

package/dist/commands/index.js

@@ -1,3 +1,4 @@
-export { ephemeral } from './createEphemeral.js';
+export { ephemeral } from './create-ephemeral.js';
 export { register } from './register.js';
 export { deleteIt } from './delete.js';
+export { terraformInit } from './terraform-init.js';

package/dist/commands/terraform-init.js

@@ -0,0 +1,31 @@
+import { execFile } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { wrap } from '../exceptions.js';
+export function terraformInit(program) {
+    program
+        .command('terraform-init')
+        .description('Wrapper for terraform init, to initialize a development environment')
+        .argument('<string>', 'key used to create/register the environment')
+        .action(wrap(handler));
+}
+async function handler(key) {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const scriptPath = path.join(__dirname, '../../scripts/terraform-init.sh');
+    const child = execFile(scriptPath, [key], (error, stdout, stderr) => {
+        if (error) {
+            console.error(`Script failed: ${error.message}`);
+            return;
+        }
+        if (stdout)
+            console.log(stdout);
+        if (stderr)
+            console.error(stderr);
+    });
+    child.on('exit', (code) => {
+        if (code !== 0) {
+            console.log(`Shell script exited with code ${code}`);
+        }
+    });
+}

package/dist/exceptions.js

@@ -4,6 +4,16 @@ export class KnownException extends Error {
         this.name = 'KnownException';
     }
 }
+export class HttpException extends Error {
+    statusCode;
+    responseBody;
+    constructor(statusCode, responseBody) {
+        super(`Received ${statusCode} response`);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = 'HttpException';
+    }
+}
 export function wrap(callable) {
     return async (...args) => {
         let result;
@@ -14,6 +24,14 @@ export function wrap(callable) {
             if (error instanceof KnownException) {
                 console.error(error.message);
             }
+            else if (error instanceof HttpException) {
+                if (error.statusCode === 422) {
+                    console.error(`Validation error: ${error.responseBody}`);
+                }
+                else {
+                    console.error(error.message);
+                }
+            }
             else {
                 console.error('Unknown error:', error);
             }

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
-import { deleteIt, ephemeral, register } from './commands/index.js';
+import { deleteIt, ephemeral, register, terraformInit } from './commands/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
@@ -14,4 +14,5 @@ program
 register(program);
 ephemeral(program);
 deleteIt(program);
+terraformInit(program);
 program.parse(process.argv);

package/dist/service/DevEnvClient.js

@@ -1,3 +1,4 @@
+import { HttpException, KnownException } from '../exceptions.js';
 import { HttpClient } from './HttpClient.js';
 export class DevEnvClient {
     httpClient;
@@ -11,9 +12,19 @@ export class DevEnvClient {
         return await this.send('POST', '/ci/env', env);
     }
     async delete(envId) {
-        await this.httpClient.fetch(`/ci/env/${envId}`, {
-            method: 'DELETE'
-        });
+        try {
+            await this.httpClient.fetch(`/ci/env/${envId}`, {
+                method: 'DELETE'
+            });
+        }
+        catch (error) {
+            if (error instanceof HttpException) {
+                if (error.statusCode === 404) {
+                    throw new KnownException(`Environment with key ${envId} is not found`);
+                }
+                throw error;
+            }
+        }
     }
     async send(method, path, env) {
         return this.httpClient.fetch(path, {

package/dist/service/EnvCtl.js

@@ -20,6 +20,9 @@ export class EnvCtl {
                 if (message.startsWith('The SSO session token') || message.startsWith('Token is expired')) {
                     throw new KnownException(error.message);
                 }
+                if (message.startsWith('ForbiddenException: No access')) {
+                    throw new KnownException(`Original error: ${message}. Could be wrong sso_account_id in ~/.aws/config for the profile`);
+                }
             }
             throw new Error('Error fetching account', { cause: error });
         }

package/dist/service/HttpClient.js

@@ -1,7 +1,7 @@
 import { fromEnv, fromSSO } from '@aws-sdk/credential-providers';
 import aws4 from 'aws4';
-import { KnownException } from '../exceptions.js';
-const HOST = 'dev-env.maintenance.agilecustoms.com';
+import { HttpException } from '../exceptions.js';
+const HOST = 'env-api.maintenance.agilecustoms.com';
 export class HttpClient {
     async fetch(path, options) {
         const creds = await this.getCredentials();
@@ -26,10 +26,7 @@ export class HttpClient {
         }
         const text = await response.text();
         if (!response.ok) {
-            if (response.status === 422) {
-                throw new KnownException(`Validation error: ${text}`);
-            }
-            throw new Error(`Received ${response.status} response: ${text}`);
+            throw new HttpException(response.status, text);
         }
         return text;
     }

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
     "envctl": "dist/index.js"
   },
+  "files": [
+    "dist/",
+    "scripts/",
+    "package.json"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/agilecustoms/envctl.git"
@@ -23,7 +28,8 @@
     "run-version": "tsc --sourceMap true; npm run run -- --version",
     "run-register": "tsc --sourceMap true; npm run run -- register --project tt --env alexc --owner laxa1986",
     "run-ephemeral": "tsc --sourceMap true; npm run run -- ephemeral -p tt -e tempenv",
-    "run-delete": "tsc --sourceMap true; npm run run -- delete tt-alexc"
+    "run-delete": "tsc --sourceMap true; npm run run -- delete tt-alexc",
+    "run-terraform-init": "tsc --sourceMap true; npm run run -- terraform-init test"
   },
   "dependencies": {
     "@aws-sdk/client-sts": "^3.716.0",

package/scripts/terraform-init.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+KEY="${1:?}"
+
+echo "KEY: ${KEY}"
+
+#echo "time: $(TZ=America/New_York date +"%T") ETD ($(date -u +"%T") UTC)"
+#echo
+#
+## TF stored in S3 in format: {company}-{acc-alias}-tf-state/{env} where {acc-alias} has form of {project-code}-{env-kind} like tt-dev
+## Retrieve AWS account information
+#acc_id=$(aws sts get-caller-identity --query "Account" --output text)
+#acc_alias=$(aws organizations list-tags-for-resource --resource-id "$acc_id" --query "Tags[?Key=='Alias'].Value" --output text)
+#state_prefix="agilecustoms-$acc_alias" # like "agilecustoms-tt-dev"
+#
+## -upgrade - get latest version of providers (mainly hashicorp/aws)
+## -reconfigure - discard local state, use (or create) remote
+## added to allow deploy multiple envs from local machine (on CI no local state survive between runs)
+#terraform init -upgrade -reconfigure \
+# -backend-config="bucket=$state_prefix-tf-state" \
+# -backend-config="key=$KEY"
+#
+#echo
+#echo "time: $(TZ=America/New_York date +"%T") ETD ($(date -u +"%T") UTC)"

package/.github/workflows/build-and-release.yml

@@ -1,37 +0,0 @@
-name: Client Build and Release
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  Build:
-    uses: ./.github/workflows/build.yml
-    with:
-      artifacts: true
-    secrets: inherit
-
-
-  Release:
-    needs:
-      - Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          token: ${{ secrets.GH_ACTIONS_TOKEN }} # Admin PAT to bypass push protection on 'main' branch
-
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-
-      - name: Release
-        id: release
-        uses: agilecustoms/gha-release@main
-        with:
-          aws-account: ${{ vars.AWS_ACCOUNT_DIST }}
-          npmjs-token: ${{ secrets.NPMJS_TOKEN }}
-
-      - name: Summary
-        run: echo "### Released ${{ steps.release.outputs.version }} :pushpin:" >> $GITHUB_STEP_SUMMARY

package/.github/workflows/build.yml

@@ -1,46 +0,0 @@
-name: Client Build
-
-on:
-  push:
-    branches-ignore:
-      - main
-  workflow_call:
-    inputs:
-      artifacts:
-        required: false
-        type: boolean
-        default: false
-        description: upload artifacts or not
-
-jobs:
-  Build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: 23
-          cache: npm
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Lint
-        run: npm run lint
-
-      - name: Test
-        run: npm run test
-
-      - name: Build
-        run: npm run build
-
-      - name: Upload artifacts
-        if: inputs.artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          path: dist # take everything from dist/ folder
-          name: dist #  and create artifact named dist (so later on the download action will create <repo-root>/dist/ folder)
-          # if not specify name - it will be available as 'artifact' dir

package/Makefile

@@ -1,21 +0,0 @@
-_aws-login:
-	@aws sso login
-
-# npm list --all - show dependency tree
-app0-install-deps:
-	@npm install
-
-app0-update-deps:
-	@npm update; npm outdated
-
-app1-lint:
-	@npm run lint
-
-app1-lint-fix:
-	@npm run lint:fix
-
-app2-test:
-	@npm run test
-
-app3-build:
-	@npm run build

package/eslint.config.mjs

@@ -1,34 +0,0 @@
-import tseslint from 'typescript-eslint'
-import plugin from '@stylistic/eslint-plugin'
-import importPlugin from 'eslint-plugin-import';
-
-export default [
-    ...tseslint.configs.recommended,
-    plugin.configs['recommended-flat'],
-    {
-        plugins: {
-            import: importPlugin,
-        },
-        rules: {
-            '@stylistic/brace-style': ['error', '1tbs'], // 'else' keyword on the same line as closing brace
-            '@stylistic/comma-dangle': 'off', // there are cases when trailing comma desired, and sometimes not
-            '@typescript-eslint/no-unused-vars': ['error', { // unused var starting from _ is ok
-                'argsIgnorePattern': '^_',
-                'destructuredArrayIgnorePattern': '^_'
-            }],
-
-            // Enforce Alphabetical Import Order and Merge Duplicate Imports
-            'import/order': ['error', {
-                'alphabetize': {'order': 'asc', 'caseInsensitive': true}
-            }],
-            'import/no-duplicates': 'error',
-        }
-    },
-    // Test-specific configuration (glob-based override)
-    {
-        files: ['**/*.test.ts', '**/*.test.tsx'],
-        rules: {
-            '@typescript-eslint/no-extra-non-null-assertion': 'off', // allow using !! initially to use with .mock.calls[0]!!
-        },
-    },
-];

package/src/commands/createEphemeral.ts

@@ -1,21 +0,0 @@
-import { Command } from 'commander'
-import { envCtl } from '../container.js'
-import { wrap } from '../exceptions.js'
-
-export function ephemeral(program: Command) {
-  program
-    .command('ephemeral')
-    .description('Create new ephemeral environment')
-    .requiredOption('-k, --key <key>', 'Key used to store env state (s3 key in case of AWS). Can be git hash, feature-a or {project-code}-{env-name}')
-    .action(wrap(handler))
-}
-
-type Options = {
-  key: string
-}
-
-async function handler(options: object): Promise<string> {
-  const { key } = options as Options
-
-  return await envCtl.createEphemeralEnv(key)
-}

package/src/commands/delete.ts

@@ -1,15 +0,0 @@
-import { Command } from 'commander'
-import { envCtl } from '../container.js'
-import { wrap } from '../exceptions.js'
-
-export function deleteIt(program: Command) {
-  program
-    .command('delete')
-    .description('Delete a development environment')
-    .argument('<string>', 'key used to create/register the environment')
-    .action(wrap(handler))
-}
-
-async function handler(key: string): Promise<void> {
-  await envCtl.delete(key)
-}

package/src/commands/index.ts

@@ -1,3 +0,0 @@
-export { ephemeral } from './createEphemeral.js'
-export { register } from './register.js'
-export { deleteIt } from './delete.js'

package/src/commands/register.ts

@@ -1,23 +0,0 @@
-import { Command } from 'commander'
-import { envCtl } from '../container.js'
-import { wrap } from '../exceptions.js'
-
-export function register(program: Command) {
-  program
-    .command('register')
-    .description('Create new or update existing dev environment')
-    .requiredOption('-k, --key <key>', 'Key used to store env state (s3 key in case of AWS). Can be git hash, feature-a or {project-code}-{env-name}')
-    .requiredOption('-o, --owner <owner>', 'Environment owner (GH username)')
-    .action(wrap(handler))
-}
-
-type Options = {
-  key: string
-  owner: string
-}
-
-async function handler(options: object): Promise<string> {
-  const { key, owner } = options as Options
-
-  return await envCtl.registerEnv(key, owner)
-}

package/src/container.ts

@@ -1,9 +0,0 @@
-import { STSClient } from '@aws-sdk/client-sts'
-import { DevEnvClient, EnvCtl, HttpClient } from './service/index.js'
-
-const stsClient = new STSClient()
-const httpClient = new HttpClient()
-const devEnvClient = new DevEnvClient(httpClient)
-const envCtl = new EnvCtl(stsClient, devEnvClient)
-
-export { envCtl }

package/src/exceptions.ts

@@ -1,29 +0,0 @@
-export class KnownException extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'KnownException'
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function wrap(callable: (...args: any[]) => Promise<string | void>): (...args: any[]) => void | Promise<void> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return async (...args: any[]): Promise<void> => {
-    let result: string | void
-    try {
-      result = await callable(...args)
-    } catch (error) {
-      if (error instanceof KnownException) {
-        console.error(error.message)
-      } else {
-        // print stack trace
-        console.error('Unknown error:', error)
-      }
-      process.exit(1)
-    }
-    // this is how result is returned back so it can be accessed by calling shell script
-    if (result !== undefined) {
-      console.log(result)
-    }
-  }
-}

package/src/index.ts

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'module'
-import { Command } from 'commander'
-import updateNotifier from 'update-notifier'
-import { deleteIt, ephemeral, register } from './commands/index.js'
-
-// it is possible to use 'import' to load JSON files, but package.json is level higher, so such trick copies 'src' in /dist :(
-const require = createRequire(import.meta.url) // custom 'require' relative to current module’s file URL
-const pkg = require('../package.json')
-
-// Check for updates
-updateNotifier({ pkg, updateCheckInterval: 0 }).notify()
-
-const program = new Command()
-program
-  .name('envctl') // shown when running --help: Usage: envctl [options] [command]
-  .description('CLI to manage environments')
-  .version(pkg.version)
-register(program)
-ephemeral(program)
-deleteIt(program)
-
-program.parse(process.argv)

package/src/model/Environment.ts

@@ -1,4 +0,0 @@
-export type Environment = {
-  account: string
-  key: string
-}

package/src/model/PersonalEnvironment.ts

@@ -1,5 +0,0 @@
-import type { Environment } from './Environment.js'
-
-export type PersonalEnvironment = Environment & {
-  owner: string
-}

package/src/model/index.ts

@@ -1,2 +0,0 @@
-export type { Environment } from './Environment.js'
-export type { PersonalEnvironment } from './PersonalEnvironment.js'

package/src/service/DevEnvClient.ts

@@ -1,34 +0,0 @@
-import type { Environment, PersonalEnvironment } from '../model/index.js'
-import { HttpClient } from './HttpClient.js'
-
-export class DevEnvClient {
-  private httpClient: HttpClient
-
-  constructor(httpClient: HttpClient) {
-    this.httpClient = httpClient
-  }
-
-  public async registerEnv(env: PersonalEnvironment): Promise<string> {
-    return await this.send('PUT', '/ci/env', env)
-  }
-
-  public async createEphemeralEnv(env: Environment): Promise<string> {
-    return await this.send('POST', '/ci/env', env)
-  }
-
-  public async delete(envId: string): Promise<void> {
-    await this.httpClient.fetch(`/ci/env/${envId}`, {
-      method: 'DELETE'
-    })
-  }
-
-  private async send(method: string, path: string, env: Environment): Promise<string> {
-    return this.httpClient.fetch(path, {
-      method,
-      body: JSON.stringify(env),
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    })
-  }
-}

package/src/service/EnvCtl.ts

@@ -1,57 +0,0 @@
-import { GetCallerIdentityCommand, STSClient } from '@aws-sdk/client-sts'
-import type { GetCallerIdentityResponse } from '@aws-sdk/client-sts'
-import { KnownException } from '../exceptions.js'
-import { DevEnvClient } from './DevEnvClient.js'
-
-export class EnvCtl {
-  private stsClient: STSClient
-  private devEnvClient: DevEnvClient
-
-  constructor(
-    stsClient: STSClient,
-    devEnvClient: DevEnvClient
-  ) {
-    this.stsClient = stsClient
-    this.devEnvClient = devEnvClient
-  }
-
-  private async getAccount(): Promise<string> {
-    const command = new GetCallerIdentityCommand({})
-    let response: GetCallerIdentityResponse
-    try {
-      response = await this.stsClient.send(command)
-    } catch (error) {
-      // there is no type to check with instanceof, and also different errors have same .name  == 'CredentialsProviderError'
-      if (error instanceof Error) {
-        const message = error.message
-        if (message.startsWith('The SSO session token') || message.startsWith('Token is expired')) {
-          throw new KnownException(error.message)
-        }
-      }
-      throw new Error('Error fetching account', { cause: error })
-    }
-    return response.Account!
-  }
-
-  public async registerEnv(key: string, owner: string): Promise<string> {
-    const account = await this.getAccount()
-    const env = { account, key, owner }
-    return await this.devEnvClient.registerEnv(env)
-  }
-
-  public async createEphemeralEnv(key: string): Promise<string> {
-    const account = await this.getAccount()
-    const env = { account, key }
-    return await this.devEnvClient.createEphemeralEnv(env)
-  }
-
-  /**
-   * Here client uses secret knowledge on how id is constructed from account and key
-   * Probably it is OK because client and server are tightly coupled
-   */
-  public async delete(key: string): Promise<void> {
-    const account = await this.getAccount()
-    const envId = `${account}-${key}`
-    return this.devEnvClient.delete(envId)
-  }
-}

package/src/service/HttpClient.ts

@@ -1,58 +0,0 @@
-import { fromEnv, fromSSO } from '@aws-sdk/credential-providers'
-import type { AwsCredentialIdentity, AwsCredentialIdentityProvider } from '@smithy/types'
-import aws4 from 'aws4'
-import type { Credentials, Request as Aws4Request } from 'aws4'
-import { KnownException } from '../exceptions.js'
-
-const HOST = 'dev-env.maintenance.agilecustoms.com'
-
-export class HttpClient {
-  public async fetch(path: string, options: RequestInit): Promise<string> {
-    const creds: Credentials = await this.getCredentials()
-
-    const requestOptions: Aws4Request = {
-      method: options.method,
-      body: options.body as string | undefined,
-      headers: options.headers as Record<string, string>,
-      host: HOST,
-      service: 'execute-api',
-      path,
-    }
-    const signedOptions: Aws4Request = aws4.sign(requestOptions, creds)
-    const signedHeaders = signedOptions.headers as Record<string, string>
-
-    const url = `https://${HOST}${path}`
-    options.headers = signedHeaders
-
-    let response: Response
-    try {
-      response = await fetch(url, options)
-    } catch (error) {
-      throw new Error('Error (network?) making the request:', { cause: error })
-    }
-
-    const text = await response.text()
-    if (!response.ok) {
-      if (response.status === 422) {
-        throw new KnownException(`Validation error: ${text}`)
-      }
-      throw new Error(`Received ${response.status} response: ${text}`)
-    }
-
-    return text
-  }
-
-  private async getCredentials(): Promise<AwsCredentialIdentity> {
-    let identityProvider: AwsCredentialIdentityProvider
-    if (process.env.CI) {
-      identityProvider = fromEnv()
-    } else {
-      identityProvider = fromSSO()
-    }
-    try {
-      return await identityProvider()
-    } catch (error) {
-      throw new Error('Error fetching credentials:', { cause: error })
-    }
-  }
-}

package/src/service/index.ts

@@ -1,3 +0,0 @@
-export { DevEnvClient } from './DevEnvClient.js'
-export { EnvCtl } from './EnvCtl.js'
-export { HttpClient } from './HttpClient.js'

package/test/service/EnvCtl.test.ts

@@ -1,34 +0,0 @@
-import { STSClient } from '@aws-sdk/client-sts'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { DevEnvClient, EnvCtl } from '../../src/service'
-
-const stsClient = {
-  send: vi.fn(),
-}
-
-const devEnvClient = {
-  registerEnv: vi.fn(),
-}
-
-describe('EnvCtl', () => {
-  let envCtl: EnvCtl
-  beforeEach(() => {
-    envCtl = new EnvCtl(
-      stsClient as unknown as STSClient,
-      devEnvClient as unknown as DevEnvClient
-    )
-  })
-
-  describe('registerEnv', () => {
-    it('should call stsClient to get account and then call devEnvClient to register env', async () => {
-      stsClient.send.mockResolvedValue({ Account: 'testAccount' })
-      devEnvClient.registerEnv.mockResolvedValue('testEnvId')
-
-      const result = await envCtl.registerEnv('env', 'owner')
-
-      expect(result).toBe('testEnvId')
-      expect(stsClient.send).toHaveBeenCalled()
-      expect(devEnvClient.registerEnv).toHaveBeenCalled()
-    })
-  })
-})

package/tsconfig.json

@@ -1,23 +0,0 @@
-// https://www.typescriptlang.org/tsconfig
-{
-  "include": [
-    "src"
-  ],
-  // Runtime is Node 23 (latest as Jan 2025), to be run in CI (action/setup-node) and local machines
-  "compilerOptions": {
-    // MAIN SETTINGS (based on runtime)
-    "target": "es2023",   // highest available, fully supported by Node 23
-    "module": "nodenext", // preferred for modern Node projects
-    "outDir": "dist",     // standard output folder for all emitted files
-
-    // DEFAULTS that are always "good to have" - expect to be the same for all projects
-    "allowJs": false,             // no need to compile JS, all is TS
-    "noUncheckedIndexedAccess": true,
-    "removeComments": true,
-    "skipLibCheck": true,         // skip type checking of declaration files (.d.ts) - allows quick hot reload
-    "strict": true,               // enable all strict type-checking options
-    "verbatimModuleSyntax": true, // force using 'import type' for types
-
-    // ADDITIONAL SETTINGS (vary per project)
-  }
-}

package/vitest.config.ts

@@ -1,19 +0,0 @@
-import { coverageConfigDefaults, defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    coverage: {
-      exclude: [
-        '**/index.ts',
-        'src/container.ts',
-        'src/model/**',
-        ...coverageConfigDefaults.exclude
-      ],
-      reporter: ['text'], // other: 'html', 'clover', 'json'
-      thresholds: {
-        lines: 26,
-        branches: 44,
-      }
-    }
-  }
-})