cdk-serverless 1.1.44 → 2.0.0

package/lib/lambda/auth.d.ts

@@ -0,0 +1,144 @@
+import logger from 'lambda-log';
+/**
+ * A generic JWT authorizer base class, presupposing the presence of an issuer, a number of authorization claims, an
+ * admin permission claim and optionally a separate URL to a JWKS to use if the issuers well-known URL does not
+ * point to it in its metadata.
+ */
+export declare abstract class JwtAuthorizer {
+    protected issuerUrl: string;
+    protected groupClaim: string;
+    protected adminClaim: string;
+    protected jwksUrl?: string | undefined;
+    /**
+     * The claims of the authenticated user.
+     */
+    protected claims?: {
+        [name: string]: string | number | boolean | string[];
+    };
+    protected constructor(issuerUrl: string, groupClaim: string, adminClaim: string, jwksUrl?: string | undefined);
+    /**
+     * Returns an array of groups the user belongs to, or an empty array if the user
+     * is not authenticated or has no groups.
+     */
+    getGroups(): string[];
+    /**
+     * Returns true if the user belongs to the specified group, false otherwise.
+     * @param group The name of the group to check.
+     */
+    hasGroup(group: string): boolean;
+    /**
+     * Authenticates the user and sets the claims.
+     */
+    abstract authenticate(): Promise<void>;
+    /**
+     * Returns true if the user is authenticated, false otherwise.
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Throws an UnauthenticatedError if the user is not authenticated.
+     */
+    assertAuthenticated(): void;
+    /**
+     * Throws a ForbiddenError if the user is not authenticated or does not belong
+     * to the specified group.
+     * @param group The name of the group to check.
+     */
+    assertGroup(group: string): void;
+    /**
+     * Returns true if the user belongs to the 'admin' group, false otherwise.
+     */
+    isAdmin(): boolean;
+    /**
+     * Throws a ForbiddenError if the user is not authenticated or is not an admin.
+     */
+    assertAdmin(): void;
+    /**
+     * Returns the email of the authenticated user.
+     */
+    getEMail(): string;
+    /**
+     * Returns the subject of the authenticated user.
+     */
+    getSubject(): string;
+    /**
+     * Returns the value of the claim with the specified name, or undefined if the
+     * claim does not exist.
+     * @param name The name of the claim to retrieve.
+     */
+    getClaim(name: string): string | number | boolean | string[] | undefined;
+}
+/**
+ * CognitoAuthorizer is an abstract class representing an authorizer
+ * that can be used to authenticate and authorize a user through Cognito.
+ */
+export declare abstract class CognitoAuthorizer extends JwtAuthorizer {
+    protected constructor();
+}
+/**
+ * Implements authorization on API Gateway v1 (Rest API) using JWT.
+ */
+export declare class ApiGatewayv1JwtAuthorizer extends JwtAuthorizer {
+    protected event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;
+    protected _logger: logger.LambdaLog;
+    constructor(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, //FIXME: Learn about possible requestContext.authorizer sources in API gateway
+    adminClaim: string, _logger: logger.LambdaLog);
+    /**
+     * Authenticates the user using the claims provided by the API Gateway event or
+     * by decoding a JWT token from the 'Authorization' header.
+     */
+    authenticate(): Promise<void>;
+}
+/**
+ * Implements JWT Authorization on API Gateway v2 (HTTP API).
+ */
+export declare class ApiGatewayv2JwtAuthorizer extends JwtAuthorizer {
+    protected event: AWSLambda.APIGatewayProxyEventV2WithJWTAuthorizer;
+    protected _logger: logger.LambdaLog;
+    constructor(event: AWSLambda.APIGatewayProxyEventV2WithJWTAuthorizer, _logger: logger.LambdaLog);
+    /**
+     * Authenticates the user using the claims provided by the API Gateway event or
+     * by decoding a JWT token from the 'Authorization' header.
+     */
+    authenticate(): Promise<void>;
+}
+/**
+ * ApiGatewayv1CognitoAuthorizer is a specialization of an ApiGatewayv1JwtAuthorizer
+ * and implements authentication logic for API Gateway v1 requests when using Cognito..
+ */
+export declare class ApiGatewayv1CognitoAuthorizer extends ApiGatewayv1JwtAuthorizer {
+    protected event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;
+    protected _logger: logger.LambdaLog;
+    /**
+     * The event that triggered the authorization check.
+     */
+    constructor(event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, _logger: logger.LambdaLog);
+}
+/**
+ * ApiGatewayv2CognitoAuthorizer is a class that extends CognitoAuthorizer
+ * and implements authentication logic for API Gateway v2 requests with a
+ * JWT authorizer.
+ */
+export declare class ApiGatewayv2CognitoAuthorizer extends ApiGatewayv2JwtAuthorizer {
+    protected event: AWSLambda.APIGatewayProxyEventV2WithJWTAuthorizer;
+    protected _logger: logger.LambdaLog;
+    /**
+     * The event that triggered the authorization check.
+     */
+    constructor(event: AWSLambda.APIGatewayProxyEventV2WithJWTAuthorizer, _logger: logger.LambdaLog);
+}
+/**
+ * AppSyncCognitoAuthorizer is a class that extends CognitoAuthorizer
+ * and implements authentication logic for AppSync resolver events with a
+ * Cognito authorizer.
+ */
+export declare class AppSyncCognitoAuthorizer extends CognitoAuthorizer {
+    protected event: AWSLambda.AppSyncResolverEvent<any>;
+    /**
+     * The event that triggered the authorization check.
+     */
+    constructor(event: AWSLambda.AppSyncResolverEvent<any>);
+    /**
+     * Authenticates the user using the claims provided by the AppSync event.
+     */
+    authenticate(): Promise<void>;
+}

package/lib/lambda/auth.js

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b, _c, _d, _e;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppSyncCognitoAuthorizer = exports.ApiGatewayv2CognitoAuthorizer = exports.ApiGatewayv1CognitoAuthorizer = exports.ApiGatewayv2JwtAuthorizer = exports.ApiGatewayv1JwtAuthorizer = exports.CognitoAuthorizer = exports.JwtAuthorizer = void 0;
+const process_1 = require("process");
+const axios_1 = __importDefault(require("axios"));
+const jsonwebtoken_1 = require("jsonwebtoken");
+const jwk_to_pem_1 = __importDefault(require("jwk-to-pem"));
+const errors_1 = require("./errors");
+const cognitoPoolId = (_a = process_1.env.USER_POOL_ID) !== null && _a !== void 0 ? _a : '';
+const cognitoPoolRegion = (_c = (_b = process_1.env.USER_POOL_REGION) !== null && _b !== void 0 ? _b : process_1.env.AWS_REGION) !== null && _c !== void 0 ? _c : 'eu-central-1';
+const jwtIssuerUrl = cognitoPoolId ? `https://cognito-idp.${cognitoPoolRegion}.amazonaws.com/${cognitoPoolId}` : ((_d = process_1.env.JWT_ISSUER_URL) !== null && _d !== void 0 ? _d : '');
+const jwtJwksUrl = cognitoPoolId ? `${jwtIssuerUrl}/.well-known/jwks.json` : process_1.env.JWT_JWKS_URL;
+const jwtGroupClaim = cognitoPoolId ? 'cognito:groups' : ((_e = process_1.env.JWT_GROUP_CLAIM) !== null && _e !== void 0 ? _e : '');
+const jwtAudience = (process_1.env.JWT_AUDIENCE_URL && process_1.env.JWT_AUDIENCE_URL.length > 0) ? process_1.env.JWT_AUDIENCE_URL.split('||') : undefined;
+let cacheKeys;
+const getPublicKeys = async (jwksUrl) => {
+    if (!cacheKeys) {
+        const publicKeys = (await axios_1.default.get(jwksUrl)).data;
+        cacheKeys = publicKeys.keys.reduce((agg, current) => {
+            const pem = (0, jwk_to_pem_1.default)(current);
+            agg[current.kid] = { instance: current, pem };
+            return agg;
+        }, {});
+        return cacheKeys;
+    }
+    else {
+        return cacheKeys;
+    }
+};
+// Grab the JWKS URI from the JWT issuer's metadata
+const getJwksUri = async (discoveryUri, jwksUri) => {
+    if (jwksUri) {
+        return jwksUri;
+    }
+    const wellKnownUri = `${discoveryUri}/.well-known`;
+    const issuerMetadata = (await axios_1.default.get(wellKnownUri)).data;
+    if (!issuerMetadata.jwks_uri) {
+        throw new Error('Issuer does not offer JWKS endpoint');
+    }
+    return issuerMetadata.jwks_uri;
+};
+const promisedVerify = (token, issuerUri, jwksUri) => {
+    return new Promise((resolve, reject) => {
+        (0, jsonwebtoken_1.verify)(token, (header, cb) => {
+            if (!header.kid) {
+                cb(new Error('no key id found'));
+            }
+            getJwksUri(issuerUri, jwksUri).then(getPublicKeys).then((keys) => {
+                cb(null, keys[header.kid].pem);
+            }, cb);
+        }, { issuer: issuerUri, audience: jwtAudience }, (err, decoded) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(decoded);
+            }
+        });
+    });
+};
+/**
+ * A generic JWT authorizer base class, presupposing the presence of an issuer, a number of authorization claims, an
+ * admin permission claim and optionally a separate URL to a JWKS to use if the issuers well-known URL does not
+ * point to it in its metadata.
+ */
+class JwtAuthorizer {
+    constructor(issuerUrl, groupClaim, adminClaim, jwksUrl) {
+        this.issuerUrl = issuerUrl;
+        this.groupClaim = groupClaim;
+        this.adminClaim = adminClaim;
+        this.jwksUrl = jwksUrl;
+    }
+    /**
+     * Returns an array of groups the user belongs to, or an empty array if the user
+     * is not authenticated or has no groups.
+     */
+    getGroups() {
+        if (!this.isAuthenticated() || !this.claims.hasOwnProperty(this.groupClaim)) {
+            return [];
+        }
+        return this.claims[this.groupClaim];
+    }
+    /**
+     * Returns true if the user belongs to the specified group, false otherwise.
+     * @param group The name of the group to check.
+     */
+    hasGroup(group) {
+        // 'cognito:groups': [ 'admin' ],
+        return this.getGroups().includes(group);
+    }
+    /**
+     * Returns true if the user is authenticated, false otherwise.
+     */
+    isAuthenticated() {
+        return this.claims !== undefined;
+    }
+    /**
+     * Throws an UnauthenticatedError if the user is not authenticated.
+     */
+    assertAuthenticated() {
+        if (!this.isAuthenticated()) {
+            throw new errors_1.UnauthenticatedError();
+        }
+    }
+    /**
+     * Throws a ForbiddenError if the user is not authenticated or does not belong
+     * to the specified group.
+     * @param group The name of the group to check.
+     */
+    assertGroup(group) {
+        this.assertAuthenticated();
+        if (!this.hasGroup(group)) {
+            throw new errors_1.ForbiddenError();
+        }
+    }
+    /**
+     * Returns true if the user belongs to the 'admin' group, false otherwise.
+     */
+    isAdmin() {
+        return this.hasGroup(this.adminClaim);
+    }
+    /**
+     * Throws a ForbiddenError if the user is not authenticated or is not an admin.
+     */
+    assertAdmin() {
+        this.assertGroup(this.adminClaim);
+    }
+    /**
+     * Returns the email of the authenticated user.
+     */
+    getEMail() {
+        this.assertAuthenticated();
+        return this.claims.email;
+    }
+    /**
+     * Returns the subject of the authenticated user.
+     */
+    getSubject() {
+        this.assertAuthenticated();
+        return this.claims.sub;
+    }
+    /**
+     * Returns the value of the claim with the specified name, or undefined if the
+     * claim does not exist.
+     * @param name The name of the claim to retrieve.
+     */
+    getClaim(name) {
+        this.assertAuthenticated();
+        return this.claims[name];
+    }
+}
+exports.JwtAuthorizer = JwtAuthorizer;
+/**
+ * CognitoAuthorizer is an abstract class representing an authorizer
+ * that can be used to authenticate and authorize a user through Cognito.
+ */
+class CognitoAuthorizer extends JwtAuthorizer {
+    constructor() {
+        super(jwtIssuerUrl, jwtGroupClaim, 'admin');
+    }
+}
+exports.CognitoAuthorizer = CognitoAuthorizer;
+/**
+ * Implements authorization on API Gateway v1 (Rest API) using JWT.
+ */
+class ApiGatewayv1JwtAuthorizer extends JwtAuthorizer {
+    constructor(event, //FIXME: Learn about possible requestContext.authorizer sources in API gateway
+    adminClaim, _logger) {
+        super(jwtIssuerUrl, jwtGroupClaim, adminClaim, jwtJwksUrl);
+        this.event = event;
+        this._logger = _logger;
+    }
+    /**
+     * Authenticates the user using the claims provided by the API Gateway event or
+     * by decoding a JWT token from the 'Authorization' header.
+     */
+    async authenticate() {
+        // Could be almost the exact same code as Cognito if we can specify our own Authorizer in the event's request context
+        if (this.event.requestContext.authorizer && this.event.requestContext.authorizer.claims) {
+            this.claims = this.event.requestContext.authorizer.claims;
+        }
+        if (this.claims) {
+            return;
+        }
+        const authHeader = this.event.headers.authorization;
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return;
+        }
+        const token = authHeader.substring('Bearer '.length);
+        // Verify the token and set the claims on the event and this object
+        try {
+            const claims = await promisedVerify(token, this.issuerUrl, this.jwksUrl);
+            this._logger.debug(JSON.stringify(claims));
+            this.event.requestContext.authorizer = { claims };
+            this.claims = claims;
+        }
+        catch (err) {
+            this._logger.error(err);
+        }
+    }
+}
+exports.ApiGatewayv1JwtAuthorizer = ApiGatewayv1JwtAuthorizer;
+/**
+ * Implements JWT Authorization on API Gateway v2 (HTTP API).
+ */
+class ApiGatewayv2JwtAuthorizer extends JwtAuthorizer {
+    constructor(event, _logger) {
+        super(jwtIssuerUrl, 'cognito:groups', 'admin', jwtJwksUrl);
+        this.event = event;
+        this._logger = _logger;
+    }
+    /**
+     * Authenticates the user using the claims provided by the API Gateway event or
+     * by decoding a JWT token from the 'Authorization' header.
+     */
+    async authenticate() {
+        var _a, _b;
+        // Try to get the claims from the event
+        this.claims = (_b = (_a = this.event.requestContext.authorizer) === null || _a === void 0 ? void 0 : _a.jwt) === null || _b === void 0 ? void 0 : _b.claims;
+        // If no pool ID is defined or claims exist, return early
+        if (!cognitoPoolId || this.claims) {
+            return;
+        }
+        // Extract the token from the Authorization header
+        const authHeader = this.event.headers.authorization;
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return;
+        }
+        const token = authHeader.substring('Bearer '.length);
+        // Verify the token and set the claims on the event and this object
+        try {
+            const claims = await promisedVerify(token, this.issuerUrl, this.jwksUrl);
+            this._logger.debug(JSON.stringify(claims));
+            this.event.requestContext.authorizer = {
+                jwt: {
+                    claims,
+                    scopes: ['openid', 'email'],
+                },
+                integrationLatency: 0,
+                principalId: 'toolbox',
+            };
+            this.claims = claims;
+        }
+        catch (err) {
+            this._logger.error(err);
+        }
+    }
+}
+exports.ApiGatewayv2JwtAuthorizer = ApiGatewayv2JwtAuthorizer;
+/**
+ * ApiGatewayv1CognitoAuthorizer is a specialization of an ApiGatewayv1JwtAuthorizer
+ * and implements authentication logic for API Gateway v1 requests when using Cognito..
+ */
+class ApiGatewayv1CognitoAuthorizer extends ApiGatewayv1JwtAuthorizer {
+    /**
+     * The event that triggered the authorization check.
+     */
+    constructor(event, _logger) {
+        super(event, 'admin', _logger);
+        this.event = event;
+        this._logger = _logger;
+    }
+}
+exports.ApiGatewayv1CognitoAuthorizer = ApiGatewayv1CognitoAuthorizer;
+/**
+ * ApiGatewayv2CognitoAuthorizer is a class that extends CognitoAuthorizer
+ * and implements authentication logic for API Gateway v2 requests with a
+ * JWT authorizer.
+ */
+class ApiGatewayv2CognitoAuthorizer extends ApiGatewayv2JwtAuthorizer {
+    /**
+     * The event that triggered the authorization check.
+     */
+    constructor(event, _logger) {
+        super(event, _logger);
+        this.event = event;
+        this._logger = _logger;
+    }
+}
+exports.ApiGatewayv2CognitoAuthorizer = ApiGatewayv2CognitoAuthorizer;
+/**
+ * AppSyncCognitoAuthorizer is a class that extends CognitoAuthorizer
+ * and implements authentication logic for AppSync resolver events with a
+ * Cognito authorizer.
+ */
+class AppSyncCognitoAuthorizer extends CognitoAuthorizer {
+    /**
+     * The event that triggered the authorization check.
+     */
+    constructor(event) {
+        super();
+        this.event = event;
+    }
+    /**
+     * Authenticates the user using the claims provided by the AppSync event.
+     */
+    async authenticate() {
+        // Try to get the claims from the event
+        if (this.event.identity) {
+            this.claims = this.event.identity.claims;
+        }
+    }
+}
+exports.AppSyncCognitoAuthorizer = AppSyncCognitoAuthorizer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lambda/auth.ts"],"names":[],"mappings":";;;;;;;AAAA,qCAA8B;AAC9B,kDAA0B;AAC1B,+CAAqE;AACrE,4DAAkC;AAElC,qCAAgE;AAEhE,MAAM,aAAa,GAAG,MAAA,aAAG,CAAC,YAAY,mCAAI,EAAE,CAAC;AAC7C,MAAM,iBAAiB,GAAG,MAAA,MAAA,aAAG,CAAC,gBAAgB,mCAAI,aAAG,CAAC,UAAU,mCAAI,cAAc,CAAC;AAEnF,MAAM,YAAY,GAAG,aAAa,CAAC,CAAC,CAAC,uBAAuB,iBAAiB,kBAAkB,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC,MAAA,aAAG,CAAC,cAAc,mCAAI,EAAE,CAAC,CAAC;AAC5I,MAAM,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,YAAY,wBAAwB,CAAC,CAAC,CAAC,aAAG,CAAC,YAAY,CAAC;AAC9F,MAAM,aAAa,GAAG,aAAa,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAA,aAAG,CAAC,eAAe,mCAAI,EAAE,CAAC,CAAC;AACrF,MAAM,WAAW,GAAG,CAAC,aAAG,CAAC,gBAAgB,IAAI,aAAG,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,aAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AA6B7H,IAAI,SAA0C,CAAC;AAE/C,MAAM,aAAa,GAAG,KAAK,EAAE,OAAe,EAAgC,EAAE;IAC5E,IAAI,CAAC,SAAS,EAAE;QACd,MAAM,UAAU,GAAe,CAAC,MAAM,eAAK,CAAC,GAAG,CAAa,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3E,SAAS,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAA,oBAAQ,EAAC,OAAuB,CAAC,CAAC;YAC9C,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;YAC9C,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAyB,CAAC,CAAC;QAC9B,OAAO,SAAS,CAAC;KAClB;SAAM;QACL,OAAO,SAAS,CAAC;KAClB;AACH,CAAC,CAAC;AAEF,mDAAmD;AACnD,MAAM,UAAU,GAAG,KAAK,EAAE,YAAoB,EAAE,OAAgB,EAAmB,EAAE;IACnF,IAAI,OAAO,EAAE;QACX,OAAO,OAAO,CAAC;KAChB;IACD,MAAM,YAAY,GAAG,GAAG,YAAY,cAAc,CAAC;IACnD,MAAM,cAAc,GAAG,CAAC,MAAM,eAAK,CAAC,GAAG,CAAiB,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5E,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE;QAC5B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;KACxD;IACD,OAAO,cAAc,CAAC,QAAQ,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,KAAa,EAAE,SAAiB,EAAE,OAAgB,EAAuC,EAAE;IACjH,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,IAAA,qBAAM,EAAC,KAAK,EAAE,CAAC,MAAiB,EAAE,EAAsB,EAAE,EAAE;YAC1D,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;gBACf,EAAE,CAAC,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;aAClC;YACD,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC/D,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,GAAI,CAAC,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC,EAAE,EAAE,CAAC,CAAC;QACT,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE;YAChE,IAAI,GAAG,EAAE;gBACP,MAAM,CAAC,GAAG,CAAC,CAAC;aACb;iBAAM;gBACL,OAAO,CAAC,OAAqC,CAAC,CAAC;aAChD;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAsB,aAAa;IAOjC,YACY,SAAiB,EACjB,UAAkB,EAClB,UAAkB,EAClB,OAAgB;QAHhB,cAAS,GAAT,SAAS,CAAQ;QACjB,eAAU,GAAV,UAAU,CAAQ;QAClB,eAAU,GAAV,UAAU,CAAQ;QAClB,YAAO,GAAP,OAAO,CAAS;IAE5B,CAAC;IAED;;;OAGG;IACI,SAAS;QACd,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,MAAO,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;YAC5E,OAAO,EAAE,CAAC;SACX;QACD,OAAO,IAAI,CAAC,MAAO,CAAC,IAAI,CAAC,UAAU,CAAwB,CAAC;IAC9D,CAAC;IAED;;;OAGG;IACI,QAAQ,CAAC,KAAa;QAC3B,iCAAiC;QACjC,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAOD;;OAEG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,mBAAmB;QACxB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE;YAC3B,MAAM,IAAI,6BAAoB,EAAE,CAAC;SAClC;IACH,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,KAAa;QAC9B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YACzB,MAAM,IAAI,uBAAc,EAAE,CAAC;SAC5B;IACH,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,QAAQ;QACb,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC,MAAO,CAAC,KAAe,CAAC;IACtC,CAAC;IAED;;OAEG;IACI,UAAU;QACf,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC,MAAO,CAAC,GAAa,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,IAAY;QAC1B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC,MAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;CACF;AA3GD,sCA2GC;AAED;;;GAGG;AACH,MAAsB,iBAAkB,SAAQ,aAAa;IAE3D;QACE,KAAK,CAAC,YAAY,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;CACF;AALD,8CAKC;AAED;;GAEG;AACH,MAAa,yBAA0B,SAAQ,aAAa;IAE1D,YACY,KAA0D,EAAE,8EAA8E;IACpJ,UAAkB,EACR,OAAyB;QAEnC,KAAK,CAAC,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QAJjD,UAAK,GAAL,KAAK,CAAqD;QAE1D,YAAO,GAAP,OAAO,CAAkB;IAGrC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,YAAY;QAEvB,qHAAqH;QACrH,IAAI,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,MAAM,EAAE;YACvF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC;SAC3D;QAED,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,OAAO;SACR;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC;QACpD,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;YACpD,OAAO;SACR;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAErD,mEAAmE;QACnE,IAAI;YACF,MAAM,MAAM,GAA+B,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACrG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;YAE3C,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,GAAG,EAAE,MAAM,EAAE,CAAC;YAClD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;SACtB;QAAC,OAAO,GAAQ,EAAE;YACjB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SACzB;IACH,CAAC;CACF;AA1CD,8DA0CC;AAED;;GAEG;AACH,MAAa,yBAA0B,SAAQ,aAAa;IAC1D,YAAsB,KAAwD,EAAY,OAAyB;QACjH,KAAK,CAAC,YAAY,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QADvC,UAAK,GAAL,KAAK,CAAmD;QAAY,YAAO,GAAP,OAAO,CAAkB;IAEnH,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,YAAY;;QACvB,uCAAuC;QACvC,IAAI,CAAC,MAAM,GAAG,MAAA,MAAA,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,0CAAE,GAAG,0CAAE,MAAM,CAAC;QAEhE,yDAAyD;QACzD,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,EAAE;YACjC,OAAO;SACR;QAED,kDAAkD;QAClD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC;QACpD,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;YACpD,OAAO;SACR;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAErD,mEAAmE;QACnE,IAAI;YACF,MAAM,MAAM,GAA+B,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACrG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;YAE3C,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,GAAG;gBACrC,GAAG,EAAE;oBACH,MAAM;oBACN,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;iBAC5B;gBACD,kBAAkB,EAAE,CAAC;gBACrB,WAAW,EAAE,SAAS;aACvB,CAAC;YACF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;SACtB;QAAC,OAAO,GAAQ,EAAE;YACjB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SACzB;IACH,CAAC;CACF;AA3CD,8DA2CC;AAED;;;GAGG;AACH,MAAa,6BAA8B,SAAQ,yBAAyB;IAE1E;;OAEG;IACH,YAAsB,KAA0D,EAAY,OAAyB;QACnH,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QADX,UAAK,GAAL,KAAK,CAAqD;QAAY,YAAO,GAAP,OAAO,CAAkB;IAErH,CAAC;CACF;AARD,sEAQC;AAED;;;;GAIG;AACH,MAAa,6BAA8B,SAAQ,yBAAyB;IAE1E;;OAEG;IACH,YAAsB,KAAwD,EAAY,OAAyB;QACjH,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QADF,UAAK,GAAL,KAAK,CAAmD;QAAY,YAAO,GAAP,OAAO,CAAkB;IAEnH,CAAC;CACF;AARD,sEAQC;AAED;;;;GAIG;AACH,MAAa,wBAAyB,SAAQ,iBAAiB;IAE7D;;OAEG;IACH,YAAsB,KAA0C;QAC9D,KAAK,EAAE,CAAC;QADY,UAAK,GAAL,KAAK,CAAqC;IAEhE,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,YAAY;QACvB,uCAAuC;QACvC,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;YACvB,IAAI,CAAC,MAAM,GAAI,IAAI,CAAC,KAAK,CAAC,QAA6C,CAAC,MAAM,CAAC;SAChF;IACH,CAAC;CAEF;AAnBD,4DAmBC","sourcesContent":["import { env } from 'process';\nimport Axios from 'axios';\nimport { verify, JwtHeader, SigningKeyCallback } from 'jsonwebtoken';\nimport jwkToPem from 'jwk-to-pem';\nimport logger from 'lambda-log';\nimport { ForbiddenError, UnauthenticatedError } from './errors';\n\nconst cognitoPoolId = env.USER_POOL_ID ?? '';\nconst cognitoPoolRegion = env.USER_POOL_REGION ?? env.AWS_REGION ?? 'eu-central-1';\n\nconst jwtIssuerUrl = cognitoPoolId ? `https://cognito-idp.${cognitoPoolRegion}.amazonaws.com/${cognitoPoolId}` : (env.JWT_ISSUER_URL ?? '');\nconst jwtJwksUrl = cognitoPoolId ? `${jwtIssuerUrl}/.well-known/jwks.json` : env.JWT_JWKS_URL;\nconst jwtGroupClaim = cognitoPoolId ? 'cognito:groups' : (env.JWT_GROUP_CLAIM ?? '');\nconst jwtAudience = (env.JWT_AUDIENCE_URL && env.JWT_AUDIENCE_URL.length > 0) ? env.JWT_AUDIENCE_URL.split('||') : undefined;\n\ninterface PublicKey {\n  alg: string;\n  e: string;\n  kid: string;\n  kty: string;\n  n: string;\n  use: string;\n}\n\ninterface PublicKeyMeta {\n  instance: PublicKey;\n  pem: string;\n}\n\ninterface PublicKeys {\n  keys: PublicKey[];\n}\n\ninterface IssuerMetadata {\n  jwks_uri?: string;\n  [key: string]: unknown;\n}\n\ninterface MapOfKidToPublicKey {\n  [key: string]: PublicKeyMeta;\n}\n\nlet cacheKeys: MapOfKidToPublicKey | undefined;\n\nconst getPublicKeys = async (jwksUrl: string): Promise<MapOfKidToPublicKey> => {\n  if (!cacheKeys) {\n    const publicKeys: PublicKeys = (await Axios.get<PublicKeys>(jwksUrl)).data;\n    cacheKeys = publicKeys.keys.reduce((agg, current) => {\n      const pem = jwkToPem(current as jwkToPem.JWK);\n      agg[current.kid] = { instance: current, pem };\n      return agg;\n    }, {} as MapOfKidToPublicKey);\n    return cacheKeys;\n  } else {\n    return cacheKeys;\n  }\n};\n\n// Grab the JWKS URI from the JWT issuer's metadata\nconst getJwksUri = async (discoveryUri: string, jwksUri?: string): Promise<string> => {\n  if (jwksUri) {\n    return jwksUri;\n  }\n  const wellKnownUri = `${discoveryUri}/.well-known`;\n  const issuerMetadata = (await Axios.get<IssuerMetadata>(wellKnownUri)).data;\n  if (!issuerMetadata.jwks_uri) {\n    throw new Error('Issuer does not offer JWKS endpoint');\n  }\n  return issuerMetadata.jwks_uri;\n};\n\nconst promisedVerify = (token: string, issuerUri: string, jwksUri?: string): Promise<{ [name: string]: string }> => {\n  return new Promise((resolve, reject) => {\n    verify(token, (header: JwtHeader, cb: SigningKeyCallback) => {\n      if (!header.kid) {\n        cb(new Error('no key id found'));\n      }\n      getJwksUri(issuerUri, jwksUri).then(getPublicKeys).then((keys) => {\n        cb(null, keys[header.kid!].pem);\n      }, cb);\n    }, { issuer: issuerUri, audience: jwtAudience }, (err, decoded) => {\n      if (err) {\n        reject(err);\n      } else {\n        resolve(decoded as { [name: string]: string });\n      }\n    });\n  });\n};\n\n/**\n * A generic JWT authorizer base class, presupposing the presence of an issuer, a number of authorization claims, an\n * admin permission claim and optionally a separate URL to a JWKS to use if the issuers well-known URL does not\n * point to it in its metadata.\n */\nexport abstract class JwtAuthorizer {\n\n  /**\n   * The claims of the authenticated user.\n   */\n  protected claims?: { [name: string]: string | number | boolean | string[] };\n\n  protected constructor(\n    protected issuerUrl: string,\n    protected groupClaim: string,\n    protected adminClaim: string,\n    protected jwksUrl?: string,\n  ) {\n  }\n\n  /**\n   * Returns an array of groups the user belongs to, or an empty array if the user\n   * is not authenticated or has no groups.\n   */\n  public getGroups(): string[] {\n    if (!this.isAuthenticated() || !this.claims!.hasOwnProperty(this.groupClaim)) {\n      return [];\n    }\n    return this.claims![this.groupClaim] as unknown as string[];\n  }\n\n  /**\n   * Returns true if the user belongs to the specified group, false otherwise.\n   * @param group The name of the group to check.\n   */\n  public hasGroup(group: string): boolean {\n    // 'cognito:groups': [ 'admin' ],\n    return this.getGroups().includes(group);\n  }\n\n  /**\n   * Authenticates the user and sets the claims.\n   */\n  public abstract authenticate(): Promise<void>;\n\n  /**\n   * Returns true if the user is authenticated, false otherwise.\n   */\n  public isAuthenticated(): boolean {\n    return this.claims !== undefined;\n  }\n\n  /**\n   * Throws an UnauthenticatedError if the user is not authenticated.\n   */\n  public assertAuthenticated(): void {\n    if (!this.isAuthenticated()) {\n      throw new UnauthenticatedError();\n    }\n  }\n\n  /**\n   * Throws a ForbiddenError if the user is not authenticated or does not belong\n   * to the specified group.\n   * @param group The name of the group to check.\n   */\n  public assertGroup(group: string): void {\n    this.assertAuthenticated();\n    if (!this.hasGroup(group)) {\n      throw new ForbiddenError();\n    }\n  }\n\n  /**\n   * Returns true if the user belongs to the 'admin' group, false otherwise.\n   */\n  public isAdmin(): boolean {\n    return this.hasGroup(this.adminClaim);\n  }\n\n  /**\n   * Throws a ForbiddenError if the user is not authenticated or is not an admin.\n   */\n  public assertAdmin(): void {\n    this.assertGroup(this.adminClaim);\n  }\n\n  /**\n   * Returns the email of the authenticated user.\n   */\n  public getEMail(): string {\n    this.assertAuthenticated();\n    return this.claims!.email as string;\n  }\n\n  /**\n   * Returns the subject of the authenticated user.\n   */\n  public getSubject(): string {\n    this.assertAuthenticated();\n    return this.claims!.sub as string;\n  }\n\n  /**\n   * Returns the value of the claim with the specified name, or undefined if the\n   * claim does not exist.\n   * @param name The name of the claim to retrieve.\n   */\n  public getClaim(name: string): string | number | boolean | string[] | undefined {\n    this.assertAuthenticated();\n    return this.claims![name];\n  }\n}\n\n/**\n * CognitoAuthorizer is an abstract class representing an authorizer\n * that can be used to authenticate and authorize a user through Cognito.\n */\nexport abstract class CognitoAuthorizer extends JwtAuthorizer {\n\n  protected constructor() {\n    super(jwtIssuerUrl, jwtGroupClaim, 'admin');\n  }\n}\n\n/**\n * Implements authorization on API Gateway v1 (Rest API) using JWT.\n */\nexport class ApiGatewayv1JwtAuthorizer extends JwtAuthorizer {\n\n  constructor(\n    protected event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, //FIXME: Learn about possible requestContext.authorizer sources in API gateway\n    adminClaim: string,\n    protected _logger: logger.LambdaLog,\n  ) {\n    super(jwtIssuerUrl, jwtGroupClaim, adminClaim, jwtJwksUrl);\n  }\n\n  /**\n   * Authenticates the user using the claims provided by the API Gateway event or\n   * by decoding a JWT token from the 'Authorization' header.\n   */\n  public async authenticate(): Promise<void> {\n\n    // Could be almost the exact same code as Cognito if we can specify our own Authorizer in the event's request context\n    if (this.event.requestContext.authorizer && this.event.requestContext.authorizer.claims) {\n      this.claims = this.event.requestContext.authorizer.claims;\n    }\n\n    if (this.claims) {\n      return;\n    }\n\n    const authHeader = this.event.headers.authorization;\n    if (!authHeader || !authHeader.startsWith('Bearer ')) {\n      return;\n    }\n    const token = authHeader.substring('Bearer '.length);\n\n    // Verify the token and set the claims on the event and this object\n    try {\n      const claims: { [name: string]: string } = await promisedVerify(token, this.issuerUrl, this.jwksUrl);\n      this._logger.debug(JSON.stringify(claims));\n\n      this.event.requestContext.authorizer = { claims };\n      this.claims = claims;\n    } catch (err: any) {\n      this._logger.error(err);\n    }\n  }\n}\n\n/**\n * Implements JWT Authorization on API Gateway v2 (HTTP API).\n */\nexport class ApiGatewayv2JwtAuthorizer extends JwtAuthorizer {\n  constructor(protected event: AWSLambda.APIGatewayProxyEventV2WithJWTAuthorizer, protected _logger: logger.LambdaLog) {\n    super(jwtIssuerUrl, 'cognito:groups', 'admin', jwtJwksUrl);\n  }\n\n  /**\n   * Authenticates the user using the claims provided by the API Gateway event or\n   * by decoding a JWT token from the 'Authorization' header.\n   */\n  public async authenticate(): Promise<void> {\n    // Try to get the claims from the event\n    this.claims = this.event.requestContext.authorizer?.jwt?.claims;\n\n    // If no pool ID is defined or claims exist, return early\n    if (!cognitoPoolId || this.claims) {\n      return;\n    }\n\n    // Extract the token from the Authorization header\n    const authHeader = this.event.headers.authorization;\n    if (!authHeader || !authHeader.startsWith('Bearer ')) {\n      return;\n    }\n    const token = authHeader.substring('Bearer '.length);\n\n    // Verify the token and set the claims on the event and this object\n    try {\n      const claims: { [name: string]: string } = await promisedVerify(token, this.issuerUrl, this.jwksUrl);\n      this._logger.debug(JSON.stringify(claims));\n\n      this.event.requestContext.authorizer = {\n        jwt: {\n          claims,\n          scopes: ['openid', 'email'],\n        },\n        integrationLatency: 0,\n        principalId: 'toolbox',\n      };\n      this.claims = claims;\n    } catch (err: any) {\n      this._logger.error(err);\n    }\n  }\n}\n\n/**\n * ApiGatewayv1CognitoAuthorizer is a specialization of an ApiGatewayv1JwtAuthorizer\n * and implements authentication logic for API Gateway v1 requests when using Cognito..\n */\nexport class ApiGatewayv1CognitoAuthorizer extends ApiGatewayv1JwtAuthorizer {\n\n  /**\n   * The event that triggered the authorization check.\n   */\n  constructor(protected event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, protected _logger: logger.LambdaLog) {\n    super(event, 'admin', _logger);\n  }\n}\n\n/**\n * ApiGatewayv2CognitoAuthorizer is a class that extends CognitoAuthorizer\n * and implements authentication logic for API Gateway v2 requests with a\n * JWT authorizer.\n */\nexport class ApiGatewayv2CognitoAuthorizer extends ApiGatewayv2JwtAuthorizer {\n\n  /**\n   * The event that triggered the authorization check.\n   */\n  constructor(protected event: AWSLambda.APIGatewayProxyEventV2WithJWTAuthorizer, protected _logger: logger.LambdaLog) {\n    super(event, _logger);\n  }\n}\n\n/**\n * AppSyncCognitoAuthorizer is a class that extends CognitoAuthorizer\n * and implements authentication logic for AppSync resolver events with a\n * Cognito authorizer.\n */\nexport class AppSyncCognitoAuthorizer extends CognitoAuthorizer {\n\n  /**\n   * The event that triggered the authorization check.\n   */\n  constructor(protected event: AWSLambda.AppSyncResolverEvent<any>) {\n    super();\n  }\n\n  /**\n   * Authenticates the user using the claims provided by the AppSync event.\n   */\n  public async authenticate(): Promise<void> {\n    // Try to get the claims from the event\n    if (this.event.identity) {\n      this.claims = (this.event.identity as AWSLambda.AppSyncIdentityCognito).claims;\n    }\n  }\n\n}\n"]}

package/lib/lambda/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message?: string);
+}
+export declare class BadRequestError extends HttpError {
+    constructor(message?: string);
+}
+export declare class UnauthenticatedError extends HttpError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string);
+}

package/lib/lambda/errors.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.ForbiddenError = exports.UnauthenticatedError = exports.BadRequestError = exports.HttpError = void 0;
+class HttpError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.HttpError = HttpError;
+class BadRequestError extends HttpError {
+    constructor(message) {
+        super(400, message);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class UnauthenticatedError extends HttpError {
+    constructor(message) {
+        super(401, message);
+    }
+}
+exports.UnauthenticatedError = UnauthenticatedError;
+class ForbiddenError extends HttpError {
+    constructor(message) {
+        super(403, message);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class NotFoundError extends HttpError {
+    constructor(message) {
+        super(404, message);
+    }
+}
+exports.NotFoundError = NotFoundError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xhbWJkYS9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsTUFBYSxTQUFVLFNBQVEsS0FBSztJQUNsQyxZQUE0QixVQUFrQixFQUFFLE9BQWdCO1FBQzlELEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQURXLGVBQVUsR0FBVixVQUFVLENBQVE7SUFFOUMsQ0FBQztDQUNGO0FBSkQsOEJBSUM7QUFFRCxNQUFhLGVBQWdCLFNBQVEsU0FBUztJQUM1QyxZQUFZLE9BQWdCO1FBQzFCLEtBQUssQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDdEIsQ0FBQztDQUNGO0FBSkQsMENBSUM7QUFFRCxNQUFhLG9CQUFxQixTQUFRLFNBQVM7SUFDakQsWUFBWSxPQUFnQjtRQUMxQixLQUFLLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3RCLENBQUM7Q0FDRjtBQUpELG9EQUlDO0FBRUQsTUFBYSxjQUFlLFNBQVEsU0FBUztJQUMzQyxZQUFZLE9BQWdCO1FBQzFCLEtBQUssQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDdEIsQ0FBQztDQUNGO0FBSkQsd0NBSUM7QUFFRCxNQUFhLGFBQWMsU0FBUSxTQUFTO0lBQzFDLFlBQVksT0FBZ0I7UUFDMUIsS0FBSyxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUN0QixDQUFDO0NBQ0Y7QUFKRCxzQ0FJQyIsInNvdXJjZXNDb250ZW50IjpbIlxuZXhwb3J0IGNsYXNzIEh0dHBFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IHN0YXR1c0NvZGU6IG51bWJlciwgbWVzc2FnZT86IHN0cmluZykge1xuICAgIHN1cGVyKG1lc3NhZ2UpO1xuICB9XG59XG5cbmV4cG9ydCBjbGFzcyBCYWRSZXF1ZXN0RXJyb3IgZXh0ZW5kcyBIdHRwRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihtZXNzYWdlPzogc3RyaW5nKSB7XG4gICAgc3VwZXIoNDAwLCBtZXNzYWdlKTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgVW5hdXRoZW50aWNhdGVkRXJyb3IgZXh0ZW5kcyBIdHRwRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihtZXNzYWdlPzogc3RyaW5nKSB7XG4gICAgc3VwZXIoNDAxLCBtZXNzYWdlKTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgRm9yYmlkZGVuRXJyb3IgZXh0ZW5kcyBIdHRwRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihtZXNzYWdlPzogc3RyaW5nKSB7XG4gICAgc3VwZXIoNDAzLCBtZXNzYWdlKTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgTm90Rm91bmRFcnJvciBleHRlbmRzIEh0dHBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U/OiBzdHJpbmcpIHtcbiAgICBzdXBlcig0MDQsIG1lc3NhZ2UpO1xuICB9XG59XG4iXX0=

package/lib/lambda/handler.d.ts

@@ -0,0 +1,90 @@
+import logger from 'lambda-log';
+import { CognitoAuthorizer, JwtAuthorizer } from './auth';
+/**
+ * An object containing the properties for an HTTP response.
+ */
+export interface HttpResponseContext {
+    statusCode?: number;
+    headers: {
+        [name: string]: string;
+    };
+    json: boolean;
+}
+/**
+ * An object containing the properties for an HTTP request handler.
+ */
+export interface HttpHandlerContext {
+    event: AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent;
+    lambdaContext: AWSLambda.Context;
+    logger: logger.LambdaLog;
+    response: HttpResponseContext;
+    auth: JwtAuthorizer;
+}
+/**
+ * A type definition for an HTTP handler.
+ */
+export type HttpHandler<T, R> = (context: HttpHandlerContext, body: T) => Promise<R>;
+/**
+ * An object containing the properties for an OpenAPI operation.
+ */
+export interface Operation {
+    responses: {
+        [statusCode: number]: {
+            content: {
+                'application/json': any;
+            };
+        } | any;
+    };
+}
+/**
+ * A type definition for an API Gateway v1 request handler.
+ */
+export type APIGatewayv1Handler = AWSLambda.Handler<AWSLambda.APIGatewayProxyWithCognitoAuthorizerEvent, AWSLambda.APIGatewayProxyResult | undefined>;
+/**
+ * An object containing the properties for an OpenAPI operation with a request body.
+ */
+export interface OperationWithRequestBody extends Operation {
+    requestBody: {
+        content: {
+            'application/json': any;
+        };
+    };
+}
+/**
+ * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body.
+ */
+export declare const createOpenApiHandlerWithRequestBody: <OP extends OperationWithRequestBody, SC extends number = 200>(handler: HttpHandler<OP["requestBody"]["content"]["application/json"], OP["responses"][SC]["content"]["application/json"]>) => APIGatewayv1Handler;
+/**
+ * A factory function that creates an HTTP request handler for an OpenAPI operation with a request body and no response.
+ */
+export declare const createOpenApiHandlerWithRequestBodyNoResponse: <OP extends OperationWithRequestBody>(handler: HttpHandler<OP["requestBody"]["content"]["application/json"], void>) => APIGatewayv1Handler;
+/**
+ * A factory function that creates an HTTP request handler for an OpenAPI operation.
+ */
+export declare const createOpenApiHandler: <OP extends Operation, SC extends number = 200>(handler: HttpHandler<any, OP["responses"][SC]["content"]["application/json"]>) => APIGatewayv1Handler;
+/**
+ * A factory function that creates an HTTP request handler.
+ */
+export declare const createHttpHandler: <T, R>(handler: HttpHandler<T, R>) => APIGatewayv1Handler;
+/**
+ * The context for the AppSync resolver function.
+ * Contains information about the event, lambda context, logger, and Cognito authorizer.
+ */
+export interface AppSyncHandlerContext<T> {
+    event: AWSLambda.AppSyncResolverEvent<T>;
+    lambdaContext: AWSLambda.Context;
+    logger: logger.LambdaLog;
+    cognitoAuth: CognitoAuthorizer;
+}
+/**
+ * A function that handles an AppSync resolver event.
+ * Receives the context object and returns the response.
+ */
+export type AppSyncHandler<T, R> = (context: AppSyncHandlerContext<T>) => Promise<R>;
+/**
+ * Creates an AppSync resolver handler from the given AppSyncHandler.
+ * Returns a function that can be used as an AppSync resolver.
+ *
+ * @param handler The AppSyncHandler to use as the resolver.
+ */
+export declare const createAppSyncHandler: <T, R>(handler: AppSyncHandler<T, R>) => import("aws-lambda").AppSyncResolverHandler<T, R, Record<string, any> | null>;