I just got off a support chat with AWS, and they seemed to imply that a user could log into the AWS Console using an IAM role (not an IAM user). I don’t see how that’s possible though. anyone know?

anyone know how to get AWS SSO to not timeout my auth every 30 mins?

Don't like the new CDK v2 way of importing. IDE can't resolve for me. Everything is longer. 😞

import { cloudformation_include as cloudformation, aws_iam as iam, aws_s3 as s3, RemovalPolicy } from "aws-cdk-lib";

What would you guys think of an entirely functional api to create stacks:

export async function TableStack(props) {
  const table = new sst.Table(props.stack, ...);

  return { table };
}

export async function StackB(props) {
  const { table } = use(TableStack);
  new sst.Function(props.stack, { environment:  { MYTABLE: table } })
}

It would be totally typesafe + support async functions

What would you guys think of SST stepped a bit more towards offering a backend framework. Nothing crazy and it would be totally modular but basically providing more application level structure instead of just being on the infrastructure side? Is this useful or are you here because you specifically want to handroll everything in the application?

Just curious anyone who uses DynamoDB & does aggregations how do you handle idempotency specifically at high velocity writes. At high speeds updating the same item for aggregation causes a lot of transaction conflicts because Dynamo does not allow 2 transactions to update the same attribute even if you are not doing any condition checking on the update.

ok, I feel like I’m losing my mind 😐 does anyone know why a call to

sfn.StartExecution

would do absolutely nothing? not even throw an error?

try {
        console.log('Starting execution:', JSON.stringify(startExecParams));
        const res = await sfn.send(new StartExecutionCommand(startExecParams));
        console.log('execution result:', JSON.stringify(res));
      } catch (e) {
        console.error('y tho?', e);
      }

one Lambda function calls the function that performs the above code, and it works with no problem. but another Lambda calls the same function and I see “Starting execution” in CloudWatch Logs and that’s it. no error, no “execution result”. I don’t get it. EDIT: forgot an

await

🤦‍♂️

With DynamoDB, say a write takes 1ms then for that period another write with the same key can't happen, so if a second write comes along one microsecond after the first, what happens? Are they serialised up? Or does the second bomb out? The specific reason for asking is this - when performing an updateItem with an ADD action to, say, increment a count attribute, if multiple were executed concurrently would all the updates (including the maths) get carried out sequentially, resulting in the correct final count? Or could the maths get carried out in parallel, so for example if the count started out a 9, could two concurrent calls to increment it result in 10 (because both calls did the sum on the same starting value).

Their approach to testing https://www.serverless.com/cloud/docs/workflows/testing

How do you guys handle running data migrations with dynamo?

"Nhost v2 - The beginning of something big" https://www.nhost.io/blog/nhost-v2-the-beginning-of-something-big

If anyone wants to try the functional stack approach you can paste this code in your application

import * as sst from "@serverless-stack/resources"

export type FunctionalStackProps = {
  app: <http://sst.App|sst.App>
  stack: sst.Stack
}

export type FunctionalStack<T> = (props: FunctionalStackProps) => T

let currentApp: <http://sst.App|sst.App> | undefined = undefined
const cache: Record<string, any> = {}

class EmptyStack extends sst.Stack {
  constructor(scope: <http://sst.App|sst.App>, id: string) {
    super(scope, id)
  }
}

export function createStacks(app: <http://sst.App|sst.App>, ...fns: FunctionalStack<any>[]) {
  currentApp = app
  for (const fn of fns) {
    const name = fn.name.toLowerCase()
    const exists = cache[name]
    if (exists) continue
    const stack = new EmptyStack(app, name)
    const result = fn({
      app,
      stack,
    })
    console.log(`Synthesized stack ${name}`)
    cache[name] = result
  }
}

export function defineStack<T>(cb: FunctionalStack<T>) {
  return cb
}

export function use<T>(stack: FunctionalStack<T>): T {
  if (!currentApp) throw new Error("No app is set")
  const name = stack.name.toLowerCase()
  const exists = cache[name]
  if (exists) return exists
  createStacks(currentApp, stack)
  return use(stack)
}

Can define stacks like this

export function Solid(props: FunctionalStackProps) {
  const api = use(Api)

  new StaticSite(props.stack, "web", {
    path: "solid/app",
    buildCommand: "yarn run build",
    environment: {
      VITE_GRAPHQL_ENDPOINT: api.graphql.url,
    },
  })
}

And in your main make sure you load at least one stack with

createStacks(app, MyStack)

- it'll use dependency injection to load all the ones MyStack depends on

Does anyone know how to make an embedded snippet of Javascript for other peoples websites?

<scripts src="my-cool-embed.bundled.js"></script>

Is that just some kind of minified JS that’s stored in an s3 bucket and the access is by… I guess URL? I don’t really understand the architecture of how something like that would work.

for anyone who uses VS Code: how the heck do I disable auto open quotes when editing HTML? it’s driving me insane 🤪 it suddenly turned on out of nowhere. I can’t find the appropriate setting

Random question: Our analytics collect endpoint is using an API to retrieve IP information (country, state, city). We pay for each request on that service. Generally a normal session will trigger about 5ish events. I’m thinking about some in memory database to store that IP payload for the next hour. What AWS serverless product would you use for that?

Talked about this a long time ago but finally got around to making an open source version of creating Algolia indexes from the CDK if anyone is interested. CDK Version 1: https://www.npmjs.com/package/@garretcharp/cdk-constructs-algolia CDK Version 2: https://www.npmjs.com/package/@garretcharp/cdk-constructs-algolia-v2 Usage:

import { AlgoliaIndex } from '@garretcharp/cdk-constructs-algolia-v2'
import { SecretValue } from 'aws-cdk-lib'

const MyIndex = new AlgoliaIndex(this, 'MyIndex', {
	indexName: `${this.stage}-my-index`,
	// See: <https://www.algolia.com/doc/api-reference/settings-api-parameters>
	settings: {
		searchableAttributes: ['name']
	},
	apiKey: SecretValue.plainText('my-algolia-api-key'),
	appId: 'my-algolia-app-id'
})

If you run into any issues let me know 🙂 Source code: https://github.com/garretcharp/cdk-constructs

Howdy y'all, it's Dillon, the founder of NotionMail. We launched on Product Hunt today (https://www.producthunt.com/posts/notionmail), something we’ve put a lot of care into. ✉️ NotionMail was built 100% with SST 😊 NotionMail will send your Notion pages as HTML emails, right to your recipient’s inboxes. You can make your email right inside of a Notion page, and grab that URL to send to a mailing list you already have setup in a database, or use a simple comma separated list. Best part? There’s no limit on how many emails you can send on NotionMail. Check it out! Product Hunt NotionMail - Send Notion pages as HTML emails | Product Hunt Send Notion pages as Emails ✉️ ⚡ Build your email in Notion with blocks you know 🛠️ Automate with tools like Chilipepper to send emails from form responses 💰 Save over 70% when compared to ConvertKit based on 3K subscribers https://www.producthunt.com/posts/notionmail

hey all, what’s the easiest way to send an alert (of some kind) that a long-running process is complete? like if a user makes an API call, it returns with a 202 (async process). the process completes, and it should somehow let the user know, like via email. is EventBridge the way to go? (one Lambda alerting another one)

Looks like SST may get some love in Corey Quinn's newsletter https://lastweekinaws.slack.com/archives/C02NS8ADMU1/p1643821438916479

The SST Team is doing too many updates! 😛 My side project work consists of just upgrading every time as I don't spend much time on it. But yea, nah, it's been amazing actually! I don't see too many projects with a solid amount of improvements like this! 🙂

It's messed up they didn't shout us out in their earnings report

Always a headache every time I get an email from AWS

I have a lambda function with a graphql server that processes in ~ 1-2ms. If I randomly throw an error in it the response time goes up to to ~150ms. I suspect the amount of delay is correlated with sourcemap size. I believe inspecting or traversing the error as graphql does to generate messages is causing this but need to confirm So now I'm back to recommending disabling --enable-source-maps in production unless you have benchmarked it with exceptions being thrown

@thdxr any other land mines when using graphql with lambda? Do you use AppSync?

hey all! I’ve got an architectural conundrum that i’m trying to figure out, and I’m pretty stuck. here’s the deal: our setup is pretty typical: a primary AWS account running the production SST stack + front end, and multiple AWS sub-accounts for developers with their own SST stacks (but no front end). when someone opens a PR for the front end, AWS Amplify Console deploys a preview branch (e.g.

<http://pr-131.reelcrafter.com|pr-131.reelcrafter.com>

) so we can look at it & test things out. the problem is, ALL front end deployment happens in the production account, and is tied to the GitHub repo. I’m trying to figure out a way for a dev to open a PR, and somehow point that preview instance of the front end to their SST dev stack in their AWS account

Random pro tip:

UpdateUserPool

updates all user pool props not specified in the request back to their default values. Learned the hard way.

Was there a specific reason to remove the default stage key from

sst.json

?

new record for an authentication mandatory API - 1884 req/s. This is crazy damn it. 😂

We’re implementing a webhook from a 3rd party system and I’d like to be able to inspect the header of the request to check for the existence certain headers and their values. I had planned to do this in a lambda authorizer but what I’ve found is that, if the Authorization header is not present, API Gateway rejects the request as unauthorised and the authorisation lambda is never called. Is there a way to do this using lambda authorizers? If not, does anyone have any recommendations?