@kirschbaum-development/sst-laravel 0.0.3 → 0.0.5

package/AGENTS.md

@@ -0,0 +1,28 @@
+# Agent Guidelines for SST Laravel
+
+This project is an NPM package, and it is an extension of SST to add some functionality on top of it, to help deploy Laravel applications to AWS Fargate using Docker containers.
+
+## Build/Test Commands
+- **Publish**: `npm run publish` (publishes package to npm with public access)
+- No test suite or linting configured in this project
+- No build step required (TypeScript consumed directly by SST)
+
+## Code Style & Conventions
+- **Formatting**: 2-space indentation, LF line endings, UTF-8 charset (see `.editorconfig`)
+- **Language**: TypeScript with SST/Pulumi types
+- **Imports**: Use relative paths for local modules (e.g., `./src/laravel-env.js`), absolute for SST platform (e.g., `../../../.sst/platform/...`)
+- **Types**: Use Input<T> for component props, Output<T> for Pulumi async values, explicit interfaces for public APIs
+- **Naming**: PascalCase for classes/interfaces/types/enums, camelCase for variables/functions, kebab-case for files
+
+## Architecture Patterns
+- Component extends SST's `Component` base class
+- Use `all()` and `.apply()` for Pulumi Output transformations
+- File system operations use Node.js `fs` and `path` modules synchronously
+- Configuration defaults: PHP 8.4, opcache enabled, auto-inject env vars
+- Build artifacts go to `.sst/laravel` directory (managed via `pluginBuildPath`)
+
+## Error Handling & Security
+- Validate paths with `path.resolve()` before file operations
+- Use `fs.existsSync()` checks before reading files
+- Never log or expose secrets/passwords
+- Set proper file permissions (0o755 for scripts, 0o777 for s6 executables)

package/README.md

@@ -1,21 +1,25 @@
 # SST Laravel
 
-This is an unofficial extension of SST to deploy your Laravel application to AWS behind a robust, reliable and scalable infrastructure, with all the power the SST provides.
+SST Laravel is an unofficial extension of [SST](https://sst.dev) created by [Kirschbaum Development](https://kirschbaumdevelopment.com) to deploy your Laravel application to AWS behind a robust, reliable and scalable infrastructure, with all the power of SST.
 
-**TODO: Add explanation about what exactly SST is.**
+SST is a framework that makes it easy to build modern full-stack applications on your own infrastructure.
 
-## What it deploys
+## What gets deployed
 
-Behind the scenes, this extension uses the SST Cluster + Service component, which runs in AWS Fargate using pre-built Docker containers. This all gets deployed on your own AWS account, and you have full control over the infrastructure. Behind the scenes, we use the powerful PHP containers from Serverside Up.
+Behind the scenes, this extension uses the SST Cluster + Service component, which deploys custom Docker containers to AWS Fargate. It all gets deployed on your own AWS account, and you have full control over the infrastructure and which services are connected to your application. 
 
 This package deploys a full-blown infrastructure in AWS, with zero downtime deployments, as it can be seeing in the image below.
 
-![](./images/diagram.png)
+Behind the scenes, we use the powerful PHP containers from [Serverside Up](https://serversideup.net/open-source/docker-php/).
+
+![](https://github.com/kirschbaum-development/sst-laravel/raw/main/images/diagram.png)
 
 ## Pre-requisites
 
 1. NodeJS.
 1. Have [SST](https://sst.dev) installed and configured.
+1. Have [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installed and configured.
+  * Guide on how to set up IAM Credentials [here](https://sst.dev/docs/iam-credentials/).
 
 ## Installation instructions
 
@@ -25,6 +29,14 @@ Pull in the package using npm:
 npm install @kirschbaum/sst-laravel --save
 ```
 
+## Quick start
+
+To get started quickly, you can use the `init` command:
+
+```bash
+npx sst-laravel init
+```
+
 ## Usage
 
 To start using, you only need to import the component in your `sst.config.ts` file:
@@ -44,13 +56,13 @@ Setting up your app to receive HTTP requests, on the `laravel-sst-demo.kdg.dev`
 
 ```js
 const app = new Laravel('MyLaravelApp', {
-    web: {
-        domain: 'laravel-sst-demo.kdg.dev',
-        scaling: {
-            min: 1, 
-            max: 3,
-        }
-    },
+  web: {
+    domain: 'laravel-sst-demo.kdg.dev',
+    scaling: {
+      min: 1, 
+      max: 3,
+    }
+  },
 });
 ```
 
@@ -65,12 +77,12 @@ SST Laravel will automatically deploy and configure worker containers running yo
 
 ```js
 const app = new Laravel('MyLaravelApp', {
-    workers: [
-        {
-            name: 'scheduler',
-            scheduler: true,
-        },
-    ],
+  workers: [
+    {
+      name: 'scheduler',
+      scheduler: true,
+    },
+  ],
 });
 ```
 
@@ -78,12 +90,12 @@ const app = new Laravel('MyLaravelApp', {
 
 ```js
 const app = new Laravel('MyLaravelApp', {
-    workers: [
-        {
-            name: 'horizon',
-            horizon: true,
-        },
-    ],
+  workers: [
+    {
+      name: 'horizon',
+      horizon: true,
+    },
+  ],
 });
 ```
 
@@ -91,22 +103,22 @@ const app = new Laravel('MyLaravelApp', {
 
 ```js
 const app = new Laravel('MyLaravelApp', {
-    workers: [
-        {
-            name: 'worker',
-            tasks: {
-                'scheduler': {
-                    command: 'php artisan schedule:work',
-                },
-                'queue': {
-                    command: 'php artisan queue:work',
-                },
-                'pulse': {
-                    command: 'php artisan pulse:work',
-                },
-            },
+  workers: [
+    {
+      name: 'worker',
+      tasks: {
+        'scheduler': {
+          command: 'php artisan schedule:work',
         },
-    ],
+        'queue': {
+          command: 'php artisan queue:work',
+        },
+        'pulse': {
+          command: 'php artisan pulse:work',
+        },
+      },
+    },
+  ],
 });
 ```
 
@@ -152,7 +164,7 @@ const redis = new sst.aws.Redis("MyRedis", { vpc });
 const bucket = new sst.aws.Bucket("MyBucket");
 
 const app = new Laravel('MyLaravelApp', {
-    link: [database, redis, bucket],
+  link: [database, redis, bucket],
 });
 ```
 
@@ -164,27 +176,27 @@ If you need to customize the environment variable names for your resources, you
 
 ```js
 const app = new Laravel('MyLaravelApp', {
-    link: [
-        email, 
-        {
-            resource: database,
-            environment: (database: sst.aws.Postgres) => ({
-                CUSTOM_DB_HOST: database.host.apply(host => host.toString()),
-                CUSTOM_DB_NAME: database.database.apply(database => database.toString()),
-                CUSTOM_DB_USER: database.username.apply(username => username.toString()),
-                CUSTOM_DB_PASSWORD: database.password.apply(password => password.toString()),
-            })
-        },
-        {
-            resource: redis,
-            environment: (redis: sst.aws.Redis) => ({
-                QUEUE_CONNECTION: 'redis',
-                QUEUE_REDIS_HOST: redis.host.apply(host => host ? `tls://${host}` : ''),
-                QUEUE_REDIS_PORT: redis.port.apply(port => port.toString()),
-            })
-        }
-    ],
-    web: {}
+  link: [
+    email, 
+    {
+      resource: database,
+      environment: (database: sst.aws.Postgres) => ({
+        CUSTOM_DB_HOST: database.host.apply(host => host.toString()),
+        CUSTOM_DB_NAME: database.database.apply(database => database.toString()),
+        CUSTOM_DB_USER: database.username.apply(username => username.toString()),
+        CUSTOM_DB_PASSWORD: database.password.apply(password => password.toString()),
+      })
+    },
+    {
+      resource: redis,
+      environment: (redis: sst.aws.Redis) => ({
+        QUEUE_CONNECTION: 'redis',
+        QUEUE_REDIS_HOST: redis.host.apply(host => host ? `tls://${host}` : ''),
+        QUEUE_REDIS_PORT: redis.port.apply(port => port.toString()),
+      })
+    }
+  ],
+  web: {}
 });
 ```
 
@@ -212,13 +224,13 @@ You can configure the PHP version, custom environment variables and a custom dep
 
 ```js
 const app = new Laravel('MyLaravelApp', {
-    config: {
-        php: 8.4,
-        opcache: true,
-        deployment: {
-            script: './infra/deploy.sh'
-        },
+  config: {
+    php: 8.4,
+    opcache: true,
+    deployment: {
+      script: './infra/deploy.sh'
     },
+  },
 });
 ```
 
@@ -241,9 +253,29 @@ echo "🚀 Running Laravel Migrations..."
 php artisan migrate --force
 ```
 
-## Debugging Containers
+## Accessing Containers
+
+Using the `sst-laravel` CLI tool, you can easily connect to your running ECS containers for debugging and troubleshooting.
+
+```bash
+npx sst-laravel ssh --stage production
+```
+
+This will list all running tasks in your cluster and let you choose which one to connect to.
+
+**Connect to a specific service:**
+
+```bash
+npx sst-laravel ssh web --stage production
+npx sst-laravel ssh worker --stage production
+```
+
+If you are naming your workers differently, you can specify the worker name:
 
-TODO: Add documentation on how to SSH to debug containers.
+```bash
+npx sst-laravel ssh {worker-name} --stage production
+npx sst-laravel ssh worker --stage production
+```
 
 ***
 

package/bin/cli.ts

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { ECSClient, ListTasksCommand, DescribeTasksCommand, ListClustersCommand, Task } from '@aws-sdk/client-ecs';
+import { select } from '@inquirer/prompts';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface SshOptions {
+  stage?: string;
+  cluster?: string;
+  region: string;
+}
+
+function findSstConfig(): string | null {
+  const cwd = process.cwd();
+  const possiblePaths = [
+    path.join(cwd, 'sst.config.ts'),
+    path.join(cwd, 'sst.config.js'),
+  ];
+
+  for (const configPath of possiblePaths) {
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+
+  return null;
+}
+
+function extractLaravelComponents(configPath: string): string[] {
+  const content = fs.readFileSync(configPath, 'utf-8');
+  const regex = /new\s+Laravel\s*\(\s*['"`]([^'"`]+)['"`]/g;
+  const components: string[] = [];
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(content)) !== null) {
+    components.push(match[1]);
+  }
+
+  return components;
+}
+
+const program = new Command();
+
+program
+  .name('sst-laravel')
+  .description('CLI tools for SST Laravel deployments')
+  .version('0.0.4');
+
+program
+  .command('init')
+  .description('Initialize a new sst.config.ts file with Laravel boilerplate')
+  .action(() => {
+    try {
+      const cwd = process.cwd();
+      const targetPath = path.join(cwd, 'sst.config.ts');
+
+      if (fs.existsSync(targetPath)) {
+        console.error('Warning: sst.config.ts already exists in the current directory.');
+        console.error('Will not overwrite existing file.');
+        process.exit(1);
+      }
+
+      const templatePath = path.join(__dirname, '..', 'templates', 'sst.config.ts.template');
+      
+      if (!fs.existsSync(templatePath)) {
+        console.error('Error: Template file not found.');
+        process.exit(1);
+      }
+
+      let templateContent = fs.readFileSync(templatePath, 'utf-8');
+
+      const envPath = path.join(cwd, '.env');
+      let appName = 'my-laravel-app';
+
+      if (fs.existsSync(envPath)) {
+        const envContent = fs.readFileSync(envPath, 'utf-8');
+        const appNameMatch = envContent.match(/^APP_NAME=(.+)$/m);
+        
+        if (appNameMatch && appNameMatch[1]) {
+          const rawAppName = appNameMatch[1].trim().replace(/^["']|["']$/g, '');
+          appName = rawAppName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+          console.log(`Using APP_NAME from .env: ${rawAppName}`);
+        }
+      }
+
+      templateContent = templateContent.replace('my-laravel-app', appName);
+
+      fs.writeFileSync(targetPath, templateContent, 'utf-8');
+
+      console.log('Successfully created sst.config.ts');
+      console.log('You can now customize the configuration for your Laravel application.');
+    } catch (error) {
+      console.error('Error:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('ssh')
+  .description('SSH into a running ECS task')
+  .argument('[service]', 'Service to connect to (web, worker, or worker name) - optional')
+  .option('-s, --stage <stage>', 'SST stage name (required)')
+  .option('-c, --cluster <cluster>', 'ECS cluster name (optional, auto-detected from SST config)')
+  .option('-r, --region <region>', 'AWS region', process.env.AWS_REGION || 'us-east-1')
+  .action(async (service: string | undefined, options: SshOptions) => {
+    try {
+      const region = options.region;
+      const stage = options.stage;
+
+      if (!stage) {
+        console.error('Error: Stage is required. Use --stage flag to specify the SST stage.');
+        process.exit(1);
+      }
+
+      const ecsClient = new ECSClient({ region });
+
+      let clusterArn = options.cluster;
+
+      if (!clusterArn) {
+        const configPath = findSstConfig();
+        if (!configPath) {
+          console.error('Error: Could not find sst.config.ts or sst.config.js in current directory.');
+          console.error('Please use --cluster flag to specify cluster ARN manually.');
+          process.exit(1);
+        }
+
+        const components = extractLaravelComponents(configPath);
+
+        if (components.length === 0) {
+          console.error('Error: No Laravel components found in SST config.');
+          console.error('Please use --cluster flag to specify cluster ARN manually.');
+          process.exit(1);
+        }
+
+        if (components.length > 1) {
+          console.error('Error: Multiple Laravel components found in SST config.');
+          console.error(`Found: ${components.join(', ')}`);
+          console.error('Please use --cluster flag to specify which cluster to connect to.');
+          process.exit(1);
+        }
+
+        const componentName = components[0].replace(/-/g, '');
+        const clusterPattern = `${stage}-${componentName}Cluster`;
+
+        console.log(`Looking for cluster matching pattern: *${clusterPattern}`);
+
+        const listClustersCommand = new ListClustersCommand({});
+        const listClustersResponse = await ecsClient.send(listClustersCommand);
+
+        if (!listClustersResponse.clusterArns || listClustersResponse.clusterArns.length === 0) {
+          console.error('Error: No ECS clusters found in this region.');
+          process.exit(1);
+        }
+
+        const matchingCluster = listClustersResponse.clusterArns.find(arn => {
+          const clusterName = arn.split('/').pop();
+          return clusterName?.includes(stage) && clusterName?.includes(componentName);
+        });
+
+        if (!matchingCluster) {
+          console.error(`Error: No cluster found matching stage "${stage}" and component "${components[0]}".`);
+          console.error('Available clusters:');
+          listClustersResponse.clusterArns.forEach(arn => {
+            console.error(`  - ${arn.split('/').pop()}`);
+          });
+          process.exit(1);
+        }
+
+        clusterArn = matchingCluster;
+        console.log(`Auto-detected cluster: ${clusterArn.split('/').pop()}`);
+      }
+
+      console.log(`Cluster ARN: ${clusterArn}`);
+
+      const listTasksCommand = new ListTasksCommand({
+        cluster: clusterArn,
+        desiredStatus: 'RUNNING'
+      });
+
+      const listTasksResponse = await ecsClient.send(listTasksCommand);
+
+      if (!listTasksResponse.taskArns || listTasksResponse.taskArns.length === 0) {
+        console.error('No running tasks found in cluster');
+        process.exit(1);
+      }
+
+      const describeTasksCommand = new DescribeTasksCommand({
+        cluster: clusterArn,
+        tasks: listTasksResponse.taskArns
+      });
+
+      const describeTasksResponse = await ecsClient.send(describeTasksCommand);
+
+      let matchingTask: Task | undefined;
+
+      if (service) {
+        let servicePrefix: string;
+        if (service === 'web') {
+          servicePrefix = '-web';
+        } else if (service === 'worker') {
+          servicePrefix = '-worker';
+        } else {
+          servicePrefix = `-${service}`;
+        }
+
+        matchingTask = describeTasksResponse.tasks?.find(task => {
+          const containerName = task.containers?.[0]?.name || '';
+          return containerName.toLowerCase().includes(servicePrefix.toLowerCase());
+        });
+      }
+
+      if (!matchingTask) {
+        if (service) {
+          console.log(`\nNo running task found matching service: ${service}`);
+        }
+        console.log('Available tasks in cluster:\n');
+
+        const choices = describeTasksResponse.tasks?.map(task => {
+          const taskId = task.taskArn?.split('/').pop() || '';
+          const containerName = task.containers?.[0]?.name || 'unknown';
+          const status = task.lastStatus || 'unknown';
+          
+          return {
+            name: `${containerName} (${taskId.substring(0, 8)}...) - ${status}`,
+            value: task,
+            description: `Task: ${taskId}`
+          };
+        }) || [];
+
+        if (choices.length === 0) {
+          console.error('No tasks available to select from.');
+          process.exit(1);
+        }
+
+        matchingTask = await select({
+          message: 'Select a task to connect to:',
+          choices
+        });
+      }
+
+      const taskId = matchingTask.taskArn?.split('/').pop();
+
+      console.log(`Connecting to task: ${taskId}`);
+
+      const awsCommand = spawn('aws', [
+        'ecs',
+        'execute-command',
+        '--cluster', clusterArn,
+        '--task', taskId!,
+        '--container', matchingTask.containers?.[0]?.name || '',
+        '--interactive',
+        '--command', '/bin/bash'
+      ], {
+        stdio: 'inherit',
+        env: { ...process.env, AWS_REGION: region }
+      });
+
+      awsCommand.on('exit', (code) => {
+        process.exit(code || 0);
+      });
+
+    } catch (error) {
+      console.error('Error:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/laravel-sst.ts

@@ -3,16 +3,12 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import { Component } from "../../../.sst/platform/src/components/component.js";
-import { FunctionArgs } from "../../../.sst/platform/src/components/aws/function.js";
+import { FunctionArgs } from "../../../.sst/platform/src/components/aws/function.js";;
 import { ComponentResourceOptions, Output, all, output } from "../../../.sst/platform/node_modules/@pulumi/pulumi/index.js";
 import { Input } from "../../../.sst/platform/src/components/input.js";
-import { Link } from "../../../.sst/platform/src/components/link.js";
 import { ClusterArgs } from "../../../.sst/platform/src/components/aws/cluster.js";
 import { ServiceArgs } from "../../../.sst/platform/src/components/aws/service.js";
 import { Dns } from "../../../.sst/platform/src/components/dns.js";
-import { Postgres } from "../../../.sst/platform/src/components/aws/postgres.js";
-import { Redis } from "../../../.sst/platform/src/components/aws/redis.js";
-import { Email } from "../../../.sst/platform/src/components/aws/email.js";
 import { applyLinkedResourcesEnv, EnvCallback, EnvCallbacks } from "./src/laravel-env.js";
 
 // duplicate from cluster.ts
@@ -164,6 +160,8 @@ export interface LaravelArgs extends ClusterArgs {
 }
 
 export class Laravel extends Component {
+  private readonly services: Record<string, sst.aws.Service>;
+
   constructor(
     name: string,
     args: LaravelArgs,
@@ -171,13 +169,15 @@ export class Laravel extends Component {
   ) {
     super(__pulumiType, name, args, opts);
 
+    this.services = {};
+
     args.config = args.config ?? {};
     const sitePath = args.path ?? '.';
     const absSitePath = path.resolve(sitePath.toString());
-    // TODO: We need to update sst-laravel to whatever the real package name will be.
-    const nodeModulePath = path.resolve(__dirname, '../../node_modules/sst-laravel');
+    const nodeModulePath = path.resolve(__dirname, '../../node_modules/@kirschbaum-development/sst-laravel');
 
-    // Determine the path where our plugin will save build files. SST sets __dirname to the .sst/platform directory.
+    // Determine the path where our plugin will save build files.
+    // SST sets __dirname to the .sst/platform directory.
     const pluginBuildPath = path.resolve(__dirname, '../laravel');
 
     prepareEnvironmentFile();
@@ -187,18 +187,10 @@ export class Laravel extends Component {
       vpc: args.vpc
     });
 
-    if (args.web) {
-      addWebService();
-    }
-
-    if (args.workers) {
-      addWorkerServices();
-    }
-
-    function addWebService() {
+    const addWebService = () => {
       const envVariables = getEnvironmentVariables();
 
-      const webService = new sst.aws.Service(`${name}-Web`, {
+      this.services['web'] = new sst.aws.Service(`${name}-Web`, {
         cluster,
         link: getLinks(),
         permissions: args.permissions,
@@ -257,7 +249,7 @@ export class Laravel extends Component {
       });
     }
 
-    function createWorkerService(workerConfig: LaravelWorkerConfig, serviceName: string, workerBuildPath: string) {
+    const createWorkerService = (workerConfig: LaravelWorkerConfig, serviceName: string, workerBuildPath: string) => {
       createWorkerTasks(workerConfig, workerBuildPath);
 
       const imgBuildArgs = {
@@ -265,7 +257,7 @@ export class Laravel extends Component {
         'CUSTOM_CONF_PATH': workerBuildPath.replace(absSitePath, ''),
       };
 
-      return new sst.aws.Service(serviceName, {
+      this.services[serviceName] = new sst.aws.Service(serviceName, {
         cluster,
         link: getLinks(),
         permissions: args.permissions,
@@ -304,6 +296,14 @@ export class Laravel extends Component {
       });
     }
 
+    if (args.web) {
+      addWebService();
+    }
+
+    if (args.workers) {
+      addWorkerServices();
+    }
+
     function getDefaultPublicPorts(): Ports {
       let ports;
       const forwardPort: Port = "8080/http";
@@ -324,7 +324,7 @@ export class Laravel extends Component {
       return ports;
     }
 
-    // TODO: We have to test if it works when an image is provided in sst.config.js
+    // TODO: We have to test if it works when a custom image is provided in sst.config.js
     function getImage(imgFromConfig: LaravelWebArgs["image"] | null | undefined, imgType: ImageType, extraArgs: object = {}) {
       const img = imgFromConfig
         ? imgFromConfig
@@ -380,6 +380,7 @@ export class Laravel extends Component {
           'PHP_OPCACHE_ENABLE': args.config?.opcache? '1' : '0',
           'AUTORUN_LARAVEL_MIGRATION': imageType === ImageType.Web ? 'true' : 'false',
           'CONTAINER_TYPE': imageType,
+          'ENV_FILENAME': args.config?.environment?.file ?? '.env',
           stage: "deploy",
           platform: "linux/amd64",
           ...extraArgs
@@ -493,6 +494,16 @@ export class Laravel extends Component {
       fs.chmodSync(dst, 0o755);
     }
   };
+
+  /**
+   * The URL of the service.
+   *
+   * If `public.domain` is set, this is the URL with the custom domain.
+   * Otherwise, it's the auto-generated load balancer URL.
+   */
+  public get url() {
+    return this.services['web'].url;
+  }
 }
 
 const __pulumiType = "sst:aws:Laravel";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirschbaum-development/sst-laravel",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "An unofficial extension of SST to deploy containerized Laravel applications to AWS Fargate.",
   "main": "laravel-sst.ts",
   "scripts": {
@@ -25,5 +25,16 @@
     "url": "https://github.com/kirschbaum-development/sst-laravel/issues"
   },
   "homepage": "https://github.com/kirschbaum-development/sst-laravel#readme",
-  "dependencies": {}
+  "bin": {
+    "sst-laravel": "./bin/cli.ts"
+  },
+  "dependencies": {
+    "@aws-sdk/client-ecs": "^3.0.0",
+    "@inquirer/prompts": "^7.0.0",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
 }

package/sst-env.d.ts

@@ -3,7 +3,7 @@
 /* eslint-disable */
 /* deno-fmt-ignore-file */
 
-/// <reference path="../../sst-env.d.ts" />
+/// <reference path="../../../sst-env.d.ts" />
 
 import "sst"
 export {}

package/templates/sst.config.ts.template

@@ -0,0 +1,35 @@
+/// <reference path="./.sst/platform/config.d.ts" />
+
+export default $config({
+  app(input) {
+    return {
+      name: "my-laravel-app",
+      removal: input?.stage === "production" ? "retain" : "remove",
+      protect: ["production"].includes(input?.stage),
+      home: "aws",
+    };
+  },
+  async run() {
+    const { Laravel } = await import("@kirschbaum-development/sst-laravel");
+    const vpc = new sst.aws.Vpc("MyVpc");
+
+    const app = new Laravel("MyLaravelApp", {
+      vpc,
+
+      web: {
+        domain: $app.stage === "production"
+          ? "example.com"
+          : `${$app.stage}.example.com`,
+      },
+
+      workers: [{
+        horizon: true,
+        scheduler: true,
+      }]
+    });
+
+    return {
+      url: app.url,
+    };
+  },
+});