@stacksjs/cloud 0.66.0 → 0.67.0

package/src/cloud/jump-box.ts

@@ -1,47 +0,0 @@
-import type { aws_efs as efs } from 'aws-cdk-lib'
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { aws_ec2 as ec2, aws_iam as iam, CfnOutput as Output } from 'aws-cdk-lib'
-
-export interface JumpBoxStackProps extends NestedCloudProps {
-  vpc: ec2.Vpc
-  fileSystem: efs.FileSystem
-}
-
-// export class DocsStack extends NestedStack {
-export class JumpBoxStack {
-  jumpBox?: ec2.Instance
-
-  constructor(scope: Construct, props: JumpBoxStackProps) {
-    const role = new iam.Role(scope, 'JumpBoxInstanceRole', {
-      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
-      managedPolicies: [
-        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
-        iam.ManagedPolicy.fromAwsManagedPolicyName('CloudWatchAgentServerPolicy'),
-      ],
-    })
-
-    // this instance needs to be created once to mount the EFS & clone the Stacks repo
-    this.jumpBox = new ec2.Instance(scope, 'JumpBox', {
-      vpc: props.vpc,
-      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T2, ec2.InstanceSize.MICRO),
-      machineImage: new ec2.AmazonLinuxImage(),
-      role,
-      userData: ec2.UserData.custom(`
-      #!/bin/bash
-      yum update -y
-      yum install -y amazon-efs-utils
-      yum install -y git
-      yum install -y https://s3.us-east-1.amazonaws.com/amazon-ssm-us-east-1/latest/linux_amd64/amazon-ssm-agent.rpm
-      mkdir /mnt/efs
-      mount -t efs ${props.fileSystem.fileSystemId}:/ /mnt/efs
-      git clone https://github.com/stacksjs/stacks.git /mnt/efs
-    `),
-    })
-
-    new Output(scope, 'JumpBoxInstanceId', {
-      value: this.jumpBox.instanceId,
-      description: 'The ID of the EC2 instance that can be used to SSH into the Stacks Cloud.',
-    })
-  }
-}

package/src/cloud/network.ts

@@ -1,32 +0,0 @@
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { aws_ec2 as ec2 } from 'aws-cdk-lib'
-
-export interface NetworkStackProps extends NestedCloudProps {
-  //
-}
-
-export class NetworkStack {
-  vpc: ec2.Vpc
-
-  constructor(scope: Construct, props: NetworkStackProps) {
-    this.vpc = new ec2.Vpc(scope, 'Network', {
-      vpcName: `${props.slug}-${props.appEnv}-vpc`,
-      ipAddresses: ec2.IpAddresses.cidr('10.0.0.0/16'),
-      maxAzs: 3,
-      natGateways: 0,
-      subnetConfiguration: [
-        {
-          name: 'public-subnet-1',
-          subnetType: ec2.SubnetType.PUBLIC,
-          cidrMask: 24,
-        },
-        {
-          name: 'private-subnet-1',
-          subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
-          cidrMask: 28,
-        },
-      ],
-    })
-  }
-}

package/src/cloud/permissions.ts

@@ -1,33 +0,0 @@
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { config } from '@stacksjs/config'
-import { env } from '@stacksjs/env'
-import { string } from '@stacksjs/strings'
-import { aws_iam as iam, SecretValue } from 'aws-cdk-lib'
-
-export interface PermissionsStackProps extends NestedCloudProps {
-  //
-}
-
-export class PermissionsStack {
-  constructor(scope: Construct) {
-    const teamName = config.team.name
-    const users = config.team.members
-    const password = env.AWS_DEFAULT_PASSWORD || string.random()
-
-    for (const name in users) {
-      // const userEmail = users[userName]
-      const id = `User${string.pascalCase(teamName)}${string.pascalCase(name)}`
-      const userName = string.slug(`${teamName}-${name}`)
-      const user = new iam.User(scope, id, {
-        userName,
-        password: SecretValue.unsafePlainText(password),
-        passwordResetRequired: true,
-      })
-
-      user.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AdministratorAccess'))
-
-      // TODO: email the userEmail their credentials
-    }
-  }
-}

package/src/cloud/queue.ts

@@ -1,164 +0,0 @@
-import type { Cluster, TaskDefinition } from 'aws-cdk-lib/aws-ecs'
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { path } from '@stacksjs/path'
-import { fs } from '@stacksjs/storage'
-import { pascalCase, slug } from '@stacksjs/strings'
-import { aws_ec2 as ec2 } from 'aws-cdk-lib'
-import { Rule, Schedule } from 'aws-cdk-lib/aws-events'
-import { EcsTask } from 'aws-cdk-lib/aws-events-targets'
-
-export interface QueueStackProps extends NestedCloudProps {
-  cluster: Cluster
-  taskDefinition: TaskDefinition
-}
-
-export class QueueStack {
-  scope: Construct
-  props: QueueStackProps
-
-  constructor(scope: Construct, props: QueueStackProps) {
-    this.scope = scope
-    this.props = props
-  }
-
-  async init(): Promise<void> {
-    const jobsDir = path.jobsPath()
-    const actionsDir = path.appPath('Actions')
-    const ormActionDir = path.builtUserActionsPath('src')
-
-    const jobFiles = await fs.readdir(jobsDir)
-    const actionFiles = await fs.readdir(actionsDir)
-    const ormActionFiles = await fs.readdir(ormActionDir)
-    const jobs = []
-
-    // then, need to loop through all app/Jobs/*.ts and create a rule for each, potentially overwriting the Schedule.ts jobs
-    for (const file of jobFiles) {
-      if (!file.endsWith('.ts'))
-        continue
-
-      const jobPath = path.jobsPath(file)
-
-      // Await the loading of the job module
-      const job = await this.loadModule(jobPath)
-      this.createQueueRule(job, file)
-      jobs.push(job)
-    }
-
-    for (const ormFile of ormActionFiles) {
-      if (!ormFile.endsWith('.ts'))
-        continue
-
-      const ormActionPath = path.builtUserActionsPath(`src/${ormFile}`)
-
-      // Await the loading of the job module
-      const ormAction = await this.loadModule(ormActionPath)
-      this.createQueueRule(ormAction, ormFile)
-      jobs.push(ormAction)
-    }
-
-    for (const file of actionFiles) {
-      if (!file.endsWith('.ts'))
-        continue
-
-      const actionPath = path.appPath(`Actions/${file}`)
-
-      // Await the loading of the job module
-      const action = await this.loadModule(actionPath)
-      this.createQueueRule(action, file)
-      jobs.push(action)
-    }
-  }
-
-  // Helper function to convert a rate string to a cron object for AWS Schedule
-  cronScheduleFromRate(rate: string): {
-    minute?: string
-    hour?: string
-    month?: string
-    weekDay?: string
-    year?: string
-  } {
-    // Assuming the rate is in standard cron format, split it to map to the AWS Schedule.cron() parameters
-    const parts = rate.split(' ')
-    return {
-      minute: parts[0],
-      hour: parts[1],
-      month: parts[2],
-      weekDay: parts[3],
-      year: parts[4],
-    }
-  }
-
-  async loadModule(filePath: string): Promise<{ default: any }> {
-    const jobModule = await import(filePath)
-
-    return jobModule
-  }
-
-  // TODO: narrow any type -> jobs & actions are allowed
-  createQueueRule(module: { default: any }, file: string): void {
-    // Now you can safely access module.default.rate
-    const rate = module.default?.rate
-
-    // if no rate or job is disabled, no need to schedule, skip
-    if (!rate || module.default?.enabled === false)
-      return
-
-    // Convert the rate to a Schedule object
-    const schedule = Schedule.cron(this.cronScheduleFromRate(rate))
-
-    const id = `QueueRule${pascalCase(file.replace('.ts', ''))}`
-
-    // Perform operations with the jobModule.default as needed
-    const rule = new Rule(this.scope, id, {
-      // schedule to run every second
-      ruleName: `${this.props.appName}-${this.props.appEnv}-queue-rule-${slug(file.replace('.ts', ''))}`,
-      schedule,
-    })
-
-    rule.addTarget(
-      new EcsTask({
-        cluster: this.props.cluster,
-        taskDefinition: this.props.taskDefinition,
-        containerOverrides: [
-          {
-            containerName: `${this.props.appName}-${this.props.appEnv}-api`,
-            environment: [
-              {
-                name: 'QUEUE_WORKER',
-                value: 'true',
-              },
-              {
-                name: 'JOB',
-                value: file,
-              },
-              {
-                name: 'JOB_BACKOFF_FACTOR',
-                value: module.default?.backoffFactor,
-              },
-              {
-                name: 'JOB_RETRIES',
-                value: module.default?.tries,
-              },
-              {
-                name: 'JOB_INITIAL_DELAY',
-                value: module.default?.initialDelay,
-              },
-              {
-                name: 'JOB_JITTER',
-                value: module.default?.jitter,
-              },
-            ],
-          },
-        ],
-
-        retryAttempts: 1, // we utilize a custom retry mechanism in the job itself
-        // retryAttempts: module.default.tries || 3,
-
-        subnetSelection: {
-          subnetType: ec2.SubnetType.PUBLIC, // SubnetType.PRIVATE_WITH_EGRESS
-        },
-      }),
-    )
-  }
-}

package/src/cloud/redirects.ts

@@ -1,52 +0,0 @@
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { config } from '@stacksjs/config'
-import { RemovalPolicy, aws_route53 as route53, aws_s3 as s3 } from 'aws-cdk-lib'
-
-export interface RedirectsStackProps extends NestedCloudProps {
-  //
-}
-
-export class RedirectsStack {
-  redirectZones: route53.IHostedZone[] = []
-
-  constructor(scope: Construct, props: RedirectsStackProps) {
-    // for each redirect, create a bucket & redirect it to the APP_URL
-    config.dns.redirects?.forEach((redirect: string) => {
-      // TODO: use string-ts function here instead
-      const slug = redirect
-        .split('.')
-        .map((part: string, index: number) => (index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
-        .join('') // creates a CamelCase slug from the redirect
-      const hostedZone = route53.HostedZone.fromLookup(scope, 'HostedZone', {
-        domainName: redirect,
-      })
-
-      const redirectBucket = new s3.Bucket(scope, `RedirectBucket${slug}`, {
-        bucketName: `${redirect}-redirect`,
-        websiteRedirect: {
-          hostName: props.domain,
-          protocol: s3.RedirectProtocol.HTTPS,
-        },
-        removalPolicy: RemovalPolicy.DESTROY,
-        autoDeleteObjects: true,
-      })
-
-      new route53.CnameRecord(scope, `RedirectRecord${slug}`, {
-        zone: hostedZone,
-        recordName: 'redirect',
-        domainName: redirectBucket.bucketWebsiteDomainName,
-      })
-    })
-
-    // TODO: fix this – redirects do not work yet
-    config.dns.redirects?.forEach((redirect: string) => {
-      const slug = redirect
-        .split('.')
-        .map((part: string, index: number) => (index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
-        .join('') // creates a CamelCase slug from the redirect
-      const hostedZone = route53.HostedZone.fromLookup(scope, `RedirectHostedZone${slug}`, { domainName: redirect })
-      this.redirectZones.push(hostedZone)
-    })
-  }
-}

package/src/cloud/router-layer/nodejs/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "stacks-router-layer",
-  "version": "0.66.0",
-  "description": "",
-  "author": "",
-  "license": "MIT",
-  "keywords": [],
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "dependencies": {
-    "@stacksjs/router": "^0.64.6"
-  }
-}

package/src/cloud/search-engine.ts

@@ -1,108 +0,0 @@
-// async manageSearchEngine() {
-//   const vpc = this.vpc
-
-//   // Security Group
-//   const bastionSecurityGroup = new ec2.SecurityGroup(this, 'BastionSecurityGroup', {
-//     vpc,
-//     allowAllOutbound: true,
-//     securityGroupName: `${this.appName}-${appEnv}-bastion-sg`,
-//   })
-
-//   const opensearchSecurityGroup = new ec2.SecurityGroup(this, 'OpenSearchSecurityGroup', {
-//     vpc,
-//     securityGroupName: `${this.appName}-${appEnv}-opensearch-sg`,
-//   })
-
-//   opensearchSecurityGroup.addIngressRule(bastionSecurityGroup, ec2.Port.tcp(443))
-
-//   // Service-linked role that Amazon OpenSearch Service will use
-//   const iamClient = new IAMClient({})
-//   const response = await iamClient.send(
-//     new ListRolesCommand({
-//       PathPrefix: '/aws-service-role/opensearchservice.amazonaws.com/',
-//     }),
-//   )
-
-//   // Only if the role for OpenSearch Service doesn't exist, it will be created.
-//   if (response.Roles && response.Roles?.length === 0) {
-//     new iam.CfnServiceLinkedRole(this, 'OpenSearchServiceLinkedRole', {
-//       awsServiceName: 'es.amazonaws.com',
-//     })
-//   }
-
-//   // Bastion host to access Opensearch Dashboards
-//   new ec2.BastionHostLinux(this, 'BastionHost', {
-//     vpc,
-//     securityGroup: bastionSecurityGroup,
-//     machineImage: ec2.MachineImage.latestAmazonLinux2023(),
-//     blockDevices: [
-//       {
-//         deviceName: '/dev/xvda',
-//         volume: ec2.BlockDeviceVolume.ebs(10, {
-//           encrypted: true,
-//         }),
-//       },
-//     ],
-//   })
-
-//   // OpenSearch domain
-//   const domain = new opensearch.Domain(this, 'OpenSearchDomain', {
-//     version: opensearch.EngineVersion.OPENSEARCH_2_9,
-//     nodeToNodeEncryption: true,
-//     enforceHttps: true,
-//     encryptionAtRest: {
-//       enabled: true,
-//     },
-//     vpc,
-//     // unsure if there are "better" ways to do this
-//     vpcSubnets: [
-//       { subnetGroupName: `${this.appName}-${appEnv}-private-subnet-1` },
-//       { subnetGroupName: `${this.appName}-${appEnv}-private-subnet-2` },
-//     ],
-
-//     capacity: {
-//       masterNodes: 2,
-//       dataNodes: 2,
-//       multiAzWithStandbyEnabled: true,
-//     },
-//     ebs: {
-//       volumeSize: 10,
-//       volumeType: ec2.EbsDeviceVolumeType.GP3, // or opensearch.EbsVolumeType.IO1
-//     },
-//     removalPolicy: RemovalPolicy.DESTROY,
-//     zoneAwareness: {
-//       enabled: true,
-//       availabilityZoneCount: 2,
-//     },
-//     securityGroups: [opensearchSecurityGroup],
-//   })
-
-//   domain.addAccessPolicies(
-//     new iam.PolicyStatement({
-//       principals: [new iam.AnyPrincipal()],
-//       actions: ['es:ESHttp*'],
-//       resources: [`${domain.domainArn}/*`],
-//     }),
-//   )
-
-//   // // Lambda
-//   // const dataIndexFunction = PythonFunction(this, 'DataIndex', {
-//   //   runtime: lambda.Runtime.PYTHON_3_10,
-//   //   entry: 'lambda',
-//   //   vpc,
-//   //   environment: {
-//   //     OPENSEARCH_HOST: domain.domainEndpoint,
-//   //   },
-//   // })
-
-//   // domain.connections.allowFrom(dataIndexFunction, Port.tcp(443))
-
-//   // Outputs
-//   new Output(this, 'OpenSearchDomainHost', {
-//     value: domain.domainEndpoint,
-//   })
-
-//   // new Output(this, 'IndexingFunctionName', {
-//   //   value: dataIndexFunction.functionName,
-//   // })
-// }