@nudojs/service 0.2.1 → 0.3.1

package/src/__tests__/fn-sig-impl.test.ts

@@ -1,247 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { typeValueToString } from "@nudojs/core";
-import { analyzeFile } from "../analyzer.ts";
-
-describe("fnSig impl: concrete args produce precise values", () => {
-  it("Math.floor with literal returns exact result", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "concrete" (3.7)
- * @nudo:case "symbolic" (T.number)
- */
-function floorIt(x) {
-  return Math.floor(x);
-}
-`;
-    const result = analyzeFile("/test/math.js", source);
-    const fn = result.functions[0];
-    expect(fn.cases[0].name).toBe("concrete");
-    expect(typeValueToString(fn.cases[0].result)).toBe("3");
-    expect(fn.cases[1].name).toBe("symbolic");
-    expect(typeValueToString(fn.cases[1].result)).toBe("number");
-  });
-
-  it("Math.max with literals returns exact result", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "test" (3, 7)
- */
-function maxOf(a, b) {
-  return Math.max(a, b);
-}
-`;
-    const result = analyzeFile("/test/math.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("7");
-  });
-
-  it("JSON.stringify with literal returns exact string", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "test" (42)
- */
-function toJson(x) {
-  return JSON.stringify(x);
-}
-`;
-    const result = analyzeFile("/test/json.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('"42"');
-  });
-
-  it("encodeURIComponent with literal returns exact string", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "test" ("hello world")
- */
-function encode(s) {
-  return encodeURIComponent(s);
-}
-`;
-    const result = analyzeFile("/test/encode.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('"hello%20world"');
-  });
-
-  it("Number.isInteger with literal returns exact boolean", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "int" (5)
- * @nudo:case "float" (5.5)
- */
-function checkInt(x) {
-  return Number.isInteger(x);
-}
-`;
-    const result = analyzeFile("/test/num.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("true");
-    expect(typeValueToString(result.functions[0].cases[1].result)).toBe("false");
-  });
-
-  it("parseInt with literal returns exact number", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "test" ("42")
- */
-function parseIt(s) {
-  return parseInt(s);
-}
-`;
-    const result = analyzeFile("/test/parse.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("42");
-  });
-
-  it("Promise.resolve preserves argument type", () => {
-    const source = `
-/// @nudo:env es
-
-/**
- * @nudo:case "test" (42)
- */
-async function wrap(x) {
-  return await Promise.resolve(x);
-}
-`;
-    const result = analyzeFile("/test/promise.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("Promise<42>");
-  });
-});
-
-describe("fnSig impl: URL constructor with concrete args", () => {
-  it("URL with literal string returns precise properties", () => {
-    const source = `
-/// @nudo:env web
-
-/**
- * @nudo:case "test" ("https://example.com/path?q=hello#hash")
- */
-function parseUrl(raw) {
-  const url = new URL(raw);
-  return {
-    host: url.hostname,
-    path: url.pathname,
-    query: url.search,
-    hash: url.hash,
-  };
-}
-`;
-    const result = analyzeFile("/test/url.js", source);
-    const res = typeValueToString(result.functions[0].cases[0].result);
-    expect(res).toContain('"example.com"');
-    expect(res).toContain('"/path"');
-    expect(res).toContain('"?q=hello"');
-    expect(res).toContain('"#hash"');
-  });
-
-  it("URL with symbolic string falls back to generic type", () => {
-    const source = `
-/// @nudo:env web
-
-/**
- * @nudo:case "test" (T.string)
- */
-function parseUrl(raw) {
-  const url = new URL(raw);
-  return url.hostname;
-}
-`;
-    const result = analyzeFile("/test/url.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("string");
-  });
-});
-
-describe("fnSig impl: Node.js path with concrete args", () => {
-  it("path.join with literals returns exact path", () => {
-    const source = `
-/// @nudo:env node
-
-import { join } from "node:path";
-
-/**
- * @nudo:case "test" ("src", "utils", "index.js")
- */
-function buildPath(a, b, c) {
-  return join(a, b, c);
-}
-`;
-    const result = analyzeFile("/test/path.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('"src/utils/index.js"');
-  });
-
-  it("path.extname with literal returns exact extension", () => {
-    const source = `
-/// @nudo:env node
-
-import { extname } from "node:path";
-
-/**
- * @nudo:case "test" ("file.ts")
- */
-function getExt(f) {
-  return extname(f);
-}
-`;
-    const result = analyzeFile("/test/path.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('".ts"');
-  });
-
-  it("path.basename with literal returns exact name", () => {
-    const source = `
-/// @nudo:env node
-
-import { basename } from "node:path";
-
-/**
- * @nudo:case "test" ("/home/user/file.txt")
- */
-function getName(p) {
-  return basename(p);
-}
-`;
-    const result = analyzeFile("/test/path.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('"file.txt"');
-  });
-
-  it("path.dirname with literal returns exact dir", () => {
-    const source = `
-/// @nudo:env node
-
-import { dirname } from "node:path";
-
-/**
- * @nudo:case "test" ("/home/user/file.txt")
- */
-function getDir(p) {
-  return dirname(p);
-}
-`;
-    const result = analyzeFile("/test/path.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe('"/home/user"');
-  });
-
-  it("path.join with symbolic args falls back to string", () => {
-    const source = `
-/// @nudo:env node
-
-import { join } from "node:path";
-
-/**
- * @nudo:case "test" (T.string, T.string)
- */
-function buildPath(a, b) {
-  return join(a, b);
-}
-`;
-    const result = analyzeFile("/test/path.js", source);
-    expect(typeValueToString(result.functions[0].cases[0].result)).toBe("string");
-  });
-});

package/src/__tests__/guard-generator.test.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T } from "@nudojs/core";
-import { generateGuardFunction } from "../guard-generator.ts";
-
-describe("guard-generator", () => {
-  it("generates guard for string type", () => {
-    const guard = generateGuardFunction("isString", T.string);
-    expect(guard).toContain("typeof data === 'string'");
-  });
-
-  it("generates guard for object type", () => {
-    const obj = T.object({ name: T.string, age: T.number });
-    const guard = generateGuardFunction("isUser", obj);
-    expect(guard).toContain("typeof data === 'object'");
-    expect(guard).toContain("data.name");
-    expect(guard).toContain("data.age");
-  });
-
-  it("generates guard for union type", () => {
-    const union = T.union(T.string, T.number);
-    const guard = generateGuardFunction("isStringOrNumber", union);
-    expect(guard).toContain("||");
-  });
-
-  it("generates guard for array type", () => {
-    const guard = generateGuardFunction("isStringArray", T.array(T.string));
-    expect(guard).toContain("Array.isArray(data)");
-  });
-});

package/src/__tests__/integration.test.ts

@@ -1,332 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { typeValueToString } from "@nudojs/core";
-import {
-  analyzeFile,
-  typeValueToZodSchema,
-  generateGuardFunction,
-  generateDts,
-  typeValueToTSType,
-} from "../index.ts";
-
-describe("integration: full pipeline", () => {
-  it("infers types through the complete analyze → generate pipeline", () => {
-    const source = `
-/**
- * @nudo:case "strings" (T.string)
- * @nudo:case "numbers" (T.number)
- */
-function process(x) {
-  if (typeof x === "string") return x.toUpperCase();
-  return x + 1;
-}
-`;
-    const result = analyzeFile("/test.js", source);
-
-    // Verify inference
-    expect(result.functions).toHaveLength(1);
-    expect(result.functions[0].name).toBe("process");
-    expect(result.functions[0].cases).toHaveLength(2);
-    expect(result.functions[0].combined).toBeDefined();
-
-    // Verify Zod generation for each case result
-    const zodSchema0 = typeValueToZodSchema(result.functions[0].cases[0].result);
-    expect(zodSchema0).toBeTruthy();
-    expect(typeof zodSchema0).toBe("string");
-
-    const zodSchema1 = typeValueToZodSchema(result.functions[0].cases[1].result);
-    expect(zodSchema1).toBeTruthy();
-
-    // Verify guard generation
-    const guard = generateGuardFunction("isProcessOutput", result.functions[0].cases[0].result);
-    expect(guard).toContain("function isProcessOutput");
-    expect(guard).toContain("export function");
-
-    // Verify DTS generation
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function process");
-    expect(dts).toContain("strings");
-    expect(dts).toContain("numbers");
-  });
-
-  it("handles a single-case function end-to-end", () => {
-    const source = `
-/**
- * @nudo:case "test" (T.number)
- */
-function double(x) {
-  return x * 2;
-}
-`;
-    const result = analyzeFile("/test/double.js", source);
-
-    expect(result.functions).toHaveLength(1);
-    const fn = result.functions[0];
-    expect(fn.name).toBe("double");
-    expect(fn.cases).toHaveLength(1);
-    expect(typeValueToString(fn.cases[0].result)).toBe("number");
-
-    // Zod schema should produce a valid z.number() call
-    const zod = typeValueToZodSchema(fn.cases[0].result);
-    expect(zod).toBe("z.number()");
-
-    // Guard should check typeof
-    const guard = generateGuardFunction("isDoubleOutput", fn.cases[0].result);
-    expect(guard).toContain("typeof data === 'number'");
-
-    // DTS should have a single declaration line
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function double(x: number): number;");
-  });
-});
-
-describe("integration: Zod schema generation", () => {
-  it("generates Zod schemas from inferred object types", () => {
-    const source = `
-/**
- * @nudo:case "test" ({ name: "Alice", age: 30 })
- */
-function getUser(config) {
-  return config;
-}
-`;
-    const result = analyzeFile("/test/user.js", source);
-    const fn = result.functions[0];
-    const zod = typeValueToZodSchema(fn.cases[0].result);
-
-    expect(zod).toContain("z.object");
-    expect(zod).toContain("name");
-    expect(zod).toContain("age");
-  });
-
-  it("generates Zod schemas for union return types", () => {
-    const source = `
-/**
- * @nudo:case "string" (T.string)
- * @nudo:case "number" (T.number)
- */
-function parse(x) {
-  if (typeof x === "string") return x;
-  return x;
-}
-`;
-    const result = analyzeFile("/test/parse.js", source);
-    const fn = result.functions[0];
-
-    // Each case should produce a valid Zod schema
-    expect(typeValueToZodSchema(fn.cases[0].result)).toBe("z.string()");
-    expect(typeValueToZodSchema(fn.cases[1].result)).toBe("z.number()");
-
-    // Combined type should produce a union schema
-    const combined = fn.combined!;
-    const combinedZod = typeValueToZodSchema(combined);
-    expect(combinedZod).toContain("z.union");
-  });
-});
-
-describe("integration: guard generation", () => {
-  it("generates guards for complex inferred types", () => {
-    const source = `
-/**
- * @nudo:case "test" ([1, "two", true])
- */
-function identity(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("/test/tuple.js", source);
-    const fn = result.functions[0];
-    const guard = generateGuardFunction("isTuple", fn.cases[0].result);
-
-    expect(guard).toContain("export function isTuple");
-    expect(guard).toContain("Array.isArray");
-    expect(guard).toContain("data.length === 3");
-    // Literal values produce equality checks, not typeof checks
-    expect(guard).toContain("data[0] === 1");
-    expect(guard).toContain('data[1] === "two"');
-    expect(guard).toContain("data[2] === true");
-  });
-
-  it("generates guards for object return types", () => {
-    const source = `
-/**
- * @nudo:case "test" ({ id: 1, active: true })
- */
-function getRecord(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("/test/record.js", source);
-    const fn = result.functions[0];
-    const guard = generateGuardFunction("isRecord", fn.cases[0].result);
-
-    expect(guard).toContain("export function isRecord");
-    expect(guard).toContain("typeof data === 'object'");
-    expect(guard).toContain("data !== null");
-    expect(guard).toContain("data.id");
-    expect(guard).toContain("data.active");
-  });
-});
-
-describe("integration: DTS generation", () => {
-  it("generates declarations for functions returning inferred object types", () => {
-    const source = `
-/**
- * @nudo:case "test" ({ x: 1, y: "hello" })
- */
-function makePoint(config) {
-  return config;
-}
-`;
-    const result = analyzeFile("/test/point.js", source);
-    const dts = generateDts(result);
-
-    expect(dts).toContain("export declare function makePoint");
-    expect(dts).toContain("x:");
-    expect(dts).toContain("y:");
-  });
-
-  it("generates TS type strings from inferred values", () => {
-    const source = `
-/**
- * @nudo:case "concrete" (1, 2)
- * @nudo:case "symbolic" (T.number, T.number)
- */
-function add(a, b) {
-  return a + b;
-}
-`;
-    const result = analyzeFile("/test/add.js", source);
-    const fn = result.functions[0];
-
-    expect(typeValueToTSType(fn.cases[0].result)).toBe("3");
-    expect(typeValueToTSType(fn.cases[1].result)).toBe("number");
-
-    // 行为已修复：多 case 不再逐 case 生成字面量重载（`): 3;` 拦截合法调用），
-    // 改为单一 widen 主签名 + JSDoc 保留字面量精度
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function add(a: number, b: number): number;");
-    expect(dts).toContain("Case: concrete (1, 2) => 3");
-  });
-});
-
-describe("integration: multiple cases", () => {
-  it("resolves combined type from multiple @nudo:case directives", () => {
-    const source = `
-/**
- * @nudo:case "string-input" (T.string)
- * @nudo:case "number-input" (T.number)
- * @nudo:case "boolean-input" (T.boolean)
- */
-function stringify(x) {
-  if (typeof x === "string") return x;
-  if (typeof x === "number") return String(x);
-  return String(x);
-}
-`;
-    const result = analyzeFile("/test/stringify.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(3);
-    expect(fn.cases[0].name).toBe("string-input");
-    expect(fn.cases[1].name).toBe("number-input");
-    expect(fn.cases[2].name).toBe("boolean-input");
-
-    // Combined type should be a union of the three return types
-    expect(fn.combined).toBeDefined();
-    const combinedStr = typeValueToString(fn.combined!);
-    expect(combinedStr).toBeTruthy();
-
-    // DTS should contain overloads for all three cases
-    const dts = generateDts(result);
-    expect(dts).toContain("string-input");
-    expect(dts).toContain("number-input");
-    expect(dts).toContain("boolean-input");
-  });
-
-  it("handles mixed literal and symbolic cases", () => {
-    const source = `
-/**
- * @nudo:case "literal" (42)
- * @nudo:case "symbolic" (T.number)
- */
-function passThrough(x) {
-  return x;
-}
-`;
-    const result = analyzeFile("/test/mixed.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(2);
-    expect(typeValueToString(fn.cases[0].result)).toBe("42");
-    expect(typeValueToString(fn.cases[1].result)).toBe("number");
-
-    // Zod should produce valid schemas for both
-    expect(typeValueToZodSchema(fn.cases[0].result)).toBe("z.literal(42)");
-    expect(typeValueToZodSchema(fn.cases[1].result)).toBe("z.number()");
-  });
-});
-
-describe("integration: error cases", () => {
-  it("detects throw paths and reports diagnostics", () => {
-    const source = `
-/**
- * @nudo:case "valid" (10)
- * @nudo:case "negative" (-1)
- */
-function safeSqrt(x) {
-  if (x < 0) {
-    throw new RangeError("negative input");
-  }
-  return x;
-}
-`;
-    const result = analyzeFile("/test/sqrt.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(2);
-
-    // The valid case should not throw
-    expect(fn.cases[0].throws.kind).toBe("never");
-
-    // The negative case should throw
-    expect(fn.cases[1].throws.kind).not.toBe("never");
-
-    // Diagnostics should contain a may-throw warning for the active (first) case
-    // if its branch can throw, or for the negative case
-    const throwDiags = result.diagnostics.filter(
-      (d) => d.code === "nudo-may-throw",
-    );
-    // At least one throw diagnostic should exist since the function has a throw path
-    expect(throwDiags.length).toBeGreaterThanOrEqual(0);
-
-    // The result should still be analysable and produce valid outputs
-    const dts = generateDts(result);
-    expect(dts).toContain("export declare function safeSqrt");
-  });
-
-  it("handles a function that always throws", () => {
-    const source = `
-/**
- * @nudo:case "test" (T.string)
- */
-function alwaysFails(x) {
-  throw new Error("always fails");
-}
-`;
-    const result = analyzeFile("/test/fail.js", source);
-    const fn = result.functions[0];
-
-    expect(fn.cases).toHaveLength(1);
-    // Result type should be never since the function always throws
-    expect(fn.cases[0].result.kind).toBe("never");
-    // Throws type should not be never
-    expect(fn.cases[0].throws.kind).not.toBe("never");
-
-    // A throw diagnostic should be generated
-    const throwDiags = result.diagnostics.filter(
-      (d) => d.code === "nudo-may-throw",
-    );
-    expect(throwDiags.length).toBeGreaterThanOrEqual(1);
-    expect(throwDiags[0].message).toContain("alwaysFails");
-  });
-});

package/src/__tests__/schema-generator.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T } from "@nudojs/core";
-import { typeValueToZodSchema } from "../schema-generator.ts";
-
-describe("schema-generator", () => {
-  it("generates z.string() for string type", () => {
-    expect(typeValueToZodSchema(T.string)).toBe("z.string()");
-  });
-
-  it("generates z.number() for number type", () => {
-    expect(typeValueToZodSchema(T.number)).toBe("z.number()");
-  });
-
-  it("generates z.literal() for literal types", () => {
-    expect(typeValueToZodSchema(T.literal("hello"))).toBe('z.literal("hello")');
-    expect(typeValueToZodSchema(T.literal(42))).toBe("z.literal(42)");
-    expect(typeValueToZodSchema(T.literal(true))).toBe("z.literal(true)");
-  });
-
-  it("generates z.object() for object types", () => {
-    const obj = T.object({ name: T.string, age: T.number });
-    expect(typeValueToZodSchema(obj)).toBe("z.object({ name: z.string(), age: z.number() })");
-  });
-
-  it("generates z.array() for array types", () => {
-    expect(typeValueToZodSchema(T.array(T.string))).toBe("z.array(z.string())");
-  });
-
-  it("generates z.union() for union types", () => {
-    const union = T.union(T.string, T.number);
-    expect(typeValueToZodSchema(union)).toBe("z.union([z.string(), z.number()])");
-  });
-
-  it("generates z.null() and z.undefined()", () => {
-    expect(typeValueToZodSchema(T.null)).toBe("z.null()");
-    expect(typeValueToZodSchema(T.undefined)).toBe("z.undefined()");
-  });
-});