@awsless/awsless 0.0.7 → 0.0.9

package/dist/bin.js

@@ -195,6 +195,8 @@ var toStack = ({ config: config2, assets, app, stackConfig, plugins }) => {
   functions.forEach((lambda) => lambda.addToRolePolicy(allowConfigParameters));
   return {
     stack,
+    functions,
+    bindings,
     depends: stackConfig.depends
   };
 };
@@ -204,7 +206,8 @@ import { join } from "path";
 var rootDir = process.cwd();
 var outDir = join(rootDir, ".awsless");
 var assemblyDir = join(outDir, "assembly");
-var functionDir = join(outDir, "function");
+var assetDir = join(outDir, "asset");
+var cacheDir = join(outDir, "cache");
 
 // src/stack/app-bootstrap.ts
 import { Stack as Stack3 } from "aws-cdk-lib";
@@ -249,7 +252,7 @@ var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 import { Rule } from "aws-cdk-lib/aws-events";
 
 // src/util/resource.ts
-import { constantCase, paramCase, pascalCase } from "change-case";
+import { paramCase, pascalCase } from "change-case";
 var toId = (resource, id) => {
   return pascalCase(`${resource}-${id}`);
 };
@@ -257,7 +260,7 @@ var toName = (stack, id) => {
   return paramCase(`${stack.stackName}-${id}`);
 };
 var toEnvKey = (resource, id) => {
-  return constantCase(`RESOURCE_${resource}_${id}`);
+  return `RESOURCE_${resource.toUpperCase()}_${id}`;
 };
 var addResourceEnvironment = (stack, resource, id, lambda) => {
   const key = toEnvKey(resource, id);
@@ -356,43 +359,45 @@ var SizeSchema = z7.custom((value) => {
   return z7.string().regex(/[0-9]+ (KB|MB|GB)/).safeParse(value).success;
 }, "Invalid size").transform(toSize);
 
-// src/plugins/function/util/build-worker.ts
-import { bundle } from "@swc/core";
-import { createHash } from "crypto";
+// src/plugins/function/util/esbuild.ts
+import { build } from "esbuild";
+import { createHash, randomUUID } from "crypto";
+import { join as join2 } from "path";
+import { readFile, rm } from "fs/promises";
 var defaultBuild = async (file) => {
-  const output = await bundle({
-    entry: {
-      file
-    },
-    mode: "production",
-    target: "node",
-    externalModules: [
+  const random = randomUUID();
+  const codeFile = join2(cacheDir, `${random}.mjs`);
+  const mapFile = join2(cacheDir, `${random}.mjs.map`);
+  await build({
+    entryPoints: [file],
+    minify: true,
+    bundle: true,
+    external: [
       "@aws-sdk/*",
       "@aws-sdk",
       "aws-sdk"
     ],
-    module: {},
-    options: {
-      minify: true,
-      sourceMaps: true,
-      jsc: {
-        target: "es2022"
-      }
-    },
-    output: {
-      name: "output",
-      path: ""
-    }
+    sourcemap: "external",
+    target: "esnext",
+    treeShaking: true,
+    // jsxSideEffects:
+    format: "esm",
+    platform: "node",
+    outfile: codeFile
   });
-  const hash = createHash("sha1").update(output.file.code).digest("hex");
+  const code = await readFile(codeFile, "utf8");
+  const map = await readFile(mapFile, "utf8");
+  await rm(codeFile);
+  await rm(mapFile);
+  const hash = createHash("sha1").update(code).digest("hex");
   return {
     handler: "index.default",
     hash,
     files: [
       {
-        name: "index.js",
-        code: output.file.code,
-        map: output.file.map?.toString()
+        name: "index.mjs",
+        code,
+        map
       }
     ]
   };
@@ -400,7 +405,7 @@ var defaultBuild = async (file) => {
 
 // src/plugins/function/util/build.ts
 import JSZip from "jszip";
-import { basename, join as join2 } from "path";
+import { basename, join as join3 } from "path";
 import { mkdir, writeFile } from "fs/promises";
 import { filesize } from "filesize";
 var zipFiles = (files) => {
@@ -417,36 +422,36 @@ var zipFiles = (files) => {
   });
 };
 var writeBuildHash = async (config2, stack, id, hash) => {
-  const funcPath = join2(functionDir, config2.name, stack.artifactId, id);
-  const versionFile = join2(funcPath, "HASH");
+  const funcPath = join3(assetDir, "function", config2.name, stack.artifactId, id);
+  const versionFile = join3(funcPath, "HASH");
   await writeFile(versionFile, hash);
 };
 var writeBuildFiles = async (config2, stack, id, files) => {
-  const bundle2 = await zipFiles(files);
-  const funcPath = join2(functionDir, config2.name, stack.artifactId, id);
-  const filesPath = join2(funcPath, "files");
-  const bundleFile = join2(funcPath, "bundle.zip");
-  debug("Bundle size of", style.info(join2(config2.name, stack.artifactId, id)), "is", style.attr(filesize(bundle2.byteLength)));
+  const bundle = await zipFiles(files);
+  const funcPath = join3(assetDir, "function", config2.name, stack.artifactId, id);
+  const filesPath = join3(funcPath, "files");
+  const bundleFile = join3(funcPath, "bundle.zip");
+  debug("Bundle size of", style.info(join3(config2.name, stack.artifactId, id)), "is", style.attr(filesize(bundle.byteLength)));
   await mkdir(filesPath, { recursive: true });
-  await writeFile(bundleFile, bundle2);
+  await writeFile(bundleFile, bundle);
   await Promise.all(files.map(async (file) => {
-    const fileName = join2(filesPath, file.name);
+    const fileName = join3(filesPath, file.name);
     await mkdir(basename(fileName), { recursive: true });
     await writeFile(fileName, file.code);
     if (file.map) {
-      const mapName = join2(filesPath, `${file.name}.map`);
+      const mapName = join3(filesPath, `${file.name}.map`);
       await writeFile(mapName, file.map);
     }
   }));
   return {
     file: bundleFile,
-    size: bundle2.byteLength
+    size: bundle.byteLength
   };
 };
 
 // src/plugins/function/util/publish.ts
-import { join as join3 } from "path";
-import { readFile } from "fs/promises";
+import { join as join4 } from "path";
+import { readFile as readFile2 } from "fs/promises";
 import { GetObjectCommand, ObjectCannedACL, PutObjectCommand, S3Client, StorageClass } from "@aws-sdk/client-s3";
 
 // src/stack/bootstrap.ts
@@ -486,11 +491,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 = join3(functionDir, config2.name, stack.artifactId, id);
-  const bundleFile = join3(funcPath, "bundle.zip");
-  const hashFile = join3(funcPath, "HASH");
-  const hash = await readFile(hashFile, "utf8");
-  const file = await readFile(bundleFile);
+  const funcPath = join4(assetDir, "function", config2.name, stack.artifactId, id);
+  const bundleFile = join4(funcPath, "bundle.zip");
+  const hashFile = join4(funcPath, "HASH");
+  const hash = await readFile2(hashFile, "utf8");
+  const file = await readFile2(bundleFile);
   const client = new S3Client({
     credentials: config2.credentials,
     region: config2.region
@@ -576,7 +581,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 Function(stack, toId("function", id), {
     functionName: toName(stack, id),
@@ -587,24 +592,24 @@ 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() {
       const result = await defaultBuild(props.file);
-      const bundle2 = await writeBuildFiles(config2, stack, id, result.files);
+      const bundle = await writeBuildFiles(config2, stack, id, result.files);
       await writeBuildHash(config2, stack, id, result.hash);
       const func = lambda.node.defaultChild;
       func.handler = result.handler;
       return {
-        size: formatByteSize(bundle2.size)
+        size: formatByteSize(bundle.size)
       };
     },
     async publish() {
@@ -840,7 +845,6 @@ import { z as z18 } from "zod";
 import { Topic } from "aws-cdk-lib/aws-sns";
 import { SnsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { Arn as Arn2, ArnFormat } from "aws-cdk-lib";
-import { PolicyStatement as PolicyStatement2 } from "aws-cdk-lib/aws-iam";
 var topicPlugin = definePlugin({
   name: "topic",
   schema: z18.object({
@@ -862,12 +866,6 @@ var topicPlugin = definePlugin({
   },
   onStack(ctx) {
     const { config: config2, stack, stackConfig, bind } = ctx;
-    bind((lambda) => {
-      lambda.addToRolePolicy(new PolicyStatement2({
-        actions: ["sns:publish"],
-        resources: ["*"]
-      }));
-    });
     return Object.entries(stackConfig.topics || {}).map(([id, props]) => {
       const lambda = toFunction(ctx, id, props);
       const topic = Topic.fromTopicArn(
@@ -880,6 +878,10 @@ var topicPlugin = definePlugin({
         }, stack)
       );
       lambda.addEventSource(new SnsEventSource(topic));
+      bind((lambda2) => {
+        addResourceEnvironment(stack, "topic", id, lambda2);
+        topic.grantPublish(lambda2);
+      });
       return lambda;
     });
   }
@@ -888,7 +890,7 @@ var topicPlugin = definePlugin({
 // src/plugins/search.ts
 import { z as z19 } from "zod";
 import { CfnCollection } from "aws-cdk-lib/aws-opensearchserverless";
-import { PolicyStatement as PolicyStatement3 } from "aws-cdk-lib/aws-iam";
+import { PolicyStatement as PolicyStatement2 } from "aws-cdk-lib/aws-iam";
 var searchPlugin = definePlugin({
   name: "search",
   schema: z19.object({
@@ -903,7 +905,7 @@ var searchPlugin = definePlugin({
         type: "SEARCH"
       });
       bind((lambda) => {
-        lambda.addToRolePolicy(new PolicyStatement3({
+        lambda.addToRolePolicy(new PolicyStatement2({
           actions: ["aoss:APIAccessAll"],
           resources: [collection.attrArn]
         }));
@@ -912,6 +914,138 @@ var searchPlugin = definePlugin({
   }
 });
 
+// src/plugins/graphql/index.ts
+import { z as z21 } from "zod";
+import { AuthorizationType, CfnGraphQLApi, CfnGraphQLSchema, GraphqlApi, MappingTemplate } from "aws-cdk-lib/aws-appsync";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+
+// src/util/array.ts
+var toArray = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return [value];
+};
+
+// src/plugins/graphql/index.ts
+import { dirname, join as join5 } from "path";
+import { print } from "graphql";
+import { paramCase as paramCase2 } from "change-case";
+
+// src/plugins/graphql/schema/resolver-field.ts
+import { z as z20 } from "zod";
+var ResolverFieldSchema = z20.custom((value) => {
+  return z20.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
+import { CfnOutput as CfnOutput2, Fn } from "aws-cdk-lib";
+var graphqlPlugin = definePlugin({
+  name: "graphql",
+  schema: z21.object({
+    defaults: z21.object({
+      graphql: z21.record(ResourceIdSchema, z21.object({
+        authorization: z21.object({
+          authorizer: FunctionSchema,
+          ttl: DurationSchema.default("1 hour")
+        }).optional(),
+        mappingTemplate: z21.object({
+          request: LocalFileSchema.optional(),
+          response: LocalFileSchema.optional()
+        }).optional()
+      })).optional()
+    }).default({}),
+    stacks: z21.object({
+      graphql: z21.record(ResourceIdSchema, z21.object({
+        schema: z21.union([
+          LocalFileSchema,
+          z21.array(LocalFileSchema).min(1)
+        ]).optional(),
+        resolvers: z21.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 = join5(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: AuthorizationType.LAMBDA,
+          lambdaAuthorizerConfig: {
+            authorizerUri: authorizer.functionArn,
+            authorizerResultTtlInSeconds: authorization.ttl.toSeconds()
+          }
+        }];
+      }
+      const api = new CfnGraphQLApi(stack, toId("graphql", id), {
+        ...authProps,
+        name: toName(stack, id),
+        authenticationType: AuthorizationType.API_KEY
+      });
+      new CfnOutput2(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 readFile3(schemaFile, "utf8");
+              schemas.push(schema3);
+            }));
+          }));
+          const schema2 = print(mergeTypeDefs(schemas));
+          await mkdir2(dirname(file), { recursive: true });
+          await writeFile2(file, schema2);
+          new 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 = GraphqlApi.fromGraphqlApiAttributes(stack, toId("graphql", id), {
+          graphqlApiId: Fn.importValue(toId("graphql", id))
+        });
+        const [typeName, fieldName] = typeAndField.split(/[\s]+/g);
+        const functionId = paramCase2(`${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 ? MappingTemplate.fromFile(defaults.mappingTemplate.request) : MappingTemplate.lambdaRequest(),
+          responseMappingTemplate: defaults.mappingTemplate?.response ? MappingTemplate.fromFile(defaults.mappingTemplate.response) : MappingTemplate.lambdaResult()
+        });
+        return lambda;
+      });
+    }).flat();
+  }
+});
+
 // src/plugins/index.ts
 var defaultPlugins = [
   functionPlugin,
@@ -920,7 +1054,8 @@ var defaultPlugins = [
   tablePlugin,
   storePlugin,
   topicPlugin,
-  searchPlugin
+  searchPlugin,
+  graphqlPlugin
 ];
 
 // src/stack/app-bootstrap.ts
@@ -933,8 +1068,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
@@ -1000,10 +1143,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++
     });
@@ -1013,12 +1156,12 @@ 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);
     });
   }
 };
@@ -1056,13 +1199,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,
@@ -1070,14 +1214,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)
     }];
@@ -1149,7 +1293,7 @@ var footer = () => {
 };
 
 // src/config.ts
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 
 // src/util/account.ts
 import { STSClient, GetCallerIdentityCommand } from "@aws-sdk/client-sts";
@@ -1168,17 +1312,17 @@ var getCredentials = (profile) => {
 };
 
 // src/schema/app.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 
 // src/schema/stack.ts
-import { z as z20 } from "zod";
-var StackSchema = z20.object({
+import { z as z22 } from "zod";
+var StackSchema = z22.object({
   name: ResourceIdSchema,
-  depends: z20.array(z20.lazy(() => StackSchema)).optional()
+  depends: z22.array(z22.lazy(() => StackSchema)).optional()
 });
 
 // src/schema/region.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "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"];
@@ -1195,35 +1339,35 @@ var regions = [
   ...ME,
   ...SA
 ];
-var RegionSchema = z21.enum(regions);
+var RegionSchema = z23.enum(regions);
 
 // src/schema/plugin.ts
-import { z as z22 } from "zod";
-var PluginSchema = z22.object({
-  name: z22.string(),
-  schema: z22.custom().optional(),
-  depends: z22.array(z22.lazy(() => PluginSchema)).optional(),
-  onBootstrap: z22.function().optional(),
-  onStack: z22.function().returns(z22.any()).optional(),
-  onApp: z22.function().optional()
+import { z as z24 } from "zod";
+var PluginSchema = z24.object({
+  name: z24.string(),
+  schema: z24.custom().optional(),
+  // depends: z.array(z.lazy(() => PluginSchema)).optional(),
+  onBootstrap: z24.function().returns(z24.any()).optional(),
+  onStack: z24.function().returns(z24.any()).optional(),
+  onApp: z24.function().returns(z24.void()).optional()
   // bind: z.function().optional(),
 });
 
 // src/schema/app.ts
-var AppSchema = z23.object({
+var AppSchema = z25.object({
   name: ResourceIdSchema,
   region: RegionSchema,
-  profile: z23.string(),
-  stage: z23.string().regex(/[a-z]+/).default("prod"),
-  defaults: z23.object({}).default({}),
-  stacks: z23.array(StackSchema).min(1),
-  plugins: z23.array(PluginSchema).optional()
+  profile: z25.string(),
+  stage: z25.string().regex(/[a-z]+/).default("prod"),
+  defaults: z25.object({}).default({}),
+  stacks: z25.array(StackSchema).min(1),
+  plugins: z25.array(PluginSchema).optional()
 });
 
 // src/util/import.ts
 import { transformFile } from "@swc/core";
-import { dirname, join as join4 } from "path";
-import { lstat, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join6 } from "path";
+import { lstat, mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 var resolveFileNameExtension = async (path) => {
   const options = [
     "",
@@ -1247,14 +1391,14 @@ var resolveFileNameExtension = async (path) => {
   throw new Error(`Failed to load file: ${path}`);
 };
 var resolveDir = (path) => {
-  return dirname(path).replace(rootDir + "/", "");
+  return dirname2(path).replace(rootDir + "/", "");
 };
 var importFile = async (path) => {
   const load = async (file) => {
     let { code: code2 } = await transformFile(file, {
       isModule: true
     });
-    const path2 = dirname(file);
+    const path2 = dirname2(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);
@@ -1263,23 +1407,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(join4(path2, from));
+      const file2 = await resolveFileNameExtension(join6(path2, from));
       const result = await load(file2);
       code2 = code2.replace(match, result);
     }));
     return code2;
   };
   const code = await load(path);
-  const outputFile = join4(outDir, "config.js");
-  await mkdir2(outDir, { recursive: true });
-  await writeFile2(outputFile, code);
+  const outputFile = join6(outDir, "config.js");
+  await mkdir3(outDir, { recursive: true });
+  await writeFile3(outputFile, code);
   return import(outputFile);
 };
 
 // src/config.ts
 var importConfig = async (options) => {
   debug("Import config file");
-  const fileName = join5(process.cwd(), options.configFile || "awsless.config.ts");
+  const fileName = join7(process.cwd(), options.configFile || "awsless.config.ts");
   const module = await importFile(fileName);
   const appConfig = typeof module.default === "function" ? await module.default({
     profile: options.profile,
@@ -1493,6 +1637,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;
@@ -1642,12 +1793,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);
@@ -1668,7 +1813,7 @@ var layout = async (cb) => {
     term.in.unref();
     setTimeout(() => {
       process.exit(0);
-    }, 50);
+    }, 100);
   }
 };
 
@@ -1699,7 +1844,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) => {
@@ -1708,12 +1854,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),
           " ",
@@ -1744,25 +1891,26 @@ var assetBuilder = (assets) => {
 };
 
 // src/util/cleanup.ts
-import { mkdir as mkdir3, rm } from "fs/promises";
+import { mkdir as mkdir4, rm as rm2 } from "fs/promises";
 var cleanUp = async () => {
   debug("Clean up assembly & asset files");
   const paths = [
     assemblyDir,
-    functionDir
+    assetDir,
+    cacheDir
   ];
-  await Promise.all(paths.map((path) => rm(path, {
+  await Promise.all(paths.map((path) => rm2(path, {
     recursive: true,
     force: true,
     maxRetries: 2
   })));
-  await Promise.all(paths.map((path) => mkdir3(path, {
+  await Promise.all(paths.map((path) => mkdir4(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);
@@ -1880,7 +2028,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,
@@ -2146,6 +2294,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) => {
@@ -2161,21 +2310,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");
     });
@@ -2350,7 +2506,7 @@ program.on("option:verbose", () => {
 var commands2 = [
   bootstrap,
   status,
-  build,
+  build2,
   deploy,
   config
   // diff,