@kirschbaum-development/sst-laravel 0.0.1

package/.dockerignore

@@ -0,0 +1,5 @@
+# sst
+.sst/**
+!.sst/laravel
+node_modules
+.env

package/.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[docker-compose.yml]
+indent_size = 4

package/Dockerfile.web

@@ -0,0 +1,57 @@
+ARG PHP_VERSION=8.3
+FROM serversideup/php:${PHP_VERSION}-unit as base
+
+USER root
+
+LABEL authors="Kirschbaum"
+LABEL maintainer="Kirschbaum"
+
+ENV AUTORUN_ENABLED=false
+# ENV AUTORUN_LARAVEL_MIGRATION=true
+
+RUN apt-get update \
+    && apt-get upgrade -y
+
+RUN install-php-extensions gd intl
+
+# ENV NVM_VERSION v0.39.7
+# ENV NODE_VERSION 21.6.0
+# ENV NVM_DIR /usr/local/nvm
+# RUN mkdir "$NVM_DIR"
+
+# RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
+
+# ENV NODE_PATH $NVM_DIR/v$NODE_VERSION/lib/node_modules
+# ENV PATH $NVM_DIR/versions/node/v$NODE_VERSION/bin:$PATH
+
+# RUN echo "source $NVM_DIR/nvm.sh \
+#     && nvm install $NODE_VERSION \
+#     && nvm alias default $NODE_VERSION \
+#     && nvm use default \
+#     && nvm install-latest-npm" | bash
+
+FROM base as development
+
+# Save the build arguments as a variable
+ARG USER_ID
+ARG GROUP_ID
+
+# Drop back to our unprivileged user
+USER www-data
+
+FROM base as deploy
+
+ARG ENV_FILENAME
+ENV CONTAINER_TYPE=web
+
+# Enable OPCache
+ENV PHP_OPCACHE_ENABLE=1
+
+COPY --chown=www-data:www-data . /var/www/html
+COPY --chown=www-data:www-data $ENV_FILENAME /var/www/html/.env
+
+# Copy deploy script generated into .sst/laravel by the build step
+COPY --chmod=755 .sst/laravel/deploy/60-deploy.sh /etc/entrypoint.d/60-deploy.sh
+
+# Drop back to our unprivileged user
+USER www-data

package/Dockerfile.worker

@@ -0,0 +1,85 @@
+ARG PHP_VERSION=8.3
+FROM serversideup/php:${PHP_VERSION}-cli AS phpcli
+
+##########
+# S6 Build
+##########
+FROM phpcli AS s6-build
+
+ARG CONF_PATH
+
+USER root
+
+ARG S6_DIR='/opt/s6/'
+ARG S6_SRC_URL="https://github.com/just-containers/s6-overlay/releases/download"
+
+# copy our scripts
+COPY --chmod=755 $CONF_PATH /
+
+RUN s6-install.sh
+
+############
+# BASE IMAGE
+############
+FROM phpcli AS base
+
+ARG CONF_PATH
+ARG CUSTOM_CONF_PATH
+
+USER root
+
+LABEL authors="Kirschbaum"
+LABEL maintainer="Kirschbaum"
+
+ENV AUTORUN_ENABLED=false
+ENV AUTORUN_LARAVEL_MIGRATION=false
+
+# copy our scripts
+RUN test -n "$CUSTOM_CONF_PATH"
+
+COPY --chmod=755 $CONF_PATH /
+COPY --chmod=755 $CUSTOM_CONF_PATH /
+
+# copy s6-overlay from s6-build
+COPY --from=s6-build /opt/s6/ /
+
+RUN apt-get update \
+&& apt-get upgrade -y
+
+# RUN install-php-extensions gd intl
+
+###################
+# Development image
+###################
+FROM base AS development
+
+# Save the build arguments as a variable
+ARG USER_ID
+ARG GROUP_ID
+
+# Drop back to our unprivileged user
+USER www-data
+
+##############
+# Deploy image
+##############
+FROM base AS deploy
+
+ENV CONTAINER_TYPE=cli
+
+COPY --chown=www-data:www-data . /var/www/html
+
+# Fix S6 Overlay issues with Big Cloud PaaS (https://github.com/serversideup/docker-php/pull/376#issuecomment-2179262427)
+RUN chown -R www-data:www-data /run
+
+# Copy deploy script generated into .sst/laravel by the build step
+COPY --chmod=755 .sst/laravel/deploy/60-deploy.sh /etc/entrypoint.d/60-deploy.sh
+
+USER www-data
+
+ENTRYPOINT ["entrypoint.sh"]
+
+# Set stop signal to SIGQUIT for a graceful shutdown instead of S6's preferred SIGTERM (https://github.com/just-containers/s6-overlay/issues/586)
+STOPSIGNAL SIGQUIT
+
+CMD ["/init"]

package/README.md

@@ -0,0 +1,268 @@
+# 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.
+
+**TODO: Add explanation about what exactly SST is.**
+
+## What it deploys
+
+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.
+
+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)
+
+## Pre-requisites
+
+1. NodeJS.
+1. Have [SST](https://sst.dev) installed and configured.
+
+## Installation instructions
+
+Pull in the package using npm:
+
+```bash
+npm install @kirschbaum/sst-laravel --save
+```
+
+## Usage
+
+To start using, you only need to import the component in your `sst.config.ts` file:
+
+```ts
+import { Laravel } from "@kirschbaum-development/sst-laravel";
+```
+
+And now you can start using the `Laravel` SST component. All the configuration options are Typescript files with documentation, so
+
+// TODO: Add full list of options (auto generate?)
+To check the full list of options. check [here](). 
+
+### HTTP
+
+Setting up your app to receive HTTP requests, on the `laravel-sst-demo.kdg.dev` domain (with SSL), with auto-scaling with a max of 3 servers.
+
+```js
+const app = new Laravel('MyLaravelApp', {
+    web: {
+        domain: 'laravel-sst-demo.kdg.dev',
+        scaling: {
+            min: 1, 
+            max: 3,
+        }
+    },
+});
+```
+
+### Workers
+
+Beyond HTTP requests, you can set up one or more `workers` for your Laravel application. Workers are meant to run background commands like Laravel Horizon, the Laravel Scheduler or any background command you may need to run.
+
+SST Laravel will automatically deploy and configure worker containers running your configured commands. See some examples below.
+
+
+**Running the Laravel scheduler**
+
+```js
+const app = new Laravel('MyLaravelApp', {
+    workers: [
+        {
+            name: 'scheduler',
+            scheduler: true,
+        },
+    ],
+});
+```
+
+**Running the Laravel Horizon**
+
+```js
+const app = new Laravel('MyLaravelApp', {
+    workers: [
+        {
+            name: 'horizon',
+            horizon: true,
+        },
+    ],
+});
+```
+
+**Running custom commands**
+
+```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',
+                },
+            },
+        },
+    ],
+});
+```
+
+## Environment Variables
+
+There are multiple ways to configure environment variables. If you want SST Laravel to copy an environment file, you can configure the `config.environment.file` entry.
+
+The below configuration would copy a file named `.env.$STAGE` into the deployment containers as your `.env` file.
+
+```js
+const app = new Laravel('MyLaravelApp', {
+  // ...
+  config: {
+    environment: {
+      file: `.env.${$app.stage}`,
+    }
+  }
+});
+```
+
+You can also configure it to use simply `.env`.
+
+```js
+const app = new Laravel('MyLaravelApp', {
+  // ...
+  config: {
+    environment: {
+      file: `.env`,
+    }
+  }
+});
+```
+
+### Resources
+
+In SST, you can [link resources](https://sst.dev/docs/linking). If you link resources to your Laravel component, SST Laravel will automatically inject and configure environment variables using sensible defaults for all the linked resources.
+
+In the example configuration below, SST Laravel will automatically inject environment variables for the database, cache and filesystem.
+
+```js
+const database = new sst.aws.Postgres('MyDatabase', { vpc });
+const redis = new sst.aws.Redis("MyRedis", { vpc });
+const bucket = new sst.aws.Bucket("MyBucket");
+
+const app = new Laravel('MyLaravelApp', {
+    link: [database, redis, bucket],
+});
+```
+
+The `DB_*`, `REDIS_*` and `AWS_*` environment variables will be automatically injected into your Laravel application. 
+
+#### Custom Environment Key Names
+
+If you need to customize the environment variable names for your resources, you can provide an object with the resource and a callback function in the `link` array:
+
+```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: {}
+});
+```
+
+The callback function receives the resource as a parameter and should return an object with the custom environment variables. The default environment variables are still set, so you can either override them or add new ones.
+
+#### Disabling the auto-inject of environment variables
+
+If you don't want SST Laravel to auto-inject environment variables, you can disable with the following option:
+
+```js
+config: {
+  environment: {
+    autoInject: false,
+  }
+}
+```
+
+#### IAM Roles and Permissions
+
+The IAM permissions for the linked resources are also automatically added to the ECS IAM Execution Role, meaning your application has access to all the linked resources.
+
+### Other Configurations
+
+You can configure the PHP version, custom environment variables and a custom deployment script.
+
+```js
+const app = new Laravel('MyLaravelApp', {
+    config: {
+        php: 8.4,
+        opcache: true,
+        deployment: {
+            script: './infra/deploy.sh'
+        },
+    },
+});
+```
+
+Custom deployment script example:
+
+```bash
+#!/bin/sh
+
+# Exit on error
+set -e
+
+echo "🚀 Running Deployment Script..."
+
+cd "$APP_BASE_DIR"
+
+echo "🚀 Running PHP Artisan Optimize..."
+php artisan optimize
+
+echo "🚀 Running Laravel Migrations..."
+php artisan migrate --force
+```
+
+## Debugging Containers
+
+TODO: Add documentation on how to SSH to debug containers.
+
+***
+
+### Roadmap
+
+* Custom CLI to facilitate accessing resources;
+* Add support for Inertia SSR;
+* Add support for Octane;
+* Add support for Laravel Reverb;
+* Dev mode;
+
+## Security
+
+If you discover any security related issues, please email security@kirschbaumdevelopment.com instead of using the issue tracker.
+
+## Sponsorship
+
+Development of this package is sponsored by Kirschbaum Development Group, a developer driven company focused on problem solving, team building, and community. Learn more [about us](https://kirschbaumdevelopment.com) or [join us](https://careers.kirschbaumdevelopment.com)!
+
+## License
+
+The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

package/conf/entrypoint.d/99-example.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+echo "KIRSCHBAUM DEVELOPMENT GROUP"

package/conf/etc/s6-overlay/s6-rc.d/laravel-horizon/finish

@@ -0,0 +1,4 @@
+#!/command/execlineb -S0
+php artisan horizon:terminate
+echo "0" > /run/s6-linux-init-container-results/exitcode
+/run/s6/basedir/bin/halt

package/conf/etc/s6-overlay/s6-rc.d/laravel-horizon/laravel-horizon

@@ -0,0 +1,16 @@
+#!/command/with-contenv bash
+
+# Exit on error
+set -e
+
+# Check to see if an Artisan file exists and assume it means Laravel is configured.
+if [ -f "$APP_BASE_DIR/artisan" ]; then
+        echo "🚀 Starting Laravel Horizon..."
+
+        cd "$APP_BASE_DIR"
+        php "$APP_BASE_DIR/artisan" horizon
+else
+    echo "👉 Skipping Laravel Horizon because we could not detect a Laravel install or it was specifically disabled..."
+
+    tail -f /dev/null
+fi

package/conf/etc/s6-overlay/s6-rc.d/laravel-horizon/run

@@ -0,0 +1,2 @@
+#!/command/execlineb -P
+/etc/s6-overlay/s6-rc.d/laravel-horizon/laravel-horizon

package/conf/etc/s6-overlay/s6-rc.d/laravel-horizon/type

@@ -0,0 +1 @@
+longrun

package/conf/etc/s6-overlay/s6-rc.d/laravel-scheduler/finish

@@ -0,0 +1,4 @@
+#!/command/execlineb -S0
+php artisan schedule:interrupt
+echo "0" > /run/s6-linux-init-container-results/exitcode
+/run/s6/basedir/bin/halt

package/conf/etc/s6-overlay/s6-rc.d/laravel-scheduler/laravel-scheduler

@@ -0,0 +1,16 @@
+#!/command/with-contenv bash
+
+# Exit on error
+set -e
+
+# Check to see if an Artisan file exists and assume it means Laravel is configured.
+if [ -f "$APP_BASE_DIR/artisan" ]; then
+        echo "🚀 Starting Laravel Scheduler..."
+
+        cd "$APP_BASE_DIR"
+        php "$APP_BASE_DIR/artisan" schedule:work
+else
+    echo "👉 Skipping Laravel Scheduler because we could not detect a Laravel install or it was specifically disabled..."
+
+    tail -f /dev/null
+fi

package/conf/etc/s6-overlay/s6-rc.d/laravel-scheduler/run

@@ -0,0 +1,2 @@
+#!/command/execlineb -P
+/etc/s6-overlay/s6-rc.d/laravel-scheduler/laravel-scheduler

package/conf/etc/s6-overlay/s6-rc.d/laravel-scheduler/type

@@ -0,0 +1 @@
+longrun

package/conf/usr/local/bin/entrypoint.sh

@@ -0,0 +1,76 @@
+#!/bin/sh
+set -e
+
+##############
+# BASED ON https://github.com/serversideup/docker-php/blob/main/src/common/usr/local/bin/docker-php-serversideup-entrypoint
+##############
+
+# Initialize variables
+DEFAULT_COMMAND="false"
+S6_INITIALIZED="false"
+
+echo "🔥🔥🔥 STARTING ENTRYPOINT SCRIPT 🔥🔥🔥"
+
+# Enable debug mode if LOG_OUTPUT_LEVEL is set to "debug"
+if [ "$LOG_OUTPUT_LEVEL" = "debug" ]; then
+    echo "🔥🔥🔥 DEBUG MODE has been set. Get ready for a ton of debug log output..."
+    set -x
+fi
+
+# Check if the default command is being used
+case "$1" in
+    "/init")
+        DEFAULT_COMMAND="true"
+        ;;
+    "unitd")
+        if [ "$2" = "--no-daemon" ]; then
+            DEFAULT_COMMAND="true"
+        fi
+        ;;
+esac
+
+# Check if S6 overlay is initialized
+if [ -d "/etc/s6-overlay" ] && [ "$DEFAULT_COMMAND" = "true" ]; then
+    S6_INITIALIZED="true"
+fi
+
+# Export variables
+export DEFAULT_COMMAND
+export S6_INITIALIZED
+
+###############################################
+# Usage: entrypoint.sh
+###############################################
+# This script is used to execute scripts from "/etc/entrypoint.d" and then
+# execute the CMD passed in from the Dockerfile.
+
+# Execute scripts from /etc/entrypoint.d/ in numeric order
+find /etc/entrypoint.d/ -type f -name '*.sh' | sort -V | while IFS= read -r f; do
+    if [ -e "$f" ]; then
+        if [ "$LOG_OUTPUT_LEVEL" = "debug" ]; then
+            echo "Executing $f"
+        fi
+        if ! . "$f"; then
+            echo "Error executing $f" >&2
+            exit 1
+        fi
+    else
+        echo "Warning: $f not found" >&2
+    fi
+done
+
+# first arg is `-f` or `--some-option`
+if [ "${1#-}" != "$1" ]; then
+	set -- php "$@"
+fi
+
+# Some scripts may need to change the CMD based on the log level. If this file is set, execute the contents of that file instead of the Dockerfile CMD.
+if [ -f /tmp/docker_cmd_override ]; then
+    docker_cmd_override=$(cat /tmp/docker_cmd_override)
+    rm /tmp/docker_cmd_override
+    set -- $docker_cmd_override # Perform word splitting by not quoting the commands
+    exec "$@"
+else
+    # Execute the CMD passed in from the Dockerfile
+    exec "$@"
+fi

package/conf/usr/local/bin/s6-install.sh

@@ -0,0 +1,33 @@
+#!/bin/sh
+set -oue
+
+######################
+# Usage: s6-install.sh
+######################
+
+# BASED ON https://github.com/serversideup/docker-php/blob/main/src/s6/usr/local/bin/docker-php-serversideup-s6-install
+# This script is used to install S6 Overlay. It is intended to be used during the build process only.
+# Be sure to set the S6_SRC_URL, S6_SRC_DEP, and S6_DIR  environment variables before running this script.
+
+S6_VERSION=v3.2.0.2
+mkdir -p $S6_DIR
+export SYS_ARCH=$(uname -m)
+case "$SYS_ARCH" in
+    aarch64 ) export S6_ARCH='aarch64' ;;
+    arm64   ) export S6_ARCH='aarch64' ;;
+    armhf   ) export S6_ARCH='armhf'   ;;
+    arm*    ) export S6_ARCH='arm'     ;;
+    i4*     ) export S6_ARCH='i486'    ;;
+    i6*     ) export S6_ARCH='i686'    ;;
+    s390*   ) export S6_ARCH='s390x'   ;;
+    *       ) export S6_ARCH='x86_64'  ;;
+esac
+
+untar() {
+    echo "⏬ Downloading $1"
+    curl -L $1 -o - | tar Jxp -C $S6_DIR
+}
+
+echo "⬇️ Downloading s6 overlay:${S6_ARCH}-${S6_VERSION} for ${SYS_ARCH}"
+untar ${S6_SRC_URL}/${S6_VERSION}/s6-overlay-noarch.tar.xz
+untar ${S6_SRC_URL}/${S6_VERSION}/s6-overlay-${S6_ARCH}.tar.xz

package/laravel-sst.ts

@@ -0,0 +1,500 @@
+/// <reference path="./../../.sst/platform/config.d.ts" />
+
+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 { 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
+type Port = `${number}/${"http" | "https" | "tcp" | "udp" | "tcp_udp" | "tls"}`;
+
+type Ports = {
+  listen: Port,
+  forward: Port
+}[];
+
+enum ImageType {
+  Web = 'web',
+  Worker = 'worker',
+  Cli = 'cli',
+}
+
+export interface LaravelWebArgs {
+  /**
+   * Domain for the web layer.
+   */
+  domain?: Input<
+    string
+    | {
+      name: Input<string>;
+      cert?: Input<string>;
+      dns?: Input<false | (Dns & {})>;
+    }
+  >;
+
+  loadBalancer?: ServiceArgs["loadBalancer"];
+  image?: ServiceArgs["image"];
+  scaling?: ServiceArgs["scaling"];
+}
+
+export interface LaravelWorkerConfig {
+  name?: Input<string>;
+  link?: ServiceArgs["link"];
+  scaling?: ServiceArgs["scaling"];
+
+  /**
+  * Running horizon?
+  */
+  horizon?: Input<boolean>;
+
+  /**
+   * Running scheduler?
+   */
+  scheduler?: Input<boolean>;
+
+  /**
+   * Multiple tasks can be run in the worker.
+   */
+  tasks?: Input<{
+    [key: string]: Input<{
+      command: Input<string>;
+      dependencies?: Input<string[]>;
+    }>
+  }>
+}
+
+export interface LaravelArgs extends ClusterArgs {
+  // dev?: false | DevArgs["dev"];
+  path?: Input<string>;
+  link?: Array<
+    | any
+    | {
+        resource: any;
+        environment?: EnvCallback;
+      }
+  >;
+
+  permissions?: Array<{
+    actions: string[];
+    resources: string[];
+  }>;
+
+  /**
+  * If enabled, a container will be created to handle HTTP traffic.
+  */
+  web?: LaravelWebArgs;
+
+  /**
+  * Multiple workers settings.
+  */
+  workers?: LaravelWorkerConfig[];
+
+  /**
+   * Config settings.
+   */
+  config?: {
+    php?: Input<Number>;
+
+    /**
+     * PHP Opcache should be enabled?
+     *
+     * @default `true`
+     */
+    opcache?: Input<boolean>;
+    environment?: {
+      /**
+       * Use this option if you want to import an .env file during build. By default, SST Laravel won't use your .env file since that might be the wrong file when deploying from your local machine.
+       *
+       * @example
+       * ```js
+       * # Use use a fila named .env.$stage as your .env file
+       * environment: {
+       *   file: `.env.${$app.stage}`,
+       * }
+       * OR
+       * environment: {
+       *   file: `.env`,
+       * }
+       * ```
+       */
+      file?: Input<string>,
+
+      /**
+       * Set this to false in case you don't want to auto inject environment variables from your linked resources.
+       *
+       * @default `true`
+       */
+      autoInject?: Input<boolean>,
+
+      /**
+       * Custom environment variables that will be automatically injected into your application.
+       *
+       * @example
+       * ```js
+       * environment: {
+       *   vars: {
+       *     SESSION_DRIVER: 'redis',
+       *     QUEUE_CONNECTION: 'redis',
+       *   }
+       * }
+       * ```
+       */
+      vars?: FunctionArgs["environment"],
+    };
+
+    /**
+     * Custom deployment configurations.
+     */
+    deployment?: {
+      migrate?: Input<boolean>;
+      optimize?: Input<boolean>;
+      script?: Input<string>;
+    };
+  }
+}
+
+export class Laravel extends Component {
+  constructor(
+    name: string,
+    args: LaravelArgs,
+    opts: ComponentResourceOptions = {},
+  ) {
+    super(__pulumiType, name, args, opts);
+
+    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');
+
+    // 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();
+    prepareDeploymentScript();
+
+    const cluster = new sst.aws.Cluster(`${name}-Cluster`, {
+      vpc: args.vpc
+    });
+
+    if (args.web) {
+      addWebService();
+    }
+
+    if (args.workers) {
+      addWorkerServices();
+    }
+
+    function addWebService() {
+      const envVariables = getEnvironmentVariables();
+
+      const webService = new sst.aws.Service(`${name}-Web`, {
+        cluster,
+        link: getLinks(),
+        permissions: args.permissions,
+
+        /**
+         * Image passed or use our default provided image.
+         */
+        image: getImage(args.web?.image, ImageType.Web),
+        environment: envVariables,
+        scaling: args.web?.scaling,
+
+        loadBalancer: args.web && args.web.loadBalancer ? args.web.loadBalancer : {
+          domain: args.web?.domain,
+          ports: getDefaultPublicPorts(),
+        },
+
+        dev: {
+          command: `php ${sitePath}/artisan serve`,
+        },
+      });
+    }
+
+    function createWorkerTasks(workerConfig: LaravelWorkerConfig, workerBuildPath: string) {
+      const s6RcDPath = path.resolve(workerBuildPath, 'etc/s6-overlay/s6-rc.d');
+      const s6UserContentsPath = path.resolve(s6RcDPath, 'user/contents.d');
+
+      fs.mkdirSync(s6UserContentsPath, { recursive: true });
+
+      const tasks: Record<string, { command: string; dependencies?: string[] }> = {
+        ...((workerConfig.tasks as any) ?? {}),
+      };
+
+      if (workerConfig.horizon) {
+        tasks['laravel-horizon'] = {
+          command: 'php artisan horizon',
+        };
+      }
+
+      if (workerConfig.scheduler) {
+        tasks['laravel-scheduler'] = {
+          command: 'php artisan schedule:work',
+        };
+      }
+
+      Object.entries(tasks).forEach(([taskName, config]) => {
+        const tasksDir = path.resolve(s6RcDPath, `${taskName}`);
+        fs.mkdirSync(tasksDir, { recursive: true });
+
+        const scriptSrcPath = path.join(tasksDir, 'script');
+
+        fs.writeFileSync(scriptSrcPath, `#!/command/with-contenv bash\ncd /var/www/html\n${config.command}`, { mode: 0o777 });
+        fs.writeFileSync(path.join(tasksDir, 'run'), `#!/command/execlineb -P\n/etc/s6-overlay/s6-rc.d/${taskName}/script`, { mode: 0o777 });
+        fs.writeFileSync(path.join(tasksDir, 'type'), 'longrun');
+        fs.writeFileSync(path.join(tasksDir, 'dependencies'), (config.dependencies || []).join('\n'));
+        fs.writeFileSync(path.join(s6UserContentsPath, taskName), '');
+      });
+    }
+
+    function createWorkerService(workerConfig: LaravelWorkerConfig, serviceName: string, workerBuildPath: string) {
+      createWorkerTasks(workerConfig, workerBuildPath);
+
+      const imgBuildArgs = {
+        'CONF_PATH': path.resolve(nodeModulePath, 'conf').replace(absSitePath, ''),
+        'CUSTOM_CONF_PATH': workerBuildPath.replace(absSitePath, ''),
+      };
+
+      return new sst.aws.Service(serviceName, {
+        cluster,
+        link: getLinks(),
+        permissions: args.permissions,
+
+        image: getImage(args.web?.image, ImageType.Worker, imgBuildArgs),
+        scaling: workerConfig.scaling,
+        environment: getEnvironmentVariables(),
+
+        dev: {
+          command: `php ${sitePath}/artisan horizon`,
+        },
+
+        transform: {
+          taskDefinition: (args) => {
+            args.containerDefinitions = (args.containerDefinitions as $util.Output<string>).apply(a => {
+              return JSON.stringify([{
+                ...JSON.parse(a)[0],
+                linuxParameters: {
+                  initProcessEnabled: false,
+                }
+              }]);
+            })
+          }
+        }
+      }, {
+        dependsOn: [],
+      });
+    }
+
+    function addWorkerServices() {
+      args.workers?.forEach((workerConfig, index) => {
+        const workerName = workerConfig.name || `worker-${index + 1}`;
+        const absWorkerBuildPath = path.resolve(pluginBuildPath, `worker-${workerName}`);
+
+        createWorkerService(workerConfig, `${name}-${workerName}`, absWorkerBuildPath);
+      });
+    }
+
+    function getDefaultPublicPorts(): Ports {
+      let ports;
+      const forwardPort: Port = "8080/http";
+      const portHttp: Port = "80/http";
+      const portHttps: Port = "443/https";
+
+      if (args.web?.domain) {
+        ports = [
+          { listen: portHttp, forward: forwardPort },
+          { listen: portHttps, forward: forwardPort },
+        ];
+      } else {
+        ports = [
+          { listen: portHttp, forward: forwardPort },
+        ];
+      }
+
+      return ports;
+    }
+
+    // TODO: We have to test if it works when an image is provided in sst.config.js
+    function getImage(imgFromConfig: LaravelWebArgs["image"] | null | undefined, imgType: ImageType, extraArgs: object = {}) {
+      const img = imgFromConfig
+        ? imgFromConfig
+        : getDefaultImage(imgType, extraArgs);
+
+      const context = typeof img === 'string'
+        ? sitePath.toString()
+        : (img as { context: string }).context.toString();
+
+      const dockerfile = typeof img === 'string'
+        ? 'Dockerfile'
+        : (img as { dockerfile: string }).dockerfile;
+
+      // add .sst/laravel to .dockerignore if not exist
+      const dockerIgnore = (() => {
+        let filePath = path.join(context, `${dockerfile}.dockerignore`);
+        if (fs.existsSync(filePath)) return filePath;
+
+        filePath = path.join(context, ".dockerignore");
+        if (fs.existsSync(filePath)) return filePath;
+      })();
+
+      const content = dockerIgnore ? fs.readFileSync(dockerIgnore).toString() : "";
+
+      const lines = content.split("\n");
+
+      // SST adds it later, so we need to add it here to ensure .sst/laravel is after it and is not ignored
+      if (dockerIgnore) {
+        if (!lines.find((line) => line === ".sst")) {
+          fs.writeFileSync(
+            dockerIgnore,
+            [...lines, "", "# sst", "!.sst/laravel"].join("\n"),
+          );
+        }
+
+        if (!lines.find((line) => line === "!.sst/laravel")) {
+          fs.writeFileSync(
+            dockerIgnore,
+            [...lines, "", "# sst-laravel", "!.sst/laravel"].join("\n"),
+          );
+        }
+      }
+
+      return img;
+    }
+
+    function getDefaultImage(imageType: ImageType, extraArgs: object = {}) {
+      return {
+        context: sitePath,
+        dockerfile: path.resolve(nodeModulePath, `Dockerfile.${imageType}`).replace(absSitePath, '.'),
+        args: {
+          'PHP_VERSION': getPhpVersion().toString(),
+          'PHP_OPCACHE_ENABLE': args.config?.opcache? '1' : '0',
+          'AUTORUN_LARAVEL_MIGRATION': imageType === ImageType.Web ? 'true' : 'false',
+          'CONTAINER_TYPE': imageType,
+          stage: "deploy",
+          platform: "linux/amd64",
+          ...extraArgs
+        },
+      };
+    };
+
+    function getPhpVersion() {
+      return args.config?.php ?? 8.4;
+    }
+
+    function getEnvironmentVariables() {
+      const env = args.config?.environment?.vars || {};
+
+      if (args.web?.domain) {
+        if (typeof args.web.domain === 'string') {
+          (env as any)['APP_URL'] = args.web.domain;
+        }
+      }
+
+      return env;
+    }
+
+    function applyLinkedResourcesToEnvironment() {
+      const links = (args.link || []);
+      const resources: any[] = [];
+      const customEnv: Record<string, string | Output<string>> = {};
+
+      links.forEach(link => {
+        if (link && typeof link === 'object' && 'resource' in link) {
+          // Link is an object with resource and optional envCallback
+          resources.push(link.resource);
+
+          // If there's an envCallback, call it and merge the result
+          if (link.envCallback) {
+            const callbackResult = link.envCallback(link.resource);
+            Object.assign(customEnv, callbackResult);
+          }
+        } else {
+          // Link is just a resource
+          resources.push(link);
+        }
+      });
+
+      // Apply default environment variables for all resources
+      if (!args.config) args.config = {};
+      if (!args.config.environment) args.config.environment = {};
+
+      const resourcesEnvVars = {
+        ...applyLinkedResourcesEnv(resources),
+        ...customEnv,
+      };
+
+      // TODO: Write resourcesEnvVars to the .env file
+      // TODO: Add proper types
+    };
+
+    /**
+     * Return the links as an array of resources in the original SST format.
+     */
+    function getLinks(): any[] {
+      return (args.link || []).map(link => {
+        if (link && typeof link === 'object' && 'resource' in link) {
+          return link.resource;
+        }
+
+        return link;
+      });
+    }
+
+    function prepareEnvironmentFile() {
+      const envFile = args.config?.environment?.file as string | undefined;
+
+      if (! envFile) {
+        return;
+      }
+
+      const envDir = path.resolve(pluginBuildPath, 'deploy');
+      const dst = path.resolve(envDir, '.env');
+      const src = path.resolve(absSitePath, envFile);
+
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dst);
+        fs.chmodSync(dst, 0o755);
+      } else {
+        fs.writeFileSync(dst, '');
+      }
+
+      if (! args.config?.environment?.autoInject === false) {
+        applyLinkedResourcesToEnvironment();
+      }
+    }
+
+    function prepareDeploymentScript() {
+      const deployDir = path.resolve(pluginBuildPath, 'deploy');
+      const dst = path.resolve(deployDir, '60-deploy.sh');
+
+      fs.mkdirSync(deployDir, { recursive: true });
+
+      const script = args.config?.deployment?.script as string | undefined;
+      if (script) {
+        const src = path.resolve(absSitePath, script);
+        if (fs.existsSync(src)) {
+          fs.copyFileSync(src, dst);
+          fs.chmodSync(dst, 0o755);
+          return;
+        }
+      }
+
+      fs.writeFileSync(dst, "#!/bin/sh\nexit 0\n");
+      fs.chmodSync(dst, 0o755);
+    }
+  };
+}
+
+const __pulumiType = "sst:aws:Laravel";
+// @ts-expect-error
+Laravel.__pulumiType = __pulumiType;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@kirschbaum-development/sst-laravel",
+  "version": "0.0.1",
+  "description": "An unofficial extension of SST to deploy containerized Laravel applications to AWS Fargate.",
+  "main": "laravel-sst.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kirschbaumdevelopment/sst-laravel.git"
+  },
+  "keywords": [
+    "laravel",
+    "sst",
+    "aws",
+    "serverless"
+  ],
+  "author": {
+    "name": "Luis Dalmolin",
+    "email": "luis@kirschbaumdevelopment.com"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kirschbaum-development/sst-laravel/issues"
+  },
+  "homepage": "https://github.com/kirschbaum-development/sst-laravel#readme",
+  "dependencies": {}
+}

package/src/laravel-env.ts

@@ -0,0 +1,154 @@
+import { Email } from "../../../.sst/platform/src/components/aws/email.js";
+import { Mysql } from "../../../.sst/platform/src/components/aws/mysql.js";
+import { Postgres } from "../../../.sst/platform/src/components/aws/postgres.js";
+import { Redis } from "../../../.sst/platform/src/components/aws/redis.js";
+import { Output } from "../../../.sst/platform/node_modules/@pulumi/pulumi/index.js";
+import * as pulumiAws from "../../../.sst/platform/node_modules/@pulumi/aws";
+import { Queue } from "../../../.sst/platform/src/components/aws/queue.js";
+import { Aurora } from "../../../.sst/platform/src/components/aws/aurora.js";
+import { Bucket } from "../../../.sst/platform/src/components/aws/bucket.js";
+
+type EnvType = Record<string, string | Output<string>>|Record<string, string | Output<string | undefined> | undefined>;
+type Database = Postgres | Mysql | Aurora | pulumiAws.rds.Instance;
+type LinkSupportedTypes = Database | Email | Queue | Redis | Bucket;
+
+export type EnvCallback = (resource: any) => EnvType;
+export type EnvCallbacks = {
+  postgres?: EnvCallback;
+  mysql?: EnvCallback;
+  redis?: EnvCallback;
+  email?: EnvCallback;
+  queue?: EnvCallback;
+};
+
+export function applyLinkedResourcesEnv(links: LinkSupportedTypes[], callbacks?: EnvCallbacks): EnvType {
+  let environment: EnvType  = {};
+
+  links.forEach((link: LinkSupportedTypes) => {
+    if (link instanceof Postgres) {
+      const defaultEnv = applyDatabaseEnv(link);
+
+      environment = {
+        ...environment,
+        ...defaultEnv,
+        ...(callbacks?.postgres ? callbacks.postgres(link) : {}),
+      };
+    }
+
+    if (link instanceof Redis) {
+      const defaultEnv = applyRedisEnv(link);
+
+      environment = {
+        ...environment,
+        ...defaultEnv,
+        ...(callbacks?.redis ? callbacks.redis(link) : {}),
+      };
+    }
+
+    if (link instanceof Email) {
+      const defaultEnv = applyEmailEnv(link);
+
+      environment = {
+        ...environment,
+        ...defaultEnv,
+        ...(callbacks?.email ? callbacks.email(link) : {}),
+      };
+    }
+
+    if (link instanceof Queue) {
+      const defaultEnv = applyQueueEnv(link);
+
+      environment = {
+        ...environment,
+        ...defaultEnv,
+        ...(callbacks?.queue ? callbacks.queue(link) : {}),
+      };
+    }
+
+    if (link instanceof Bucket) {
+      const defaultEnv = applyBucketEnv(link);
+
+      environment = {
+        ...environment,
+        ...defaultEnv,
+      };
+    }
+  });
+
+  return environment;
+}
+
+function applyDatabaseEnv(database: Database, callbacks?: EnvCallbacks): EnvType {
+  let port: number;
+database.port.apply(value => port = value);
+
+  if (database instanceof Postgres || (database instanceof Aurora && port === 5432)) {
+    return applyPostgresEnv(database);
+  }
+
+  if (database instanceof Mysql || (database instanceof Aurora && port === 3306) || database instanceof pulumiAws.rds.Instance) {
+    return applyMySqlEnv(database);
+  }
+
+  return {};
+}
+
+function applyPostgresEnv(database: Postgres|Aurora): EnvType {
+  const port: Output<number> = database.port;
+
+  return {
+    DB_CONNECTION: 'pgsql',
+    DB_HOST: database.host,
+    DB_DATABASE: database.database,
+    DB_USERNAME: database.username,
+    DB_PASSWORD: database.password,
+    DB_PORT: port.apply(port => port.toString()),
+  };
+}
+
+function applyMySqlEnv(database: Mysql|Aurora|pulumiAws.rds.Instance): EnvType {
+  const port: Output<number> = database.port;
+
+  return {
+    DB_CONNECTION: 'mysql',
+    DB_HOST: database instanceof Aurora || database instanceof Mysql ? database.host : database.endpoint,
+    DB_DATABASE: database instanceof Aurora || database instanceof Mysql ? database.database : database.dbName,
+    DB_USERNAME: database.username,
+    DB_PASSWORD: database.password,
+    DB_PORT: port.apply(port => port.toString()),
+  };
+}
+
+export function applyRedisEnv(database: Redis): EnvType {
+  // TODO: Check if when encryption at rest is disabled, TLS is not required/throw errors
+  return {
+    REDIS_HOST: database.host.apply(host => host ? `tls://${host}` : ''),
+    REDIS_PORT: database.port.apply(port => port.toString()),
+    REDIS_PASSWORD: database.password,
+  };
+}
+
+// TODO
+export function applyEmailEnv(mail: Email): EnvType {
+  return {
+    MAIL_MAILER: 'ses',
+    // MAIL_FROM_ADDRESS: link.sender,
+  };
+}
+
+// TODO
+export function applyQueueEnv(queue: Queue): EnvType {
+  const queueUrl: Output<string> = queue.url;
+
+  return {
+    SQS_QUEUE: queue.url,
+    // MAIL_FROM_ADDRESS: link.sender,
+  };
+}
+
+export function applyBucketEnv(bucket: Bucket): EnvType {
+  return {
+      FILESYSTEM_DISK: 's3',
+      AWS_BUCKET: bucket.name,
+  };
+}

package/sst-env.d.ts

@@ -0,0 +1,9 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import "sst"
+export {}