@awsless/awsless 0.0.8 → 0.0.9

package/dist/bin.cjs

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 
 // src/app.ts
-var import_aws_cdk_lib6 = require("aws-cdk-lib");
+var import_aws_cdk_lib7 = require("aws-cdk-lib");
 
 // src/stack.ts
 var import_aws_cdk_lib = require("aws-cdk-lib");
@@ -215,6 +215,8 @@ var toStack = ({ config: config2, assets, app, stackConfig, plugins }) => {
   functions.forEach((lambda) => lambda.addToRolePolicy(allowConfigParameters));
   return {
     stack,
+    functions,
+    bindings,
     depends: stackConfig.depends
   };
 };
@@ -224,10 +226,11 @@ var import_path = require("path");
 var rootDir = process.cwd();
 var outDir = (0, import_path.join)(rootDir, ".awsless");
 var assemblyDir = (0, import_path.join)(outDir, "assembly");
-var functionDir = (0, import_path.join)(outDir, "function");
+var assetDir = (0, import_path.join)(outDir, "asset");
+var cacheDir = (0, import_path.join)(outDir, "cache");
 
 // src/stack/app-bootstrap.ts
-var import_aws_cdk_lib5 = require("aws-cdk-lib");
+var import_aws_cdk_lib6 = require("aws-cdk-lib");
 
 // src/plugin.ts
 var definePlugin = (plugin) => plugin;
@@ -280,7 +283,7 @@ var toName = (stack, id) => {
   return (0, import_change_case.paramCase)(`${stack.stackName}-${id}`);
 };
 var toEnvKey = (resource, id) => {
-  return (0, import_change_case.constantCase)(`RESOURCE_${resource}_${id}`);
+  return `RESOURCE_${resource.toUpperCase()}_${id}`;
 };
 var addResourceEnvironment = (stack, resource, id, lambda) => {
   const key = toEnvKey(resource, id);
@@ -379,76 +382,54 @@ var SizeSchema = import_zod7.z.custom((value) => {
   return import_zod7.z.string().regex(/[0-9]+ (KB|MB|GB)/).safeParse(value).success;
 }, "Invalid size").transform(toSize);
 
-// src/plugins/function/util/build-worker.ts
-var import_worker_threads = require("worker_threads");
-var cjs = typeof require !== "undefined";
-var importESM = `
-import { bundle } from "@awsless/code";
-import { createHash } from "crypto";
-import { parentPort, workerData } from "worker_threads";
-`;
-var importCJS = `
-const { bundle } = require("@awsless/code");
-const { createHash } = require("crypto");
-const { parentPort, workerData } = require("worker_threads");
-`;
-var workerCode = `
-${cjs ? importCJS : importESM}
-
-const build = async (file) => {
-	const { code, map } = await bundle(file, {
-		format: 'esm',
-		sourceMap: true,
-		minimize: true,
-		onwarn: () => {},
-		moduleSideEffects: (id) => file === id,
-		external: (importee) => (
-			importee.startsWith('aws-sdk') ||
-			importee.startsWith('@aws-sdk')
-		),
-	})
-
-	const hash = createHash('sha1').update(code).digest('hex')
-
-    parentPort.postMessage(JSON.stringify({
-		handler: 'index.default',
-		hash,
-		files: [
-			{ name: 'index.js', code, map: map?.toString() }
-		]
-	}))
-}
-
-build(workerData)
-`;
+// src/plugins/function/util/esbuild.ts
+var import_esbuild = require("esbuild");
+var import_crypto = require("crypto");
+var import_path3 = require("path");
+var import_promises2 = require("fs/promises");
 var defaultBuild = async (file) => {
-  return new Promise((resolve, reject) => {
-    const worker = new import_worker_threads.Worker(workerCode, { workerData: file, eval: true });
-    const cleanUp2 = () => {
-      worker.removeAllListeners();
-      worker.terminate();
-    };
-    worker.on("message", (data) => {
-      resolve(JSON.parse(data.toString("utf8")));
-      cleanUp2();
-    });
-    worker.on("error", (data) => {
-      reject(data);
-      cleanUp2();
-    });
-    worker.on("exit", (code) => {
-      if (code !== 0) {
-        reject(new Error(`Worker exited with code ${code}`));
-        cleanUp2();
-      }
-    });
+  const random = (0, import_crypto.randomUUID)();
+  const codeFile = (0, import_path3.join)(cacheDir, `${random}.mjs`);
+  const mapFile = (0, import_path3.join)(cacheDir, `${random}.mjs.map`);
+  await (0, import_esbuild.build)({
+    entryPoints: [file],
+    minify: true,
+    bundle: true,
+    external: [
+      "@aws-sdk/*",
+      "@aws-sdk",
+      "aws-sdk"
+    ],
+    sourcemap: "external",
+    target: "esnext",
+    treeShaking: true,
+    // jsxSideEffects:
+    format: "esm",
+    platform: "node",
+    outfile: codeFile
   });
+  const code = await (0, import_promises2.readFile)(codeFile, "utf8");
+  const map = await (0, import_promises2.readFile)(mapFile, "utf8");
+  await (0, import_promises2.rm)(codeFile);
+  await (0, import_promises2.rm)(mapFile);
+  const hash = (0, import_crypto.createHash)("sha1").update(code).digest("hex");
+  return {
+    handler: "index.default",
+    hash,
+    files: [
+      {
+        name: "index.mjs",
+        code,
+        map
+      }
+    ]
+  };
 };
 
 // src/plugins/function/util/build.ts
 var import_jszip = __toESM(require("jszip"), 1);
-var import_path3 = require("path");
-var import_promises2 = require("fs/promises");
+var import_path5 = require("path");
+var import_promises3 = require("fs/promises");
 var import_filesize = require("filesize");
 var zipFiles = (files) => {
   const zip = new import_jszip.default();
@@ -464,25 +445,25 @@ var zipFiles = (files) => {
   });
 };
 var writeBuildHash = async (config2, stack, id, hash) => {
-  const funcPath = (0, import_path3.join)(functionDir, config2.name, stack.artifactId, id);
-  const versionFile = (0, import_path3.join)(funcPath, "HASH");
-  await (0, import_promises2.writeFile)(versionFile, hash);
+  const funcPath = (0, import_path5.join)(assetDir, "function", config2.name, stack.artifactId, id);
+  const versionFile = (0, import_path5.join)(funcPath, "HASH");
+  await (0, import_promises3.writeFile)(versionFile, hash);
 };
 var writeBuildFiles = async (config2, stack, id, files) => {
   const bundle = await zipFiles(files);
-  const funcPath = (0, import_path3.join)(functionDir, config2.name, stack.artifactId, id);
-  const filesPath = (0, import_path3.join)(funcPath, "files");
-  const bundleFile = (0, import_path3.join)(funcPath, "bundle.zip");
-  debug("Bundle size of", style.info((0, import_path3.join)(config2.name, stack.artifactId, id)), "is", style.attr((0, import_filesize.filesize)(bundle.byteLength)));
-  await (0, import_promises2.mkdir)(filesPath, { recursive: true });
-  await (0, import_promises2.writeFile)(bundleFile, bundle);
+  const funcPath = (0, import_path5.join)(assetDir, "function", config2.name, stack.artifactId, id);
+  const filesPath = (0, import_path5.join)(funcPath, "files");
+  const bundleFile = (0, import_path5.join)(funcPath, "bundle.zip");
+  debug("Bundle size of", style.info((0, import_path5.join)(config2.name, stack.artifactId, id)), "is", style.attr((0, import_filesize.filesize)(bundle.byteLength)));
+  await (0, import_promises3.mkdir)(filesPath, { recursive: true });
+  await (0, import_promises3.writeFile)(bundleFile, bundle);
   await Promise.all(files.map(async (file) => {
-    const fileName = (0, import_path3.join)(filesPath, file.name);
-    await (0, import_promises2.mkdir)((0, import_path3.basename)(fileName), { recursive: true });
-    await (0, import_promises2.writeFile)(fileName, file.code);
+    const fileName = (0, import_path5.join)(filesPath, file.name);
+    await (0, import_promises3.mkdir)((0, import_path5.basename)(fileName), { recursive: true });
+    await (0, import_promises3.writeFile)(fileName, file.code);
     if (file.map) {
-      const mapName = (0, import_path3.join)(filesPath, `${file.name}.map`);
-      await (0, import_promises2.writeFile)(mapName, file.map);
+      const mapName = (0, import_path5.join)(filesPath, `${file.name}.map`);
+      await (0, import_promises3.writeFile)(mapName, file.map);
     }
   }));
   return {
@@ -492,8 +473,8 @@ var writeBuildFiles = async (config2, stack, id, files) => {
 };
 
 // src/plugins/function/util/publish.ts
-var import_path5 = require("path");
-var import_promises3 = require("fs/promises");
+var import_path7 = require("path");
+var import_promises4 = require("fs/promises");
 var import_client_s3 = require("@aws-sdk/client-s3");
 
 // src/stack/bootstrap.ts
@@ -533,11 +514,11 @@ var shouldDeployBootstrap = async (client, name) => {
 var publishFunctionAsset = async (config2, stack, id) => {
   const bucket = assetBucketName(config2);
   const key = `${config2.name}/${stack.artifactId}/function/${id}.zip`;
-  const funcPath = (0, import_path5.join)(functionDir, config2.name, stack.artifactId, id);
-  const bundleFile = (0, import_path5.join)(funcPath, "bundle.zip");
-  const hashFile = (0, import_path5.join)(funcPath, "HASH");
-  const hash = await (0, import_promises3.readFile)(hashFile, "utf8");
-  const file = await (0, import_promises3.readFile)(bundleFile);
+  const funcPath = (0, import_path7.join)(assetDir, "function", config2.name, stack.artifactId, id);
+  const bundleFile = (0, import_path7.join)(funcPath, "bundle.zip");
+  const hashFile = (0, import_path7.join)(funcPath, "HASH");
+  const hash = await (0, import_promises4.readFile)(hashFile, "utf8");
+  const file = await (0, import_promises4.readFile)(bundleFile);
   const client = new import_client_s3.S3Client({
     credentials: config2.credentials,
     region: config2.region
@@ -623,7 +604,7 @@ var functionPlugin = definePlugin({
     });
   }
 });
-var toFunction = ({ config: config2, stack, stackConfig, assets }, id, fileOrProps) => {
+var toFunction = ({ config: config2, stack, assets }, id, fileOrProps) => {
   const props = typeof fileOrProps === "string" ? { ...config2.defaults?.function, file: fileOrProps } : { ...config2.defaults?.function, ...fileOrProps };
   const lambda = new import_aws_lambda3.Function(stack, toId("function", id), {
     functionName: toName(stack, id),
@@ -634,14 +615,14 @@ var toFunction = ({ config: config2, stack, stackConfig, assets }, id, fileOrPro
   });
   lambda.addEnvironment("APP", config2.name, { removeInEdge: true });
   lambda.addEnvironment("STAGE", config2.stage, { removeInEdge: true });
-  lambda.addEnvironment("STACK", stackConfig.name, { removeInEdge: true });
+  lambda.addEnvironment("STACK", stack.artifactId, { removeInEdge: true });
   if (lambda.runtime.toString().startsWith("nodejs")) {
     lambda.addEnvironment("AWS_NODEJS_CONNECTION_REUSE_ENABLED", "1", {
       removeInEdge: true
     });
   }
   assets.add({
-    stack: stackConfig,
+    stackName: stack.artifactId,
     resource: "function",
     resourceName: id,
     async build() {
@@ -887,7 +868,6 @@ var import_zod18 = require("zod");
 var import_aws_sns = require("aws-cdk-lib/aws-sns");
 var import_aws_lambda_event_sources2 = require("aws-cdk-lib/aws-lambda-event-sources");
 var import_aws_cdk_lib4 = require("aws-cdk-lib");
-var import_aws_iam2 = require("aws-cdk-lib/aws-iam");
 var topicPlugin = definePlugin({
   name: "topic",
   schema: import_zod18.z.object({
@@ -909,12 +889,6 @@ var topicPlugin = definePlugin({
   },
   onStack(ctx) {
     const { config: config2, stack, stackConfig, bind } = ctx;
-    bind((lambda) => {
-      lambda.addToRolePolicy(new import_aws_iam2.PolicyStatement({
-        actions: ["sns:publish"],
-        resources: ["*"]
-      }));
-    });
     return Object.entries(stackConfig.topics || {}).map(([id, props]) => {
       const lambda = toFunction(ctx, id, props);
       const topic = import_aws_sns.Topic.fromTopicArn(
@@ -927,6 +901,10 @@ var topicPlugin = definePlugin({
         }, stack)
       );
       lambda.addEventSource(new import_aws_lambda_event_sources2.SnsEventSource(topic));
+      bind((lambda2) => {
+        addResourceEnvironment(stack, "topic", id, lambda2);
+        topic.grantPublish(lambda2);
+      });
       return lambda;
     });
   }
@@ -935,7 +913,7 @@ var topicPlugin = definePlugin({
 // src/plugins/search.ts
 var import_zod19 = require("zod");
 var import_aws_opensearchserverless = require("aws-cdk-lib/aws-opensearchserverless");
-var import_aws_iam3 = require("aws-cdk-lib/aws-iam");
+var import_aws_iam2 = require("aws-cdk-lib/aws-iam");
 var searchPlugin = definePlugin({
   name: "search",
   schema: import_zod19.z.object({
@@ -950,7 +928,7 @@ var searchPlugin = definePlugin({
         type: "SEARCH"
       });
       bind((lambda) => {
-        lambda.addToRolePolicy(new import_aws_iam3.PolicyStatement({
+        lambda.addToRolePolicy(new import_aws_iam2.PolicyStatement({
           actions: ["aoss:APIAccessAll"],
           resources: [collection.attrArn]
         }));
@@ -959,6 +937,138 @@ var searchPlugin = definePlugin({
   }
 });
 
+// src/plugins/graphql/index.ts
+var import_zod21 = require("zod");
+var import_aws_appsync = require("aws-cdk-lib/aws-appsync");
+var import_merge = require("@graphql-tools/merge");
+var import_promises5 = require("fs/promises");
+
+// src/util/array.ts
+var toArray = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return [value];
+};
+
+// src/plugins/graphql/index.ts
+var import_path8 = require("path");
+var import_graphql = require("graphql");
+var import_change_case2 = require("change-case");
+
+// src/plugins/graphql/schema/resolver-field.ts
+var import_zod20 = require("zod");
+var ResolverFieldSchema = import_zod20.z.custom((value) => {
+  return import_zod20.z.string().regex(/([a-z0-9\_]+)(\s){1}([a-z0-9\_]+)/gi).safeParse(value).success;
+}, `Invalid resolver field. Valid example: "Query list"`);
+
+// src/plugins/graphql/index.ts
+var import_aws_cdk_lib5 = require("aws-cdk-lib");
+var graphqlPlugin = definePlugin({
+  name: "graphql",
+  schema: import_zod21.z.object({
+    defaults: import_zod21.z.object({
+      graphql: import_zod21.z.record(ResourceIdSchema, import_zod21.z.object({
+        authorization: import_zod21.z.object({
+          authorizer: FunctionSchema,
+          ttl: DurationSchema.default("1 hour")
+        }).optional(),
+        mappingTemplate: import_zod21.z.object({
+          request: LocalFileSchema.optional(),
+          response: LocalFileSchema.optional()
+        }).optional()
+      })).optional()
+    }).default({}),
+    stacks: import_zod21.z.object({
+      graphql: import_zod21.z.record(ResourceIdSchema, import_zod21.z.object({
+        schema: import_zod21.z.union([
+          LocalFileSchema,
+          import_zod21.z.array(LocalFileSchema).min(1)
+        ]).optional(),
+        resolvers: import_zod21.z.record(ResolverFieldSchema, FunctionSchema).optional()
+      })).optional()
+    }).array()
+  }),
+  onBootstrap({ config: config2, stack, assets }) {
+    const list3 = /* @__PURE__ */ new Set();
+    Object.values(config2.stacks).forEach((stackConfig) => {
+      Object.keys(stackConfig.graphql || {}).forEach((id) => {
+        list3.add(id);
+      });
+    });
+    list3.forEach((id) => {
+      const file = (0, import_path8.join)(assetDir, "graphql", config2.name, id, "schema.graphql");
+      const authorization = config2.defaults.graphql?.[id]?.authorization;
+      const authProps = {};
+      if (authorization) {
+        const authorizer = toFunction({ config: config2, assets, stack }, `${id}-authorizer`, authorization.authorizer);
+        authProps.additionalAuthenticationProviders = [{
+          authenticationType: import_aws_appsync.AuthorizationType.LAMBDA,
+          lambdaAuthorizerConfig: {
+            authorizerUri: authorizer.functionArn,
+            authorizerResultTtlInSeconds: authorization.ttl.toSeconds()
+          }
+        }];
+      }
+      const api = new import_aws_appsync.CfnGraphQLApi(stack, toId("graphql", id), {
+        ...authProps,
+        name: toName(stack, id),
+        authenticationType: import_aws_appsync.AuthorizationType.API_KEY
+      });
+      new import_aws_cdk_lib5.CfnOutput(stack, toId("output", id), {
+        exportName: toId("graphql", id),
+        value: api.attrApiId
+      });
+      assets.add({
+        stackName: stack.artifactId,
+        resource: "schema",
+        resourceName: id,
+        async build() {
+          const schemas = [];
+          await Promise.all(Object.values(config2.stacks).map(async (stackConfig) => {
+            const schemaFiles = toArray(stackConfig.graphql?.[id].schema || []);
+            await Promise.all(schemaFiles.map(async (schemaFile) => {
+              const schema3 = await (0, import_promises5.readFile)(schemaFile, "utf8");
+              schemas.push(schema3);
+            }));
+          }));
+          const schema2 = (0, import_graphql.print)((0, import_merge.mergeTypeDefs)(schemas));
+          await (0, import_promises5.mkdir)((0, import_path8.dirname)(file), { recursive: true });
+          await (0, import_promises5.writeFile)(file, schema2);
+          new import_aws_appsync.CfnGraphQLSchema(stack, toId("schema", id), {
+            apiId: api.attrApiId,
+            definition: schema2
+          });
+        }
+      });
+    });
+  },
+  onStack(ctx) {
+    const { config: config2, stack, stackConfig } = ctx;
+    return Object.entries(stackConfig.graphql || {}).map(([id, props]) => {
+      const defaults = config2.defaults.graphql?.[id] || {};
+      return Object.entries(props.resolvers || {}).map(([typeAndField, functionProps]) => {
+        const api = import_aws_appsync.GraphqlApi.fromGraphqlApiAttributes(stack, toId("graphql", id), {
+          graphqlApiId: import_aws_cdk_lib5.Fn.importValue(toId("graphql", id))
+        });
+        const [typeName, fieldName] = typeAndField.split(/[\s]+/g);
+        const functionId = (0, import_change_case2.paramCase)(`${id}-${typeName}-${fieldName}`);
+        const lambda = toFunction(ctx, functionId, functionProps);
+        const source = api.addLambdaDataSource(toId("data-source", functionId), lambda, {
+          name: toId("data-source", functionId)
+        });
+        source.createResolver(toId("resolver", functionId), {
+          typeName,
+          fieldName,
+          requestMappingTemplate: defaults.mappingTemplate?.request ? import_aws_appsync.MappingTemplate.fromFile(defaults.mappingTemplate.request) : import_aws_appsync.MappingTemplate.lambdaRequest(),
+          responseMappingTemplate: defaults.mappingTemplate?.response ? import_aws_appsync.MappingTemplate.fromFile(defaults.mappingTemplate.response) : import_aws_appsync.MappingTemplate.lambdaResult()
+        });
+        return lambda;
+      });
+    }).flat();
+  }
+});
+
 // src/plugins/index.ts
 var defaultPlugins = [
   functionPlugin,
@@ -967,12 +1077,13 @@ var defaultPlugins = [
   tablePlugin,
   storePlugin,
   topicPlugin,
-  searchPlugin
+  searchPlugin,
+  graphqlPlugin
 ];
 
 // src/stack/app-bootstrap.ts
 var appBootstrapStack = ({ config: config2, app, assets }) => {
-  const stack = new import_aws_cdk_lib5.Stack(app, "bootstrap", {
+  const stack = new import_aws_cdk_lib6.Stack(app, "bootstrap", {
     stackName: `${config2.name}-bootstrap`
   });
   const plugins = [
@@ -980,8 +1091,16 @@ var appBootstrapStack = ({ config: config2, app, assets }) => {
     ...config2.plugins || []
   ];
   debug("Run plugin onBootstrap listeners");
-  plugins.forEach((plugin) => plugin.onBootstrap?.({ config: config2, stack, app, assets }));
-  return stack;
+  const functions = plugins.map((plugin) => plugin.onBootstrap?.({
+    config: config2,
+    app,
+    stack,
+    assets
+  })).filter(Boolean).flat().filter(Boolean);
+  return {
+    stack,
+    functions
+  };
 };
 
 // src/util/deployment.ts
@@ -1047,10 +1166,10 @@ var Assets = class {
   assets = {};
   id = 0;
   add(opts) {
-    if (!this.assets[opts.stack.name]) {
-      this.assets[opts.stack.name] = [];
+    if (!this.assets[opts.stackName]) {
+      this.assets[opts.stackName] = [];
     }
-    this.assets[opts.stack.name].push({
+    this.assets[opts.stackName].push({
       ...opts,
       id: this.id++
     });
@@ -1060,21 +1179,21 @@ var Assets = class {
   }
   forEach(cb) {
     Object.values(this.assets).forEach((assets) => {
-      cb(assets[0].stack, assets);
+      cb(assets[0].stackName, assets);
     });
   }
   map(cb) {
     return Object.values(this.assets).map((assets) => {
-      return cb(assets[0].stack, assets);
+      return cb(assets[0].stackName, assets);
     });
   }
 };
 
 // src/app.ts
 var makeApp = (config2) => {
-  return new import_aws_cdk_lib6.App({
+  return new import_aws_cdk_lib7.App({
     outdir: assemblyDir,
-    defaultStackSynthesizer: new import_aws_cdk_lib6.DefaultStackSynthesizer({
+    defaultStackSynthesizer: new import_aws_cdk_lib7.DefaultStackSynthesizer({
       fileAssetsBucketName: assetBucketName(config2),
       fileAssetPublishingRoleArn: "",
       generateBootstrapVersionRule: false
@@ -1103,13 +1222,14 @@ var toApp = async (config2, filters) => {
   debug("Plugins detected:", plugins.map((plugin) => style.info(plugin.name)).join(", "));
   debug("Run plugin onApp listeners");
   plugins.forEach((plugin) => plugin.onApp?.({ config: config2, app, assets }));
+  const bootstrap2 = appBootstrapStack({ config: config2, app, assets });
   debug("Stack filters:", filters.map((filter) => style.info(filter)).join(", "));
   const filterdStacks = filters.length === 0 ? config2.stacks : getAllDepends(
     // config.stacks,
     config2.stacks.filter((stack) => filters.includes(stack.name))
   );
   for (const stackConfig of filterdStacks) {
-    const { stack } = toStack({
+    const { stack, bindings } = toStack({
       config: config2,
       stackConfig,
       assets,
@@ -1117,14 +1237,14 @@ var toApp = async (config2, filters) => {
       app
     });
     stacks.push({ stack, config: stackConfig });
+    bindings.forEach((cb) => bootstrap2.functions.forEach(cb));
   }
   let dependencyTree;
-  const bootstrap2 = appBootstrapStack({ config: config2, app, assets });
-  if (bootstrap2.node.children.length === 0) {
+  if (bootstrap2.stack.node.children.length === 0) {
     dependencyTree = createDependencyTree(stacks, 0);
   } else {
     dependencyTree = [{
-      stack: bootstrap2,
+      stack: bootstrap2.stack,
       level: 0,
       children: createDependencyTree(stacks, 1)
     }];
@@ -1196,7 +1316,7 @@ var footer = () => {
 };
 
 // src/config.ts
-var import_path9 = require("path");
+var import_path13 = require("path");
 
 // src/util/account.ts
 var import_client_sts = require("@aws-sdk/client-sts");
@@ -1215,17 +1335,17 @@ var getCredentials = (profile) => {
 };
 
 // src/schema/app.ts
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 
 // src/schema/stack.ts
-var import_zod20 = require("zod");
-var StackSchema = import_zod20.z.object({
+var import_zod22 = require("zod");
+var StackSchema = import_zod22.z.object({
   name: ResourceIdSchema,
-  depends: import_zod20.z.array(import_zod20.z.lazy(() => StackSchema)).optional()
+  depends: import_zod22.z.array(import_zod22.z.lazy(() => StackSchema)).optional()
 });
 
 // src/schema/region.ts
-var import_zod21 = require("zod");
+var import_zod23 = 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"];
@@ -1242,35 +1362,35 @@ var regions = [
   ...ME,
   ...SA
 ];
-var RegionSchema = import_zod21.z.enum(regions);
+var RegionSchema = import_zod23.z.enum(regions);
 
 // src/schema/plugin.ts
-var import_zod22 = require("zod");
-var PluginSchema = import_zod22.z.object({
-  name: import_zod22.z.string(),
-  schema: import_zod22.z.custom().optional(),
-  depends: import_zod22.z.array(import_zod22.z.lazy(() => PluginSchema)).optional(),
-  onBootstrap: import_zod22.z.function().optional(),
-  onStack: import_zod22.z.function().returns(import_zod22.z.any()).optional(),
-  onApp: import_zod22.z.function().optional()
+var import_zod24 = require("zod");
+var PluginSchema = import_zod24.z.object({
+  name: import_zod24.z.string(),
+  schema: import_zod24.z.custom().optional(),
+  // depends: z.array(z.lazy(() => PluginSchema)).optional(),
+  onBootstrap: import_zod24.z.function().returns(import_zod24.z.any()).optional(),
+  onStack: import_zod24.z.function().returns(import_zod24.z.any()).optional(),
+  onApp: import_zod24.z.function().returns(import_zod24.z.void()).optional()
   // bind: z.function().optional(),
 });
 
 // src/schema/app.ts
-var AppSchema = import_zod23.z.object({
+var AppSchema = import_zod25.z.object({
   name: ResourceIdSchema,
   region: RegionSchema,
-  profile: import_zod23.z.string(),
-  stage: import_zod23.z.string().regex(/[a-z]+/).default("prod"),
-  defaults: import_zod23.z.object({}).default({}),
-  stacks: import_zod23.z.array(StackSchema).min(1),
-  plugins: import_zod23.z.array(PluginSchema).optional()
+  profile: import_zod25.z.string(),
+  stage: import_zod25.z.string().regex(/[a-z]+/).default("prod"),
+  defaults: import_zod25.z.object({}).default({}),
+  stacks: import_zod25.z.array(StackSchema).min(1),
+  plugins: import_zod25.z.array(PluginSchema).optional()
 });
 
 // src/util/import.ts
 var import_core3 = require("@swc/core");
-var import_path7 = require("path");
-var import_promises4 = require("fs/promises");
+var import_path11 = require("path");
+var import_promises6 = require("fs/promises");
 var resolveFileNameExtension = async (path) => {
   const options = [
     "",
@@ -1283,7 +1403,7 @@ var resolveFileNameExtension = async (path) => {
     const file = path + option;
     let stat;
     try {
-      stat = await (0, import_promises4.lstat)(file);
+      stat = await (0, import_promises6.lstat)(file);
     } catch (error) {
       continue;
     }
@@ -1294,14 +1414,14 @@ var resolveFileNameExtension = async (path) => {
   throw new Error(`Failed to load file: ${path}`);
 };
 var resolveDir = (path) => {
-  return (0, import_path7.dirname)(path).replace(rootDir + "/", "");
+  return (0, import_path11.dirname)(path).replace(rootDir + "/", "");
 };
 var importFile = async (path) => {
   const load = async (file) => {
     let { code: code2 } = await (0, import_core3.transformFile)(file, {
       isModule: true
     });
-    const path2 = (0, import_path7.dirname)(file);
+    const path2 = (0, import_path11.dirname)(file);
     const dir = resolveDir(file);
     code2 = code2.replaceAll("__dirname", `"${dir}"`);
     const matches = code2.match(/import\s*{\s*[a-z0-9\_]+\s*}\s*from\s*('|")(\.[\/a-z0-9\_\-]+)('|");?/ig);
@@ -1310,23 +1430,23 @@ var importFile = async (path) => {
     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_path7.join)(path2, from));
+      const file2 = await resolveFileNameExtension((0, import_path11.join)(path2, from));
       const result = await load(file2);
       code2 = code2.replace(match, result);
     }));
     return code2;
   };
   const code = await load(path);
-  const outputFile = (0, import_path7.join)(outDir, "config.js");
-  await (0, import_promises4.mkdir)(outDir, { recursive: true });
-  await (0, import_promises4.writeFile)(outputFile, code);
+  const outputFile = (0, import_path11.join)(outDir, "config.js");
+  await (0, import_promises6.mkdir)(outDir, { recursive: true });
+  await (0, import_promises6.writeFile)(outputFile, code);
   return import(outputFile);
 };
 
 // src/config.ts
 var importConfig = async (options) => {
   debug("Import config file");
-  const fileName = (0, import_path9.join)(process.cwd(), options.configFile || "awsless.config.ts");
+  const fileName = (0, import_path13.join)(process.cwd(), options.configFile || "awsless.config.ts");
   const module2 = await importFile(fileName);
   const appConfig = typeof module2.default === "function" ? await module2.default({
     profile: options.profile,
@@ -1540,6 +1660,13 @@ var Interface = class {
     if (this.input.isTTY) {
       this.input.setRawMode(true);
     }
+    this.input.on("keypress", (_, key) => {
+      const action = parseAction(key);
+      if (action === "abort") {
+        this.unref();
+        process.exit(1);
+      }
+    });
   }
   // private subscriber: Actions | undefined
   readline;
@@ -1689,12 +1816,6 @@ var layout = async (cb) => {
   const term = createTerminal();
   term.out.clear();
   term.out.write(logo());
-  term.in.captureInput({
-    abort: () => {
-      term.in.showCursor();
-      process.exit(1);
-    }
-  });
   try {
     const options = program.optsWithGlobals();
     const config2 = await importConfig(options);
@@ -1715,7 +1836,7 @@ var layout = async (cb) => {
     term.in.unref();
     setTimeout(() => {
       process.exit(0);
-    }, 50);
+    }, 100);
   }
 };
 
@@ -1746,7 +1867,8 @@ var assetBuilder = (assets) => {
     const groups = new Signal([br()]);
     term.out.write(groups);
     const stackNameSize = Math.max(...Object.keys(assets.list()).map((stack) => stack.length));
-    await Promise.all(assets.map(async (stack, assets2) => {
+    const resourceSize = Math.max(...Object.values(assets.list()).map((assets2) => assets2.map((asset) => asset.resource.length)).flat());
+    await Promise.all(assets.map(async (stackName, assets2) => {
       const group = new Signal([]);
       groups.update((groups2) => [...groups2, group]);
       await Promise.all(assets2.map(async (asset) => {
@@ -1755,12 +1877,13 @@ var assetBuilder = (assets) => {
         const line = flexLine(term, [
           icon,
           "  ",
-          style.label(stack.name),
-          " ".repeat(stackNameSize - stack.name.length),
+          style.label(stackName),
+          " ".repeat(stackNameSize - stackName.length),
           " ",
           style.placeholder(symbol.pointerSmall),
           " ",
           style.warning(asset.resource),
+          " ".repeat(resourceSize - asset.resource.length),
           " ",
           style.placeholder(symbol.pointerSmall),
           " ",
@@ -1791,25 +1914,26 @@ var assetBuilder = (assets) => {
 };
 
 // src/util/cleanup.ts
-var import_promises5 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var cleanUp = async () => {
   debug("Clean up assembly & asset files");
   const paths = [
     assemblyDir,
-    functionDir
+    assetDir,
+    cacheDir
   ];
-  await Promise.all(paths.map((path) => (0, import_promises5.rm)(path, {
+  await Promise.all(paths.map((path) => (0, import_promises7.rm)(path, {
     recursive: true,
     force: true,
     maxRetries: 2
   })));
-  await Promise.all(paths.map((path) => (0, import_promises5.mkdir)(path, {
+  await Promise.all(paths.map((path) => (0, import_promises7.mkdir)(path, {
     recursive: true
   })));
 };
 
 // src/cli/command/build.ts
-var build = (program2) => {
+var build2 = (program2) => {
   program2.command("build").argument("[stack...]", "Optionally filter stacks to build").description("Build your app").action(async (filters) => {
     await layout(async (config2, write) => {
       const { app, assets } = await toApp(config2, filters);
@@ -1927,7 +2051,7 @@ var StackClient = class {
     stack.Outputs?.forEach((output) => {
       outputs[output.OutputKey] = output.OutputValue;
     });
-    debug("Status for: ", style.info(name), "is", stack.StackStatus);
+    debug("Status for:", style.info(name), "is", style.attr(stack.StackStatus));
     return {
       status: stack.StackStatus,
       reason: stack.StackStatusReason,
@@ -2193,6 +2317,7 @@ var deploy = (program2) => {
       await cleanUp();
       await write(assetBuilder(assets));
       write(br());
+      write(br());
       const donePublishing = write(loadingDialog("Publishing stack assets to AWS..."));
       await Promise.all(assets.map(async (_, assets2) => {
         await Promise.all(assets2.map(async (asset) => {
@@ -2208,21 +2333,28 @@ var deploy = (program2) => {
       const doneDeploying = write(loadingDialog("Deploying stacks to AWS..."));
       write(br());
       write(stackTree(dependencyTree, statuses));
+      write(br());
       const client = new StackClient(config2);
       const deploymentLine = createDeploymentLine(dependencyTree);
       for (const stacks of deploymentLine) {
-        await Promise.allSettled(stacks.map(async (stack) => {
+        const results = await Promise.allSettled(stacks.map(async (stack) => {
+          const signal = statuses[stack.artifactId];
           const stackArtifect = assembly.stacks.find((item) => item.id === stack.artifactId);
-          statuses[stack.artifactId].set(style.warning("deploying"));
+          signal.set(style.warning("deploying"));
           try {
             await client.deploy(stackArtifect);
           } catch (error) {
             debugError(error);
-            statuses[stack.artifactId].set(style.error("failed"));
+            signal.set(style.error("failed"));
             throw error;
           }
-          statuses[stack.artifactId].set(style.success("deployed"));
+          signal.set(style.success("deployed"));
         }));
+        for (const result of results) {
+          if (result.status === "rejected") {
+            throw result.reason;
+          }
+        }
       }
       doneDeploying("Done deploying stacks to AWS");
     });
@@ -2397,7 +2529,7 @@ program.on("option:verbose", () => {
 var commands2 = [
   bootstrap,
   status,
-  build,
+  build2,
   deploy,
   config
   // diff,