@shortlink-org/portolan 0.2.1 → 0.2.3

package/scripts/local-api.test.mjs

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { rmSync } from "node:fs";
 
-import { classifyRepositoryFailure, diffGeneratedFiles, discoverProject, forgetRepositoryCredential, inspectionRoot, localApiPath, planProject, readLocalSource, resolveRepositoryCommit, storeRepositoryCredential, summarizeProjectTrial, writeProject } from "./local-api.mjs";
+import { classifyRepositoryFailure, diffGeneratedFiles, discoverProject, externalProjectDefaults, forgetRepositoryCredential, inspectionRoot, localApiPath, manifestWithoutProject, manifestWithProject, planProject, readLocalSource, removeProject, resolveRepositoryCommit, starterManifestProject, storeRepositoryCredential, summarizeProjectTrial, undoProjectRemoval, writeProject } from "./local-api.mjs";
 import { installDeliveryPreset, planDeliveryPreset, providerFromRemote, publicDeliveryPreset } from "./delivery-presets.mjs";
 
 const PACKAGE_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
@@ -72,6 +72,44 @@ describe("local project setup", () => {
     expect(installDeliveryPreset(root, { provider: "github", revision: installed.revision }).written).toEqual([]);
   });
 
+  it("generates only the selected GitHub jobs and keeps elevated permissions isolated", () => {
+    const root = gitWorkspace("github");
+    const preview = planDeliveryPreset(root, { provider: "github", features: ["check", "diff", "sarif"] });
+    expect(preview.features.filter((feature) => feature.selected).map((feature) => feature.id)).toEqual(["check", "diff", "sarif"]);
+    expect(preview.files.map((file) => file.path)).toEqual([
+      ".github/workflows/portolan-check.yml",
+      ".github/workflows/portolan-review.yml",
+    ]);
+    const installed = installDeliveryPreset(root, {
+      provider: "github",
+      features: ["check", "diff", "sarif"],
+      revision: preview.revision,
+    });
+    expect(installed.status).toBe("installed");
+    const check = readFileSync(join(root, ".github/workflows/portolan-check.yml"), "utf8");
+    const review = readFileSync(join(root, ".github/workflows/portolan-review.yml"), "utf8");
+    expect(check).not.toContain("pull-requests: write");
+    expect(review).toContain("command: diff");
+    expect(review).toContain("pull-requests: write");
+    expect(review).toContain("security-events: write");
+    expect(review).toContain("github/codeql-action/upload-sarif@v4");
+    expect(existsSync(join(root, ".github/workflows/portolan-pages.yml"))).toBe(false);
+    expect(planDeliveryPreset(root).features.filter((feature) => feature.selected).map((feature) => feature.id)).toEqual(["check", "diff", "sarif"]);
+  });
+
+  it("removes a disabled GitHub job only when Portolan owns the file", () => {
+    const root = gitWorkspace("github");
+    const initial = planDeliveryPreset(root, { provider: "github", features: ["check", "diff"] });
+    installDeliveryPreset(root, { provider: "github", features: ["check", "diff"], revision: initial.revision });
+    const withoutDiff = planDeliveryPreset(root, { provider: "github", features: ["check"] });
+    expect(withoutDiff.files.find((file) => file.path.endsWith("portolan-review.yml"))?.status).toBe("removed");
+    installDeliveryPreset(root, { provider: "github", features: ["check"], revision: withoutDiff.revision });
+    expect(existsSync(join(root, ".github/workflows/portolan-review.yml"))).toBe(false);
+
+    writeFileSync(join(root, ".github/workflows/portolan-review.yml"), "name: Mine\n");
+    expect(planDeliveryPreset(root, { provider: "github", features: ["check"] }).files.some((file) => file.path.endsWith("portolan-review.yml"))).toBe(false);
+  });
+
   it("refuses to overwrite an unmanaged GitHub workflow or apply a stale preview", () => {
     const root = gitWorkspace("github");
     mkdirSync(join(root, ".github/workflows"), { recursive: true });
@@ -112,6 +150,18 @@ describe("local project setup", () => {
     expect(existsSync(join(root, ".github"))).toBe(false);
   });
 
+  it("builds the GitLab managed region from selected jobs", () => {
+    const root = gitWorkspace("gitlab");
+    const preview = planDeliveryPreset(root, { provider: "gitlab", features: ["diff"] });
+    expect(preview.files[0].diff).toContain('+"portolan:review":');
+    expect(preview.files[0].diff).not.toContain('+"portolan:check":');
+    expect(preview.files[0].diff).not.toContain('+"portolan:pages":');
+    const installed = installDeliveryPreset(root, { provider: "gitlab", features: ["diff"], revision: preview.revision });
+    expect(planDeliveryPreset(root).features.filter((feature) => feature.selected).map((feature) => feature.id)).toEqual(["diff"]);
+    expect(installed.status).toBe("installed");
+    expect(() => planDeliveryPreset(root, { provider: "gitlab", features: ["sarif"] })).toThrow(/only for GitHub/);
+  });
+
   it("classifies repository authentication, authorization, and timeout failures", () => {
     expect(classifyRepositoryFailure(new Error("fatal: Authentication failed"), "GitHub")).toMatchObject({
       code: "repository_auth_required", status: 401, retryable: true, provider: "GitHub",
@@ -189,6 +239,18 @@ describe("local project setup", () => {
     expect(discovery.detections.find((item) => item.plugin === "adr")?.selected).toBe(false);
   });
 
+  it("names external projects from the repository or selected component instead of the inspection cache", () => {
+    expect(externalProjectDefaults("https://github.com/batazor/microservice-template-ddd")).toEqual({
+      id: "microservice-template-ddd",
+      name: "Microservice Template Ddd",
+      group: "microservice-template-ddd",
+      component: "microservice-template-ddd",
+      context: "microservice-template-ddd",
+      service: "microservice-template-ddd",
+    });
+    expect(externalProjectDefaults("git@github.com:acme/platform.git", "services/payments").id).toBe("payments");
+  });
+
   it("finds component roots in a monorepo without reading dependency directories", () => {
     const root = workspace();
     mkdirSync(join(root, "services/orders"), { recursive: true });
@@ -209,6 +271,55 @@ describe("local project setup", () => {
     ]);
   });
 
+  it("splits corroborated Go cmd entrypoints into deployable services", () => {
+    const root = workspace();
+    const platform = join(root, "services/platform");
+    mkdirSync(platform, { recursive: true });
+    writeFileSync(join(platform, "go.mod"), "module example.com/platform\nrequire github.com/go-redis/redis v6.15.9+incompatible\n");
+    for (const service of ["api", "billing", "book", "user"]) {
+      mkdirSync(join(platform, "cmd", service), { recursive: true });
+      mkdirSync(join(platform, "ops/dockerfile"), { recursive: true });
+      writeFileSync(join(platform, "cmd", service, `${service}.go`), "package main\nfunc main() {}\n");
+      writeFileSync(join(platform, "ops/dockerfile", `${service}.Dockerfile`), `FROM golang\nRUN go build -o app ./cmd/${service}\n`);
+    }
+    for (const service of ["billing", "book", "user"]) {
+      mkdirSync(join(platform, "internal", service, "infrastructure/rpc"), { recursive: true });
+      writeFileSync(join(platform, "internal", service, "infrastructure/rpc", `${service}.proto`), `syntax = "proto3"; package ${service}; service ${service}RPC {}\n`);
+      mkdirSync(join(platform, "internal", service, "domain"), { recursive: true });
+      writeFileSync(join(platform, "internal", service, "domain", `${service}.go`), `package domain\ntype ${service[0].toUpperCase() + service.slice(1)} struct{}\n`);
+    }
+    mkdirSync(join(platform, "internal/db/redis"), { recursive: true });
+    mkdirSync(join(platform, "internal/di"), { recursive: true });
+    writeFileSync(join(platform, "internal/db/redis/redis.go"), "package redisdb\nimport redis \"github.com/go-redis/redis\"\nfunc Open() { _ = redis.NewClient(nil) }\n");
+    writeFileSync(join(platform, "internal/di/book.go"), "package di\nimport _ \"example.com/platform/internal/db\"\n");
+
+    const discovery = discoverProject(root, "services/platform");
+    expect(discovery.deployables.map(({ slug, confidence }) => [slug, confidence])).toEqual([
+      ["api", "high"], ["billing", "high"], ["book", "high"], ["user", "high"],
+    ]);
+
+    const manifest = JSON.parse(readFileSync(join(root, "portolan.json"), "utf8"));
+    const plan = planProject(root, manifest, {
+      root: "services/platform", id: "platform", name: "Platform", group: "platform", component: "platform", componentKind: "application", plugins: ["project", "go-domain", "proto", "redis"],
+    });
+    expect(plan.project).toMatchObject({ group: "platform", components: ["api", "billing", "book", "user"] });
+    expect(plan.project).not.toHaveProperty("component");
+    expect(plan.steps[0].options.components.map((component) => component.slug)).toEqual(["api", "billing", "book", "user"]);
+    expect(plan.steps.filter((step) => step.plugin === "proto").map((step) => [step.options.service, step.options.out])).toEqual([
+      ["billing", "proto-billing.json"], ["book", "proto-book.json"], ["user", "proto-user.json"],
+    ]);
+    expect(plan.steps.filter((step) => step.plugin === "redis").map((step) => [step.options.service, step.options.out])).toEqual([
+      ["book", "redis-book.json"],
+    ]);
+    expect(plan.steps.filter((step) => step.plugin === "go-domain").map((step) => [step.options.service, step.options.scope, step.options.store, step.options.peers, step.options.out])).toEqual([
+      ["api", "api", undefined, { billing: "platform.billing", book: "platform.book", user: "platform.user" }, "go-domain-api.json"],
+      ["billing", "billing", undefined, { billing: "platform.billing", book: "platform.book", user: "platform.user" }, "go-domain-billing.json"],
+      ["book", "book", "redis", { billing: "platform.billing", book: "platform.book", user: "platform.user" }, "go-domain-book.json"],
+      ["user", "user", undefined, { billing: "platform.billing", book: "platform.book", user: "platform.user" }, "go-domain-user.json"],
+    ]);
+    expect(plan.steps[0].options.groupKind).toBe("system");
+  });
+
   it("only offers the Go domain extractor when the layout contains an aggregate root", () => {
     const root = workspace();
     mkdirSync(join(root, "services/billing/internal/domain/invoice"), { recursive: true });
@@ -233,6 +344,14 @@ describe("local project setup", () => {
     expect(discovery.detections.find((item) => item.plugin === "sql")?.evidence).toBe("2 repository packages");
   });
 
+  it("accepts a feature domain package named domain", () => {
+    const root = workspace();
+    mkdirSync(join(root, "services/billing/internal/invoice/domain"), { recursive: true });
+    writeFileSync(join(root, "services/billing/internal/invoice/domain/invoice.go"), "package domain\n\ntype Invoice struct{}\n");
+    const discovery = discoverProject(root, "services/billing");
+    expect(discovery.detections.find((item) => item.plugin === "go-domain")?.evidence).toBe("internal/invoice/domain/invoice.go");
+  });
+
   it("offers the River extractor when the Go module uses River", () => {
     const root = workspace();
     writeFileSync(join(root, "services/billing/go.mod"), "module example.com/billing\nrequire github.com/riverqueue/river v0.26.0\n");
@@ -383,6 +502,131 @@ describe("local project setup", () => {
     expect(() => writeProject(root, { ...request, id: "another" })).toThrow(/already exists/);
   });
 
+  it("removes a project's complete catalog slice without touching its neighbour", () => {
+    const manifest = {
+      sources: ["portolan/*.json", "services/billing/portolan/*.json"],
+      defaultCatalog: "portolan",
+      catalogs: [
+        { id: "portolan", title: "Portolan", sources: ["portolan/*.json"], contexts: ["portolan"], projects: ["portolan"] },
+        { id: "billing", title: "Billing", sources: ["services/billing/portolan/*.json"], contexts: ["finance"], projects: ["billing"] },
+      ],
+      projects: [
+        { id: "portolan", name: "Portolan", root: ".", group: "portolan", component: "portolan" },
+        { id: "billing", name: "Billing", root: "services/billing", group: "finance", component: "billing" },
+      ],
+      extract: [
+        { plugin: "project", in: ".", out: "portolan", options: {} },
+        { plugin: "commands", in: "scripts", out: "portolan", options: {} },
+        { plugin: "project", in: "services/billing", out: "services/billing/portolan", options: {} },
+      ],
+      verify: [
+        { plugin: "otel", in: ".", out: "portolan", options: {} },
+        { plugin: "otel", in: "services/billing", out: "services/billing/portolan", options: {} },
+      ],
+      generate: [
+        { plugin: "markdown", catalog: "portolan", out: "docs", options: {} },
+        { plugin: "markdown", catalog: "billing", out: "docs/billing", options: {} },
+      ],
+    };
+    const result = manifestWithoutProject(manifest, "portolan");
+    expect(result.manifest.projects.map((project) => project.id)).toEqual(["billing"]);
+    expect(result.manifest.sources).toEqual(["services/billing/portolan/*.json"]);
+    expect(result.manifest.extract.map((step) => step.out)).toEqual(["services/billing/portolan"]);
+    expect(result.manifest.verify.map((step) => step.out)).toEqual(["services/billing/portolan"]);
+    expect(result.manifest.catalogs.map((catalog) => catalog.id)).toEqual(["billing"]);
+    expect(result.manifest.defaultCatalog).toBe("billing");
+    expect(result.manifest.generate.map((step) => step.catalog)).toEqual(["billing"]);
+    expect(result.removedOutputs).toEqual(["docs"]);
+  });
+
+  it("keeps a valid empty-workspace source and replaces it when a project is added", () => {
+    const removed = manifestWithoutProject({
+      sources: ["portolan/*.json"],
+      projects: [{ id: "portolan", name: "Portolan", root: ".", group: "portolan", component: "portolan" }],
+      extract: [{ plugin: "project", in: ".", out: "portolan", options: {} }],
+      generate: [{ plugin: "markdown", out: "docs", options: {} }],
+    }, "portolan");
+    expect(removed.manifest).toMatchObject({ sources: ["portolan/*.json"], projects: [], extract: [] });
+    expect(removed.removedOutputs).toEqual(["docs"]);
+
+    const added = planProject(workspace(), { sources: ["portolan/*.json"], projects: [], extract: [] }, {
+      root: "services/billing", id: "aviaadmin", name: "Avia Admin", group: "avia", groupKind: "bounded-context", component: "aviaadmin", plugins: ["project"],
+    });
+    expect(added.project).toMatchObject({ id: "aviaadmin", group: "avia", groupKind: "bounded-context" });
+    expect(added.steps[0].options).toMatchObject({ group: "avia", groupKind: "bounded-context" });
+    const manifest = { sources: ["portolan/*.json"], projects: [], extract: [] };
+    expect(manifestWithProject(manifest, added).sources).toEqual(["services/billing/portolan/*.json"]);
+  });
+
+  it("does not duplicate an existing external fetch when a project is re-added", () => {
+    const fetch = { repo: "https://github.com/acme/orders", commit: "a".repeat(40), paths: [] };
+    const manifest = {
+      sources: ["vendor/repos/*/*/git.repo.json"], projects: [],
+      extract: [{ plugin: "git", in: "vendor", out: "vendor/repos", options: { cache: "vendor/repos", repos: [fetch] } }],
+    };
+    const plan = {
+      project: { id: "orders", root: "vendor/repos/acme/orders", group: "orders", component: "orders" },
+      steps: [{ plugin: "project", in: "vendor/repos/acme/orders", out: "vendor/repos/acme/orders/portolan", options: {} }],
+      source: "vendor/repos/**/portolan/*.json", fetch,
+    };
+    expect(manifestWithProject(manifest, plan).extract[0].options.repos).toEqual([fetch]);
+  });
+
+  it("adds the project slice to the default catalog profile", () => {
+    const root = workspace();
+    const manifest = {
+      sources: ["portolan/*.json"],
+      defaultCatalog: "company",
+      catalogs: [{ id: "company", title: "Company", sources: ["portolan/*.json"], contexts: ["platform"], projects: ["portolan"] }],
+      projects: [{ id: "portolan", root: ".", group: "platform", component: "portolan" }],
+      extract: [],
+    };
+    const added = planProject(root, manifest, {
+      root: "services/billing", id: "billing", name: "Billing", group: "finance", component: "billing", plugins: ["project"],
+    });
+    expect(manifestWithProject(manifest, added).catalogs[0]).toMatchObject({
+      sources: ["portolan/*.json", "services/billing/portolan/*.json"],
+      contexts: ["platform", "finance"],
+      projects: ["portolan", "billing"],
+    });
+  });
+
+  it("replaces a starter atomically after project discovery succeeds", () => {
+    const root = workspace();
+    const manifest = JSON.parse(readFileSync(join(root, "portolan.json"), "utf8"));
+    Object.assign(manifest, {
+      sources: ["portolan/*.json"],
+      projects: [{ id: "starter", name: "Starter", root: ".", group: "starter", component: "starter" }],
+      extract: [{ plugin: "project", in: ".", out: "portolan", options: { group: "starter", component: "starter" } }],
+    });
+    writeFileSync(join(root, "portolan.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    expect(starterManifestProject(manifest)?.id).toBe("starter");
+    const result = writeProject(root, {
+      root: "services/billing", id: "aviaadmin", name: "Avia Admin", group: "avia", contextName: "Aviation", contextSummary: "Flight administration.", classification: "core", groupKind: "bounded-context", component: "aviaadmin", componentKind: "service", replaceStarter: true, plugins: ["project"],
+    });
+    const written = JSON.parse(readFileSync(join(root, "portolan.json"), "utf8"));
+    expect(result.replacedProject?.id).toBe("starter");
+    expect(written.projects.map((project) => project.id)).toEqual(["aviaadmin"]);
+    expect(starterManifestProject(written)).toBeNull();
+    expect(written.sources).toEqual(["services/billing/portolan/*.json"]);
+    expect(written.extract).toHaveLength(1);
+    expect(written.extract[0].options).toMatchObject({ group: "avia", groupName: "Aviation", groupSummary: "Flight administration.", classification: "core", groupKind: "bounded-context", componentKind: "service" });
+  });
+
+  it("undoes a project removal only while the manifest is unchanged", () => {
+    const root = workspace();
+    writeProject(root, { root: "services/billing", id: "billing", name: "Billing", group: "finance", component: "billing", plugins: ["project"] });
+    mkdirSync(join(root, "services/billing/portolan"), { recursive: true });
+    writeFileSync(join(root, "services/billing/portolan/project.json"), "generated slice\n");
+    const removed = removeProject(root, "billing");
+    expect(JSON.parse(readFileSync(join(root, "portolan.json"), "utf8")).projects).toEqual([]);
+    expect(existsSync(join(root, "services/billing/portolan/project.json"))).toBe(false);
+    expect(undoProjectRemoval(root, removed.undoToken)).toEqual({ restored: true });
+    expect(JSON.parse(readFileSync(join(root, "portolan.json"), "utf8")).projects[0].id).toBe("billing");
+    expect(readFileSync(join(root, "services/billing/portolan/project.json"), "utf8")).toBe("generated slice\n");
+    expect(() => undoProjectRemoval(root, removed.undoToken)).toThrow(/can no longer be undone/);
+  });
+
   it("plans a pinned external repository through the built-in git fetcher", () => {
     const root = workspace();
     const repository = "https://github.com/acme/platform.git";