@gigadrive/network-config 2.0.4 → 2.1.1

package/dist/index.mjs

@@ -18,22 +18,98 @@ import addFormats from "ajv-formats";
 
 // src/build-output-v3/parse.ts
 import { getFilesForPattern } from "@gigadrive/build-utils";
-import fs3 from "fs";
+import { deepMerge } from "@gigadrive/commons";
+import path5 from "path";
+
+// src/build-output-v3/determine-repo-root.ts
+import path2 from "path";
+var determineRepoRoot = (projectFolder, config) => {
+  if (!config.entrypoints?.length) {
+    return projectFolder;
+  }
+  const filePaths = [];
+  for (const entrypoint of config.entrypoints) {
+    if (entrypoint.package?.filePathMap) {
+      filePaths.push(...Object.keys(entrypoint.package.filePathMap));
+    }
+  }
+  if (filePaths.length === 0) {
+    return projectFolder;
+  }
+  const pathParts = filePaths.map((p) => p.split(path2.sep));
+  const firstPath = pathParts[0];
+  let commonParts = [];
+  for (let i = 0; i < firstPath.length; i++) {
+    const part = firstPath[i];
+    if (pathParts.every((parts) => parts[i] === part)) {
+      commonParts.push(part);
+    } else {
+      break;
+    }
+  }
+  const commonRoot = commonParts.join(path2.sep);
+  if (commonRoot && projectFolder.startsWith(commonRoot) && commonRoot !== projectFolder) {
+    return commonRoot;
+  }
+  return projectFolder;
+};
+
+// src/build-output-v3/get-default-path-map.ts
+import fs2 from "fs";
 import path3 from "path";
+var getDefaultPathMap = (directory) => {
+  const result = {};
+  if (!fs2.existsSync(directory)) {
+    return result;
+  }
+  const processDirectory = (currentPath, basePath = "") => {
+    const files = fs2.readdirSync(currentPath, { withFileTypes: true });
+    for (const file of files) {
+      const fullPath = path3.join(currentPath, file.name);
+      const relativePath = path3.join(basePath, file.name);
+      if (file.isDirectory()) {
+        processDirectory(fullPath, relativePath);
+      } else {
+        result[fullPath] = relativePath;
+      }
+    }
+  };
+  processDirectory(directory);
+  return result;
+};
+
+// src/build-output-v3/get-monorepo-files.ts
+function getMonorepoFiles(directory, filePathMaps) {
+  const result = [];
+  for (const filePathMap of filePathMaps ?? []) {
+    if (!filePathMap) {
+      continue;
+    }
+    for (const file of Object.keys(filePathMap)) {
+      if (!file.startsWith(directory)) {
+        result.push(file);
+      }
+    }
+  }
+  return result;
+}
+
+// src/build-output-v3/read-config-file.ts
+import fs4 from "fs";
 
 // src/parse-raw-config.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path4 from "path";
 import { parse as parseYaml } from "yaml";
 var parseRawConfig = async (filePath, { disableVersionCheck = false } = {}) => {
-  if (!fs2.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     throw new Error(`Config file not found at ${filePath}`);
   }
-  const fileContents = fs2.readFileSync(filePath, "utf8");
+  const fileContents = fs3.readFileSync(filePath, "utf8");
   if (fileContents.length === 0) {
     throw new Error(`Config file is empty at ${filePath}`);
   }
-  const fileExtension = path2.extname(filePath).toLowerCase();
+  const fileExtension = path4.extname(filePath).toLowerCase();
   let parsed;
   try {
     if (fileExtension === ".json") {
@@ -57,150 +133,187 @@ var parseRawConfig = async (filePath, { disableVersionCheck = false } = {}) => {
   return parsed;
 };
 
+// src/build-output-v3/read-config-file.ts
+var readConfigFile = async (configFilePath) => {
+  if (!fs4.existsSync(configFilePath)) {
+    return null;
+  }
+  const parsed = await parseRawConfig(configFilePath, { disableVersionCheck: true });
+  return parsed;
+};
+
+// src/build-output-v3/translate-vercel-region.ts
+var translateVercelRegion = (region) => {
+  const regionMap = {
+    arn1: "eu-north-1",
+    bom1: "ap-south-1",
+    cdg1: "eu-west-3",
+    cle1: "us-east-2",
+    cpt1: "af-south-1",
+    dub1: "eu-west-1",
+    fra1: "eu-central-1",
+    gru1: "sa-east-1",
+    hkg1: "ap-east-1",
+    hnd1: "ap-northeast-1",
+    iad1: "us-east-1",
+    icn1: "ap-northeast-2",
+    kix1: "ap-northeast-3",
+    lhr1: "eu-west-2",
+    pdx1: "us-west-2",
+    sfo1: "us-west-1",
+    sin1: "ap-southeast-1",
+    syd1: "ap-southeast-2"
+  };
+  return regionMap[region.toLowerCase()] ?? "us-east-1";
+};
+
+// src/build-output-v3/translate-vercel-runtime.ts
+var translateVercelRuntime = (runtime) => {
+  switch (runtime) {
+    case "nodejs12.x":
+    case "nodejs14.x":
+    case "nodejs16.x":
+    case "nodejs18.x":
+      return "node-18";
+    case "nodejs20.x":
+    case "nodejs22.x":
+      return "node-20";
+    default:
+      return null;
+  }
+};
+
 // src/build-output-v3/parse.ts
 var configPath = ".vercel/output/config.json";
-var functionConfigsPattern = ".vercel/output/functions/*.func/.vc-config.json";
+var functionsFolder = ".vercel/output/functions";
+var functionConfigsPattern = `${functionsFolder}/**/*.func/.vc-config.json`;
 var parseVercelBuildOutputV3 = async (parseResult, projectFolder) => {
-  const config = await readConfigFile(path3.join(projectFolder, configPath));
+  const config = await readConfigFile(path5.join(projectFolder, configPath));
   if (!config || config.version < 3) {
     return parseResult;
   }
-  await loadFunctions(config, parseResult, projectFolder);
-  await loadAssetOverrides(config, parseResult);
-  return parseResult;
+  const functionData = await loadFunctions(config, parseResult, projectFolder);
+  const assetOverrides = await loadAssetOverrides(config, parseResult);
+  return deepMerge(parseResult, functionData, assetOverrides);
 };
 var loadAssetOverrides = async (config, parseResult) => {
-  if (!parseResult.assets) {
-    parseResult.assets = {
-      paths: [],
-      prefixToStrip: ""
-    };
-  }
-  parseResult.assets.overrides = {
-    ...parseResult.assets.overrides ?? {},
-    ...config.overrides
+  return {
+    assets: {
+      overrides: {
+        ...parseResult.assets?.overrides ?? {},
+        ...config.overrides
+      }
+    }
   };
 };
 var loadFunctions = async (config, parseResult, projectFolder) => {
   const functionConfigs = await getFilesForPattern(functionConfigsPattern, projectFolder);
+  const result = {
+    entrypoints: [],
+    routes: [],
+    regions: []
+  };
   for (const functionConfigPath of functionConfigs) {
-    const functionConfig = await readConfigFile(path3.join(projectFolder, functionConfigPath));
+    const functionConfig = await readConfigFile(path5.join(projectFolder, functionConfigPath));
     if (!functionConfig) {
       parseResult.errors.push(`Failed to read function config at ${functionConfigPath}`);
       continue;
     }
-    const functionName = path3.basename(path3.dirname(functionConfigPath)).replace(/\.func$/, "");
+    const functionPathRelative = path5.dirname(functionConfigPath).replace(functionsFolder, "");
+    const functionName = functionPathRelative.replace(/^\/|\.func$/g, "");
     const runtime = translateVercelRuntime(functionConfig.runtime);
     if (!runtime) {
       parseResult.errors.push(`Unsupported runtime for function ${functionName}: ${functionConfig.runtime}`);
       continue;
     }
     const functionDirectory = `.vercel/output/functions/${functionName}.func`;
-    const handler = functionConfig.handler;
-    const maxDuration = functionConfig.maxDuration;
-    const memory = functionConfig.memory;
-    parseResult.regions = Array.from(
-      /* @__PURE__ */ new Set([
-        ...parseResult.regions ?? [],
-        ...(functionConfig.regions ?? ["us-east-1"]).map((r) => translateVercelRegion(r))
-      ])
-    );
+    const {
+      handler,
+      maxDuration,
+      memory,
+      regions = [],
+      environment,
+      filePathMap: configFilePathMap = {}
+    } = functionConfig;
+    const translatedRegions = regions.length > 0 ? regions.map(translateVercelRegion) : ["us-east-1"];
+    result.regions = Array.from(/* @__PURE__ */ new Set([...parseResult.regions, ...translatedRegions]));
     const environmentVariables = {};
-    const functionEnv = functionConfig.environment;
-    if (functionEnv != null && typeof functionEnv === "object") {
-      for (const env of Object.values(functionEnv)) {
-        for (const [key, value] of Object.entries(env)) {
-          environmentVariables[key] = value;
-        }
+    if (environment && typeof environment === "object") {
+      for (const env of Object.values(environment)) {
+        Object.assign(environmentVariables, env);
       }
     }
-    const streaming = runtime == null || runtime.startsWith("node-") || runtime.startsWith("bun-");
-    const filePathMap = {};
-    for (const [key, value] of Object.entries(functionConfig.filePathMap ?? {})) {
-      filePathMap[path3.join(projectFolder, key)] = value;
+    const streaming = runtime.startsWith("node-") || runtime.startsWith("bun-");
+    let filePathMap = {};
+    for (const [key, value] of Object.entries(configFilePathMap)) {
+      filePathMap[path5.join(projectFolder, key)] = value;
+    }
+    if (Object.keys(filePathMap).length === 0) {
+      filePathMap = getDefaultPathMap(path5.join(projectFolder, functionDirectory));
     }
-    parseResult.entrypoints.push({
+    if (!result.entrypoints) {
+      result.entrypoints = [];
+    }
+    result.entrypoints.push({
       displayName: functionName,
       runtime,
-      path: handler,
+      path: path5.join(functionDirectory, handler),
       memory: memory ?? 1024,
       maxDuration: maxDuration ?? 15,
       environmentVariables,
       streaming,
       package: {
-        rootOverwrite: path3.join(projectFolder, functionDirectory),
         filePathMap
       }
     });
     const handlerType = streaming ? "SERVERLESS_FUNCTION_STREAMING" : "SERVERLESS_FUNCTION";
-    [
-      {
-        path: `/${functionName}`,
-        methods: ["ANY"],
-        headers: {},
-        destination: handler,
-        handler: handlerType
-      },
-      ...config.routes?.filter((r) => r.dest === `/${functionName}`).map((r) => ({
+    const defaultRoute = {
+      path: `/${functionName}`,
+      methods: ["ANY"],
+      headers: {},
+      destination: handler,
+      handler: handlerType
+    };
+    const configRoutes = config.routes?.filter((r) => r.dest === `/${functionName}`).map(
+      (r) => ({
         path: r.src ?? `/${functionName}`,
         methods: ["ANY"],
         headers: {},
         destination: handler,
         handler: handlerType
-      })) ?? []
-    ].forEach((route) => {
-      parseResult.routes.push(route);
-    });
-  }
-};
-var readConfigFile = async (configFilePath) => {
-  if (!fs3.existsSync(configFilePath)) {
-    return null;
-  }
-  const parsed = await parseRawConfig(configFilePath, { disableVersionCheck: true });
-  return parsed;
-};
-var translateVercelRuntime = (runtime) => {
-  switch (runtime) {
-    case "nodejs12.x":
-    case "nodejs14.x":
-    case "nodejs16.x":
-    case "nodejs18.x":
-      return "node-18";
-    case "nodejs20.x":
-    case "nodejs22.x":
-      return "node-20";
-    default:
-      return null;
+      })
+    ) ?? [];
+    if (!result.routes) {
+      result.routes = [];
+    }
+    result.routes.push(defaultRoute, ...configRoutes);
   }
+  return {
+    ...result,
+    userArchive: {
+      rootOverwrite: determineRepoRoot(projectFolder, result),
+      fileWhitelist: [
+        `${projectFolder}/*`,
+        ...getMonorepoFiles(projectFolder, result.entrypoints?.map((e) => e.package?.filePathMap ?? {}) ?? [])
+      ]
+    }
+  };
 };
-var translateVercelRegion = (region) => {
-  const regionMap = {
-    arn1: "eu-north-1",
-    bom1: "ap-south-1",
-    cdg1: "eu-west-3",
-    cle1: "us-east-2",
-    cpt1: "af-south-1",
-    dub1: "eu-west-1",
-    fra1: "eu-central-1",
-    gru1: "sa-east-1",
-    hkg1: "ap-east-1",
-    hnd1: "ap-northeast-1",
-    iad1: "us-east-1",
-    icn1: "ap-northeast-2",
-    kix1: "ap-northeast-3",
-    lhr1: "eu-west-2",
-    pdx1: "us-west-2",
-    sfo1: "us-west-1",
-    sin1: "ap-southeast-1",
-    syd1: "ap-southeast-2"
+
+// src/filter-functions-from-assets.ts
+var filterFunctionsFromAssets = async (config) => {
+  return {
+    ...config,
+    assets: {
+      ...config.assets,
+      paths: config.assets?.paths?.filter((path6) => !config.entrypoints.some((entrypoint) => entrypoint.path === path6))
+    }
   };
-  return regionMap[region.toLowerCase()] ?? "us-east-1";
 };
 
 // src/v4/parse.ts
 import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
-import fs4 from "fs";
+import fs5 from "fs";
 import { minimatch } from "minimatch";
 
 // src/regions.ts
@@ -235,16 +348,16 @@ var parseConfigV4 = async (config, projectFolder) => {
   const errors = [];
   const warnings = [];
   if (config.functions != null) {
-    for (const [path4, func] of Object.entries(config.functions)) {
-      const settings = getFunctionSettings(path4, config);
+    for (const [path6, func] of Object.entries(config.functions)) {
+      const settings = getFunctionSettings(path6, config);
       if (settings == null) {
-        throw new Error(`Settings invalid for function at path '${path4}'`);
+        throw new Error(`Settings invalid for function at path '${path6}'`);
       }
-      (await getFilesForPattern2(path4, projectFolder, func.excludeFiles)).forEach((file) => {
+      (await getFilesForPattern2(path6, projectFolder, func.excludeFiles)).forEach((file) => {
         if (entrypoints.find((entrypoint) => entrypoint.path === file)) {
           return;
         }
-        if (config.functions != null && Object.keys(config.functions).find((func2) => func2 === file && func2 !== path4)) {
+        if (config.functions != null && Object.keys(config.functions).find((func2) => func2 === file && func2 !== path6)) {
           return;
         }
         entrypoints.push({
@@ -262,11 +375,11 @@ var parseConfigV4 = async (config, projectFolder) => {
   const assets = [];
   if (config.assets != null) {
     const assetsPath = `${projectFolder}/${config.assets}`;
-    if (fs4.existsSync(assetsPath) && fs4.statSync(assetsPath).isDirectory()) {
-      for (const asset of fs4.readdirSync(`${projectFolder}/${config.assets}`, {
+    if (fs5.existsSync(assetsPath) && fs5.statSync(assetsPath).isDirectory()) {
+      for (const asset of fs5.readdirSync(`${projectFolder}/${config.assets}`, {
         recursive: true
       })) {
-        if (fs4.statSync(`${projectFolder}/${config.assets}/${asset}`).isDirectory()) {
+        if (fs5.statSync(`${projectFolder}/${config.assets}/${asset}`).isDirectory()) {
           continue;
         }
         const disallowedExtensions = [".htaccess", ".htpasswd"];
@@ -274,6 +387,9 @@ var parseConfigV4 = async (config, projectFolder) => {
         if (disallowedExtensions.some((ext) => assetName.toLowerCase().endsWith(ext.toLowerCase()))) {
           continue;
         }
+        if (getFunctionSettings(`${config.assets}/${assetName}`, config) != null) {
+          continue;
+        }
         assets.push(`${config.assets}/${assetName}`);
       }
     }
@@ -307,10 +423,10 @@ var parseConfigV4 = async (config, projectFolder) => {
     })
   };
 };
-var getFunctionSettings = (path4, config) => {
+var getFunctionSettings = (path6, config) => {
   let functionSettings;
   for (const [key, value] of Object.entries(config.functions ?? {})) {
-    if (minimatch(path4, key) || new RegExp(key).test(path4)) {
+    if (minimatch(path6, key) || new RegExp(key).test(path6)) {
       if (functionSettings == null) {
         functionSettings = {
           memory: 128,
@@ -720,6 +836,7 @@ var parseConfig = async (filePath, projectFolder) => {
       "The current project config does not resolve to any functions, assets or routes and can not be deployed."
     );
   }
+  parseResult = await filterFunctionsFromAssets(parseResult);
   return parseResult;
 };