diff --git a/apps/api/test/modules/apps/app-install-routing.test.ts b/apps/api/test/modules/apps/app-install-routing.test.ts index 992ecf782..980fffc58 100644 --- a/apps/api/test/modules/apps/app-install-routing.test.ts +++ b/apps/api/test/modules/apps/app-install-routing.test.ts @@ -703,3 +703,41 @@ it("deduplicates an interpolated secret also declared as a generated config fiel vars.filter((v: { key: string }) => v.key === "OPENSHIP_ADMIN_PASSWORD"), ).toHaveLength(1); }); + +function templateWithConfigPorts() { + const template = structuredClone(getAppTemplate("convex")!); + template.id = "config-ports-test"; + template.configFields = [ + { key: "HOST_PORT", service: "backend", label: "Host port", default: "8181" }, + { key: "HTTP_PORT", service: "backend", label: "Container port", default: "8080" }, + ]; + template.services!.find(service => service.name === "backend")!.ports = ["{{config:HOST_PORT}}:{{config:HTTP_PORT}}/tcp"]; + customTemplateMock.mockResolvedValue({ template }); + return template; +} + +it("substitutes port defaults before validating routes and preserves the cached template", async () => { + const template = templateWithConfigPorts(); + await installApp(ctx, { templateId: template.id, routes: [{ service: "backend", port: 8080, mode: "port" }] }); + expect(payloadFor("backend")?.ports).toEqual(["0.0.0.0:8181:8080/tcp"]); + expect(template.services![0]!.ports).toEqual(["{{config:HOST_PORT}}:{{config:HTTP_PORT}}/tcp"]); +}); + +it("uses supplied port values for both route validation and service creation", async () => { + const template = templateWithConfigPorts(); + await installApp(ctx, { + templateId: template.id, config: { HOST_PORT: "9191", HTTP_PORT: "9090" }, + routes: [{ service: "backend", port: 9090, mode: "port" }], + }); + expect(payloadFor("backend")?.ports).toEqual(["0.0.0.0:9191:9090/tcp"]); +}); + +it("uses resolved authored ports when undoing port-only access on an adopted draft", async () => { + const template = templateWithConfigPorts(); + draftMock.mockResolvedValue({ id: "p1", slug: "draft", name: "Draft" }); + listServicesMock.mockResolvedValue(template.services!.map(service => ({ id: `svc-${service.name}`, name: service.name, ports: service.name === "backend" ? ["0.0.0.0:8181:8080/tcp"] : [] }))); + await installApp(ctx, { templateId: template.id, routes: [{ service: "backend", port: 8080, mode: "custom", customDomain: "ports.example.com" }] }); + expect(updateServiceMock).toHaveBeenCalledWith(ctx, "p1", "svc-backend", expect.objectContaining({ ports: ["8181:8080/tcp"] })); + expect(createServiceMock).not.toHaveBeenCalled(); + expect(setEnvMock).not.toHaveBeenCalled(); +}); diff --git a/packages/platform/src/engine/modules/apps/app-install.service.ts b/packages/platform/src/engine/modules/apps/app-install.service.ts index d4b3d97e8..74f0d6f26 100644 --- a/packages/platform/src/engine/modules/apps/app-install.service.ts +++ b/packages/platform/src/engine/modules/apps/app-install.service.ts @@ -394,7 +394,53 @@ export async function installApp( return { kind: "flow", flowHref: template.flowHref ?? "/" }; } - assertInstallRoutes(template, input.routes); + // Resolve config values. Secrets sharing a `generateGroup` get ONE generated + // value (e.g. a DB password that must match across two services). + const groupSecret = new Map(); + // Pre-generate every grouped secret so generate:"jwt" fields can sign with + // them regardless of field order (the JWT secret must exist before the keys). + for (const field of template.configFields ?? []) { + if (field.generate === "secret" && field.generateGroup && !groupSecret.has(field.generateGroup)) { + groupSecret.set(field.generateGroup, generateSecret()); + } + } + const valueFor = (field: AppConfigField): string => { + if (field.generate === "secret") { + if (field.generateGroup) { + const existing = groupSecret.get(field.generateGroup); + if (existing) return existing; + const secret = generateSecret(); + groupSecret.set(field.generateGroup, secret); + return secret; + } + return generateSecret(); + } + if (field.generate === "jwt") { + const secret = field.jwtSecretGroup ? groupSecret.get(field.jwtSecretGroup) : undefined; + if (!secret || !field.jwtRole) return ""; + return signHs256Jwt(secret, field.jwtRole); + } + return input.config?.[field.key] ?? field.default ?? ""; + }; + + // Resolve each field's final value EXACTLY once (a non-grouped secret would + // otherwise differ between the env write and the file substitution below). + const resolved = new Map(); + for (const field of template.configFields ?? []) resolved.set(field.key, valueFor(field)); + + // Inline generated config values (`{{config:KEY}}`) now — in both service env + // and mounted files — while leaving `{{publicUrl:…}}` for deploy-time. This + // lets a service env embed a generated secret it can't otherwise interpolate + // (e.g. a full `postgres://user:PASSWORD@db/…` connection URL). + const inlineConfig = (s: string): string => + s.replace(CONFIG_TOKEN_RE, (_m, k) => resolved.get(k) ?? ""); + + // Resolve the same specs for route validation, fresh rows and draft repair. + // Never mutate the catalog template shared by other installations. + const serviceSpecs = (template.services ?? []).map(service => ({ + ...service, ports: service.ports?.map(inlineConfig), + })); + assertInstallRoutes({ services: serviceSpecs }, input.routes); let workspaceId: string | undefined; // Linked Cloud servers retain their workspace on self-hosted control planes @@ -489,47 +535,6 @@ export async function installApp( project = created!; } - // Resolve config values. Secrets sharing a `generateGroup` get ONE generated - // value (e.g. a DB password that must match across two services). - const groupSecret = new Map(); - // Pre-generate every grouped secret so generate:"jwt" fields can sign with - // them regardless of field order (the JWT secret must exist before the keys). - for (const field of template.configFields ?? []) { - if (field.generate === "secret" && field.generateGroup && !groupSecret.has(field.generateGroup)) { - groupSecret.set(field.generateGroup, generateSecret()); - } - } - const valueFor = (field: AppConfigField): string => { - if (field.generate === "secret") { - if (field.generateGroup) { - const existing = groupSecret.get(field.generateGroup); - if (existing) return existing; - const secret = generateSecret(); - groupSecret.set(field.generateGroup, secret); - return secret; - } - return generateSecret(); - } - if (field.generate === "jwt") { - const secret = field.jwtSecretGroup ? groupSecret.get(field.jwtSecretGroup) : undefined; - if (!secret || !field.jwtRole) return ""; - return signHs256Jwt(secret, field.jwtRole); - } - return input.config?.[field.key] ?? field.default ?? ""; - }; - - // Resolve each field's final value EXACTLY once (a non-grouped secret would - // otherwise differ between the env write and the file substitution below). - const resolved = new Map(); - for (const field of template.configFields ?? []) resolved.set(field.key, valueFor(field)); - - // Inline generated config values (`{{config:KEY}}`) now — in both service env - // and mounted files — while leaving `{{publicUrl:…}}` for deploy-time. This - // lets a service env embed a generated secret it can't otherwise interpolate - // (e.g. a full `postgres://user:PASSWORD@db/…` connection URL). - const inlineConfig = (s: string): string => - s.replace(CONFIG_TOKEN_RE, (_m, k) => resolved.get(k) ?? ""); - // Resolve template files per service. const filesByService = new Map(); for (const f of template.files ?? []) { @@ -562,7 +567,7 @@ export async function installApp( const varsByService = new Map(); // The operator's routing, resolved once for the whole stack. - const routingPlan = planInstallRouting(template, project.slug ?? project.name, input.routes); + const routingPlan = planInstallRouting({ services: serviceSpecs }, project.slug ?? project.name, input.routes); // Rows the adopted draft already has. A fresh project has none, so the loop // below reduces to a plain seed. @@ -578,7 +583,7 @@ export async function installApp( // Seed the compose service rows — or, on an adopted draft, re-apply the chosen // routing to the rows that already exist and seed only what's missing (a first // install that died part-way left the project with fewer rows than the template). - for (const svc of template.services ?? []) { + for (const svc of serviceSpecs) { const routing = routingPlan.get(svc.name) ?? { exposed: false, publicEndpoints: [] }; const existingRow = rowByName.get(svc.name); @@ -729,9 +734,10 @@ function inlinedConfigKeys(template: AppTemplate): ReadonlySet { if (!text) return; for (const [, key] of text.matchAll(CONFIG_TOKEN_RE)) keys.add(key); }; - // The four places `inlineConfig` is applied, and only those. + // Every surface that copies a resolved config value at installation. for (const svc of template.services ?? []) { for (const value of Object.values(svc.environment ?? {})) scan(value); + for (const port of svc.ports ?? []) scan(port); scan(svc.build?.dockerfile); for (const file of svc.build?.files ?? []) scan(file.content); }