@awsless/awsless 0.0.549 → 0.0.550

package/dist/bin.js

@@ -370,7 +370,7 @@ var createWorkSpace = async (props) => {
   if (process.env.VERBOSE) {
     enableDebug();
   }
-  const aws = await terraform.install("hashicorp", "aws", "5.98.0");
+  const aws = await terraform.install("hashicorp", "aws", "6.9.0");
   const workspace = new WorkSpace({
     providers: [
       createLambdaProvider(props),
@@ -998,32 +998,30 @@ var DomainSchema = ResourceIdSchema.describe("The domain id to link your Pubsub
 var PubSubDefaultSchema = z18.record(
   ResourceIdSchema,
   z18.object({
-    auth: FunctionSchema,
+    auth: FunctionSchema.describe("The authentication function for the pubsub API."),
     domain: DomainSchema.optional(),
-    subDomain: z18.string().optional()
-    // auth: z.union([
-    // 	ResourceIdSchema,
-    // 	z.object({
-    // 		authorizer: FunctionSchema,
-    // 		// ttl: AuthorizerTtl.default('1 hour'),
-    // 	}),
-    // ]),
-    // policy: z
-    // 	.object({
-    // 		publish: z.array(z.string()).optional(),
-    // 		subscribe: z.array(z.string()).optional(),
-    // 	})
-    // 	.optional(),
+    subDomain: z18.string().optional(),
+    namespaces: z18.array(z18.string()).optional().describe('The namespaces for the PubSub API. If not set, a single "default" namespace is created.'),
+    logLevel: z18.enum(["none", "info", "error", "debug", "all"]).optional().describe("The logging level for AppSync API. When set, logging is enabled.")
   })
-).optional().describe("Define the pubsub subscriber in your stack.");
+).optional().describe("Define the pubsub API configuration in your stack.");
 var PubSubSchema = z18.record(
   ResourceIdSchema,
   z18.object({
-    sql: z18.string().describe("The SQL statement used to query the IOT topic."),
-    sqlVersion: z18.enum(["2015-10-08", "2016-03-23", "beta"]).default("2016-03-23").describe("The version of the SQL rules engine to use when evaluating the rule."),
-    consumer: FunctionSchema.describe("The consuming lambda function properties.")
+    channels: z18.array(z18.string()).describe("The event channels this subscriber listens to."),
+    filter: z18.object({
+      eventType: z18.string().optional().describe("Filter events by event type.")
+      // Add more filter options as needed
+      // userId: z.string().optional(),
+      // custom: z.record(z.string(), z.any()).optional(),
+    }).optional().describe("Event filtering options."),
+    consumer: FunctionSchema.describe("The consuming lambda function properties."),
+    batchSize: z18.number().int().min(1).max(100).default(1).describe("Number of events to batch before invoking the consumer function."),
+    retryPolicy: z18.object({
+      maxRetries: z18.number().int().min(0).max(3).default(2).describe("Maximum number of retry attempts.")
+    }).optional().describe("Retry policy for failed event processing.")
   })
-).optional().describe("Define the pubsub subscriber in your stack.");
+).optional().describe("Define the pubsub event subscribers in your stack.");
 
 // src/feature/queue/schema.ts
 import { days as days2, hours, minutes as minutes2, seconds as seconds2 } from "@awsless/duration";
@@ -1790,8 +1788,7 @@ var StoresSchema = z35.union([
   z35.record(
     ResourceIdSchema,
     z35.object({
-      // cors: CorsSchema,
-      // deletionProtection: DeletionProtectionSchema.optional(),
+      static: LocalDirectorySchema.optional().describe("Specifies the path to the static files directory."),
       versioning: z35.boolean().default(false).describe("Enable versioning of your store."),
       events: z35.object({
         // create
@@ -3977,87 +3974,137 @@ var formatFullDomainName = (config2, id, subDomain) => {
 var pubsubFeature = defineFeature({
   name: "pubsub",
   onApp(ctx) {
-    for (const [id, props] of Object.entries(ctx.appConfig.defaults.pubsub ?? {})) {
+    for (const [id, props] of Object.entries(ctx.appConfig.defaults?.pubsub ?? {})) {
       const group = new Group9(ctx.base, "pubsub", id);
-      const { lambda } = createLambdaFunction(group, ctx, "pubsub-authorizer", id, props.auth);
+      const shortName = `${ctx.app.name}--${id}`;
       const name = formatGlobalResourceName({
         appName: ctx.app.name,
         resourceType: "pubsub",
         resourceName: id
       });
-      const authorizer = new $9.aws.iot.Authorizer(group, "authorizer", {
-        name,
-        authorizerFunctionArn: lambda.arn,
-        status: "ACTIVE",
-        signingDisabled: true,
-        enableCachingForHttp: false
+      const authGroup = new Group9(group, "auth", "lambda");
+      const { lambda: authLambda } = createLambdaFunction(authGroup, ctx, "pubsub", `${id}-auth`, {
+        ...props.auth,
+        description: `PubSub ${id} authorizer`
       });
-      new $9.aws.lambda.Permission(group, "permission", {
-        functionName: lambda.functionName,
-        action: "lambda:InvokeFunction",
-        principal: "iot.amazonaws.com",
-        sourceArn: authorizer.arn
+      let loggingRole;
+      if (props.logLevel) {
+        loggingRole = new $9.aws.iam.Role(group, "logging-role", {
+          name: shortId(`${name}-logging-role`),
+          assumeRolePolicy: JSON.stringify({
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Effect: "Allow",
+                Principal: {
+                  Service: "appsync.amazonaws.com"
+                },
+                Action: "sts:AssumeRole"
+              }
+            ]
+          })
+        });
+        new $9.aws.iam.RolePolicyAttachment(group, "logs-policy", {
+          role: loggingRole.name,
+          policyArn: "arn:aws:iam::aws:policy/service-role/AWSAppSyncPushToCloudWatchLogs"
+        });
+      }
+      const api = new $9.aws.appsync.Api(group, "api", {
+        name: shortName,
+        eventConfig: [
+          {
+            connectionAuthMode: [{ authType: "AWS_IAM" }, { authType: "AWS_LAMBDA" }],
+            authProvider: [
+              {
+                authType: "AWS_LAMBDA",
+                lambdaAuthorizerConfig: [
+                  {
+                    authorizerUri: authLambda.arn,
+                    authorizerResultTtlInSeconds: 300
+                  }
+                ]
+              },
+              {
+                authType: "AWS_IAM"
+              }
+            ],
+            defaultPublishAuthMode: [
+              {
+                authType: "AWS_IAM"
+              }
+            ],
+            defaultSubscribeAuthMode: [
+              {
+                authType: "AWS_LAMBDA"
+              },
+              {
+                authType: "AWS_IAM"
+              }
+            ],
+            logConfig: props.logLevel ? [
+              {
+                logLevel: props.logLevel.toUpperCase(),
+                cloudwatchLogsRoleArn: loggingRole.arn
+              }
+            ] : void 0
+          }
+        ]
       });
-      ctx.bind(`PUBSUB_${constantCase5(id)}_AUTHORIZER`, name);
-      const endpoint = $9.aws.iot.getEndpoint(group, "endpoint", {
-        endpointType: "iot:Data-ATS"
+      const namespaces = props.namespaces ?? ["default"];
+      for (const namespace of namespaces) {
+        new $9.aws.appsync.ChannelNamespace(group, `namespace-${namespace}`, {
+          name: namespace,
+          apiId: api.apiId
+        });
+      }
+      new $9.aws.lambda.Permission(group, "auth-permission", {
+        action: "lambda:InvokeFunction",
+        principal: "appsync.amazonaws.com",
+        functionName: authLambda.functionName,
+        sourceArn: api.apiArn
       });
       if (props.domain) {
         const domainName = formatFullDomainName(ctx.appConfig, props.domain, props.subDomain);
-        new $9.aws.iot.DomainConfiguration(group, "domain", {
-          name,
+        const zoneId = ctx.shared.entry("domain", `zone-id`, props.domain);
+        const certificateArn = ctx.shared.entry("domain", `certificate-arn`, props.domain);
+        const apiDomain = new $9.aws.appsync.DomainName(group, "domain", {
           domainName,
-          serverCertificateArns: [ctx.shared.entry("domain", `certificate-arn`, props.domain)],
-          authorizerConfig: {
-            defaultAuthorizerName: authorizer.name
-          }
-          // validationCertificate: ctx.shared.get(`global-certificate-${props.domain}-arn`),
+          certificateArn
+        });
+        new $9.aws.appsync.DomainNameApiAssociation(group, "domain-association", {
+          apiId: api.apiArn,
+          domainName: apiDomain.domainName
         });
         new $9.aws.route53.Record(group, "record", {
-          zoneId: ctx.shared.entry("domain", `zone-id`, props.domain),
-          name: domainName,
+          zoneId,
           type: "CNAME",
-          records: [endpoint.endpointAddress]
+          name: domainName,
+          records: [apiDomain.appsyncDomainName],
+          ttl: 300
         });
-        ctx.bind(`PUBSUB_${constantCase5(id)}_ENDPOINT`, domainName);
+        ctx.bind(`PUBSUB_${constantCase5(id)}_ENDPOINT`, `${domainName}/event`);
+        ctx.bind(`PUBSUB_${constantCase5(id)}_REALTIME_ENDPOINT`, `${domainName}/event/realtime`);
       } else {
-        ctx.bind(`PUBSUB_${constantCase5(id)}_ENDPOINT`, endpoint.endpointAddress);
+        ctx.bind(
+          `PUBSUB_${constantCase5(id)}_ENDPOINT`,
+          api.dns.pipe((dns) => dns.HTTP)
+        );
+        ctx.bind(
+          `PUBSUB_${constantCase5(id)}_REALTIME_ENDPOINT`,
+          api.dns.pipe((dns) => dns.REALTIME)
+        );
       }
     }
-    ctx.addGlobalPermission({
-      actions: [`iot:Publish`],
-      resources: [
-        //
-        `arn:aws:iot:${ctx.appConfig.region}:${ctx.accountId}:topic/*`,
-        `arn:aws:iot:${ctx.appConfig.region}:${ctx.accountId}:topic/${ctx.app.name}/pubsub/*`
-      ]
-    });
-  },
-  onStack(ctx) {
-    for (const [id, props] of Object.entries(ctx.stackConfig.pubsub ?? {})) {
-      const group = new Group9(ctx.stack, "pubsub", id);
-      const { lambda } = createAsyncLambdaFunction(group, ctx, `pubsub`, id, props.consumer);
-      const name = formatLocalResourceName({
-        appName: ctx.app.name,
-        stackName: ctx.stack.name,
-        resourceType: "pubsub",
-        resourceName: id
-      });
-      const topic = new $9.aws.iot.TopicRule(group, "rule", {
-        name: name.replaceAll("-", "_"),
-        enabled: true,
-        sql: props.sql,
-        sqlVersion: props.sqlVersion,
-        lambda: [{ functionArn: lambda.arn }]
-      });
-      new $9.aws.lambda.Permission(group, "permission", {
-        action: "lambda:InvokeFunction",
-        principal: "iot.amazonaws.com",
-        functionName: lambda.functionName,
-        sourceArn: topic.arn
-      });
-    }
   }
+  // Note: The onStack method would handle channel namespaces and subscriptions
+  // but is commented out for now as it needs to be refactored for AppSync Event API
+  // onStack(ctx) {
+  // 	// Channel namespaces and event handlers would be configured here
+  // 	// This would include:
+  // 	// 1. Creating channel namespaces with their own auth modes (overriding defaults)
+  // 	// 2. Setting up event handlers (Lambda functions) for specific channels
+  // 	// 3. Configuring event filtering and routing rules
+  // },
 });
 
 // src/feature/queue/index.ts
@@ -5431,6 +5478,30 @@ var siteFeature = defineFeature({
 import { Group as Group16 } from "@awsless/formation";
 import { kebabCase as kebabCase7 } from "change-case";
 import { $ as $16 } from "@awsless/formation";
+import { glob as glob3 } from "glob";
+
+// src/feature/store/util.ts
+import { contentType as contentType2, lookup as lookup2 } from "mime-types";
+import { extname as extname3 } from "path";
+var getCacheControl2 = (file) => {
+  switch (lookup2(file)) {
+    case false:
+    case "text/html":
+    case "application/json":
+    case "application/manifest+json":
+    case "application/manifest":
+    case "text/markdown":
+      return "s-maxage=31536000, max-age=0";
+    default:
+      return `public, max-age=31536000, immutable`;
+  }
+};
+var getContentType2 = (file) => {
+  return contentType2(extname3(file)) || "text/html; charset=utf-8";
+};
+
+// src/feature/store/index.ts
+import { join as join12 } from "path";
 var typeGenCode5 = `
 import { Body, PutObjectProps, BodyStream } from '@awsless/s3'
 
@@ -5523,6 +5594,24 @@ var storeFeature = defineFeature({
           import: ctx.import ? name : void 0
         }
       );
+      ctx.onReady(() => {
+        if (typeof props.static === "string" && bucket) {
+          const files = glob3.sync("**", {
+            cwd: props.static,
+            nodir: true
+          });
+          for (const file of files) {
+            new $16.aws.s3.BucketObject(group, file, {
+              bucket: bucket.bucket,
+              key: file,
+              cacheControl: getCacheControl2(file),
+              contentType: getContentType2(file),
+              source: join12(props.static, file),
+              sourceHash: $hash(join12(props.static, file))
+            });
+          }
+        }
+      });
       const eventMap = {
         "created:*": "s3:ObjectCreated:*",
         "created:put": "s3:ObjectCreated:Put",
@@ -6213,12 +6302,12 @@ var layerFeature = defineFeature({
 
 // src/feature/image/index.ts
 import { $ as $23, Group as Group23 } from "@awsless/formation";
-import { join as join12, dirname as dirname8 } from "path";
+import { join as join13, dirname as dirname8 } from "path";
 import { mebibytes as mebibytes4 } from "@awsless/size";
 import { days as days7, seconds as seconds9, toDays as toDays6, toSeconds as toSeconds8 } from "@awsless/duration";
 import { constantCase as constantCase12 } from "change-case";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { glob as glob3 } from "glob";
+import { glob as glob4 } from "glob";
 var __dirname2 = dirname8(fileURLToPath2(import.meta.url));
 var imageFeature = defineFeature({
   name: "image",
@@ -6230,7 +6319,7 @@ var imageFeature = defineFeature({
       return;
     }
     const group = new Group23(ctx.base, "image", "layer");
-    const path = join12(__dirname2, "/layers/sharp-arm.zip");
+    const path = join13(__dirname2, "/layers/sharp-arm.zip");
     const layerId = formatGlobalResourceName({
       appName: ctx.appConfig.name,
       resourceType: "layer",
@@ -6313,8 +6402,8 @@ var imageFeature = defineFeature({
         resourceName: "sharp"
       });
       const serverLambda = createPrebuildLambdaFunction(group, ctx, "image", id, {
-        bundleFile: join12(__dirname2, "/prebuild/image/bundle.zip"),
-        bundleHash: join12(__dirname2, "/prebuild/image/HASH"),
+        bundleFile: join13(__dirname2, "/prebuild/image/bundle.zip"),
+        bundleHash: join13(__dirname2, "/prebuild/image/HASH"),
         memorySize: mebibytes4(512),
         timeout: seconds9(10),
         handler: "index.default",
@@ -6372,7 +6461,7 @@ var imageFeature = defineFeature({
       }
       ctx.onReady(() => {
         if (props.origin.static && s3Origin) {
-          const files = glob3.sync("**", {
+          const files = glob4.sync("**", {
             cwd: props.origin.static,
             nodir: true
           });
@@ -6380,8 +6469,8 @@ var imageFeature = defineFeature({
             new $23.aws.s3.BucketObject(group, `static-${file}`, {
               bucket: s3Origin.bucket,
               key: file,
-              source: join12(props.origin.static, file),
-              sourceHash: $hash(join12(props.origin.static, file))
+              source: join13(props.origin.static, file),
+              sourceHash: $hash(join13(props.origin.static, file))
             });
           }
         }
@@ -6533,12 +6622,12 @@ var imageFeature = defineFeature({
 
 // src/feature/icon/index.ts
 import { $ as $24, Group as Group24 } from "@awsless/formation";
-import { join as join13, dirname as dirname9 } from "path";
+import { join as join14, dirname as dirname9 } from "path";
 import { mebibytes as mebibytes5 } from "@awsless/size";
 import { days as days8, seconds as seconds10, toDays as toDays7, toSeconds as toSeconds9 } from "@awsless/duration";
 import { constantCase as constantCase13 } from "change-case";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { glob as glob4 } from "glob";
+import { glob as glob5 } from "glob";
 var __dirname3 = dirname9(fileURLToPath3(import.meta.url));
 var iconFeature = defineFeature({
   name: "icon",
@@ -6591,8 +6680,8 @@ var iconFeature = defineFeature({
         } : {}
       });
       const serverLambda = createPrebuildLambdaFunction(group, ctx, "icon", id, {
-        bundleFile: join13(__dirname3, "/prebuild/icon/bundle.zip"),
-        bundleHash: join13(__dirname3, "/prebuild/icon/HASH"),
+        bundleFile: join14(__dirname3, "/prebuild/icon/bundle.zip"),
+        bundleHash: join14(__dirname3, "/prebuild/icon/HASH"),
         memorySize: mebibytes5(512),
         timeout: seconds10(10),
         handler: "index.default",
@@ -6648,7 +6737,7 @@ var iconFeature = defineFeature({
       }
       ctx.onReady(() => {
         if (props.origin.static && s3Origin) {
-          const files = glob4.sync("**", {
+          const files = glob5.sync("**", {
             cwd: props.origin.static,
             nodir: true
           });
@@ -6659,8 +6748,8 @@ var iconFeature = defineFeature({
             new $24.aws.s3.BucketObject(group, `static-${file}`, {
               bucket: s3Origin.bucket,
               key: file,
-              source: join13(props.origin.static, file),
-              sourceHash: $hash(join13(props.origin.static, file))
+              source: join14(props.origin.static, file),
+              sourceHash: $hash(join14(props.origin.static, file))
             });
           }
         }
@@ -6820,15 +6909,15 @@ import { toMebibytes as toMebibytes4 } from "@awsless/size";
 import { generateFileHash as generateFileHash2 } from "@awsless/ts-file-cache";
 import { constantCase as constantCase14, pascalCase as pascalCase3 } from "change-case";
 import deepmerge4 from "deepmerge";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/feature/instance/build/executable.ts
 import { createHash as createHash4 } from "crypto";
 import { readFile as readFile4 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { exec as exec2 } from "promisify-child-process";
 var buildExecutable = async (input, outputPath) => {
-  const filePath = join14(outputPath, "program");
+  const filePath = join15(outputPath, "program");
   const args = ["build", input, "--compile", "--target", "bun-linux-x64-modern", "--outfile", filePath];
   try {
     await exec2(`bun ${args.join(" ")}`);
@@ -7048,7 +7137,7 @@ var createFargateTask = (parentGroup, ctx, ns, id, local) => {
               healthCheck: props.healthCheck ? {
                 command: [
                   "CMD-SHELL",
-                  `curl -f http://${join15("localhost", props.healthCheck.path)} || exit 1`
+                  `curl -f http://${join16("localhost", props.healthCheck.path)} || exit 1`
                 ],
                 interval: toSeconds10(props.healthCheck.interval),
                 retries: props.healthCheck.retries,
@@ -8249,13 +8338,13 @@ import wildstring4 from "wildstring";
 import { log as log15 } from "@awsless/clui";
 import chalk4 from "chalk";
 import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import wildstring3 from "wildstring";
 
 // src/build/__fingerprint.ts
 import { createHash as createHash5 } from "crypto";
 import { readdir as readdir4, readFile as readFile5, stat as stat4 } from "fs/promises";
-import { basename as basename4, dirname as dirname10, extname as extname3, join as join16 } from "path";
+import { basename as basename4, dirname as dirname10, extname as extname4, join as join17 } from "path";
 import parseStaticImports from "parse-static-imports";
 var extensions = ["js", "mjs", "jsx", "ts", "mts", "tsx"];
 var generateFileHashes = async (file, hashes) => {
@@ -8276,8 +8365,8 @@ var fingerprintFromDirectory = async (dir) => {
   const hashes = /* @__PURE__ */ new Map();
   const files = await readdir4(dir, { recursive: true });
   for (const file of files) {
-    if (extensions.includes(extname3(file).substring(1)) && file.at(0) !== "_") {
-      await generateFileHashes(join16(dir, file), hashes);
+    if (extensions.includes(extname4(file).substring(1)) && file.at(0) !== "_") {
+      await generateFileHashes(join17(dir, file), hashes);
     }
   }
   const merge2 = Buffer.concat(Array.from(hashes.values()).sort());
@@ -8291,7 +8380,7 @@ var readModuleFile = (file) => {
     return readFiles([
       file,
       ...extensions.map((exp) => `${file}.${exp}`),
-      ...extensions.map((exp) => join16(file, `/index.${exp}`))
+      ...extensions.map((exp) => join17(file, `/index.${exp}`))
     ]);
   }
   return readFile5(file, "utf8");
@@ -8311,7 +8400,7 @@ var readFiles = async (files) => {
 };
 var findDependencies = async (file, code) => {
   const imports = await parseStaticImports(code);
-  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join16(dirname10(file), value) : value);
+  return imports.map((entry) => entry.moduleName).filter(Boolean).map((value) => value?.startsWith(".") ? join17(dirname10(file), value) : value);
 };
 
 // src/test/reporter.ts
@@ -8391,7 +8480,7 @@ var CustomReporter = class {
 import commonjs2 from "@rollup/plugin-commonjs";
 import json2 from "@rollup/plugin-json";
 import nodeResolve2 from "@rollup/plugin-node-resolve";
-import { dirname as dirname11, join as join17 } from "path";
+import { dirname as dirname11, join as join18 } from "path";
 import { swc as swc2 } from "rollup-plugin-swc3";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { configDefaults } from "vitest/config";
@@ -8413,7 +8502,7 @@ var startTest = async (props) => {
       reporters: props.reporter,
       setupFiles: [
         //
-        join17(__dirname4, "test-global-setup.js")
+        join18(__dirname4, "test-global-setup.js")
       ]
       // globalSetup: [
       // 	//
@@ -8503,7 +8592,7 @@ var logTestErrors = (event) => {
 var runTest = async (stack, dir, filters, opts) => {
   await mkdir4(directories.test, { recursive: true });
   const fingerprint = await fingerprintFromDirectory(dir);
-  const file = join18(directories.test, `${stack}.json`);
+  const file = join19(directories.test, `${stack}.json`);
   const exists = await fileExist(file);
   if (exists && !process.env.NO_CACHE) {
     const raw = await readFile6(file, { encoding: "utf8" });
@@ -8841,7 +8930,7 @@ import { log as log18 } from "@awsless/clui";
 
 // src/type-gen/generate.ts
 import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname12, join as join19, relative as relative7 } from "path";
+import { dirname as dirname12, join as join20, relative as relative7 } from "path";
 var generateTypes = async (props) => {
   const files = [];
   await Promise.all(
@@ -8850,7 +8939,7 @@ var generateTypes = async (props) => {
         ...props,
         async write(file, data, include = false) {
           const code = data?.toString("utf8");
-          const path = join19(directories.types, file);
+          const path = join20(directories.types, file);
           if (code) {
             if (include) {
               files.push(relative7(directories.root, path));
@@ -8864,7 +8953,7 @@ var generateTypes = async (props) => {
   );
   if (files.length) {
     const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
-    await writeFile4(join19(directories.root, `awsless.d.ts`), code);
+    await writeFile4(join20(directories.root, `awsless.d.ts`), code);
   }
 };
 

package/dist/build-json-schema.js

@@ -390,32 +390,30 @@ var DomainSchema = ResourceIdSchema.describe("The domain id to link your Pubsub
 var PubSubDefaultSchema = z15.record(
   ResourceIdSchema,
   z15.object({
-    auth: FunctionSchema,
+    auth: FunctionSchema.describe("The authentication function for the pubsub API."),
     domain: DomainSchema.optional(),
-    subDomain: z15.string().optional()
-    // auth: z.union([
-    // 	ResourceIdSchema,
-    // 	z.object({
-    // 		authorizer: FunctionSchema,
-    // 		// ttl: AuthorizerTtl.default('1 hour'),
-    // 	}),
-    // ]),
-    // policy: z
-    // 	.object({
-    // 		publish: z.array(z.string()).optional(),
-    // 		subscribe: z.array(z.string()).optional(),
-    // 	})
-    // 	.optional(),
+    subDomain: z15.string().optional(),
+    namespaces: z15.array(z15.string()).optional().describe('The namespaces for the PubSub API. If not set, a single "default" namespace is created.'),
+    logLevel: z15.enum(["none", "info", "error", "debug", "all"]).optional().describe("The logging level for AppSync API. When set, logging is enabled.")
   })
-).optional().describe("Define the pubsub subscriber in your stack.");
+).optional().describe("Define the pubsub API configuration in your stack.");
 var PubSubSchema = z15.record(
   ResourceIdSchema,
   z15.object({
-    sql: z15.string().describe("The SQL statement used to query the IOT topic."),
-    sqlVersion: z15.enum(["2015-10-08", "2016-03-23", "beta"]).default("2016-03-23").describe("The version of the SQL rules engine to use when evaluating the rule."),
-    consumer: FunctionSchema.describe("The consuming lambda function properties.")
+    channels: z15.array(z15.string()).describe("The event channels this subscriber listens to."),
+    filter: z15.object({
+      eventType: z15.string().optional().describe("Filter events by event type.")
+      // Add more filter options as needed
+      // userId: z.string().optional(),
+      // custom: z.record(z.string(), z.any()).optional(),
+    }).optional().describe("Event filtering options."),
+    consumer: FunctionSchema.describe("The consuming lambda function properties."),
+    batchSize: z15.number().int().min(1).max(100).default(1).describe("Number of events to batch before invoking the consumer function."),
+    retryPolicy: z15.object({
+      maxRetries: z15.number().int().min(0).max(3).default(2).describe("Maximum number of retry attempts.")
+    }).optional().describe("Retry policy for failed event processing.")
   })
-).optional().describe("Define the pubsub subscriber in your stack.");
+).optional().describe("Define the pubsub event subscribers in your stack.");
 
 // src/feature/queue/schema.ts
 import { days as days2, hours, minutes as minutes2, seconds as seconds2 } from "@awsless/duration";
@@ -1182,8 +1180,7 @@ var StoresSchema = z32.union([
   z32.record(
     ResourceIdSchema,
     z32.object({
-      // cors: CorsSchema,
-      // deletionProtection: DeletionProtectionSchema.optional(),
+      static: LocalDirectorySchema.optional().describe("Specifies the path to the static files directory."),
       versioning: z32.boolean().default(false).describe("Enable versioning of your store."),
       events: z32.object({
         // create