@takumi-stack/core 1.0.0 → 1.0.1

package/script/config-command/ssm-connect.ts

@@ -0,0 +1,129 @@
+/* eslint-disable no-console */
+import { GetSecretValueCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+
+import { Secret } from '@takumi-stack/sdk';
+import { SpawnOptions, ExecSyncOptions, spawn, execSync } from 'child_process';
+import { log } from 'console';
+
+import {
+  BaseEnvName,
+  BaseGlobalEnv,
+  BaseDeployTargetName,
+  BaseGlobalConstConfig,
+  BaseGlobalEnvConfig,
+  BaseGlobalDeployTargetConfig,
+  preScript,
+  assumeRole,
+  getResourceName,
+} from '../../common';
+
+import { ConfigCommand } from '..';
+
+export const ssmConnect: ConfigCommand = async <
+  GlobalConst,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+>(
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  args: string[]
+): Promise<void> => {
+  try {
+    log('<< Open session SSM Started >>');
+
+    const commandArg = args[5] || 'sync';
+
+    if (!['sync', 'async'].includes(commandArg)) throw new Error('Action not allowed, you can use: sync or async');
+
+    const { envName, ephemeralEnvName, servicesNamesInput, roleName, accountMap, isSingleProjectAccount } = await preScript(
+      globalConstConfig,
+      globalEnvConfig,
+      globalDeployTargetConfig,
+      args
+    );
+
+    log('>> STEP: (1/2) => LOADING CONFIGS');
+    const projectName = globalConstConfig.projectName;
+
+    const account =
+      accountMap
+        .split(' ')
+        .find((a) => a.includes('services'))
+        ?.split('=')[1] || '';
+    const region = globalDeployTargetConfig[envName as AllowedEnv]['services' as DeployTargetName]['region'];
+
+    const role = await assumeRole({ account, region }, roleName);
+
+    const getParamName = (name: string) =>
+      getResourceName(name, {
+        isSingleProjectAccount,
+        projectName,
+        envName,
+        ephemeralEnvName,
+        serviceName: servicesNamesInput[0]!,
+      });
+
+    const ssm = new SSMClient(role);
+    const configs = await ssm.send(new GetParameterCommand({ Name: getParamName('config') }));
+
+    if (!configs.Parameter?.Value) throw new Error('Invalid Config');
+    const { clusterSecretArn, ec2InstanceId, publicAccess } = JSON.parse(configs.Parameter?.Value);
+
+    if (publicAccess) throw new Error('Action not allowed, this RDS has public access');
+
+    const sm: SecretsManagerClient = new SecretsManagerClient(role);
+    const response = await sm.send(
+      new GetSecretValueCommand({
+        SecretId: clusterSecretArn,
+      })
+    );
+
+    const DbSecrets: Secret['payload'] = JSON.parse(response.SecretString!);
+    const { host, port } = DbSecrets;
+    const localPort = 1432;
+
+    log('>> STEP: (2/2) => STARTING SESSION');
+
+    const command = `aws ssm start-session --region ${region} --target ${ec2InstanceId} --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters host="${host}",portNumber="${port}",localPortNumber="${localPort}"`;
+
+    const parts = command.split(' ');
+    const cmdAsync = parts[0];
+    const argsAsync = parts.splice(1);
+
+    const spawnOptions: SpawnOptions = {
+      stdio: 'ignore',
+      detached: true,
+      cwd: `${process.cwd()}`,
+      env: {
+        ...process.env,
+        AWS_ACCESS_KEY_ID: role.credentials.accessKeyId,
+        AWS_SECRET_ACCESS_KEY: role.credentials.secretAccessKey,
+        AWS_SESSION_TOKEN: role.credentials.sessionToken,
+        AWS_REGION: role.region,
+      },
+    };
+
+    const execOptions: ExecSyncOptions = {
+      stdio: 'inherit',
+      cwd: `${process.cwd()}`,
+      env: {
+        ...process.env,
+        AWS_ACCESS_KEY_ID: role.credentials.accessKeyId,
+        AWS_SECRET_ACCESS_KEY: role.credentials.secretAccessKey,
+        AWS_SESSION_TOKEN: role.credentials.sessionToken,
+        AWS_REGION: role.region,
+      },
+    };
+
+    if (commandArg == 'async') spawn(cmdAsync!, argsAsync, spawnOptions).unref();
+    else execSync(command, execOptions);
+
+    console.log('SSM Connected! ✅');
+  } catch (error: any) {
+    console.log(error);
+    process.exit(1);
+  }
+};

package/script/config-command/start-spa.ts

@@ -0,0 +1,93 @@
+/* eslint-disable no-console */
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
+
+import {
+  BaseEnvName,
+  BaseGlobalEnv,
+  BaseDeployTargetName,
+  BaseGlobalConstConfig,
+  BaseGlobalEnvConfig,
+  BaseGlobalDeployTargetConfig,
+  preScript,
+  assumeRole,
+  getResourceName,
+} from '../../common';
+
+import { ConfigCommand } from '..';
+
+export const startSPA: ConfigCommand = async <
+  GlobalConst,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+>(
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  args: string[]
+): Promise<void> => {
+  try {
+    console.log('<< Start SPA Script >>');
+
+    const yarnCommand = args[5] || 'start';
+
+    const { envName, ephemeralEnvName, servicesNamesInput, envNameInput, roleName, accountMap, isSingleProjectAccount } = await preScript(
+      globalConstConfig,
+      globalEnvConfig,
+      globalDeployTargetConfig,
+      args
+    );
+
+    console.log('>> STEP: (1/3) => LOADING CONFIGS');
+    const projectName = globalConstConfig.projectName;
+
+    const account =
+      accountMap
+        .split(' ')
+        .find((a) => a.includes('services'))
+        ?.split('=')[1] || '';
+
+    const region = globalDeployTargetConfig[envName as AllowedEnv]['services' as DeployTargetName]['region'];
+
+    const role = await assumeRole({ account, region }, roleName);
+
+    console.log('>> STEP: (2/3) => RENDERING ENV');
+    const getParamName = (name: string) =>
+      getResourceName(name, {
+        projectName,
+        envName,
+        ephemeralEnvName,
+        isSingleProjectAccount,
+        serviceName: servicesNamesInput[0]!,
+      });
+
+    const ssm = new SSMClient(role);
+
+    const deployConfig = await ssm.send(new GetParameterCommand({ Name: getParamName('config') }));
+
+    if (!deployConfig.Parameter?.Value) throw new Error('Invalid Config');
+    const { baseDir } = JSON.parse(deployConfig.Parameter?.Value);
+
+    const calculatedEnv = await ssm.send(new GetParameterCommand({ Name: getParamName('env-calculated') }));
+    if (!calculatedEnv.Parameter?.Value) throw new Error('Invalid CalculatedEnv');
+
+    const manualEnv = await ssm.send(new GetParameterCommand({ Name: getParamName('env-manual') }));
+    if (!manualEnv.Parameter?.Value) throw new Error('Invalid CalculatedEnv');
+
+    const envFile = `${calculatedEnv.Parameter?.Value}\n${manualEnv.Parameter?.Value}`;
+
+    writeFileSync(`${process.cwd()}/${baseDir}/.env.${envNameInput}`, envFile);
+
+    console.log('>> STEP: (3/3) => STARTING');
+
+    const command = `yarn && yarn ${yarnCommand} ${envNameInput}`;
+
+    execSync(command, { stdio: 'inherit', cwd: `${process.cwd()}/${baseDir}` });
+  } catch (error: any) {
+    console.log(error);
+    process.exit(1);
+  }
+};

package/script/config-command/start-ssr.ts

@@ -0,0 +1,91 @@
+/* eslint-disable no-console */
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
+
+import {
+  BaseEnvName,
+  BaseGlobalEnv,
+  BaseDeployTargetName,
+  BaseGlobalConstConfig,
+  BaseGlobalEnvConfig,
+  BaseGlobalDeployTargetConfig,
+  preScript,
+  assumeRole,
+  getResourceName,
+} from '../../common';
+
+import { ConfigCommand } from '..';
+
+export const startSSR: ConfigCommand = async <
+  GlobalConst,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+>(
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  args: string[]
+): Promise<void> => {
+  try {
+    console.log('<< Start SSR Script >>');
+
+    const yarnCommand = args[5] || 'start';
+
+    const { envName, ephemeralEnvName, servicesNamesInput, envNameInput, roleName, accountMap, isSingleProjectAccount } = await preScript(
+      globalConstConfig,
+      globalEnvConfig,
+      globalDeployTargetConfig,
+      args
+    );
+
+    console.log('>> STEP: (1/3) => LOADING CONFIGS');
+    const projectName = globalConstConfig.projectName;
+
+    const account =
+      accountMap
+        .split(' ')
+        .find((a) => a.includes('services'))
+        ?.split('=')[1] || '';
+
+    const region = globalDeployTargetConfig[envName as AllowedEnv]['services' as DeployTargetName]['region'];
+
+    const role = await assumeRole({ account, region }, roleName);
+
+    console.log('>> STEP: (2/3) => RENDERING ENV');
+
+    const getParamName = (name: string) =>
+      getResourceName(name, {
+        isSingleProjectAccount,
+        projectName,
+        envName,
+        ephemeralEnvName,
+        serviceName: servicesNamesInput[0]!,
+      });
+
+    const ssm = new SSMClient(role);
+    const deployConfig = await ssm.send(new GetParameterCommand({ Name: getParamName('config') }));
+
+    if (!deployConfig.Parameter?.Value) throw new Error('Invalid Config');
+    const { baseDir } = JSON.parse(deployConfig.Parameter?.Value);
+
+    const calculatedEnv = await ssm.send(new GetParameterCommand({ Name: getParamName('env-calculated') }));
+    if (!calculatedEnv.Parameter?.Value) throw new Error('Invalid CalculatedEnv');
+
+    const manualEnv = await ssm.send(new GetParameterCommand({ Name: getParamName('env-manual') }));
+    if (!manualEnv.Parameter?.Value) throw new Error('Invalid CalculatedEnv');
+
+    const envFile = `${calculatedEnv.Parameter?.Value}\n${manualEnv.Parameter?.Value}`;
+
+    writeFileSync(`${process.cwd()}/${baseDir}/.env.${envNameInput}`, envFile);
+    console.log('>> STEP: (3/3) => STARTING');
+
+    const command = `yarn ${yarnCommand} ${envNameInput}`;
+    execSync(command, { stdio: 'inherit', cwd: `${process.cwd()}/${baseDir}` });
+  } catch (error: any) {
+    console.log(error);
+    process.exit(1);
+  }
+};

package/script/config-command/synth.ts

@@ -0,0 +1,50 @@
+/* eslint-disable no-console */
+import { execSync } from 'child_process';
+
+import {
+  BaseEnvName,
+  BaseGlobalEnv,
+  BaseDeployTargetName,
+  BaseGlobalConstConfig,
+  BaseGlobalEnvConfig,
+  BaseGlobalDeployTargetConfig,
+  preScript,
+} from '../../common';
+
+import { ConfigCommand } from '..';
+
+export const synth: ConfigCommand = async <
+  GlobalConst,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+>(
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  args: string[]
+): Promise<void> => {
+  try {
+    console.log('<< Deploy Started >>');
+
+    const { envNameInput, roleName, outputFile, servicesNames, accountMap } = await preScript(
+      globalConstConfig,
+      globalEnvConfig,
+      globalDeployTargetConfig,
+      args
+    );
+
+    const command = `npx cdk synth \
+    --require-approval='never' \
+    --cloudformation-execution-policies=arn:aws:iam::aws:policy/AdministratorAccess \
+    --context env=${envNameInput} \
+    --context assume-role-credentials:writeIamRoleName=${roleName} \
+    --context assume-role-credentials:readIamRoleName=${roleName} \
+    --outputs-file ${outputFile} \
+    ${accountMap} ${servicesNames}`;
+
+    execSync(command, { stdio: 'inherit', env: process.env });
+  } catch (error: any) {
+    process.exit(1);
+  }
+};

package/script/index.ts

@@ -0,0 +1,86 @@
+import {
+  BaseEnvName,
+  BaseGlobalEnv,
+  BaseDeployTargetName,
+  BaseGlobalConstConfig,
+  BaseGlobalEnvConfig,
+  BaseGlobalDeployTargetConfig,
+} from '../common';
+
+import { bootstrap } from './config-command/bootstrap';
+import { deploy } from './config-command/deploy';
+import { deploySPA } from './config-command/deploy-spa';
+import { destroy } from './config-command/destroy';
+import { envSSR } from './config-command/env-ssr';
+import { invalidationSSR } from './config-command/invalidation-ssr';
+import { rdsMigration } from './config-command/rds-migration';
+import { rdsSync } from './config-command/rds-sync';
+import { ssmConnect } from './config-command/ssm-connect';
+import { startSPA } from './config-command/start-spa';
+import { startSSR } from './config-command/start-ssr';
+import { synth } from './config-command/synth';
+import { createUser } from './output-command/create-user';
+import { genPostmanEnv } from './output-command/gen-postman-env';
+
+export type ConfigCommand<
+  GlobalConst = any,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+> = (
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  args: string[]
+) => Promise<void>;
+
+export type SignatureType = 'config' | 'output';
+
+export const getCommandSignature = (command: string): SignatureType => {
+  const ops: Record<string, SignatureType> = {
+    deploy: 'config',
+    synth: 'config',
+    bootstrap: 'config',
+    destroy: 'config',
+    'deploy-spa': 'config',
+    'start-spa': 'config',
+    'invalidation-ssr': 'config',
+    'env-ssr': 'config',
+    'start-ssr': 'config',
+    'ssm-connect': 'config',
+    'rds-sync': 'config',
+    'rds-migration': 'config',
+    'create-user': 'output',
+    'gen-postman-env': 'output',
+  };
+  if (!ops[command]) throw new Error('Missing command');
+  return ops[command];
+};
+
+export const executeConfigCommand = (command: string): any => {
+  const ops: Record<string, ConfigCommand> = {
+    deploy: deploy,
+    synth: synth,
+    bootstrap: bootstrap,
+    destroy: destroy,
+    'deploy-spa': deploySPA,
+    'start-spa': startSPA,
+    'invalidation-ssr': invalidationSSR,
+    'env-ssr': envSSR,
+    'start-ssr': startSSR,
+    'ssm-connect': ssmConnect,
+    'rds-sync': rdsSync,
+    'rds-migration': rdsMigration,
+  };
+  if (!ops[command]) throw new Error('Missing command');
+  return ops[command];
+};
+
+export const executeOutputCommand = (command: string): any => {
+  const ops: Record<string, any> = {
+    'create-user': createUser,
+    'gen-postman-env': genPostmanEnv,
+  };
+  if (!ops[command]) throw new Error('Missing command');
+  return ops[command];
+};

package/script/output-command/create-user.ts

@@ -0,0 +1,89 @@
+/* eslint-disable no-console */
+import { AdminConfirmSignUpCommand, CognitoIdentityProviderClient, SignUpCommand } from '@aws-sdk/client-cognito-identity-provider';
+
+import {
+  assumeRole,
+  BaseDeployTargetName,
+  BaseEnvName,
+  BaseGlobalConstConfig,
+  BaseGlobalDeployTargetConfig,
+  BaseGlobalEnv,
+  BaseGlobalEnvConfig,
+  getServiceName,
+  preScript,
+} from '../../common';
+
+export const createUser = async <
+  GlobalConst,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+>(
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  output: Record<string, Record<string, string>>,
+  args: string[]
+): Promise<void> => {
+  try {
+    console.log('<< Create Cognito User >>');
+
+    console.log('>> STEP: (1/3) => LOADING CONFIGS');
+    const name = args[4];
+    const password = args[5];
+    const postfix = args[6];
+    const tenant = args[7];
+
+    const email = `${name}+${postfix}@sinapsis.co`;
+
+    const { envNameInput, roleName, accountMap, envName } = await preScript(globalConstConfig, globalEnvConfig, globalDeployTargetConfig, args);
+
+    const identityServiceKey = getServiceName('Identity', {
+      envName: envNameInput,
+      projectName: globalConstConfig.projectName,
+    });
+    if (!identityServiceKey) throw new Error('Missing Service. Please deploy it in order to run this command: yarn deploy [env] Identity');
+    const clientIdKey = Object.keys(output[identityServiceKey]!).find((w) => w.startsWith('CognitoAuthPoolPrefabUserPoolClient'));
+    const userPoolIdKey = Object.keys(output[identityServiceKey]!).find((w) => w.startsWith('CognitoAuthPoolPrefabUserPoolId'));
+    if (!clientIdKey || !userPoolIdKey) throw new Error('Missing output');
+
+    const clientId = output[identityServiceKey]![clientIdKey];
+    const userPoolId = output[identityServiceKey]![userPoolIdKey];
+
+    const account =
+      accountMap
+        .split(' ')
+        .find((a) => a.includes('services'))
+        ?.split('=')[1] || '';
+    const region = globalDeployTargetConfig[envName]['services' as DeployTargetName]['region'];
+
+    const role = await assumeRole({ account, region }, roleName);
+
+    const cognito = new CognitoIdentityProviderClient(role);
+
+    const att = [
+      { Name: 'email', Value: email },
+      { Name: 'given_name', Value: name },
+      { Name: 'family_name', Value: name },
+    ];
+    if (tenant) {
+      const [name, value] = tenant.split('@');
+      att.push({ Name: `custom:${name}`, Value: value });
+    }
+
+    console.log('>> STEP: (2/3) => SIGN UP');
+    await cognito.send(
+      new SignUpCommand({
+        ClientId: clientId,
+        Username: email,
+        Password: password,
+        UserAttributes: att,
+      })
+    );
+    console.log('>> STEP: (3/3) => CONFIRM SIGN UP');
+    await cognito.send(new AdminConfirmSignUpCommand({ UserPoolId: userPoolId, Username: email }));
+  } catch (error: any) {
+    console.log(error);
+    process.exit(1);
+  }
+};

package/script/output-command/gen-postman-env.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-console */
+import {
+  BaseDeployTargetName,
+  BaseEnvName,
+  BaseGlobalConstConfig,
+  BaseGlobalDeployTargetConfig,
+  BaseGlobalEnv,
+  BaseGlobalEnvConfig,
+  getServiceName,
+  preScript,
+} from '../../common';
+
+export const genPostmanEnv = async <
+  GlobalConst,
+  AllowedEnv extends BaseEnvName = BaseEnvName,
+  GlobalEnv extends BaseGlobalEnv = BaseGlobalEnv,
+  DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName,
+>(
+  globalConstConfig: BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  output: Record<string, Record<string, string>>,
+  args: string[]
+): Promise<void> => {
+  try {
+    console.log('<< Gen Postman Env >>');
+
+    const { envNameInput } = await preScript(globalConstConfig, globalEnvConfig, globalDeployTargetConfig, args);
+
+    const identityServiceKey = getServiceName('Identity', {
+      envName: envNameInput,
+      projectName: globalConstConfig.projectName,
+    });
+
+    const clientIdKey = Object.keys(output[identityServiceKey]!).find((w) => w.startsWith('CognitoAuthPoolPrefabUserPoolClient'));
+
+    const cdnApiServiceKey = getServiceName('CdnApi', {
+      envName: envNameInput,
+      projectName: globalConstConfig.projectName,
+    });
+
+    const apiUrlKey = Object.keys(output[cdnApiServiceKey]!).find((w) => w.startsWith('CdnApiPrefabapiDomain'));
+    if (!clientIdKey || !apiUrlKey) throw new Error('Missing output');
+
+    const postmanEnv = {
+      name: `${globalConstConfig.projectName}-${envNameInput}`,
+      values: [
+        {
+          key: 'baseUrl',
+          value: `https://${output[cdnApiServiceKey]![apiUrlKey]}`,
+          enabled: true,
+        },
+        {
+          key: 'cognitoClientId',
+          value: output[identityServiceKey]![clientIdKey],
+          enabled: true,
+        },
+        {
+          key: 'cognitoUser',
+          value: 'andres+test@sinapsis.co',
+          enabled: true,
+        },
+        {
+          key: 'cognitoPassword',
+          value: '4tn34n2ewc-23r23',
+          enabled: true,
+        },
+      ],
+    };
+    console.log(JSON.stringify(postmanEnv, null, 2));
+  } catch (error: any) {
+    console.log(error);
+    process.exit(1);
+  }
+};

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "exclude": ["node_modules/**/*", ".dist"],
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "target": "es2022",
+    "lib": ["es2022"],
+    "module": "NodeNext",
+    /* Monorepo Lib */
+    "noEmit": false,
+    "sourceMap": true,
+    "declaration": true,
+    "composite": true,
+    "declarationMap": true,
+    "outDir": ".dist"
+  }
+}

package/common/coordinator.d.ts

@@ -1,28 +0,0 @@
-import { App } from 'aws-cdk-lib';
-import { Construct } from 'constructs';
-
-import * as propsTypes from './synth/props-types';
-import { ServiceStack } from './service';
-
-export declare class Coordinator<
-  GlobalConstConfig extends propsTypes.BaseGlobalConstConfig = propsTypes.BaseGlobalConstConfig,
-  AllowedEnvName extends propsTypes.BaseEnvName = propsTypes.BaseEnvName,
-  GlobalEnv extends propsTypes.BaseGlobalEnv = propsTypes.BaseGlobalEnv,
-  GlobalDeployTarget extends propsTypes.BaseGlobalDeployTarget = propsTypes.BaseGlobalDeployTarget,
-> extends App {
-  scope: Construct;
-  globalProps: propsTypes.BaseGlobalProps<GlobalConstConfig, GlobalEnv, GlobalDeployTarget>;
-  private serviceList;
-  private services;
-  constructor(
-    globalConstConfig: GlobalConstConfig,
-    globalEnvConfig: propsTypes.BaseGlobalEnvConfig<AllowedEnvName, GlobalEnv>,
-    globalDeployTargetConfig: propsTypes.BaseGlobalDeployTargetConfig<AllowedEnvName, propsTypes.BaseDeployTargetName>
-  );
-  addService(service: ServiceStack): void;
-  build(): void;
-  private orderDependencies;
-}
-export declare function DepCheck(): (target: any, propertyKey: any) => void;
-export declare class ServiceDependencies {}
-//# sourceMappingURL=coordinator.d.ts.map

package/common/index.d.ts

@@ -1,6 +0,0 @@
-export * from './naming';
-export * from './synth';
-export * from './coordinator';
-export * from './modifier';
-export * from './service';
-//# sourceMappingURL=index.d.ts.map

package/common/modifier.d.ts

@@ -1,5 +0,0 @@
-import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
-
-export type Modifier = (lambda: NodejsFunction) => void;
-export declare const combineModifiers: (modifiers: Modifier[]) => Modifier;
-//# sourceMappingURL=modifier.d.ts.map