@awsless/awsless 0.0.43 → 0.0.44

package/dist/bin.js

@@ -54,90 +54,6 @@ var flushDebug = () => {
   return queue.splice(0, queue.length);
 };
 
-// src/util/param.ts
-import { DeleteParameterCommand, GetParameterCommand, GetParametersByPathCommand, ParameterType, PutParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
-var configParameterPrefix = (config) => {
-  return `/.awsless/${config.name}`;
-};
-var Params = class {
-  constructor(config) {
-    this.config = config;
-    this.client = new SSMClient({
-      credentials: config.credentials,
-      region: config.region
-    });
-  }
-  client;
-  getName(name) {
-    return `${configParameterPrefix(this.config)}/${name}`;
-  }
-  async get(name) {
-    debug("Get remote config value");
-    debug("Name:", style.info(name));
-    let result;
-    try {
-      result = await this.client.send(new GetParameterCommand({
-        Name: this.getName(name),
-        WithDecryption: true
-      }));
-    } catch (error) {
-      if (error instanceof Error && error.name === "ParameterNotFound") {
-        debug("Parameter not found");
-        return;
-      }
-      throw error;
-    }
-    const value = result.Parameter?.Value;
-    debug("Value:", style.info(value));
-    debug("Done getting remote config value");
-    return value;
-  }
-  async set(name, value) {
-    debug("Save remote config value");
-    debug("Name:", style.info(name));
-    debug("Value:", style.info(value));
-    await this.client.send(new PutParameterCommand({
-      Type: ParameterType.STRING,
-      Name: this.getName(name),
-      Value: value,
-      Overwrite: true
-    }));
-    debug("Done saving remote config value");
-  }
-  async delete(name) {
-    debug("Delete remote config value");
-    debug("Name:", style.info(name));
-    try {
-      await this.client.send(new DeleteParameterCommand({
-        Name: this.getName(name)
-      }));
-    } catch (error) {
-      if (error instanceof Error && error.name === "ParameterNotFound") {
-        debug("Remote config value was already deleted");
-        return;
-      }
-      throw error;
-    }
-    debug("Done deleting remote config value");
-  }
-  async list() {
-    debug("Load remote config values");
-    const result = await this.client.send(new GetParametersByPathCommand({
-      Path: configParameterPrefix(this.config),
-      WithDecryption: true,
-      MaxResults: 10,
-      Recursive: true
-    }));
-    debug("Done loading remote config values");
-    const values = {};
-    result.Parameters?.forEach((param) => {
-      const name = param.Name.substring(configParameterPrefix(this.config).length).substring(1);
-      values[name] = param.Value || "";
-    });
-    return values;
-  }
-};
-
 // src/formation/asset.ts
 import { paramCase } from "change-case";
 var Asset = class {
@@ -261,11 +177,12 @@ var Lazy = class {
 
 // src/formation/resource/iam/inline-policy.ts
 var InlinePolicy = class {
+  name;
+  statements;
   constructor(name, props = {}) {
-    this.name = name;
     this.statements = props.statements || [];
+    this.name = formatName(name);
   }
-  statements;
   addStatement(...statements) {
     this.statements.push(...statements.flat());
     return this;
@@ -304,9 +221,7 @@ var Role = class extends Resource {
   constructor(logicalId, props = {}) {
     super("AWS::IAM::Role", logicalId);
     this.props = props;
-    this.name = formatName(logicalId);
   }
-  name;
   inlinePolicies = /* @__PURE__ */ new Set();
   managedPolicies = /* @__PURE__ */ new Set();
   get arn() {
@@ -571,18 +486,6 @@ var toStack = ({ config, app, stackConfig, bootstrap: bootstrap2, usEastBootstra
       bind2(fn);
     }
   }
-  for (const fn of functions) {
-    fn.addPermissions({
-      actions: [
-        "ssm:GetParameter",
-        "ssm:GetParameters",
-        "ssm:GetParametersByPath"
-      ],
-      resources: [
-        sub("arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter" + configParameterPrefix(config))
-      ]
-    });
-  }
   return {
     stack,
     bindings
@@ -749,7 +652,7 @@ var LocalFileSchema = z3.string().refine(async (path) => {
 // src/schema/resource-id.ts
 import { paramCase as paramCase3 } from "change-case";
 import { z as z4 } from "zod";
-var ResourceIdSchema = z4.string().min(3).max(24).regex(/^[a-z\-]+$/i, "Invalid resource ID").transform((value) => paramCase3(value));
+var ResourceIdSchema = z4.string().min(3).max(24).regex(/^[a-z0-9\-]+$/i, "Invalid resource ID").transform((value) => paramCase3(value));
 
 // src/schema/size.ts
 import { z as z5 } from "zod";
@@ -1063,7 +966,7 @@ import { relative as relative2 } from "path";
 // src/util/type-gen.ts
 import { mkdir, writeFile } from "fs/promises";
 import { join as join2, relative } from "path";
-import { camelCase } from "change-case";
+import { camelCase, constantCase } from "change-case";
 var generateResourceTypes = async (config) => {
   const plugins = [
     ...defaultPlugins,
@@ -1085,9 +988,10 @@ var generateResourceTypes = async (config) => {
   }
 };
 var TypeGen = class {
-  constructor(module, interfaceName) {
+  constructor(module, interfaceName, readonly = true) {
     this.module = module;
     this.interfaceName = interfaceName;
+    this.readonly = readonly;
   }
   codes = /* @__PURE__ */ new Set();
   types = /* @__PURE__ */ new Map();
@@ -1102,7 +1006,13 @@ var TypeGen = class {
   }
   addType(name, type) {
     if (type) {
-      this.types.set(name, type);
+      this.types.set(camelCase(name), type);
+    }
+    return this;
+  }
+  addConst(name, type) {
+    if (type) {
+      this.types.set(constantCase(name), type);
     }
     return this;
   }
@@ -1133,7 +1043,7 @@ var TypeGen = class {
       `declare module '${this.module}' {`,
       `	interface ${this.interfaceName} {`,
       ...Array.from(this.types.entries()).map(([propName, type]) => {
-        return `		readonly ${camelCase(propName)}: ${type}`;
+        return `		${this.readonly ? "readonly " : ""}${propName}: ${type}`;
       }),
       `	}`,
       `}`,
@@ -1146,7 +1056,15 @@ var TypeGen = class {
 var TypeObject = class {
   types = /* @__PURE__ */ new Map();
   addType(name, type) {
-    this.types.set(name, type);
+    if (type) {
+      this.types.set(camelCase(name), type);
+    }
+    return this;
+  }
+  addConst(name, type) {
+    if (type) {
+      this.types.set(constantCase(name), type);
+    }
     return this;
   }
   toString() {
@@ -1156,7 +1074,7 @@ var TypeObject = class {
     return [
       "{",
       ...Array.from(this.types.entries()).map(([propName, type]) => {
-        return `			readonly ${camelCase(propName)}: ${type}`;
+        return `			readonly ${propName}: ${type}`;
       }),
       "		}"
     ].join("\n");
@@ -1230,6 +1148,9 @@ var FunctionSchema = z6.union([
     // onFailure: ResourceIdSchema.optional(),
   })
 ]);
+var isFunctionProps = (input) => {
+  return typeof input === "string" || typeof input.file === "string";
+};
 var schema = z6.object({
   defaults: z6.object({
     function: z6.object({
@@ -1429,7 +1350,7 @@ var Permission2 = class extends Resource {
       FunctionName: this.props.functionArn,
       Action: this.props.action || "lambda:InvokeFunction",
       Principal: this.props.principal,
-      SourceArn: this.props.sourceArn
+      ...this.attr("SourceArn", this.props.sourceArn)
     };
   }
 };
@@ -1555,7 +1476,7 @@ var Queue = class extends Resource {
 };
 
 // src/formation/resource/lambda/event-source-mapping.ts
-import { constantCase } from "change-case";
+import { constantCase as constantCase2 } from "change-case";
 var EventSourceMapping = class extends Resource {
   constructor(logicalId, props) {
     super("AWS::Lambda::EventSourceMapping", logicalId);
@@ -1577,7 +1498,7 @@ var EventSourceMapping = class extends Resource {
       ...this.attr("ParallelizationFactor", this.props.parallelizationFactor),
       ...this.attr("TumblingWindowInSeconds", this.props.tumblingWindow?.toSeconds()),
       ...this.attr("BisectBatchOnFunctionError", this.props.bisectBatchOnError),
-      ...this.attr("StartingPosition", this.props.startingPosition && constantCase(this.props.startingPosition)),
+      ...this.attr("StartingPosition", this.props.startingPosition && constantCase2(this.props.startingPosition)),
       ...this.attr("StartingPositionTimestamp", this.props.startingPositionTimestamp),
       ...this.props.maxConcurrency ? {
         ScalingConfig: {
@@ -1618,7 +1539,7 @@ var SqsEventSource = class extends Group {
 };
 
 // src/plugins/queue.ts
-import { camelCase as camelCase3, constantCase as constantCase2 } from "change-case";
+import { camelCase as camelCase3, constantCase as constantCase3 } from "change-case";
 import { relative as relative3 } from "path";
 var RetentionPeriodSchema = DurationSchema.refine(durationMin(Duration.minutes(1)), "Minimum retention period is 1 minute").refine(durationMax(Duration.days(14)), "Maximum retention period is 14 days");
 var VisibilityTimeoutSchema = DurationSchema.refine(durationMax(Duration.hours(12)), "Maximum visibility timeout is 12 hours");
@@ -1773,7 +1694,7 @@ var queuePlugin = definePlugin({
       stack.add(queue2, lambda, source);
       bind((lambda2) => {
         lambda2.addPermissions(queue2.permissions);
-        lambda2.addEnvironment(`QUEUE_${constantCase2(stack.name)}_${constantCase2(id)}_URL`, queue2.url);
+        lambda2.addEnvironment(`QUEUE_${constantCase3(stack.name)}_${constantCase3(id)}_URL`, queue2.url);
       });
     }
   }
@@ -1783,7 +1704,7 @@ var queuePlugin = definePlugin({
 import { z as z9 } from "zod";
 
 // src/formation/resource/dynamodb/table.ts
-import { constantCase as constantCase3 } from "change-case";
+import { constantCase as constantCase4 } from "change-case";
 var Table = class extends Resource {
   constructor(logicalId, props) {
     super("AWS::DynamoDB::Table", logicalId);
@@ -1856,7 +1777,7 @@ var Table = class extends Resource {
     return {
       TableName: this.name,
       BillingMode: "PAY_PER_REQUEST",
-      TableClass: constantCase3(this.props.class || "standard"),
+      TableClass: constantCase4(this.props.class || "standard"),
       PointInTimeRecoverySpecification: {
         PointInTimeRecoveryEnabled: this.props.pointInTimeRecovery || false
       },
@@ -1867,7 +1788,7 @@ var Table = class extends Resource {
       AttributeDefinitions: this.attributeDefinitions(),
       ...this.props.stream ? {
         StreamSpecification: {
-          StreamViewType: constantCase3(this.props.stream)
+          StreamViewType: constantCase4(this.props.stream)
         }
       } : {},
       ...this.props.timeToLiveAttribute ? {
@@ -1884,7 +1805,7 @@ var Table = class extends Resource {
             ...props.sort ? [{ KeyType: "RANGE", AttributeName: props.sort }] : []
           ],
           Projection: {
-            ProjectionType: constantCase3(props.projection || "all")
+            ProjectionType: constantCase4(props.projection || "all")
           }
         }))
       } : {}
@@ -2234,54 +2155,81 @@ var topicPlugin = definePlugin({
   name: "topic",
   schema: z11.object({
     stacks: z11.object({
-      /** Define the topics to listen too in your stack.
+      /** Define the events to publish too in your stack.
        * @example
        * {
-       *   topics: {
+       *   topics: [ 'TOPIC_NAME' ]
+       * }
+       */
+      topics: z11.array(ResourceIdSchema).refine((topics) => {
+        return topics.length === new Set(topics).size;
+      }, "Must be a list of unique topic names").optional(),
+      /** Define the events to subscribe too in your stack.
+       * @example
+       * {
+       *   subscribers: {
        *     TOPIC_NAME: 'function.ts'
        *   }
        * }
        */
-      topics: z11.record(ResourceIdSchema, FunctionSchema).optional()
-    }).array()
+      subscribers: z11.record(ResourceIdSchema, FunctionSchema).optional()
+    }).array().superRefine((stacks, ctx) => {
+      const topics = [];
+      for (const stack of stacks) {
+        topics.push(...stack.topics || []);
+      }
+      for (const index in stacks) {
+        const stack = stacks[index];
+        for (const sub2 of Object.keys(stack.subscribers || {})) {
+          if (!topics.includes(sub2)) {
+            ctx.addIssue({
+              code: z11.ZodIssueCode.custom,
+              message: `Topic subscription to "${sub2}" is undefined`,
+              path: [Number(index), "subscribers"]
+            });
+          }
+        }
+      }
+    })
   }),
   onTypeGen({ config }) {
     const gen = new TypeGen("@awsless/awsless", "TopicResources");
     gen.addCode(typeGenCode3);
     for (const stack of config.stacks) {
-      for (const topic of Object.keys(stack.topics || {})) {
+      for (const topic of stack.topics || []) {
         const name = formatName(`${config.name}-${topic}`);
         gen.addType(topic, `Publish<'${name}'>`);
       }
     }
     return gen.toString();
   },
-  onApp({ config, bootstrap: bootstrap2, bind }) {
-    const allTopicNames = config.stacks.map((stack) => {
-      return Object.keys(stack.topics || {});
-    }).flat();
-    const uniqueTopicNames = [...new Set(allTopicNames)];
-    for (const id of uniqueTopicNames) {
-      const topic = new Topic(id, {
-        name: `${config.name}-${id}`
-      });
-      bootstrap2.add(topic);
-      bootstrap2.export(`topic-${id}-arn`, topic.arn);
+  onApp({ config, bootstrap: bootstrap2 }) {
+    for (const stack of config.stacks) {
+      for (const id of stack.topics || []) {
+        const topic = new Topic(id, {
+          name: `${config.name}-${id}`
+        });
+        bootstrap2.add(topic);
+        bootstrap2.export(`topic-${id}-arn`, topic.arn);
+      }
     }
-    bind((lambda) => {
-      lambda.addPermissions({
-        actions: ["sns:Publish"],
-        resources: [
-          sub("arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${app}-*", {
-            app: config.name
-          })
-        ]
-      });
-    });
   },
   onStack(ctx) {
-    const { stack, stackConfig, bootstrap: bootstrap2 } = ctx;
-    for (const [id, props] of Object.entries(stackConfig.topics || {})) {
+    const { config, stack, stackConfig, bootstrap: bootstrap2, bind } = ctx;
+    for (const id of stackConfig.topics || []) {
+      bind((lambda) => {
+        lambda.addPermissions({
+          actions: ["sns:Publish"],
+          resources: [
+            sub("arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${app}-${topic}", {
+              app: config.name,
+              topic: id
+            })
+          ]
+        });
+      });
+    }
+    for (const [id, props] of Object.entries(stackConfig.subscribers || {})) {
       const lambda = toLambdaFunction(ctx, `topic-${id}`, props);
       const source = new SnsEventSource(id, lambda, {
         topicArn: bootstrap2.import(`topic-${id}-arn`)
@@ -2423,7 +2371,7 @@ var toArray = (value) => {
 import { paramCase as paramCase4 } from "change-case";
 
 // src/formation/resource/appsync/graphql-api.ts
-import { constantCase as constantCase4 } from "change-case";
+import { constantCase as constantCase5 } from "change-case";
 var GraphQLApi = class extends Resource {
   constructor(logicalId, props) {
     super("AWS::AppSync::GraphQLApi", logicalId);
@@ -2455,7 +2403,7 @@ var GraphQLApi = class extends Resource {
   properties() {
     return {
       Name: this.name,
-      AuthenticationType: constantCase4(this.props.authenticationType || "api-key"),
+      AuthenticationType: constantCase5(this.props.authenticationType || "api-key"),
       AdditionalAuthenticationProviders: this.lambdaAuthProviders.map((provider) => ({
         AuthenticationType: "AWS_LAMBDA",
         LambdaAuthorizerConfig: {
@@ -2784,10 +2732,18 @@ var graphqlPlugin = definePlugin({
           z14.array(LocalFileSchema).min(1)
         ]).optional(),
         resolvers: z14.record(
+          // TypeName
           z14.string(),
           z14.record(
+            // FieldName
             z14.string(),
-            FunctionSchema
+            z14.union([
+              FunctionSchema,
+              z14.object({
+                consumer: FunctionSchema,
+                resolver: LocalFileSchema
+              })
+            ])
           )
         ).optional()
       })).optional()
@@ -2855,14 +2811,15 @@ var graphqlPlugin = definePlugin({
     for (const [id, props] of Object.entries(stackConfig.graphql || {})) {
       const apiId = bootstrap2.import(`graphql-${id}`);
       for (const [typeName, fields] of Object.entries(props.resolvers || {})) {
-        for (const [fieldName, functionProps] of Object.entries(fields || {})) {
+        for (const [fieldName, resolverProps] of Object.entries(fields || {})) {
+          const props2 = isFunctionProps(resolverProps) ? { consumer: resolverProps } : resolverProps;
           const entryId = paramCase4(`${id}-${typeName}-${fieldName}`);
-          const lambda = toLambdaFunction(ctx, `graphql-${entryId}`, functionProps);
+          const lambda = toLambdaFunction(ctx, `graphql-${entryId}`, props2.consumer);
           const source = new AppsyncEventSource(entryId, lambda, {
             apiId,
             typeName,
             fieldName,
-            code: Code2.fromInline(entryId, defaultResolver)
+            code: Code2.fromInline(entryId, props2.resolver || defaultResolver)
           });
           stack.add(lambda, source);
         }
@@ -2943,6 +2900,37 @@ var RecordSetGroup = class extends Resource {
   }
 };
 
+// src/custom/util.ts
+var sendCode = (
+  /* JS */
+  `
+
+const send = async (event, id, status, data, reason = '') => {
+	const body = JSON.stringify({
+		Status: status,
+		Reason: reason,
+		PhysicalResourceId: id,
+		StackId: event.StackId,
+		RequestId: event.RequestId,
+		LogicalResourceId: event.LogicalResourceId,
+		NoEcho: false,
+		Data: data
+	})
+
+	await fetch(event.ResponseURL, {
+		method: 'PUT',
+		port: 443,
+		body,
+		headers: {
+			'content-type': '',
+            'content-length': Buffer.from(body).byteLength,
+		},
+	})
+}
+
+`
+);
+
 // src/custom/delete-hosted-zone/handler.ts
 var deleteHostedZoneRecordsHandlerCode = (
   /* JS */
@@ -2952,6 +2940,8 @@ const { Route53Client, ListResourceRecordSetsCommand, ChangeResourceRecordSetsCo
 
 const client = new Route53Client({})
 
+${sendCode}
+
 exports.handler = async (event) => {
 	const type = event.RequestType
 	const hostedZoneId = event.ResourceProperties.hostedZoneId
@@ -2975,29 +2965,6 @@ exports.handler = async (event) => {
 	}
 }
 
-const send = async (event, id, status, data = {}, reason = '') => {
-	const body = JSON.stringify({
-		Status: status,
-		Reason: reason,
-		PhysicalResourceId: id,
-		StackId: event.StackId,
-		RequestId: event.RequestId,
-		LogicalResourceId: event.LogicalResourceId,
-		NoEcho: false,
-		Data: data
-	})
-
-	await fetch(event.ResponseURL, {
-		method: 'PUT',
-		port: 443,
-		body,
-		headers: {
-			'content-type': '',
-            'content-length': Buffer.from(body).byteLength,
-		},
-	})
-}
-
 const deleteHostedZoneRecords = async (hostedZoneId, records) => {
 	records = records.filter(record => ![ 'SOA', 'NS' ].includes(record.Type))
 	if(records.length === 0) {
@@ -3541,7 +3508,7 @@ var LoadBalancer = class extends Resource {
 };
 
 // src/formation/resource/elb/listener.ts
-import { constantCase as constantCase5 } from "change-case";
+import { constantCase as constantCase6 } from "change-case";
 var Listener = class extends Resource {
   constructor(logicalId, props) {
     super("AWS::ElasticLoadBalancingV2::Listener", logicalId);
@@ -3557,7 +3524,7 @@ var Listener = class extends Resource {
     return {
       LoadBalancerArn: this.props.loadBalancerArn,
       Port: this.props.port,
-      Protocol: constantCase5(this.props.protocol),
+      Protocol: constantCase6(this.props.protocol),
       Certificates: this.props.certificates.map((arn) => ({
         CertificateArn: arn
       })),
@@ -3996,7 +3963,7 @@ var SubnetGroup = class extends Resource {
 };
 
 // src/plugins/cache.ts
-import { constantCase as constantCase6 } from "change-case";
+import { constantCase as constantCase7 } from "change-case";
 var TypeSchema = z19.enum([
   "t4g.small",
   "t4g.medium",
@@ -4082,9 +4049,420 @@ var cachePlugin = definePlugin({
       }).dependsOn(subnetGroup, securityGroup);
       stack.add(subnetGroup, securityGroup, cluster);
       bind((lambda) => {
-        lambda.addEnvironment(`CACHE_${constantCase6(stack.name)}_${constantCase6(id)}_HOST`, cluster.address).addEnvironment(`CACHE_${constantCase6(stack.name)}_${constantCase6(id)}_PORT`, props.port.toString());
+        lambda.addEnvironment(`CACHE_${constantCase7(stack.name)}_${constantCase7(id)}_HOST`, cluster.address).addEnvironment(`CACHE_${constantCase7(stack.name)}_${constantCase7(id)}_PORT`, props.port.toString());
+      });
+    }
+  }
+});
+
+// src/plugins/rest.ts
+import { z as z21 } from "zod";
+
+// src/schema/route.ts
+import { z as z20 } from "zod";
+var RouteSchema2 = z20.custom((route) => {
+  return z20.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/ig).safeParse(route).success;
+}, "Invalid route");
+
+// src/formation/resource/api-gateway-v2/api.ts
+var Api = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::ApiGatewayV2::Api", logicalId);
+    this.props = props;
+    this.name = formatName(this.props.name || logicalId);
+  }
+  name;
+  get endpoint() {
+    return getAtt(this.logicalId, "ApiEndpoint");
+  }
+  get id() {
+    return getAtt(this.logicalId, "ApiId");
+  }
+  properties() {
+    return {
+      Name: this.name,
+      ProtocolType: this.props.protocolType,
+      ...this.attr("Description", this.props.description),
+      CorsConfiguration: {
+        ...this.attr("AllowCredentials", this.props.cors?.allow?.credentials),
+        ...this.attr("AllowHeaders", this.props.cors?.allow?.headers),
+        ...this.attr("AllowMethods", this.props.cors?.allow?.methods),
+        ...this.attr("AllowOrigins", this.props.cors?.allow?.origins),
+        ...this.attr("ExposeHeaders", this.props.cors?.expose?.headers),
+        ...this.attr("MaxAge", this.props.cors?.maxAge?.toSeconds())
+      }
+    };
+  }
+};
+
+// src/formation/resource/api-gateway-v2/integration.ts
+var Integration = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::ApiGatewayV2::Integration", logicalId);
+    this.props = props;
+  }
+  get id() {
+    return ref(this.logicalId);
+  }
+  properties() {
+    return {
+      ApiId: this.props.apiId,
+      IntegrationType: this.props.type,
+      IntegrationUri: this.props.uri,
+      IntegrationMethod: this.props.method,
+      PayloadFormatVersion: this.props.payloadFormatVersion ?? "2.0",
+      ...this.attr("Description", this.props.description)
+    };
+  }
+};
+
+// src/formation/resource/api-gateway-v2/route.ts
+var Route2 = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::ApiGatewayV2::Route", logicalId);
+    this.props = props;
+  }
+  get id() {
+    return getAtt(this.logicalId, "RouteId");
+  }
+  properties() {
+    return {
+      ApiId: this.props.apiId,
+      RouteKey: this.props.routeKey,
+      Target: this.props.target
+    };
+  }
+};
+
+// src/formation/resource/lambda/event-source/api-gateway-v2.ts
+var ApiGatewayV2EventSource = class extends Group {
+  constructor(id, lambda, props) {
+    const name = formatName(id);
+    const permission = new Permission2(id, {
+      action: "lambda:InvokeFunction",
+      principal: "apigateway.amazonaws.com",
+      functionArn: lambda.arn
+    }).dependsOn(lambda);
+    const integration = new Integration(id, {
+      apiId: props.apiId,
+      description: name,
+      method: "POST",
+      payloadFormatVersion: "2.0",
+      type: "AWS_PROXY",
+      uri: sub("arn:${AWS::Partition}:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${lambda}/invocations", {
+        lambda: lambda.arn
+      })
+    });
+    const route = new Route2(id, {
+      apiId: props.apiId,
+      routeKey: props.routeKey,
+      target: sub("integrations/${id}", { id: integration.id })
+    }).dependsOn(lambda, permission, integration);
+    super([integration, route, permission]);
+  }
+};
+
+// src/formation/resource/api-gateway-v2/domain-name.ts
+var DomainName2 = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::ApiGatewayV2::DomainName", logicalId);
+    this.props = props;
+  }
+  get name() {
+    return ref(this.logicalId);
+  }
+  get regionalDomainName() {
+    return getAtt(this.logicalId, "RegionalDomainName");
+  }
+  get regionalHostedZoneId() {
+    return getAtt(this.logicalId, "RegionalHostedZoneId");
+  }
+  properties() {
+    return {
+      DomainName: this.props.name,
+      DomainNameConfigurations: [{
+        CertificateArn: this.props.certificateArn
+      }]
+    };
+  }
+};
+
+// src/formation/resource/api-gateway-v2/stage.ts
+var Stage = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::ApiGatewayV2::Stage", logicalId);
+    this.props = props;
+    this.name = formatName(this.props.name || logicalId);
+  }
+  name;
+  properties() {
+    return {
+      ApiId: this.props.apiId,
+      StageName: this.name,
+      AutoDeploy: this.props.autoDeploy ?? true,
+      ...this.attr("DeploymentId", this.props.deploymentId),
+      ...this.attr("Description", this.props.description)
+    };
+  }
+};
+
+// src/formation/resource/api-gateway-v2/api-mapping.ts
+var ApiMapping = class extends Resource {
+  constructor(logicalId, props) {
+    super("AWS::ApiGatewayV2::ApiMapping", logicalId);
+    this.props = props;
+  }
+  get id() {
+    return getAtt(this.logicalId, "ApiMappingId");
+  }
+  properties() {
+    return {
+      DomainName: this.props.domainName,
+      ApiId: this.props.apiId,
+      Stage: this.props.stage
+    };
+  }
+};
+
+// src/plugins/rest.ts
+var restPlugin = definePlugin({
+  name: "rest",
+  schema: z21.object({
+    defaults: z21.object({
+      /** Define your global REST API's.
+       * @example
+       * {
+       *   rest: {
+       *     REST_API_NAME: {
+       *       domain: 'example.com',
+       *       subDomain: 'api',
+       *     }
+       *   }
+       * }
+       */
+      rest: z21.record(
+        ResourceIdSchema,
+        z21.object({
+          /** The domain to link your API with. */
+          domain: z21.string(),
+          subDomain: z21.string().optional()
+        })
+      ).optional()
+    }).default({}),
+    stacks: z21.object({
+      /** Define routes in your stack for your global REST API.
+       * @example
+       * {
+       *   rest: {
+       *     REST_API_NAME: {
+       *       'GET /': 'index.ts',
+       *       'POST /posts': 'create-post.ts',
+       *     }
+       *   }
+       * }
+       */
+      rest: z21.record(
+        ResourceIdSchema,
+        z21.record(RouteSchema2, FunctionSchema)
+      ).optional()
+    }).array()
+  }),
+  onApp({ config, bootstrap: bootstrap2, usEastBootstrap }) {
+    for (const [id, props] of Object.entries(config.defaults?.rest || {})) {
+      const api = new Api(id, {
+        name: `${config.name}-${id}`,
+        protocolType: "HTTP"
       });
+      const stage = new Stage(id, {
+        name: "v1",
+        apiId: api.id
+      }).dependsOn(api);
+      bootstrap2.add(api, stage).export(`rest-${id}-id`, api.id);
+      if (props.domain) {
+        const domainName = props.subDomain ? `${props.subDomain}.${props.domain}` : props.domain;
+        const hostedZoneId = usEastBootstrap.import(`hosted-zone-${props.domain}-id`);
+        const certificateArn = bootstrap2.import(`certificate-${props.domain}-arn`);
+        const domain = new DomainName2(id, {
+          name: domainName,
+          certificateArn
+        });
+        const mapping = new ApiMapping(id, {
+          apiId: api.id,
+          domainName: domain.name,
+          stage: stage.name
+        }).dependsOn(api, domain, stage);
+        const record = new RecordSet(`${id}-rest`, {
+          hostedZoneId,
+          type: "A",
+          name: domainName,
+          alias: {
+            dnsName: domain.regionalDomainName,
+            hostedZoneId: domain.regionalHostedZoneId
+          }
+        }).dependsOn(domain, mapping);
+        bootstrap2.add(domain, mapping, record);
+      }
+    }
+  },
+  onStack(ctx) {
+    const { stack, stackConfig, bootstrap: bootstrap2 } = ctx;
+    for (const [id, routes] of Object.entries(stackConfig.rest || {})) {
+      for (const [routeKey, props] of Object.entries(routes)) {
+        const lambda = toLambdaFunction(ctx, `rest-${id}-${routeKey}`, props);
+        const source = new ApiGatewayV2EventSource(`rest-${id}-${routeKey}`, lambda, {
+          apiId: bootstrap2.import(`rest-${id}-id`),
+          routeKey
+        });
+        stack.add(lambda, source);
+      }
+    }
+  }
+});
+
+// src/plugins/config.ts
+import { z as z22 } from "zod";
+
+// src/util/param.ts
+import { DeleteParameterCommand, GetParameterCommand, GetParametersByPathCommand, ParameterType, PutParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+var configParameterPrefix = (config) => {
+  return `/.awsless/${config.name}`;
+};
+var Params = class {
+  constructor(config) {
+    this.config = config;
+    this.client = new SSMClient({
+      credentials: config.credentials,
+      region: config.region
+    });
+  }
+  client;
+  getName(name) {
+    return `${configParameterPrefix(this.config)}/${name}`;
+  }
+  async get(name) {
+    debug("Get remote config value");
+    debug("Name:", style.info(name));
+    let result;
+    try {
+      result = await this.client.send(new GetParameterCommand({
+        Name: this.getName(name),
+        WithDecryption: true
+      }));
+    } catch (error) {
+      if (error instanceof Error && error.name === "ParameterNotFound") {
+        debug("Parameter not found");
+        return;
+      }
+      throw error;
+    }
+    const value = result.Parameter?.Value;
+    debug("Value:", style.info(value));
+    debug("Done getting remote config value");
+    return value;
+  }
+  async set(name, value) {
+    debug("Save remote config value");
+    debug("Name:", style.info(name));
+    debug("Value:", style.info(value));
+    await this.client.send(new PutParameterCommand({
+      Type: ParameterType.STRING,
+      Name: this.getName(name),
+      Value: value,
+      Overwrite: true
+    }));
+    debug("Done saving remote config value");
+  }
+  async delete(name) {
+    debug("Delete remote config value");
+    debug("Name:", style.info(name));
+    try {
+      await this.client.send(new DeleteParameterCommand({
+        Name: this.getName(name)
+      }));
+    } catch (error) {
+      if (error instanceof Error && error.name === "ParameterNotFound") {
+        debug("Remote config value was already deleted");
+        return;
+      }
+      throw error;
+    }
+    debug("Done deleting remote config value");
+  }
+  async list() {
+    debug("Load remote config values");
+    const result = await this.client.send(new GetParametersByPathCommand({
+      Path: configParameterPrefix(this.config),
+      WithDecryption: true,
+      MaxResults: 10,
+      Recursive: true
+    }));
+    debug("Done loading remote config values");
+    const values = {};
+    result.Parameters?.forEach((param) => {
+      const name = param.Name.substring(configParameterPrefix(this.config).length).substring(1);
+      values[name] = param.Value || "";
+    });
+    return values;
+  }
+};
+
+// src/plugins/config.ts
+import { paramCase as paramCase5 } from "change-case";
+var ConfigNameSchema = z22.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var configPlugin = definePlugin({
+  name: "config",
+  schema: z22.object({
+    stacks: z22.object({
+      /** Define the config values for your stack.
+       * @example
+       * ```
+       * {
+       *   configs: [ 'your-secret' ]
+       * }
+       * ```
+       *
+       * You can access the config values via:
+       * @example
+       * ```
+       * import { Config } from '@awsless/awsless'
+       *
+       * Config.YOUR_SECRET
+       * ```
+       */
+      configs: z22.array(ConfigNameSchema).optional()
+    }).array()
+  }),
+  onTypeGen({ config }) {
+    const types2 = new TypeGen("@awsless/awsless", "ConfigResources", false);
+    for (const stack of config.stacks) {
+      for (const name of stack.configs || []) {
+        types2.addConst(name, "string");
+      }
     }
+    return types2.toString();
+  },
+  onStack({ bind, config, stackConfig }) {
+    const configs = stackConfig.configs;
+    bind((lambda) => {
+      if (configs && configs.length) {
+        lambda.addEnvironment("AWSLESS_CONFIG", configs.join(","));
+        lambda.addPermissions({
+          actions: [
+            "ssm:GetParameter",
+            "ssm:GetParameters",
+            "ssm:GetParametersByPath"
+          ],
+          resources: configs.map((name) => {
+            return formatArn({
+              service: "ssm",
+              resource: "parameter",
+              resourceName: configParameterPrefix(config) + "/" + paramCase5(name),
+              seperator: ""
+            });
+          })
+        });
+      }
+    });
   }
 });
 
@@ -4093,6 +4471,7 @@ var defaultPlugins = [
   extendPlugin,
   vpcPlugin,
   functionPlugin,
+  configPlugin,
   cachePlugin,
   cronPlugin,
   queuePlugin,
@@ -4104,6 +4483,7 @@ var defaultPlugins = [
   domainPlugin,
   graphqlPlugin,
   httpPlugin,
+  restPlugin,
   onFailurePlugin
 ];
 
@@ -4141,6 +4521,8 @@ var globalExportsHandlerCode = (
 
 const { CloudFormationClient, ListExportsCommand } = require('@aws-sdk/client-cloudformation')
 
+${sendCode}
+
 exports.handler = async (event) => {
 	const region = event.ResourceProperties.region
 
@@ -4157,29 +4539,6 @@ exports.handler = async (event) => {
 	}
 }
 
-const send = async (event, id, status, data, reason = '') => {
-	const body = JSON.stringify({
-		Status: status,
-		Reason: reason,
-		PhysicalResourceId: id,
-		StackId: event.StackId,
-		RequestId: event.RequestId,
-		LogicalResourceId: event.LogicalResourceId,
-		NoEcho: false,
-		Data: data
-	})
-
-	await fetch(event.ResponseURL, {
-		method: 'PUT',
-		port: 443,
-		body,
-		headers: {
-			'content-type': '',
-            'content-length': Buffer.from(body).byteLength,
-		},
-	})
-}
-
 const listExports = async (region) => {
 	const client = new CloudFormationClient({ region })
 	const data = {}
@@ -4357,17 +4716,17 @@ var getCredentials = (profile) => {
 };
 
 // src/schema/app.ts
-import { z as z23 } from "zod";
+import { z as z26 } from "zod";
 
 // src/schema/stack.ts
-import { z as z20 } from "zod";
-var StackSchema = z20.object({
+import { z as z23 } from "zod";
+var StackSchema = z23.object({
   name: ResourceIdSchema,
-  depends: z20.array(z20.lazy(() => StackSchema)).optional()
+  depends: z23.array(z23.lazy(() => StackSchema)).optional()
 });
 
 // src/schema/region.ts
-import { z as z21 } 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"];
@@ -4384,41 +4743,41 @@ var regions = [
   ...ME,
   ...SA
 ];
-var RegionSchema = z21.enum(regions);
+var RegionSchema = z24.enum(regions);
 
 // src/schema/plugin.ts
-import { z as z22 } from "zod";
-var PluginSchema = z22.object({
-  name: z22.string(),
-  schema: z22.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(),
-  onApp: z22.function().returns(z22.void()).optional(),
-  onStack: z22.function().returns(z22.any()).optional(),
-  onResource: z22.function().returns(z22.any()).optional()
+  onApp: z25.function().returns(z25.void()).optional(),
+  onStack: z25.function().returns(z25.any()).optional(),
+  onResource: z25.function().returns(z25.any()).optional()
   // bind: z.function().optional(),
 });
 
 // src/schema/app.ts
-var AppSchema = z23.object({
+var AppSchema = z26.object({
   /** App name */
   name: ResourceIdSchema,
   /** The AWS region to deploy to. */
   region: RegionSchema,
   /** The AWS profile to deploy to. */
-  profile: z23.string(),
+  profile: z26.string(),
   /** The deployment stage.
    * @default 'prod'
    */
-  stage: z23.string().regex(/^[a-z]+$/).default("prod"),
+  stage: z26.string().regex(/^[a-z]+$/).default("prod"),
   /** Default properties. */
-  defaults: z23.object({}).default({}),
+  defaults: z26.object({}).default({}),
   /** The application stacks. */
-  stacks: z23.array(StackSchema).min(1).refine((stacks) => {
+  stacks: z26.array(StackSchema).min(1).refine((stacks) => {
     const unique = new Set(stacks.map((stack) => stack.name));
     return unique.size === stacks.length;
   }, "Must be an array of unique stacks"),
   /** Custom plugins. */
-  plugins: z23.array(PluginSchema).optional()
+  plugins: z26.array(PluginSchema).optional()
 });
 
 // src/util/import.ts
@@ -4515,7 +4874,7 @@ var watchFile = (path) => {
 };
 
 // src/config.ts
-import { z as z24 } from "zod";
+import { z as z27 } from "zod";
 var ConfigError = class extends Error {
   constructor(error, data) {
     super(error.message);
@@ -4548,7 +4907,7 @@ var importConfig = async (options) => {
   try {
     config = await schema2.parseAsync(appConfig);
   } catch (error) {
-    if (error instanceof z24.ZodError) {
+    if (error instanceof z27.ZodError) {
       throw new ConfigError(error, appConfig);
     }
     throw error;
@@ -4589,7 +4948,7 @@ var watchConfig = async function* (options) {
     try {
       config = await schema2.parseAsync(appConfig);
     } catch (error) {
-      if (error instanceof z24.ZodError) {
+      if (error instanceof z27.ZodError) {
         throw new ConfigError(error, appConfig);
       }
       throw error;
@@ -5080,7 +5439,6 @@ var format = (value) => {
 };
 var zodError = (error, data) => {
   return (term) => {
-    term.out.write(JSON.stringify(error.errors));
     for (const issue of error.issues) {
       term.out.gap();
       term.out.write(dialog("error", [
@@ -5365,7 +5723,7 @@ var shouldDeployBootstrap = async (client, stack) => {
 // src/formation/client.ts
 import { CloudFormationClient, CreateStackCommand, DeleteStackCommand, DescribeStackEventsCommand, DescribeStacksCommand, GetTemplateCommand, OnFailure, TemplateStage, UpdateStackCommand, ValidateTemplateCommand, waitUntilStackCreateComplete, waitUntilStackDeleteComplete, waitUntilStackUpdateComplete } from "@aws-sdk/client-cloudformation";
 import { S3Client, PutObjectCommand, ObjectCannedACL, StorageClass } from "@aws-sdk/client-s3";
-import { paramCase as paramCase5 } from "change-case";
+import { paramCase as paramCase6 } from "change-case";
 var StackClient = class {
   constructor(app, account, region, credentials) {
     this.app = app;
@@ -5398,7 +5756,7 @@ var StackClient = class {
     };
   }
   stackName(stackName) {
-    return paramCase5(`${this.app.name}-${stackName}`);
+    return paramCase6(`${this.app.name}-${stackName}`);
   }
   tags(stack) {
     const tags = [];
@@ -5411,7 +5769,8 @@ var StackClient = class {
     debug("Upload the", style.info(stack.name), "stack to awsless assets bucket");
     const client = new S3Client({
       credentials: this.credentials,
-      region: stack.region
+      region: stack.region,
+      maxAttempts: 5
     });
     await client.send(new PutObjectCommand({
       Bucket: this.assetBucketName,
@@ -5831,7 +6190,8 @@ import { GetObjectCommand, ObjectCannedACL as ObjectCannedACL2, PutObjectCommand
 var assetPublisher = (config, app) => {
   const client = new S3Client2({
     credentials: config.credentials,
-    region: config.region
+    region: config.region,
+    maxAttempts: 5
   });
   return async (term) => {
     const done = term.out.write(loadingDialog("Publishing stack assets to AWS..."));