1tube 0.4.0 → 0.5.1

package/dist/test/api.d.ts

@@ -44,7 +44,8 @@ export interface DescribeFunction extends RegisterSuite {
     skipIf(condition: unknown): RegisterSuite;
     each<Row>(table: readonly Row[]): (name: string, fn: (...args: EachArgs<Row>) => void) => void;
 }
-export type Hook = (fn: HookFn) => void;
+/** A setup/teardown hook; `timeout` in milliseconds (runner default when omitted). */
+export type Hook = (fn: HookFn, timeout?: number) => void;
 type AnyFn = (...args: any[]) => any;
 export interface MockFunction {
     /** A mock function (records calls; optional implementation). */

package/dist/test/node.js

@@ -17,10 +17,10 @@ export const { test, it, describe, beforeAll, afterAll, beforeEach, afterEach, m
     test: (name, fn, { timeout, skip, only }) => void node.test(name, { timeout, skip, only }, wrap(fn)),
     todo: (name) => void node.test(name, { todo: true }),
     describe: (name, fn, mode) => void node.describe(name, { skip: mode === "skip", only: mode === "only" }, fn),
-    beforeAll: (fn) => node.before(wrap(fn)),
-    afterAll: (fn) => node.after(wrap(fn)),
-    beforeEach: (fn) => node.beforeEach(wrap(fn)),
-    afterEach: (fn) => node.afterEach(wrap(fn)),
+    beforeAll: (fn, timeout) => node.before(wrap(fn), { timeout }),
+    afterAll: (fn, timeout) => node.after(wrap(fn), { timeout }),
+    beforeEach: (fn, timeout) => node.beforeEach(wrap(fn), { timeout }),
+    afterEach: (fn, timeout) => node.afterEach(wrap(fn), { timeout }),
     mockModule: (specifier, factory) => {
         const moduleMock = node.mock.module;
         if (typeof moduleMock !== "function") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway on Bun, plus an ESLint plugin for consumers",
   "license": "MIT",

package/src/cli/deno-config.ts

@@ -67,8 +67,8 @@ export async function resolveDenoConfigPath(
     return { configPath: found };
   }
   onMessage?.(
-    `no import_map.json / deno.json[c] at ${cwd} or ${fnDirAbs} — bundling ` +
-      `without an import map. Pass --config <path> if you want one.`,
+    `no import map at ${cwd} or ${fnDirAbs}; bare imports resolve from ` +
+      `node_modules (package.json is the version source).`,
   );
   return {};
 }

package/src/cli/test.ts

@@ -9,6 +9,10 @@
  * 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.
+ *
+ * Each test file runs isolated (fresh globals and module registry), like
+ * each function on the gateway: by default in parallel worker processes,
+ * so `mock.module` and other module state cannot leak between files.
  */
 
 import { existsSync } from "node:fs";
@@ -34,6 +38,8 @@ const BUN_TEST_VALUE_FLAGS = new Set([
 
 export interface TestArgs {
   functionsDir: string;
+  /** `--no-parallel`: isolate files in one process instead of workers. */
+  parallel: boolean;
   config?: string;
   depsDir?: string;
   envFiles: string[];
@@ -42,7 +48,7 @@ export interface TestArgs {
 }
 
 export function parseTestArgs(argv: readonly string[]): TestArgs {
-  const out: TestArgs = { functionsDir: "", envFiles: [], forwarded: [], hasPaths: false };
+  const out: TestArgs = { functionsDir: "", parallel: true, envFiles: [], forwarded: [], hasPaths: false };
   let functionsDir: string | undefined;
   for (let i = 0; i < argv.length; i++) {
     const tok = argv[i];
@@ -71,6 +77,9 @@ export function parseTestArgs(argv: readonly string[]): TestArgs {
       case "--env-file":
         out.envFiles.push(value());
         continue;
+      case "--no-parallel":
+        out.parallel = false;
+        continue;
     }
     out.forwarded.push(tok);
     if (BUN_TEST_VALUE_FLAGS.has(flag) && eq === -1 && i + 1 < argv.length) {
@@ -90,12 +99,14 @@ export async function runTest(argv: readonly string[]): Promise<number> {
 
 Runs edge function tests (files importing \`1tube/test\`) with the gateway's
 module resolution. Without paths, runs every test under the functions dir.
+Each file runs isolated, in parallel workers by default.
 
 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)
+  --no-parallel           Run files one after another in one process (still isolated)
   --                      Pass everything after it to the runner verbatim
 `);
     return 0;
@@ -134,6 +145,10 @@ Options:
     "test",
     "--preload",
     preload,
+    // Isolation unless the caller chose a mode themselves.
+    ...(args.forwarded.some((a) => /^--(parallel|isolate|no-isolate)(=|$)/.test(a))
+      ? []
+      : [args.parallel ? "--parallel" : "--isolate"]),
     ...args.forwarded,
     ...(args.hasPaths ? [] : [defaultPath]),
   ];

package/src/test/api.ts

@@ -55,7 +55,8 @@ export interface DescribeFunction extends RegisterSuite {
   each<Row>(table: readonly Row[]): (name: string, fn: (...args: EachArgs<Row>) => void) => void;
 }
 
-export type Hook = (fn: HookFn) => void;
+/** A setup/teardown hook; `timeout` in milliseconds (runner default when omitted). */
+export type Hook = (fn: HookFn, timeout?: number) => void;
 
 // `any` is unavoidable for generic function shapes.
 type AnyFn = (...args: any[]) => any;

package/src/test/bun.ts

@@ -24,10 +24,10 @@ export const { test, it, describe, beforeAll, afterAll, beforeEach, afterEach, m
   todo: (name) => bun.test.todo(name, () => {}),
   describe: (name, fn, mode) =>
     mode === "skip" ? bun.describe.skip(name, fn) : mode === "only" ? bun.describe.only(name, fn) : bun.describe(name, fn),
-  beforeAll: (fn) => bun.beforeAll(fn),
-  afterAll: (fn) => bun.afterAll(fn),
-  beforeEach: (fn) => bun.beforeEach(fn),
-  afterEach: (fn) => bun.afterEach(fn),
+  beforeAll: (fn, timeout) => bun.beforeAll(fn, timeout),
+  afterAll: (fn, timeout) => bun.afterAll(fn, timeout),
+  beforeEach: (fn, timeout) => bun.beforeEach(fn, timeout),
+  afterEach: (fn, timeout) => bun.afterEach(fn, timeout),
   mockModule: (specifier, factory) => {
     void bun.mock.module(specifier.startsWith("file:") ? fileURLToPath(specifier) : specifier, factory);
   },

package/src/test/node.ts

@@ -25,10 +25,10 @@ export const { test, it, describe, beforeAll, afterAll, beforeEach, afterEach, m
   test: (name, fn, { timeout, skip, only }) => void node.test(name, { timeout, skip, only }, wrap(fn)),
   todo: (name) => void node.test(name, { todo: true }),
   describe: (name, fn, mode) => void node.describe(name, { skip: mode === "skip", only: mode === "only" }, fn),
-  beforeAll: (fn) => node.before(wrap(fn)),
-  afterAll: (fn) => node.after(wrap(fn)),
-  beforeEach: (fn) => node.beforeEach(wrap(fn)),
-  afterEach: (fn) => node.afterEach(wrap(fn)),
+  beforeAll: (fn, timeout) => node.before(wrap(fn), { timeout }),
+  afterAll: (fn, timeout) => node.after(wrap(fn), { timeout }),
+  beforeEach: (fn, timeout) => node.beforeEach(wrap(fn), { timeout }),
+  afterEach: (fn, timeout) => node.afterEach(wrap(fn), { timeout }),
   mockModule: (specifier, factory) => {
     const moduleMock = (node.mock as { module?: (s: string, o: object) => unknown }).module;
     if (typeof moduleMock !== "function") {