@beignet/cli 0.0.31 → 0.0.33

package/src/templates/testing.ts

@@ -0,0 +1,545 @@
+import type { TemplateFile } from "./shared.js";
+
+export const testHelperTemplateFile: TemplateFile = {
+  path: "lib/beignet-test.ts",
+  content: `import assert from "node:assert/strict";
+import {
+  after,
+  afterEach,
+  before,
+  beforeEach,
+  describe as nodeDescribe,
+  it as nodeIt,
+  test as nodeTest,
+} from "node:test";
+import { inspect, isDeepStrictEqual } from "node:util";
+
+export { after, afterEach, before, beforeEach };
+
+type TestBody = () => void | Promise<void>;
+type TestEach = {
+  <T>(cases: readonly T[]): (
+    name: string,
+    body: (value: T) => void | Promise<void>,
+  ) => void;
+  <T extends readonly unknown[]>(cases: readonly T[]): (
+    name: string,
+    body: (...values: T) => void | Promise<void>,
+  ) => void;
+};
+type TestRunner = ((name: string, body: TestBody) => unknown) & {
+  each: TestEach;
+  skip: (name: string, body: TestBody) => unknown;
+  skipIf: (condition: boolean) => TestRunner;
+};
+type NodeRunner = {
+  (name: string, body: TestBody): unknown;
+  (
+    name: string,
+    options: { skip?: boolean },
+    body: TestBody,
+  ): unknown;
+};
+
+type AsymmetricMatcher =
+  | { kind: "any"; expected: unknown }
+  | { kind: "arrayContaining"; expected: readonly unknown[] }
+  | { kind: "objectContaining"; expected: Record<string, unknown> };
+
+type BaseMatchers = {
+  toBe(expected: unknown): void;
+  toEqual(expected: unknown): void;
+  toMatchObject(expected: unknown): void;
+  toContain(expected: unknown): void;
+  toContainEqual(expected: unknown): void;
+  toHaveLength(expected: number): void;
+  toBeDefined(): void;
+  toBeUndefined(): void;
+  toBeNull(): void;
+  toBeGreaterThan(expected: number): void;
+  toMatch(expected: string | RegExp): void;
+  toThrow(expected?: string | RegExp | (new (...args: unknown[]) => object)): void;
+};
+
+type AsyncMatchers = {
+  toBe(expected: unknown): Promise<void>;
+  toEqual(expected: unknown): Promise<void>;
+  toMatchObject(expected: unknown): Promise<void>;
+  toBeNull(): Promise<void>;
+  toBeUndefined(): Promise<void>;
+  toThrow(expected?: string | RegExp | (new (...args: unknown[]) => object)): Promise<void>;
+};
+
+type Matchers = BaseMatchers & {
+  not: BaseMatchers;
+  resolves: AsyncMatchers;
+  rejects: AsyncMatchers;
+};
+
+type Expect = ((actual: unknown) => Matchers) & {
+  any(expected: unknown): AsymmetricMatcher;
+  arrayContaining(expected: readonly unknown[]): AsymmetricMatcher;
+  objectContaining(expected: Record<string, unknown>): AsymmetricMatcher;
+};
+
+export const describe = createRunner(nodeDescribe as NodeRunner);
+export const it = createRunner(nodeIt as NodeRunner);
+export const test = createRunner(nodeTest as NodeRunner);
+
+export const expect = Object.assign(
+  (actual: unknown) => createMatchers(actual),
+  {
+    any: (expected: unknown): AsymmetricMatcher => ({
+      kind: "any",
+      expected,
+    }),
+    arrayContaining: (expected: readonly unknown[]): AsymmetricMatcher => ({
+      kind: "arrayContaining",
+      expected,
+    }),
+    objectContaining: (
+      expected: Record<string, unknown>,
+    ): AsymmetricMatcher => ({ kind: "objectContaining", expected }),
+  },
+) satisfies Expect;
+
+function createRunner(
+  base: NodeRunner,
+  options?: { skip?: boolean },
+): TestRunner {
+  const runner = ((name: string, body: TestBody) =>
+    runTest(base, name, body, options)) as TestRunner;
+  runner.each = ((cases: readonly unknown[]) => {
+    return (
+      name: string,
+      body: (...values: unknown[]) => void | Promise<void>,
+    ) => {
+      for (const testCase of cases) {
+        const values = (
+          Array.isArray(testCase) ? testCase : [testCase]
+        ) as unknown[];
+        runTest(base, formatEachName(name, values), () => body(...values), options);
+      }
+    };
+  }) as TestEach;
+  runner.skip = (name: string, body: TestBody) =>
+    runTest(base, name, body, { skip: true });
+  runner.skipIf = (condition: boolean) =>
+    condition ? createRunner(base, { skip: true }) : runner;
+  return runner;
+}
+
+function runTest(
+  base: NodeRunner,
+  name: string,
+  body: TestBody,
+  options?: { skip?: boolean },
+): unknown {
+  return options ? base(name, options, body) : base(name, body);
+}
+
+function formatEachName(name: string, values: readonly unknown[]): string {
+  let index = 0;
+  return name.replace(/%[sdifoO]/g, () => formatInline(values[index++]));
+}
+
+function createMatchers(actual: unknown): Matchers {
+  return {
+    ...createBaseMatchers(actual, false),
+    not: createBaseMatchers(actual, true),
+    resolves: createAsyncMatchers(actual, "resolves"),
+    rejects: createAsyncMatchers(actual, "rejects"),
+  };
+}
+
+function createBaseMatchers(actual: unknown, negated: boolean): BaseMatchers {
+  return {
+    toBe(expected) {
+      check(
+        Object.is(actual, expected),
+        negated,
+        "Expected values to be identical.",
+      );
+    },
+    toEqual(expected) {
+      check(matchesExpected(actual, expected), negated, "Expected values to be equal.");
+    },
+    toMatchObject(expected) {
+      check(
+        matchesObject(actual, expected),
+        negated,
+        "Expected value to match object.",
+      );
+    },
+    toContain(expected) {
+      const matches =
+        typeof actual === "string"
+          ? actual.includes(String(expected))
+          : Array.isArray(actual) && actual.includes(expected);
+      check(matches, negated, "Expected value to contain item.");
+    },
+    toContainEqual(expected) {
+      check(
+        Array.isArray(actual) &&
+          actual.some((item) => matchesExpected(item, expected)),
+        negated,
+        "Expected array to contain equal item.",
+      );
+    },
+    toHaveLength(expected) {
+      const length =
+        actual !== null && typeof actual === "object"
+          ? (actual as { length?: unknown }).length
+          : undefined;
+      check(length === expected, negated, "Expected value to have length.");
+    },
+    toBeDefined() {
+      check(actual !== undefined, negated, "Expected value to be defined.");
+    },
+    toBeUndefined() {
+      check(actual === undefined, negated, "Expected value to be undefined.");
+    },
+    toBeNull() {
+      check(actual === null, negated, "Expected value to be null.");
+    },
+    toBeGreaterThan(expected) {
+      check(
+        typeof actual === "number" && actual > expected,
+        negated,
+        "Expected value to be greater than " + expected + ".",
+      );
+    },
+    toMatch(expected) {
+      const text = String(actual);
+      const matches =
+        typeof expected === "string" ? text.includes(expected) : expected.test(text);
+      check(matches, negated, "Expected value to match pattern.");
+    },
+    toThrow(expected) {
+      assert.equal(typeof actual, "function", "toThrow expects a function.");
+      let didThrow = false;
+      let thrown: unknown;
+      try {
+        (actual as () => unknown)();
+      } catch (error) {
+        didThrow = true;
+        thrown = error;
+      }
+      check(
+        didThrow && thrownMatches(thrown, expected),
+        negated,
+        "Expected function to throw.",
+      );
+    },
+  };
+}
+
+function createAsyncMatchers(
+  actual: unknown,
+  kind: "resolves" | "rejects",
+): AsyncMatchers {
+  const resolveActual = async () =>
+    kind === "resolves" ? await Promise.resolve(actual) : await rejected(actual);
+
+  return {
+    async toBe(expected) {
+      createBaseMatchers(await resolveActual(), false).toBe(expected);
+    },
+    async toEqual(expected) {
+      createBaseMatchers(await resolveActual(), false).toEqual(expected);
+    },
+    async toMatchObject(expected) {
+      createBaseMatchers(await resolveActual(), false).toMatchObject(expected);
+    },
+    async toBeNull() {
+      createBaseMatchers(await resolveActual(), false).toBeNull();
+    },
+    async toBeUndefined() {
+      createBaseMatchers(await resolveActual(), false).toBeUndefined();
+    },
+    async toThrow(expected) {
+      const thrown =
+        kind === "rejects" ? await rejected(actual) : await resolveActual();
+      check(
+        thrownMatches(thrown, expected),
+        false,
+        "Expected promise to reject with matching error.",
+      );
+    },
+  };
+}
+
+async function rejected(actual: unknown): Promise<unknown> {
+  try {
+    await Promise.resolve(actual);
+  } catch (error) {
+    return error;
+  }
+  assert.fail("Expected promise to reject.");
+}
+
+function check(condition: boolean, negated: boolean, message: string): void {
+  assert.ok(
+    negated ? !condition : condition,
+    negated ? "Negated assertion failed: " + message : message,
+  );
+}
+
+function matchesExpected(actual: unknown, expected: unknown): boolean {
+  if (!containsAsymmetric(expected)) {
+    return isDeepStrictEqual(actual, expected);
+  }
+
+  if (isAsymmetricMatcher(expected)) {
+    switch (expected.kind) {
+      case "any":
+        return matchesAny(actual, expected.expected);
+      case "arrayContaining":
+        return (
+          Array.isArray(actual) &&
+          expected.expected.every((expectedItem) =>
+            actual.some((actualItem) => matchesExpected(actualItem, expectedItem)),
+          )
+        );
+      case "objectContaining":
+        return matchesObject(actual, expected.expected);
+    }
+  }
+
+  if (Array.isArray(expected)) {
+    return (
+      Array.isArray(actual) &&
+      actual.length === expected.length &&
+      expected.every((item, index) => matchesExpected(actual[index], item))
+    );
+  }
+
+  if (isObjectRecord(expected)) {
+    if (!isObjectRecord(actual)) return false;
+    const actualKeys = Object.keys(actual);
+    const expectedKeys = Object.keys(expected);
+    return (
+      actualKeys.length === expectedKeys.length &&
+      expectedKeys.every(
+        (key) =>
+          Object.hasOwn(actual, key) &&
+          matchesExpected(actual[key], expected[key]),
+      )
+    );
+  }
+
+  return Object.is(actual, expected);
+}
+
+function matchesObject(actual: unknown, expected: unknown): boolean {
+  if (isAsymmetricMatcher(expected)) return matchesExpected(actual, expected);
+  if (Array.isArray(expected)) {
+    return (
+      Array.isArray(actual) &&
+      actual.length >= expected.length &&
+      expected.every((item, index) => matchesObject(actual[index], item))
+    );
+  }
+  if (!isObjectRecord(expected)) return matchesExpected(actual, expected);
+  if (!isObjectRecord(actual)) return false;
+  return Object.entries(expected).every(([key, expectedValue]) =>
+    matchesObject(actual[key], expectedValue),
+  );
+}
+
+function containsAsymmetric(value: unknown): boolean {
+  if (isAsymmetricMatcher(value)) return true;
+  if (Array.isArray(value)) return value.some(containsAsymmetric);
+  if (!isObjectRecord(value)) return false;
+  return Object.values(value).some(containsAsymmetric);
+}
+
+function isAsymmetricMatcher(value: unknown): value is AsymmetricMatcher {
+  return (
+    isObjectRecord(value) &&
+    (value.kind === "any" ||
+      value.kind === "arrayContaining" ||
+      value.kind === "objectContaining")
+  );
+}
+
+function matchesAny(actual: unknown, expected: unknown): boolean {
+  if (expected === String) return typeof actual === "string";
+  if (expected === Number) return typeof actual === "number";
+  if (expected === Boolean) return typeof actual === "boolean";
+  if (expected === Array) return Array.isArray(actual);
+  if (expected === Object) return isObjectRecord(actual);
+  if (expected instanceof Function) {
+    return actual instanceof (expected as new (...args: unknown[]) => object);
+  }
+  return actual !== undefined && actual !== null;
+}
+
+function thrownMatches(
+  error: unknown,
+  expected: string | RegExp | (new (...args: unknown[]) => object) | undefined,
+): boolean {
+  if (expected === undefined) return true;
+  if (typeof expected === "string") return errorMessage(error).includes(expected);
+  if (expected instanceof RegExp) return expected.test(errorMessage(error));
+  return error instanceof expected;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+function formatInline(value: unknown): string {
+  return typeof value === "string"
+    ? value
+    : inspect(value, { breakLength: Number.POSITIVE_INFINITY, depth: 2 });
+}
+`,
+};
+
+export const testRunnerTemplateFile: TemplateFile = {
+  path: "lib/beignet-test-runner.ts",
+  content: `import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+
+const defaultTestRoots = [
+  "app",
+  "features",
+  "infra",
+  "lib",
+  "ports",
+  "server",
+  "tests",
+  "src/tests",
+];
+const ignoredDirectories = new Set([
+  ".beignet-local",
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage",
+  "dist",
+  "node_modules",
+]);
+const testFilePattern = /\\.(test|spec)\\.[cm]?[tj]sx?$/;
+
+const explicitArgs = process.argv.slice(2);
+const testArgs =
+  explicitArgs.length > 0
+    ? resolveTestArgs(process.cwd(), explicitArgs)
+    : discoverTestFiles(process.cwd());
+
+if (testArgs.length === 0) {
+  console.log("No test files found.");
+  process.exit(0);
+}
+
+const result = spawnSync(
+  process.execPath,
+  ["--import", "tsx", "--test", ...testArgs],
+  {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+  },
+);
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);
+
+function discoverTestFiles(cwd: string): string[] {
+  const files: string[] = [];
+  for (const root of testRoots(cwd)) {
+    const rootPath = path.join(cwd, root);
+    if (existsSync(rootPath)) {
+      walk(rootPath, cwd, files);
+    }
+  }
+  return files.sort();
+}
+
+function resolveTestArgs(cwd: string, args: string[]): string[] {
+  const resolved: string[] = [];
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      resolved.push(arg);
+      continue;
+    }
+
+    const argPath = path.resolve(cwd, arg);
+    if (!existsSync(argPath)) {
+      resolved.push(arg);
+      continue;
+    }
+
+    const stats = statSync(argPath);
+    if (stats.isDirectory()) {
+      const files: string[] = [];
+      walk(argPath, cwd, files);
+      resolved.push(...files.sort());
+      continue;
+    }
+
+    resolved.push(path.relative(cwd, argPath).split(path.sep).join("/"));
+  }
+  return Array.from(new Set(resolved));
+}
+
+function testRoots(cwd: string): string[] {
+  return Array.from(new Set([...defaultTestRoots, ...configuredRoots(cwd)]));
+}
+
+function configuredRoots(cwd: string): string[] {
+  const configPath = path.join(cwd, "beignet.config.json");
+  if (!existsSync(configPath)) return [];
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf8")) as {
+      paths?: Record<string, string>;
+    };
+    const paths = config.paths ?? {};
+    return [
+      paths.tests,
+      paths.features,
+      paths.routes ? path.dirname(paths.routes) : undefined,
+      paths.server ? path.dirname(paths.server) : undefined,
+      paths.infrastructurePorts
+        ? path.dirname(paths.infrastructurePorts)
+        : undefined,
+      paths.ports ? path.dirname(paths.ports) : undefined,
+      paths.useCaseBuilder ? path.dirname(paths.useCaseBuilder) : undefined,
+    ].filter((root): root is string => Boolean(root) && root !== ".");
+  } catch {
+    return [];
+  }
+}
+
+function walk(directory: string, cwd: string, files: string[]): void {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (!ignoredDirectories.has(entry.name)) {
+        walk(entryPath, cwd, files);
+      }
+      continue;
+    }
+    if (entry.isFile() && testFilePattern.test(entry.name)) {
+      files.push(path.relative(cwd, entryPath).split(path.sep).join("/"));
+    }
+  }
+}
+`,
+};
+
+export const testSupportTemplateFiles: TemplateFile[] = [
+  testHelperTemplateFile,
+  testRunnerTemplateFile,
+];

package/src/templates/todos.ts

@@ -359,7 +359,7 @@ export function createTestTodoRepository(): TodoRepository {
 	};
 }
 `,
-  useCaseTest: `import { describe, expect, it } from "bun:test";
+  useCaseTest: `import { describe, expect, it } from "@/lib/beignet-test";
 import { createUseCaseTester } from "@beignet/core/application";
 import { createTestUserActor } from "@beignet/core/ports/testing";
 import {
@@ -476,7 +476,7 @@ describe("todos use cases", () => {
 	});
 });
 `,
-  routesTest: `import { describe, expect, it } from "bun:test";
+  routesTest: `import { describe, expect, it } from "@/lib/beignet-test";
 import { createStaticAuth } from "@beignet/core/ports";
 import { createIdempotencyHooks, defineRoutes } from "@beignet/core/server";
 import { createTestPorts } from "@beignet/core/testing";

package/src/test-helpers/generated-app.ts

@@ -12,7 +12,8 @@ const repoRoot = path.resolve(import.meta.dir, "../../../..");
 
 /**
  * Symlink the workspace and vendored dependencies a generated app needs for a
- * real `tsc --noEmit` and `bun test` run, without a package-manager install.
+ * real `tsc --noEmit` and generated test script run, without a package-manager
+ * install.
  * Pass `shell: true` for full-stack apps so the shadcn shell dependencies
  * (icons, radix, theming) resolve too.
  */
@@ -56,7 +57,6 @@ export async function linkSmokeDependencies(
     "@libsql/client",
     "@tanstack/react-query",
     "better-auth",
-    "@types/bun",
     "@types/node",
     "@types/pg",
     "@types/react",
@@ -71,6 +71,7 @@ export async function linkSmokeDependencies(
     "react-hook-form",
     "resend",
     "typescript",
+    "tsx",
     "zod",
   ];
   if (options.shell) {
@@ -114,10 +115,8 @@ export async function linkSmokeDependencies(
       repoRoot,
       "packages/provider-mail-resend/node_modules/resend",
     ),
-    "next-themes": path.join(
-      repoRoot,
-      "apps/example-ehr/node_modules/next-themes",
-    ),
+    "next-themes": path.join(repoRoot, "packages/cli/node_modules/next-themes"),
+    tsx: path.join(repoRoot, "node_modules/tsx"),
   };
 
   for (const packageName of externalPackages) {
@@ -128,6 +127,11 @@ export async function linkSmokeDependencies(
     );
   }
 
+  await linkDependency(
+    path.join(nodeModules, "tsx/dist/cli.mjs"),
+    path.join(nodeModules, ".bin/tsx"),
+  );
+
   await linkDependency(
     path.join(
       repoRoot,