@awsless/awsless 0.0.627 → 0.0.628

package/dist/bin.js

@@ -2525,6 +2525,78 @@ var StackSchema = z44.object({
 // src/config/load/read.ts
 import { readFile as readFile2 } from "fs/promises";
 import { basename, dirname as dirname2, extname, join as join4 } from "path";
+
+// src/config/stage-patch.ts
+import jsonPatch from "fast-json-patch";
+import { z as z45 } from "zod";
+var AddOperationSchema = z45.object({
+  op: z45.literal("add"),
+  path: z45.string(),
+  value: z45.unknown()
+}).strict();
+var RemoveOperationSchema = z45.object({
+  op: z45.literal("remove"),
+  path: z45.string()
+}).strict();
+var ReplaceOperationSchema = z45.object({
+  op: z45.literal("replace"),
+  path: z45.string(),
+  value: z45.unknown()
+}).strict();
+var MoveOperationSchema = z45.object({
+  op: z45.literal("move"),
+  from: z45.string(),
+  path: z45.string()
+}).strict();
+var CopyOperationSchema = z45.object({
+  op: z45.literal("copy"),
+  from: z45.string(),
+  path: z45.string()
+}).strict();
+var TestOperationSchema = z45.object({
+  op: z45.literal("test"),
+  path: z45.string(),
+  value: z45.unknown()
+}).strict();
+var JsonPatchOperationSchema = z45.discriminatedUnion("op", [
+  AddOperationSchema,
+  RemoveOperationSchema,
+  ReplaceOperationSchema,
+  MoveOperationSchema,
+  CopyOperationSchema,
+  TestOperationSchema
+]);
+var StagePatchSchema = z45.object({
+  $schema: z45.string().optional(),
+  operations: JsonPatchOperationSchema.array()
+}).strict();
+var applyStagePatch = (source, patch, file) => {
+  try {
+    const result = jsonPatch.applyPatch(structuredClone(source), patch.operations, true, false);
+    return result.newDocument;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new FileError(file, error.message);
+    }
+    throw error;
+  }
+};
+
+// src/config/load/validate.ts
+import { z as z46 } from "zod";
+var validateConfig = async (schema, file, data) => {
+  try {
+    const result = await schema.parseAsync(data);
+    return result;
+  } catch (error) {
+    if (error instanceof z46.ZodError) {
+      throw new ConfigError(file, error, data);
+    }
+    throw error;
+  }
+};
+
+// src/config/load/read.ts
 var readConfig = async (file) => {
   try {
     const json2 = await readFile2(file, "utf8");
@@ -2540,32 +2612,28 @@ var readConfig = async (file) => {
 var readConfigWithStage = async (file, stage) => {
   const config2 = await readConfig(file);
   if (!stage) {
-    return config2;
+    return {
+      file,
+      data: config2
+    };
   }
   const ext = extname(file);
   const stageFileName = basename(file, ext) + "." + stage + ext;
   const stageFile = join4(dirname2(file), stageFileName);
   const stageFileExists = await fileExist(stageFile);
   if (!stageFileExists) {
-    return config2;
+    return {
+      file,
+      data: config2
+    };
   }
   debug("Load env file:", color.info(stageFile));
   const stageConfig = await readConfig(stageFile);
-  return stageConfig;
-};
-
-// src/config/load/validate.ts
-import { z as z45 } from "zod";
-var validateConfig = async (schema, file, data) => {
-  try {
-    const result = await schema.parseAsync(data);
-    return result;
-  } catch (error) {
-    if (error instanceof z45.ZodError) {
-      throw new ConfigError(file, error, data);
-    }
-    throw error;
-  }
+  const patch = await validateConfig(StagePatchSchema, stageFile, stageConfig);
+  return {
+    file: stageFile,
+    data: applyStagePatch(config2, patch, stageFile)
+  };
 };
 
 // src/config/load/load.ts
@@ -2580,7 +2648,7 @@ var loadAppConfig = async (options) => {
   debug("Load app config file");
   const appConfig = await readConfigWithStage(appFileName, options.stage);
   debug("Validate app config file");
-  const app = await validateConfig(AppSchema, appFileName, appConfig);
+  const app = await validateConfig(AppSchema, appConfig.file, appConfig.data);
   return app;
 };
 var loadStackConfigs = async (options) => {
@@ -2600,7 +2668,7 @@ var loadStackConfigs = async (options) => {
     debug("Load stack file:", color.info(file));
     const stackConfig = await readConfigWithStage(join5(directories.root, file), options.stage);
     setLocalBasePath(join5(directories.root, dirname3(file)));
-    const stack = await validateConfig(StackSchema, file, stackConfig);
+    const stack = await validateConfig(StackSchema, stackConfig.file, stackConfig.data);
     stacks.push({
       ...stack,
       file
@@ -5312,14 +5380,15 @@ var siteFeature = defineFeature({
             const instance = Bun.spawn(buildProps.command.split(" "), {
               cwd,
               env,
-              stdout: "ignore",
-              stderr: "ignore"
+              stdout: "pipe",
+              stderr: "pipe"
+              // stdout: 'ignore',
+              // stderr: ''
               // stdout: 'inherit',
               // stderr: 'inherit',
             });
             await instance.exited;
             if (instance.exitCode !== null && instance.exitCode > 0) {
-              console.log(instance.stderr);
               throw new Error("Site build failed");
             }
             await write("HASH", fingerprint);
@@ -8863,6 +8932,14 @@ var startTest = async (props) => {
       exclude: ["**/_*", "**/_*/**", ...configDefaults.exclude],
       globals: true,
       reporters: [new NullReporter()],
+      // isolate: false,
+      // typecheck: {
+      // 	enabled: true,
+      // 	only: false,
+      // 	exclude: ['**/_*', '**/_*/**', ...configDefaults.exclude],
+      // 	include: ['**/*.{js,jsx,ts,tsx}'],
+      // 	checker: 'tsc',
+      // },
       // reporters: 'json',
       // typecheck: {
       // 	checker: 'tsc',
@@ -10261,6 +10338,7 @@ var parseJsonLog = (message) => {
 // src/cli/command/image/clear-cache.ts
 import { DeleteObjectsCommand, ListObjectsV2Command, S3Client as S3Client3 } from "@aws-sdk/client-s3";
 import { Cancelled as Cancelled3, log as log28, prompt as prompt14 } from "@awsless/clui";
+import { CloudFrontClient as CloudFrontClient2 } from "@aws-sdk/client-cloudfront";
 var clearCache = (program2) => {
   program2.command("clear-cache").argument("[stack]", "The stack name of the image proxy").argument("[name]", "The name of the image proxy").description("Clears the cache of the image proxy").action(async (stack, name) => {
     await layout("image clear-cache", async ({ appConfig, stackConfigs }) => {
@@ -10325,6 +10403,10 @@ var clearCache = (program2) => {
         credentials,
         region
       });
+      const cloudFrontClient = new CloudFrontClient2({
+        credentials,
+        region
+      });
       let totalDeleted = 0;
       await log28.task({
         initialMessage: "Clearing cache...",
@@ -10359,9 +10441,7 @@ var clearCache = (program2) => {
               break;
             }
           }
-          await createInvalidationForDistributionTenants({
-            credentials,
-            region,
+          await createInvalidationForDistributionTenants(cloudFrontClient, {
             distributionId,
             paths: [shared.entry("image", "path", name)]
           });
@@ -10382,6 +10462,7 @@ var image = (program2) => {
 // src/cli/command/icon/clear-cache.ts
 import { DeleteObjectsCommand as DeleteObjectsCommand2, ListObjectsV2Command as ListObjectsV2Command2, S3Client as S3Client4 } from "@aws-sdk/client-s3";
 import { Cancelled as Cancelled4, log as log29, prompt as prompt15 } from "@awsless/clui";
+import { CloudFrontClient as CloudFrontClient3 } from "@aws-sdk/client-cloudfront";
 var clearCache2 = (program2) => {
   program2.command("clear-cache").argument("[stack]", "The stack name of the icon proxy").argument("[name]", "The name of the icon proxy").description("Clears the cache of the icon proxy").action(async (stack, name) => {
     await layout("icon clear-cache", async ({ appConfig, stackConfigs }) => {
@@ -10446,6 +10527,10 @@ var clearCache2 = (program2) => {
         credentials,
         region
       });
+      const cloudFrontClient = new CloudFrontClient3({
+        credentials,
+        region
+      });
       let totalDeleted = 0;
       await log29.task({
         initialMessage: "Clearing cache...",
@@ -10480,9 +10565,7 @@ var clearCache2 = (program2) => {
               break;
             }
           }
-          await createInvalidationForDistributionTenants({
-            credentials,
-            region,
+          await createInvalidationForDistributionTenants(cloudFrontClient, {
             distributionId,
             paths: [shared.entry("icon", "path", name)]
           });

package/dist/build-json-schema.js

@@ -942,6 +942,259 @@ var AppSchema = z24.object({
   }).default({}).describe("Default properties")
 });
 
+// src/config/stage-patch-json-schema.ts
+var clone = (value) => {
+  return JSON.parse(JSON.stringify(value));
+};
+var escapePointerSegment = (value) => {
+  return value.replaceAll("~", "~0").replaceAll("/", "~1");
+};
+var escapeRegexSegment = (value) => {
+  return value.replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&");
+};
+var makeExactPath = (prefix, segment) => {
+  return `${prefix}/${escapePointerSegment(segment)}`;
+};
+var makeExactPattern = (path) => {
+  return `^${path.split("/").map(escapeRegexSegment).join("/")}$`;
+};
+var makePatternPath = (prefix, segmentPattern) => {
+  return prefix ? `${prefix}/${segmentPattern}` : `/${segmentPattern}`;
+};
+var appendExactPattern = (pattern, segment) => {
+  const base = pattern.slice(1, -1);
+  return `^${base}/${escapeRegexSegment(segment)}$`;
+};
+var appendRegexPattern = (pattern, segmentPattern) => {
+  const base = pattern.slice(1, -1);
+  return `^${base}/${segmentPattern}$`;
+};
+var mergeSchemas = (schemas) => {
+  const list = schemas.map((schema) => clone(schema));
+  if (list.length === 1) {
+    return list[0];
+  }
+  return {
+    anyOf: list
+  };
+};
+var dereference = (schema, root) => {
+  if (typeof schema.$ref !== "string" || !schema.$ref.startsWith("#/")) {
+    return schema;
+  }
+  const target = schema.$ref.slice(2).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((value, segment) => {
+    if (typeof value === "object" && value !== null) {
+      return value[segment];
+    }
+    return void 0;
+  }, root);
+  if (!target || typeof target !== "object") {
+    return schema;
+  }
+  const { $ref: _, ...rest } = schema;
+  return {
+    ...clone(target),
+    ...rest
+  };
+};
+var listBranches = (schema) => {
+  const groups = [schema.anyOf, schema.oneOf, schema.allOf].filter(Boolean);
+  if (groups.length === 0) {
+    return [schema];
+  }
+  return groups.flatMap((group) => group);
+};
+var childSegmentPattern = (schema) => {
+  const propertyNameSchema = schema.propertyNames;
+  if (propertyNameSchema && typeof propertyNameSchema.pattern === "string") {
+    return propertyNameSchema.pattern;
+  }
+  const firstPattern = Object.keys(schema.patternProperties ?? {})[0];
+  if (firstPattern) {
+    return firstPattern;
+  }
+  return "[^/]+";
+};
+var joinEntries = (entries) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = [entry.path, entry.pattern ?? "", entry.addOnly ? "1" : "0"].join("|");
+    const previous = map.get(key);
+    if (!previous) {
+      map.set(key, {
+        ...entry,
+        schema: clone(entry.schema)
+      });
+      continue;
+    }
+    previous.schema = mergeSchemas([previous.schema, entry.schema]);
+  }
+  return [...map.values()];
+};
+var collectEntries = (schema, pointer = "", pattern = makeExactPattern(pointer), root = schema) => {
+  const resolved = dereference(schema, root);
+  const entries = [
+    {
+      path: pointer,
+      pattern,
+      schema: clone(resolved)
+    }
+  ];
+  for (const branch of listBranches(resolved)) {
+    const branchType = Array.isArray(branch.type) ? branch.type : branch.type ? [branch.type] : [];
+    const isObject = branchType.includes("object") || branch.properties !== void 0 || branch.additionalProperties !== void 0 || branch.patternProperties !== void 0;
+    const isArray = branchType.includes("array") || branch.items !== void 0 || branch.prefixItems !== void 0;
+    if (isObject) {
+      for (const [property, propertySchema] of Object.entries(branch.properties ?? {})) {
+        const path = makeExactPath(pointer, property);
+        entries.push(...collectEntries(propertySchema, path, appendExactPattern(pattern, property), root));
+      }
+      for (const [propertyPattern, propertySchema] of Object.entries(branch.patternProperties ?? {})) {
+        const path = makePatternPath(pointer, propertyPattern);
+        entries.push(...collectEntries(propertySchema, path, appendRegexPattern(pattern, propertyPattern), root));
+      }
+      if (branch.additionalProperties && typeof branch.additionalProperties === "object") {
+        const segmentPattern = childSegmentPattern(branch);
+        const path = makePatternPath(pointer, segmentPattern);
+        entries.push(...collectEntries(branch.additionalProperties, path, appendRegexPattern(pattern, segmentPattern), root));
+      }
+    }
+    if (isArray) {
+      if (Array.isArray(branch.items)) {
+        branch.items.forEach((itemSchema, index) => {
+          entries.push(...collectEntries(itemSchema, `${pointer}/${index}`, appendExactPattern(pattern, `${index}`), root));
+        });
+      } else if (branch.items && typeof branch.items === "object") {
+        entries.push(...collectEntries(branch.items, `${pointer}/\\d+`, appendRegexPattern(pattern, "\\d+"), root));
+        entries.push({
+          path: `${pointer}/-`,
+          pattern: makeExactPattern(`${pointer}/-`),
+          schema: clone(branch.items),
+          addOnly: true
+        });
+      }
+      for (const [index, itemSchema] of (branch.prefixItems ?? []).entries()) {
+        entries.push(...collectEntries(itemSchema, `${pointer}/${index}`, appendExactPattern(pattern, `${index}`), root));
+      }
+    }
+  }
+  return joinEntries(entries);
+};
+var pathMatcherSchema = (entry) => {
+  if (entry.pattern && entry.pattern !== makeExactPattern(entry.path)) {
+    return {
+      type: "string",
+      pattern: entry.pattern
+    };
+  }
+  return {
+    type: "string",
+    const: entry.path
+  };
+};
+var objectSchema = (properties, required) => {
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  };
+};
+var conditionalValueSchema = (entry) => {
+  return {
+    if: {
+      type: "object",
+      properties: {
+        path: pathMatcherSchema(entry)
+      },
+      required: ["path"]
+    },
+    then: {
+      properties: {
+        value: clone(entry.schema)
+      }
+    }
+  };
+};
+var matchersSchema = (entries) => {
+  return {
+    oneOf: entries.map(pathMatcherSchema)
+  };
+};
+var patchOperationSchema = (op, entries) => {
+  const props = {
+    op: {
+      type: "string",
+      const: op
+    },
+    path: matchersSchema(entries)
+  };
+  const required = ["op", "path"];
+  const schema = objectSchema(props, required);
+  switch (op) {
+    case "add":
+    case "replace":
+    case "test":
+      schema.properties = {
+        ...schema.properties,
+        value: {}
+      };
+      schema.required = [...required, "value"];
+      schema.allOf = entries.map(conditionalValueSchema);
+      return schema;
+    case "move":
+    case "copy":
+      schema.properties = {
+        ...schema.properties,
+        from: matchersSchema(entries)
+      };
+      schema.required = ["op", "from", "path"];
+      return schema;
+    default:
+      return schema;
+  }
+};
+var normalizeEntry = (entry) => {
+  return {
+    ...entry,
+    pattern: entry.pattern ?? makeExactPattern(entry.path)
+  };
+};
+var isSchemaMetadataPath = (entry) => {
+  return entry.path === "/$schema" || entry.path.startsWith("/$schema/");
+};
+var createStagePatchJsonSchema = (baseSchema, title) => {
+  const entries = collectEntries(baseSchema).map(normalizeEntry).filter((entry) => !isSchemaMetadataPath(entry));
+  const standardEntries = entries.filter((entry) => !entry.addOnly);
+  const addEntries = entries;
+  const moveCopyEntries = standardEntries.filter((entry) => entry.path !== "");
+  return {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title,
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      $schema: {
+        type: "string"
+      },
+      operations: {
+        type: "array",
+        items: {
+          oneOf: [
+            patchOperationSchema("add", addEntries),
+            patchOperationSchema("remove", standardEntries),
+            patchOperationSchema("replace", standardEntries),
+            patchOperationSchema("move", moveCopyEntries),
+            patchOperationSchema("copy", moveCopyEntries),
+            patchOperationSchema("test", standardEntries)
+          ]
+        }
+      }
+    },
+    required: ["operations"]
+  };
+};
+
 // src/config/stack.ts
 import { z as z40 } from "zod";
 
@@ -1597,6 +1850,7 @@ var generateJsonSchema = (props) => {
   appendDefaults(schema);
   schema.title = props.title;
   writeFileSync(file, JSON.stringify(schema));
+  return schema;
 };
 var appendDefaults = (object) => {
   if (Array.isArray(object)) {
@@ -1619,13 +1873,21 @@ var appendDefaults = (object) => {
     }
   }
 };
-generateJsonSchema({
+var appSchema = generateJsonSchema({
   schema: AppSchema,
   name: "app",
   title: "Awsless App Config"
 });
-generateJsonSchema({
+var stackSchema = generateJsonSchema({
   schema: StackSchema,
   name: "stack",
   title: "Awsless Stack Config"
 });
+writeFileSync(
+  join2(process.cwd(), "dist/app.stage.json"),
+  JSON.stringify(createStagePatchJsonSchema(appSchema, "Awsless App Stage Patch Config"))
+);
+writeFileSync(
+  join2(process.cwd(), "dist/stack.stage.json"),
+  JSON.stringify(createStagePatchJsonSchema(stackSchema, "Awsless Stack Stage Patch Config"))
+);