@takumi-stack/core 1.0.0 → 1.0.1

package/.prettierignore

@@ -0,0 +1,10 @@
+node_modules
+cdk.out
+.env*
+.DS_Store
+yarn-error.log
+.editorconfig
+.eslintcache
+.dist
+.next
+merged.graphql

package/.prettierrc.json

@@ -0,0 +1,12 @@
+{
+  "plugins": ["@trivago/prettier-plugin-sort-imports"],
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "singleQuote": true,
+  "printWidth": 150,
+  "proseWrap": "preserve",
+  "importOrderParserPlugins": ["typescript", "decorators-legacy", "jsx"],
+  "importOrderSeparation": true,
+  "importOrderGroupNamespaceSpecifiers": true,
+  "importOrder": ["reflect-metadata", "(aws-cdk-lib|constructs)", "@aws-sdk", "<THIRD_PARTY_MODULES>", "^[./]"]
+}

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @takumi-stack/core@1.0.1 build /Users/agustindecima/Desktop/takumi/packages/core
+> tsc
+

package/.turbo/turbo-release.log

@@ -0,0 +1,7 @@
+
+
+> @takumi-stack/core@1.0.0 release /Users/agustindecima/Desktop/takumi/packages/core
+> release-it --ci
+
+sh: release-it: command not found
+ ELIFECYCLE  Command failed.

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.0.1 (2024-08-29)
+
+**Note:** Version bump only for package @takumi-stack/core

package/common/coordinator.ts

@@ -0,0 +1,103 @@
+/* eslint-disable no-console */
+import { App } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+
+import * as propsTypes from './synth/props-types';
+import { ServiceStack } from './service';
+import { getGlobalProps } from './synth/get-global-props';
+import { SynthError } from './synth/synth-error';
+
+export 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 {
+  public scope!: Construct;
+  public globalProps: propsTypes.BaseGlobalProps<GlobalConstConfig, GlobalEnv, GlobalDeployTarget>;
+  private serviceList: ServiceStack[];
+  private services: Record<ServiceStack['name'], ServiceStack> = {} as Record<ServiceStack['name'], ServiceStack>;
+
+  constructor(
+    globalConstConfig: GlobalConstConfig,
+    globalEnvConfig: propsTypes.BaseGlobalEnvConfig<AllowedEnvName, GlobalEnv>,
+    globalDeployTargetConfig: propsTypes.BaseGlobalDeployTargetConfig<AllowedEnvName, propsTypes.BaseDeployTargetName>
+  ) {
+    super({ autoSynth: false });
+    this.globalProps = getGlobalProps(this, globalConstConfig, globalEnvConfig, globalDeployTargetConfig);
+    this.serviceList = [];
+    this.services = {};
+  }
+
+  public addService(service: ServiceStack): void {
+    service.depsNames = service.depsNames.map((d) => `${d.charAt(0).toUpperCase()}${d.slice(1)}`);
+    this.serviceList.push(service);
+    this.services[service.name] = service;
+  }
+
+  public build(): void {
+    try {
+      const ordererServiceList = this.orderDependencies();
+      ordererServiceList.map((l) => {
+        const service = this.services[l];
+        const deps: Record<string, ServiceStack> = service!.depsNames.reduce((memo: Record<string, any>, cu) => {
+          const name = `${cu.charAt(0).toLowerCase()}${cu.slice(1)}`;
+          memo[name] = this.services[cu];
+          return memo;
+        }, {});
+        service!.build(deps);
+      });
+      this.synth();
+    } catch (error: any) {
+      console.log('ServiceBuildFailed: Missing dependency error (Did you forget adding @DepCheck() decorator?)');
+      console.log(error);
+      process.exit(1);
+    }
+  }
+
+  private orderDependencies(): string[] {
+    const nodeMap = new Map<string, ServiceStack>();
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+    const result: string[] = [];
+    const serviceNames = this.serviceList.map((s) => s.name);
+    this.serviceList.forEach((node) => {
+      node.depsNames = node.depsNames.map((d) => {
+        if (!serviceNames.includes(d)) throw new SynthError(`Dependency ${d}, in ${node.name} doesn't exist`);
+        return d;
+      });
+      nodeMap.set(node.name, node);
+    });
+    this.serviceList.forEach((n) => visit(n));
+    function visit(node: ServiceStack) {
+      if (!node) return;
+      if (visited.has(node.name)) return;
+      if (visiting.has(node.name)) throw new Error(`Circular dependency detected for node ${node.name}`);
+      visiting.add(node.name);
+      node.depsNames.forEach((depId) => {
+        if (!visited.has(depId)) visit(nodeMap.get(depId)!);
+      });
+      visiting.delete(node.name);
+      visited.add(node.name);
+      result.push(node.name);
+    }
+
+    return result;
+  }
+}
+
+export function DepCheck() {
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  return function (target: any, propertyKey: any) {
+    // Define the _propertyMap dict if it doesn't exist yet
+    if (!target.depStore) {
+      target.depStore = [];
+    }
+    // Store the decorated property's value in the _propertyMap dict
+    target.depStore.push(propertyKey);
+  };
+}
+
+export class ServiceDependencies {
+  // depStore: string[] = [];
+}

package/common/index.ts

@@ -0,0 +1,5 @@
+export * from './naming';
+export * from './synth';
+export * from './coordinator';
+export * from './modifier';
+export * from './service';

package/common/modifier.ts

@@ -0,0 +1,11 @@
+import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
+
+export type Modifier = (lambda: NodejsFunction) => void;
+
+export const combineModifiers = (modifiers: Modifier[]): Modifier => {
+  return (lambda: NodejsFunction) => {
+    for (const modifier of modifiers) {
+      modifier(lambda);
+    }
+  };
+};

package/common/naming/get-deploy-config.ts

@@ -0,0 +1,5 @@
+import { BaseGlobalProps, BaseDeployTargetName, DeployConfig } from '../synth/props-types';
+
+export const getDeployConfig = (deployTarget: BaseGlobalProps, deployTargetName: BaseDeployTargetName = 'services'): { env: DeployConfig } => {
+  return { env: deployTarget.deployTarget[deployTargetName]! };
+};

package/common/naming/get-domain.ts

@@ -0,0 +1,14 @@
+import { BaseServiceProps } from '../synth/props-types';
+
+type GetDomainParams = {
+  envDomainName?: BaseServiceProps['envDomainName'];
+  ephemeralEnvName?: BaseServiceProps['ephemeralEnvName'];
+};
+
+export const getDomain = (subdomain: string, { envDomainName, ephemeralEnvName }: GetDomainParams, includeProtocol?: boolean): string => {
+  if (!envDomainName) throw new Error('Missing envDomainName in config');
+  const preFix = subdomain ? `${subdomain}.` : '';
+  const protocolPreFix = includeProtocol ? `https://${preFix}` : preFix;
+  const posFix = ephemeralEnvName ? `${ephemeralEnvName}.${envDomainName}` : envDomainName;
+  return `${protocolPreFix}${posFix}`;
+};

package/common/naming/get-function-entry.ts

@@ -0,0 +1,11 @@
+import { existsSync } from 'fs';
+
+import { BaseServiceProps } from '../synth/props-types';
+import { SynthError } from '../synth/synth-error';
+
+export const getFunctionEntry = (baseFunctionFolder: string, name: string, compiled?: boolean, props?: BaseServiceProps): string => {
+  const ext = compiled === true ? 'js' : 'ts';
+  const entry = `${baseFunctionFolder}/handlers/${name}/handler.${ext}`.toLowerCase();
+  if (!existsSync(entry)) throw new SynthError(`Handler ${entry} for ${name} doesn't exist`, props);
+  return entry;
+};

package/common/naming/get-logical-name.ts

@@ -0,0 +1,3 @@
+export const getLogicalName = (resourceType: string, resourceId = ''): string => {
+  return `${resourceType}:${resourceId}`;
+};

package/common/naming/get-resource-name.ts

@@ -0,0 +1,77 @@
+import { BaseServiceProps } from '../synth/props-types';
+import { toDashCase, toSnakeCase } from './string-parser';
+
+type GetResourceNameParams = {
+  projectName: BaseServiceProps['projectName'];
+  envName: BaseServiceProps['envName'];
+  ephemeralEnvName?: BaseServiceProps['ephemeralEnvName'];
+  serviceName: BaseServiceProps['serviceName'];
+  isSingleProjectAccount?: BaseServiceProps['isSingleProjectAccount'];
+};
+
+type GetShortResourceNameParams = {
+  projectShortName: BaseServiceProps['projectShortName'];
+  envName: BaseServiceProps['envName'];
+  ephemeralEnvName?: BaseServiceProps['ephemeralEnvName'];
+  serviceName: BaseServiceProps['serviceName'];
+  isSingleProjectAccount?: BaseServiceProps['isSingleProjectAccount'];
+};
+
+export const getResourceName = (
+  resourceName: string,
+  { isSingleProjectAccount, projectName, envName, ephemeralEnvName, serviceName }: GetResourceNameParams
+): string => {
+  const project = isSingleProjectAccount ? '' : `${toDashCase(projectName)}-`;
+  const env = ephemeralEnvName ? `${envName}-${ephemeralEnvName}` : envName;
+  const resource = resourceName && toDashCase(serviceName) !== toDashCase(resourceName) ? `-${toDashCase(resourceName)}` : '';
+  return `${project}${toDashCase(env)}-${toDashCase(serviceName)}${resource}`;
+};
+
+export const getShortResourceName = (
+  resourceName: string,
+  { isSingleProjectAccount, projectShortName, envName, ephemeralEnvName, serviceName }: GetShortResourceNameParams
+): string => {
+  const project = isSingleProjectAccount ? '' : `${toDashCase(projectShortName)}-`;
+  const env = ephemeralEnvName ? `${envName}-${ephemeralEnvName}` : envName;
+  const shortServiceName = serviceName.toLowerCase().includes('service') ? (serviceName.toLowerCase().split('service')[0] as string) : serviceName;
+  const resource = resourceName && toDashCase(serviceName) !== toDashCase(resourceName) ? `-${toDashCase(resourceName)}` : '';
+  return `${project}${toDashCase(env)}-${toDashCase(shortServiceName)}${resource}`;
+};
+
+export const getDatabaseName = (
+  resourceName: string,
+  { isSingleProjectAccount, projectName, envName, ephemeralEnvName, serviceName }: GetResourceNameParams
+): string => {
+  const project = isSingleProjectAccount ? '' : `${toDashCase(projectName)}-`;
+  const env = ephemeralEnvName ? `${envName}_${ephemeralEnvName}` : envName;
+  const resource = resourceName && serviceName !== resourceName ? `_${toSnakeCase(resourceName)}` : '';
+  return `${project}${toSnakeCase(env)}_${toSnakeCase(serviceName)}${resource}`;
+};
+
+export const getCloudFrontName = (
+  resourceType: string,
+  resourceName: string,
+  { projectName, envName, ephemeralEnvName, serviceName }: GetResourceNameParams
+): string => {
+  const arr = [projectName, envName, ephemeralEnvName, serviceName, resourceType, resourceName].map((a) =>
+    a ? `${a.charAt(0).toUpperCase()}${a.slice(1)}` : ''
+  );
+  return arr.join('');
+};
+
+export const getBucketName = (
+  bucketName: string,
+  {
+    envDomainName,
+    ephemeralEnvName,
+    serviceName,
+  }: {
+    envDomainName: BaseServiceProps['envDomainName'];
+    ephemeralEnvName?: BaseServiceProps['ephemeralEnvName'];
+    serviceName: BaseServiceProps['serviceName'];
+  }
+): string => {
+  const preFix = bucketName === serviceName ? bucketName : `${serviceName}.${bucketName}`;
+  const posFix = ephemeralEnvName ? `${ephemeralEnvName}.${envDomainName}` : envDomainName;
+  return `${preFix}.${posFix}`.toLowerCase();
+};

package/common/naming/get-service-name.ts

@@ -0,0 +1,13 @@
+import { BaseGlobalProps } from '../synth/props-types';
+import { capFirstLetter } from './string-parser';
+
+type GetServiceNameParams = {
+  projectName: BaseGlobalProps['projectName'];
+  envName: BaseGlobalProps['envName'];
+  ephemeralEnvName?: BaseGlobalProps['ephemeralEnvName'];
+};
+
+export const getServiceName = (simpleServiceName: string, { projectName, envName, ephemeralEnvName }: GetServiceNameParams): string => {
+  const env = ephemeralEnvName ? `${capFirstLetter(envName)}-${capFirstLetter(ephemeralEnvName)}` : capFirstLetter(envName);
+  return `${capFirstLetter(projectName)}-${env}-${capFirstLetter(simpleServiceName)}`;
+};

package/common/naming/index.ts

@@ -0,0 +1,7 @@
+export * from './get-deploy-config';
+export * from './get-domain';
+export * from './get-function-entry';
+export * from './get-logical-name';
+export * from './get-resource-name';
+export * from './get-service-name';
+export * from './string-parser';

package/common/naming/string-parser.ts

@@ -0,0 +1,17 @@
+export const capFirstLetter = (stringToConvert: string): string => {
+  return stringToConvert.charAt(0).toUpperCase() + stringToConvert.slice(1);
+};
+
+export const toDashCase = (stringToConvert: string): string => {
+  return stringToConvert
+    .split(/(?=[A-Z])/)
+    .join('-')
+    .toLowerCase();
+};
+
+export const toSnakeCase = (stringToConvert: string): string => {
+  return stringToConvert
+    .split(/(?=[A-Z])/)
+    .join('_')
+    .toLowerCase();
+};

package/common/service.ts

@@ -0,0 +1,48 @@
+import { Stack } from 'aws-cdk-lib';
+
+import { Coordinator, ServiceDependencies } from './coordinator';
+import { getDeployConfig } from './naming/get-deploy-config';
+import { getServiceName } from './naming/get-service-name';
+import { getServiceProps } from './synth/get-service-props';
+import { BaseDeployTargetName, BaseServiceProps } from './synth/props-types';
+import { SynthError } from './synth/synth-error';
+
+type ServiceClass<MyCoord extends Coordinator = Coordinator> = {
+  props: MyCoord['globalProps'];
+  name: string;
+  build(args: any): void;
+};
+
+type ServiceOptions<DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName> = {
+  deployTargetName?: DeployTargetName;
+  stackName?: string;
+};
+
+export abstract class ServiceStack<MyCoord extends Coordinator = Coordinator, DeployTargetName extends BaseDeployTargetName = BaseDeployTargetName>
+  extends Stack
+  implements ServiceClass<MyCoord>
+{
+  public readonly props: BaseServiceProps<MyCoord['globalProps']>;
+  public readonly name: string;
+  public depsNames: string[];
+
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  constructor(coordinator: MyCoord, name: string, dep: typeof ServiceDependencies, serviceOptions?: ServiceOptions<DeployTargetName>) {
+    super(
+      coordinator,
+      serviceOptions?.stackName || getServiceName(name, coordinator.globalProps),
+      getDeployConfig(coordinator.globalProps, serviceOptions?.deployTargetName)
+    );
+    this.props = getServiceProps(name, coordinator.globalProps);
+    this.name = name;
+    try {
+      const d: any = new dep();
+      this.depsNames = d.depStore || [];
+    } catch {
+      throw new SynthError(`Service ${name} invalid dependency`, this.props);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  abstract build(deps: any): void;
+}

package/common/synth/account-mapping.ts

@@ -0,0 +1,16 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb';
+
+const client = new DynamoDBClient({ region: 'us-east-1' });
+const dynamo = DynamoDBDocumentClient.from(client);
+export const accountMapping = async (project: string, env: string): Promise<string> => {
+  const { Item } = await dynamo.send(
+    new GetCommand({
+      TableName: 'accounts-repository',
+      Key: { pk: project, sk: env },
+    })
+  );
+  if (!Item) throw new Error(`Not entry for account: ${project}-${env}`);
+
+  return Item['account'] as string;
+};

package/common/synth/assume-role.ts

@@ -0,0 +1,39 @@
+import { AssumeRoleCommand, STSClient } from '@aws-sdk/client-sts';
+
+import { BaseGlobalProps, BaseRegionName, DeployConfig } from './props-types';
+
+export type AssumeRoleResponse = {
+  region: BaseRegionName;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+  };
+};
+
+type AssumeRoleParams = {
+  region: BaseGlobalProps['regionName'];
+  account: DeployConfig['account'];
+};
+
+export const assumeRole = async ({ account, region = 'us-east-1' }: AssumeRoleParams, roleName: string): Promise<AssumeRoleResponse> => {
+  return assumeRoleArn(`arn:aws:iam::${account}:role/${roleName}`, region);
+};
+
+export const assumeRoleArn = async (arn: string, region = 'us-east-1'): Promise<AssumeRoleResponse> => {
+  const sts = new STSClient({ region });
+  const { Credentials } = await sts.send(
+    new AssumeRoleCommand({
+      RoleArn: arn,
+      RoleSessionName: 'cdk-scripts',
+    })
+  );
+  return {
+    region,
+    credentials: {
+      accessKeyId: Credentials?.AccessKeyId as string,
+      secretAccessKey: Credentials?.SecretAccessKey as string,
+      sessionToken: Credentials?.SessionToken as string,
+    },
+  };
+};

package/common/synth/get-global-props.ts

@@ -0,0 +1,46 @@
+import { Construct } from 'constructs';
+
+import * as propsTypes from './props-types';
+import { getDomain } from '../naming/get-domain';
+import { SynthError } from './synth-error';
+
+export const getGlobalProps = <
+  GlobalConstConfig extends propsTypes.BaseGlobalConstConfig,
+  AllowedEnvName extends propsTypes.BaseEnvName,
+  GlobalEnv extends propsTypes.BaseGlobalEnv,
+  GlobalDeployTarget extends propsTypes.BaseGlobalDeployTarget,
+>(
+  app: Construct,
+  globalConstConfig: GlobalConstConfig,
+  globalEnvConfig: propsTypes.BaseGlobalEnvConfig<AllowedEnvName, GlobalEnv>,
+  globalDeployTargetConfig: propsTypes.BaseGlobalDeployTargetConfig<AllowedEnvName, propsTypes.BaseDeployTargetName>
+): propsTypes.BaseGlobalProps<GlobalConstConfig, GlobalEnv, GlobalDeployTarget> => {
+  const envInput: string = app.node.tryGetContext('env');
+
+  const envName: AllowedEnvName = (envInput.includes('-') ? envInput.split('-')[0] : envInput) as AllowedEnvName;
+  const ephemeralEnvName = envInput.includes('-') ? envInput.split('-')[1] : '';
+
+  const currentGlobalServiceEnv = globalEnvConfig[envName as AllowedEnvName];
+  if (!currentGlobalServiceEnv) throw new Error(`Invalid env name: '${envName}'`);
+
+  const currentGlobalDeployTarget = globalDeployTargetConfig[envName];
+  Object.keys(currentGlobalDeployTarget).forEach((a) => {
+    currentGlobalDeployTarget[a]!['account'] = app.node.tryGetContext(a);
+    if (!currentGlobalDeployTarget[a]!['account']) throw new SynthError(`Missing account mapping of ${a}`);
+  });
+
+  const emailSender = `${currentGlobalServiceEnv['emailSender']}@${getDomain('', {
+    envDomainName: currentGlobalServiceEnv['envDomainName'],
+    ephemeralEnvName,
+  })}`;
+
+  return {
+    envName,
+    ephemeralEnvName,
+    regionName: currentGlobalDeployTarget['services']!.region,
+    deployTarget: currentGlobalDeployTarget as GlobalDeployTarget,
+    ...globalConstConfig,
+    ...currentGlobalServiceEnv,
+    emailSender,
+  };
+};

package/common/synth/get-service-props.ts

@@ -0,0 +1,16 @@
+import { BaseGlobalProps, BaseServiceProps, BaseServiceDependencies } from './props-types';
+
+export const getServiceProps = <
+  GlobalProps extends BaseGlobalProps = BaseGlobalProps,
+  ServiceDependencies extends BaseServiceDependencies = BaseServiceDependencies,
+>(
+  serviceName: string,
+  globalProps: GlobalProps,
+  serviceDependencies: ServiceDependencies = {} as ServiceDependencies
+): BaseServiceProps<GlobalProps, ServiceDependencies> => {
+  return {
+    serviceName,
+    ...globalProps,
+    ...serviceDependencies,
+  };
+};

package/common/synth/index.ts

@@ -0,0 +1,7 @@
+export * from './account-mapping';
+export * from './assume-role';
+export * from './get-global-props';
+export * from './get-service-props';
+export * from './pre-script';
+export * from './props-types';
+export * from './synth-error';

package/common/synth/pre-script.ts

@@ -0,0 +1,103 @@
+/* eslint-disable no-console */
+import * as propsTypes from './props-types';
+import { getServiceName } from '../naming/get-service-name';
+import { accountMapping } from './account-mapping';
+import { SynthError } from './synth-error';
+
+export const preScript = async <
+  GlobalConst,
+  AllowedEnv extends propsTypes.BaseEnvName = propsTypes.BaseEnvName,
+  GlobalEnv extends propsTypes.BaseGlobalEnv = propsTypes.BaseGlobalEnv,
+  DeployTargetName extends propsTypes.BaseDeployTargetName = propsTypes.BaseDeployTargetName,
+>(
+  globalConstConfig: propsTypes.BaseGlobalConstConfig<GlobalConst>,
+  globalEnvConfig: propsTypes.BaseGlobalEnvConfig<AllowedEnv, GlobalEnv>,
+  globalDeployTargetConfig: propsTypes.BaseGlobalDeployTargetConfig<AllowedEnv, DeployTargetName>,
+  args: string[]
+): Promise<{
+  isSingleProjectAccount?: boolean;
+  servicesNamesInput: string[];
+  envNameInput: string;
+  ephemeralEnvName: string | undefined;
+  envName: AllowedEnv;
+  roleName: string;
+  outputFile: string;
+  servicesNames: string;
+  bootstrappingServices: string;
+  accountMap: string;
+  landingZones: string[];
+}> => {
+  try {
+    if (!args[3]) throw new SynthError('Missing env');
+    const envNameInput: string = args[3];
+    const servicesNamesInput: string[] = args.slice(4);
+
+    const envName = (envNameInput.includes('-') ? (envNameInput.split('-')[0] as string) : envNameInput) as AllowedEnv;
+    const ephemeralEnvName = envNameInput.includes('-') ? envNameInput.split('-')[1] : '';
+    const props: propsTypes.BaseGlobalProps = {
+      ...globalConstConfig,
+      ...globalEnvConfig[envName],
+      envName,
+      ephemeralEnvName,
+      regionName: '', // Add the regionName property
+      deployTarget: {}, // Add the deployTarget property
+    };
+
+    if (!globalDeployTargetConfig[envName]) throw new SynthError('Invalid Env');
+
+    const landingZones = await Promise.all(globalConstConfig.landingZones.map((l) => accountMapping(l, 'landingzone')));
+
+    const accountMap = parseContext(
+      (
+        await Promise.all(
+          Object.keys(globalDeployTargetConfig[envName]).map(async (a) => {
+            const account: string = globalDeployTargetConfig[envName][a as DeployTargetName]['account'];
+            if (!account.includes('-')) return `${a}=${account}`;
+            const [env, ...project] = account.split('-').reverse();
+            const composed = project.reverse();
+            return `${a}=${await accountMapping(composed.join('-'), env!)}`;
+          })
+        )
+      ).join('&')
+    );
+    const outputFile = `cdk.out/output/${envNameInput}.json`;
+    const roleName = globalEnvConfig[envName].roleName;
+    const servicesNames = parseServicesNames(servicesNamesInput, props);
+
+    const bootstrappingServices = globalConstConfig.bootstrappingServices ? parseServicesNames(globalConstConfig.bootstrappingServices, props) : '';
+
+    return {
+      isSingleProjectAccount: props.isSingleProjectAccount,
+      servicesNamesInput,
+      envName,
+      envNameInput,
+      ephemeralEnvName,
+      roleName,
+      outputFile,
+      servicesNames,
+      bootstrappingServices,
+      accountMap,
+      landingZones,
+    };
+  } catch (error: any) {
+    console.log(`PreScript Error: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+const parseServicesNames = (servicesNamesInput: string[], props: propsTypes.BaseGlobalProps): string => {
+  return servicesNamesInput.length < 1
+    ? '--all'
+    : `${servicesNamesInput.reduce((acc, s) => {
+        acc += `${getServiceName(s, props)} `;
+        return acc;
+      }, '')}--exclusively`;
+};
+
+const parseContext = (stringContext: string): string => {
+  if (!stringContext) return '';
+  return stringContext
+    .split('&')
+    .map((c) => `--context ${c} `)
+    .join('');
+};