Skip to content
Serverless batch computing made simple, for TypeScript and JavaScript.
Branch: master
Clone or download
Pull request Compare This branch is 57 commits behind faastjs:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.circleci
.vscode
build
docs
etc
examples
measurements
src
test-perf
test
types
website
.gitignore
CODE_OF_CONDUCT.md
CONTRIBUTING.md
LICENSE
README.md
api-extractor.json
codecov.yml
index.ts
package-lock.json
package.json
tsconfig.json
tslint.json

README.md

faast.js

License CircleCI codecov Codacy Badge

Faast.js dynamically transforms JavaScript modules into scalable serverless functions.

  • Frictionless: Faast.js takes care of packaging your code, setting up IAM roles, and other infrastructure complexity. Run your code on a thousand cores in seconds. All you need is an AWS or GCP account.
  • Scalable: Use serverless functions to scale your batch jobs up to thousands of cores.
  • Cost-effective: Understand and optimize your workload costs in real time. Pay only for compute time actually used.
  • Ephemeral: No clusters or services to manage. Faast.js creates the infrastructure it uses on the fly and cleans up when it's done.
  • Developer optimized: First class support for TypeScript and JavaScript. Type safety, documentation, and extensive testing are part of our DNA.
  • Portable: Built-in support for AWS Lambda and Google Cloud Functions, as well as local processing mode when you don't have network access. Switch with one line of code.

Installation

Faast.js requires node version 8+.

$ npm install faastjs

Example

Export your cloud functions in a module, and invoke faast.js on that module:

// functions.ts
export function hello(name: string) {
    return "hello " + name;
}
// main.ts
import { faast } from "faastjs";
import * as funcs from "./functions";

(async () => {
    const m = await faast("aws", funcs);
    const { hello } = m.functions;
    const result = await hello("world!");
    console.log(result);
    await m.cleanup();
})();

Make 1000 concurrent calls if you like:

const promises: string[] = [];
for (let i = 0; i < 1000; i++) {
    promises.push(hello(`world ${i}!`));
}
await Promise.all(promises);

Hold on! How much did that cost?

const cost = await m.costSnapshot();
console.log(cost);

Relax. It's just half a penny:

functionCallDuration  $0.00002813/second          102.0 seconds    $0.00286876    68.2%  [1]
sqs                   $0.00000040/request          1276 requests   $0.00051040    12.1%  [2]
sns                   $0.00000050/request          1000 requests   $0.00050000    11.9%  [3]
functionCallRequests  $0.00000020/request          1000 requests   $0.00020000     4.8%  [4]
outboundDataTransfer  $0.09000000/GB         0.00143808 GB         $0.00012943     3.1%  [5]
logIngestion          $0.50000000/GB                  0 GB         $0              0.0%  [6]
---------------------------------------------------------------------------------------
                                                                   $0.00420858 (USD)

It's that easy.

Ready to learn more?

Check out our website, documentation or detailed API.

Contributing

See contributing

You can’t perform that action at this time.