@awsless/awsless 0.0.11 → 0.0.13

package/dist/bin.js

@@ -63,15 +63,15 @@ var flushDebug = () => {
 
 // src/util/param.ts
 import { DeleteParameterCommand, GetParameterCommand, GetParametersByPathCommand, ParameterType, PutParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
-var configParameterPrefix = (config2) => {
-  return `/${config2.stage}/awsless/${config2.name}`;
+var configParameterPrefix = (config) => {
+  return `/${config.stage}/awsless/${config.name}`;
 };
 var Params = class {
-  constructor(config2) {
-    this.config = config2;
+  constructor(config) {
+    this.config = config;
     this.client = new SSMClient({
-      credentials: config2.credentials,
-      region: config2.region
+      credentials: config.credentials,
+      region: config.region
     });
   }
   client;
@@ -146,13 +146,13 @@ var Params = class {
 };
 
 // src/stack.ts
-var toStack = ({ config: config2, assets, app, stackConfig, plugins }) => {
-  const stackName = `${config2.name}-${stackConfig.name}`;
+var toStack = ({ config, assets, app, stackConfig, plugins }) => {
+  const stackName = `${config.name}-${stackConfig.name}`;
   const stack = new Stack(app, stackConfig.name, {
     stackName,
     tags: {
-      APP: config2.name,
-      STAGE: config2.stage,
+      APP: config.name,
+      STAGE: config.stage,
       STACK: stackConfig.name
     }
   });
@@ -163,7 +163,7 @@ var toStack = ({ config: config2, assets, app, stackConfig, plugins }) => {
   };
   debug("Run plugin onStack listeners");
   const functions = plugins.map((plugin) => plugin.onStack?.({
-    config: config2,
+    config,
     assets,
     app,
     stack,
@@ -182,12 +182,12 @@ var toStack = ({ config: config2, assets, app, stackConfig, plugins }) => {
     ],
     resources: [
       Arn.format({
-        region: config2.region,
-        account: config2.account,
+        region: config.region,
+        account: config.account,
         partition: "aws",
         service: "ssm",
         resource: "parameter",
-        resourceName: configParameterPrefix(config2)
+        resourceName: configParameterPrefix(config)
       })
       // Fn.sub('arn:aws:ssm:${AWS::Region}:${AWS::AccountId}:parameter' + configParameterPrefix(config)),
     ]
@@ -377,17 +377,17 @@ var zipFiles = (files) => {
     }
   });
 };
-var writeBuildHash = async (config2, stack, id, hash) => {
-  const funcPath = join2(assetDir, "function", config2.name, stack.artifactId, id);
+var writeBuildHash = async (config, stack, id, hash) => {
+  const funcPath = join2(assetDir, "function", config.name, stack.artifactId, id);
   const versionFile = join2(funcPath, "HASH");
   await writeFile(versionFile, hash);
 };
-var writeBuildFiles = async (config2, stack, id, files) => {
+var writeBuildFiles = async (config, stack, id, files) => {
   const bundle = await zipFiles(files);
-  const funcPath = join2(assetDir, "function", config2.name, stack.artifactId, id);
+  const funcPath = join2(assetDir, "function", config.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(bundle.byteLength)));
+  debug("Bundle size of", style.info(join2(config.name, stack.artifactId, id)), "is", style.attr(filesize(bundle.byteLength)));
   await mkdir(filesPath, { recursive: true });
   await writeFile(bundleFile, bundle);
   await Promise.all(files.map(async (file) => {
@@ -413,20 +413,20 @@ import { GetObjectCommand, ObjectCannedACL, PutObjectCommand, S3Client, StorageC
 // src/stack/bootstrap.ts
 import { CfnOutput, RemovalPolicy, Stack as Stack2 } from "aws-cdk-lib";
 import { Bucket, BucketAccessControl } from "aws-cdk-lib/aws-s3";
-var assetBucketName = (config2) => {
-  return `awsless-bootstrap-${config2.account}-${config2.region}`;
+var assetBucketName = (config) => {
+  return `awsless-bootstrap-${config.account}-${config.region}`;
 };
-var assetBucketUrl = (config2, stackName) => {
-  const bucket = assetBucketName(config2);
-  return `https://s3-${config2.region}.amazonaws.com/${bucket}/${stackName}/cloudformation.json`;
+var assetBucketUrl = (config, stackName) => {
+  const bucket = assetBucketName(config);
+  return `https://s3-${config.region}.amazonaws.com/${bucket}/${stackName}/cloudformation.json`;
 };
 var version = "2";
-var bootstrapStack = (config2, app) => {
+var bootstrapStack = (config, app) => {
   const stack = new Stack2(app, "bootstrap", {
     stackName: `awsless-bootstrap`
   });
   new Bucket(stack, "assets", {
-    bucketName: assetBucketName(config2),
+    bucketName: assetBucketName(config),
     versioned: true,
     accessControl: BucketAccessControl.PRIVATE,
     removalPolicy: RemovalPolicy.DESTROY
@@ -444,17 +444,17 @@ var shouldDeployBootstrap = async (client, name) => {
 };
 
 // src/plugins/function/util/publish.ts
-var publishFunctionAsset = async (config2, stack, id) => {
-  const bucket = assetBucketName(config2);
-  const key = `${config2.name}/${stack.artifactId}/function/${id}.zip`;
-  const funcPath = join3(assetDir, "function", config2.name, stack.artifactId, id);
+var publishFunctionAsset = async (config, stack, id) => {
+  const bucket = assetBucketName(config);
+  const key = `${config.name}/${stack.artifactId}/function/${id}.zip`;
+  const funcPath = join3(assetDir, "function", config.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 client = new S3Client({
-    credentials: config2.credentials,
-    region: config2.region
+    credentials: config.credentials,
+    region: config.region
   });
   let getResult;
   try {
@@ -527,19 +527,22 @@ var rollupBuild = async (input) => {
       json()
     ]
   });
-  const { output: [output] } = await bundle.generate({
+  const result = await bundle.generate({
     format: "esm",
     sourcemap: "hidden",
     exports: "default"
   });
-  const hash = createHash("sha1").update(output.code).digest("hex");
+  const output = result.output[0];
+  const code = output.code;
+  const map = output.map?.toString();
+  const hash = createHash("sha1").update(code).digest("hex");
   return {
     handler: "index.default",
     hash,
     files: [{
       name: "index.mjs",
-      code: output.code,
-      map: output.map?.toString()
+      code,
+      map
     }]
   };
 };
@@ -586,8 +589,8 @@ var functionPlugin = definePlugin({
     });
   }
 });
-var toFunction = ({ config: config2, stack, assets }, id, fileOrProps) => {
-  const props = typeof fileOrProps === "string" ? { ...config2.defaults?.function, file: fileOrProps } : { ...config2.defaults?.function, ...fileOrProps };
+var toFunction = ({ config, stack, assets }, id, fileOrProps) => {
+  const props = typeof fileOrProps === "string" ? { ...config.defaults?.function, file: fileOrProps } : { ...config.defaults?.function, ...fileOrProps };
   const lambda = new Function(stack, toId("function", id), {
     functionName: toName(stack, id),
     handler: "index.default",
@@ -595,8 +598,8 @@ var toFunction = ({ config: config2, stack, assets }, id, fileOrProps) => {
     ...props,
     memorySize: props.memorySize.toMebibytes()
   });
-  lambda.addEnvironment("APP", config2.name, { removeInEdge: true });
-  lambda.addEnvironment("STAGE", config2.stage, { removeInEdge: true });
+  lambda.addEnvironment("APP", config.name, { removeInEdge: true });
+  lambda.addEnvironment("STAGE", config.stage, { removeInEdge: true });
   lambda.addEnvironment("STACK", stack.artifactId, { removeInEdge: true });
   if (lambda.runtime.toString().startsWith("nodejs")) {
     lambda.addEnvironment("AWS_NODEJS_CONNECTION_REUSE_ENABLED", "1", {
@@ -609,8 +612,8 @@ var toFunction = ({ config: config2, stack, assets }, id, fileOrProps) => {
     resourceName: id,
     async build() {
       const result = await rollupBuild(props.file);
-      const bundle = await writeBuildFiles(config2, stack, id, result.files);
-      await writeBuildHash(config2, stack, id, result.hash);
+      const bundle = await writeBuildFiles(config, stack, id, result.files);
+      await writeBuildHash(config, stack, id, result.hash);
       const func = lambda.node.defaultChild;
       func.handler = result.handler;
       return {
@@ -618,11 +621,11 @@ var toFunction = ({ config: config2, stack, assets }, id, fileOrProps) => {
       };
     },
     async publish() {
-      const version2 = await publishFunctionAsset(config2, stack, id);
+      const version2 = await publishFunctionAsset(config, stack, id);
       const func = lambda.node.defaultChild;
       func.code = {
-        s3Bucket: assetBucketName(config2),
-        s3Key: `${config2.name}/${stack.artifactId}/function/${id}.zip`,
+        s3Bucket: assetBucketName(config),
+        s3Key: `${config.name}/${stack.artifactId}/function/${id}.zip`,
         s3ObjectVersion: version2
       };
     }
@@ -691,9 +694,9 @@ var queuePlugin = definePlugin({
     }).array()
   }),
   onStack(ctx) {
-    const { stack, config: config2, stackConfig, bind } = ctx;
+    const { stack, config, stackConfig, bind } = ctx;
     return Object.entries(stackConfig.queues || {}).map(([id, functionOrProps]) => {
-      const props = typeof functionOrProps === "string" ? { ...config2.defaults.queue, consumer: functionOrProps } : { ...config2.defaults.queue, ...functionOrProps };
+      const props = typeof functionOrProps === "string" ? { ...config.defaults.queue, consumer: functionOrProps } : { ...config.defaults.queue, ...functionOrProps };
       const queue2 = new Queue(stack, toId("queue", id), {
         queueName: toName(stack, id),
         ...props,
@@ -857,20 +860,20 @@ var topicPlugin = definePlugin({
       topics: z18.record(ResourceIdSchema, FunctionSchema).optional()
     }).array()
   }),
-  onBootstrap({ config: config2, stack }) {
-    const allTopicNames = config2.stacks.map((stack2) => {
+  onBootstrap({ config, stack }) {
+    const allTopicNames = config.stacks.map((stack2) => {
       return Object.keys(stack2.topics || {});
     }).flat();
     const uniqueTopicNames = [...new Set(allTopicNames)];
     uniqueTopicNames.forEach((id) => {
       new Topic(stack, toId("topic", id), {
-        topicName: `${config2.name}-${id}`,
+        topicName: `${config.name}-${id}`,
         displayName: id
       });
     });
   },
   onStack(ctx) {
-    const { config: config2, stack, stackConfig, bind } = ctx;
+    const { config, stack, stackConfig, bind } = ctx;
     return Object.entries(stackConfig.topics || {}).map(([id, props]) => {
       const lambda = toFunction(ctx, id, props);
       const topic = Topic.fromTopicArn(
@@ -879,7 +882,7 @@ var topicPlugin = definePlugin({
         Arn2.format({
           arnFormat: ArnFormat.NO_RESOURCE_NAME,
           service: "sns",
-          resource: `${config2.name}-${id}`
+          resource: `${config.name}-${id}`
         }, stack)
       );
       lambda.addEventSource(new SnsEventSource(topic));
@@ -971,19 +974,19 @@ var graphqlPlugin = definePlugin({
       })).optional()
     }).array()
   }),
-  onBootstrap({ config: config2, stack, assets }) {
+  onBootstrap({ config, stack, assets }) {
     const list3 = /* @__PURE__ */ new Set();
-    Object.values(config2.stacks).forEach((stackConfig) => {
+    Object.values(config.stacks).forEach((stackConfig) => {
       Object.keys(stackConfig.graphql || {}).forEach((id) => {
         list3.add(id);
       });
     });
     list3.forEach((id) => {
-      const file = join4(assetDir, "graphql", config2.name, id, "schema.graphql");
-      const authorization = config2.defaults.graphql?.[id]?.authorization;
+      const file = join4(assetDir, "graphql", config.name, id, "schema.graphql");
+      const authorization = config.defaults.graphql?.[id]?.authorization;
       const authProps = {};
       if (authorization) {
-        const authorizer = toFunction({ config: config2, assets, stack }, `${id}-authorizer`, authorization.authorizer);
+        const authorizer = toFunction({ config, assets, stack }, `${id}-authorizer`, authorization.authorizer);
         authProps.additionalAuthenticationProviders = [{
           authenticationType: AuthorizationType.LAMBDA,
           lambdaAuthorizerConfig: {
@@ -1007,7 +1010,7 @@ var graphqlPlugin = definePlugin({
         resourceName: id,
         async build() {
           const schemas = [];
-          await Promise.all(Object.values(config2.stacks).map(async (stackConfig) => {
+          await Promise.all(Object.values(config.stacks).map(async (stackConfig) => {
             const schemaFiles = toArray(stackConfig.graphql?.[id].schema || []);
             await Promise.all(schemaFiles.map(async (schemaFile) => {
               const schema3 = await readFile2(schemaFile, "utf8");
@@ -1026,9 +1029,9 @@ var graphqlPlugin = definePlugin({
     });
   },
   onStack(ctx) {
-    const { config: config2, stack, stackConfig } = ctx;
+    const { config, stack, stackConfig } = ctx;
     return Object.entries(stackConfig.graphql || {}).map(([id, props]) => {
-      const defaults = config2.defaults.graphql?.[id] || {};
+      const defaults = config.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))
@@ -1051,6 +1054,48 @@ var graphqlPlugin = definePlugin({
   }
 });
 
+// src/plugins/pubsub.ts
+import { z as z22 } from "zod";
+import { CfnTopicRule } from "aws-cdk-lib/aws-iot";
+import { PolicyStatement as PolicyStatement3 } from "aws-cdk-lib/aws-iam";
+var pubsubPlugin = definePlugin({
+  name: "pubsub",
+  schema: z22.object({
+    stacks: z22.object({
+      pubsub: z22.record(ResourceIdSchema, z22.object({
+        sql: z22.string(),
+        sqlVersion: z22.enum(["2015-10-08", "2016-03-23", "beta"]).default("2016-03-23"),
+        consumer: FunctionSchema
+      })).optional()
+    }).array()
+  }),
+  onStack(ctx) {
+    const { stack, stackConfig, bind } = ctx;
+    bind((lambda) => {
+      lambda.addToRolePolicy(new PolicyStatement3({
+        actions: ["iot:publish"],
+        resources: ["*"]
+      }));
+    });
+    return Object.entries(stackConfig.pubsub || {}).map(([id, props]) => {
+      const lambda = toFunction(ctx, id, props.consumer);
+      new CfnTopicRule(stack, toId("pubsub", id), {
+        ruleName: toName(stack, id),
+        topicRulePayload: {
+          sql: props.sql,
+          awsIotSqlVersion: props.sqlVersion,
+          actions: [{
+            lambda: {
+              functionArn: lambda.functionArn
+            }
+          }]
+        }
+      });
+      return lambda;
+    });
+  }
+});
+
 // src/plugins/index.ts
 var defaultPlugins = [
   functionPlugin,
@@ -1060,21 +1105,22 @@ var defaultPlugins = [
   storePlugin,
   topicPlugin,
   searchPlugin,
-  graphqlPlugin
+  graphqlPlugin,
+  pubsubPlugin
 ];
 
 // src/stack/app-bootstrap.ts
-var appBootstrapStack = ({ config: config2, app, assets }) => {
+var appBootstrapStack = ({ config, app, assets }) => {
   const stack = new Stack3(app, "bootstrap", {
-    stackName: `${config2.name}-bootstrap`
+    stackName: `${config.name}-bootstrap`
   });
   const plugins = [
     ...defaultPlugins,
-    ...config2.plugins || []
+    ...config.plugins || []
   ];
   debug("Run plugin onBootstrap listeners");
   const functions = plugins.map((plugin) => plugin.onBootstrap?.({
-    config: config2,
+    config,
     app,
     stack,
     assets
@@ -1098,9 +1144,9 @@ var flattenDependencyTree = (stacks) => {
   return list3;
 };
 var createDependencyTree = (stacks, startingLevel) => {
-  const list3 = stacks.map(({ stack, config: config2 }) => ({
+  const list3 = stacks.map(({ stack, config }) => ({
     stack,
-    depends: config2?.depends?.map((dep) => dep.name) || []
+    depends: config?.depends?.map((dep) => dep.name) || []
   }));
   const findChildren = (list4, parents, level) => {
     const children = [];
@@ -1172,11 +1218,11 @@ var Assets = class {
 };
 
 // src/app.ts
-var makeApp = (config2) => {
+var makeApp = (config) => {
   return new App4({
     outdir: assemblyDir,
     defaultStackSynthesizer: new DefaultStackSynthesizer({
-      fileAssetsBucketName: assetBucketName(config2),
+      fileAssetsBucketName: assetBucketName(config),
       fileAssetPublishingRoleArn: "",
       generateBootstrapVersionRule: false
     })
@@ -1193,26 +1239,26 @@ var getAllDepends = (filters) => {
   walk(filters);
   return list3;
 };
-var toApp = async (config2, filters) => {
+var toApp = async (config, filters) => {
   const assets = new Assets();
-  const app = makeApp(config2);
+  const app = makeApp(config);
   const stacks = [];
   const plugins = [
     ...defaultPlugins,
-    ...config2.plugins || []
+    ...config.plugins || []
   ];
   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 });
+  plugins.forEach((plugin) => plugin.onApp?.({ config, app, assets }));
+  const bootstrap2 = appBootstrapStack({ config, app, assets });
   debug("Stack filters:", filters.map((filter) => style.info(filter)).join(", "));
-  const filterdStacks = filters.length === 0 ? config2.stacks : getAllDepends(
+  const filterdStacks = filters.length === 0 ? config.stacks : getAllDepends(
     // config.stacks,
-    config2.stacks.filter((stack) => filters.includes(stack.name))
+    config.stacks.filter((stack) => filters.includes(stack.name))
   );
   for (const stackConfig of filterdStacks) {
     const { stack, bindings } = toStack({
-      config: config2,
+      config,
       stackConfig,
       assets,
       plugins,
@@ -1317,17 +1363,17 @@ var getCredentials = (profile) => {
 };
 
 // src/schema/app.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/schema/stack.ts
-import { z as z22 } from "zod";
-var StackSchema = z22.object({
+import { z as z23 } from "zod";
+var StackSchema = z23.object({
   name: ResourceIdSchema,
-  depends: z22.array(z22.lazy(() => StackSchema)).optional()
+  depends: z23.array(z23.lazy(() => StackSchema)).optional()
 });
 
 // src/schema/region.ts
-import { z as z23 } from "zod";
+import { z as z24 } 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"];
@@ -1344,29 +1390,29 @@ var regions = [
   ...ME,
   ...SA
 ];
-var RegionSchema = z23.enum(regions);
+var RegionSchema = z24.enum(regions);
 
 // src/schema/plugin.ts
-import { z as z24 } from "zod";
-var PluginSchema = z24.object({
-  name: z24.string(),
-  schema: z24.custom().optional(),
+import { z as z25 } from "zod";
+var PluginSchema = z25.object({
+  name: z25.string(),
+  schema: z25.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()
+  onBootstrap: z25.function().returns(z25.any()).optional(),
+  onStack: z25.function().returns(z25.any()).optional(),
+  onApp: z25.function().returns(z25.void()).optional()
   // bind: z.function().optional(),
 });
 
 // src/schema/app.ts
-var AppSchema = z25.object({
+var AppSchema = z26.object({
   name: ResourceIdSchema,
   region: RegionSchema,
-  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()
+  profile: z26.string(),
+  stage: z26.string().regex(/[a-z]+/).default("prod"),
+  defaults: z26.object({}).default({}),
+  stacks: z26.array(StackSchema).min(1),
+  plugins: z26.array(PluginSchema).optional()
 });
 
 // src/util/import.ts
@@ -1446,14 +1492,14 @@ var importConfig = async (options) => {
       schema2 = schema2.and(plugin.schema);
     }
   }
-  const config2 = await schema2.parseAsync(appConfig);
-  debug("Load credentials", style.info(config2.profile));
-  const credentials = getCredentials(config2.profile);
+  const config = await schema2.parseAsync(appConfig);
+  debug("Load credentials", style.info(config.profile));
+  const credentials = getCredentials(config.profile);
   debug("Load AWS account ID");
-  const account = await getAccountId(credentials, config2.region);
+  const account = await getAccountId(credentials, config.region);
   debug("Account ID:", style.info(account));
   return {
-    ...config2,
+    ...config,
     account,
     credentials
   };
@@ -1475,14 +1521,14 @@ var list = (data) => {
 };
 
 // src/cli/ui/layout/header.ts
-var header = (config2) => {
+var header = (config) => {
   return [
     br(),
     list({
-      App: config2.name,
-      Stage: config2.stage,
-      Region: config2.region,
-      Profile: config2.profile
+      App: config.name,
+      Stage: config.stage,
+      Region: config.region,
+      Profile: config.profile
     }),
     br()
   ];
@@ -1800,9 +1846,9 @@ var layout = async (cb) => {
   term.out.write(logo());
   try {
     const options = program.optsWithGlobals();
-    const config2 = await importConfig(options);
-    term.out.write(header(config2));
-    await cb(config2, term.out.write.bind(term.out), term);
+    const config = await importConfig(options);
+    term.out.write(header(config));
+    await cb(config, term.out.write.bind(term.out), term);
   } catch (error) {
     if (error instanceof Error) {
       term.out.write(dialog("error", [error.message]));
@@ -1917,8 +1963,8 @@ var cleanUp = async () => {
 // src/cli/command/build.ts
 var build = (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);
+    await layout(async (config, write) => {
+      const { app, assets } = await toApp(config, filters);
       await cleanUp();
       await write(assetBuilder(assets));
       app.synth();
@@ -1931,11 +1977,11 @@ import { CloudFormationClient, CreateStackCommand, DeleteStackCommand, DescribeS
 import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2, ObjectCannedACL as ObjectCannedACL2, StorageClass as StorageClass2 } from "@aws-sdk/client-s3";
 var StackClient = class {
   // 30 seconds
-  constructor(config2) {
-    this.config = config2;
+  constructor(config) {
+    this.config = config;
     this.client = new CloudFormationClient({
-      credentials: config2.credentials,
-      region: config2.region
+      credentials: config.credentials,
+      region: config.region
     });
   }
   client;
@@ -2164,12 +2210,12 @@ var confirmPrompt = (label, options = {}) => {
 };
 
 // src/cli/ui/complex/bootstrap.ts
-var bootstrapDeployer = (config2) => {
+var bootstrapDeployer = (config) => {
   return async (term) => {
     debug("Initializing bootstrap");
-    const app = makeApp(config2);
-    const client = new StackClient(config2);
-    const bootstrap2 = bootstrapStack(config2, app);
+    const app = makeApp(config);
+    const client = new StackClient(config);
+    const bootstrap2 = bootstrapStack(config, app);
     const shouldDeploy = await shouldDeployBootstrap(client, bootstrap2.stackName);
     if (shouldDeploy) {
       term.out.write(dialog("warning", [`Your app hasn't been bootstrapped yet`]));
@@ -2193,8 +2239,8 @@ var bootstrapDeployer = (config2) => {
 // src/cli/command/bootstrap.ts
 var bootstrap = (program2) => {
   program2.command("bootstrap").description("Create the awsless bootstrap stack").action(async () => {
-    await layout(async (config2, write) => {
-      await write(bootstrapDeployer(config2));
+    await layout(async (config, write) => {
+      await write(bootstrapDeployer(config));
     });
   });
 };
@@ -2238,14 +2284,14 @@ var stackTree = (nodes, statuses) => {
 // src/cli/command/status.ts
 var status = (program2) => {
   program2.command("status").argument("[stacks...]", "Optionally filter stacks to lookup status").description("View the application status").action(async (filters) => {
-    await layout(async (config2, write) => {
-      const { app, assets, dependencyTree } = await toApp(config2, filters);
+    await layout(async (config, write) => {
+      const { app, assets, dependencyTree } = await toApp(config, filters);
       await cleanUp();
       await write(assetBuilder(assets));
       write(br());
       const assembly = app.synth();
       const doneLoading = write(loadingDialog("Loading stack information..."));
-      const client = new StackClient(config2);
+      const client = new StackClient(config);
       const statuses = [];
       const stackStatuses = {};
       assembly.stacks.forEach((stack) => {
@@ -2285,9 +2331,9 @@ var status = (program2) => {
 // src/cli/command/deploy.ts
 var deploy = (program2) => {
   program2.command("deploy").argument("[stacks...]", "Optionally filter stacks to deploy").description("Deploy your app to AWS").action(async (filters) => {
-    await layout(async (config2, write) => {
-      await write(bootstrapDeployer(config2));
-      const { app, stackNames, assets, dependencyTree } = await toApp(config2, filters);
+    await layout(async (config, write) => {
+      await write(bootstrapDeployer(config));
+      const { app, stackNames, assets, dependencyTree } = await toApp(config, filters);
       const formattedFilter = stackNames.map((i) => style.info(i)).join(style.placeholder(", "));
       debug("Stacks to deploy", formattedFilter);
       const deployAll = filters.length === 0;
@@ -2316,7 +2362,7 @@ var deploy = (program2) => {
       write(br());
       write(stackTree(dependencyTree, statuses));
       write(br());
-      const client = new StackClient(config2);
+      const client = new StackClient(config);
       const deploymentLine = createDeploymentLine(dependencyTree);
       for (const stacks of deploymentLine) {
         const results = await Promise.allSettled(stacks.map(async (stack) => {
@@ -2405,35 +2451,35 @@ var textPrompt = (label, options = {}) => {
   };
 };
 
-// src/cli/command/config/set.ts
+// src/cli/command/secrets/set.ts
 var set = (program2) => {
-  program2.command("set <name>").description("Set a config value").action(async (name) => {
-    await layout(async (config2, write) => {
-      const params = new Params(config2);
+  program2.command("set <name>").description("Set a secret value").action(async (name) => {
+    await layout(async (config, write) => {
+      const params = new Params(config);
       write(list({
-        "Set config parameter": style.info(name)
+        "Set secret parameter": style.info(name)
       }));
       write(br());
-      const value = await write(textPrompt("Enter config value"));
+      const value = await write(textPrompt("Enter secret value"));
       if (value === "") {
-        write(dialog("error", [`Provided config value can't be empty`]));
+        write(dialog("error", [`Provided secret value can't be empty`]));
       } else {
-        const done = write(loadingDialog(`Saving remote config parameter`));
+        const done = write(loadingDialog(`Saving remote secret parameter`));
         await params.set(name, value);
-        done(`Done saving remote config parameter`);
+        done(`Done saving remote secret parameter`);
       }
     });
   });
 };
 
-// src/cli/command/config/get.ts
+// src/cli/command/secrets/get.ts
 var get = (program2) => {
-  program2.command("get <name>").description("Get a config value").action(async (name) => {
-    await layout(async (config2, write) => {
-      const params = new Params(config2);
-      const done = write(loadingDialog(`Getting remote config parameter`));
+  program2.command("get <name>").description("Get a secret value").action(async (name) => {
+    await layout(async (config, write) => {
+      const params = new Params(config);
+      const done = write(loadingDialog(`Getting remote secret parameter`));
       const value = await params.get(name);
-      done(`Done getting remote config parameter`);
+      done(`Done getting remote secret parameter`);
       write(br());
       write(list({
         Name: name,
@@ -2443,20 +2489,20 @@ var get = (program2) => {
   });
 };
 
-// src/cli/command/config/delete.ts
+// src/cli/command/secrets/delete.ts
 var del = (program2) => {
-  program2.command("delete <name>").description("Delete a config value").action(async (name) => {
-    await layout(async (config2, write) => {
-      const params = new Params(config2);
-      write(dialog("warning", [`Your deleting the ${style.info(name)} config parameter`]));
+  program2.command("delete <name>").description("Delete a secret value").action(async (name) => {
+    await layout(async (config, write) => {
+      const params = new Params(config);
+      write(dialog("warning", [`Your deleting the ${style.info(name)} secret parameter`]));
       const confirm = await write(confirmPrompt("Are you sure?"));
       if (!confirm) {
         throw new Cancelled();
       }
-      const done = write(loadingDialog(`Deleting remote config parameter`));
+      const done = write(loadingDialog(`Deleting remote secret parameter`));
       const value = await params.get(name);
       await params.delete(name);
-      done(`Done deleting remote config parameter`);
+      done(`Done deleting remote secret parameter`);
       write(br());
       write(list({
         Name: name,
@@ -2466,33 +2512,33 @@ var del = (program2) => {
   });
 };
 
-// src/cli/command/config/list.ts
+// src/cli/command/secrets/list.ts
 var list2 = (program2) => {
-  program2.command("list").description(`List all config value's`).action(async () => {
-    await layout(async (config2, write) => {
-      const params = new Params(config2);
-      const done = write(loadingDialog("Loading config parameters..."));
+  program2.command("list").description(`List all secret value's`).action(async () => {
+    await layout(async (config, write) => {
+      const params = new Params(config);
+      const done = write(loadingDialog("Loading secret parameters..."));
       const values = await params.list();
-      done("Done loading config values");
+      done("Done loading secret values");
       if (Object.keys(values).length > 0) {
         write(br());
         write(list(values));
       } else {
-        write(dialog("warning", ["No config parameters found"]));
+        write(dialog("warning", ["No secret parameters found"]));
       }
     });
   });
 };
 
-// src/cli/command/config/index.ts
+// src/cli/command/secrets/index.ts
 var commands = [
   set,
   get,
   del,
   list2
 ];
-var config = (program2) => {
-  const command = program2.command("config").description("Manage config values");
+var secrets = (program2) => {
+  const command = program2.command("secrets").description(`Manage app secrets`);
   commands.forEach((cb) => cb(command));
 };
 
@@ -2513,7 +2559,7 @@ var commands2 = [
   status,
   build,
   deploy,
-  config
+  secrets
   // diff,
   // remove,
   // test,