a month ago
We are preparing a Staging-only TLS configuration release for an existing Runtime service. We need to update only MEMBERSHIP_DATABASE_URL and MEMBERSHIP_DATABASE_CA_CERT without automatic deployment, then explicitly deploy a fixed reviewed source. Before implementing mutation transport, we need Railway's supported contract for precise restoration, unrelated pending changes, concurrent writers and uncertain request outcomes. Please provide guidance only; do not change any project, variables, staged changes, repository or deployments.
Evidence and versions
- Existing read-only authenticated introspection recorded on 2026-10-14 reports environmentPatchCommit(environmentId: String!, patch: EnvironmentConfig, skipDeploys: Boolean, commitMessage: String): String!. The skipDeploys description says to skip deployments for services affected by the patch. We have not performed a new live introspection for this request.
- Railway CLI is pinned to 5.62.1, source commit 4b3cf5936274180f049c424edfb97aea1aced9aa. Its bundled schema is older than the observed live signature, so we do not interpret its missing skipDeploys argument as proof that the live API lacks it.
- Our existing local/synthetic tests verify the exact two-key candidate and read-only rejection behavior. They do not prove Railway server mutation semantics. No TLS patch, inverse patch, staged commit or rollback was submitted by this candidate; there is no real mutation attempt ID to reconcile.
- Internal candidate: Membership #201, commit 274f5f3b222b7d3d291345aa8ee4f05861e3e789. Execution remains blocked; our question is about Railway platform contracts, not application debugging.
Please confirm these six points with supported documentation or an engineering answer:
- Null deletion: Is services[serviceId].variables[key] = null supported exact deletion? Does it restore genuine absence rather than an empty, retained or sealed value? Please distinguish ordinary, sealed, shared and reference variables.
- Deployment suppression: Does environmentPatchCommit(..., explicitPatch, skipDeploys: true) suppress every deployment caused by that patch, including deletion? We do not assume it pauses independent queued/autodeploy operations; how must those races be handled for a later exact-source deployment?
- Pending isolation: Does committing an explicit service-scoped patch preserve all unrelated environment pending changes without applying, merging, discarding or rebasing them? What happens if another actor stages or commits during the request?
- Concurrency/CAS: What supported expected-etag/revision, lock, conflict rejection or equivalent prevents overwriting a state that changed after preflight? The observed signature has no CAS argument. A client-side read-before/write/read-after is not being treated as CAS.
- Unknown submission reconciliation: What exactly does the returned String identify, and which read-only query reports that operation's terminal state and partial results? If the response is lost before we receive the ID, is there a supported client attempt/idempotency key or lookup? When can non-application be established definitively? We will not blindly retry an uncertain mutation.
- Atomicity and rollback: Are the two variable changes atomic on success and error? If partial application is possible, how can its completed state be identified and an inverse bound safely without reverting another actor's updates? Our original CA variable is absent; the proposed inverse restores the original URL byte-for-byte and deletes only the added CA, without deployment. We have not tested or submitted that inverse.
If this round trip is unsupported, please identify the narrowest supported alternative. environmentApplyChangeSet advertises baseConfigEtag and apply-status polling, but the pinned CLI labels variable operations deployEffect: deploy; please clarify no-deploy support, pending isolation, initial-response-loss recovery and any ownership effects before recommending it. We cannot replace all variables, consume a global staged changeset, broaden access, weaken certificate/hostname verification or use Production to discover behavior.
Why contact support?
The assistant recommended official clarification because public documentation and the existing schema evidence do not establish these guarantees. The owner then explicitly authorized this contract inquiry. This is a pre-release question, not an outage escalation. Please state the applicable API/version or rollout scope and any limitations. No resource modification is authorized.
Prepared with Railway's support template (v1).
3 Replies
a month ago
These are the answers we could confirm against the current API. No changes were made to your project.
environmentPatchCommit returns a workflow identifier, not a patch identifier. It takes only environmentId, patch, skipDeploys and commitMessage. There is no etag, revision or idempotency-key argument, so it has no compare-and-set, and if the response is lost before you receive that identifier, there is no attempt key you can use to look the submission up.
With skipDeploys: true, deployments are skipped for the services that patch affects. It does not pause other autodeploys or queued deployments, so independent deploy triggers on that service can still race with your later exact-source deploy.
Committing an explicit patch creates its own new patch and does not touch the environment's existing staged changes. Those are only applied through the separate staged-commit mutation, environmentPatchCommitStaged.
For protection against concurrent writers, environmentApplyChangeSet is the narrower path. It accepts an optional baseConfigEtag, taken from the environment's configEtag, and rejects the apply if the environment has changed since that snapshot.
We could not establish three things from what we checked: exact null-deletion semantics across ordinary, sealed, shared and reference variables, whether both variable writes land atomically when an error occurs, and whether environmentApplyChangeSet suppresses deploys for variable operations. The answers above should not be read as guarantees on those points.
Status changed to Awaiting User Response Railway • about 1 month ago
a month ago
Follow-up: B only — CAS-protected, two-variable TLS changeset round trip
Thank you. We are retaining the earlier evidence rather than reopening environmentPatchCommit (A). We need a supported engineering/documentation answer for environmentApplyChangeSet (B). No project, variable, pending change or deployment action is requested.
Known client behavior: pinned CLI 5.62.1 passes baseConfigEtag, receives an apply ID and polls environmentChangeSetApply; variable.set/delete are marked deployEffect: deploy, and the apply call does not pass skipDeploys. We therefore do not infer no-deploy behavior from CAS or from a client-edited deployEffect field.
Single contract to confirm: can an explicit changeset, restricted to one existing service and exactly MEMBERSHIP_DATABASE_URL / MEMBERSHIP_DATABASE_CA_CERT, perform BOTH the following under baseConfigEtag without deploying?
- Forward: preserve every credential/target byte of the existing URL except adding the required verify-full TLS mode, and add the approved CA.
- Inverse: with a fresh expected etag after a known settled forward/partial outcome, restore the original URL byte-for-byte and delete only the added CA, restoring true absence.
Please confirm the exact supported request options/schema and applicable API/version, or explicitly identify which condition is unsupported:
- No deployment for either direction, including variable.delete. Does this require a supported option other than deployEffect? We do not assume this pauses independent queued/autodeploy triggers.
- Scope isolation: neither direction applies/clears/rebases unrelated pending changes, replaces the variable collection, or claims/changes IaC ownership. Can this be done as an explicit two-operation changeset without an IaC ownership migration? Intended scope is ordinary service-local variables; sealed/shared/reference variables are excluded rather than converted.
- Settlement and safe inverse: for the returned apply ID, which statuses are terminal with no later writes, and which per-operation results identify completed changes? Is the two-key operation atomic, or can a partially_applied/failed result be reconciled and compensated under a fresh CAS without overwriting another writer? We do not require atomicity if supported terminal/partial-state semantics permit exact safe recovery. A staged result is not being treated as effective committed configuration.
- Unknown submission: if the response is lost AFTER the ID is retained, confirm the supported same-ID read-only reconciliation query. If lost BEFORE any ID is received, is there a supported attempt/idempotency lookup or definitive non-application signal? If not, please say so; our behavior remains STOP, retain the exclusive attempt record, no retry, no speculative inverse and no later deployment.
Please answer this bounded round-trip contract as SUPPORTED / UNSUPPORTED / NOT CONFIRMED, with limitations and a documentation reference or engineering confirmation. We are not requesting an environment-wide staged commit, a configuration change, a test mutation or any Production workaround. No credentials or actual variable values are included.
Status changed to Awaiting Railway Response Railway • about 1 month ago
a month ago
Overall, the round trip you described is UNSUPPORTED, because environmentApplyChangeSet has no option to skip deploys. Variable set and delete changes redeploy the affected service in both directions, and deployEffect is a label on the plan, not a control. The only no-deploy option for variable changes is skipDeploys on environmentPatchCommit.
The other conditions are SUPPORTED. An explicit changeset with only those two variable operations does not need a declared list or an IaC ownership migration. It does not apply, clear or rebase your existing staged changes. It changes only the keys it names and does not replace the rest of the service's variables. A delete removes the key entirely. baseConfigEtag is checked before anything is written, and a mismatch rejects the whole apply with a STALE_ENVIRONMENT_BASE error.
Both changes are committed together as one change, so you should not see one variable land without the other. Poll the returned apply ID with environmentChangeSetApply. applied and failed are the final states. Check each change's own status (noop, applied or failed) rather than only the overall status, because the overall status can read applied even when a change did nothing.
If the response is lost after you have the ID, the same environmentChangeSetApply query reconciles it. If it is lost before you receive an ID, there is no client attempt key or lookup we can confirm, so non-application cannot be established that way.
Status changed to Awaiting User Response Railway • about 1 month ago
24 days ago
This thread has been marked as solved automatically due to a lack of recent activity. Please re-open this thread or create a new one if you require further assistance. Thank you!
Status changed to Solved Railway • 24 days ago