@mstuercke/pulumi-modules 0.0.7 → 0.0.8

package/dist/mongodb/MongoDBDefaultInstance.d.ts

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

package/dist/mongodb/MongoDBDefaultInstance.js

@@ -0,0 +1,19 @@
+import { output, Resource } from '@pulumi/pulumi';
+import { getProject, getServerlessInstance } from '@pulumi/mongodbatlas';
+export class MongoDBDefaultInstance extends Resource {
+    mongoProjectId;
+    connectionString;
+    databaseName;
+    constructor(args, opts) {
+        const { organizationId, projectId, environmentName } = args;
+        super('mstuercke:mongodb:MongoDBDefaultInstance', organizationId, false, undefined, opts);
+        const mongoProject = output(getProject({ name: 'default' }));
+        const mongoInstance = mongoProject.id.apply((mongoProjectId) => output(getServerlessInstance({
+            projectId: mongoProjectId,
+            name: 'default',
+        })));
+        this.mongoProjectId = mongoProject.id;
+        this.connectionString = mongoInstance.connectionStringsStandardSrv;
+        this.databaseName = `${projectId}-${environmentName}`;
+    }
+}

package/dist/mongodb/MongoDBUser.d.ts

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

package/dist/mongodb/MongoDBUser.js

@@ -0,0 +1,28 @@
+import { Resource } from '@pulumi/pulumi';
+import { RandomPassword } from '@pulumi/random';
+import { DatabaseUser } from '@pulumi/mongodbatlas';
+export class MongoDBUser extends Resource {
+    username;
+    password;
+    constructor(args, opts) {
+        const { mongoProjectId, databaseName, projectId, environmentName } = args;
+        const username = `${projectId}-${environmentName}`;
+        super('mstuercke:mongodb:MongoDBUser', username, false, undefined, opts);
+        const password = new RandomPassword('password', {
+            length: 32,
+            special: false,
+        }, { parent: this });
+        new DatabaseUser('user', {
+            projectId: mongoProjectId,
+            username,
+            password: password.result,
+            authDatabaseName: 'admin',
+            roles: [
+                { roleName: 'dbAdmin', databaseName },
+                { roleName: 'readWrite', databaseName },
+            ],
+        }, { parent: this });
+        this.username = username;
+        this.password = password.result;
+    }
+}

package/dist/mongodb/index.d.ts

@@ -0,0 +1,11 @@
+import { MongoDBCustomInstance } from './MongoDBCustomInstance';
+import { MongoDBDefaultInstance } from './MongoDBDefaultInstance';
+import { MongoDBUser } from './MongoDBUser';
+export * from './MongoDBCustomInstance';
+export * from './MongoDBDefaultInstance';
+export * from './MongoDBUser';
+export declare const mongodb: {
+    MongoDBCustomInstance: typeof MongoDBCustomInstance;
+    MongoDBDefaultInstance: typeof MongoDBDefaultInstance;
+    MongoDBUser: typeof MongoDBUser;
+};

package/dist/mongodb/index.js

@@ -0,0 +1,11 @@
+import { MongoDBCustomInstance } from './MongoDBCustomInstance';
+import { MongoDBDefaultInstance } from './MongoDBDefaultInstance';
+import { MongoDBUser } from './MongoDBUser';
+export * from './MongoDBCustomInstance';
+export * from './MongoDBDefaultInstance';
+export * from './MongoDBUser';
+export const mongodb = {
+    MongoDBCustomInstance,
+    MongoDBDefaultInstance,
+    MongoDBUser,
+};

package/dist/rest/RestApi.d.ts

@@ -0,0 +1,19 @@
+import * as aws from '@pulumi/aws';
+import type { CustomResourceOptions, Input } from '@pulumi/pulumi';
+import type { NodeLambdaFunction } from '../lambda';
+export interface RestApiArgs {
+    name: string;
+    projectId: string;
+    lambdaFunction: NodeLambdaFunction;
+    timeoutSeconds?: number;
+    stageName?: string;
+    domain: {
+        zoneId: Input<string>;
+        fullName: Input<string>;
+        usEast1CertificateArn: Input<string>;
+    };
+}
+export declare class RestApi extends aws.apigateway.RestApi {
+    readonly url: string;
+    constructor(id: string, args: RestApiArgs, opts?: CustomResourceOptions);
+}

package/dist/rest/RestApi.js

@@ -0,0 +1,129 @@
+import * as aws from '@pulumi/aws';
+import { apigateway, lambda } from '@pulumi/aws';
+import { Record } from '@pulumi/aws/route53';
+import { BasePathMapping, DomainName } from '@pulumi/aws/apigateway';
+export class RestApi extends aws.apigateway.RestApi {
+    url;
+    constructor(id, args, opts) {
+        const { name, projectId, stageName = 'v1', domain } = args;
+        super(id, {
+            name,
+            tags: {
+                project: projectId,
+            },
+        }, opts);
+        const { lambdaFunction, timeoutSeconds = 29 } = args;
+        const proxyResource = new apigateway.Resource(`proxy`, {
+            restApi: this.id,
+            parentId: this.rootResourceId,
+            pathPart: '{proxy+}',
+        }, { parent: this });
+        const proxyMethod = new apigateway.Method(`proxy`, {
+            restApi: this.id,
+            resourceId: proxyResource.id,
+            httpMethod: 'ANY',
+            authorization: 'NONE',
+        }, { parent: proxyResource });
+        const lambdaIntegration = new apigateway.Integration(`proxy`, {
+            restApi: this.id,
+            resourceId: proxyResource.id,
+            httpMethod: proxyMethod.httpMethod,
+            integrationHttpMethod: 'POST',
+            type: 'AWS_PROXY',
+            uri: lambdaFunction.invokeArn,
+            timeoutMilliseconds: timeoutSeconds * 1000,
+        }, { parent: proxyMethod });
+        const proxyOptionsMethod = new apigateway.Method(`options`, {
+            restApi: this.id,
+            resourceId: proxyResource.id,
+            httpMethod: 'OPTIONS',
+            authorization: 'NONE',
+        }, { parent: proxyResource });
+        const lambdaIntegrationOptions = new apigateway.Integration(`options`, {
+            restApi: this.id,
+            resourceId: proxyResource.id,
+            httpMethod: proxyOptionsMethod.httpMethod,
+            integrationHttpMethod: 'POST',
+            type: 'AWS_PROXY',
+            uri: lambdaFunction.invokeArn,
+            timeoutMilliseconds: timeoutSeconds * 1000,
+        }, { parent: proxyOptionsMethod });
+        const proxyRootMethod = new apigateway.Method(`proxy-root`, {
+            restApi: this.id,
+            resourceId: this.rootResourceId,
+            httpMethod: 'ANY',
+            authorization: 'NONE',
+        }, { parent: this });
+        const lambdaRootIntegration = new apigateway.Integration(`proxy-root`, {
+            restApi: this.id,
+            resourceId: proxyRootMethod.resourceId,
+            httpMethod: proxyRootMethod.httpMethod,
+            integrationHttpMethod: 'POST',
+            type: 'AWS_PROXY',
+            uri: lambdaFunction.invokeArn,
+            timeoutMilliseconds: timeoutSeconds * 1000,
+        }, { parent: proxyRootMethod });
+        const proxyRootOptionsMethod = new apigateway.Method(`proxy-root-options`, {
+            restApi: this.id,
+            resourceId: this.rootResourceId,
+            httpMethod: 'OPTIONS',
+            authorization: 'NONE',
+        }, { parent: this });
+        const lambdaRootIntegrationOptions = new apigateway.Integration(`proxy-root-options`, {
+            restApi: this.id,
+            resourceId: proxyRootOptionsMethod.resourceId,
+            httpMethod: proxyRootOptionsMethod.httpMethod,
+            integrationHttpMethod: 'POST',
+            type: 'AWS_PROXY',
+            uri: lambdaFunction.invokeArn,
+            timeoutMilliseconds: timeoutSeconds * 1000,
+        }, { parent: proxyRootOptionsMethod });
+        new lambda.Permission(`rest-api`, {
+            statementId: 'AllowRestApiInvoke',
+            action: 'lambda:InvokeFunction',
+            function: lambdaFunction.name,
+            principal: 'apigateway.amazonaws.com',
+            sourceArn: this.executionArn.apply((executionArn) => `${executionArn}/*`),
+        }, { parent: lambdaFunction });
+        const deployment = new apigateway.Deployment(stageName, { restApi: this.id }, {
+            dependsOn: [
+                proxyMethod,
+                lambdaIntegration,
+                lambdaIntegrationOptions,
+                proxyRootMethod,
+                lambdaRootIntegration,
+                lambdaRootIntegrationOptions,
+            ],
+            parent: this,
+        });
+        const stage = new apigateway.Stage(stageName, {
+            restApi: this.id,
+            stageName: stageName,
+            deployment: deployment.id,
+            tags: { project: projectId },
+        }, { parent: deployment });
+        const domainName = new DomainName('domain', {
+            domainName: domain.fullName,
+            certificateArn: domain.usEast1CertificateArn,
+        }, { parent: this });
+        new Record('redirect', {
+            zoneId: domain.zoneId,
+            name: domain.fullName,
+            type: 'A',
+            aliases: [
+                {
+                    zoneId: domainName.cloudfrontZoneId,
+                    name: domainName.cloudfrontDomainName,
+                    evaluateTargetHealth: true,
+                },
+            ],
+            allowOverwrite: true,
+        }, { parent: domainName });
+        new BasePathMapping('root', {
+            restApi: this.id,
+            stageName: stage.stageName,
+            domainName: domainName.domainName,
+        }, { parent: stage });
+        this.url = `https://${domain.fullName}/`;
+    }
+}

package/dist/rest/index.d.ts

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

package/dist/rest/index.js

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

package/dist/s3/PublicS3Bucket.d.ts

@@ -0,0 +1,11 @@
+import { Bucket, type BucketArgs } from '@pulumi/aws/s3';
+import type { CustomResourceOptions } from '@pulumi/pulumi';
+type PublicS3BucketArgs = {
+    name: string;
+    allowPresignedPost?: boolean;
+    tags?: BucketArgs['tags'];
+};
+export declare class PublicS3Bucket extends Bucket {
+    constructor(id: string, args: PublicS3BucketArgs, opts?: CustomResourceOptions);
+}
+export {};

package/dist/s3/PublicS3Bucket.js

@@ -0,0 +1,48 @@
+import { Bucket, BucketAclV2, BucketCorsConfigurationV2, BucketOwnershipControls, BucketPolicy, BucketPublicAccessBlock, } from '@pulumi/aws/s3';
+export class PublicS3Bucket extends Bucket {
+    constructor(id, args, opts) {
+        const { name, allowPresignedPost = false, tags } = args;
+        super(id, { bucket: name, tags }, opts);
+        const accessBlock = new BucketPublicAccessBlock('public-access', {
+            bucket: this.id,
+            blockPublicAcls: false,
+            blockPublicPolicy: false,
+            ignorePublicAcls: false,
+            restrictPublicBuckets: false,
+        }, { parent: this });
+        const ownershipControls = new BucketOwnershipControls('ownership', {
+            bucket: this.id,
+            rule: { objectOwnership: 'BucketOwnerPreferred' },
+        }, { parent: this, dependsOn: [accessBlock] });
+        new BucketAclV2('acl', {
+            bucket: this.id,
+            acl: 'public-read',
+        }, { parent: this, dependsOn: [ownershipControls] });
+        new BucketPolicy('policy', {
+            bucket: this.id,
+            policy: this.arn.apply((arn) => JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Sid: 'Allow Public Access',
+                        Effect: 'Allow',
+                        Principal: '*',
+                        Action: 's3:GetObject',
+                        Resource: `${arn}/*`,
+                    },
+                ],
+            })),
+        }, { parent: this, dependsOn: [accessBlock] });
+        new BucketCorsConfigurationV2('allowAll', {
+            bucket: this.bucket,
+            corsRules: [
+                {
+                    maxAgeSeconds: 3000,
+                    allowedMethods: allowPresignedPost ? ['GET', 'POST'] : ['GET'],
+                    allowedHeaders: ['*'],
+                    allowedOrigins: ['*'],
+                },
+            ],
+        }, { parent: this });
+    }
+}

package/dist/s3/index.d.ts

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

package/dist/s3/index.js

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

package/dist/website/StaticWebsite.d.ts

@@ -0,0 +1,17 @@
+import { type CustomResourceOptions, type Input, Resource } from '@pulumi/pulumi';
+import { type PublicS3Bucket } from '../s3';
+export interface StaticWebsiteArgs {
+    projectId: string;
+    environmentName: string;
+    filesPath: string;
+    customDomain?: {
+        fullName: Input<string>;
+        zoneId: Input<string>;
+        usEast1CertificateArn: Input<string>;
+    };
+}
+export declare class StaticWebsite extends Resource {
+    url: string;
+    bucket: PublicS3Bucket;
+    constructor(id: string, args: StaticWebsiteArgs, opts?: CustomResourceOptions);
+}

package/dist/website/StaticWebsite.js

@@ -0,0 +1,129 @@
+import { Resource } from '@pulumi/pulumi';
+import { s3 } from '../s3';
+import { BucketObject } from '@pulumi/aws/s3';
+import { Distribution } from '@pulumi/aws/cloudfront';
+import { Record } from '@pulumi/aws/route53';
+import { readFilesRecursive } from './readFilesRecursive.js';
+export class StaticWebsite extends Resource {
+    url;
+    bucket;
+    constructor(id, args, opts) {
+        super('mstuercke:website:StaticWebsite', id, false, undefined, opts);
+        const { projectId, environmentName, filesPath, customDomain } = args;
+        const bucket = new s3.PublicS3Bucket('bucket', {
+            name: `${projectId}-web-${environmentName}`,
+            allowPresignedPost: false,
+            tags: {
+                project: projectId,
+            },
+        }, { parent: this });
+        for (const file of readFilesRecursive(filesPath)) {
+            new BucketObject(file.relativePath, {
+                key: file.relativePath,
+                bucket: bucket.id,
+                source: file.absolutePath,
+                contentType: file.mimeType,
+                etag: file.md5,
+                tags: {
+                    project: projectId,
+                },
+            }, { parent: bucket });
+        }
+        const cloudfront = new Distribution(`website`, {
+            enabled: true,
+            comment: `${projectId} (${environmentName})`,
+            defaultRootObject: 'index.html',
+            origins: [
+                {
+                    domainName: bucket.bucketRegionalDomainName,
+                    originId: bucket.id,
+                },
+            ],
+            defaultCacheBehavior: {
+                allowedMethods: ['GET', 'HEAD', 'OPTIONS'],
+                cachedMethods: ['GET', 'HEAD'],
+                targetOriginId: bucket.id,
+                viewerProtocolPolicy: 'redirect-to-https',
+                forwardedValues: {
+                    queryString: false,
+                    cookies: {
+                        forward: 'none',
+                    },
+                },
+            },
+            orderedCacheBehaviors: [
+                {
+                    pathPattern: 'index.html',
+                    allowedMethods: ['GET', 'HEAD', 'OPTIONS'],
+                    cachedMethods: ['GET', 'HEAD'],
+                    targetOriginId: bucket.id,
+                    viewerProtocolPolicy: 'redirect-to-https',
+                    defaultTtl: 0,
+                    maxTtl: 0,
+                    forwardedValues: {
+                        queryString: false,
+                        cookies: {
+                            forward: 'none',
+                        },
+                    },
+                },
+                {
+                    pathPattern: 'config.json',
+                    allowedMethods: ['GET', 'HEAD', 'OPTIONS'],
+                    cachedMethods: ['GET', 'HEAD'],
+                    targetOriginId: bucket.id,
+                    viewerProtocolPolicy: 'redirect-to-https',
+                    defaultTtl: 0,
+                    maxTtl: 0,
+                    forwardedValues: {
+                        queryString: false,
+                        cookies: {
+                            forward: 'none',
+                        },
+                    },
+                },
+            ],
+            customErrorResponses: [
+                {
+                    errorCode: 404,
+                    responsePagePath: '/index.html',
+                    responseCode: 200,
+                    errorCachingMinTtl: 0,
+                },
+            ],
+            restrictions: {
+                geoRestriction: {
+                    restrictionType: 'none',
+                },
+            },
+            viewerCertificate: customDomain
+                ? {
+                    acmCertificateArn: customDomain?.usEast1CertificateArn,
+                    sslSupportMethod: 'sni-only',
+                    minimumProtocolVersion: 'TLSv1.2_2019',
+                }
+                : { cloudfrontDefaultCertificate: true },
+            aliases: customDomain ? [customDomain?.fullName] : undefined,
+            tags: {
+                project: projectId,
+            },
+        }, { parent: this });
+        if (customDomain) {
+            new Record('redirect', {
+                zoneId: customDomain?.zoneId,
+                name: customDomain?.fullName,
+                type: 'A',
+                allowOverwrite: true,
+                aliases: [
+                    {
+                        zoneId: cloudfront.hostedZoneId,
+                        name: cloudfront.domainName,
+                        evaluateTargetHealth: false,
+                    },
+                ],
+            }, { parent: this });
+        }
+        this.url = `https://${customDomain?.fullName || cloudfront.domainName}`;
+        this.bucket = bucket;
+    }
+}

package/dist/website/index.d.ts

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

package/dist/website/index.js

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

package/dist/website/readFilesRecursive.d.ts

@@ -0,0 +1,8 @@
+interface File {
+    absolutePath: string;
+    relativePath: string;
+    md5: string;
+    mimeType: string;
+}
+export declare function readFilesRecursive(dir: string): File[];
+export {};

package/dist/website/readFilesRecursive.js

@@ -0,0 +1,23 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+import mime from 'mime';
+import { globSync } from 'glob';
+export function readFilesRecursive(dir) {
+    const files = globSync(`${dir}/**/*`, { nodir: true });
+    return files.reduce((previousValue, fullPath) => {
+        const content = fs.readFileSync(fullPath, 'base64');
+        const md5 = createHash('md5').update(content, 'base64').digest('hex');
+        const mimeType = mime.getType(fullPath);
+        if (!mimeType)
+            throw `Cannot determine mimeType for ${fullPath}`;
+        return [
+            ...previousValue,
+            {
+                absolutePath: fullPath,
+                relativePath: fullPath.replace(`${dir}/`, '').replace(dir, ''),
+                md5,
+                mimeType,
+            },
+        ];
+    }, []);
+}

package/dist/websocket/WebsocketApi.d.ts

@@ -0,0 +1,22 @@
+import { type CustomResourceOptions, type Input, type Output, Resource } from '@pulumi/pulumi';
+import type { NodeLambdaFunction } from '../lambda';
+export interface WebsocketApiArgs {
+    name: string;
+    lambdaFunction: NodeLambdaFunction;
+    routeThrottling?: {
+        rateLimit?: number;
+        burstLimit?: number;
+    };
+    stageName?: string;
+    domain: {
+        zoneId: Input<string>;
+        fullName: Input<string>;
+        euCentral1CertificateArn: Input<string>;
+    };
+    projectId: string;
+}
+export declare class WebsocketApi extends Resource {
+    id: Output<string>;
+    url: string;
+    constructor(id: string, args: WebsocketApiArgs, opts?: CustomResourceOptions);
+}