swallowkit 1.1.2 → 2.0.0-alpha.10

package/src/__tests__/release-metadata.test.ts

@@ -0,0 +1,121 @@
+import * as fs from "fs";
+import * as path from "path";
+import { spawnSync } from "child_process";
+
+describe("npm release metadata", () => {
+  const repository = process.cwd();
+  const script = path.join(repository, "scripts", "release-metadata.cjs");
+  let directory: string;
+
+  beforeEach(() => {
+    directory = fs.mkdtempSync(path.join(repository, ".tmp-release-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  function run(
+    version: unknown,
+    options: {
+      refType?: string;
+      refName?: string;
+      lockVersion?: string;
+      rootVersion?: string;
+      noRootPackage?: boolean;
+    } = {}
+  ) {
+    fs.writeFileSync(
+      path.join(directory, "package.json"),
+      JSON.stringify({ name: "swallowkit", version })
+    );
+    fs.writeFileSync(
+      path.join(directory, "package-lock.json"),
+      JSON.stringify({
+        version: options.lockVersion ?? version,
+        packages: options.noRootPackage
+          ? {}
+          : { "": { version: options.rootVersion ?? version } },
+      })
+    );
+    const outputPath = path.join(directory, "output.txt");
+    const result = spawnSync(process.execPath, [script], {
+      cwd: directory,
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        GITHUB_REF_TYPE: options.refType ?? "tag",
+        GITHUB_REF_NAME: options.refName ?? `v${version}`,
+        GITHUB_OUTPUT: outputPath,
+      },
+    });
+    expect(result.error).toBeUndefined();
+    const output = fs.existsSync(outputPath)
+      ? fs.readFileSync(outputPath, "utf8")
+      : "";
+    return { ...result, output };
+  }
+
+  it.each([
+    ["2.0.0", "latest"],
+    ["2.0.0-alpha.1", "alpha"],
+    ["2.0.0-alpha.2", "alpha"],
+    ["2.0.0-alpha", "alpha"],
+    ["2.0.0-beta.1", "beta"],
+    ["2.0.0-beta.12", "beta"],
+    ["2.0.0-rc.1", "next"],
+    ["2.0.0-next.1", "next"],
+    ["2.0.0-alphabet.1", "next"],
+    ["2.0.0-0", "next"],
+    ["2.0.0+build.1", "latest"],
+    ["2.0.0-alpha.1+build.1", "alpha"],
+  ])("publishes %s on the %s channel", (version, channel) => {
+    const result = run(version);
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe("");
+    expect(result.output).toBe(`version=${version}\ndist_tag=${channel}\n`);
+    expect(result.stdout).toBe(result.output);
+  });
+
+  it("supports manual branch dry runs without requiring a release tag", () => {
+    const result = run("2.0.0-alpha.1", {
+      refType: "branch",
+      refName: "main",
+    });
+    expect(result.status).toBe(0);
+    expect(result.output).toContain("dist_tag=alpha\n");
+  });
+
+  it.each([
+    { refName: "v2.0.0" },
+    { refName: "2.0.0-alpha.1" },
+    { lockVersion: "1.1.2" },
+    { rootVersion: "1.1.2" },
+    { noRootPackage: true },
+  ])("rejects inconsistent release metadata: %j", (options) => {
+    const result = run("2.0.0-alpha.1", options);
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("must match");
+    expect(result.output).toBe("");
+  });
+
+  it.each([
+    undefined,
+    2,
+    "",
+    "v2.0.0-alpha.1",
+    "2.0",
+    "02.0.0",
+    "2.0.0-",
+    "2.0.0-alpha.01",
+    "2.0.0-alpha..1",
+    "2.0.0-alpha_1",
+    "2.0.0\n",
+    "2.0.0-alpha.1\ndist_tag=latest",
+  ])("rejects invalid versions before emitting Actions outputs: %j", (version) => {
+    const result = run(version);
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain("must be a valid SemVer version");
+    expect(result.output).toBe("");
+  });
+});

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

@@ -0,0 +1,329 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { parseModelFile } from "../core/scaffold/model-parser";
+import { generateOpenApiDocument } from "../core/scaffold/openapi-generator";
+import { generateListPage, generateFormComponent } from "../core/scaffold/ui-generator";
+import { generateLanguageSchemaArtifacts, getPythonRegexWarnings, toPythonRegex } from "../core/scaffold/native-schema-generator";
+import { generateDetailPage } from "../core/scaffold/ui-generator";
+import { spawnSync } from "child_process";
+import { FileOperationSession } from "../core/operations/file-session";
+import { buildUserScopedDataWarning } from "../cli/commands/scaffold";
+import { inspectCapabilities } from "../core/project/capabilities";
+
+const repoRoot = path.resolve(__dirname, "..", "..");
+
+function model(name: string, fields: string, extra = ""): string {
+  const pascal = name.replace(/(^|-)([a-z])/g, (_, __, char: string) => char.toUpperCase());
+  return `import { z } from 'zod/v4';
+export const ${pascal} = z.object({
+  id: z.string(),
+${fields}
+});
+export type ${pascal} = z.infer<typeof ${pascal}>;
+${extra}`;
+}
+
+describe("foreign-key inference", () => {
+  let root: string;
+  const write = (name: string, source: string) => {
+    const file = path.join(root, "shared", "models", `${name}.ts`);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, source);
+    return file;
+  };
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-fk-"));
+  });
+  afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  it("does not treat userId as a foreign key when no User model exists", async () => {
+    const info = await parseModelFile(write("probe-item", model("probe-item", "  userId: z.string(),\n  title: z.string(),", "export const partitionKey = '/userId';\n")));
+    const userId = info.fields.find((field) => field.name === "userId")!;
+    expect(userId.isForeignKey).toBeUndefined();
+    expect(userId.referencedModel).toBeUndefined();
+    expect(info.parserWarnings).toEqual([]);
+
+    const list = generateListPage(info, "@sample/shared");
+    const form = generateFormComponent(info, "@sample/shared");
+    expect(list).not.toMatch(/api\/user|userMap/);
+    expect(form).not.toMatch(/api\/user|userOptions/);
+    const schema = JSON.parse(generateOpenApiDocument([info], info)).components.schemas;
+    expect(schema.ProbeItem.properties.userId).toEqual({ type: "string" });
+    expect(Object.keys(schema)).toEqual(["ProbeItem"]);
+  });
+
+  it("infers a foreign key when the referenced model exists", async () => {
+    write("category", model("category", "  name: z.string(),"));
+    const info = await parseModelFile(write("todo", model("todo", "  categoryId: z.string(),")));
+    expect(info.fields.find((field) => field.name === "categoryId")).toMatchObject({ isForeignKey: true, referencedModel: "Category" });
+    expect(generateListPage(info, "@sample/shared")).toContain("/api/category");
+  });
+
+  it("supports explicit references, opt-out, and warns about missing targets", async () => {
+    write("user", model("user", "  name: z.string(),"));
+    const info = await parseModelFile(write("post", model(
+      "post",
+      "  authorId: z.string(),\n  userId: z.string(),\n  reviewerId: z.string(),\n  tagIds: z.array(z.string()),",
+      "export const references = { authorId: 'User', userId: false, reviewerId: 'Reviewer', tagIds: 'Tag', missingId: 'User' };\n"
+    )));
+    const field = (name: string) => info.fields.find((candidate) => candidate.name === name)!;
+    expect(field("authorId")).toMatchObject({ isForeignKey: true, referencedModel: "User" });
+    expect(field("userId").isForeignKey).toBeUndefined();
+    expect(field("reviewerId").isForeignKey).toBeUndefined();
+    expect(field("tagIds").isForeignKey).toBeUndefined();
+    expect(info.parserWarnings).toEqual([
+      "reference-model-not-found: Post.reviewerId references Reviewer, but shared/models has no Reviewer model; it is treated as a plain field.",
+      "reference-field-unsupported: Post.tagIds must be a single string id to reference Tag.",
+      "reference-field-not-found: Post.references declares missingId, but the schema has no such field.",
+    ]);
+  });
+
+  it("declares one lookup per referenced model when several fields reference it", async () => {
+    write("user", model("user", "  name: z.string(),"));
+    const info = await parseModelFile(write("review", model(
+      "review",
+      "  authorId: z.string(),\n  reviewerId: z.string(),",
+      "export const references = { authorId: 'User', reviewerId: 'User' };\n"
+    )));
+    const count = (source: string, text: string) => source.split(text).length - 1;
+    for (const source of [generateListPage(info, "@sample/shared"), generateDetailPage(info, "@sample/shared")]) {
+      expect(count(source, "const [userMap, setUserMap]")).toBe(1);
+      expect(count(source, "fetch('/api/user')")).toBe(1);
+      expect(source).toContain("userMap[item.authorId]".replace("item", source.includes("ListPage") ? "item" : "review"));
+    }
+    const form = generateFormComponent(info, "@sample/shared");
+    expect(count(form, "const [userOptions, setUserOptions]")).toBe(1);
+    expect(count(form, "fetch('/api/user')")).toBe(1);
+    expect(form).toContain('id="authorId"');
+    expect(form).toContain('id="reviewerId"');
+  });
+
+  it("documents the references declaration in capabilities", () => {
+    expect(inspectCapabilities().modelDeclarations.map((declaration) => declaration.name)).toContain("references");
+  });
+});
+
+describe("dynamic schema evaluation metadata", () => {
+  let root: string;
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-dynamic-"));
+    fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "sample", type: "module" }));
+    fs.mkdirSync(path.join(root, "node_modules"), { recursive: true });
+    fs.symlinkSync(path.join(repoRoot, "node_modules", "zod"), path.join(root, "node_modules", "zod"), "junction");
+  });
+  afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+
+  it("extracts formats, integers, constraints, and inline objects from Zod v4 at runtime", async () => {
+    const file = path.join(root, "shared", "models", "probe-item.ts");
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // startsWith() is outside the static subset, which forces runtime evaluation.
+    fs.writeFileSync(file, model("probe-item", [
+      "  userId: z.string().startsWith('u'),",
+      "  title: z.string().min(1).max(5),",
+      "  code: z.string().regex(/^a\\d$/i),",
+      "  tags: z.array(z.string().min(2)).min(1),",
+      "  score: z.number().gt(0).lte(1),",
+      "  edge: z.number().gt(0).min(0).lt(1).max(1),",
+      "  count: z.int(),",
+      "  publishedAt: z.iso.datetime().optional(),",
+      "  createdAt: z.string().optional(),",
+      "  nested: z.object({ x: z.string() }).optional(),",
+    ].join("\n")));
+
+    const info = await parseModelFile(file);
+    const field = (name: string) => info.fields.find((candidate) => candidate.name === name)!;
+    expect(info.parserMode).toBe("dynamic");
+    expect(field("userId").isForeignKey).toBeUndefined();
+    expect(field("title").constraints).toEqual({ minLength: 1, maxLength: 5 });
+    expect(field("code").constraints).toEqual({ pattern: "^a\\d$", patternFlags: "i" });
+    expect(field("tags")).toMatchObject({ isArray: true, constraints: { minLength: 2, minItems: 1 } });
+    expect(field("score").constraints).toEqual({ minimum: 0, exclusiveMinimum: true, maximum: 1 });
+    expect(field("edge").constraints).toEqual({ minimum: 0, exclusiveMinimum: true, maximum: 1, exclusiveMaximum: true });
+    expect(field("count").isInteger).toBe(true);
+    expect(field("publishedAt")).toMatchObject({ format: "date-time", isOptional: true });
+    expect(field("createdAt").format).toBeUndefined();
+    expect(field("nested")).toMatchObject({ type: "object", isOptional: true, objectFields: [expect.objectContaining({ name: "x", type: "string" })] });
+  });
+
+  it("extracts the same metadata from Zod v3 schemas", async () => {
+    const file = path.join(root, "shared", "models", "legacy-item.ts");
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, model("legacy-item", [
+      "  title: z.string().startsWith('t').min(2),",
+      "  score: z.number().int().positive(),",
+      "  publishedAt: z.string().datetime().optional(),",
+      "  kind: z.enum(['a', 'b']),",
+      "  nested: z.object({ x: z.string().max(3) }),",
+    ].join("\n")).replace("from 'zod/v4'", "from 'zod'"));
+
+    const info = await parseModelFile(file);
+    const field = (name: string) => info.fields.find((candidate) => candidate.name === name)!;
+    expect(info.parserMode).toBe("dynamic");
+    expect(field("title").constraints).toEqual({ minLength: 2 });
+    expect(field("score")).toMatchObject({ isInteger: true, constraints: { minimum: 0, exclusiveMinimum: true } });
+    expect(field("publishedAt").format).toBe("date-time");
+    expect(field("kind").enumValues).toEqual(["a", "b"]);
+    expect(field("nested").objectFields).toEqual([expect.objectContaining({ name: "x", constraints: { maxLength: 3 } })]);
+  });
+});
+
+describe("Python schema assets", () => {
+  let root: string;
+  const originalCwd = process.cwd();
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-python-schema-"));
+  });
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("keeps declared types and constraints instead of guessing from names", async () => {
+    const file = path.join(root, "shared", "models", "probe-item.ts");
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, model("probe-item", [
+      "  title: z.string().min(1),",
+      "  code: z.string().regex(/^a\\d$/i).optional(),",
+      "  tags: z.array(z.string().min(2)).max(3),",
+      "  score: z.number().min(0).max(1),",
+      "  count: z.number().int(),",
+      "  publishedAt: z.iso.datetime().optional(),",
+      "  createdAt: z.string().optional(),",
+      "  nested: z.object({ x: z.string() }).optional(),",
+    ].join("\n")));
+    const info = await parseModelFile(file);
+    process.chdir(root);
+    await generateLanguageSchemaArtifacts([info], info, "functions", "python", new FileOperationSession("commit", root));
+    const modelsDir = path.join(root, "functions", "generated", "python-models", "backend_models", "models");
+    const source = fs.readFileSync(path.join(modelsDir, "probe_item.py"), "utf8");
+
+    expect(source).toContain("created_at: Optional[StrictStr] = Field(default=None, alias=\"createdAt\")");
+    expect(source).toContain("published_at: Optional[datetime] = Field(default=None, alias=\"publishedAt\")");
+    expect(source).toContain("title: StrictStr = Field(min_length=1)");
+    expect(source).toContain("tags: List[Annotated[StrictStr, Field(min_length=2)]] = Field(max_length=3)");
+    expect(source).toContain("score: Union[StrictFloat, StrictInt] = Field(ge=0, le=1)");
+    expect(source).toContain("count: StrictInt");
+    expect(source).toContain("nested: Optional[ProbeItemNested] = Field(default=None)");
+    expect(source).toContain('re.search("^a\\\\d$", item, re.IGNORECASE)');
+    expect(source).toContain("return self.model_dump_json(by_alias=True, exclude_none=True)");
+    expect(fs.readFileSync(path.join(modelsDir, "probe_item_nested.py"), "utf8")).toContain("class ProbeItemNested(BaseModel):");
+  });
+});
+
+describe("Python regex translation", () => {
+  it("translates JavaScript named groups and back-references", () => {
+    expect(toPythonRegex("^(?<code>[A-Z]+)-\\k<code>$")).toEqual({ pattern: "^(?P<code>[A-Z]+)-(?P=code)$" });
+    expect(toPythonRegex("^a\\d$", "i")).toEqual({ pattern: "^a\\d$" });
+  });
+
+  it.each([
+    ["\\p{L}+", "", /Unicode property/],
+    ["(?<=a)b", "", /lookbehind/],
+    ["[^]", "", /empty character classes/],
+    ["\\u{1F600}", "u", /flag\(s\) u|code point/],
+    ["abc", "y", /flag\(s\) y/],
+  ])("reports %s /%s as not enforceable", (pattern, flags, reason) => {
+    const result = toPythonRegex(pattern, flags);
+    expect("unsupported" in result && result.unsupported).toMatch(reason);
+  });
+
+  it("skips unenforceable patterns with a warning and validates raw strings before conversion", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-python-regex-"));
+    const originalCwd = process.cwd();
+    try {
+      const file = path.join(root, "shared", "models", "regex-item.ts");
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, model("regex-item", [
+        "  code: z.string().regex(/^(?<code>[A-Z]+)$/),",
+        "  letters: z.string().regex(/^\\p{L}+$/u),",
+        "  when: z.string().datetime().regex(/Z$/),",
+      ].join("\n")));
+      const info = await parseModelFile(file);
+      expect(getPythonRegexWarnings(info)).toEqual([
+        expect.stringMatching(/^python-regex-not-enforced: RegexItem\.letters uses Unicode property escapes/),
+      ]);
+      process.chdir(root);
+      const session = new FileOperationSession("commit", root);
+      await generateLanguageSchemaArtifacts([info], info, "functions", "python", session);
+      expect(session.warnings).toEqual(getPythonRegexWarnings(info));
+      const source = fs.readFileSync(path.join(root, "functions", "generated", "python-models", "backend_models", "models", "regex_item.py"), "utf8");
+      expect(source).toContain('re.search("^(?P<code>[A-Z]+)$", item, 0)');
+      expect(source).not.toContain("letters_validate_pattern");
+      expect(source).toContain("@field_validator('when', mode='before')");
+      expect(source).toContain("if isinstance(item, str) and not re.search");
+    } finally {
+      process.chdir(originalCwd);
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+const pydanticPython = ["python", "python3"].find((command) => spawnSync(command, ["-c", "import pydantic"], { stdio: "ignore" }).status === 0);
+const itWithPydantic = pydanticPython ? it : it.skip;
+
+describe("generated Python model runtime", () => {
+  itWithPydantic("accepts valid regex and timestamp values and rejects invalid ones", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-python-runtime-"));
+    const originalCwd = process.cwd();
+    try {
+      const file = path.join(root, "shared", "models", "regex-item.ts");
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, model("regex-item", [
+        "  code: z.string().regex(/^(?<code>[A-Z]+)$/),",
+        "  when: z.iso.datetime().regex(/Z$/),",
+        "  tags: z.array(z.string().regex(/^t/)),",
+      ].join("\n")));
+      const info = await parseModelFile(file);
+      process.chdir(root);
+      await generateLanguageSchemaArtifacts([info], info, "functions", "python", new FileOperationSession("commit", root));
+      process.chdir(originalCwd);
+      const script = [
+        "import sys",
+        "sys.path.insert(0, 'generated/python-models')",
+        "from backend_models.models.regex_item import RegexItem",
+        "ok = {'id': '1', 'code': 'ABC', 'when': '2024-05-06T07:08:09Z', 'tags': ['t1']}",
+        "RegexItem.from_dict(ok)",
+        "for bad in ({**ok, 'code': 'abc'}, {**ok, 'when': '2024-05-06T07:08:09+09:00'}, {**ok, 'tags': ['x']}):",
+        "    try:",
+        "        RegexItem.from_dict(bad)",
+        "    except ValueError:",
+        "        continue",
+        "    raise SystemExit('accepted ' + repr(bad))",
+        "print('ok')",
+      ].join("\n");
+      const run = spawnSync(pydanticPython!, ["-c", script], { cwd: path.join(root, "functions"), encoding: "utf8" });
+      if (run.status !== 0) throw new Error(`${run.stdout}\n${run.stderr}`);
+      expect(run.stdout.trim()).toBe("ok");
+    } finally {
+      process.chdir(originalCwd);
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }, 60000);
+});
+
+describe("user-scoped data warning", () => {
+  const info = (partitionKey: string, fields: string[]) => ({
+    name: "ProbeItem",
+    partitionKey,
+    fields: fields.map((name) => ({ name, type: "string", isOptional: false, isArray: false })),
+  }) as unknown as Parameters<typeof buildUserScopedDataWarning>[0];
+
+  it("warns when the partition key is a per-user id and auth is not configured", () => {
+    expect(buildUserScopedDataWarning(info("/userId", ["id", "userId"]), undefined))
+      .toMatch(/^user-scoped-data-without-auth: ProbeItem\.userId is the partition key and looks like a per-user owner id/);
+    expect(buildUserScopedDataWarning(info("/userId", ["id", "userId"]), { provider: "none" })).toBeDefined();
+  });
+
+  it("warns for owner-like fields that are not the partition key", () => {
+    expect(buildUserScopedDataWarning(info("/id", ["id", "learnerId"]), undefined))
+      .toMatch(/ProbeItem\.learnerId looks like a per-user owner id/);
+  });
+
+  it("stays quiet when authentication is configured or nothing looks user-scoped", () => {
+    expect(buildUserScopedDataWarning(info("/userId", ["id", "userId"]), { provider: "swa" })).toBeUndefined();
+    expect(buildUserScopedDataWarning(info("/userId", ["id", "userId"]), { schemes: { admin: { provider: "swa" } } } as never)).toBeUndefined();
+    expect(buildUserScopedDataWarning(info("/tenantId", ["id", "tenantId", "categoryId"]), undefined)).toBeUndefined();
+  });
+});