core: Return concrete values for physical names and ARNs if explicitly stated

[melnikalex]

Describe the feature

Re-opening this issue: #4093

❗️There is a problem: CloudFormation references implicitly indicate that there is a dependency between the consuming resource and the referenced resource. If we return a concrete name (string), this dependency will now be lost forever. Is there anything we can do about it? (@rix0rrr?)

A solution to this could be to return physical names only if embedded in a cross-environment stack. Otherwise return the token.

Use Case

Trying to reference resources across environments. This should be possible if I name the resources at compile-time. However cdk always tokenizes it regardless of if a static name is provided or not.

Proposed Solution

No response

Other Information

No response

Acknowledgements

• I may be able to implement this feature request
• This feature might incur a breaking change

CDK version used

latest

Environment details (OS name and version, etc.)

mac

[rittneje]

Even within a single stack, I ought to be able to reference, say, the aws_iam.User.user_name in an if statement without needing an extra variable.

[rix0rrr]

What are you trying to do?

[github-actions]

This issue has not received a response in a while. If you want to keep this issue open, please leave a comment below and auto-close will be canceled.

[rittneje]

@rix0rrr Two days is not "a while". Please fix your GitHub action configuration to be more reasonable.

With regards to your question, we have a shared account in which we have to generate resource names with a unique suffix. (We can't always use the auto-generated names that CDK would pick.) In these situations we sometimes need to later feed this chosen name into some conditional logic. Due to the current way CDK works, the only way to do this is to save the name in a separate variable, which is very annoying. It is part of a larger issue where CDK does not support CloudFormation conditions, only host language ones, which means anything not resolved at synth time is a problem.

[rix0rrr]

I understand why this is frustrating. The problem is it cannot really be solved easily. We need the reference to imply a dependency, but also be readable at synth time. We want both of the following:

const bucket = new Bucket(..., { bucketName: 'deterministic' });

// At deploy time, BucketUser must be sequenced AFTER Bucket
const user = new BucketUser(..., { bucketName: bucket.bucketName });

// But right now, I also want to know the literal value
if (bucket.bucketName !== 'deterministic') {
  throw new Error('But I told you what it was!');
}

There is not a single value we can populate bucket.bucketName with that will satisfy both use cases:

• If we pick 'deterministic', we will fail to imply the deploy-time dependency
  • If we try to invent a magic JavaScript object that behaves like a string but can be uniquely distinguished from other strings, that magic will not survive the jsii-JavaScript transition.
• If we pick the tokenized value, we will fail the if.

Something that might work for you is to use one of:

// Probably works for resources that have properly implemented 'physicalName' support
function physicalNameOf(resource: Resource) {
  const resolvedName = Stack.of(resource).resolve(resource.physicalName);
  if (resolvedName === undefined) {
    throw new Error(`Should have given a physical name to ${source.node.path}`);
  }
  return resolvedName;
}

// Or dig into the L1 properties of each type
function physicalNameOfBucket(bucket: Bucket) {
  const resolvedName = Stack.of(bucket).resolve((resource.node.defaultChild as CfnBucket).bucketName);
  if (resolvedName === undefined) {
    throw new Error(`Bucket needs a physical name ${source.node.path}`);
  }
  return resolvedName;
}

function physicalNameOfUser(bucket: User) { ... }
// etc.

[rix0rrr]

I have been toying with the idea of making bucket.bucketName be a tokenized value that both resolves to a literal value, as well as implies a dependency in all resources where it is used, giving us (mostly) the best of both worlds. You could then get the value you wanted via:

const probablyResolved = stack.resolve(bucket.bucketName); // Either 'deterministic' or { Ref: 'MyBucket' }
if (typeof probablyResolved === 'string') {
  // ... 
}

Which is also not fantastic, but at least slightly more construct-agnostic than the other mechanism.

Not likely to come any time soon though.