@octalmesh/seagull-core 0.0.2 → 0.1.1

package/src/generators/openapi-generator-cli/openapi-generator-cli.generator.test.ts

@@ -0,0 +1,259 @@
+import { mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { GenerateContext } from "../../generator/types";
+import { makeArtifact, makeContract } from "../../test-support/fixtures";
+
+const runMock = vi.fn((..._args: unknown[]) => Promise.resolve());
+const resolveBinPathMock = vi.fn(
+  (..._args: unknown[]) => "/fake/bin/openapi-generator-cli.js",
+);
+const patchMocks = {
+  go: vi.fn((..._args: unknown[]) => Promise.resolve()),
+  typescript: vi.fn((..._args: unknown[]) => Promise.resolve()),
+  java: vi.fn((..._args: unknown[]) => Promise.resolve()),
+};
+
+vi.mock("../../process/exec", () => ({
+  run: (...a: unknown[]) => runMock(...a),
+}));
+vi.mock("../../process/resolve-bin", () => ({
+  resolveBinPath: (...a: unknown[]) => resolveBinPathMock(...a),
+}));
+vi.mock("./patchers/go-module.patcher", () => ({
+  GoModulePatcher: class {
+    patch = patchMocks.go;
+  },
+}));
+vi.mock("./patchers/npm.patcher", () => ({
+  NpmPackagePatcher: class {
+    patch = patchMocks.typescript;
+  },
+}));
+vi.mock("./patchers/maven.patcher", () => ({
+  MavenPomPatcher: class {
+    patch = patchMocks.java;
+  },
+}));
+
+const { OpenApiGeneratorCli } =
+  await import("./openapi-generator-cli.generator");
+
+function makeCtx(overrides: Partial<GenerateContext> = {}): GenerateContext {
+  return {
+    rootDir: "/repo",
+    contract: makeContract(),
+    artifact: makeArtifact(),
+    version: "1.0.0",
+    specInputPath: "/repo/dist/specs/auth.json",
+    ...overrides,
+  };
+}
+
+describe("OpenApiGeneratorCli", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "seagull-ogc-"));
+    runMock.mockClear();
+    resolveBinPathMock.mockClear();
+    patchMocks.go.mockClear();
+    patchMocks.typescript.mockClear();
+    patchMocks.java.mockClear();
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("exposes 'tool' as \"openapi-generator\"", () => {
+    expect(new OpenApiGeneratorCli().tool).toBe("openapi-generator");
+  });
+
+  it("creates the artifact's output directory", async () => {
+    const outputDir = path.join(dir, "auth", "ts-client");
+
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({ artifact: makeArtifact({ outputDir }) }),
+    );
+
+    await expect(stat(outputDir)).resolves.toMatchObject({});
+  });
+
+  it("throws when the artifact has no 'generator' value", async () => {
+    await expect(
+      new OpenApiGeneratorCli().generate(
+        makeCtx({
+          artifact: makeArtifact({ id: "weird", generator: undefined }),
+        }),
+      ),
+    ).rejects.toThrow(
+      /Artifact "weird" uses tool "openapi-generator" but has no "generator" value/,
+    );
+  });
+
+  it("resolves the openapi-generator-cli bin and invokes it with the expected flags", async () => {
+    const outputDir = path.join(dir, "auth", "ts-client");
+
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({ outputDir, generator: "typescript-fetch" }),
+        specInputPath: "/repo/dist/specs/auth.json",
+      }),
+    );
+
+    expect(resolveBinPathMock).toHaveBeenCalledWith(
+      "@openapitools/openapi-generator-cli",
+      "openapi-generator-cli",
+    );
+    expect(runMock).toHaveBeenCalledWith(
+      "node",
+      [
+        "/fake/bin/openapi-generator-cli.js",
+        "generate",
+        "-i",
+        "/repo/dist/specs/auth.json",
+        "-g",
+        "typescript-fetch",
+        "-o",
+        outputDir,
+        expect.stringMatching(/^--additional-properties=/),
+      ],
+      "/repo",
+    );
+  });
+
+  it("derives npmName from artifact.package for typescript artifacts", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "typescript",
+          package: "@octalmesh/auth-client",
+        }),
+      }),
+    );
+
+    const [, args] = runMock.mock.calls[0]!;
+    const flag = (args as string[]).find((a) =>
+      a.startsWith("--additional-properties="),
+    )!;
+
+    expect(flag).toContain("npmName=@octalmesh/auth-client");
+  });
+
+  it("derives packageName from artifact.goPackageName for go artifacts", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "go",
+          package: undefined,
+          goModule: "github.com/octalmesh/ows-contracts",
+          goPackageName: "authclient",
+        }),
+      }),
+    );
+
+    const [, args] = runMock.mock.calls[0]!;
+    const flag = (args as string[]).find((a) =>
+      a.startsWith("--additional-properties="),
+    )!;
+
+    expect(flag).toContain("packageName=authclient");
+  });
+
+  it("derives groupId/artifactId/invokerPackage/apiPackage/modelPackage for java artifacts", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "java",
+          kind: "client",
+          package: undefined,
+          maven: { groupId: "com.octalmesh.auth", artifactId: "auth-client" },
+        }),
+      }),
+    );
+
+    const [, args] = runMock.mock.calls[0]!;
+    const flag = (args as string[]).find((a) =>
+      a.startsWith("--additional-properties="),
+    )!;
+
+    expect(flag).toContain("groupId=com.octalmesh.auth");
+    expect(flag).toContain("artifactId=auth-client");
+    expect(flag).toContain("invokerPackage=com.octalmesh.auth.client");
+    expect(flag).toContain("apiPackage=com.octalmesh.auth.client.api");
+    expect(flag).toContain("modelPackage=com.octalmesh.auth.client.model");
+  });
+
+  it("layers the artifact's own additionalProperties on top of derived ones, with explicit values winning", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "typescript",
+          package: "@octalmesh/auth-client",
+          additionalProperties: {
+            npmName: "@octalmesh/explicit-override",
+            supportsES6: true,
+          },
+        }),
+      }),
+    );
+
+    const [, args] = runMock.mock.calls[0]!;
+    const flag = (args as string[]).find((a) =>
+      a.startsWith("--additional-properties="),
+    )!;
+
+    expect(flag).toContain("npmName=@octalmesh/explicit-override");
+    expect(flag).toContain("supportsES6=true");
+    expect(flag).not.toContain("npmName=@octalmesh/auth-client,");
+  });
+
+  it("dispatches to the go patcher for lang 'go'", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "go",
+          package: undefined,
+        }),
+      }),
+    );
+
+    expect(patchMocks.go).toHaveBeenCalledOnce();
+    expect(patchMocks.typescript).not.toHaveBeenCalled();
+    expect(patchMocks.java).not.toHaveBeenCalled();
+  });
+
+  it("dispatches to the npm patcher for lang 'typescript'", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({ outputDir: dir, lang: "typescript" }),
+      }),
+    );
+
+    expect(patchMocks.typescript).toHaveBeenCalledOnce();
+  });
+
+  it("dispatches to the maven patcher for lang 'java'", async () => {
+    await new OpenApiGeneratorCli().generate(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "java",
+          package: undefined,
+          maven: { groupId: "com.octalmesh.auth", artifactId: "auth-client" },
+        }),
+      }),
+    );
+
+    expect(patchMocks.java).toHaveBeenCalledOnce();
+  });
+});

package/src/generators/openapi-generator-cli/patchers/go-module.patcher.test.ts

@@ -0,0 +1,119 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import type { GenerateContext } from "../../../generator/types";
+import { makeArtifact, makeContract } from "../../../test-support/fixtures";
+import { GoModulePatcher } from "./go-module.patcher";
+
+function makeCtx(overrides: Partial<GenerateContext> = {}): GenerateContext {
+  return {
+    rootDir: "/repo",
+    contract: makeContract(),
+    artifact: makeArtifact({
+      lang: "go",
+      package: undefined,
+      goModule: "github.com/octalmesh/ows-contracts",
+      goPackageName: "authclient",
+    }),
+    version: "1.0.0",
+    specInputPath: "/repo/dist/specs/auth.json",
+    ...overrides,
+  };
+}
+
+describe("GoModulePatcher", () => {
+  let dir: string;
+  const patcher = new GoModulePatcher();
+
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "seagull-gomod-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("rewrites the 'module' line of an existing go.mod to the artifact's goModule", async () => {
+    await writeFile(
+      path.join(dir, "go.mod"),
+      ["module openapi", "", "go 1.21", ""].join("\n"),
+    );
+
+    await patcher.patch(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "go",
+          package: undefined,
+          goModule: "github.com/octalmesh/ows-contracts",
+        }),
+      }),
+    );
+
+    const content = await readFile(path.join(dir, "go.mod"), "utf8");
+
+    expect(content).toContain("module github.com/octalmesh/ows-contracts");
+    expect(content).toContain("go 1.21");
+  });
+
+  it("only replaces the module line, leaving the rest of the file untouched", async () => {
+    await writeFile(
+      path.join(dir, "go.mod"),
+      ["module old/path", "", "require (", "\tfoo v1.0.0", ")", ""].join("\n"),
+    );
+
+    await patcher.patch(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "go",
+          package: undefined,
+          goModule: "new/module/path",
+        }),
+      }),
+    );
+
+    const content = await readFile(path.join(dir, "go.mod"), "utf8");
+
+    expect(content).toBe(
+      ["module new/module/path", "", "require (", "\tfoo v1.0.0", ")", ""].join(
+        "\n",
+      ),
+    );
+  });
+
+  it("does nothing (no throw) when the artifact has no goModule", async () => {
+    await expect(
+      patcher.patch(
+        makeCtx({
+          artifact: makeArtifact({
+            outputDir: dir,
+            lang: "go",
+            package: undefined,
+            goModule: undefined,
+          }),
+        }),
+      ),
+    ).resolves.toBeUndefined();
+  });
+
+  it("silently does nothing when go.mod doesn't exist (e.g. go-server templates)", async () => {
+    await mkdir(dir, { recursive: true });
+
+    await expect(
+      patcher.patch(
+        makeCtx({
+          artifact: makeArtifact({
+            outputDir: dir,
+            lang: "go",
+            package: undefined,
+            goModule: "github.com/octalmesh/ows-contracts",
+          }),
+        }),
+      ),
+    ).resolves.toBeUndefined();
+  });
+});

package/src/generators/openapi-generator-cli/patchers/maven.patcher.test.ts

@@ -0,0 +1,141 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import type { GenerateContext } from "../../../generator/types";
+import { makeArtifact, makeContract } from "../../../test-support/fixtures";
+import { MavenPomPatcher } from "./maven.patcher";
+
+function makeCtx(overrides: Partial<GenerateContext> = {}): GenerateContext {
+  return {
+    rootDir: "/repo",
+    contract: makeContract(),
+    artifact: makeArtifact({
+      lang: "java",
+      package: undefined,
+      maven: { groupId: "com.octalmesh.auth", artifactId: "auth-client" },
+    }),
+    version: "1.0.0",
+    specInputPath: "/repo/dist/specs/auth.json",
+    ...overrides,
+  };
+}
+
+describe("MavenPomPatcher", () => {
+  let dir: string;
+  const patcher = new MavenPomPatcher();
+
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "seagull-pom-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("replaces the <version> element with the resolved version", async () => {
+    await writeFile(
+      path.join(dir, "pom.xml"),
+      ["<project>", "  <version>0.0.0</version>", "</project>", ""].join("\n"),
+    );
+
+    await patcher.patch(
+      makeCtx({
+        version: "2.5.0",
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "java",
+          package: undefined,
+        }),
+      }),
+    );
+
+    const content = await readFile(path.join(dir, "pom.xml"), "utf8");
+
+    expect(content).toContain("<version>2.5.0</version>");
+  });
+
+  it("appends <distributionManagement> using the artifact's resolved publishing config", async () => {
+    await writeFile(
+      path.join(dir, "pom.xml"),
+      ["<project>", "  <version>0.0.0</version>", "</project>", ""].join("\n"),
+    );
+
+    await patcher.patch(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "java",
+          package: undefined,
+          publishing: {
+            branch: "sdk/svc-auth/java-client",
+            tagTemplate: "svc-{service}-{id}-v{version}",
+            repositoryUrl: "https://github.com/OctalMesh/ows-contracts",
+            npmRegistry: "https://npm.pkg.github.com",
+            npmAccess: "public",
+            mavenRepositoryId: "github",
+            mavenRepositoryUrl:
+              "https://maven.pkg.github.com/OctalMesh/ows-contracts",
+          },
+        }),
+      }),
+    );
+
+    const content = await readFile(path.join(dir, "pom.xml"), "utf8");
+
+    expect(content).toContain("<distributionManagement>");
+    expect(content).toContain("<id>github</id>");
+    expect(content).toContain(
+      "<url>https://maven.pkg.github.com/OctalMesh/ows-contracts</url>",
+    );
+    expect(content.indexOf("</distributionManagement>")).toBeLessThan(
+      content.indexOf("</project>"),
+    );
+  });
+
+  it("does not duplicate <distributionManagement> if it's already present", async () => {
+    await writeFile(
+      path.join(dir, "pom.xml"),
+      [
+        "<project>",
+        "  <version>0.0.0</version>",
+        "  <distributionManagement>",
+        "    <repository><id>existing</id></repository>",
+        "  </distributionManagement>",
+        "</project>",
+        "",
+      ].join("\n"),
+    );
+
+    await patcher.patch(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          lang: "java",
+          package: undefined,
+        }),
+      }),
+    );
+
+    const content = await readFile(path.join(dir, "pom.xml"), "utf8");
+
+    expect(content.split("<distributionManagement>").length - 1).toBe(1);
+    expect(content).toContain("<id>existing</id>");
+  });
+
+  it("silently does nothing when pom.xml is absent (e.g. Gradle build selected)", async () => {
+    await expect(
+      patcher.patch(
+        makeCtx({
+          artifact: makeArtifact({
+            outputDir: dir,
+            lang: "java",
+            package: undefined,
+          }),
+        }),
+      ),
+    ).resolves.toBeUndefined();
+  });
+});

package/src/generators/openapi-generator-cli/patchers/npm.patcher.test.ts

@@ -0,0 +1,132 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import type { GenerateContext } from "../../../generator/types";
+import { makeArtifact, makeContract } from "../../../test-support/fixtures";
+import { NpmPackagePatcher } from "./npm.patcher";
+
+function makeCtx(overrides: Partial<GenerateContext> = {}): GenerateContext {
+  return {
+    rootDir: "/repo",
+    contract: makeContract(),
+    artifact: makeArtifact(),
+    version: "1.0.0",
+    specInputPath: "/repo/dist/specs/auth.json",
+    ...overrides,
+  };
+}
+
+describe("NpmPackagePatcher", () => {
+  let dir: string;
+  const patcher = new NpmPackagePatcher();
+
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "seagull-npmpkg-"));
+    await writeFile(
+      path.join(dir, "package.json"),
+      JSON.stringify(
+        { name: "@octalmesh/auth-client", version: "0.0.0", main: "index.js" },
+        null,
+        2,
+      ),
+    );
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("sets 'version' to the resolved version", async () => {
+    await patcher.patch(
+      makeCtx({ version: "3.1.4", artifact: makeArtifact({ outputDir: dir }) }),
+    );
+
+    const pkg = JSON.parse(
+      await readFile(path.join(dir, "package.json"), "utf8"),
+    ) as Record<string, unknown>;
+
+    expect(pkg.version).toBe("3.1.4");
+  });
+
+  it("sets 'repository' from artifact.publishing.repositoryUrl, git+ prefixed and .git suffixed", async () => {
+    await patcher.patch(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          publishing: {
+            branch: "sdk/svc-auth/ts-client",
+            tagTemplate: "svc-{service}-{id}-v{version}",
+            repositoryUrl: "https://github.com/OctalMesh/ows-contracts",
+            npmRegistry: "https://npm.pkg.github.com",
+            npmAccess: "public",
+            mavenRepositoryId: "github",
+            mavenRepositoryUrl:
+              "https://maven.pkg.github.com/OctalMesh/ows-contracts",
+          },
+        }),
+      }),
+    );
+
+    const pkg = JSON.parse(
+      await readFile(path.join(dir, "package.json"), "utf8"),
+    ) as Record<string, unknown>;
+
+    expect(pkg.repository).toEqual({
+      type: "git",
+      url: "git+https://github.com/OctalMesh/ows-contracts.git",
+    });
+  });
+
+  it("sets 'publishConfig' from artifact.publishing.npmRegistry/npmAccess", async () => {
+    await patcher.patch(
+      makeCtx({
+        artifact: makeArtifact({
+          outputDir: dir,
+          publishing: {
+            branch: "sdk/svc-auth/ts-client",
+            tagTemplate: "svc-{service}-{id}-v{version}",
+            repositoryUrl: "https://github.com/OctalMesh/ows-contracts",
+            npmRegistry: "https://custom.registry.example.com",
+            npmAccess: "restricted",
+            mavenRepositoryId: "github",
+            mavenRepositoryUrl:
+              "https://maven.pkg.github.com/OctalMesh/ows-contracts",
+          },
+        }),
+      }),
+    );
+
+    const pkg = JSON.parse(
+      await readFile(path.join(dir, "package.json"), "utf8"),
+    ) as Record<string, unknown>;
+
+    expect(pkg.publishConfig).toEqual({
+      registry: "https://custom.registry.example.com",
+      access: "restricted",
+    });
+  });
+
+  it("preserves fields it doesn't own (e.g. 'main' emitted by openapi-generator-cli)", async () => {
+    await patcher.patch(
+      makeCtx({ artifact: makeArtifact({ outputDir: dir }) }),
+    );
+
+    const pkg = JSON.parse(
+      await readFile(path.join(dir, "package.json"), "utf8"),
+    ) as Record<string, unknown>;
+
+    expect(pkg.name).toBe("@octalmesh/auth-client");
+    expect(pkg.main).toBe("index.js");
+  });
+
+  it("rejects when package.json doesn't exist (unlike the go/maven patchers, this one is not tolerant)", async () => {
+    await rm(path.join(dir, "package.json"));
+
+    await expect(
+      patcher.patch(makeCtx({ artifact: makeArtifact({ outputDir: dir }) })),
+    ).rejects.toThrow();
+  });
+});