@architect/functions
Version:
Runtime utility library for Functional Web Apps (FWAs) built with Architect (https://arc.codes)
137 lines (124 loc) • 4.56 kB
text/typescript
import type { AwsLiteClient } from "@aws-lite/client"
import type { GetConnectionResponse } from "@aws-lite/apigatewaymanagementapi-types";
import type { PublishResponse } from "@aws-lite/sns-types"
import type { SendMessageResponse } from "@aws-lite/sqs-types"
import type { Context } from "aws-lambda";
import { expectType, expectAssignable, expectNotAssignable } from "tsd";
import arc from "../";
import type { HttpHandler, HttpAsyncHandler } from "../"
import type { HttpMethods, HttpRequest, HttpResponse } from "./http";
// SERVICES
const servicesResult = await arc.services();
expectType<Record<string, any>>(servicesResult);
// EVENTS
const eventsPublishArg = { name: "test", payload: { foo: "bar" } };
const eventsPublishResult = await arc.events.publish(eventsPublishArg);
expectType<PublishResponse>(eventsPublishResult);
// QUEUES
const queuesPublishArg = { name: "test", payload: { foo: "bar" } };
const queuesPublishResult = await arc.queues.publish(queuesPublishArg);
expectType<SendMessageResponse>(queuesPublishResult);
// HTTP
const middleware: HttpHandler = (req, res, next) => {
expectType<HttpRequest>(req);
expectType<(p: HttpResponse | Error) => void>(res);
expectType<() => void>(next);
// doing nothing is valid middleware
next();
};
const asyncMiddleware: HttpAsyncHandler = async (req, ctx) => {
expectType<HttpRequest>(req);
expectType<Context>(ctx);
// doing nothing is valid middleware
await (new Promise((resolve) => resolve('foo')));
}
// default callback pattern
arc.http(function (req, res) {
expectType<HttpRequest>(req);
expectType<boolean>(req.isBase64Encoded);
expectType<(p: HttpResponse | Error) => void>(res);
const responseValue: HttpResponse = { json: { foo: "bar" } };
expectAssignable<Record<string, any> | undefined>(responseValue.session);
expectNotAssignable<string>(responseValue.status);
return res(responseValue);
});
// with middleware
arc.http(middleware, function (req, res) {
return res({ json: { foo: "bar" } });
});
// async pattern
arc.http(async function (req, ctx) {
expectType<HttpRequest>(req);
expectType<Context>(ctx);
const response: HttpResponse = { html: "<h1>types</h1>" };
return response;
} as HttpAsyncHandler);
// with async middleware
arc.http(asyncMiddleware, <HttpAsyncHandler>async function (req, ctx) {
return { text: "types" };
});
// legacy async
arc.http.async(asyncMiddleware, async function (req, ctx) {
expectType<HttpRequest>(req);
expectType<string>(req.path);
expectType<Context>(ctx);
const response: HttpResponse = { html: "<h1>types</h1>" };
expectAssignable<number | undefined>(response.status);
expectNotAssignable<string>(response.session);
return response;
});
const sampleRequest = {
httpMethod: "POST" as HttpMethods,
method: "POST" as HttpMethods,
path: "/",
resource: "",
pathParameters: { foo: "bar" },
params: { foo: "bar" },
queryStringParameters: { bar: "baz" },
query: { bar: "baz" },
headers: { accept: "any" },
body: "undefined",
rawBody: "undefined",
isBase64Encoded: false,
version: "42",
};
expectType<Record<string, any>>(arc.http.helpers.bodyParser(sampleRequest));
expectType<HttpRequest>(arc.http.helpers.interpolate(sampleRequest));
expectType<string>(arc.http.helpers.url("/foobar-baz"));
// STATIC
expectType<string>(arc.static("/my-image.png"));
arc.static("/", { stagePath: false });
// TABLES
const dbClient = await arc.tables()
expectType<AwsLiteClient["DynamoDB"]>(dbClient._client)
expectType<string>(dbClient.name('widgets'))
expectType<Record<string, string>>(dbClient.reflect())
const myTable = dbClient.foobar
const id42 = await myTable.get({ id: 42 })
await myTable.update({
Key: { id: 42 },
UpdateExpression: 'ADD radness :inc',
ExpressionAttributeValues: { ':inc': 1 },
})
await myTable.put({ id: 42, put: true })
await myTable.delete({ id: 42 })
await myTable.query({
IndexName: 'fooByBar',
KeyConditionExpression: 'bar = :bar',
ExpressionAttributeValues: { ':bar': 'baz' },
})
await myTable.scan({
FilterExpression: 'radness > :ninethousand',
ExpressionAttributeValues: { ':ninethousand': 9000 },
})
await myTable.scanAll({
FilterExpression: 'radness > :ninethousand',
ExpressionAttributeValues: { ':ninethousand': 9000 },
})
// WS
expectType<AwsLiteClient["ApiGatewayManagementApi"]>(await arc.ws._api());
expectType<void>(await arc.ws.send({ id: "foo", payload: { bar: "baz" } }));
expectType<void>(await arc.ws.close({ id: "foo" }));
expectType<GetConnectionResponse>(
await arc.ws.info({ id: "foo" }),
);