the created lambda looks like:

exports.handler = __f0;

var __exports = {};

var __secret = {};

var __secret_arn_proto = {};

__f1.prototype = __secret_arn_proto;

Object.defineProperty(__secret_arn_proto, "constructor", { configurable: true, writable: true, value: __f1 });

Object.defineProperty(__secret_arn_proto, "apply", { configurable: true, writable: true, value: __f2 });

Object.defineProperty(__secret_arn_proto, "get", { configurable: true, writable: true, value: __f3 });

var __secret_arn = Object.create(__secret_arn_proto);

__secret_arn.value = "arn:aws:secretsmanager:us-east-2:485017757204:secret:macsdb_password-d28f2fe-bTXrLB";

__secret.arn = __secret_arn;

var __db = {};

var __db_arn = Object.create(__secret_arn_proto);

__db_arn.value = "arn:aws:rds:us-east-2:485017757204:cluster:tf-20200709154701156900000001";

__db.arn = __db_arn;

function __f1(__0) {

return (function() {

with({  }) {

return function /*constructor*/(value) {

this.value = value;

};

}

}).apply(undefined, undefined).apply(this, arguments);

}

function __f2(__0) {

return (function() {

with({  }) {

return function /*apply*/(func) {

throw new Error("'apply' is not allowed from inside a cloud-callback. Use 'get' to retrieve the value of this Output directly.");

};

}

}).apply(undefined, undefined).apply(this, arguments);

}

function __f3() {

return (function() {

with({  }) {

return function /*get*/() {

return this.value;

};

}

}).apply(undefined, undefined).apply(this, arguments);

}

function __f0(__0) {

return (function() {

with({ exports: __exports, secret: __secret, db: __db }) {

return async (event) => {

const AWS = require("aws-sdk");

exports.handler = async function (event, context, callback) {

const data = require("data-api-client")({

secretArn: secret.arn,

resourceArn: db.arn,

database: "macsgameboard", // default database

region: "us-east-2",

});

`return data.query(

call getmiscdata();

);`

};

};

}

}).apply(undefined, undefined).apply(this, arguments);

}

strange, right?

not sure why its adding all the extra crap, @faint-motherboard-95438

Feels like related to `Input`/`Output` again though. What’s the types of

secret.arn

and

db.arn

?

how do i find out?

im hard coding right now and same thing:

secretArn: "arnawssecretsmanagerus east 2485017757204㊙️rds-db-credentials/cluster-OIUG4EBTF7YZQN73YWXAOI3A64/admin-99EhqD", resourceArn: "arnawsrdsus east 2485017757204clustertf-20200709154701156900000001",

ultimately this is the entirity of the lambda code:

const data = require("data-api-client")({ secretArn: "arnawssecretsmanagerus east 2485017757204㊙️rds-db-credentials/cluster-OIUG4EBTF7YZQN73YWXAOI3A64/admin-99EhqD", resourceArn: "arnawsrdsus east 2485017757204clustertf-20200709154701156900000001", database: "macsgameboard", // default database region: "us-east-2", }); return data.query(

call getmiscdata();

);

its really s trange

@faint-table-42725 is it easy to implement cors on a rest api gateway?

Normally there would just be an enable_cors option in cf

As you point out, in Cloudformation, it’s easier since you can use SAM templates, which simply exposes a

CorsConfiguration

If you wanted to work with the HTTP API type in API Gateway, you could alternatively use https://www.pulumi.com/docs/reference/pkg/aws/apigatewayv2/api/

so its apigatewayv1

I am lost @faint-table-42725, i have everything else working but cors

I would try to at least get that working since the lambda it providers on

OPTIONS

is simply what the mock integration would typicall do

And then if you look at https://www.pulumi.com/docs/reference/pkg/aws/apigateway/integration/#example-usage — there’s a MOCK integration example at the end

which you’ll pair with an integration response: https://www.pulumi.com/docs/reference/pkg/aws/apigateway/integrationresponse/

The example in the integration response doc has and end-to-end 200 mock integration response

You would need to cross-ref the doc I pointed out earlier around the appropriate CORS headers to return

You could also simply use code abstractions, too, to do what you want, e.g. create a function in your code like

makeCorsPath(…)

which takes the appropriate args and generates all the relevant resources

so something like:

function enableCorsForPath(path: string) {
    new Method(`${name}-options`), { ... });
    new Integration(`${name}-integration`, { ... });
    ...
}

and then anything you want to enable cors on a path, just include

enableCorsForPath("/api/path")

in your Pulumi program

so basically build out what they have on that example but for cors

which is just headers that it needs to return

but i cant wrap my head around it even though you skeletoned it out

In the case we’re talking about, the way I think about it is this: I have some Lambda callback integration (e.g.

GET

on some path

/foo

) and so my Lambda must return the appropriate headers in its response. This is easy. I just have to include that in my response, e.g.

return {
    statusCode: 200,
    headers: {
        "Access-Control-Allow-Headers" : "Content-Type",
        "Access-Control-Allow-Origin": "<https://www.example.com>",
        "Access-Control-Allow-Methods": "OPTIONS,POST,GET"
    },
    body: JSON.stringify(resp),
}

Now, the harder part, we have to account for the preflight

OPTIONS

request that a browser is going to send us

We could do it the easy way (what I suggested getting working first)

Which is to simply add another Lambda callback integration on

OPTIONS

which simply returns the headers with an empty body

So it would look very similar to your actual function, sans any business logic and returning an empty body.

Now, if you want to do it the “API Gateway Way (tm)” you can do what we just discussed — setup a mock integration for

OPTIONS

on that path instead, which involves having the

IntegrationResponse

etc.

If you’re going to be setting up multiple paths with CORS, it’s easiest to wrap that either in a

ComponentResource

or some other abstraction (say a function in your program itself) that will give you back a thing that encapsulates what we just talked about — either creating the simple Lambda callback that returns the headers w/ empty body or the set of various API Gateway resources (Resource, Integration, Method, IntegrationResponse) to give back the correct mock response.

the lambda that is

function enableCorsForPath(name) {

`const resource = new aws.apigateway.Resource(

"${name}-resource

, {`

parentId: api.rootResourceId,

pathPart: name,

restApi: api.id,

});

`const method = new aws.apigateway.Method(

"${name}-method"

, {`

authorization: "NONE",

httpMethod: "GET",

resourceId: resource.id,

restApi: api.id,

});

`const integration = new aws.apigateway.Integration(

${name}-integration

, {`

httpMethod: method.httpMethod,

resourceId: resource.id,

restApi: api.id,

type: "MOCK",

});

const response200 = new aws.apigateway.MethodResponse("response_200", {

httpMethod: method.httpMethod,

resourceId: resource.id,

restApi: api.id,

statusCode: "200",

});

const integrationresponse = new aws.apigateway.IntegrationResponse(

``${name}-integrationresponse`,`

{

httpMethod: method.httpMethod,

resourceId: resource.id,

// Transforms the backend JSON response to XML

responseTemplates: {},

restApi: api.id,

statusCode: response200.statusCode,

headers: {

"Access-Control-Allow-Headers": "Content-Type",

"Access-Control-Allow-Origin": "*",

"Access-Control-Allow-Methods": "OPTIONS,POST,GET",

},

}

);

}

my resource says its missing parentId but its right there

But I can totally see something along the lines of the above working and then you can totally refactor more and more later

One thing you’ll probably want to take a look at is either

ComponentResource

or

parent

so that you can nest some resources of these w/in your resource graph