cloud-run-functions 0.1.0 → 0.1.2

package/config.schema.json

@@ -64,6 +64,30 @@
           "type": "null"
         }
       ]
+    },
+    "maxInstanceConcurrency": {
+      "oneOf": [
+        {
+          "description": "The maximum number of instances (per function) that can be run concurrently. You can either set the same limit for all functions or set a different limit for each function.\n\n@default 5",
+          "oneOf": [
+            {
+              "type": "number"
+            },
+            {
+              "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
+              "additionalProperties": {
+                "type": "number"
+              }
+            }
+          ]
+        },
+        {
+          "type": "null"
+        }
+      ]
     }
   },
   "required": []

package/dist/chunk-DG37B63B.js

@@ -0,0 +1,33 @@
+// src/tools/dev.ts
+import { findUpSync } from "find-up-simple";
+import path from "node:path";
+import $ from "picospawn";
+function dev(root, { port, define, ...options } = {}) {
+  const packageDir = findUpSync("dist", {
+    cwd: import.meta.dirname,
+    type: "directory"
+  });
+  const source = path.join(packageDir, "targets/dev.js");
+  const binDir = path.resolve(packageDir, "../node_modules/.bin");
+  return $(
+    "functions-framework --target=dev --source %s",
+    [source, port != null && ["--port", port.toString()]],
+    {
+      stdio: "inherit",
+      ...options,
+      env: {
+        ...options.env ?? process.env,
+        CRF_OPTIONS: JSON.stringify({
+          searchDir: root,
+          workingDir: process.cwd(),
+          define
+        }),
+        PATH: `${binDir}:${process.env.PATH}`
+      }
+    }
+  );
+}
+
+export {
+  dev
+};

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export { dev } from './tools/dev.js';
+export { DevOptions, dev } from './tools/dev.js';
 import 'picospawn';
+import './tools/build.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   dev
-} from "./chunk-XTHOFO7F.js";
+} from "./chunk-DG37B63B.js";
 export {
   dev
 };

package/dist/targets/dev.js

@@ -1,19 +1,39 @@
 // src/targets/dev.ts
+import "source-map-support/register.js";
 import functions from "@google-cloud/functions-framework";
 import esbuild from "esbuild";
 import { findUpSync } from "find-up-simple";
+import fs2 from "node:fs";
+import { Module } from "node:module";
 import os from "node:os";
 import path2 from "node:path";
 
-// src/config/index.ts
-import * as z2 from "@zod/mini";
-import Joycon from "joycon";
-import path from "node:path";
-
-// src/config/schema.ts
-import * as z from "@zod/mini";
-
 // node_modules/.pnpm/radashi@12.4.0/node_modules/radashi/dist/radashi.js
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message ?? "Operation timed out");
+    this.name = "TimeoutError";
+  }
+};
+function timeout(ms, error) {
+  return new Promise(
+    (_, reject) => setTimeout(
+      () => reject(isFunction(error) ? error() : new TimeoutError(error)),
+      ms
+    )
+  );
+}
+async function toResult(promise) {
+  try {
+    const result = await promise;
+    return [void 0, result];
+  } catch (error) {
+    if (isError(error)) {
+      return [error, void 0];
+    }
+    throw error;
+  }
+}
 function dedent(text, ...values) {
   var _a;
   if (isArray(text)) {
@@ -41,8 +61,26 @@ var asyncIteratorSymbol = (
   /* c8 ignore next */
   Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator")
 );
+function isError(value) {
+  return isTagged(value, "[object Error]");
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function isTagged(value, tag) {
+  return Object.prototype.toString.call(value) === tag;
+}
+
+// src/config/index.ts
+import * as z2 from "@zod/mini";
+import Joycon from "joycon";
+import path from "node:path";
 
 // src/config/schema.ts
+import * as z from "@zod/mini";
 var configSchema = z.partial(
   z.interface({
     root: z.string().register(z.globalRegistry, {
@@ -81,6 +119,13 @@ var configSchema = z.partial(
 
         @default "node"
       `
+    }),
+    maxInstanceConcurrency: z.union([z.number(), z.record(z.string(), z.number())]).register(z.globalRegistry, {
+      description: dedent`
+          The maximum number of instances (per function) that can be run concurrently. You can either set the same limit for all functions or set a different limit for each function.
+
+          @default 5
+        `
     })
   })
 );
@@ -116,11 +161,10 @@ function hash(data, len) {
 
 // src/targets/dev.ts
 async function createBuild() {
-  const callerDir = process.env.CALLER_DIR ?? "";
-  const searchDir = process.env.CRF_ROOT ? path2.resolve(callerDir, process.env.CRF_ROOT) : callerDir;
+  const options = JSON.parse(process.env.CRF_OPTIONS);
+  const searchDir = path2.resolve(options.workingDir, options.searchDir ?? "");
   const config = loadConfig(searchDir);
   const root = config.configDir ? path2.resolve(config.configDir, config.root ?? "") : searchDir;
-  let pendingBuild;
   const entryPoints = [];
   const requiredSuffix = config.entrySuffix?.replace(/^\.?/, ".") ?? "";
   const knownSuffixes = /* @__PURE__ */ new Set();
@@ -142,27 +186,25 @@ async function createBuild() {
   const knownSuffixesRE = new RegExp(
     `(${Array.from(knownSuffixes, (e) => e.replace(/\./g, "\\.")).sort((a, b) => b.length - a.length).join("|")})$`
   );
-  const nodeModulesDir = findUpSync("node_modules", {
-    cwd: root,
-    type: "directory"
-  });
-  const outDir = emptyDir(
-    nodeModulesDir ? path2.join(nodeModulesDir, `.cache/cloud-run-functions-${hash(root, 8)}`) : path2.join(os.tmpdir(), `cloud-run-functions-${hash(root, 8)}`)
+  const cacheDir = emptyDir(
+    path2.join(
+      fs2.realpathSync(os.tmpdir()),
+      "cloud-run-functions-" + hash(root, 8)
+    )
   );
-  console.log({
-    root,
-    outDir,
-    entryPoints,
-    knownSuffixesRE
-  });
+  let pendingBuild;
+  let finishedBuild;
   const context = await esbuild.context({
     entryPoints,
     absWorkingDir: root,
-    outdir: outDir,
+    outdir: cacheDir,
+    define: options.define,
     bundle: true,
-    format: "esm",
-    packages: nodeModulesDir ? "external" : "bundle",
+    format: "cjs",
+    platform: "node",
+    packages: "bundle",
     sourcemap: true,
+    sourcesContent: false,
     metafile: true,
     logOverride: {
       "empty-glob": "silent"
@@ -171,11 +213,16 @@ async function createBuild() {
       {
         name: "build-status",
         setup(build) {
+          pendingBuild = Promise.withResolvers();
           build.onStart(() => {
-            pendingBuild = Promise.withResolvers();
+            pendingBuild ??= Promise.withResolvers();
           });
           build.onEnd((result) => {
-            pendingBuild.resolve(result);
+            if (pendingBuild) {
+              pendingBuild.resolve(result);
+              pendingBuild = void 0;
+            }
+            finishedBuild = result;
           });
         }
       }
@@ -183,14 +230,22 @@ async function createBuild() {
   });
   await context.watch();
   console.log("[esbuild] Watching for changes...");
-  try {
-    const dotenv = await import("dotenv");
-    dotenv.config();
-  } catch {
+  const envPath = findUpSync(".env", { cwd: root });
+  if (envPath) {
+    try {
+      const dotenv = await import("dotenv");
+      dotenv.config({ path: envPath });
+      console.log("[dotenv] Environment variables loaded.");
+    } catch {
+    }
   }
+  const taskStates = /* @__PURE__ */ new Map();
   return {
     async match(url) {
-      const result = await pendingBuild.promise;
+      const result = await pendingBuild?.promise ?? finishedBuild;
+      if (!result) {
+        return null;
+      }
       for (const [file, output] of Object.entries(
         result.metafile?.outputs ?? {}
       )) {
@@ -199,18 +254,50 @@ async function createBuild() {
         }
         const taskName = output.entryPoint.replace(knownSuffixesRE, "");
         if (url.pathname === "/" + taskName) {
-          const taskPath = path2.join(root, file) + "?t=" + Date.now();
-          console.log("Importing:", taskPath);
-          const taskModule = await import(taskPath);
-          const taskHandler = taskModule.default;
+          const taskState = taskStates.get(taskName) ?? {
+            running: 0,
+            queue: []
+          };
+          const taskConcurrency = isNumber(config.maxInstanceConcurrency) ? config.maxInstanceConcurrency : config.maxInstanceConcurrency?.[taskName] ?? 5;
+          if (taskState.running >= taskConcurrency) {
+            const ticket = Promise.withResolvers();
+            taskState.queue.push(ticket);
+            const [error] = await toResult(
+              Promise.race([ticket.promise, timeout(3e4)])
+            );
+            if (error) {
+              return (_req, res) => {
+                res.status(429).end();
+              };
+            }
+          }
+          taskState.running++;
+          taskStates.set(taskName, taskState);
+          const require2 = Module.createRequire(import.meta.filename);
+          let taskHandler = require2(path2.join(root, file));
+          while (taskHandler && typeof taskHandler !== "function") {
+            taskHandler = taskHandler.default;
+          }
+          if (!taskHandler) {
+            return () => {
+              throw new Error(`Task ${taskName} is not a function.`);
+            };
+          }
           switch (config.adapter) {
             case "hattip": {
               const { createMiddleware } = await import("@hattip/adapter-node");
-              return createMiddleware(taskHandler);
+              taskHandler = createMiddleware(taskHandler);
             }
-            default:
-              return taskHandler;
           }
+          return (req, res) => {
+            const end = res.end.bind(res);
+            res.end = (...args) => {
+              taskState.running--;
+              taskState.queue.shift()?.resolve();
+              return end(...args);
+            };
+            return taskHandler(req, res);
+          };
         }
       }
       return null;
@@ -223,7 +310,12 @@ functions.http("dev", async (req, res) => {
   const build = await buildPromise;
   const handler = await build.match(url);
   if (handler) {
-    handler(req, res);
+    try {
+      await handler(req, res);
+    } catch (error) {
+      console.error(error);
+      res.status(500).end();
+    }
   } else {
     res.status(404).end();
   }

package/dist/tools/build.d.ts

@@ -1,2 +1,17 @@
+type BuildOptions = {
+    /**
+     * Statically replace specific variables in the source code.
+     *
+     * ⚠️ The value must be valid JavaScript syntax!
+     *
+     * @example
+     * ```ts
+     * define: {
+     *   'process.env.NODE_ENV': '"development"',
+     * }
+     * ```
+     */
+    define?: Record<string, string>;
+};
 
-export {  }
+export type { BuildOptions };

package/dist/tools/dev.d.ts

@@ -1,8 +1,17 @@
 import * as picospawn from 'picospawn';
+import { PicospawnOptions } from 'picospawn';
+import { BuildOptions } from './build.js';
 
+interface DevOptions extends PicospawnOptions, BuildOptions {
+    /**
+     * Customize the port to use for the development server.
+     * @default 8080
+     */
+    port?: string | number;
+}
 /**
  * Start the development server in a separate process.
  */
-declare function dev(root?: string): picospawn.PicospawnPromise<string>;
+declare function dev(root?: string, { port, define, ...options }?: DevOptions): picospawn.PicospawnPromise<unknown>;
 
-export { dev };
+export { type DevOptions, dev };

package/dist/tools/dev.js

@@ -1,6 +1,6 @@
 import {
   dev
-} from "../chunk-XTHOFO7F.js";
+} from "../chunk-DG37B63B.js";
 export {
   dev
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cloud-run-functions",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "bin": "./dist/main.js",
   "exports": {
     "types": "./dist/index.d.ts",
@@ -39,7 +39,8 @@
     "find-up-simple": "^1.0.1",
     "joycon": "^3.1.1",
     "ordana": "^0.4.0",
-    "picospawn": "^0.3.1",
+    "picospawn": "^0.3.2",
+    "source-map-support": "^0.5.21",
     "tinyglobby": "^0.2.13"
   },
   "peerDependencies": {

package/readme.md

@@ -27,3 +27,7 @@ When you're ready to deploy, use the `build` command to bundle your functions.
 ```sh
 npx cloud-run-functions build ./path/to/functions/
 ```
+
+## Tips
+
+- If you have the [dotenv](https://www.npmjs.com/package/dotenv) package installed, the dev server will import it and automatically load environment variables from the closest `.env` file. Note that environment variables in `.env` won't override existing `process.env` values.

package/dist/chunk-XTHOFO7F.js

@@ -1,25 +0,0 @@
-// src/tools/dev.ts
-import { findUpSync } from "find-up-simple";
-import path from "node:path";
-import $ from "picospawn";
-function dev(root) {
-  const packageDir = findUpSync("dist", {
-    cwd: import.meta.dirname,
-    type: "directory"
-  });
-  const source = path.join(packageDir, "targets/dev.js");
-  const binDir = path.resolve(packageDir, "../node_modules/.bin");
-  return $("functions-framework --target=dev --source", [source], {
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      CRF_ROOT: root,
-      CALLER_DIR: process.cwd(),
-      PATH: `${binDir}:${process.env.PATH}`
-    }
-  });
-}
-
-export {
-  dev
-};