I don't understand the document in the section Referencing SST stack outputs in other SST stacks It says in

stackA.js

this.bucket = new s3.Bucket(this, "MyBucket");

And in

stackB.js

// stackA's bucket is passed to stackB
const { bucket } = this.props;
// SST will implicitly set the exports in stackA
// and imports in stackB
bucket.bucketArn;

Is the

bucket

props passed automatically to stackB? Don't we have to do something like following?

const stackA = new StackA(app, 'stack-a');
new StackB(app, 'stack-b', { bucket: stackA.bucket });

Pavan, you are correct. You can find a more explicit example in the guide here: https://serverless-stack.com/chapters/add-an-api-to-create-a-note.html

That make sense. But when I have following code, typescript typechecking throws error.

new StackB(app, 'stack-b', { bucket: stackA.bucket });

Argument of type '{ bucket: string; }' is not assignable to parameter of type 'StackProps'.

Hey @Pavan Kumar, if you are using TypeScript, you’d need to define a Props that extends

StackProps

like this:

interface StackBProps extends StackProps {
  readonly bucket: sst.Bucket;
}

You an find an example here of sharing an

sst.Api

across stack, but the idea is the same for sharing an

sst.Table

.

This way makes most sense.

constructor(scope: App, id: string, bucket: sst.Bucket, props?: StackProps)

I find it is more handy when you are writing in pure js less so for ts

You don't need to pass stackprops if you're not overriding any of the settings in it

What I meant is, if props is meant to send custom props (not strictly StackProps), then we should have different type instead of

StackProps

May be something like this.

interface GenericProps {
   [key: string]: any;
}

type NewStackProps = StackProps && GenericProps

Then the Stack constructer would have following signature.

new Stack(scope: Construct, id: string, props: NewStackProps)

I agree those types should be kept separate but there's many ways you can do this so comes down to personal preference