@gigadrive/network-config 4.6.0 → 4.6.1

package/dist/index.mjs

@@ -454,38 +454,60 @@ var ImagePolicySchema = Schema3.mutable(
     variants: Schema3.mutable(Schema3.Record({ key: Schema3.String, value: ImageVariantSchema }))
   })
 );
-var GigadriveNextPrerenderOutputSchema = Schema3.mutable(
-  Schema3.Struct({
-    id: Schema3.String,
-    type: Schema3.Literal("PRERENDER"),
-    pathname: UrlPathnameSchema,
-    parentOutputId: Schema3.String,
-    groupId: Schema3.Number,
-    pprChain: Schema3.optional(Schema3.mutable(Schema3.Struct({ headers: HttpSingleValueHeadersSchema }))),
-    parentFallbackMode: Schema3.optional(JsonValueSchema),
-    fallback: Schema3.optional(
-      Schema3.mutable(
-        Schema3.Struct({
-          filePath: Schema3.optional(PortableRelativePathSchema),
-          initialStatus: Schema3.optional(Schema3.Int.pipe(Schema3.between(100, 599))),
-          initialHeaders: Schema3.optional(HttpHeadersSchema),
-          initialExpiration: Schema3.optional(Schema3.Number),
-          initialRevalidate: Schema3.optional(Schema3.Union(Schema3.Number, Schema3.Literal(false))),
-          postponedState: Schema3.optional(Schema3.String)
-        })
-      )
-    ),
-    config: Schema3.mutable(
+var GigadriveNextPrerenderOutputFields = {
+  id: Schema3.String,
+  type: Schema3.Literal("PRERENDER"),
+  pathname: UrlPathnameSchema,
+  route: Schema3.optional(UrlPathnameSchema),
+  parentOutputId: Schema3.String,
+  groupId: Schema3.Number,
+  pprChain: Schema3.optional(Schema3.mutable(Schema3.Struct({ headers: HttpSingleValueHeadersSchema }))),
+  parentFallbackMode: Schema3.optional(JsonValueSchema),
+  fallback: Schema3.optional(
+    Schema3.mutable(
       Schema3.Struct({
-        allowQuery: Schema3.optional(StringArraySchema),
-        allowHeader: Schema3.optional(StringArraySchema),
-        bypassFor: Schema3.optional(Schema3.mutable(Schema3.Array(JsonValueSchema))),
-        renderingMode: Schema3.optional(Schema3.String),
-        partialFallback: Schema3.optional(Schema3.Boolean),
-        bypassToken: Schema3.optional(Schema3.String)
+        filePath: Schema3.optional(PortableRelativePathSchema),
+        initialStatus: Schema3.optional(Schema3.Int.pipe(Schema3.between(100, 599))),
+        initialHeaders: Schema3.optional(HttpHeadersSchema),
+        initialExpiration: Schema3.optional(Schema3.Number),
+        initialRevalidate: Schema3.optional(Schema3.Union(Schema3.Number, Schema3.Literal(false))),
+        postponedState: Schema3.optional(Schema3.String)
       })
     )
-  })
+  ),
+  config: Schema3.mutable(
+    Schema3.Struct({
+      allowQuery: Schema3.optional(StringArraySchema),
+      allowHeader: Schema3.optional(StringArraySchema),
+      bypassFor: Schema3.optional(Schema3.mutable(Schema3.Array(JsonValueSchema))),
+      renderingMode: Schema3.optional(Schema3.String),
+      partialFallback: Schema3.optional(Schema3.Boolean),
+      bypassToken: Schema3.optional(Schema3.String)
+    })
+  )
+};
+var GigadriveNextPrerenderClassificationSchema = Schema3.Struct({
+  routeType: Schema3.Literal("route", "fallback", "shell", "page"),
+  response: Schema3.Literal("empty", "initial", "complete"),
+  compute: Schema3.Literal("blocking", "resuming", "static"),
+  htmlSize: Schema3.optional(Schema3.Number)
+});
+var GigadriveNextPrerenderWithoutClassificationSchema = Schema3.Struct({
+  routeType: Schema3.optional(Schema3.Never),
+  response: Schema3.optional(Schema3.Never),
+  compute: Schema3.optional(Schema3.Never),
+  htmlSize: Schema3.optional(Schema3.Never)
+});
+var GigadriveNextPrerenderOutputSchema = Schema3.Union(
+  Schema3.mutable(
+    Schema3.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
+  ),
+  Schema3.mutable(
+    Schema3.Struct({
+      ...GigadriveNextPrerenderOutputFields,
+      ...GigadriveNextPrerenderWithoutClassificationSchema.fields
+    })
+  )
 );
 var GigadriveNextStaticAssetPrefixSchema = Schema3.mutable(
   Schema3.Struct({
@@ -494,6 +516,43 @@ var GigadriveNextStaticAssetPrefixSchema = Schema3.mutable(
     immutable: Schema3.Boolean
   })
 );
+var GigadriveNextRouteConditionSchema = Schema3.Union(
+  Schema3.mutable(
+    Schema3.Struct({
+      type: Schema3.Literal("header", "cookie", "query"),
+      key: Schema3.String,
+      value: Schema3.optional(Schema3.String)
+    })
+  ),
+  Schema3.mutable(
+    Schema3.Struct({
+      type: Schema3.Literal("host"),
+      value: Schema3.String
+    })
+  )
+);
+var GigadriveNextMiddlewareMatcherSchema = Schema3.mutable(
+  Schema3.Struct({
+    source: Schema3.String,
+    sourceRegex: Schema3.String,
+    has: Schema3.optional(Schema3.mutable(Schema3.Array(GigadriveNextRouteConditionSchema))),
+    missing: Schema3.optional(Schema3.mutable(Schema3.Array(GigadriveNextRouteConditionSchema)))
+  })
+);
+var GigadriveNextMiddlewareDescriptorSchema = Schema3.Union(
+  Schema3.mutable(
+    Schema3.Struct({
+      present: Schema3.Literal(true),
+      matchers: Schema3.mutable(Schema3.Array(GigadriveNextMiddlewareMatcherSchema))
+    })
+  ),
+  Schema3.mutable(
+    Schema3.Struct({
+      present: Schema3.Literal(false),
+      matchers: Schema3.mutable(Schema3.Tuple())
+    })
+  )
+);
 var GigadriveNextServerDescriptorSchema = Schema3.mutable(
   Schema3.Struct({
     maxDuration: Schema3.optional(Schema3.Number),
@@ -504,6 +563,9 @@ var GigadriveNextServerDescriptorSchema = Schema3.mutable(
 var PrerenderArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextPrerenderOutputSchema));
 var StaticAssetArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextStaticAssetPrefixSchema));
 var JsonValueArraySchema = Schema3.mutable(Schema3.Array(JsonValueSchema));
+var GigadriveNextPrerenderSeedMethodsSchema = Schema3.mutable(
+  Schema3.Tuple(Schema3.Literal("GET"), Schema3.Literal("HEAD"))
+);
 var GigadriveNextBuildManifestV1Schema = Schema3.mutable(
   Schema3.Struct({
     version: Schema3.Literal(1),
@@ -560,7 +622,8 @@ var GigadriveNextBuildManifestV2StandaloneSchema = Schema3.mutable(
         prerenderManifest: Schema3.optional(PortableRelativePathSchema),
         assetManifest: Schema3.optional(PortableRelativePathSchema),
         entryPagePaths: Schema3.optional(Schema3.mutable(Schema3.Array(UrlPathnameSchema))),
-        staticAssets: StaticAssetArraySchema
+        staticAssets: StaticAssetArraySchema,
+        middleware: Schema3.optional(GigadriveNextMiddlewareDescriptorSchema)
       })
     )
   })
@@ -573,6 +636,7 @@ var GigadriveNextBuildManifestSchema = Schema3.Union(
 var GigadriveNextPrerenderManifestV1Schema = Schema3.mutable(
   Schema3.Struct({
     version: Schema3.Literal(1),
+    seedMethods: Schema3.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
@@ -1438,9 +1502,51 @@ var SchemaValidator = class extends Effect14.Service()("SchemaValidator", {
 
 // src/services/v4-config-parser.ts
 import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
-import { getFilesForPattern } from "@gigadrive/build-utils";
-import { Effect as Effect15 } from "effect";
+
+// ../build-utils/src/get-files-for-pattern.ts
 import { minimatch } from "minimatch";
+import { readdir } from "fs/promises";
+var getFilesForPattern = async (pattern, projectFolder, excludeFiles = []) => {
+  const files = [];
+  const filesInFolder = await readdir(projectFolder, { recursive: true });
+  const exactFiles = new Set(filesInFolder.filter((file) => typeof file === "string"));
+  let regex = null;
+  if (!exactFiles.has(pattern)) {
+    try {
+      regex = new RegExp(`^(?:${pattern})$`);
+    } catch {
+    }
+  }
+  const finalExclusions = Array.isArray(excludeFiles) ? excludeFiles : [excludeFiles];
+  for (const file of filesInFolder) {
+    if (typeof file !== "string") {
+      continue;
+    }
+    if (finalExclusions.some((excludeFile) => {
+      if (minimatch(file, excludeFile)) {
+        return true;
+      }
+      if (!exactFiles.has(excludeFile)) {
+        try {
+          return new RegExp(`^(?:${excludeFile})$`).test(file);
+        } catch {
+          return false;
+        }
+      }
+      return false;
+    })) {
+      continue;
+    }
+    if (minimatch(file, pattern) || regex != null && regex.test(file)) {
+      files.push(file);
+    }
+  }
+  return files;
+};
+
+// src/services/v4-config-parser.ts
+import { Effect as Effect15 } from "effect";
+import { minimatch as minimatch2 } from "minimatch";
 import safeRegex from "safe-regex2";
 var MAX_ASSET_DEPTH = 100;
 var DISALLOWED_ASSET_EXTENSIONS = [".htaccess", ".htpasswd"];
@@ -1505,7 +1611,7 @@ var destinationMatchesEntrypoint = (destination, entrypointPath) => {
   return new RegExp(`^${pattern}$`).test(entrypointPath);
 };
 var matchesPattern = (path2, pattern) => {
-  if (minimatch(path2, pattern)) return true;
+  if (minimatch2(path2, pattern)) return true;
   try {
     if (safeRegex(pattern)) {
       return new RegExp(pattern).test(path2);
@@ -1668,8 +1774,34 @@ var V4ConfigParser = class extends Effect15.Service()("V4ConfigParser", {
 
 // src/services/vercel-build-output-parser.ts
 import { Path as Path9 } from "@effect/platform";
-import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
-import { deepMerge } from "@gigadrive/commons";
+
+// ../commons/src/deep-merge.ts
+var deepMerge = (target, ...partials) => {
+  const isObject = (item) => item !== null && typeof item === "object";
+  if (!isObject(target)) {
+    return target;
+  }
+  for (const partial of partials) {
+    if (!isObject(partial)) {
+      continue;
+    }
+    Object.keys(partial).forEach((key) => {
+      if (key === "__proto__" || key === "constructor") return;
+      const targetValue = target[key];
+      const sourceValue = partial[key];
+      if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+        targetValue.push(...sourceValue);
+      } else if (isObject(targetValue) && isObject(sourceValue)) {
+        deepMerge(targetValue, sourceValue);
+      } else {
+        target[key] = sourceValue;
+      }
+    });
+  }
+  return target;
+};
+
+// src/services/vercel-build-output-parser.ts
 import { Effect as Effect16 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
@@ -1784,7 +1916,7 @@ var VercelBuildOutputParser = class extends Effect16.Service()("VercelBuildOutpu
     });
     const loadFunctions = Effect16.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
       const functionConfigs = yield* Effect16.tryPromise({
-        try: () => getFilesForPattern2(FUNCTION_CONFIGS_PATTERN, projectFolder),
+        try: () => getFilesForPattern(FUNCTION_CONFIGS_PATTERN, projectFolder),
         catch: (error) => new ConfigFileParseError({
           message: `Failed to scan for function configs: ${error instanceof Error ? error.message : String(error)}`,
           filePath: projectFolder
@@ -2464,8 +2596,12 @@ export {
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextMiddlewareDescriptorSchema,
+  GigadriveNextMiddlewareMatcherSchema,
   GigadriveNextPrerenderManifestV1Schema,
   GigadriveNextPrerenderOutputSchema,
+  GigadriveNextPrerenderSeedMethodsSchema,
+  GigadriveNextRouteConditionSchema,
   GigadriveNextServerDescriptorSchema,
   GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,