@mstuercke/pulumi-modules 0.0.7 → 0.0.8

package/dist/auth0/Auth0.d.ts

@@ -0,0 +1,29 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type Auth0Domain = `${string}.auth0.com`;
+export type Auth0URL = `http://${string}` | `https://${string}`;
+export interface Auth0User {
+    name: string;
+    email: string;
+    password: string;
+    emailVerified: boolean;
+    appMetadata?: Record<string, unknown>;
+}
+export interface Auth0Args {
+    projectId: string;
+    environmentName: string;
+    tenantDisplayName: string;
+    clientDisplayName: string;
+    domain: Auth0Domain;
+    m2mClientId: string;
+    allowedUrls: Auth0URL[];
+    allowedLoginCallbackUrls?: Auth0URL[];
+    allowedLogoutCallbackUrls?: Auth0URL[];
+    nativeAppId?: `com.${string}`;
+    defaultUsers?: Auth0User[];
+    disableSignup?: boolean;
+}
+export declare class Auth0 extends Resource {
+    domain: string;
+    clientId: Output<string>;
+    constructor(id: string, args: Auth0Args, opts?: CustomResourceOptions);
+}

package/dist/auth0/Auth0.js

@@ -0,0 +1,81 @@
+import { Resource } from '@pulumi/pulumi';
+import { Client, ClientCredentials, Connection, ConnectionClient, Provider, Tenant, User } from '@pulumi/auth0';
+export class Auth0 extends Resource {
+    domain;
+    clientId;
+    constructor(id, args, opts) {
+        super('mstuercke:auth0:Auth0', id, false, undefined, opts);
+        const { projectId, environmentName, tenantDisplayName, clientDisplayName, domain, m2mClientId, allowedUrls, allowedLoginCallbackUrls, allowedLogoutCallbackUrls, nativeAppId, defaultUsers = [], disableSignup = false, } = args;
+        new Provider('provider', {}, { parent: this });
+        new Tenant('tenant', {
+            friendlyName: tenantDisplayName,
+            flags: {
+                enableClientConnections: false,
+            },
+        }, { parent: this });
+        const nativeAppCallbackUrls = nativeAppId
+            ? [
+                `${nativeAppId}.auth0://${domain}/ios/${nativeAppId}/callback`,
+                `${nativeAppId}.auth0://${domain}/android/${nativeAppId}/callback`,
+            ]
+            : [];
+        const client = new Client('client', {
+            name: clientDisplayName,
+            appType: 'spa',
+            callbacks: [...(allowedLoginCallbackUrls || allowedUrls), ...nativeAppCallbackUrls],
+            webOrigins: allowedUrls,
+            allowedLogoutUrls: [...(allowedLogoutCallbackUrls || allowedUrls), ...nativeAppCallbackUrls],
+            jwtConfiguration: {
+                alg: 'RS256',
+            },
+            addons: {},
+        }, { parent: this });
+        const connection = new Connection('password-authentication', {
+            name: `${projectId}-${environmentName}`,
+            strategy: 'auth0',
+            options: {
+                disableSignup: disableSignup,
+                bruteForceProtection: true,
+            },
+        }, { parent: this });
+        const m2mClientConnection = new ConnectionClient('password-authentication-m2m-client', {
+            clientId: m2mClientId,
+            connectionId: connection.id,
+        }, { parent: client });
+        const clientConnection = new ConnectionClient('password-authentication-client', {
+            clientId: client.id,
+            connectionId: connection.id,
+        }, { parent: client });
+        // TODO: Implement disabling of google-oauth2 (If possible, also disable "Username-Password-Authentication")
+        // // disable google-oauth2 on all clients
+        // const googleOauth2Connection = output(getConnection({name: 'google-oauth2'}))
+        // new ConnectionClients(
+        //   'google-oauth2-clien',
+        //   {
+        //     connectionId: googleOauth2Connection.id,
+        //     enabledClients: [],
+        //   },
+        //   {parent: client, dependsOn: [client]},
+        // )
+        new ClientCredentials('credentials', {
+            clientId: client.id,
+            authenticationMethod: 'none',
+        }, { parent: this });
+        for (const defaultUser of defaultUsers) {
+            const { name, email, emailVerified, password, appMetadata } = defaultUser;
+            new User(`default-user-${defaultUser.email}`, {
+                connectionName: connection.name,
+                name: name,
+                email: email,
+                emailVerified: emailVerified,
+                password: password,
+                appMetadata: appMetadata ? JSON.stringify(appMetadata) : undefined,
+            }, {
+                dependsOn: [m2mClientConnection, clientConnection],
+                parent: connection,
+            });
+        }
+        this.domain = domain;
+        this.clientId = client.id;
+    }
+}

package/dist/auth0/index.d.ts

@@ -0,0 +1,5 @@
+import { Auth0 } from './Auth0';
+export * from './Auth0';
+export declare const auth0: {
+    Auth0: typeof Auth0;
+};

package/dist/auth0/index.js

@@ -0,0 +1,5 @@
+import { Auth0 } from './Auth0';
+export * from './Auth0';
+export const auth0 = {
+    Auth0,
+};

package/dist/domain/getDomain.d.ts

@@ -0,0 +1,13 @@
+import { type Provider } from '@pulumi/aws';
+export interface DataDomainOptions {
+    usEast1Provider: Provider;
+    name: `${string}.${string}`;
+}
+export type DomainResult = {
+    name: string;
+    zoneId: string;
+    nameServers: string[];
+    usEast1CertificateArn: string;
+    euCentral1CertificateArn: string;
+};
+export declare const getDomain: (options: DataDomainOptions) => Promise<DomainResult>;

package/dist/domain/getDomain.js

@@ -0,0 +1,14 @@
+import { acm, route53 } from '@pulumi/aws';
+export const getDomain = async (options) => {
+    const { usEast1Provider, name } = options;
+    const zone = await route53.getZone({ name });
+    const euCentral1Certificate = await acm.getCertificate({ domain: name });
+    const usEast1Certificate = await acm.getCertificate({ domain: name }, { provider: usEast1Provider });
+    return {
+        name: zone.name,
+        zoneId: zone.zoneId,
+        nameServers: zone.nameServers,
+        usEast1CertificateArn: usEast1Certificate.arn,
+        euCentral1CertificateArn: euCentral1Certificate.arn,
+    };
+};

package/dist/domain/index.d.ts

@@ -0,0 +1,4 @@
+export * from './getDomain';
+export declare const domain: {
+    getDomain: (options: import("./getDomain").DataDomainOptions) => Promise<import("./getDomain").DomainResult>;
+};

package/dist/domain/index.js

@@ -0,0 +1,5 @@
+import { getDomain } from './getDomain';
+export * from './getDomain';
+export const domain = {
+    getDomain,
+};

package/dist/iam/SimpleIamRolePolicy.d.ts

@@ -0,0 +1,6 @@
+import { iam } from '@pulumi/aws';
+import type { SimpleIamRolePolicyConfig } from './SimpleIamRolePolicyConfig.js';
+import { type CustomResourceOptions } from '@pulumi/pulumi';
+export declare class SimpleIamRolePolicy extends iam.RolePolicy {
+    constructor(iamRoleId: string, config: SimpleIamRolePolicyConfig, opts?: CustomResourceOptions);
+}

package/dist/iam/SimpleIamRolePolicy.js

@@ -0,0 +1,115 @@
+import { iam } from '@pulumi/aws';
+import { output } from '@pulumi/pulumi';
+export class SimpleIamRolePolicy extends iam.RolePolicy {
+    constructor(iamRoleId, config, opts) {
+        switch (config.type) {
+            case 'custom':
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, config.statements), opts);
+                break;
+            case 'dynamodb':
+                if (config.level !== 'full-access')
+                    throw mapError(config);
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Action: ['dynamodb:*'],
+                        Effect: 'Allow',
+                        Resource: output(config.tableArn).apply((tableArn) => [`${tableArn}`, `${tableArn}/*`]),
+                    },
+                ]), opts);
+                break;
+            case 'timestream':
+                if (config.level !== 'full-access')
+                    throw mapError(config);
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Action: ['timestream:*'],
+                        Effect: 'Allow',
+                        Resource: [config.dbArn, config.tableArn],
+                    },
+                    {
+                        Action: ['timestream:DescribeEndpoin'],
+                        Effect: 'Allow',
+                        Resource: ['*'],
+                    },
+                ]), opts);
+                break;
+            case 's3':
+                if (config.level !== 'full-access')
+                    throw mapError(config);
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Action: ['s3:*'],
+                        Effect: 'Allow',
+                        Resource: output(config.bucketArn).apply((bucketArn) => [`${bucketArn}`, `${bucketArn}/*`]),
+                    },
+                ]), opts);
+                break;
+            case 'cognito':
+                if (config.level !== 'full-access')
+                    throw mapError(config);
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Action: ['cognito-idp:*'],
+                        Effect: 'Allow',
+                        Resource: [config.userPoolArn],
+                    },
+                ]), opts);
+                break;
+            case 'websocket':
+                if (config.level !== 'full-access')
+                    throw mapError(config);
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Effect: 'Allow',
+                        Action: 'execute-api:*',
+                        Resource: config.apiArn,
+                    },
+                ]), opts);
+                break;
+            case 'sns':
+                if (config.level !== 'publish-message')
+                    throw mapError(config);
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Effect: 'Allow',
+                        Action: 'sns:Publish',
+                        Resource: config.snsTopicArn,
+                    },
+                ]), opts);
+                break;
+            case 'execute-lambda':
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Effect: 'Allow',
+                        Action: 'lambda:InvokeFunction',
+                        Resource: config.lambdaArn,
+                    },
+                ]), opts);
+                break;
+            case 'event-bridge':
+                super(config.name, mapIamRolePolicyConfig(iamRoleId, config.name, [
+                    {
+                        Effect: 'Allow',
+                        Action: ['events:DescribeRule', 'events:DisableRule', 'events:EnableRule'],
+                        Resource: config.ruleArn,
+                    },
+                ]), opts);
+                break;
+            default:
+                throw mapError(config);
+        }
+    }
+}
+function mapIamRolePolicyConfig(iamRoleId, name, statements) {
+    return {
+        role: iamRoleId,
+        name: name,
+        policy: {
+            Version: '2012-10-17',
+            Statement: statements,
+        },
+    };
+}
+function mapError(config) {
+    return new Error(`Unable to create policy with config: ${JSON.stringify(config)}`);
+}

package/dist/iam/SimpleIamRolePolicyConfig.d.ts

@@ -0,0 +1,57 @@
+import type { Input } from '@pulumi/pulumi';
+import type { PolicyStatement } from '@pulumi/aws/iam';
+export type SimpleIamRolePolicyConfig = CustomPolicyConfig | DynamoDbPolicyConfig | TimestreamPolicyConfig | S3PolicyConfig | CognitoPolicyConfig | WebsocketPolicyConfig | ExecuteLambdaConfig | SnsPolicyConfig | EventBridgeConfig;
+interface CustomPolicyConfig {
+    type: 'custom';
+    name: string;
+    statements: PolicyStatement[];
+}
+interface DynamoDbPolicyConfig {
+    type: 'dynamodb';
+    level: 'full-access';
+    name: string;
+    tableArn: Input<string>;
+}
+interface TimestreamPolicyConfig {
+    type: 'timestream';
+    level: 'full-access';
+    name: string;
+    dbArn: Input<string>;
+    tableArn: Input<string>;
+}
+interface S3PolicyConfig {
+    type: 's3';
+    level: 'full-access';
+    name: string;
+    bucketArn: Input<string>;
+}
+interface CognitoPolicyConfig {
+    type: 'cognito';
+    level: 'full-access';
+    name: string;
+    userPoolArn: Input<string>;
+}
+interface WebsocketPolicyConfig {
+    type: 'websocket';
+    level: 'full-access';
+    name: string;
+    apiArn: '*';
+}
+interface SnsPolicyConfig {
+    type: 'sns';
+    level: 'publish-message';
+    name: string;
+    snsTopicArn: Input<string>;
+}
+interface ExecuteLambdaConfig {
+    type: 'execute-lambda';
+    name: string;
+    lambdaArn: Input<string>;
+}
+interface EventBridgeConfig {
+    type: 'event-bridge';
+    level: 'enable-disable-rule';
+    name: string;
+    ruleArn: Input<string>;
+}
+export {};

package/dist/iam/SimpleIamRolePolicyConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/iam/index.d.ts

@@ -0,0 +1,6 @@
+import { SimpleIamRolePolicy } from './SimpleIamRolePolicy';
+export * from './SimpleIamRolePolicy';
+export * from './SimpleIamRolePolicyConfig';
+export declare const iam: {
+    SimpleIamRolePolicy: typeof SimpleIamRolePolicy;
+};

package/dist/iam/index.js

@@ -0,0 +1,6 @@
+import { SimpleIamRolePolicy } from './SimpleIamRolePolicy';
+export * from './SimpleIamRolePolicy';
+export * from './SimpleIamRolePolicyConfig';
+export const iam = {
+    SimpleIamRolePolicy,
+};

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export * from './auth0';
+export * from './domain';
+export * from './iam';
+export * from './lambda';
+export * from './mongodb';
+export * from './rest';
+export * from './s3';
+export * from './website';
+export * from './websocket';
+export declare const mstuercke: {
+    auth0: {
+        Auth0: typeof import("./auth0").Auth0;
+    };
+    domain: {
+        getDomain: (options: import("./domain").DataDomainOptions) => Promise<import("./domain").DomainResult>;
+    };
+    iam: {
+        SimpleIamRolePolicy: typeof import("./iam").SimpleIamRolePolicy;
+    };
+    lambda: {
+        NodeLambdaFunction: typeof import("./lambda").NodeLambdaFunction;
+    };
+    mongodb: {
+        MongoDBCustomInstance: typeof import("./mongodb").MongoDBCustomInstance;
+        MongoDBDefaultInstance: typeof import("./mongodb").MongoDBDefaultInstance;
+        MongoDBUser: typeof import("./mongodb").MongoDBUser;
+    };
+    rest: {
+        RestApi: typeof import("./rest").RestApi;
+    };
+    s3: {
+        PublicS3Bucket: typeof import("./s3").PublicS3Bucket;
+    };
+    website: {
+        StaticWebsite: typeof import("./website").StaticWebsite;
+    };
+    websocket: {
+        WebsocketApi: typeof import("./websocket").WebsocketApi;
+    };
+};

package/dist/index.js

@@ -0,0 +1,29 @@
+import { auth0 } from './auth0';
+import { domain } from './domain';
+import { iam } from './iam';
+import { rest } from './rest';
+import { lambda } from './lambda';
+import { mongodb } from './mongodb';
+import { s3 } from './s3';
+import { website } from './website';
+import { websocket } from './websocket';
+export * from './auth0';
+export * from './domain';
+export * from './iam';
+export * from './lambda';
+export * from './mongodb';
+export * from './rest';
+export * from './s3';
+export * from './website';
+export * from './websocket';
+export const mstuercke = {
+    auth0,
+    domain,
+    iam,
+    lambda,
+    mongodb,
+    rest,
+    s3,
+    website,
+    websocket: websocket,
+};

package/dist/lambda/NodeLambdaFunction.d.ts

@@ -0,0 +1,20 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+import { type SimpleIamRolePolicyConfig } from '../iam';
+import type { WithInputs } from './WithInputs.js';
+export type NodeLambdaFunctionArgs<EnvironmentVariables> = {
+    name: string;
+    runtime?: string;
+    functionHandler?: string;
+    memorySize?: number;
+    timeoutSeconds?: number;
+    lambdaPath: string;
+    additionalIamRolePolicies?: SimpleIamRolePolicyConfig[];
+    environmentVariables?: WithInputs<EnvironmentVariables>;
+    projectId: string;
+};
+export declare class NodeLambdaFunction<EnvironmentVariables extends Record<string, string> = Record<string, string>> extends Resource {
+    name: string;
+    arn: Output<string>;
+    invokeArn: Output<string>;
+    constructor(args: NodeLambdaFunctionArgs<EnvironmentVariables>, opts?: CustomResourceOptions);
+}

package/dist/lambda/NodeLambdaFunction.js

@@ -0,0 +1,71 @@
+import { iam, lambda } from '@pulumi/aws';
+import { getFile } from '@pulumi/archive';
+import { asset, Resource } from '@pulumi/pulumi';
+import { SimpleIamRolePolicy } from '../iam';
+export class NodeLambdaFunction extends Resource {
+    name;
+    arn;
+    invokeArn;
+    constructor(args, opts) {
+        super('mstuercke:lambda:NodeLambdaFunction', args.name, false, undefined, opts);
+        const { name, additionalIamRolePolicies = [], environmentVariables = undefined, runtime = 'nodejs22.x', functionHandler = 'lambdaFunction.lambdaHandler', memorySize = 128, timeoutSeconds = 30, projectId, } = args;
+        const role = new iam.Role(name, {
+            name: `${name}-lambda`,
+            assumeRolePolicy: JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Action: 'sts:AssumeRole',
+                        Principal: { Service: 'lambda.amazonaws.com' },
+                        Effect: 'Allow',
+                    },
+                ],
+            }),
+            tags: {
+                project: projectId,
+            },
+        }, { parent: this });
+        role.id.apply((roleId) => {
+            new SimpleIamRolePolicy(roleId, {
+                type: 'custom',
+                name: 'logging',
+                statements: [
+                    {
+                        Effect: 'Allow',
+                        Action: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEven'],
+                        Resource: '*',
+                    },
+                ],
+            }, { parent: this });
+            for (const config of additionalIamRolePolicies) {
+                new SimpleIamRolePolicy(roleId, config, { parent: this });
+            }
+        });
+        const lambdaZip = getFile({
+            type: 'zip',
+            sourceDir: args.lambdaPath,
+            outputPath: `dist/lambda/${name}.zip`,
+        });
+        const lambdaFunction = new lambda.Function(name, {
+            name: name,
+            handler: functionHandler,
+            runtime: runtime,
+            memorySize: memorySize,
+            timeout: timeoutSeconds,
+            code: new asset.FileArchive(lambdaZip.then((lambdaZip) => lambdaZip.outputPath)),
+            sourceCodeHash: lambdaZip.then((lambdaZip) => lambdaZip.outputBase64sha256),
+            role: role.arn,
+            environment: {
+                variables: {
+                    ...environmentVariables,
+                },
+            },
+            tags: {
+                project: projectId,
+            },
+        }, { parent: this });
+        this.name = name;
+        this.arn = lambdaFunction.arn;
+        this.invokeArn = lambdaFunction.invokeArn;
+    }
+}

package/dist/lambda/WithInputs.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from '@pulumi/pulumi';
+export type WithInputs<T> = {
+    [key in keyof T]: Input<T[key]>;
+};

package/dist/lambda/WithInputs.js

@@ -0,0 +1 @@
+export {};

package/dist/lambda/index.d.ts

@@ -0,0 +1,5 @@
+import { NodeLambdaFunction } from './NodeLambdaFunction';
+export * from './NodeLambdaFunction';
+export declare const lambda: {
+    NodeLambdaFunction: typeof NodeLambdaFunction;
+};

package/dist/lambda/index.js

@@ -0,0 +1,5 @@
+import { NodeLambdaFunction } from './NodeLambdaFunction';
+export * from './NodeLambdaFunction';
+export const lambda = {
+    NodeLambdaFunction,
+};

package/dist/mongodb/MongoDB.d.ts

@@ -0,0 +1,13 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type MongoDBArgs = {
+    organizationId: string;
+    projectId: string;
+    environmentName: string;
+};
+export declare class MongoDB extends Resource {
+    readonly connectionString: Output<string>;
+    readonly databaseName: string;
+    readonly username: string;
+    readonly password: Output<string>;
+    constructor(args: MongoDBArgs, opts?: CustomResourceOptions);
+}

package/dist/mongodb/MongoDB.js

@@ -0,0 +1,51 @@
+import { Resource } from '@pulumi/pulumi';
+import { RandomPassword } from '@pulumi/random';
+import { DatabaseUser, Project, ProjectIpAccessList, Provider, ServerlessInstance } from '@pulumi/mongodbatlas';
+export class MongoDB extends Resource {
+    connectionString;
+    databaseName;
+    username;
+    password;
+    constructor(args, opts) {
+        const { organizationId, projectId, environmentName } = args;
+        super('mstuercke:mongodb:MongoDB', organizationId, false, undefined, opts);
+        new Provider('provider', {}, { parent: this });
+        const mongoProject = new Project('project', {
+            orgId: organizationId,
+            name: `${projectId}-${environmentName}`,
+            tags: {
+                project: projectId,
+            },
+        }, { parent: this });
+        new ProjectIpAccessList('network-access', {
+            projectId: mongoProject.id,
+            cidrBlock: '0.0.0.0/0',
+        }, { parent: mongoProject });
+        const mongoInstance = new ServerlessInstance('database', {
+            projectId: mongoProject.id,
+            name: `${projectId}-${environmentName}`,
+            providerSettingsBackingProviderName: 'AWS',
+            providerSettingsProviderName: 'SERVERLESS',
+            providerSettingsRegionName: 'EU_WEST_1', // Ireland
+        }, { parent: mongoProject });
+        const username = `${projectId}-${environmentName}`;
+        const password = new RandomPassword('password', {
+            length: 32,
+        }, { parent: mongoProject });
+        const databaseName = projectId;
+        new DatabaseUser('user', {
+            projectId: mongoProject.id,
+            username,
+            password: password.result,
+            authDatabaseName: 'admin',
+            roles: [
+                { roleName: 'dbAdmin', databaseName },
+                { roleName: 'readWrite', databaseName },
+            ],
+        }, { parent: mongoProject });
+        this.connectionString = mongoInstance.connectionStringsStandardSrv;
+        this.databaseName = databaseName;
+        this.username = username;
+        this.password = password.result;
+    }
+}

package/dist/mongodb/MongoDBCustomInstance.d.ts

@@ -0,0 +1,12 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type MongoDBCustomInstanceArgs = {
+    organizationId: string;
+    projectId: string;
+    environmentName: string;
+};
+export declare class MongoDBCustomInstance extends Resource {
+    readonly mongoProjectId: Output<string>;
+    readonly connectionString: Output<string>;
+    readonly databaseName: string;
+    constructor(args: MongoDBCustomInstanceArgs, opts?: CustomResourceOptions);
+}

package/dist/mongodb/MongoDBCustomInstance.js

@@ -0,0 +1,32 @@
+import { Resource } from '@pulumi/pulumi';
+import { Project, ProjectIpAccessList, ServerlessInstance } from '@pulumi/mongodbatlas';
+export class MongoDBCustomInstance extends Resource {
+    mongoProjectId;
+    connectionString;
+    databaseName;
+    constructor(args, opts) {
+        const { organizationId, projectId, environmentName } = args;
+        super('mstuercke:mongodb:MongoDBCustomInstance', organizationId, false, undefined, opts);
+        const mongoProject = new Project('project', {
+            orgId: organizationId,
+            name: `${projectId}-${environmentName}`,
+            tags: {
+                project: projectId,
+            },
+        }, { parent: this });
+        new ProjectIpAccessList('network-access', {
+            projectId: mongoProject.id,
+            cidrBlock: '0.0.0.0/0',
+        }, { parent: this });
+        const mongoInstance = new ServerlessInstance('database', {
+            projectId: mongoProject.id,
+            name: `${projectId}-${environmentName}`,
+            providerSettingsBackingProviderName: 'AWS',
+            providerSettingsProviderName: 'SERVERLESS',
+            providerSettingsRegionName: 'EU_WEST_1', // Ireland
+        }, { parent: this });
+        this.mongoProjectId = mongoProject.id;
+        this.connectionString = mongoInstance.connectionStringsStandardSrv;
+        this.databaseName = `${projectId}-${environmentName}`;
+    }
+}