1tube 0.2.0 → 0.3.0

package/src/cli/package.ts

@@ -588,7 +588,7 @@ Options:
       --compat-flag FLAG     Add a workerd compatibility flag (repeatable)
       --workerd-env A,B,C    Env vars baked into the manifest's allowlist
       --workerd-shared path  Shared module path (repeatable)
-      --config <path>        Explicit deno.json path for the build import map
+      --config <path>        Import map path for the build (import_map.json, or deno.json[c])
       --no-config            Skip the build import map entirely
   -h, --help                 Show this help`;
 

package/src/cli/test.ts

@@ -0,0 +1,145 @@
+/**
+ * `1tube test` — run edge function tests with gateway-identical resolution.
+ *
+ *   1tube test [--functions <dir>] [--config <import map>] [--env-file <f>]…
+ *              [bun test args / paths…]
+ *
+ * Test files import from `1tube/test`; this command picks the runner for
+ * the current runtime (Bun: `bun test`) and preloads the compat layer so
+ * the import map, `npm:` / `jsr:` specifiers and the managed dependency
+ * store apply to function code under test. Without explicit paths it runs
+ * every test under the functions dir.
+ */
+
+import { existsSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** `bun test` flags that consume the following token as their value. */
+const BUN_TEST_VALUE_FLAGS = new Set([
+  "--timeout",
+  "--rerun-each",
+  "--retry",
+  "-t",
+  "--test-name-pattern",
+  "--preload",
+  "--coverage-reporter",
+  "--coverage-dir",
+  "--reporter",
+  "--reporter-outfile",
+  "--seed",
+  "--max-concurrency",
+  "--path-ignore-patterns",
+]);
+
+export interface TestArgs {
+  functionsDir: string;
+  config?: string;
+  depsDir?: string;
+  envFiles: string[];
+  forwarded: string[];
+  hasPaths: boolean;
+}
+
+export function parseTestArgs(argv: readonly string[]): TestArgs {
+  const out: TestArgs = { functionsDir: "", envFiles: [], forwarded: [], hasPaths: false };
+  let functionsDir: string | undefined;
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "--") {
+      for (const rest of argv.slice(i + 1)) {
+        out.forwarded.push(rest);
+        if (!rest.startsWith("-")) out.hasPaths = true;
+      }
+      break;
+    }
+    const eq = tok.startsWith("--") ? tok.indexOf("=") : -1;
+    const flag = eq === -1 ? tok : tok.slice(0, eq);
+    const value = () => (eq !== -1 ? tok.slice(eq + 1) : argv[++i]);
+    switch (flag) {
+      case "--functions":
+      case "-f":
+        functionsDir = value();
+        continue;
+      case "--config":
+      case "--import-map":
+        out.config = value();
+        continue;
+      case "--deps-dir":
+        out.depsDir = value();
+        continue;
+      case "--env-file":
+        out.envFiles.push(value());
+        continue;
+    }
+    out.forwarded.push(tok);
+    if (BUN_TEST_VALUE_FLAGS.has(flag) && eq === -1 && i + 1 < argv.length) {
+      out.forwarded.push(argv[++i]);
+    } else if (!tok.startsWith("-")) {
+      out.hasPaths = true;
+    }
+  }
+  out.functionsDir = functionsDir ??
+    (existsSync("supabase/functions") ? "supabase/functions" : "functions");
+  return out;
+}
+
+export async function runTest(argv: readonly string[]): Promise<number> {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(`Usage: 1tube test [options] [bun test args / paths…]
+
+Runs edge function tests (files importing \`1tube/test\`) with the gateway's
+module resolution. Without paths, runs every test under the functions dir.
+
+Options:
+  --functions, -f <dir>   Functions dir (default: supabase/functions, else functions)
+  --config <path>         Import map (import_map.json, or a deno.json[c] with "imports")
+  --deps-dir <path>       Managed npm:/jsr: store (default <cwd>/.1tube/deps)
+  --env-file <path>       Env file loaded into the test process (repeatable)
+  --                      Pass everything after it to the runner verbatim
+`);
+    return 0;
+  }
+  const args = parseTestArgs(argv);
+  const cwd = process.cwd();
+  const functionsAbs = resolve(cwd, args.functionsDir);
+  if (!existsSync(functionsAbs)) {
+    console.error(`[1tube] test: functions dir not found: ${functionsAbs}`);
+    return 1;
+  }
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    "1TUBE_FUNCTIONS_DIR": functionsAbs,
+  };
+  if (args.config) {
+    const abs = isAbsolute(args.config) ? args.config : resolve(cwd, args.config);
+    if (!existsSync(abs)) {
+      console.error(`[1tube] test: --config not found: ${abs}`);
+      return 1;
+    }
+    env["1TUBE_IMPORT_MAP"] = abs;
+  }
+  if (args.depsDir) env["1TUBE_DEPS_DIR"] = resolve(cwd, args.depsDir);
+
+  const preload = fileURLToPath(new URL("../test/preload.ts", import.meta.url));
+  // A path filter starting with "./" is matched as a path, not a substring.
+  const rel = relative(cwd, functionsAbs).replace(/\\/g, "/");
+  const defaultPath = rel.startsWith("..") || isAbsolute(rel) ? functionsAbs : `./${rel || "."}`;
+  const cmd = [
+    process.execPath,
+    // Like the gateway: only the env files the caller named.
+    ...(args.envFiles.length > 0
+      ? args.envFiles.map((f) => `--env-file=${resolve(cwd, f)}`)
+      : ["--no-env-file"]),
+    "test",
+    "--preload",
+    preload,
+    ...args.forwarded,
+    ...(args.hasPaths ? [] : [defaultPath]),
+  ];
+  const child = Bun.spawn(cmd, { stdin: "inherit", stdout: "inherit", stderr: "inherit", env });
+  for (const sig of ["SIGINT", "SIGTERM"] as const) {
+    process.on(sig, () => child.kill(sig));
+  }
+  return await child.exited;
+}

package/src/cli/vercel-build.ts

@@ -581,7 +581,7 @@ export async function buildVercel(
  *   --max-duration-cap <s> hard cap for maxDuration (default 800)
  *   --deployment-id <id>   custom Skew Protection deployment id written to
  *                          config.json (env: 1TUBE_VERCEL_DEPLOYMENT_ID)
- *   --config <path>        explicit deno.json path
+ *   --config <path>        import map path
  *   --no-config            skip the import map
  */
 export async function runVercelBuild(args: string[]): Promise<number> {
@@ -801,8 +801,8 @@ Options:
                              Bake the same id into the frontend and send it as
                              x-deployment-id / ?dpl= on fetch() calls.
                              Env fallback: 1TUBE_VERCEL_DEPLOYMENT_ID
-      --config <path>        Explicit deno.json path for the import map.
-                             Default: auto-detect cwd/deno.json[c] then
-                             <functions-dir>/deno.json[c] (Supabase layout).
+      --config <path>        Import map path (import_map.json, or deno.json[c]).
+                             Default: auto-detect cwd/{import_map,deno}.json[c] then
+                             <functions-dir>/{import_map,deno}.json[c] (Supabase layout).
       --no-config            Skip the import map entirely.
   -h, --help                 Show this help`;

package/src/compat/environment.ts

@@ -6,7 +6,7 @@
  * whether a function runs locally or ships in a bundle.
  *
  *   1TUBE_DEPS_DIR                 managed store (default <cwd>/.1tube/deps)
- *   1TUBE_DENO_CONFIG              explicit deno.json[c] for the import map
+ *   1TUBE_IMPORT_MAP               explicit import map (legacy name: 1TUBE_DENO_CONFIG)
  *   1TUBE_DEPS_ISOLATED=1          ignore host node_modules
  *   1TUBE_MINIMUM_DEPENDENCY_AGE   min release age for managed installs
  *   1TUBE_RELOAD_REMOTE=1          re-download cached https: modules
@@ -45,7 +45,8 @@ export function createCompatEnvironment(
     cwd,
     opts.depsDir ?? process.env["1TUBE_DEPS_DIR"] ?? join(".1tube", "deps"),
   );
-  const configPath = opts.configPath ?? process.env["1TUBE_DENO_CONFIG"] ??
+  const configPath = opts.configPath ?? process.env["1TUBE_IMPORT_MAP"] ??
+    process.env["1TUBE_DENO_CONFIG"] ??
     findDenoConfig(cwd, opts.functionsDir);
   return {
     deps: createDependencyManager({

package/src/compat/import-map.ts

@@ -1,8 +1,9 @@
 /**
- * Deno import-map support (`imports` + `scopes` from deno.json[c]).
+ * Import-map support (`imports` + `scopes` from an import_map.json, or a
+ * deno.json[c] carrying them).
  *
- * Supabase projects keep their aliases in `supabase/functions/deno.json`
- * (or a repo-root deno.json). Bun has no notion of that file, so the compat
+ * Supabase projects keep their aliases in `supabase/functions/import_map.json`
+ * or `supabase/functions/deno.json` (or at the repo root). Bun has no notion of that file, so the compat
  * plugin and the HMR dep-graph both resolve aliases through this module —
  * the Deno CLI's algorithm reduced to its essentials: exact match first,
  * otherwise the longest trailing-slash prefix, with the most specific
@@ -58,19 +59,21 @@ export function stripJsonc(text: string): string {
   return out.replace(/,\s*([}\]])/g, "$1");
 }
 
+/** File names searched for an import map, in priority order. */
+export const IMPORT_MAP_FILES = ["import_map.json", "deno.json", "deno.jsonc"] as const;
+
 /**
- * Conventional deno.json locations for a functions project, most specific
- * last-checked: cwd first (repo-root config), then the functions dir
- * (Supabase's `supabase/functions/deno.json`).
+ * Conventional import-map locations for a functions project: cwd first
+ * (repo-root config), then the functions dir (Supabase's
+ * `supabase/functions/import_map.json` or `deno.json`).
  */
 export function findDenoConfig(
   cwd: string,
   functionsDir?: string,
 ): string | undefined {
-  const candidates = [join(cwd, "deno.json"), join(cwd, "deno.jsonc")];
+  const candidates = IMPORT_MAP_FILES.map((f) => join(cwd, f));
   if (functionsDir) {
-    candidates.push(join(functionsDir, "deno.json"));
-    candidates.push(join(functionsDir, "deno.jsonc"));
+    candidates.push(...IMPORT_MAP_FILES.map((f) => join(functionsDir, f)));
   }
   for (const c of candidates) {
     try {

package/src/launch.ts

@@ -10,6 +10,7 @@
  * ========
  *   build      → cli/build.ts   (bundle for workerd/vercel)
  *   package    → cli/package.ts (sign a firmware payload)
+ *   test       → cli/test.ts    (run function tests via `1tube/test`)
  *   --version  → print version
  *   --help     → usage
  *   <else>     → serve (the gateway)            ← default, may be spelled `serve`
@@ -35,6 +36,7 @@ import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { watchFs } from "./fs-watch.ts";
+import { IMPORT_MAP_FILES } from "./compat/import-map.ts";
 
 // ---------------------------------------------------------------------------
 // Top-level dispatch
@@ -46,6 +48,10 @@ export async function run(argv: readonly string[]): Promise<void> {
     const { runBuild } = await import("./cli/build.ts");
     process.exit(await runBuild(argv.slice(1)));
   }
+  if (arg0 === "test") {
+    const { runTest } = await import("./cli/test.ts");
+    process.exit(await runTest(argv.slice(1)));
+  }
   if (arg0 === "package") {
     const { runPackage } = await import("./cli/package.ts");
     process.exit(await runPackage(argv.slice(1)));
@@ -71,13 +77,14 @@ Commands:
   serve       Run the gateway (default when no command given)
   build       Bundle functions for a target (--target workerd|vercel)
   package     Build and/or wrap dist/ into a signed .1tube firmware payload
+  test        Run function tests (files importing 1tube/test) with gateway resolution
   --version   Print version and exit
   --help      Print this help
 
 Serve options (everything else is forwarded to the gateway):
   --deps-dir <path>             Managed npm:/jsr: store (default <cwd>/.1tube/deps)
   --refresh-deps                Drop the managed store's lockfile for a clean re-resolve
-  --config <path>               Host deno.json[c] whose import map functions use
+  --config <path>               Import map functions use (import_map.json, or deno.json[c])
   --env-file[=<path>]           Env file loaded into the gateway (repeatable)
   --minimum-dependency-age <n>  Minimum release age for managed installs (s, or 30m/24h/7d)
   --no-pin                      Ignore host node_modules; resolve npm: only via the managed store
@@ -236,7 +243,7 @@ async function runServe(args: ServeArgs): Promise<never> {
     ...process.env,
     "1TUBE_DEPS_DIR": depsDir,
   };
-  if (configAbs) childEnv["1TUBE_DENO_CONFIG"] = configAbs;
+  if (configAbs) childEnv["1TUBE_IMPORT_MAP"] = configAbs;
   if (!args.pin) childEnv["1TUBE_DEPS_ISOLATED"] = "1";
   if (args.minimumDependencyAge !== undefined) {
     childEnv["1TUBE_MINIMUM_DEPENDENCY_AGE"] = args.minimumDependencyAge;
@@ -259,7 +266,7 @@ async function runServe(args: ServeArgs): Promise<never> {
   ];
 
   const watchPaths = [
-    ...(configAbs ? [configAbs] : ["deno.json", "deno.jsonc"].map(resolveToAbs)),
+    ...(configAbs ? [configAbs] : IMPORT_MAP_FILES.map(resolveToAbs)),
     ...PROJECT_DEP_FILES.map(resolveToAbs),
   ];
 

package/src/test/api.ts

@@ -0,0 +1,40 @@
+/**
+ * The `1tube/test` contract every runner binding implements.
+ *
+ * Edge function tests import `test`, `describe`, hooks and assertions from
+ * `1tube/test` instead of a specific runner, so the same files run under
+ * `bun test` today and under another runtime's runner (node:test, a workerd
+ * pool) later. Keep this surface to what every runner can express: no test
+ * context argument, no runner-specific options.
+ */
+
+export type TestFn = () => void | Promise<unknown>;
+export type HookFn = () => void | Promise<unknown>;
+
+export interface TestOptions {
+  /** Per-test timeout in milliseconds (runner default when omitted). */
+  timeout?: number;
+  /** Register but do not run. */
+  skip?: boolean;
+  /** Run only tests marked `only` (where the runner supports focusing). */
+  only?: boolean;
+}
+
+export interface TestFunction {
+  (name: string, fn: TestFn, options?: TestOptions): void;
+  skip(name: string, fn: TestFn, options?: TestOptions): void;
+  only(name: string, fn: TestFn, options?: TestOptions): void;
+  /** A placeholder for a test that is not written yet. */
+  todo(name: string): void;
+}
+
+export interface DescribeFunction {
+  (name: string, fn: () => void): void;
+  skip(name: string, fn: () => void): void;
+  only(name: string, fn: () => void): void;
+}
+
+export type Hook = (fn: HookFn) => void;
+
+/** Which runner the active binding drives. */
+export type TestRuntime = "bun" | "node";