Skip to main content
100%

get-departure-step-fn

✓ Published0🌍 Public
Aandresmijares
Last edited Apr 3, 2018
Created on Apr 3, 2018

This example shows an AWS Lambda function that triggers a Step Functions state machine to fetch departure data for a given ID and date. It lists all state machines, filters for one named `GetDepartureMachine`, and starts an execution with the query parameters as JSON input. The code uses the AWS SDK for JavaScript (`aws-sdk`) with `AWS.StepFunctions`, `co` for generator-based control flow, and `Promise` from Bluebird. It returns the execution ARN in an HTTP response, logging “finish” before invoking the callback.

AI-generated description

Similar vizzes

Loading thumbnail…

get step function status

This example shows the status of a Step Functions execution by extracting the departure forecast from its event history. It queries the execution history using the AWS SDK’s `StepFunctions.getExecutionHistory` method, then filters for `PassStateEntered` events to parse the flight and forecast data embedded in the state input. The handler, written with `co.wrap` and Bluebird promises, returns the execution ARN and the parsed departure object as a JSON response via an API Gateway Lambda trigger.

Aandresmijares
75% match
Loading thumbnail…

Lambda triggers other lambdas

This example shows how one AWS Lambda function orchestrates two other Lambda functions to compose a departure response. The `get-departure.js` handler receives query parameters for an `id` and `date`, then invokes `get-flight` and `get-forecast` functions concurrently using the AWS SDK’s `Lambda.invoke` API with `InvocationType: "RequestResponse"`. It uses Bluebird’s `Promise.all` to await both payloads, parses each JSON response, and returns a combined `departure` object containing the forecast and flight data. The code demonstrates a saga-style pattern for coordinating dependent serverless calls.

Aandresmijares
69% match
Loading thumbnail…

Gist ef99831492181718c41fd4331d226a74

This example shows the control flow of an AWS Step Functions state machine that checks a date before deciding whether to update a Fantasy Premier League team. A chain of AWS Lambda functions retrieves player odds and details, calculates transfers, and posts updates to the team. The visualization uses the state machine’s declarative JSON definition to map states and transitions, including a choice point that branches to a success state or continues to further tasks. It relies on the Step Functions API for orchestration, not on a separate plotting library.

CConorAspell
68% match
Loading thumbnail…

Step Machine definition

This example visualizes the structure of an AWS Step Functions state machine definition, showing how parallel branches and sequential states compose a workflow. The rendered diagram maps the YAML configuration from a serverless.yml file, displaying the “Parallel” state that splits into two concurrent tasks—GetFlight and GetForecast—before converging at the FinalState. The visualization uses the Step Functions definition’s explicit StartAt, Type, Next, and End fields to determine node placement and edge routing. It relies on the serverless framework’s stepFunctions configuration to parse the state machine’s branching logic, with resource ARNs referencing Lambda functions for each task.

Aandresmijares
68% match
Loading thumbnail…

Gist ed5c09d69d4e5d65c6ec5faafaea7e08

This example shows an AWS Step Functions state machine that automates a two-step data pipeline for controlling Fantasy Premier League updates. The workflow first invokes an `oddsGetter` Lambda function to fetch betting odds, then passes the result to a `storeFPLData` Lambda function, which persists the data and ends the process. The visualization uses the Step Functions JSON state machine definition to render the sequential task flow, with explicit `Resource` ARNs linking to the Lambda functions. The graph displays the `StartAt` and `End` states, making the linear execution path and the service integrations clear without showing runtime behavior or intermediate data handling.

CConorAspell
66% match
Loading thumbnail…

Gist 4523b841021e154daebbf9c9bccaae7b

This visualization is a linear flow diagram of an AWS Step Functions state machine that orchestrates a Fantasy Premier League update. It shows three sequential tasks—DateChecker, OddsGetter, and UpdateFPLTeam—each represented as a labeled node with a resource ARN. The diagram uses rectangular and rounded-rectangle shapes connected by arrows to indicate execution order, with the final node marked as terminal. The underlying JSON definition (visible in the accompanying file) defines the state transitions, while the rendered view likely employs a graph layout library such as D3.js or a similar tool to position nodes and edges. The data source is the embedded stateMachine.txt file, which exposes the exact Lambda function names and control flow.

CConorAspell
60% match
Loading thumbnail…

Automation with AWS Lambda

This example shows how to automate data scraping and publishing to an S3 bucket using AWS Lambda. The Python handler function calls a scraper, processes the returned data, and uploads it as a JSON file to a specified S3 path with public-read access. It uses the `boto3` library for S3 interactions, `json` for serialization, and `os` for path handling. The setup also demonstrates local testing via `service.py` and deployment through the Python-lambda tool, with CloudWatch Events scheduling for recurring triggers.

LLayne Smith
53% match
Loading thumbnail…

Generated by XState Viz: https://xstate.js.org/viz

This example shows a login state machine built with XState, modeled as an explicit statechart with idle, loading, success, and failure states. It demonstrates asynchronous data fetching by invoking a `fetchJwt` function that retrieves a JSON Web Token from a remote URL. The machine uses the `invoke` property with `onDone` and `onError` transitions, assigning the returned user data or an error to the context via the `assign` action. The visualization, generated by XState Viz, renders the statechart diagram from the `machine.js` source file, highlighting how state transitions and async side effects are encoded in the machine definition.

Aadamscott
52% match