@awsless/awsless 0.0.180 → 0.0.183

package/dist/bin.js

@@ -1230,7 +1230,7 @@ var logApp = (app) => {
 };
 
 // src/cli/ui/error/error.ts
-import { log as log4 } from "@clack/prompts";
+import { log as log5 } from "@clack/prompts";
 
 // src/cli/ui/error/config-error.ts
 import * as p from "@clack/prompts";
@@ -1316,7 +1316,7 @@ var logConfigError = (error) => {
 };
 
 // src/cli/ui/error/error.ts
-import { StackError as StackError2 } from "@awsless/formation";
+import { AppError as AppError2, StackError as StackError3 } from "@awsless/formation";
 
 // src/cli/ui/error/stack-error.ts
 import { ResourceError } from "@awsless/formation";
@@ -1375,33 +1375,56 @@ var logFileError = (error) => {
   );
 };
 
+// src/cli/ui/error/app-error.ts
+import { StackError as StackError2 } from "@awsless/formation";
+import { log as log4 } from "@clack/prompts";
+var logAppError = (error) => {
+  log4.message(
+    wrap([color.error(error.message), color.dim(`App: ${error.app}`)].join("\n"), {
+      hard: true
+    }),
+    { symbol: color.error(icon.error) }
+  );
+  for (const issue of error.issues) {
+    if (issue instanceof StackError2) {
+      logStackError(issue);
+    } else if (issue instanceof Error) {
+      log4.message(wrap(color.error(issue.message), { hard: true }), {
+        symbol: color.error(icon.error)
+      });
+    }
+  }
+};
+
 // src/cli/ui/error/error.ts
 var logError = (error) => {
   if (error instanceof ConfigError) {
     logConfigError(error);
   } else if (error instanceof Cancelled) {
-    log4.message(color.error("Cancelled."), {
+    log5.message(color.error("Cancelled."), {
       symbol: color.error(icon.error)
     });
-  } else if (error instanceof StackError2) {
+  } else if (error instanceof AppError2) {
+    logAppError(error);
+  } else if (error instanceof StackError3) {
     logStackError(error);
   } else if (error instanceof FileError) {
     logFileError(error);
   } else if (error instanceof Error) {
     const message = `${error.name}: ${error.message}`;
     const stack = error.stack ? color.dim(error.stack.replace(message, "")) : "";
-    log4.message(
+    log5.message(
       wrap([color.error(message), stack], {
         hard: true
       }),
       { symbol: color.error(icon.error) }
     );
   } else if (typeof error === "string") {
-    log4.message(wrap(color.error(error)), {
+    log5.message(wrap(color.error(error)), {
       symbol: color.error(icon.error)
     });
   } else {
-    log4.message(wrap(color.error("Unknown error!")), {
+    log5.message(wrap(color.error("Unknown error!")), {
       symbol: color.error(icon.error)
     });
   }
@@ -1438,7 +1461,7 @@ import {
   ResourceNotFoundException,
   ScalarAttributeType
 } from "@aws-sdk/client-dynamodb";
-import { confirm, log as log5 } from "@clack/prompts";
+import { confirm, log as log6 } from "@clack/prompts";
 var hasStateTable = async (client) => {
   try {
     const result = await client.send(
@@ -1478,7 +1501,7 @@ var bootstrapAwsless = async (opts) => {
   const client = new DynamoDB(opts);
   const table2 = await hasStateTable(client);
   if (!table2) {
-    log5.warn(`Your Awsless hasn't been bootstrapped yet.`);
+    log6.warn(`Your Awsless hasn't been bootstrapped yet.`);
     if (!process.env.SKIP_PROMPT) {
       const confirmed = await confirm({
         message: "Would you like to bootstrap now?"
@@ -1492,7 +1515,7 @@ var bootstrapAwsless = async (opts) => {
       update("Done deploying the bootstrap stack");
     });
   } else {
-    log5.step("Awsless has already been bootstrapped.");
+    log6.step("Awsless has already been bootstrapped.");
   }
 };
 
@@ -1689,32 +1712,31 @@ var cacheFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.caches ?? {})) {
-      const group = new Node(this.name, id);
-      ctx.stack.add(group);
+      const group = new Node(ctx.stack, this.name, id);
       const name = formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, this.name, id, "-");
-      const subnetGroup = new aws.memorydb.SubnetGroup("subnets", {
+      const subnetGroup = new aws.memorydb.SubnetGroup(group, "subnets", {
         name,
         subnetIds: [
-          ctx.app.import("base", "vpc-private-subnet-id-1"),
-          ctx.app.import("base", "vpc-private-subnet-id-2")
+          //
+          ctx.shared.get("vpc-private-subnet-id-1"),
+          ctx.shared.get("vpc-private-subnet-id-2")
         ]
       });
-      const securityGroup = new aws.ec2.SecurityGroup("security", {
+      const securityGroup = new aws.ec2.SecurityGroup(group, "security", {
         name,
-        vpcId: ctx.app.import("base", `vpc-id`),
+        vpcId: ctx.shared.get(`vpc-id`),
         description: name
       });
       const port = aws.ec2.Port.tcp(props.port);
       securityGroup.addIngressRule({ port, peer: aws.ec2.Peer.anyIpv4() });
       securityGroup.addIngressRule({ port, peer: aws.ec2.Peer.anyIpv6() });
-      const cluster = new aws.memorydb.Cluster("cluster", {
+      const cluster = new aws.memorydb.Cluster(group, "cluster", {
         name,
         aclName: "open-access",
         securityGroupIds: [securityGroup.id],
         subnetGroupName: subnetGroup.name,
         ...props
       });
-      group.add(subnetGroup, securityGroup, cluster);
       ctx.onFunction(({ lambda }) => {
         lambda.addEnvironment(
           `CACHE_${constantCase2(ctx.stack.name)}_${constantCase2(id)}_HOST`,
@@ -1992,18 +2014,16 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
       };
     });
   });
-  const code = new aws2.s3.BucketObject("code", {
-    bucket: formatGlobalResourceName(ctx.appConfig.name, "function", "assets"),
+  const code = new aws2.s3.BucketObject(group, "code", {
+    bucket: ctx.shared.get("function-bucket-name"),
     key: `/lambda/${name}.zip`,
     body: Asset.fromFile(getBuildPath("function", name, "bundle.zip"))
   });
-  group.add(code);
-  const role = new aws2.iam.Role("role", {
+  const role = new aws2.iam.Role(group, "role", {
     name,
     assumedBy: "lambda.amazonaws.com"
   });
-  group.add(role);
-  const policy = new aws2.iam.RolePolicy("policy", {
+  const policy = new aws2.iam.RolePolicy(group, "policy", {
     role: role.name,
     name: "lambda-policy",
     version: "2012-10-17",
@@ -2015,8 +2035,7 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
       }
     ]
   });
-  group.add(policy);
-  const lambda = new aws2.lambda.Function(`function`, {
+  const lambda = new aws2.lambda.Function(group, `function`, {
     ...props,
     name,
     code,
@@ -2025,24 +2044,21 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
     vpc: void 0,
     log: props.log
   });
-  group.add(lambda);
   ctx.registerFunction(lambda, policy);
   lambda.addEnvironment("APP", ctx.appConfig.name);
   if ("stackConfig" in ctx) {
     lambda.addEnvironment("STACK", ctx.stackConfig.name);
   }
-  const invoke = new aws2.lambda.EventInvokeConfig("async", {
+  new aws2.lambda.EventInvokeConfig(group, "async", {
     functionArn: lambda.arn,
     retryAttempts: props.retryAttempts
     // onFailure: getGlobalOnFailure(ctx),
   });
-  group.add(invoke);
   if (props.log.retention.value > 0n) {
-    const logGroup = new aws2.cloudWatch.LogGroup("log", {
+    const logGroup = new aws2.cloudWatch.LogGroup(group, "log", {
       name: lambda.name.apply((name2) => `/aws/lambda/${name2}`),
       retention: props.log.retention
     });
-    group.add(logGroup);
     policy.addStatement(
       {
         actions: ["logs:CreateLogStream"],
@@ -2061,7 +2077,7 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
     policy.addStatement(...local.permissions);
   }
   if (props.warm) {
-    const rule = new aws2.events.Rule("warm", {
+    const rule = new aws2.events.Rule(group, "warm", {
       name: `${name}--warm`,
       schedule: "rate(5 minutes)",
       enabled: true,
@@ -2076,21 +2092,19 @@ var createLambdaFunction = (group, ctx, ns, id, local) => {
         }
       ]
     });
-    group.add(rule);
-    const permission = new aws2.lambda.Permission(`warm`, {
+    new aws2.lambda.Permission(group, `warm`, {
       action: "lambda:InvokeFunction",
       principal: "events.amazonaws.com",
       functionArn: lambda.arn,
       sourceArn: rule.arn
     });
-    group.add(permission);
   }
   if (props.vpc) {
     lambda.setVpc({
-      securityGroupIds: [ctx.app.import("base", `vpc-security-group-id`)],
+      securityGroupIds: [ctx.shared.get(`vpc-security-group-id`)],
       subnetIds: [
-        ctx.app.import("base", `vpc-public-subnet-1`),
-        ctx.app.import("base", `vpc-public-subnet-2`)
+        ctx.shared.get(`vpc-public-subnet-1`),
+        ctx.shared.get(`vpc-public-subnet-2`)
       ]
     });
     policy.addStatement({
@@ -2116,10 +2130,9 @@ var cronFeature = defineFeature({
   name: "cron",
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.crons ?? {})) {
-      const group = new Node3("cron", id);
-      ctx.stack.add(group);
+      const group = new Node3(ctx.stack, "cron", id);
       const { lambda } = createLambdaFunction(group, ctx, this.name, id, props.consumer);
-      const rule = new aws3.events.Rule("rule", {
+      const rule = new aws3.events.Rule(group, "rule", {
         name: formatLocalResourceName(ctx.app.name, ctx.stack.name, this.name, id),
         schedule: props.schedule,
         enabled: props.enabled,
@@ -2131,13 +2144,12 @@ var cronFeature = defineFeature({
           }
         ]
       });
-      const permission = new aws3.lambda.Permission("permission", {
+      new aws3.lambda.Permission(group, "permission", {
         action: "lambda:InvokeFunction",
         principal: "events.amazonaws.com",
         functionArn: lambda.arn,
         sourceArn: rule.arn
       });
-      group.add(rule, permission);
     }
   }
 });
@@ -2152,104 +2164,92 @@ var domainFeature = defineFeature({
     if (domains.length === 0) {
       return;
     }
-    const group = new Node4("domain", "mail");
-    ctx.base.add(group);
-    const configurationSet = new aws4.ses.ConfigurationSet("config", {
+    const group = new Node4(ctx.base, "domain", "mail");
+    const configurationSet = new aws4.ses.ConfigurationSet(group, "config", {
       name: ctx.app.name,
       engagementMetrics: true,
       reputationMetrics: true
     });
-    ctx.base.export(`mail-configuration-set`, configurationSet.name);
-    group.add(configurationSet);
+    ctx.shared.set(`mail-configuration-set`, configurationSet.name);
     for (const [id, props] of domains) {
-      const group2 = new Node4("domain", id);
-      ctx.base.add(group2);
-      const hostedZone = new aws4.route53.HostedZone("zone", {
+      const group2 = new Node4(ctx.base, "domain", id);
+      const hostedZone = new aws4.route53.HostedZone(group2, "zone", {
         name: props.domain
       });
-      group2.add(hostedZone);
-      ctx.base.export(`hosted-zone-${id}-id`, hostedZone.id);
-      const certificate = new aws4.acm.Certificate("local", {
+      ctx.shared.set(`hosted-zone-${id}-id`, hostedZone.id);
+      const certificate = new aws4.acm.Certificate(group2, "local", {
         domainName: props.domain,
         alternativeNames: [`*.${props.domain}`]
       });
-      group2.add(certificate);
       hostedZone.addRecord("local-cert-1", certificate.validationRecord(0));
       hostedZone.addRecord("local-cert-2", certificate.validationRecord(1));
-      const validation = new aws4.acm.CertificateValidation("local", {
+      const validation = new aws4.acm.CertificateValidation(group2, "local", {
         certificateArn: certificate.arn
       });
-      group2.add(validation);
-      ctx.base.export(`local-certificate-${id}-arn`, validation.arn);
+      ctx.shared.set(`local-certificate-${id}-arn`, validation.arn);
       if (ctx.appConfig.region !== "us-east-1") {
-        const globalCertificate = new aws4.acm.Certificate("global", {
+        const globalCertificate = new aws4.acm.Certificate(group2, "global", {
           domainName: props.domain,
           alternativeNames: [`*.${props.domain}`],
           region: "us-east-1"
         });
-        group2.add(globalCertificate);
         hostedZone.addRecord("global-cert-1", globalCertificate.validationRecord(0));
         hostedZone.addRecord("global-cert-2", globalCertificate.validationRecord(1));
-        const globalValidation = new aws4.acm.CertificateValidation("global", {
+        const globalValidation = new aws4.acm.CertificateValidation(group2, "global", {
           certificateArn: globalCertificate.arn,
           region: "us-east-1"
         });
-        group2.add(globalValidation);
-        ctx.base.export(`global-certificate-${id}-arn`, globalValidation.arn);
+        ctx.shared.set(`global-certificate-${id}-arn`, globalValidation.arn);
       } else {
-        ctx.base.export(`global-certificate-${id}-arn`, validation.arn);
+        ctx.shared.set(`global-certificate-${id}-arn`, validation.arn);
       }
-      const emailIdentity = new aws4.ses.EmailIdentity("mail", {
+      const emailIdentity = new aws4.ses.EmailIdentity(group2, "mail", {
         emailIdentity: props.domain,
         mailFromDomain: `mail.${props.domain}`,
         configurationSetName: configurationSet.name,
         feedback: true,
         rejectOnMxFailure: true
       });
-      group2.add(emailIdentity);
       let i = 0;
       for (const record of emailIdentity.dkimRecords) {
-        const recordSet = new aws4.route53.RecordSet(`dkim-${++i}`, {
+        new aws4.route53.RecordSet(group2, `dkim-${++i}`, {
           hostedZoneId: hostedZone.id,
           ...record
         });
-        group2.add(recordSet);
       }
-      const record1 = new aws4.route53.RecordSet(`MX`, {
+      new aws4.route53.RecordSet(group2, `MX`, {
         hostedZoneId: hostedZone.id,
         name: `mail.${props.domain}`,
         type: "MX",
         ttl: minutes3(5),
         records: [`10 feedback-smtp.${ctx.appConfig.region}.amazonses.com`]
       });
-      const record2 = new aws4.route53.RecordSet(`SPF`, {
+      new aws4.route53.RecordSet(group2, `SPF`, {
         hostedZoneId: hostedZone.id,
         name: `mail.${props.domain}`,
         type: "TXT",
         ttl: minutes3(5),
         records: ['"v=spf1 include:amazonses.com -all"']
       });
-      const record3 = new aws4.route53.RecordSet(`DMARC`, {
+      new aws4.route53.RecordSet(group2, `DMARC`, {
         hostedZoneId: hostedZone.id,
         name: `_dmarc.${props.domain}`,
         type: "TXT",
         ttl: minutes3(5),
         records: ['"v=DMARC1; p=none;"']
       });
-      group2.add(record1, record2, record3);
       const mailIdentityArn = emailIdentity.output(() => {
         return `arn:aws:ses:${ctx.appConfig.region}:${ctx.accountId}:identity/${props.domain}`;
       });
-      ctx.base.export(`mail-${id}-arn`, mailIdentityArn);
-      ctx.base.export(`mail-${props.domain}-arn`, mailIdentityArn);
+      ctx.shared.set(`mail-${id}-arn`, mailIdentityArn);
+      ctx.shared.set(`mail-${props.domain}-arn`, mailIdentityArn);
       for (const record of props.dns ?? []) {
         const name = record.name ?? props.domain;
-        const recordSet = new aws4.route53.RecordSet(`${name}-${record.type}`, {
+        new aws4.route53.RecordSet(group2, `${name}-${record.type}`, {
           hostedZoneId: hostedZone.id,
           name,
           ...record
         });
-        group2.add(recordSet);
       }
     }
     ctx.onFunction(
@@ -2456,20 +2456,18 @@ var functionFeature = defineFeature({
     await ctx.write("function.d.ts", types2, true);
   },
   onApp(ctx) {
-    const group = new Node5("function", "asset");
-    ctx.base.add(group);
-    const bucket = new aws5.s3.Bucket("bucket", {
+    const group = new Node5(ctx.base, "function", "asset");
+    const bucket = new aws5.s3.Bucket(group, "bucket", {
       name: formatGlobalResourceName(ctx.appConfig.name, "function", "assets"),
       versioning: true,
       forceDelete: true
     });
-    group.add(bucket);
+    ctx.shared.set("function-bucket-name", bucket.name);
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.functions || {})) {
-      const group = new Node5("function", id);
+      const group = new Node5(ctx.stack, "function", id);
       createLambdaFunction(group, ctx, "function", id, props);
-      ctx.stack.add(group);
     }
   }
 });
@@ -2702,9 +2700,8 @@ var graphqlFeature = defineFeature({
   },
   onApp(ctx) {
     for (const [id, props] of Object.entries(ctx.appConfig.defaults.graphql ?? {})) {
-      const group = new Node6("graphql", id);
-      ctx.base.add(group);
-      const role = new aws6.iam.Role("role", {
+      const group = new Node6(ctx.base, "graphql", id);
+      const role = new aws6.iam.Role(group, "role", {
         assumedBy: "appsync.amazonaws.com",
         policies: [
           {
@@ -2722,8 +2719,7 @@ var graphqlFeature = defineFeature({
           }
         ]
       });
-      group.add(role);
-      const api = new aws6.appsync.GraphQLApi("api", {
+      const api = new aws6.appsync.GraphQLApi(group, "api", {
         name: formatGlobalResourceName(ctx.app.name, "graphql", id),
         type: "merged",
         role: role.arn,
@@ -2731,14 +2727,13 @@ var graphqlFeature = defineFeature({
           default: props.auth ? {
             type: "cognito",
             region: ctx.appConfig.region,
-            userPoolId: ctx.base.import(`auth-${props.auth}-user-pool-id`)
+            userPoolId: ctx.shared.get(`auth-${props.auth}-user-pool-id`)
           } : {
             type: "iam"
           }
         }
       });
-      group.add(api);
-      ctx.base.export(`graphql-${id}-id`, api.id);
+      ctx.shared.set(`graphql-${id}-id`, api.id);
       if (props.resolver) {
         ctx.registerBuild("graphql-resolver", id, async (build3) => {
           const resolver = props.resolver;
@@ -2757,20 +2752,17 @@ var graphqlFeature = defineFeature({
       }
       if (props.domain) {
         const domainName = formatFullDomainName(ctx.appConfig, props.domain, props.subDomain);
-        const domainGroup = new Node6("domain", domainName);
-        group.add(domainGroup);
-        const domain = new aws6.appsync.DomainName("domain", {
+        const domainGroup = new Node6(group, "domain", domainName);
+        const domain = new aws6.appsync.DomainName(domainGroup, "domain", {
           domainName,
-          certificateArn: ctx.base.import(`global-certificate-${props.domain}-arn`)
+          certificateArn: ctx.shared.get(`global-certificate-${props.domain}-arn`)
         });
-        domainGroup.add(domain);
-        const association = new aws6.appsync.DomainNameApiAssociation("association", {
+        new aws6.appsync.DomainNameApiAssociation(domainGroup, "association", {
           apiId: api.id,
           domainName: domain.domainName
         });
-        domainGroup.add(association);
-        const record = new aws6.route53.RecordSet("record", {
-          hostedZoneId: ctx.base.import(`hosted-zone-${props.domain}-id`),
+        new aws6.route53.RecordSet(domainGroup, "record", {
+          hostedZoneId: ctx.shared.get(`hosted-zone-${props.domain}-id`),
           type: "A",
           name: domainName,
           alias: {
@@ -2779,7 +2771,6 @@ var graphqlFeature = defineFeature({
             evaluateTargetHealth: false
           }
         });
-        domainGroup.add(record);
       }
     }
   },
@@ -2792,9 +2783,8 @@ var graphqlFeature = defineFeature({
           `GraphQL definition is not defined on app level for "${id}"`
         );
       }
-      const group = new Node6("graphql", id);
-      ctx.stack.add(group);
-      const api = new aws6.appsync.GraphQLApi("api", {
+      const group = new Node6(ctx.stack, "graphql", id);
+      const api = new aws6.appsync.GraphQLApi(group, "api", {
         name: formatLocalResourceName(ctx.app.name, ctx.stack.name, "graphql", id),
         // visibility: false,
         auth: {
@@ -2803,29 +2793,25 @@ var graphqlFeature = defineFeature({
           }
         }
       });
-      group.add(api);
-      const schema = new aws6.appsync.GraphQLSchema("schema", {
+      const schema = new aws6.appsync.GraphQLSchema(group, "schema", {
         apiId: api.id,
         definition: Asset2.fromFile(props.schema)
       });
-      group.add(schema);
-      const association = new aws6.appsync.SourceApiAssociation("association", {
-        mergedApiId: ctx.app.import("base", `graphql-${id}-id`),
+      const association = new aws6.appsync.SourceApiAssociation(group, "association", {
+        mergedApiId: ctx.shared.get(`graphql-${id}-id`),
         sourceApiId: api.id
       });
       association.dependsOn(schema);
-      group.add(association);
       for (const [typeName, fields] of Object.entries(props.resolvers ?? {})) {
         for (const [fieldName, props2] of Object.entries(fields ?? {})) {
           const name = `${typeName}__${fieldName}`;
-          const resolverGroup = new Node6("resolver", name);
-          group.add(resolverGroup);
+          const resolverGroup = new Node6(group, "resolver", name);
           const entryId = paramCase5(`${id}-${typeName}-${fieldName}`);
           const { lambda } = createLambdaFunction(resolverGroup, ctx, `graphql`, entryId, {
             ...props2.consumer,
             description: `${id} ${typeName}.${fieldName}`
           });
-          const role = new aws6.iam.Role("source-role", {
+          const role = new aws6.iam.Role(resolverGroup, "source-role", {
             assumedBy: "appsync.amazonaws.com",
             policies: [
               {
@@ -2839,36 +2825,32 @@ var graphqlFeature = defineFeature({
               }
             ]
           });
-          resolverGroup.add(role);
-          const source = new aws6.appsync.DataSource("source", {
+          const source = new aws6.appsync.DataSource(resolverGroup, "source", {
             apiId: api.id,
             type: "lambda",
             name,
             role: role.arn,
             functionArn: lambda.arn
           });
-          resolverGroup.add(source);
           let code = Asset2.fromString(defaultResolver);
           if ("resolver" in props2 && props2.resolver) {
             code = Asset2.fromFile(props2.resolver);
           } else if (defaultProps.resolver) {
             code = Asset2.fromFile(getBuildPath("graphql-resolver", id, "resolver.js"));
           }
-          const config2 = new aws6.appsync.FunctionConfiguration("config", {
+          const config2 = new aws6.appsync.FunctionConfiguration(resolverGroup, "config", {
             apiId: api.id,
             name,
             code,
             dataSourceName: source.name
           });
-          resolverGroup.add(config2);
-          const resolver = new aws6.appsync.Resolver("resolver", {
+          new aws6.appsync.Resolver(resolverGroup, "resolver", {
             apiId: api.id,
             typeName,
             fieldName,
             functions: [config2.id],
             code
           });
-          resolverGroup.add(resolver);
         }
       }
     }
@@ -2877,7 +2859,7 @@ var graphqlFeature = defineFeature({
 
 // src/feature/on-failure/util.ts
 var getGlobalOnFailure = (ctx) => {
-  return hasOnFailure(ctx.stackConfigs) ? ctx.app.import("base", "on-failure-queue-arn") : void 0;
+  return hasOnFailure(ctx.stackConfigs) ? ctx.shared.get("on-failure-queue-arn") : void 0;
 };
 var hasOnFailure = (stacks) => {
   const onFailure = stacks.find((stack) => {
@@ -2898,27 +2880,24 @@ var onFailureFeature = defineFeature({
     if (count > 1) {
       throw new TypeError("Only 1 onFailure configuration is allowed in your app.");
     }
-    const queue2 = new aws7.sqs.Queue("on-failure", {
+    const queue2 = new aws7.sqs.Queue(ctx.base, "on-failure", {
       name: formatGlobalResourceName(ctx.appConfig.name, "on-failure", "failure")
     });
-    ctx.base.add(queue2);
-    ctx.base.export("on-failure-queue-arn", queue2.arn);
+    ctx.shared.set("on-failure-queue-arn", queue2.arn);
   },
   onStack(ctx) {
     const onFailure = ctx.stackConfig.onFailure;
     if (!onFailure) {
       return;
     }
-    const queueArn = ctx.app.import("base", "on-failure-queue-arn");
-    const group = new Node7("on-failure", "failure");
-    ctx.stack.add(group);
+    const queueArn = ctx.shared.get("on-failure-queue-arn");
+    const group = new Node7(ctx.stack, "on-failure", "failure");
     const { lambda, policy } = createLambdaFunction(group, ctx, "on-failure", "failure", onFailure);
-    const source = new aws7.lambda.EventSourceMapping("on-failure", {
+    new aws7.lambda.EventSourceMapping(group, "on-failure", {
       functionArn: lambda.arn,
       sourceArn: queueArn,
       batchSize: 10
     });
-    group.add(source);
     policy.addStatement({
       actions: [
         "sqs:SendMessage",
@@ -2946,22 +2925,20 @@ var pubsubFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.pubsub ?? {})) {
-      const group = new Node8("pubsub", id);
-      ctx.stack.add(group);
+      const group = new Node8(ctx.stack, "pubsub", id);
       const { lambda } = createLambdaFunction(group, ctx, `pubsub`, "function", props.consumer);
-      const topic = new aws8.iot.TopicRule("rule", {
+      const topic = new aws8.iot.TopicRule(group, "rule", {
         name: formatLocalResourceName(ctx.app.name, ctx.stack.name, "pubsub", id).replaceAll("-", "_"),
         sql: props.sql,
         sqlVersion: props.sqlVersion,
         actions: [{ lambda: { functionArn: lambda.arn } }]
       });
-      const permission = new aws8.lambda.Permission("permission", {
+      new aws8.lambda.Permission(group, "permission", {
         action: "lambda:InvokeFunction",
         principal: "iot.amazonaws.com",
         functionArn: lambda.arn,
         sourceArn: topic.arn
       });
-      group.add(topic, permission);
     }
   }
 });
@@ -3022,23 +2999,20 @@ var queueFeature = defineFeature({
   onStack(ctx) {
     for (const [id, local] of Object.entries(ctx.stackConfig.queues || {})) {
       const props = deepmerge2(ctx.appConfig.defaults.queue, local);
-      const group = new Node9("queue", id);
-      ctx.stack.add(group);
-      const queue2 = new aws9.sqs.Queue("queue", {
+      const group = new Node9(ctx.stack, "queue", id);
+      const queue2 = new aws9.sqs.Queue(group, "queue", {
         name: formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "queue", id),
         deadLetterArn: getGlobalOnFailure(ctx),
         ...props
       });
-      group.add(queue2);
       const { lambda, policy } = createLambdaFunction(group, ctx, `queue`, id, props.consumer);
-      const source = new aws9.lambda.EventSourceMapping("event", {
+      new aws9.lambda.EventSourceMapping(group, "event", {
         functionArn: lambda.arn,
         sourceArn: queue2.arn,
         batchSize: props.batchSize,
         maxBatchingWindow: props.maxBatchingWindow,
         maxConcurrency: props.maxConcurrency
       }).dependsOn(policy);
-      group.add(source);
       policy.addStatement({
         actions: ["sqs:ReceiveMessage", "sqs:DeleteMessage", "sqs:GetQueueAttributes"],
         resources: [queue2.arn]
@@ -3082,9 +3056,8 @@ var storeFeature = defineFeature({
   },
   onStack(ctx) {
     for (const id of ctx.stackConfig.stores || []) {
-      const group = new Node10("store", id);
-      ctx.stack.add(group);
-      const bucket = new aws10.s3.Bucket("store", {
+      const group = new Node10(ctx.stack, "store", id);
+      const bucket = new aws10.s3.Bucket(group, "store", {
         name: formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "store", id),
         cors: [
           // ---------------------------------------------
@@ -3097,7 +3070,6 @@ var storeFeature = defineFeature({
           // ---------------------------------------------
         ]
       });
-      group.add(bucket);
       ctx.onFunction(({ policy }) => {
         policy.addStatement(bucket.permissions);
       });
@@ -3125,17 +3097,15 @@ var tableFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.tables ?? {})) {
-      const group = new Node11("table", id);
-      ctx.stack.add(group);
-      const table2 = new aws11.dynamodb.Table("table", {
+      const group = new Node11(ctx.stack, "table", id);
+      const table2 = new aws11.dynamodb.Table(group, "table", {
         ...props,
         name: formatLocalResourceName(ctx.appConfig.name, ctx.stackConfig.name, "table", id),
         stream: props.stream?.type
       });
-      group.add(table2);
       if (props.stream) {
         const { lambda, policy } = createLambdaFunction(group, ctx, "table", id, props.stream.consumer);
-        const source = new aws11.lambda.EventSourceMapping(id, {
+        new aws11.lambda.EventSourceMapping(group, id, {
           functionArn: lambda.arn,
           sourceArn: table2.streamArn,
           batchSize: 100,
@@ -3145,7 +3115,6 @@ var tableFeature = defineFeature({
           startingPosition: "latest",
           onFailure: getGlobalOnFailure(ctx)
         });
-        group.add(source);
         policy.addStatement(table2.streamPermissions);
       }
       ctx.onFunction(({ policy }) => {
@@ -3203,13 +3172,11 @@ var topicFeature = defineFeature({
   onApp(ctx) {
     for (const stack of ctx.stackConfigs) {
       for (const id of stack.topics ?? []) {
-        const group = new Node12("topic", id);
-        ctx.base.add(group);
-        const topic = new aws12.sns.Topic("topic", {
+        const group = new Node12(ctx.base, "topic", id);
+        const topic = new aws12.sns.Topic(group, "topic", {
           name: formatGlobalResourceName(ctx.appConfig.name, "topic", id)
         });
-        group.add(topic);
-        ctx.base.export(`topic-${id}-arn`, topic.arn);
+        ctx.shared.set(`topic-${id}-arn`, topic.arn);
       }
     }
   },
@@ -3218,35 +3185,32 @@ var topicFeature = defineFeature({
       ctx.onFunction(({ policy }) => {
         policy.addStatement({
           actions: ["sns:Publish"],
-          resources: [ctx.app.import("base", `topic-${id}-arn`)]
+          resources: [ctx.shared.get(`topic-${id}-arn`)]
         });
       });
     }
     for (const [id, props] of Object.entries(ctx.stackConfig.subscribers ?? {})) {
-      const group = new Node12("topic", id);
-      ctx.stack.add(group);
-      const topicArn = ctx.app.import("base", `topic-${id}-arn`);
+      const group = new Node12(ctx.stack, "topic", id);
+      const topicArn = ctx.shared.get(`topic-${id}-arn`);
       if (typeof props === "string" && isEmail(props)) {
-        const subscription = new aws12.sns.Subscription(id, {
+        new aws12.sns.Subscription(group, id, {
           topicArn,
           protocol: "email",
           endpoint: props
         });
-        group.add(subscription);
       } else if (typeof props === "object") {
         const { lambda } = createLambdaFunction(group, ctx, `topic`, id, props);
-        const topic = new aws12.sns.Subscription(id, {
+        new aws12.sns.Subscription(group, id, {
           topicArn,
           protocol: "lambda",
           endpoint: lambda.arn
         });
-        const permission = new aws12.lambda.Permission(id, {
+        new aws12.lambda.Permission(group, id, {
           action: "lambda:InvokeFunction",
           principal: "sns.amazonaws.com",
           functionArn: lambda.arn,
           sourceArn: topicArn
         });
-        group.add(topic, permission);
       }
     }
   }
@@ -3257,37 +3221,35 @@ import { Node as Node13, all, aws as aws13 } from "@awsless/formation";
 var vpcFeature = defineFeature({
   name: "vpc",
   onApp(ctx) {
-    const vpc = new aws13.ec2.Vpc("vpc", {
+    const group = new Node13(ctx.base, "vpc", "main");
+    const vpc = new aws13.ec2.Vpc(group, "vpc", {
       name: ctx.app.name,
       cidrBlock: aws13.ec2.Peer.ipv4("10.0.0.0/16")
     });
-    const privateRouteTable = new aws13.ec2.RouteTable("private", {
+    const privateRouteTable = new aws13.ec2.RouteTable(group, "private", {
       vpcId: vpc.id,
       name: "private"
     });
-    const publicRouteTable = new aws13.ec2.RouteTable("public", {
+    const publicRouteTable = new aws13.ec2.RouteTable(group, "public", {
       vpcId: vpc.id,
       name: "public"
     });
-    const gateway = new aws13.ec2.InternetGateway("gateway");
-    const attachment = new aws13.ec2.VPCGatewayAttachment("attachment", {
+    const gateway = new aws13.ec2.InternetGateway(group, "gateway");
+    const attachment = new aws13.ec2.VPCGatewayAttachment(group, "attachment", {
       vpcId: vpc.id,
       internetGatewayId: gateway.id
     });
-    const route = new aws13.ec2.Route("route", {
+    new aws13.ec2.Route(group, "route", {
       gatewayId: gateway.id,
       routeTableId: publicRouteTable.id,
       destination: aws13.ec2.Peer.anyIpv4()
     });
-    ctx.base.export(
+    ctx.shared.set(
       "vpc-id",
       // Some resources require the internet gateway to be attached.
       all([vpc.id, attachment.internetGatewayId]).apply(([id]) => id)
     );
-    ctx.base.export("vpc-security-group-id", vpc.defaultSecurityGroup);
-    const group = new Node13("vpc", "main");
-    group.add(vpc, privateRouteTable, publicRouteTable, gateway, attachment, route);
-    ctx.base.add(group);
+    ctx.shared.set("vpc-security-group-id", vpc.defaultSecurityGroup);
     const zones = ["a", "b"];
     const tables = [privateRouteTable, publicRouteTable];
     let block = 0;
@@ -3295,17 +3257,16 @@ var vpcFeature = defineFeature({
       for (const i in zones) {
         const index = Number(i) + 1;
         const id = `${table2.identifier}-${index}`;
-        const subnet = new aws13.ec2.Subnet(id, {
+        const subnet = new aws13.ec2.Subnet(group, id, {
           vpcId: vpc.id,
           cidrBlock: aws13.ec2.Peer.ipv4(`10.0.${block++}.0/24`),
           availabilityZone: ctx.appConfig.region + zones[i]
         });
-        const association = new aws13.ec2.SubnetRouteTableAssociation(id, {
+        new aws13.ec2.SubnetRouteTableAssociation(group, id, {
           routeTableId: table2.id,
           subnetId: subnet.id
         });
-        ctx.base.export(`vpc-${table2.identifier}-subnet-id-${index}`, subnet.id);
-        group.add(subnet, association);
+        ctx.shared.set(`vpc-${table2.identifier}-subnet-id-${index}`, subnet.id);
       }
     }
   }
@@ -3320,7 +3281,7 @@ var authFeature = defineFeature({
     const gen = new TypeFile("@awsless/awsless");
     const resources = new TypeObject(1);
     for (const name of Object.keys(ctx.appConfig.defaults.auth)) {
-      const authName = formatGlobalResourceName(ctx.appConfig.name, this.name, name);
+      const authName = formatGlobalResourceName(ctx.appConfig.name, "auth", name);
       resources.addType(
         name,
         `{ readonly name: '${authName}', readonly userPoolId: string, readonly clientId: string }`
@@ -3331,16 +3292,14 @@ var authFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.auth ?? {})) {
-      const group = new Node14(this.name, id);
-      ctx.stack.add(group);
-      const userPoolId = ctx.app.import("base", `auth-${id}-user-pool-id`);
-      const userPoolArn = ctx.app.import("base", `auth-${id}-user-pool-arn`);
-      const clientId = ctx.app.import("base", `auth-${id}-client-id`);
+      const group = new Node14(ctx.stack, "auth", id);
+      const userPoolId = ctx.shared.get(`auth-${id}-user-pool-id`);
+      const userPoolArn = ctx.shared.get(`auth-${id}-user-pool-arn`);
+      const clientId = ctx.shared.get(`auth-${id}-client-id`);
       const triggers = {};
       const list4 = {};
       for (const [trigger, triggerProps] of Object.entries(props.triggers ?? {})) {
-        const triggerGroup = new Node14("trigger", trigger);
-        group.add(triggerGroup);
+        const triggerGroup = new Node14(group, "trigger", trigger);
         const { lambda, policy } = createLambdaFunction(
           triggerGroup,
           ctx,
@@ -3356,19 +3315,17 @@ var authFeature = defineFeature({
           policy
         };
       }
-      const lambdaTriggers = new aws14.cognito.LambdaTriggers("lambda-triggers", {
+      new aws14.cognito.LambdaTriggers(group, "lambda-triggers", {
         userPoolId,
         triggers
       });
-      group.add(lambdaTriggers);
       for (const item of Object.values(list4)) {
-        const permission = new aws14.lambda.Permission(`permission`, {
+        new aws14.lambda.Permission(item.group, `permission`, {
           action: "lambda:InvokeFunction",
           principal: "cognito-idp.amazonaws.com",
           functionArn: item.lambda.arn,
           sourceArn: userPoolArn
         });
-        item.group.add(permission);
         item.lambda.addEnvironment(`AUTH_${constantCase4(id)}_USER_POOL_ID`, userPoolId);
         item.lambda.addEnvironment(`AUTH_${constantCase4(id)}_CLIENT_ID`, clientId);
         item.policy.addStatement({
@@ -3389,21 +3346,20 @@ var authFeature = defineFeature({
   },
   onApp(ctx) {
     for (const [id, props] of Object.entries(ctx.appConfig.defaults.auth ?? {})) {
-      const group = new Node14(this.name, id);
-      ctx.base.add(group);
+      const group = new Node14(ctx.base, "auth", id);
       let emailConfig;
       if (props.messaging) {
         const [_, domainName] = props.messaging.fromEmail.split("@");
         emailConfig = {
           type: "developer",
           replyTo: props.messaging.replyTo,
-          sourceArn: ctx.base.import(`mail-${domainName}-arn`),
-          configurationSet: ctx.base.import("mail-configuration-set"),
+          sourceArn: ctx.shared.get(`mail-${domainName}-arn`),
+          configurationSet: ctx.shared.get("mail-configuration-set"),
           from: props.messaging.fromName ? `${props.messaging.fromName} <${props.messaging.fromEmail}>` : props.messaging.fromEmail
         };
       }
-      const name = formatGlobalResourceName(ctx.appConfig.name, this.name, id);
-      const userPool = new aws14.cognito.UserPool("user-pool", {
+      const name = formatGlobalResourceName(ctx.appConfig.name, "auth", id);
+      const userPool = new aws14.cognito.UserPool(group, "user-pool", {
         name,
         // deletionProtection: true,
         allowUserRegistration: props.allowUserRegistration,
@@ -3411,8 +3367,7 @@ var authFeature = defineFeature({
         password: props.password,
         email: emailConfig
       });
-      group.add(userPool);
-      const client = new aws14.cognito.UserPoolClient("client", {
+      const client = new aws14.cognito.UserPoolClient(group, "client", {
         userPoolId: userPool.id,
         name,
         validity: props.validity,
@@ -3421,10 +3376,9 @@ var authFeature = defineFeature({
           userSrp: true
         }
       });
-      group.add(client);
-      ctx.base.export(`auth-${id}-user-pool-arn`, userPool.arn);
-      ctx.base.export(`auth-${id}-user-pool-id`, userPool.id);
-      ctx.base.export(`auth-${id}-client-id`, client.id);
+      ctx.shared.set(`auth-${id}-user-pool-arn`, userPool.arn);
+      ctx.shared.set(`auth-${id}-user-pool-id`, userPool.id);
+      ctx.shared.set(`auth-${id}-client-id`, client.id);
     }
   }
 });
@@ -3513,32 +3467,32 @@ var httpFeature = defineFeature({
     if (Object.keys(ctx.appConfig.defaults?.http ?? {}).length === 0) {
       return;
     }
-    const group = new Node15("http", "main");
-    ctx.base.add(group);
-    const securityGroup = new aws15.ec2.SecurityGroup("http", {
-      vpcId: ctx.base.import(`vpc-id`),
+    const group = new Node15(ctx.base, "http", "main");
+    const securityGroup = new aws15.ec2.SecurityGroup(group, "http", {
+      vpcId: ctx.shared.get(`vpc-id`),
       name: formatGlobalResourceName(ctx.app.name, "http", "http"),
       description: `Global security group for HTTP api.`
     });
     const port = aws15.ec2.Port.tcp(443);
     securityGroup.addIngressRule({ port, peer: aws15.ec2.Peer.anyIpv4() });
     securityGroup.addIngressRule({ port, peer: aws15.ec2.Peer.anyIpv6() });
-    group.add(securityGroup);
     for (const [id, props] of Object.entries(ctx.appConfig.defaults?.http ?? {})) {
-      const group2 = new Node15("http", id);
-      ctx.base.add(group2);
-      const loadBalancer = new aws15.elb.LoadBalancer("balancer", {
+      const group2 = new Node15(ctx.base, "http", id);
+      const loadBalancer = new aws15.elb.LoadBalancer(group2, "balancer", {
         name: formatGlobalResourceName(ctx.app.name, "http", id),
         type: "application",
         securityGroups: [securityGroup.id],
-        subnets: [ctx.base.import(`vpc-public-subnet-id-1`), ctx.base.import(`vpc-public-subnet-id-2`)]
+        subnets: [
+          //
+          ctx.shared.get(`vpc-public-subnet-id-1`),
+          ctx.shared.get(`vpc-public-subnet-id-2`)
+        ]
       });
-      group2.add(loadBalancer);
-      const listener = new aws15.elb.Listener("listener", {
+      const listener = new aws15.elb.Listener(group2, "listener", {
         loadBalancerArn: loadBalancer.arn,
         port: 443,
         protocol: "https",
-        certificates: [ctx.base.import(`local-certificate-${props.domain}-arn`)],
+        certificates: [ctx.shared.get(`local-certificate-${props.domain}-arn`)],
         defaultActions: [
           aws15.elb.ListenerAction.fixedResponse({
             statusCode: 404,
@@ -3549,10 +3503,9 @@ var httpFeature = defineFeature({
           })
         ]
       });
-      group2.add(listener);
       const domainName = formatFullDomainName(ctx.appConfig, props.domain, props.subDomain);
-      const record = new aws15.route53.RecordSet(domainName, {
-        hostedZoneId: ctx.base.import(`hosted-zone-${props.domain}-id`),
+      new aws15.route53.RecordSet(group2, domainName, {
+        hostedZoneId: ctx.shared.get(`hosted-zone-${props.domain}-id`),
         name: domainName,
         type: "A",
         alias: {
@@ -3561,8 +3514,7 @@ var httpFeature = defineFeature({
           dnsName: loadBalancer.dnsName
         }
       });
-      group2.add(record);
-      ctx.base.export(`http-${id}-listener-arn`, listener.arn);
+      ctx.shared.set(`http-${id}-listener-arn`, listener.arn);
     }
   },
   onStack(ctx) {
@@ -3571,11 +3523,9 @@ var httpFeature = defineFeature({
       if (!props) {
         throw new Error(`Http definition is not defined on app level for "${id}"`);
       }
-      const group = new Node15("http", id);
-      ctx.stack.add(group);
+      const group = new Node15(ctx.stack, "http", id);
       for (const [routeKey, routeProps] of Object.entries(routes)) {
-        const routeGroup = new Node15("route", routeKey);
-        group.add(routeGroup);
+        const routeGroup = new Node15(group, "route", routeKey);
         const { method, path } = parseRoute(routeKey);
         const routeId = shortId(routeKey);
         const { lambda } = createLambdaFunction(routeGroup, ctx, "http", `${id}-${routeId}`, {
@@ -3583,21 +3533,19 @@ var httpFeature = defineFeature({
           description: routeKey
         });
         const name = formatLocalResourceName(ctx.app.name, ctx.stack.name, "http", routeId);
-        const permission = new aws15.lambda.Permission(id, {
+        const permission = new aws15.lambda.Permission(routeGroup, id, {
           action: "lambda:InvokeFunction",
           principal: "elasticloadbalancing.amazonaws.com",
           functionArn: lambda.arn
           // sourceArn: `arn:aws:elasticloadbalancing:${ctx.appConfig.region}:*:targetgroup/${name}/*`,
         });
-        routeGroup.add(permission);
-        const target = new aws15.elb.TargetGroup(id, {
+        const target = new aws15.elb.TargetGroup(routeGroup, id, {
           name,
           type: "lambda",
           targets: [lambda.arn]
         }).dependsOn(permission);
-        routeGroup.add(target);
-        const rule = new aws15.elb.ListenerRule(id, {
-          listenerArn: ctx.app.import("base", `http-${id}-listener-arn`),
+        new aws15.elb.ListenerRule(routeGroup, id, {
+          listenerArn: ctx.shared.get(`http-${id}-listener-arn`),
           priority: generatePriority(ctx.stackConfig.name, routeKey),
           conditions: [
             aws15.elb.ListenerCondition.httpRequestMethods([method]),
@@ -3605,7 +3553,6 @@ var httpFeature = defineFeature({
           ],
           actions: [aws15.elb.ListenerAction.forward([target.arn])]
         }).dependsOn(target);
-        routeGroup.add(rule);
       }
     }
   }
@@ -3631,9 +3578,8 @@ var searchFeature = defineFeature({
   },
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.searchs ?? {})) {
-      const group = new Node16("search", id);
-      ctx.stack.add(group);
-      const domain = new aws16.openSearch.Domain("domain", {
+      const group = new Node16(ctx.stack, "search", id);
+      const domain = new aws16.openSearch.Domain(group, "domain", {
         // name: formatLocalResourceName(ctx.app.name, ctx.stack.name, this.name, id),
         version: props.version,
         storageSize: props.storage,
@@ -3652,11 +3598,13 @@ var searchFeature = defineFeature({
       });
       if (props.vpc) {
         domain.setVpc({
-          securityGroupIds: [ctx.app.import("base", `vpc-security-group-id`)],
-          subnetIds: [ctx.app.import("base", "vpc-private-subnet-id-1")]
+          securityGroupIds: [ctx.shared.get(`vpc-security-group-id`)],
+          subnetIds: [
+            ctx.shared.get("vpc-private-subnet-id-1"),
+            ctx.shared.get("vpc-private-subnet-id-2")
+          ]
         });
       }
-      group.add(domain);
       ctx.onFunction(({ policy }) => {
         policy.addStatement({
           actions: ["es:*"],
@@ -3698,8 +3646,7 @@ var siteFeature = defineFeature({
   name: "site",
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.sites ?? {})) {
-      const group = new Node17("site", id);
-      ctx.stack.add(group);
+      const group = new Node17(ctx.stack, "site", id);
       const name = formatLocalResourceName(ctx.app.name, ctx.stack.name, "site", id);
       const origins = [];
       const originGroups = [];
@@ -3708,7 +3655,7 @@ var siteFeature = defineFeature({
       if (props.ssr) {
         const { lambda, code } = createLambdaFunction(group, ctx, `site`, id, props.ssr);
         versions.push(code.version);
-        const permissions = new aws17.lambda.Permission("permission", {
+        new aws17.lambda.Permission(group, "permission", {
           principal: "*",
           // principal: 'cloudfront.amazonaws.com',
           action: "lambda:InvokeFunctionUrl",
@@ -3717,13 +3664,11 @@ var siteFeature = defineFeature({
           // urlAuthType: 'aws-iam',
           // sourceArn: distribution.arn,
         });
-        group.add(permissions);
-        const url = new aws17.lambda.Url("url", {
+        const url = new aws17.lambda.Url(group, "url", {
           targetArn: lambda.arn,
           authType: "none"
           // authType: 'aws-iam',
         });
-        group.add(url);
         origins.push({
           id: "ssr",
           domainName: url.url.apply((url2) => url2.split("/")[2]),
@@ -3731,7 +3676,7 @@ var siteFeature = defineFeature({
         });
       }
       if (props.static) {
-        bucket = new aws17.s3.Bucket("bucket", {
+        bucket = new aws17.s3.Bucket(group, "bucket", {
           name,
           forceDelete: true,
           website: {
@@ -3748,28 +3693,25 @@ var siteFeature = defineFeature({
           ]
         });
         bucket.deletionPolicy = "after-deployment";
-        group.add(bucket);
-        const accessControl = new aws17.cloudFront.OriginAccessControl(`access`, {
+        const accessControl = new aws17.cloudFront.OriginAccessControl(group, `access`, {
           name,
           type: "s3",
           behavior: "always",
           protocol: "sigv4"
         });
         accessControl.deletionPolicy = "after-deployment";
-        group.add(accessControl);
         const files = glob2.sync("**", {
           cwd: props.static,
           nodir: true
         });
         for (const file of files) {
-          const object = new aws17.s3.BucketObject(file, {
+          const object = new aws17.s3.BucketObject(group, file, {
             bucket: bucket.name,
             key: file,
             body: Asset3.fromFile(join8(props.static, file)),
             cacheControl: getCacheControl(file),
             contentType: getContentType(file)
           });
-          group.add(object);
           versions.push(object.key);
           versions.push(object.etag);
         }
@@ -3786,24 +3728,22 @@ var siteFeature = defineFeature({
           statusCodes: [403, 404]
         });
       }
-      const cache = new aws17.cloudFront.CachePolicy("cache", {
+      const cache = new aws17.cloudFront.CachePolicy(group, "cache", {
         name,
         minTtl: seconds3(1),
         maxTtl: days3(365),
         defaultTtl: days3(1),
         ...props.cache
       });
-      group.add(cache);
-      const originRequest = new aws17.cloudFront.OriginRequestPolicy("request", {
+      const originRequest = new aws17.cloudFront.OriginRequestPolicy(group, "request", {
         name,
         header: {
           behavior: "all-except",
           values: ["host", "authorization"]
         }
       });
-      group.add(originRequest);
       const domainName = formatFullDomainName(ctx.appConfig, props.domain, props.subDomain);
-      const responseHeaders = new aws17.cloudFront.ResponseHeadersPolicy("response", {
+      const responseHeaders = new aws17.cloudFront.ResponseHeadersPolicy(group, "response", {
         name,
         cors: props.cors,
         remove: ["server"]
@@ -3811,10 +3751,9 @@ var siteFeature = defineFeature({
         // 	override: true,
         // },
       });
-      group.add(responseHeaders);
-      const distribution = new aws17.cloudFront.Distribution("distribution", {
+      const distribution = new aws17.cloudFront.Distribution(group, "distribution", {
         name,
-        certificateArn: ctx.app.import("base", `global-certificate-${props.domain}-arn`),
+        certificateArn: ctx.shared.get(`global-certificate-${props.domain}-arn`),
         compress: true,
         aliases: [domainName],
         origins,
@@ -3840,15 +3779,13 @@ var siteFeature = defineFeature({
           };
         })
       });
-      group.add(distribution);
-      const invalidate = new aws17.cloudFront.InvalidateCache("invalidate", {
+      new aws17.cloudFront.InvalidateCache(group, "invalidate", {
         distributionId: distribution.id,
         paths: ["/*"],
         versions
       });
-      group.add(invalidate);
       if (props.static) {
-        const bucketPolicy = new aws17.s3.BucketPolicy(`policy`, {
+        new aws17.s3.BucketPolicy(group, `policy`, {
           bucketName: bucket.name,
           statements: [
             {
@@ -3873,10 +3810,9 @@ var siteFeature = defineFeature({
             // }
           ]
         });
-        group.add(bucketPolicy);
       }
-      const record = new aws17.route53.RecordSet(`record`, {
-        hostedZoneId: ctx.app.import("base", `hosted-zone-${props.domain}-id`),
+      new aws17.route53.RecordSet(group, `record`, {
+        hostedZoneId: ctx.shared.get(`hosted-zone-${props.domain}-id`),
         type: "A",
         name: domainName,
         alias: {
@@ -3885,7 +3821,6 @@ var siteFeature = defineFeature({
           evaluateTargetHealth: false
         }
       });
-      group.add(record);
     }
   }
 });
@@ -3915,6 +3850,18 @@ var features = [
   siteFeature
 ];
 
+// src/shared.ts
+var SharedData = class {
+  data = {};
+  get(key) {
+    return this.data[key];
+  }
+  set(key, value) {
+    this.data[key] = value;
+    return this;
+  }
+};
+
 // src/app.ts
 var getFiltersWithDeps = (stacks, filters) => {
   const list4 = [];
@@ -3936,7 +3883,8 @@ var getFiltersWithDeps = (stacks, filters) => {
 };
 var createApp = (props, filters = []) => {
   const app = new App(props.appConfig.name);
-  const base = new Stack("base");
+  const base = new Stack(app, "base");
+  const shared = new SharedData();
   const tests = [];
   const builders = [];
   const allFunctions = [];
@@ -3946,6 +3894,7 @@ var createApp = (props, filters = []) => {
       ...props,
       app,
       base,
+      shared,
       onFunction(callback) {
         globalListeners.push(callback);
       },
@@ -3968,8 +3917,7 @@ var createApp = (props, filters = []) => {
   for (const stackConfig of filterdStacks) {
     const localListeners = [];
     const localFunctions = [];
-    const stack = new Stack(stackConfig.name);
-    app.add(stack);
+    const stack = new Stack(app, stackConfig.name);
     for (const feature of features) {
       feature.onStack?.({
         ...props,
@@ -3977,6 +3925,7 @@ var createApp = (props, filters = []) => {
         app,
         base,
         stack,
+        shared,
         onFunction(callback) {
           localListeners.push(callback);
         },
@@ -3998,9 +3947,6 @@ var createApp = (props, filters = []) => {
       }
     }
   }
-  if (base.resources.length > 0) {
-    app.add(base);
-  }
   for (const listener of globalListeners) {
     for (const fn of allFunctions) {
       listener(fn);
@@ -4133,7 +4079,7 @@ var del = (program2) => {
 };
 
 // src/cli/command/config/list.ts
-import { log as log6, spinner as spinner5 } from "@clack/prompts";
+import { log as log7, spinner as spinner5 } from "@clack/prompts";
 import chalk5 from "chalk";
 var list2 = (program2) => {
   program2.command("list").description(`List all config value's`).action(async () => {
@@ -4155,7 +4101,7 @@ var list2 = (program2) => {
           })
         );
       } else {
-        log6.warning("No config parameters found.");
+        log7.warning("No config parameters found.");
       }
     });
   });
@@ -4175,7 +4121,7 @@ var config = (program2) => {
 };
 
 // src/cli/command/delete.ts
-import { confirm as confirm3, spinner as spinner6 } from "@clack/prompts";
+import { confirm as confirm3 } from "@clack/prompts";
 import { WorkSpace, aws as aws18 } from "@awsless/formation";
 import { minutes as minutes4 } from "@awsless/duration";
 var del2 = (program2) => {
@@ -4201,7 +4147,7 @@ var del2 = (program2) => {
         }
       }
       const workspace = new WorkSpace({
-        stateProvider: new aws18.dynamodb.DynamoDBStateProvider({
+        stateProvider: new aws18.dynamodb.StateProvider({
           credentials,
           region,
           tableName: "awsless-state"
@@ -4212,18 +4158,11 @@ var del2 = (program2) => {
           timeout: minutes4(30)
         })
       });
-      for (const stack of app.stacks) {
-        const spin = spinner6();
-        spin.start(`Deleting the ${color.info(stack.name)} stack from AWS`);
-        try {
-          await workspace.deleteStack(stack);
-        } catch (error) {
-          debugError(error);
-          spin.stop("Failed.", 2);
-          throw error;
-        }
-        spin.stop(`Done deleting the ${color.info(stack.name)} stack from AWS`);
-      }
+      await task("Deleting the stacks to AWS", async (update) => {
+        await workspace.deleteApp(app);
+        update("Done deleting the stacks to AWS.");
+      });
+      return "Your app has been deleted!";
     });
   });
 };
@@ -4231,7 +4170,6 @@ var del2 = (program2) => {
 // src/cli/command/deploy.ts
 import { WorkSpace as WorkSpace2, aws as aws19 } from "@awsless/formation";
 import { confirm as confirm4 } from "@clack/prompts";
-import { run } from "promise-dag";
 
 // src/cli/ui/complex/run-tests.ts
 import { join as join9 } from "path";
@@ -4292,14 +4230,14 @@ var CustomReporter = class {
       this.cache = cache;
     }
   }
-  onUserConsoleLog(log9) {
-    if (log9.taskId) {
-      const test2 = this.ctx?.state.idMap.get(log9.taskId);
+  onUserConsoleLog(log10) {
+    if (log10.taskId) {
+      const test2 = this.ctx?.state.idMap.get(log10.taskId);
       if (test2) {
         test2.name;
       }
     }
-    this.logs.push(log9.content.trimEnd());
+    this.logs.push(log10.content.trimEnd());
   }
   runningTask(tasks) {
     return tasks.find((t) => t.result?.state === "run");
@@ -4363,7 +4301,7 @@ var startTest = async (props) => {
 };
 
 // src/cli/ui/complex/run-tests.ts
-import { log as log7 } from "@clack/prompts";
+import { log as log8 } from "@clack/prompts";
 import chalk6 from "chalk";
 var formatResult = (props) => {
   const line = [`Test ${chalk6.magenta(props.stack)}`];
@@ -4380,10 +4318,10 @@ var formatResult = (props) => {
 };
 var logTestLogs = (event) => {
   if (event.logs.length > 0) {
-    log7.message(color.info.bold.inverse(" LOGS "), {
+    log8.message(color.info.bold.inverse(" LOGS "), {
       symbol: color.dim(icon.dot)
     });
-    log7.message(event.logs.map((log9) => wrap(log9, { hard: true })).join("\n"));
+    log8.message(event.logs.map((log10) => wrap(log10, { hard: true })).join("\n"));
   }
 };
 var logTestErrors = (event) => {
@@ -4394,7 +4332,7 @@ var logTestErrors = (event) => {
       message,
       comment.length > 0 ? color.dim(`//${comment}`) : ""
     ].join(" ");
-    log7.message(
+    log8.message(
       [
         //
         color.error.inverse.bold(` FAIL `),
@@ -4427,7 +4365,7 @@ var runTest = async (stack, dir, filters) => {
     const raw = await readFile6(file, { encoding: "utf8" });
     const data = JSON.parse(raw);
     if (data.fingerprint === fingerprint) {
-      log7.step(
+      log8.step(
         formatResult({
           stack,
           cached: true,
@@ -4515,7 +4453,7 @@ var deploy = (program2) => {
       }
       await buildAssets(builders);
       const workspace = new WorkSpace2({
-        stateProvider: new aws19.dynamodb.DynamoDBStateProvider({
+        stateProvider: new aws19.dynamodb.StateProvider({
           credentials,
           region,
           tableName: "awsless-state"
@@ -4526,26 +4464,8 @@ var deploy = (program2) => {
           timeout: minutes5(60)
         })
       });
-      const graph = {};
-      for (const stack of app.stacks) {
-        const deps = [];
-        if (stack.name !== "base") {
-          deps.push("base");
-        }
-        graph[stack.name] = [
-          ...deps,
-          async () => {
-            await workspace.deployStack(stack);
-          }
-        ];
-      }
       await task("Deploying the stacks to AWS", async (update) => {
-        const results = await Promise.allSettled(Object.values(run(graph)));
-        for (const result of results) {
-          if (result.status === "rejected") {
-            throw result.reason;
-          }
-        }
+        await workspace.deployApp(app);
         update("Done deploying the stacks to AWS.");
       });
       return "Your app is ready!";
@@ -4623,7 +4543,7 @@ var diff = (program2) => {
 };
 
 // src/cli/ui/complex/build-types.ts
-import { log as log8 } from "@clack/prompts";
+import { log as log9 } from "@clack/prompts";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
@@ -4657,7 +4577,7 @@ var generateTypes = async (props) => {
 // src/cli/ui/complex/build-types.ts
 var buildTypes = async (props) => {
   await generateTypes(props);
-  log8.step("Done generating type definition files.");
+  log9.step("Done generating type definition files.");
 };
 
 // src/cli/command/types.ts