@studion/infra-code-blocks 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Extension Engine, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# `@studion/infra-code-blocks`
+
+Studion common infra components.
+
+## Installation 💻
+
+- Run the command:
+
+```bash
+$ npm i @studion/infra-code-blocks
+```

package/dist/components/ecs.d.ts

@@ -0,0 +1,33 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as aws from '@pulumi/aws';
+import { Size } from './types';
+export type RoleInlinePolicy = {
+    /**
+     * Name of the role policy.
+     */
+    name?: pulumi.Input<string>;
+    /**
+     * Policy document as a JSON formatted string.
+     */
+    policy?: pulumi.Input<string>;
+};
+export type EcsServiceArgs = {
+    image: pulumi.Input<string>;
+    port: pulumi.Input<number>;
+    cluster: aws.ecs.Cluster;
+    subnets: pulumi.Input<pulumi.Input<string>[]>;
+    securityGroupIds: pulumi.Input<pulumi.Input<string>[]>;
+    lb: aws.lb.LoadBalancer;
+    lbTargetGroup: aws.lb.TargetGroup;
+    lbListener: aws.lb.Listener;
+    desiredCount?: pulumi.Input<number>;
+    minCount?: pulumi.Input<number>;
+    maxCount?: pulumi.Input<number>;
+    size?: pulumi.Input<Size>;
+    environment?: aws.ecs.KeyValuePair[];
+    taskExecutionRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
+    taskRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
+};
+export declare class EcsService extends pulumi.ComponentResource {
+    constructor(name: string, args: EcsServiceArgs, opts?: pulumi.ComponentResourceOptions);
+}

package/dist/components/ecs.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsService = void 0;
+const pulumi = require("@pulumi/pulumi");
+const aws = require("@pulumi/aws");
+const constants_1 = require("../constants");
+const config = new pulumi.Config('aws');
+const awsRegion = config.get('region');
+const assumeRolePolicy = {
+    Version: '2012-10-17',
+    Statement: [
+        {
+            Action: 'sts:AssumeRole',
+            Principal: {
+                Service: 'ecs-tasks.amazonaws.com',
+            },
+            Effect: 'Allow',
+            Sid: '',
+        },
+    ],
+};
+class EcsService extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:ecs:Service', name, {}, opts);
+        const logGroup = new aws.cloudwatch.LogGroup(`${name}-log-group`, {
+            retentionInDays: 14,
+            name: `/ecs/${name}`,
+        }, { parent: this });
+        const taskExecutionRole = new aws.iam.Role(`${name}-ecs-task-exec-role`, {
+            name: `${name}-ecs-task-exec-role`,
+            assumeRolePolicy,
+            managedPolicyArns: [
+                'arn:aws:iam::aws:policy/CloudWatchFullAccess',
+                'arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess',
+            ],
+            inlinePolicies: args.taskExecutionRoleInlinePolicies || [],
+        }, { parent: this });
+        const taskRole = new aws.iam.Role(`${name}-ecs-task-role`, {
+            name: `${name}-ecs-task-role`,
+            assumeRolePolicy,
+            inlinePolicies: args.taskRoleInlinePolicies || [],
+        }, { parent: this });
+        const parsedSize = pulumi.all([args.size || 'small']).apply(([size]) => {
+            const mapCapabilities = ({ cpu, memory }) => ({
+                cpu: String(cpu),
+                memory: String(memory),
+            });
+            if (typeof size === 'string') {
+                return mapCapabilities(constants_1.PredefinedSize[size]);
+            }
+            if (typeof size === 'object') {
+                return mapCapabilities(size);
+            }
+            throw Error('Incorrect EcsService size argument');
+        });
+        const taskDefinition = new aws.ecs.TaskDefinition(`${name}-task-definition`, {
+            family: `${name}-task-definition`,
+            networkMode: 'awsvpc',
+            executionRoleArn: taskExecutionRole.arn,
+            taskRoleArn: taskRole.arn,
+            cpu: parsedSize.cpu,
+            memory: parsedSize.memory,
+            requiresCompatibilities: ['FARGATE'],
+            containerDefinitions: pulumi
+                .all([
+                name,
+                args.image,
+                args.port,
+                args.environment || [],
+                logGroup.name,
+                awsRegion,
+            ])
+                .apply(([containerName, image, port, environment, logGroup, region]) => {
+                return JSON.stringify([
+                    {
+                        name: containerName,
+                        image,
+                        essential: true,
+                        portMappings: [
+                            {
+                                containerPort: port,
+                                protocol: 'tcp',
+                            },
+                        ],
+                        logConfiguration: {
+                            logDriver: 'awslogs',
+                            options: {
+                                'awslogs-group': logGroup,
+                                'awslogs-region': region,
+                                'awslogs-stream-prefix': 'ecs',
+                            },
+                        },
+                        environment,
+                    },
+                ]);
+            }),
+        }, { parent: this });
+        const service = new aws.ecs.Service(`${name}-service`, {
+            name,
+            cluster: args.cluster.id,
+            launchType: 'FARGATE',
+            desiredCount: args.desiredCount || 1,
+            taskDefinition: taskDefinition.arn,
+            loadBalancers: [
+                {
+                    containerName: name,
+                    containerPort: args.port,
+                    targetGroupArn: args.lbTargetGroup.arn,
+                },
+            ],
+            networkConfiguration: {
+                assignPublicIp: true,
+                subnets: args.subnets,
+                securityGroups: args.securityGroupIds,
+            },
+        }, {
+            parent: this,
+            dependsOn: [args.lb, args.lbTargetGroup, args.lbListener],
+        });
+        const autoscalingTarget = new aws.appautoscaling.Target(`${name}-autoscale-target`, {
+            minCapacity: args.minCount || 1,
+            maxCapacity: args.maxCount || 10,
+            resourceId: pulumi.interpolate `service/${args.cluster.name}/${service.name}`,
+            serviceNamespace: 'ecs',
+            scalableDimension: 'ecs:service:DesiredCount',
+        }, { parent: this });
+        const memoryAutoscalingPolicy = new aws.appautoscaling.Policy(`${name}-memory-autoscale-policy`, {
+            policyType: 'TargetTrackingScaling',
+            resourceId: autoscalingTarget.resourceId,
+            scalableDimension: autoscalingTarget.scalableDimension,
+            serviceNamespace: autoscalingTarget.serviceNamespace,
+            targetTrackingScalingPolicyConfiguration: {
+                predefinedMetricSpecification: {
+                    predefinedMetricType: 'ECSServiceAverageMemoryUtilization',
+                },
+                targetValue: 80,
+            },
+        }, { parent: this });
+        const cpuAutoscalingPolicy = new aws.appautoscaling.Policy(`${name}-cpu-autoscale-policy`, {
+            policyType: 'TargetTrackingScaling',
+            resourceId: autoscalingTarget.resourceId,
+            scalableDimension: autoscalingTarget.scalableDimension,
+            serviceNamespace: autoscalingTarget.serviceNamespace,
+            targetTrackingScalingPolicyConfiguration: {
+                predefinedMetricSpecification: {
+                    predefinedMetricType: 'ECSServiceAverageCPUUtilization',
+                },
+                targetValue: 60,
+            },
+        }, { parent: this });
+        this.registerOutputs();
+    }
+}
+exports.EcsService = EcsService;

package/dist/components/project.d.ts

@@ -0,0 +1,52 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as aws from '@pulumi/aws';
+import * as awsx from '@pulumi/awsx';
+import * as upstash from '@upstash/pulumi';
+import { Rds, RdsArgs } from './rds';
+import { EcsService, EcsServiceArgs } from './ecs';
+import { Redis, RedisArgs } from './redis';
+import { Environment } from '../constants';
+export type Service = Rds | Redis | EcsService;
+export type Services = Record<string, Service>;
+type ServiceArgs = {
+    serviceName: string;
+};
+export type DatabaseService = {
+    type: 'DATABASE';
+} & ServiceArgs & Pick<RdsArgs, 'dbName' | 'username' | 'password' | 'allocatedStorage' | 'maxAllocatedStorage' | 'instanceClass' | 'applyImmediately'>;
+export type RedisService = {
+    type: 'REDIS';
+} & ServiceArgs & Pick<RedisArgs, 'dbName' | 'region'>;
+export type WebServerService = {
+    type: 'WEB_SERVER';
+    environment?: aws.ecs.KeyValuePair[] | ((services: Services) => aws.ecs.KeyValuePair[]);
+    healtCheckPath?: pulumi.Input<string>;
+} & ServiceArgs & Pick<EcsServiceArgs, 'image' | 'port' | 'desiredCount' | 'minCount' | 'maxCount' | 'size'>;
+export type Environment = (typeof Environment)[keyof typeof Environment];
+export type ProjectArgs = {
+    services: (DatabaseService | RedisService | WebServerService)[];
+    environment: Environment;
+};
+export declare class Project extends pulumi.ComponentResource {
+    name: string;
+    environment: Environment;
+    vpc: awsx.ec2.Vpc;
+    dbSubnetGroup: aws.rds.SubnetGroup | null;
+    dbSecurityGroup: aws.ec2.SecurityGroup | null;
+    cluster: aws.ecs.Cluster | null;
+    lbSecurityGroup: aws.ec2.SecurityGroup | null;
+    lb: aws.lb.LoadBalancer | null;
+    ecsServiceSecurityGroup: aws.ec2.SecurityGroup | null;
+    upstashProvider: upstash.Provider | null;
+    services: Services;
+    constructor(name: string, args: ProjectArgs, opts?: pulumi.ComponentResourceOptions);
+    private createVpc;
+    private createServices;
+    private createDatabasePrerequisites;
+    private createRedisPrerequisites;
+    private createWebServerPrerequisites;
+    private createDatabaseService;
+    private createRedisService;
+    private createWebServerService;
+}
+export {};

package/dist/components/project.js

@@ -0,0 +1,191 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+const pulumi = require("@pulumi/pulumi");
+const aws = require("@pulumi/aws");
+const awsx = require("@pulumi/awsx");
+const upstash = require("@upstash/pulumi");
+const rds_1 = require("./rds");
+const ecs_1 = require("./ecs");
+const redis_1 = require("./redis");
+class Project extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:Project', name, {}, opts);
+        this.dbSubnetGroup = null;
+        this.dbSecurityGroup = null;
+        this.cluster = null;
+        this.lbSecurityGroup = null;
+        this.lb = null;
+        this.ecsServiceSecurityGroup = null;
+        this.upstashProvider = null;
+        this.services = {};
+        const { services, environment } = args;
+        this.name = name;
+        this.environment = environment;
+        this.vpc = this.createVpc();
+        this.createServices(services);
+        this.registerOutputs();
+    }
+    createVpc() {
+        const vpc = new awsx.ec2.Vpc(`${this.name}-vpc`, {
+            numberOfAvailabilityZones: 2,
+            enableDnsHostnames: true,
+            enableDnsSupport: true,
+        }, { parent: this });
+        return vpc;
+    }
+    createServices(services) {
+        const hasDatabaseService = services.some(it => it.type === 'DATABASE');
+        const hasRedisService = services.some(it => it.type === 'REDIS');
+        const hasWebServerService = services.some(it => it.type === 'WEB_SERVER');
+        if (hasDatabaseService)
+            this.createDatabasePrerequisites();
+        if (hasRedisService)
+            this.createRedisPrerequisites();
+        if (hasWebServerService)
+            this.createWebServerPrerequisites();
+        services.forEach(it => {
+            if (it.type === 'DATABASE')
+                this.createDatabaseService(it);
+            if (it.type === 'REDIS')
+                this.createRedisService(it);
+            if (it.type === 'WEB_SERVER')
+                this.createWebServerService(it);
+        });
+    }
+    createDatabasePrerequisites() {
+        this.dbSubnetGroup = new aws.rds.SubnetGroup('db-subnet-group', {
+            subnetIds: this.vpc.privateSubnetIds,
+        }, { parent: this });
+        this.dbSecurityGroup = new aws.ec2.SecurityGroup('db-security-group', {
+            vpcId: this.vpc.vpcId,
+            ingress: [
+                {
+                    protocol: 'tcp',
+                    fromPort: 5432,
+                    toPort: 5432,
+                    cidrBlocks: [this.vpc.vpc.cidrBlock],
+                },
+            ],
+        }, { parent: this });
+    }
+    createRedisPrerequisites() {
+        const upstashConfig = new pulumi.Config('upstash');
+        this.upstashProvider = new upstash.Provider('upstash', {
+            email: upstashConfig.requireSecret('email'),
+            apiKey: upstashConfig.requireSecret('apiKey'),
+        });
+    }
+    createWebServerPrerequisites() {
+        this.cluster = new aws.ecs.Cluster(`${this.name}-cluster`, { name: this.name }, { parent: this });
+        this.lbSecurityGroup = new aws.ec2.SecurityGroup('ecs-lb-security-group', {
+            vpcId: this.vpc.vpcId,
+            ingress: [
+                {
+                    fromPort: 80,
+                    toPort: 80,
+                    protocol: 'tcp',
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+            ],
+            egress: [
+                {
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+            ],
+        }, { parent: this });
+        this.lb = new aws.lb.LoadBalancer('ecs-load-balancer', {
+            loadBalancerType: 'application',
+            subnets: this.vpc.publicSubnetIds,
+            securityGroups: [this.lbSecurityGroup.id],
+            internal: false,
+            ipAddressType: 'ipv4',
+        }, { parent: this });
+        this.ecsServiceSecurityGroup = new aws.ec2.SecurityGroup('ecs-service-security-group', {
+            vpcId: this.vpc.vpcId,
+            ingress: [
+                {
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    securityGroups: [this.lbSecurityGroup.id],
+                },
+            ],
+            egress: [
+                {
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+            ],
+        }, { parent: this });
+    }
+    createDatabaseService(options) {
+        if (!this.dbSecurityGroup || !this.dbSubnetGroup)
+            return;
+        const { serviceName, type } = options, rdsOptions = __rest(options, ["serviceName", "type"]);
+        const instance = new rds_1.Rds(serviceName, Object.assign(Object.assign({}, rdsOptions), { subnetGroupName: this.dbSubnetGroup.name, securityGroupIds: [this.dbSecurityGroup.id] }), { parent: this });
+        this.services[serviceName] = instance;
+    }
+    createRedisService(options) {
+        if (!this.upstashProvider)
+            return;
+        const { serviceName } = options, redisOptions = __rest(options, ["serviceName"]);
+        const instance = new redis_1.Redis(serviceName, redisOptions, {
+            parent: this,
+            provider: this.upstashProvider,
+        });
+        this.services[options.serviceName] = instance;
+    }
+    createWebServerService(options) {
+        if (!this.cluster || !this.ecsServiceSecurityGroup || !this.lb) {
+            return;
+        }
+        const { serviceName, environment, healtCheckPath = '/healtcheck' } = options, ecsOptions = __rest(options, ["serviceName", "environment", "healtCheckPath"]);
+        const lbTargetGroup = new aws.lb.TargetGroup(`${serviceName}-tg`, {
+            port: ecsOptions.port,
+            protocol: 'HTTP',
+            targetType: 'ip',
+            vpcId: this.vpc.vpcId,
+            healthCheck: {
+                healthyThreshold: 3,
+                unhealthyThreshold: 2,
+                interval: 60,
+                timeout: 5,
+                path: healtCheckPath,
+            },
+        }, { parent: this, dependsOn: [this.lb] });
+        const lbListener = new aws.lb.Listener(`${serviceName}-lb-listener`, {
+            loadBalancerArn: this.lb.arn,
+            port: 80,
+            defaultActions: [
+                {
+                    type: 'forward',
+                    targetGroupArn: lbTargetGroup.arn,
+                },
+            ],
+        }, { parent: this, dependsOn: [this.lb, lbTargetGroup] });
+        const parsedEnv = typeof environment === 'function'
+            ? environment(this.services)
+            : environment;
+        const instance = new ecs_1.EcsService(serviceName, Object.assign(Object.assign({}, ecsOptions), { cluster: this.cluster, subnets: this.vpc.publicSubnetIds, securityGroupIds: [this.ecsServiceSecurityGroup.id], lb: this.lb, lbTargetGroup,
+            lbListener, environment: parsedEnv }), { parent: this });
+        this.services[options.serviceName] = instance;
+    }
+}
+exports.Project = Project;

package/dist/components/rds.d.ts

@@ -0,0 +1,20 @@
+import * as aws from '@pulumi/aws';
+import * as pulumi from '@pulumi/pulumi';
+export type RdsArgs = {
+    dbName: pulumi.Input<string>;
+    username: pulumi.Input<string>;
+    password: pulumi.Input<string>;
+    subnetGroupName: pulumi.Input<string>;
+    securityGroupIds: pulumi.Input<pulumi.Input<string>[]>;
+    publiclyAccessible?: pulumi.Input<boolean>;
+    applyImmediately?: pulumi.Input<boolean>;
+    skipFinalSnapshot?: pulumi.Input<boolean>;
+    allocatedStorage?: pulumi.Input<number>;
+    maxAllocatedStorage?: pulumi.Input<number>;
+    instanceClass?: pulumi.Input<string>;
+};
+export type RdsInstance = aws.rds.Instance;
+export declare class Rds extends pulumi.ComponentResource {
+    instance: RdsInstance;
+    constructor(name: string, args: RdsArgs, opts?: pulumi.ComponentResourceOptions);
+}

package/dist/components/rds.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rds = void 0;
+const aws = require("@pulumi/aws");
+const pulumi = require("@pulumi/pulumi");
+class Rds extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:rds:Instance', name, {}, opts);
+        const kms = new aws.kms.Key(`${name}-rds-key`, {
+            customerMasterKeySpec: 'SYMMETRIC_DEFAULT',
+            isEnabled: true,
+            keyUsage: 'ENCRYPT_DECRYPT',
+            multiRegion: false,
+            enableKeyRotation: true,
+        }, { parent: this });
+        this.instance = new aws.rds.Instance(`${name}-rds`, {
+            identifier: name,
+            engine: 'postgres',
+            engineVersion: '14.9',
+            allocatedStorage: args.allocatedStorage || 20,
+            maxAllocatedStorage: args.maxAllocatedStorage || 100,
+            instanceClass: args.instanceClass || 'db.t3.micro',
+            dbName: args.dbName,
+            username: args.username,
+            password: args.password,
+            dbSubnetGroupName: args.subnetGroupName,
+            vpcSecurityGroupIds: args.securityGroupIds,
+            storageEncrypted: true,
+            kmsKeyId: kms.arn,
+            publiclyAccessible: args.publiclyAccessible || false,
+            skipFinalSnapshot: args.skipFinalSnapshot || false,
+            applyImmediately: args.applyImmediately || false,
+            autoMinorVersionUpgrade: true,
+            maintenanceWindow: 'Mon:07:00-Mon:07:30',
+            finalSnapshotIdentifier: `${name}-final-snapshot`,
+            backupWindow: '06:00-06:30',
+            backupRetentionPeriod: 14,
+        }, { parent: this });
+        this.registerOutputs();
+    }
+}
+exports.Rds = Rds;

package/dist/components/redis.d.ts

@@ -0,0 +1,14 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as upstash from '@upstash/pulumi';
+export type RedisArgs = {
+    dbName: pulumi.Input<string>;
+    region?: pulumi.Input<string>;
+};
+export interface RedisOptions extends pulumi.ComponentResourceOptions {
+    provider: upstash.Provider;
+}
+export type RedisInstance = upstash.RedisDatabase;
+export declare class Redis extends pulumi.ComponentResource {
+    instance: RedisInstance;
+    constructor(name: string, args: RedisArgs, opts: RedisOptions);
+}

package/dist/components/redis.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redis = void 0;
+const pulumi = require("@pulumi/pulumi");
+const upstash = require("@upstash/pulumi");
+class Redis extends pulumi.ComponentResource {
+    constructor(name, args, opts) {
+        super('studion:redis:Instance', name, {}, opts);
+        this.instance = new upstash.RedisDatabase(name, {
+            databaseName: args.dbName,
+            region: args.region || 'us-east-1',
+            eviction: true,
+            tls: true,
+        }, { provider: opts.provider, parent: this });
+        this.registerOutputs();
+    }
+}
+exports.Redis = Redis;

package/dist/components/types.d.ts

@@ -0,0 +1,7 @@
+import * as pulumi from '@pulumi/pulumi';
+import { PredefinedSize } from '../constants';
+export type CustomSize = {
+    cpu: pulumi.Input<number>;
+    memory: pulumi.Input<number>;
+};
+export type Size = keyof typeof PredefinedSize | CustomSize;

package/dist/components/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const PredefinedSize: {
+    readonly small: {
+        readonly cpu: number;
+        readonly memory: number;
+    };
+    readonly medium: {
+        readonly cpu: number;
+        readonly memory: 1024;
+    };
+    readonly large: {
+        readonly cpu: 1024;
+        readonly memory: number;
+    };
+    readonly xlarge: {
+        readonly cpu: number;
+        readonly memory: number;
+    };
+};
+export declare const Environment: {
+    readonly DEVELOPMENT: "DEVELOPMENT";
+    readonly PRODUCTION: "PRODUCTION";
+};

package/dist/constants.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = exports.PredefinedSize = void 0;
+const CPU_1_VCPU = 1024;
+const MEMORY_1GB = 1024;
+exports.PredefinedSize = {
+    small: {
+        cpu: CPU_1_VCPU / 4,
+        memory: MEMORY_1GB / 2, // 0.5 GB memory
+    },
+    medium: {
+        cpu: CPU_1_VCPU / 2,
+        memory: MEMORY_1GB, // 1 GB memory
+    },
+    large: {
+        cpu: CPU_1_VCPU,
+        memory: MEMORY_1GB * 2, // 2 GB memory
+    },
+    xlarge: {
+        cpu: CPU_1_VCPU * 2,
+        memory: MEMORY_1GB * 4, // 4 GB memory
+    },
+};
+exports.Environment = {
+    DEVELOPMENT: 'DEVELOPMENT',
+    PRODUCTION: 'PRODUCTION',
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components/ecs';
+export * from './components/rds';
+export * from './components/redis';
+export * from './components/project';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./components/ecs"), exports);
+__exportStar(require("./components/rds"), exports);
+__exportStar(require("./components/redis"), exports);
+__exportStar(require("./components/project"), exports);

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@studion/infra-code-blocks",
+  "version": "0.0.1",
+  "description": "Studion common infra components",
+  "keywords": [
+    "infrastructure",
+    "Pulumi",
+    "components",
+    "Studion"
+  ],
+  "homepage": "https://github.com/ExtensionEngine/infra-code-blocks#readme",
+  "bugs": {
+    "url": "https://github.com/ExtensionEngine/infra-code-blocks/issues"
+  },
+  "repository": "git+https://github.com/ExtensionEngine/infra-code-blocks.git",
+  "license": "MIT",
+  "author": {
+    "name": "Studion",
+    "email": "info@gostudion.com",
+    "url": "https://www.gostudion.com"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf dist",
+    "format": "prettier -w .",
+    "release": "release-it",
+    "test": ""
+  },
+  "prettier": "@studion/prettier-config",
+  "dependencies": {
+    "@pulumi/aws": "^5.0.0",
+    "@pulumi/awsx": "^1.0.0",
+    "@pulumi/pulumi": "^3.0.0",
+    "@upstash/pulumi": "^0.2.0"
+  },
+  "devDependencies": {
+    "@studion/prettier-config": "^0.1.0",
+    "@types/node": "^18",
+    "prettier": "^3.0.3",
+    "release-it": "^16.2.1",
+    "typescript": "^5.2.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "release-it": {
+    "github": {
+      "release": true
+    }
+  }
+}