@awsless/awsless 0.0.19 → 0.0.20

package/dist/bin.cjs

@@ -191,6 +191,12 @@ var formatLogicalId = (id) => {
 var formatName = (name) => {
   return (0, import_change_case2.paramCase)(name);
 };
+var formatArn = (props) => {
+  return sub("arn:${AWS::Partition}:${service}:${AWS::Region}:${AWS::AccountId}:${resource}${seperator}${resourceName}", {
+    seperator: "/",
+    ...props
+  });
+};
 
 // src/formation/resource.ts
 var Resource = class {
@@ -200,13 +206,19 @@ var Resource = class {
     this.logicalId = formatLogicalId(`${logicalId}-${type.replace(/^AWS::/, "")}`);
   }
   logicalId;
+  tags = /* @__PURE__ */ new Map();
   deps = /* @__PURE__ */ new Set();
+  stack;
   dependsOn(...dependencies) {
     for (const dependency of dependencies) {
       this.deps.add(dependency);
     }
     return this;
   }
+  tag(key, value) {
+    this.tags.set(key, value);
+    return this;
+  }
   attr(name, value) {
     if (typeof value === "undefined") {
       return {};
@@ -215,12 +227,41 @@ var Resource = class {
       [name]: value
     };
   }
+  setStack(stack) {
+    this.stack = stack;
+    return this;
+  }
+  ref() {
+    return this.getAtt("ref");
+  }
+  getAtt(attr) {
+    return new Lazy((stack) => {
+      if (!this.stack) {
+        throw new TypeError("Resource stack not defined before building template");
+      }
+      const value = attr === "ref" ? ref(this.logicalId) : getAtt(this.logicalId, attr);
+      if (stack === this.stack) {
+        return value;
+      }
+      const name = `${this.stack.name}-${this.logicalId}-${attr}`;
+      this.stack.export(name, value);
+      return this.stack.import(name);
+    });
+  }
   toJSON() {
     return {
       [this.logicalId]: {
         Type: this.type,
         DependsOn: [...this.deps].map((dep) => dep.logicalId),
-        Properties: this.properties()
+        Properties: {
+          ...this.tags.size ? {
+            Tags: Array.from(this.tags.entries()).map(([key, value]) => ({
+              Key: key,
+              Value: value
+            }))
+          } : {},
+          ...this.properties()
+        }
       }
     };
   }
@@ -230,6 +271,11 @@ var Group = class {
     this.children = children;
   }
 };
+var Lazy = class {
+  constructor(callback) {
+    this.callback = callback;
+  }
+};
 
 // src/formation/resource/iam/inline-policy.ts
 var InlinePolicy = class {
@@ -335,6 +381,7 @@ var Function = class extends Resource {
     this.policy = policy;
     this.name = formatName(this.props.name || logicalId);
     this.environmentVariables = props.environment ? { ...props.environment } : {};
+    this.tag("name", this.name);
   }
   name;
   role;
@@ -348,11 +395,15 @@ var Function = class extends Resource {
     this.environmentVariables[name] = value;
     return this;
   }
+  setVpc(vpc) {
+    this.props.vpc = vpc;
+    return this;
+  }
   get id() {
-    return ref(this.logicalId);
+    return this.ref();
   }
   get arn() {
-    return getAtt(this.logicalId, "Arn");
+    return this.getAtt("Arn");
   }
   get permissions() {
     return {
@@ -360,7 +411,14 @@ var Function = class extends Resource {
         "lambda:InvokeFunction",
         "lambda:InvokeAsync"
       ],
-      resources: [this.arn]
+      resources: [
+        formatArn({
+          service: "lambda",
+          resource: "function",
+          resourceName: this.name,
+          seperator: ":"
+        })
+      ]
     };
   }
   properties() {
@@ -376,6 +434,12 @@ var Function = class extends Resource {
       EphemeralStorage: {
         Size: this.props.ephemeralStorageSize?.toMegaBytes() ?? 512
       },
+      ...this.props.vpc ? {
+        VpcConfig: {
+          SecurityGroupIds: this.props.vpc.securityGroupIds,
+          SubnetIds: this.props.vpc.subnetIds
+        }
+      } : {},
       Environment: {
         Variables: this.environmentVariables
       }
@@ -400,6 +464,7 @@ var Stack = class {
       } else {
         this.add(...item.children);
         if (item instanceof Resource) {
+          item.setStack(this);
           this.resources.add(item);
         }
       }
@@ -443,8 +508,24 @@ var Stack = class {
   toJSON() {
     const resources = {};
     const outputs = {};
+    const walk = (object) => {
+      for (const [key, value] of Object.entries(object)) {
+        if (!object.hasOwnProperty(key)) {
+          continue;
+        }
+        if (value instanceof Lazy) {
+          object[key] = value.callback(this);
+          continue;
+        }
+        if (typeof value === "object" && value !== null) {
+          walk(value);
+        }
+      }
+    };
     for (const resource of this) {
-      Object.assign(resources, resource.toJSON());
+      const json2 = resource.toJSON();
+      walk(json2);
+      Object.assign(resources, json2);
     }
     for (const [name, value] of this.exports.entries()) {
       Object.assign(outputs, {
@@ -512,54 +593,33 @@ var toStack = ({ config, app, stackConfig, bootstrap: bootstrap2, usEastBootstra
   }
   return {
     stack,
-    depends: stackConfig.depends
+    bindings
+    // depends: stackConfig.depends,
   };
 };
 
 // src/util/deployment.ts
-var createDependencyTree = (stacks) => {
+var createDeploymentLine = (stacks) => {
   const list3 = stacks.map(({ stack, config }) => ({
     stack,
     depends: config?.depends?.map((dep) => dep.name) || []
   }));
-  const findChildren = (list4, parents) => {
-    const children = [];
-    const rests = [];
-    for (const item of list4) {
-      const isChild = item.depends.filter((dep) => !parents.includes(dep)).length === 0;
-      if (isChild) {
-        children.push(item);
-      } else {
-        rests.push(item);
+  const line = [];
+  const deps = [];
+  let limit = 10;
+  while (deps.length < list3.length) {
+    const local = [];
+    for (const { stack, depends } of list3) {
+      if (!deps.includes(stack.name) && depends.filter((dep) => !deps.includes(dep)).length === 0) {
+        local.push(stack);
       }
     }
-    if (!rests.length) {
-      return children.map(({ stack }) => ({
-        stack,
-        children: []
-      }));
+    if (limit-- <= 0) {
+      throw new Error(`Circular stack dependencies arn't allowed.`);
     }
-    return children.map(({ stack }) => {
-      return {
-        stack,
-        children: findChildren(rests, [...parents, stack.name])
-      };
-    });
-  };
-  return findChildren(list3, []);
-};
-var createDeploymentLine = (stacks) => {
-  const line = [];
-  const walk = (stacks2, level) => {
-    stacks2.forEach((node) => {
-      if (!line[level]) {
-        line[level] = [];
-      }
-      line[level].push(node.stack);
-      walk(node.children, level + 1);
-    });
-  };
-  walk(stacks, 0);
+    deps.push(...local.map((stack) => stack.name));
+    line.push(local);
+  }
   return line;
 };
 
@@ -959,8 +1019,12 @@ var RuntimeSchema = import_zod6.z.enum([
 var FunctionSchema = import_zod6.z.union([
   LocalFileSchema,
   import_zod6.z.object({
-    /** The file path ofthe function code. */
+    /** The file path of the function code. */
     file: LocalFileSchema,
+    /** Put the function inside your global VPC.
+     * @default false
+     */
+    vpc: import_zod6.z.boolean().optional(),
     /** The amount of time that Lambda allows a function to run before stopping it.
      * You can specify a size value from 1 second to 15 minutes.
      * @default '10 seconds'
@@ -1010,6 +1074,10 @@ var FunctionSchema = import_zod6.z.union([
 var schema = import_zod6.z.object({
   defaults: import_zod6.z.object({
     function: import_zod6.z.object({
+      /** Put the function inside your global VPC.
+       * @default false
+       */
+      vpc: import_zod6.z.boolean().default(false),
       /** The amount of time that Lambda allows a function to run before stopping it.
        * You can specify a size value from 1 second to 15 minutes.
        * @default '10 seconds'
@@ -1101,12 +1169,36 @@ var toLambdaFunction = (ctx, id, fileOrProps) => {
   const lambda = new Function(id, {
     name: `${config.name}-${stack.name}-${id}`,
     code: Code.fromFile(id, props.file),
-    ...props
+    ...props,
+    vpc: void 0
   });
   lambda.addEnvironment("APP", config.name).addEnvironment("STAGE", config.stage).addEnvironment("STACK", stack.name);
+  if (props.vpc) {
+    lambda.setVpc({
+      securityGroupIds: [
+        ctx.bootstrap.import(`vpc-security-group-id`)
+      ],
+      subnetIds: [
+        ctx.bootstrap.import(`public-subnet-1`),
+        ctx.bootstrap.import(`public-subnet-2`)
+      ]
+    }).addPermissions({
+      actions: [
+        "ec2:CreateNetworkInterface",
+        "ec2:DescribeNetworkInterfaces",
+        "ec2:DeleteNetworkInterface",
+        "ec2:AssignPrivateIpAddresses",
+        "ec2:UnassignPrivateIpAddresses"
+      ],
+      resources: ["*"]
+    });
+  }
   if (props.runtime.startsWith("nodejs")) {
     lambda.addEnvironment("AWS_NODEJS_CONNECTION_REUSE_ENABLED", "1");
   }
+  ctx.bind((other) => {
+    other.addPermissions(lambda.permissions);
+  });
   return lambda;
 };
 
@@ -1230,6 +1322,7 @@ var Queue = class extends Resource {
     super("AWS::SQS::Queue", logicalId);
     this.props = props;
     this.name = formatName(this.props.name || logicalId);
+    this.tag("name", this.name);
   }
   name;
   setDeadLetter(arn) {
@@ -1250,7 +1343,13 @@ var Queue = class extends Resource {
         "sqs:GetQueueUrl",
         "sqs:GetQueueAttributes"
       ],
-      resources: [this.arn]
+      resources: [
+        formatArn({
+          service: "sqs",
+          resource: "queue",
+          resourceName: this.name
+        })
+      ]
     };
   }
   properties() {
@@ -1477,6 +1576,7 @@ var Table = class extends Resource {
     this.props = props;
     this.name = formatName(this.props.name || logicalId);
     this.indexes = { ...this.props.indexes || {} };
+    this.tag("name", this.name);
   }
   name;
   indexes;
@@ -1509,7 +1609,13 @@ var Table = class extends Resource {
         "dynamodb:Query",
         "dynamodb:Scan"
       ],
-      resources: [this.arn]
+      resources: [
+        formatArn({
+          service: "dynamodb",
+          resource: "table",
+          resourceName: this.name
+        })
+      ]
     };
   }
   attributeDefinitions() {
@@ -1743,6 +1849,7 @@ var Bucket = class extends Resource {
     super("AWS::S3::Bucket", logicalId);
     this.props = props;
     this.name = formatName(this.props.name || logicalId);
+    this.tag("name", this.name);
   }
   name;
   get arn() {
@@ -1759,7 +1866,13 @@ var Bucket = class extends Resource {
         "s3:GetQueueUrl",
         "s3:GetQueueAttributes"
       ],
-      resources: [this.arn]
+      resources: [
+        formatArn({
+          service: "s3",
+          resource: "bucket",
+          resourceName: this.name
+        })
+      ]
     };
   }
   properties() {
@@ -1812,6 +1925,7 @@ var Topic = class extends Resource {
     super("AWS::SNS::Topic", logicalId);
     this.props = props;
     this.name = formatName(this.props.name || logicalId);
+    this.tag("name", this.name);
   }
   name;
   get arn() {
@@ -1820,7 +1934,13 @@ var Topic = class extends Resource {
   get permissions() {
     return {
       actions: ["sns:Publish"],
-      resources: [this.arn]
+      resources: [
+        formatArn({
+          service: "sns",
+          resource: "topic",
+          resourceName: this.name
+        })
+      ]
     };
   }
   properties() {
@@ -2053,6 +2173,7 @@ var GraphQLApi = class extends Resource {
     super("AWS::AppSync::GraphQLApi", logicalId);
     this.props = props;
     this.name = formatName(this.props.name || logicalId);
+    this.tag("name", this.name);
   }
   name;
   lambdaAuthProviders = [];
@@ -2817,6 +2938,12 @@ var Vpc = class extends Resource {
   get id() {
     return ref(this.logicalId);
   }
+  get defaultNetworkAcl() {
+    return getAtt(this.logicalId, "DefaultNetworkAcl");
+  }
+  get defaultSecurityGroup() {
+    return getAtt(this.logicalId, "DefaultSecurityGroup");
+  }
   properties() {
     return {
       CidrBlock: this.props.cidrBlock.ip
@@ -2828,6 +2955,7 @@ var RouteTable = class extends Resource {
     super("AWS::EC2::RouteTable", logicalId);
     this.props = props;
     this.name = formatName(props.name || logicalId);
+    this.tag("name", this.name);
   }
   name;
   get id() {
@@ -2835,11 +2963,7 @@ var RouteTable = class extends Resource {
   }
   properties() {
     return {
-      VpcId: this.props.vpcId,
-      Tags: [{
-        Key: "name",
-        Value: this.name
-      }]
+      VpcId: this.props.vpcId
     };
   }
 };
@@ -2992,6 +3116,7 @@ var vpcPlugin = definePlugin({
       routeTableId: publicRouteTable.id,
       destination: Peer.anyIpv4()
     }).dependsOn(gateway, publicRouteTable);
+    bootstrap2.export("vpc-security-group-id", vpc.defaultSecurityGroup);
     bootstrap2.export(`vpc-id`, vpc.id);
     bootstrap2.add(
       vpc,
@@ -3034,7 +3159,9 @@ var SecurityGroup = class extends Resource {
   constructor(logicalId, props) {
     super("AWS::EC2::SecurityGroup", logicalId);
     this.props = props;
+    this.name = formatName(props.name ?? logicalId);
   }
+  name;
   ingress = [];
   egress = [];
   get id() {
@@ -3059,7 +3186,7 @@ var SecurityGroup = class extends Resource {
   properties() {
     return {
       VpcId: this.props.vpcId,
-      GroupName: this.logicalId,
+      GroupName: this.name,
       GroupDescription: this.props.description,
       SecurityGroupIngress: this.ingress.map((rule) => ({
         Description: rule.description || "",
@@ -3470,6 +3597,7 @@ var Collection = class extends Resource {
     super("AWS::OpenSearchServerless::Collection", logicalId);
     this.props = props;
     this.name = this.props.name || logicalId;
+    this.tag("name", this.name);
   }
   name;
   get id() {
@@ -3481,6 +3609,18 @@ var Collection = class extends Resource {
   get endpoint() {
     return getAtt(this.logicalId, "CollectionEndpoint");
   }
+  get permissions() {
+    return {
+      actions: ["aoss:APIAccessAll"],
+      resources: [
+        formatArn({
+          service: "aoss",
+          resource: "collection",
+          resourceName: this.name
+        })
+      ]
+    };
+  }
   properties() {
     return {
       Name: this.name,
@@ -3505,10 +3645,155 @@ var searchPlugin = definePlugin({
         type: "search"
       });
       bind((lambda) => {
-        lambda.addPermissions({
-          actions: ["aoss:APIAccessAll"],
-          resources: [collection.arn]
-        });
+        lambda.addPermissions(collection.permissions);
+      });
+    }
+  }
+});
+
+// src/plugins/cache.ts
+var import_zod19 = require("zod");
+
+// src/formation/resource/memorydb/cluster.ts
+var Cluster = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::MemoryDB::Cluster", logicalId);
+    this.props = props;
+    this.name = formatName(this.props.name || logicalId);
+    this.tag("name", this.name);
+  }
+  name;
+  get status() {
+    return this.getAtt("Status");
+  }
+  get arn() {
+    return this.getAtt("ARN");
+  }
+  get address() {
+    return this.getAtt("ClusterEndpoint.Address");
+  }
+  get port() {
+    return this.getAtt("ClusterEndpoint.Port");
+  }
+  properties() {
+    return {
+      ClusterName: this.name,
+      ClusterEndpoint: {
+        Port: this.props.port
+      },
+      Port: this.props.port,
+      ...this.attr("Description", this.props.description),
+      ACLName: this.props.aclName,
+      EngineVersion: this.props.engine ?? "7.0",
+      ...this.attr("SubnetGroupName", this.props.subnetGroupName),
+      ...this.attr("SecurityGroupIds", this.props.securityGroupIds),
+      NodeType: "db." + this.props.type,
+      NumReplicasPerShard: this.props.replicasPerShard ?? 1,
+      NumShards: this.props.shards ?? 1,
+      TLSEnabled: this.props.tls ?? false,
+      DataTiering: this.props.dataTiering ? "true" : "false",
+      AutoMinorVersionUpgrade: this.props.autoMinorVersionUpgrade ?? true,
+      MaintenanceWindow: this.props.maintenanceWindow ?? "Sat:02:00-Sat:05:00"
+    };
+  }
+};
+
+// src/formation/resource/memorydb/subnet-group.ts
+var SubnetGroup = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::MemoryDB::SubnetGroup", logicalId);
+    this.props = props;
+    this.name = formatName(this.props.name || logicalId);
+  }
+  name;
+  get arn() {
+    return getAtt(this.logicalId, "Arn");
+  }
+  properties() {
+    return {
+      SubnetGroupName: this.name,
+      SubnetIds: this.props.subnetIds,
+      ...this.attr("Description", this.props.description)
+    };
+  }
+};
+
+// src/plugins/cache.ts
+var TypeSchema = import_zod19.z.enum([
+  "t4g.small",
+  "t4g.medium",
+  "r6g.large",
+  "r6g.xlarge",
+  "r6g.2xlarge",
+  "r6g.4xlarge",
+  "r6g.8xlarge",
+  "r6g.12xlarge",
+  "r6g.16xlarge",
+  "r6gd.xlarge",
+  "r6gd.2xlarge",
+  "r6gd.4xlarge",
+  "r6gd.8xlarge"
+]);
+var PortSchema = import_zod19.z.number().int().min(1).max(5e4);
+var ShardsSchema = import_zod19.z.number().int().min(0).max(100);
+var ReplicasPerShardSchema = import_zod19.z.number().int().min(0).max(5);
+var EngineSchema = import_zod19.z.enum(["7.0", "6.2"]);
+var cachePlugin = definePlugin({
+  name: "cache",
+  schema: import_zod19.z.object({
+    stacks: import_zod19.z.object({
+      /** Define the caches in your stack.
+       * For access to the cache put your functions inside the global VPC.
+       * @example
+       * {
+       *   caches: {
+       *     CACHE_NAME: {
+       *       type: 't4g.small'
+       *     }
+       *   }
+       * }
+       */
+      caches: import_zod19.z.record(
+        ResourceIdSchema,
+        import_zod19.z.object({
+          type: TypeSchema.default("t4g.small"),
+          port: PortSchema.default(6379),
+          shards: ShardsSchema.default(1),
+          replicasPerShard: ReplicasPerShardSchema.default(1),
+          engine: EngineSchema.default("7.0"),
+          dataTiering: import_zod19.z.boolean().default(false)
+        })
+      ).optional()
+    }).array()
+  }),
+  onStack({ config, stack, stackConfig, bootstrap: bootstrap2, bind }) {
+    for (const [id, props] of Object.entries(stackConfig.caches || {})) {
+      const name = `${config.name}-${stack.name}-${id}`;
+      const subnetGroup = new SubnetGroup(id, {
+        name,
+        subnetIds: [
+          bootstrap2.import(`private-subnet-1`),
+          bootstrap2.import(`private-subnet-2`)
+        ]
+      });
+      const securityGroup = new SecurityGroup(id, {
+        name,
+        vpcId: bootstrap2.import(`vpc-id`),
+        description: name
+      });
+      const port = Port.tcp(props.port);
+      securityGroup.addIngressRule(Peer.anyIpv4(), port);
+      securityGroup.addIngressRule(Peer.anyIpv6(), port);
+      const cluster = new Cluster(id, {
+        name,
+        aclName: "open-access",
+        securityGroupIds: [securityGroup.id],
+        subnetGroupName: subnetGroup.name,
+        ...props
+      }).dependsOn(subnetGroup, securityGroup);
+      stack.add(subnetGroup, securityGroup, cluster);
+      bind((lambda) => {
+        lambda.addEnvironment(`CACHE_${stack.name}_${id}_HOST`, cluster.address).addEnvironment(`CACHE_${stack.name}_${id}_PORT`, props.port.toString());
       });
     }
   }
@@ -3519,6 +3804,7 @@ var defaultPlugins = [
   extendPlugin,
   vpcPlugin,
   functionPlugin,
+  cachePlugin,
   cronPlugin,
   queuePlugin,
   tablePlugin,
@@ -3700,7 +3986,7 @@ var toApp = async (config, filters) => {
     config.stacks.filter((stack) => filters.includes(stack.name))
   );
   for (const stackConfig of filterdStacks) {
-    const { stack } = toStack({
+    const { stack, bindings: bindings2 } = toStack({
       config,
       stackConfig,
       bootstrap: bootstrap2,
@@ -3709,7 +3995,7 @@ var toApp = async (config, filters) => {
       app
     });
     app.add(stack);
-    stacks.push({ stack, config: stackConfig });
+    stacks.push({ stack, config: stackConfig, bindings: bindings2 });
   }
   for (const plugin of plugins) {
     for (const stack of app.stacks) {
@@ -3731,23 +4017,31 @@ var toApp = async (config, filters) => {
       bind2(fn);
     }
   }
-  let dependencyTree = createDependencyTree(stacks);
+  for (const entry of stacks) {
+    for (const dep of entry.config.depends || []) {
+      const depStack = stacks.find((entry2) => entry2.config.name === dep.name);
+      if (!depStack) {
+        throw new Error(`Stack dependency not found: ${dep.name}`);
+      }
+      const functions2 = entry.stack.find(Function);
+      for (const bind2 of depStack.bindings) {
+        for (const fn of functions2) {
+          bind2(fn);
+        }
+      }
+    }
+  }
+  const deploymentLine = createDeploymentLine(stacks);
   if (bootstrap2.size > 0) {
-    dependencyTree = [{
-      stack: bootstrap2,
-      children: dependencyTree
-    }];
+    deploymentLine.unshift([bootstrap2]);
   }
   if (usEastBootstrap.size > 0) {
-    dependencyTree = [{
-      stack: usEastBootstrap,
-      children: dependencyTree
-    }];
+    deploymentLine.unshift([usEastBootstrap]);
   }
   return {
     app,
     plugins,
-    dependencyTree
+    deploymentLine
   };
 };
 
@@ -3771,17 +4065,17 @@ var getCredentials = (profile) => {
 };
 
 // src/schema/app.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // src/schema/stack.ts
-var import_zod19 = require("zod");
-var StackSchema = import_zod19.z.object({
+var import_zod20 = require("zod");
+var StackSchema = import_zod20.z.object({
   name: ResourceIdSchema,
-  depends: import_zod19.z.array(import_zod19.z.lazy(() => StackSchema)).optional()
+  depends: import_zod20.z.array(import_zod20.z.lazy(() => StackSchema)).optional()
 });
 
 // src/schema/region.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = ["ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-4", "ap-south-1", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1"];
@@ -3798,45 +4092,47 @@ var regions = [
   ...ME,
   ...SA
 ];
-var RegionSchema = import_zod20.z.enum(regions);
+var RegionSchema = import_zod21.z.enum(regions);
 
 // src/schema/plugin.ts
-var import_zod21 = require("zod");
-var PluginSchema = import_zod21.z.object({
-  name: import_zod21.z.string(),
-  schema: import_zod21.z.custom().optional(),
+var import_zod22 = require("zod");
+var PluginSchema = import_zod22.z.object({
+  name: import_zod22.z.string(),
+  schema: import_zod22.z.custom().optional(),
   // depends: z.array(z.lazy(() => PluginSchema)).optional(),
-  onApp: import_zod21.z.function().returns(import_zod21.z.void()).optional(),
-  onStack: import_zod21.z.function().returns(import_zod21.z.any()).optional(),
-  onResource: import_zod21.z.function().returns(import_zod21.z.any()).optional()
+  onApp: import_zod22.z.function().returns(import_zod22.z.void()).optional(),
+  onStack: import_zod22.z.function().returns(import_zod22.z.any()).optional(),
+  onResource: import_zod22.z.function().returns(import_zod22.z.any()).optional()
   // bind: z.function().optional(),
 });
 
 // src/schema/app.ts
-var AppSchema = import_zod22.z.object({
+var AppSchema = import_zod23.z.object({
   /** App name */
   name: ResourceIdSchema,
   /** The AWS region to deploy to. */
   region: RegionSchema,
   /** The AWS profile to deploy to. */
-  profile: import_zod22.z.string(),
+  profile: import_zod23.z.string(),
   /** The deployment stage.
    * @default 'prod'
    */
-  stage: import_zod22.z.string().regex(/[a-z]+/).default("prod"),
+  stage: import_zod23.z.string().regex(/[a-z]+/).default("prod"),
   /** Default properties. */
-  defaults: import_zod22.z.object({}).default({}),
+  defaults: import_zod23.z.object({}).default({}),
   /** The application stacks. */
-  stacks: import_zod22.z.array(StackSchema).min(1).refine((stacks) => {
+  stacks: import_zod23.z.array(StackSchema).min(1).refine((stacks) => {
     const unique = new Set(stacks.map((stack) => stack.name));
     return unique.size === stacks.length;
   }, "Must be an array of unique stacks"),
   /** Custom plugins. */
-  plugins: import_zod22.z.array(PluginSchema).optional()
+  plugins: import_zod23.z.array(PluginSchema).optional()
 });
 
 // src/util/import.ts
-var import_core = require("@swc/core");
+var import_rollup3 = require("rollup");
+var import_rollup_plugin_swc32 = require("rollup-plugin-swc3");
+var import_rollup_plugin_replace = __toESM(require("rollup-plugin-replace"), 1);
 var import_path2 = require("path");
 var import_promises5 = require("fs/promises");
 
@@ -3885,54 +4181,25 @@ var fileExist = async (file) => {
 };
 
 // src/util/import.ts
-var resolveFileNameExtension = async (path) => {
-  const options = [
-    "",
-    ".ts",
-    ".js",
-    "/index.ts",
-    "/index.js"
-  ];
-  for (const option of options) {
-    const file = path.replace(/\.js$/, "") + option;
-    let stat;
-    try {
-      stat = await (0, import_promises5.lstat)(file);
-    } catch (error) {
-      continue;
-    }
-    if (stat.isFile()) {
-      return file;
-    }
-  }
-  throw new Error(`Failed to load file: ${path}`);
-};
-var resolveDir = (path) => {
-  return (0, import_path2.dirname)(path).replace(directories.root + "/", "");
-};
 var importFile = async (path) => {
-  const load = async (file) => {
-    debug("Load file:", style.info(file));
-    let { code: code2 } = await (0, import_core.transformFile)(file, {
-      isModule: true
-    });
-    const path2 = (0, import_path2.dirname)(file);
-    const dir = resolveDir(file);
-    code2 = code2.replaceAll("__dirname", `"${dir}"`);
-    const matches = code2.match(/(import|export)\s*{\s*[a-z0-9\_\,\s\*]+\s*}\s*from\s*('|")(\.\.?[\/a-z0-9\_\-\.]+)('|");?/ig);
-    if (!matches)
-      return code2;
-    await Promise.all(matches?.map(async (match) => {
-      const parts = /('|")(\.\.?[\/a-z0-9\_\-\.]+)('|")/ig.exec(match);
-      const from = parts[2];
-      const file2 = await resolveFileNameExtension((0, import_path2.join)(path2, from));
-      const result = await load(file2);
-      code2 = code2.replace(match, result);
-    }));
-    return code2;
-  };
-  const code = await load(path);
+  const bundle = await (0, import_rollup3.rollup)({
+    input: path,
+    plugins: [
+      (0, import_rollup_plugin_replace.default)({
+        __dirname: (id) => `'${(0, import_path2.dirname)(id)}'`
+      }),
+      (0, import_rollup_plugin_swc32.swc)({
+        minify: false
+      })
+    ]
+  });
   const outputFile = (0, import_path2.join)(directories.cache, "config.js");
+  const result = await bundle.generate({
+    format: "esm",
+    exports: "default"
+  });
+  const output = result.output[0];
+  const code = output.code;
   await (0, import_promises5.mkdir)(directories.cache, { recursive: true });
   await (0, import_promises5.writeFile)(outputFile, code);
   debug("Save config file:", style.info(outputFile));
@@ -4234,7 +4501,7 @@ var Renderer = class {
   flushing = false;
   screen = [];
   width() {
-    return this.output.columns;
+    return this.output.columns - 1;
   }
   height() {
     return this.output.rows;
@@ -5072,12 +5339,73 @@ var assetPublisher = (config, app) => {
   };
 };
 
+// src/cli/ui/complex/deployer.ts
+var stacksDeployer = (deploymentLine) => {
+  const stackNames = deploymentLine.map((line) => line.map((stack) => stack.name)).flat();
+  const stackNameSize = Math.max(...stackNames.map((name) => name.length));
+  return (term) => {
+    const ui = {};
+    term.out.gap();
+    for (const i in deploymentLine) {
+      const line = flexLine(
+        term,
+        ["   "],
+        [
+          " ",
+          style.placeholder(Number(i) + 1),
+          style.placeholder(" \u2500\u2500")
+        ]
+      );
+      term.out.write(line);
+      term.out.write(br());
+      for (const stack of deploymentLine[i]) {
+        const icon = new Signal(" ");
+        const name = new Signal(style.label.dim(stack.name));
+        const status2 = new Signal(style.info.dim("waiting"));
+        let stopSpinner;
+        term.out.write([
+          icon,
+          "  ",
+          name,
+          " ".repeat(stackNameSize - stack.name.length),
+          " ",
+          style.placeholder(symbol.pointerSmall),
+          " ",
+          status2,
+          br()
+        ]);
+        ui[stack.name] = {
+          start: (value) => {
+            const [spinner, stop] = createSpinner();
+            name.set(style.label(stack.name));
+            icon.set(spinner);
+            status2.set(style.warning(value));
+            stopSpinner = stop;
+          },
+          done(value) {
+            stopSpinner();
+            icon.set(style.success(symbol.success));
+            status2.set(style.success(value));
+          },
+          fail(value) {
+            stopSpinner();
+            icon.set(style.error(symbol.error));
+            status2.set(style.error(value));
+          }
+        };
+      }
+    }
+    term.out.gap();
+    return ui;
+  };
+};
+
 // src/cli/command/deploy.ts
 var deploy = (program2) => {
   program2.command("deploy").argument("[stacks...]", "Optionally filter stacks to deploy").description("Deploy your app to AWS").action(async (filters) => {
     await layout(async (config, write) => {
       await write(bootstrapDeployer(config));
-      const { app, dependencyTree } = await toApp(config, filters);
+      const { app, deploymentLine } = await toApp(config, filters);
       const stackNames = app.stacks.map((stack) => stack.name);
       const formattedFilter = stackNames.map((i) => style.info(i)).join(style.placeholder(", "));
       debug("Stacks to deploy", formattedFilter);
@@ -5091,26 +5419,21 @@ var deploy = (program2) => {
       await write(assetBuilder(app));
       await write(assetPublisher(config, app));
       await write(templateBuilder(app));
-      const statuses = {};
-      for (const stack of app) {
-        statuses[stack.name] = new Signal(style.info("waiting"));
-      }
       const doneDeploying = write(loadingDialog("Deploying stacks to AWS..."));
-      write(stackTree(dependencyTree, statuses));
       const client = new StackClient(app, config.account, config.region, config.credentials);
-      const deploymentLine = createDeploymentLine(dependencyTree);
-      for (const stacks of deploymentLine) {
-        const results = await Promise.allSettled(stacks.map(async (stack) => {
-          const signal = statuses[stack.name];
-          signal.set(style.warning("deploying"));
+      const ui = write(stacksDeployer(deploymentLine));
+      for (const line of deploymentLine) {
+        const results = await Promise.allSettled(line.map(async (stack) => {
+          const item = ui[stack.name];
+          item.start("deploying");
           try {
             await client.deploy(stack);
           } catch (error) {
             debugError(error);
-            signal.set(style.error("failed"));
+            item.fail("failed");
             throw error;
           }
-          signal.set(style.success("deployed"));
+          item.done("deployed");
         }));
         for (const result of results) {
           if (result.status === "rejected") {