@awsless/awsless 0.0.226 → 0.0.228

package/dist/bin.js

@@ -671,36 +671,51 @@ var TablesSchema = z17.record(
 
 // src/feature/store/schema.ts
 import { z as z18 } from "zod";
-import { seconds as seconds3 } from "@awsless/duration";
-var CorsSchema = z18.array(
-  z18.object({
-    maxAge: DurationSchema.refine(durationMin(seconds3(0))).optional().describe(
-      "The time in seconds that your browser is to cache the preflight response for the specified resource."
-    ),
-    origins: z18.array(z18.string()).describe("One or more origins you want customers to be able to access the bucket from."),
-    methods: z18.array(z18.enum(["GET", "PUT", "HEAD", "POST", "DELETE"])).describe("An HTTP method that you allow the origin to run."),
-    headers: z18.array(z18.string()).optional().describe(
-      "Headers that are specified in the Access-Control-Request-Headers header. These headers are allowed in a preflight OPTIONS request. In response to any preflight OPTIONS request, Amazon S3 returns any requested headers that are allowed."
-    ),
-    exposeHeaders: z18.array(z18.string()).optional().describe(
-      "One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object)."
-    )
-  })
-).max(100).optional().describe("Describes the AWS Lambda functions to invoke and the events for which to invoke them.");
-var LambdaConfigsSchema = z18.array(
-  z18.object({
-    event: z18.enum(["created", "removed"]).describe("The Amazon S3 bucket event for which to invoke the AWS Lambda function."),
-    consumer: FunctionSchema.describe("The consuming lambda function properties.")
-  })
-).optional().describe("Describes the AWS Lambda functions to invoke and the events for which to invoke them.");
-var StoresSchema = z18.record(
-  ResourceIdSchema,
-  z18.object({
-    lambdaConfigs: LambdaConfigsSchema,
-    cors: CorsSchema,
-    versioning: z18.boolean().default(false)
-  })
-).optional().describe("Define the stores in your stack.");
+var StoresSchema = z18.union([
+  z18.array(ResourceIdSchema).transform((list4) => {
+    const stores = {};
+    for (const key in list4) {
+      stores[key] = {};
+    }
+    return stores;
+  }),
+  z18.record(
+    ResourceIdSchema,
+    z18.object({
+      // lambdaConfigs: LambdaConfigsSchema,
+      // cors: CorsSchema,
+      versioning: z18.boolean().default(false).describe("Enable versioning of your store."),
+      events: z18.object({
+        // create
+        "created:*": FunctionSchema.describe(
+          "Subscribe to notifications regardless of the API that was used to create an object."
+        ),
+        "created:put": FunctionSchema.describe(
+          "Subscribe to notifications when an object is created using the PUT API operation."
+        ),
+        "created:post": FunctionSchema.describe(
+          "Subscribe to notifications when an object is created using the POST API operation."
+        ),
+        "created:copy": FunctionSchema.describe(
+          "Subscribe to notifications when an object is created using the COPY API operation."
+        ),
+        "created:upload": FunctionSchema.describe(
+          "Subscribe to notifications when an object multipart upload has been completed."
+        ),
+        // remove
+        "removed:*": FunctionSchema.describe(
+          "Subscribe to notifications when an object is deleted or a delete marker for a versioned object is created."
+        ),
+        "removed:delete": FunctionSchema.describe(
+          "Subscribe to notifications when an object is deleted"
+        ),
+        "removed:marker": FunctionSchema.describe(
+          "Subscribe to notifications when a delete marker for a versioned object is created."
+        )
+      }).optional().describe("Describes the store events you want to subscribe too.")
+    })
+  )
+]).optional().describe("Define the stores in your stack.");
 
 // src/feature/pubsub/schema.ts
 import { z as z19 } from "zod";
@@ -2098,6 +2113,17 @@ var build = (type, name, builder) => {
   });
 };
 
+// src/feature/on-failure/util.ts
+var getGlobalOnFailure = (ctx) => {
+  return hasOnFailure(ctx.stackConfigs) ? ctx.shared.get("on-failure-queue-arn") : void 0;
+};
+var hasOnFailure = (stacks) => {
+  const onFailure = stacks.find((stack) => {
+    return typeof stack.onFailure !== "undefined";
+  });
+  return !!onFailure;
+};
+
 // src/feature/function/util.ts
 var createLambdaFunction = (group, ctx, ns, id, local2) => {
   let name;
@@ -2227,6 +2253,24 @@ var createLambdaFunction = (group, ctx, ns, id, local2) => {
     code
   };
 };
+var createAsyncLambdaFunction = (group, ctx, ns, id, local2) => {
+  const result = createLambdaFunction(group, ctx, ns, id, local2);
+  const props = deepmerge(ctx.appConfig.defaults.function, local2);
+  result.lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
+  const invokeConfig = new aws2.lambda.EventInvokeConfig(group, "async", {
+    functionArn: result.lambda.arn,
+    retryAttempts: props.retryAttempts,
+    onFailure: getGlobalOnFailure(ctx)
+  });
+  invokeConfig.dependsOn(result.policy);
+  if (hasOnFailure(ctx.stackConfigs)) {
+    result.policy.addStatement({
+      actions: ["sqs:SendMessage", "sqs:GetQueueUrl"],
+      resources: [getGlobalOnFailure(ctx)]
+    });
+  }
+  return result;
+};
 
 // src/feature/cron/index.ts
 var cronFeature = defineFeature({
@@ -2234,8 +2278,7 @@ var cronFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.crons ?? {})) {
       const group = new Node3(ctx.stack, "cron", id);
-      const { lambda } = createLambdaFunction(group, ctx, this.name, id, props.consumer);
-      lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
+      const { lambda } = createAsyncLambdaFunction(group, ctx, "cron", id, props.consumer);
       const rule = new aws3.events.Rule(group, "rule", {
         name: formatLocalResourceName(ctx.app.name, ctx.stack.name, this.name, id),
         schedule: props.schedule,
@@ -2987,17 +3030,6 @@ var graphqlFeature = defineFeature({
   }
 });
 
-// src/feature/on-failure/util.ts
-var getGlobalOnFailure = (ctx) => {
-  return hasOnFailure(ctx.stackConfigs) ? ctx.shared.get("on-failure-queue-arn") : void 0;
-};
-var hasOnFailure = (stacks) => {
-  const onFailure = stacks.find((stack) => {
-    return typeof stack.onFailure !== "undefined";
-  });
-  return !!onFailure;
-};
-
 // src/feature/on-failure/index.ts
 import { Node as Node7, aws as aws7 } from "@awsless/formation";
 var onFailureFeature = defineFeature({
@@ -3057,7 +3089,7 @@ var pubsubFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.pubsub ?? {})) {
       const group = new Node8(ctx.stack, "pubsub", id);
-      const { lambda } = createLambdaFunction(group, ctx, `pubsub`, id, props.consumer);
+      const { lambda } = createAsyncLambdaFunction(group, ctx, `pubsub`, id, props.consumer);
       const name = formatLocalResourceName(ctx.app.name, ctx.stack.name, "pubsub", id);
       const topic = new aws8.iot.TopicRule(group, "rule", {
         name: name.replaceAll("-", "_"),
@@ -3195,35 +3227,38 @@ var storeFeature = defineFeature({
     for (const [id, props] of Object.entries(ctx.stackConfig.stores ?? {})) {
       const group = new Node10(ctx.stack, "store", id);
       const lambdaConfigs = [];
-      for (const [_, lambdaConfig] of Object.entries(props.lambdaConfigs ?? {})) {
-        const { lambda } = createLambdaFunction(group, ctx, `store`, id, lambdaConfig.consumer);
-        lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
-        let event;
-        if (lambdaConfig.event === "created") {
-          event = "s3:ObjectCreated:*";
-        } else if (lambdaConfig.event === "removed") {
-          event = "s3:ObjectRemoved:*";
-        }
+      const eventMap = {
+        "created:*": "s3:ObjectCreated:*",
+        "created:put": "s3:ObjectCreated:Put",
+        "created:post": "s3:ObjectCreated:Post",
+        "created:copy": "s3:ObjectCreated:Copy",
+        "created:upload": "s3:ObjectCreated:CompleteMultipartUpload",
+        "removed:*": "s3:ObjectRemoved:*",
+        "removed:delete": "s3:ObjectRemoved:Delete",
+        "removed:marker": "s3:ObjectRemoved:DeleteMarkerCreated"
+      };
+      for (const [event, funcProps] of Object.entries(props.events ?? {})) {
+        const { lambda } = createAsyncLambdaFunction(group, ctx, `store`, id, funcProps);
         lambdaConfigs.push({
-          event,
+          event: eventMap[event],
           function: lambda.arn
         });
       }
       const bucket = new aws10.s3.Bucket(group, "store", {
         name: formatLocalResourceName(ctx.appConfig.name, ctx.stack.name, "store", id),
         versioning: props.versioning,
-        cors: props.cors,
-        lambdaConfigs
-        // cors: [
-        // 	// ---------------------------------------------
-        // 	// Support for presigned post requests
-        // 	// ---------------------------------------------
-        // 	{
-        // 		origins: ['*'],
-        // 		methods: ['POST'],
-        // 	},
-        // 	// ---------------------------------------------
-        // ],
+        lambdaConfigs,
+        // cors: props.cors,
+        cors: [
+          // ---------------------------------------------
+          // Support for presigned post requests
+          // ---------------------------------------------
+          {
+            origins: ["*"],
+            methods: ["POST"]
+          }
+          // ---------------------------------------------
+        ]
       });
       ctx.onFunction(({ policy }) => {
         policy.addStatement(bucket.permissions);
@@ -3363,8 +3398,7 @@ var topicFeature = defineFeature({
           endpoint: props
         });
       } else if (typeof props === "object") {
-        const { lambda } = createLambdaFunction(group, ctx, `topic`, id, props);
-        lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
+        const { lambda } = createAsyncLambdaFunction(group, ctx, `topic`, id, props);
         new aws12.sns.Subscription(group, id, {
           topicArn,
           protocol: "lambda",
@@ -3465,10 +3499,10 @@ var authFeature = defineFeature({
       const list4 = {};
       for (const [trigger, triggerProps] of Object.entries(props.triggers ?? {})) {
         const triggerGroup = new Node14(group, "trigger", trigger);
-        const { lambda, policy } = createLambdaFunction(
+        const { lambda, policy } = createAsyncLambdaFunction(
           triggerGroup,
           ctx,
-          this.name,
+          "auth",
           `${id}-${trigger}`,
           triggerProps
         );
@@ -3787,7 +3821,7 @@ var searchFeature = defineFeature({
 
 // src/feature/site/index.ts
 import { Asset as Asset3, Node as Node17, aws as aws17 } from "@awsless/formation";
-import { days as days3, seconds as seconds4 } from "@awsless/duration";
+import { days as days3, seconds as seconds3 } from "@awsless/duration";
 import { glob as glob2 } from "glob";
 import { join as join8 } from "path";
 
@@ -3900,7 +3934,7 @@ var siteFeature = defineFeature({
       }
       const cache = new aws17.cloudFront.CachePolicy(group, "cache", {
         name,
-        minTtl: seconds4(1),
+        minTtl: seconds3(1),
         maxTtl: days3(365),
         defaultTtl: days3(1),
         ...props.cache
@@ -4082,7 +4116,7 @@ var restFeature = defineFeature({
 // src/feature/task/index.ts
 import { camelCase as camelCase6 } from "change-case";
 import { relative as relative4 } from "path";
-import { Node as Node19, aws as aws19 } from "@awsless/formation";
+import { Node as Node19 } from "@awsless/formation";
 var typeGenCode7 = `
 import { InvokeOptions } from '@awsless/lambda'
 import type { Mock } from 'vitest'
@@ -4131,20 +4165,7 @@ var taskFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.tasks ?? {})) {
       const group = new Node19(ctx.stack, "task", id);
-      const { lambda, policy } = createLambdaFunction(group, ctx, "task", id, props.consumer);
-      lambda.addEnvironment("LOG_VIEWABLE_ERROR", "1");
-      const invokeConfig = new aws19.lambda.EventInvokeConfig(group, "config", {
-        functionArn: lambda.arn,
-        retryAttempts: props.retryAttempts,
-        onFailure: getGlobalOnFailure(ctx)
-      });
-      invokeConfig.dependsOn(policy);
-      if (hasOnFailure(ctx.stackConfigs)) {
-        policy.addStatement({
-          actions: ["sqs:SendMessage", "sqs:GetQueueUrl"],
-          resources: [getGlobalOnFailure(ctx)]
-        });
-      }
+      createAsyncLambdaFunction(group, ctx, "task", id, props.consumer);
     }
   }
 });
@@ -4488,20 +4509,20 @@ var config = (program2) => {
 import { confirm as confirm3 } from "@clack/prompts";
 
 // src/util/workspace.ts
-import { WorkSpace, aws as aws20, local } from "@awsless/formation";
+import { WorkSpace, aws as aws19, local } from "@awsless/formation";
 import { minutes as minutes4 } from "@awsless/duration";
 import { dirname as dirname8, join as join9 } from "path";
 import { mkdir as mkdir2, readFile as readFile6, rm, writeFile as writeFile2 } from "fs/promises";
 var createWorkSpace = (props) => {
-  const lockProvider = new aws20.dynamodb.LockProvider({
+  const lockProvider = new aws19.dynamodb.LockProvider({
     ...props,
     tableName: "awsless-locks"
   });
-  const stateProvider = new aws20.s3.StateProvider({
+  const stateProvider = new aws19.s3.StateProvider({
     ...props,
     bucket: "awsless-state"
   });
-  const cloudProviders = aws20.createCloudProviders({
+  const cloudProviders = aws19.createCloudProviders({
     ...props,
     timeout: minutes4(60)
   });
@@ -4575,7 +4596,7 @@ var del2 = (program2) => {
 import { confirm as confirm4 } from "@clack/prompts";
 
 // src/cli/ui/complex/run-tests.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { mkdir as mkdir3, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 
 // src/test/reporter.ts
@@ -4633,14 +4654,8 @@ var CustomReporter = class {
       this.cache = cache;
     }
   }
-  onUserConsoleLog(log10) {
-    if (log10.taskId) {
-      const test2 = this.ctx?.state.idMap.get(log10.taskId);
-      if (test2) {
-        test2.name;
-      }
-    }
-    this.logs.push(log10.content.trimEnd());
+  onUserConsoleLog(log9) {
+    this.logs.push(log9.content.trimEnd());
   }
   runningTask(tasks) {
     return tasks.find((t) => t.result?.state === "run");
@@ -4664,7 +4679,10 @@ import { startVitest } from "vitest/node";
 import commonjs3 from "@rollup/plugin-commonjs";
 import nodeResolve3 from "@rollup/plugin-node-resolve";
 import json3 from "@rollup/plugin-json";
+import { dirname as dirname9, join as join10 } from "path";
+import { fileURLToPath } from "url";
 var startTest = async (props) => {
+  const __dirname = dirname9(fileURLToPath(import.meta.url));
   const result = await startVitest(
     "test",
     props.filters,
@@ -4677,7 +4695,11 @@ var startTest = async (props) => {
       include: ["**/*.{js,jsx,ts,tsx}"],
       exclude: ["**/_*", "**/_*/**", ...configDefaults.exclude],
       globals: true,
-      reporters: props.reporter
+      reporters: props.reporter,
+      globalSetup: join10(__dirname, "test-global-setup.js")
+      // env: {
+      // 	TZ: 'UTC',
+      // },
       // typecheck: {
       // 	enabled: true,
       // 	// ignoreSourceErrors: false,
@@ -4732,7 +4754,7 @@ var logTestLogs = (event) => {
     log8.message(color.info.bold.inverse(" LOGS "), {
       symbol: color.dim(icon.dot)
     });
-    log8.message(event.logs.map((log10) => wrap(log10, { hard: true })).join("\n"));
+    log8.message(event.logs.map((log9) => wrap(log9, { hard: true })).join("\n"));
   }
 };
 var logTestErrors = (event) => {
@@ -4770,7 +4792,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters) => {
   await mkdir3(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join10(directories.test, `${stack}.json`);
+  const file = join11(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile7(file, { encoding: "utf8" });
@@ -4877,7 +4899,7 @@ var deploy = (program2) => {
 };
 
 // src/cli/command/diff.ts
-import { WorkSpace as WorkSpace2, aws as aws21 } from "@awsless/formation";
+import { WorkSpace as WorkSpace2, aws as aws20 } from "@awsless/formation";
 import chalk7 from "chalk";
 var diff = (program2) => {
   program2.command("diff").description("Diff your app with AWS").action(async (filters) => {
@@ -4889,12 +4911,12 @@ var diff = (program2) => {
       const { app, builders } = createApp({ appConfig, stackConfigs, accountId }, filters);
       await buildAssets(builders);
       const workspace = new WorkSpace2({
-        stateProvider: new aws21.dynamodb.DynamoDBStateProvider({
+        stateProvider: new aws20.dynamodb.DynamoDBStateProvider({
           credentials,
           region,
           tableName: "awsless-state"
         }),
-        cloudProviders: aws21.createCloudProviders({
+        cloudProviders: aws20.createCloudProviders({
           credentials,
           region: appConfig.region
         })
@@ -4945,12 +4967,9 @@ var diff = (program2) => {
   });
 };
 
-// src/cli/ui/complex/build-types.ts
-import { log as log9 } from "@clack/prompts";
-
 // src/type-gen/generate.ts
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname9, join as join11, relative as relative5 } from "path";
+import { dirname as dirname10, join as join12, relative as relative5 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -4959,12 +4978,12 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path = join11(directories.types, file);
+          const path = join12(directories.types, file);
           if (code) {
             if (include) {
               files.push(relative5(directories.root, path));
             }
-            await mkdir4(dirname9(path), { recursive: true });
+            await mkdir4(dirname10(path), { recursive: true });
             await writeFile4(path, code);
           }
         }
@@ -4973,14 +4992,16 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join11(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join12(directories.root, `awsless.d.ts`), code);
   }
 };
 
 // src/cli/ui/complex/build-types.ts
 var buildTypes = async (props) => {
-  await generateTypes(props);
-  log9.step("Done generating type definition files.");
+  await task("Generate type definition files", async (update) => {
+    await generateTypes(props);
+    update("Done generating type definition files.");
+  });
 };
 
 // src/cli/command/types.ts

package/dist/build-json-schema.js

@@ -309,40 +309,55 @@ var TablesSchema = z8.record(
 
 // src/feature/store/schema.ts
 import { z as z9 } from "zod";
-import { seconds as seconds2 } from "@awsless/duration";
-var CorsSchema = z9.array(
-  z9.object({
-    maxAge: DurationSchema.refine(durationMin(seconds2(0))).optional().describe(
-      "The time in seconds that your browser is to cache the preflight response for the specified resource."
-    ),
-    origins: z9.array(z9.string()).describe("One or more origins you want customers to be able to access the bucket from."),
-    methods: z9.array(z9.enum(["GET", "PUT", "HEAD", "POST", "DELETE"])).describe("An HTTP method that you allow the origin to run."),
-    headers: z9.array(z9.string()).optional().describe(
-      "Headers that are specified in the Access-Control-Request-Headers header. These headers are allowed in a preflight OPTIONS request. In response to any preflight OPTIONS request, Amazon S3 returns any requested headers that are allowed."
-    ),
-    exposeHeaders: z9.array(z9.string()).optional().describe(
-      "One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object)."
-    )
-  })
-).max(100).optional().describe("Describes the AWS Lambda functions to invoke and the events for which to invoke them.");
-var LambdaConfigsSchema = z9.array(
-  z9.object({
-    event: z9.enum(["created", "removed"]).describe("The Amazon S3 bucket event for which to invoke the AWS Lambda function."),
-    consumer: FunctionSchema.describe("The consuming lambda function properties.")
-  })
-).optional().describe("Describes the AWS Lambda functions to invoke and the events for which to invoke them.");
-var StoresSchema = z9.record(
-  ResourceIdSchema,
-  z9.object({
-    lambdaConfigs: LambdaConfigsSchema,
-    cors: CorsSchema,
-    versioning: z9.boolean().default(false)
-  })
-).optional().describe("Define the stores in your stack.");
+var StoresSchema = z9.union([
+  z9.array(ResourceIdSchema).transform((list) => {
+    const stores = {};
+    for (const key in list) {
+      stores[key] = {};
+    }
+    return stores;
+  }),
+  z9.record(
+    ResourceIdSchema,
+    z9.object({
+      // lambdaConfigs: LambdaConfigsSchema,
+      // cors: CorsSchema,
+      versioning: z9.boolean().default(false).describe("Enable versioning of your store."),
+      events: z9.object({
+        // create
+        "created:*": FunctionSchema.describe(
+          "Subscribe to notifications regardless of the API that was used to create an object."
+        ),
+        "created:put": FunctionSchema.describe(
+          "Subscribe to notifications when an object is created using the PUT API operation."
+        ),
+        "created:post": FunctionSchema.describe(
+          "Subscribe to notifications when an object is created using the POST API operation."
+        ),
+        "created:copy": FunctionSchema.describe(
+          "Subscribe to notifications when an object is created using the COPY API operation."
+        ),
+        "created:upload": FunctionSchema.describe(
+          "Subscribe to notifications when an object multipart upload has been completed."
+        ),
+        // remove
+        "removed:*": FunctionSchema.describe(
+          "Subscribe to notifications when an object is deleted or a delete marker for a versioned object is created."
+        ),
+        "removed:delete": FunctionSchema.describe(
+          "Subscribe to notifications when an object is deleted"
+        ),
+        "removed:marker": FunctionSchema.describe(
+          "Subscribe to notifications when a delete marker for a versioned object is created."
+        )
+      }).optional().describe("Describes the store events you want to subscribe too.")
+    })
+  )
+]).optional().describe("Define the stores in your stack.");
 
 // src/feature/queue/schema.ts
 import { z as z10 } from "zod";
-import { days as days2, hours, minutes as minutes2, seconds as seconds3 } from "@awsless/duration";
+import { days as days2, hours, minutes as minutes2, seconds as seconds2 } from "@awsless/duration";
 import { kibibytes } from "@awsless/size";
 var RetentionPeriodSchema = DurationSchema.refine(
   durationMin(minutes2(1)),
@@ -363,9 +378,9 @@ var DeliveryDelaySchema = DurationSchema.refine(
   "The time in seconds for which the delivery of all messages in the queue is delayed. You can specify a duration from 0 to 15 minutes."
 );
 var ReceiveMessageWaitTimeSchema = DurationSchema.refine(
-  durationMin(seconds3(1)),
+  durationMin(seconds2(1)),
   "Minimum receive message wait time is 1 second"
-).refine(durationMax(seconds3(20)), "Maximum receive message wait time is 20 seconds").describe(
+).refine(durationMax(seconds2(20)), "Maximum receive message wait time is 20 seconds").describe(
   "Specifies the duration, that the ReceiveMessage action call waits until a message is in the queue in order to include it in the response, rather than returning an empty response if a message isn't yet available. You can specify a duration from 1 to 20 seconds. Short polling is used as the default."
 );
 var MaxMessageSizeSchema = SizeSchema.refine(sizeMin(kibibytes(1)), "Minimum max message size is 1 KB").refine(sizeMax(kibibytes(256)), "Maximum max message size is 256 KB").describe(