cloud-run-functions 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Alec Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/config.schema.json

@@ -0,0 +1,70 @@
+{
+  "type": "object",
+  "properties": {
+    "root": {
+      "oneOf": [
+        {
+          "description": "The base directory when searching for entry points.\n\nDefaults to the config directory (or if no config file is found, the current working directory).",
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "globs": {
+      "oneOf": [
+        {
+          "description": "The globs determine which directories are searched for entry points. Only \".ts\" and \".js\" files are matched, so you're not required to include them in the globs.\n\nBy default all directories in the \"root\" are searched.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "extensions": {
+      "oneOf": [
+        {
+          "description": "The extensions to match for entry points.\n\n@default [\".ts\", \".js\"]",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "entrySuffix": {
+      "oneOf": [
+        {
+          "description": "The entry suffix should be a string like \".task\" or \".function\" which must be present in the file name (before the extension) or else that file will be ignored when scanning for entry points.\n\nIt can also be an empty string.",
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "adapter": {
+      "oneOf": [
+        {
+          "description": "The adapter wraps your Cloud Run functions at runtime, allowing you to write them with a platform-agnostic HTTP framework, like Hattip.\n\nSet this to \"node\" to skip using an adapter, in which case, your functions should conform to what @google-cloud/functions-framework expects.\n\n@default \"node\"",
+          "enum": [
+            "hattip",
+            "node"
+          ]
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "required": []
+}

package/dist/chunk-XTHOFO7F.js

@@ -0,0 +1,25 @@
+// 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
+};

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/main.js

@@ -0,0 +1,29 @@
+// src/main.ts
+import * as ordana from "ordana";
+var command = ordana.parse(process.argv.slice(2), {
+  name: "cloud-run-functions",
+  subcommands: {
+    dev: {
+      description: "Start the development server",
+      positionals: { maximum: 1 }
+    },
+    build: {
+      description: "Generate a bundle for each function",
+      positionals: { maximum: 1 }
+    }
+  }
+});
+if (command.type === "help") {
+  console.log(ordana.generateHelpMessage(command));
+} else {
+  const subcommands = {
+    async dev() {
+      const { dev } = await import("./tools/dev.js");
+      await dev(command.positionals[0]);
+    },
+    async build() {
+      throw new Error("Not implemented");
+    }
+  };
+  await subcommands[command.subcommand]();
+}

package/dist/targets/dev.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/targets/dev.js

@@ -0,0 +1,230 @@
+// src/targets/dev.ts
+import functions from "@google-cloud/functions-framework";
+import esbuild from "esbuild";
+import { findUpSync } from "find-up-simple";
+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
+function dedent(text, ...values) {
+  var _a;
+  if (isArray(text)) {
+    if (values.length > 0) {
+      return dedent(
+        text.reduce((acc, input, i) => {
+          var _a2;
+          let value = String(values[i] ?? "");
+          const indent2 = value.includes("\n") && ((_a2 = input.match(/[ \t]*(?=[^\n]*$)/)) == null ? void 0 : _a2[0]);
+          if (indent2) {
+            value = value.replace(/\n(?=[^\n]*?\S)/g, "\n" + indent2);
+          }
+          return acc + input + value;
+        }, "")
+      );
+    }
+    text = text[0];
+  }
+  const indent = values[0] ?? ((_a = text.match(/^[ \t]*(?=\S)/m)) == null ? void 0 : _a[0]);
+  const output = indent ? text.replace(new RegExp(`^${indent}`, "gm"), "") : text;
+  return output.replace(/^[ \t]*\n|\n[ \t]*$/g, "");
+}
+var isArray = /* @__PURE__ */ (() => Array.isArray)();
+var asyncIteratorSymbol = (
+  /* c8 ignore next */
+  Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator")
+);
+
+// src/config/schema.ts
+var configSchema = z.partial(
+  z.interface({
+    root: z.string().register(z.globalRegistry, {
+      description: dedent`
+        The base directory when searching for entry points.
+
+        Defaults to the config directory (or if no config file is found, the current working directory).
+      `
+    }),
+    globs: z.array(z.string()).register(z.globalRegistry, {
+      description: dedent`
+        The globs determine which directories are searched for entry points. Only ".ts" and ".js" files are matched, so you're not required to include them in the globs.
+
+        By default all directories in the "root" are searched.
+      `
+    }),
+    extensions: z.array(z.string()).register(z.globalRegistry, {
+      description: dedent`
+        The extensions to match for entry points.
+
+        @default [".ts", ".js"]
+      `
+    }),
+    entrySuffix: z.string().register(z.globalRegistry, {
+      description: dedent`
+        The entry suffix should be a string like ".task" or ".function" which must be present in the file name (before the extension) or else that file will be ignored when scanning for entry points.
+
+        It can also be an empty string.
+      `
+    }),
+    adapter: z.enum(["hattip", "node"]).register(z.globalRegistry, {
+      description: dedent`
+        The adapter wraps your Cloud Run functions at runtime, allowing you to write them with a platform-agnostic HTTP framework, like Hattip.
+
+        Set this to "node" to skip using an adapter, in which case, your functions should conform to what @google-cloud/functions-framework expects.
+
+        @default "node"
+      `
+    })
+  })
+);
+
+// src/config/index.ts
+var joycon = new Joycon();
+function loadConfig(cwd) {
+  const result = joycon.loadSync(["crf.config.json"], cwd);
+  if (!result.path) {
+    return {
+      configDir: null
+    };
+  }
+  return {
+    ...z2.parse(configSchema, result.data),
+    configDir: path.dirname(result.path)
+  };
+}
+
+// src/utils/emptyDir.ts
+import fs from "node:fs";
+function emptyDir(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/utils/hash.ts
+import crypto from "node:crypto";
+function hash(data, len) {
+  return crypto.createHash("sha256").update(data).digest("hex").slice(0, 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 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();
+  for (const glob of config.globs ?? ["**/*"]) {
+    let ext = path2.extname(glob);
+    if (ext) {
+      knownSuffixes.add(requiredSuffix + ext);
+      entryPoints.push(
+        requiredSuffix ? glob.replace(ext, requiredSuffix + ext) : glob
+      );
+      continue;
+    }
+    for (ext of config.extensions ?? [".ts", ".js"]) {
+      ext = requiredSuffix + ext;
+      knownSuffixes.add(ext);
+      entryPoints.push(glob + ext);
+    }
+  }
+  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)}`)
+  );
+  console.log({
+    root,
+    outDir,
+    entryPoints,
+    knownSuffixesRE
+  });
+  const context = await esbuild.context({
+    entryPoints,
+    absWorkingDir: root,
+    outdir: outDir,
+    bundle: true,
+    format: "esm",
+    packages: nodeModulesDir ? "external" : "bundle",
+    sourcemap: true,
+    metafile: true,
+    logOverride: {
+      "empty-glob": "silent"
+    },
+    plugins: [
+      {
+        name: "build-status",
+        setup(build) {
+          build.onStart(() => {
+            pendingBuild = Promise.withResolvers();
+          });
+          build.onEnd((result) => {
+            pendingBuild.resolve(result);
+          });
+        }
+      }
+    ]
+  });
+  await context.watch();
+  console.log("[esbuild] Watching for changes...");
+  try {
+    const dotenv = await import("dotenv");
+    dotenv.config();
+  } catch {
+  }
+  return {
+    async match(url) {
+      const result = await pendingBuild.promise;
+      for (const [file, output] of Object.entries(
+        result.metafile?.outputs ?? {}
+      )) {
+        if (!output.entryPoint) {
+          continue;
+        }
+        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;
+          switch (config.adapter) {
+            case "hattip": {
+              const { createMiddleware } = await import("@hattip/adapter-node");
+              return createMiddleware(taskHandler);
+            }
+            default:
+              return taskHandler;
+          }
+        }
+      }
+      return null;
+    }
+  };
+}
+var buildPromise = createBuild();
+functions.http("dev", async (req, res) => {
+  const url = new URL(req.url, "http://" + req.headers.host);
+  const build = await buildPromise;
+  const handler = await build.match(url);
+  if (handler) {
+    handler(req, res);
+  } else {
+    res.status(404).end();
+  }
+});

package/dist/tools/build.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/tools/dev.d.ts

@@ -0,0 +1,8 @@
+import * as picospawn from 'picospawn';
+
+/**
+ * Start the development server in a separate process.
+ */
+declare function dev(root?: string): picospawn.PicospawnPromise<string>;
+
+export { dev };

package/dist/tools/dev.js

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

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "cloud-run-functions",
+  "type": "module",
+  "version": "0.1.0",
+  "bin": "./dist/main.js",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "config.schema.json"
+  ],
+  "license": "MIT",
+  "author": "Alec Larson",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alloc/cloud-run-functions.git"
+  },
+  "prettier": "@alloc/prettier-config",
+  "devDependencies": {
+    "@alloc/prettier-config": "^1.0.0",
+    "@google-cloud/functions-framework": "latest",
+    "@hattip/adapter-node": "latest",
+    "@hattip/core": "latest",
+    "@types/node": "^22.15.17",
+    "dotenv": "^16.5.0",
+    "prettier": "^3.5.3",
+    "radashi": "^12.4.0",
+    "rimraf": "^6.0.1",
+    "tsc-lint": "^0.1.9",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3"
+  },
+  "dependencies": {
+    "@zod/mini": "4.0.0-beta.0",
+    "esbuild": "^0.25.4",
+    "find-up-simple": "^1.0.1",
+    "joycon": "^3.1.1",
+    "ordana": "^0.4.0",
+    "picospawn": "^0.3.1",
+    "tinyglobby": "^0.2.13"
+  },
+  "peerDependencies": {
+    "@google-cloud/functions-framework": "*",
+    "@hattip/adapter-node": "*",
+    "dotenv": "*"
+  },
+  "peerDependenciesMeta": {
+    "@hattip/adapter-node": {
+      "optional": true
+    },
+    "dotenv": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "dev": "rimraf dist && tsup --sourcemap --watch",
+    "build": "rimraf dist && tsup",
+    "format": "prettier --write .",
+    "lint": "tsc-lint",
+    "test": "vitest"
+  }
+}

package/readme.md

@@ -0,0 +1,29 @@
+# cloud-run-functions
+
+> ⚠️ This project is not ready for production use.
+
+Enhances the `@google-cloud/functions-framework` package with "hot reloading" (for local development) and a bundler (for deployment).
+
+```
+pnpm add cloud-run-functions -D
+```
+
+## Development server
+
+The dev server uses the `@google-cloud/functions-framework` package to run your functions locally. We handle _transpiling_ and _hot reloading_ for you. Just tell the dev server where to find your functions.
+
+```sh
+npx cloud-run-functions dev ./path/to/functions/
+```
+
+By default, any `.ts` or `.js` module is considered "loadable" by the dev server. This behavior is configurable with a `crf.config.json` file.
+
+The dev server uses filesystem routing. By default, the dev server runs on port 8080. So if you do `http get :8080/hello` from your terminal, the dev server will look for a file called `hello.ts` or `hello.js` in the `./path/to/functions/` directory. If that file exists, its default export will be used as the function handler.
+
+## Bundling
+
+When you're ready to deploy, use the `build` command to bundle your functions.
+
+```sh
+npx cloud-run-functions build ./path/to/functions/
+```