@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/cjs/services/documentStore/versioned/file-system.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileSystemVersionedDocumentStore = void 0;
+const file_system_1 = require("../unversioned/file-system");
+const PAGE_LIMIT = 5;
+const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, getAuthor) => {
+    const unversionedDocuments = (0, file_system_1.fileSystemUnversionedDocumentStore)(initializer)()(configProvider)({}, 'id');
+    return {
+        loadAllDocumentsTheBadWay: () => {
+            return unversionedDocuments.loadAllDocumentsTheBadWay().then(documents => documents.map(document => {
+                return document.items[document.items.length - 1];
+            }));
+        },
+        getVersions: async (id, startVersion) => {
+            const item = await unversionedDocuments.getItem(id);
+            const versions = item === null || item === void 0 ? void 0 : item.items.reverse();
+            if (!versions) {
+                return undefined;
+            }
+            const startIndex = startVersion ? versions.findIndex(version => version.timestamp === startVersion) + 1 : 0;
+            const items = versions.slice(startIndex, startIndex + PAGE_LIMIT);
+            const hasMore = (startIndex + 5) < versions.length;
+            return {
+                items,
+                nextPageToken: hasMore ? items[items.length - 1].timestamp : undefined
+            };
+        },
+        getItem: async (id, timestamp) => {
+            const item = await unversionedDocuments.getItem(id);
+            if (timestamp) {
+                return item === null || item === void 0 ? void 0 : item.items.find(version => version.timestamp === timestamp);
+            }
+            return item ? item.items[item.items.length - 1] : undefined;
+        },
+        prepareItem: async (item, ...authorArgs) => {
+            // this getAuthor type is terrible
+            const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+            const timestamp = new Date().getTime();
+            return {
+                document: { ...item, timestamp, author },
+                save: async (changes) => {
+                    var _a;
+                    const document = { ...item, ...changes, timestamp, author };
+                    const container = (_a = await unversionedDocuments.getItem(document[hashKey])) !== null && _a !== void 0 ? _a : { id: document[hashKey], items: [] };
+                    const updated = { ...container, items: [...container.items, document] };
+                    await unversionedDocuments.putItem(updated);
+                    return document;
+                }
+            };
+        },
+        putItem: async (item, ...authorArgs) => {
+            var _a;
+            const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+            const document = { ...item, timestamp: new Date().getTime(), author };
+            const container = (_a = await unversionedDocuments.getItem(document[hashKey])) !== null && _a !== void 0 ? _a : { id: document[hashKey], items: [] };
+            const updated = { ...container, items: [...container.items, document] };
+            await unversionedDocuments.putItem(updated);
+            return document;
+        },
+    };
+};
+exports.fileSystemVersionedDocumentStore = fileSystemVersionedDocumentStore;

package/dist/cjs/services/documentStore/versioned/index.d.ts

@@ -0,0 +1,17 @@
+import { TDocument } from '..';
+import { dynamoVersionedDocumentStore } from './dynamodb';
+export declare type VersionedDocumentAuthor = {
+    type: 'user';
+    uuid: string;
+    name: string;
+    reason?: string;
+} | {
+    type: 'system';
+    reason: string;
+};
+export declare type VersionedDocumentRequiredFields = {
+    timestamp: number;
+    author: VersionedDocumentAuthor;
+};
+export declare type VersionedTDocument<T> = TDocument<T> & VersionedDocumentRequiredFields;
+export declare type VersionedDocumentStoreCreator = typeof dynamoVersionedDocumentStore;

package/dist/cjs/services/documentStore/versioned/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/services/exercisesGateway/index.d.ts

@@ -0,0 +1,71 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+export declare type Config = {
+    defaultCorrectness?: string;
+    exercisesHost: string;
+    exercisesAuthToken: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare type Answer = {
+    id: number;
+    content_html: string;
+    correctness?: string;
+    feedback_html?: string;
+};
+export declare type Solution = {
+    images: any[];
+    solution_type: string;
+    content_html: string;
+};
+export declare type Question = {
+    id: number;
+    is_answer_order_important: boolean;
+    stimulus_html: string;
+    stem_html: string;
+    answers: Answer[];
+    hints: string[];
+    formats: string[];
+    combo_choices: any[];
+    collaborator_solutions?: Solution[];
+    community_solutions?: Solution[];
+};
+export declare type Exercise = {
+    images: any[];
+    tags: string[];
+    uuid: string;
+    group_uuid: string;
+    number: number;
+    version: number;
+    uid: string;
+    published_at: string;
+    solutions_are_public: boolean;
+    authors: any[];
+    copyright_holders: any[];
+    derived_from: any[];
+    is_vocab: boolean;
+    questions: Question[];
+    delegations: any[];
+    versions: number[];
+    stimulus_html: string;
+};
+export declare type ExercisesSearchResults = {
+    total_count: number;
+    items: Exercise[];
+};
+export declare type ExercisesSearchResultsWithDigest = ExercisesSearchResults & {
+    digest: string;
+};
+export declare const exercisesGateway: <C extends string = "exercises">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    defaultCorrectness?: import("../../config").ConfigValueProvider<string> | undefined;
+    exercisesHost: import("../../config").ConfigValueProvider<string>;
+    exercisesAuthToken: import("../../config").ConfigValueProvider<string>;
+}; }) => (_: {}) => {
+    searchDigest: (query: string, page?: number, per_page?: number) => Promise<string>;
+    get: (uuid: string) => Promise<Exercise | undefined>;
+    search: (query: string, page?: number, per_page?: number) => Promise<ExercisesSearchResultsWithDigest>;
+};
+export declare type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
+export {};

package/dist/cjs/services/exercisesGateway/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exercisesGateway = void 0;
+const queryString = __importStar(require("query-string"));
+const __1 = require("../..");
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const routing_1 = require("../../routing");
+const exercisesGateway = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'exercises')];
+    const exercisesHost = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.exercisesHost));
+    const exercisesAuthToken = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.exercisesAuthToken));
+    const defaultCorrectness = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.defaultCorrectness || ''));
+    const doDefaultCorrectness = async (exercise) => {
+        if (await defaultCorrectness() !== 'true') {
+            return exercise;
+        }
+        for (const question of exercise.questions) {
+            const existingCorrect = question.answers.find(answer => answer.correctness !== undefined);
+            if (question.answers.length < 1 || existingCorrect) {
+                continue;
+            }
+            const defaultCorrectIndex = question.id % question.answers.length;
+            const defaultCorrect = question.answers[defaultCorrectIndex];
+            const defaultHint = `<em>random default: the correct answer is ${defaultCorrect.id}: ${defaultCorrect.content_html.slice(0, 20)}</em>`;
+            question.stem_html += `\n<br>${defaultHint}`;
+            question.collaborator_solutions = [
+                { solution_type: 'detailed', images: [], content_html: defaultHint }
+            ];
+            for (let index = 0; index < question.answers.length; index++) {
+                const answer = question.answers[index];
+                answer.correctness = defaultCorrectIndex === index ? '1.0' : '0.0';
+                answer.feedback_html = defaultCorrectIndex === index ? 'This is the good one!' : defaultHint;
+            }
+        }
+        return exercise;
+    };
+    return (_) => {
+        const request = async (method, path, query = undefined) => {
+            const host = (await exercisesHost()).replace(/\/+$/, '');
+            const baseUrl = `${host}/api/${path}`;
+            const url = query ? `${baseUrl}?${queryString.stringify(query)}` : baseUrl;
+            return initializer.fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${await exercisesAuthToken()}`,
+                },
+                method,
+            });
+        };
+        const searchDigest = async (query, page = 1, per_page = 100) => {
+            const response = await request(routing_1.METHOD.HEAD, 'exercises', { query, page, per_page });
+            return (0, assertions_1.assertString)(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint HEAD did not return an X-Digest header');
+        };
+        const search = async (query, page = 1, per_page = 100) => {
+            const response = await request(routing_1.METHOD.GET, 'exercises', { query, page, per_page });
+            const digest = (0, assertions_1.assertString)(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint GET did not return an X-Digest header');
+            const { items, total_count } = await response.json();
+            return { digest, items: await Promise.all(items.map(doDefaultCorrectness)), total_count };
+        };
+        const get = async (uuid) => {
+            const response = await request(routing_1.METHOD.GET, `exercises/${uuid}`);
+            return response.status === 404
+                ? undefined
+                : response.json().then(doDefaultCorrectness);
+        };
+        return {
+            searchDigest,
+            get,
+            search,
+        };
+    };
+};
+exports.exercisesGateway = exercisesGateway;

package/dist/cjs/services/fileServer/index.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+export declare type FileValue = {
+    dataType: 'file';
+    mimeType: string;
+    path: string;
+    label: string;
+};
+export declare type FolderValue = {
+    dataType: 'folder';
+    files: FileValue[];
+};
+export declare const isFileValue: (thing: any) => thing is FileValue;
+export declare const isFolderValue: (thing: any) => thing is FolderValue;
+export interface FileServerAdapter {
+    getFileContent: (source: FileValue) => Promise<Buffer>;
+}
+export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

package/dist/cjs/services/fileServer/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileOrFolder = exports.isFolderValue = exports.isFileValue = void 0;
+const guards_1 = require("../../guards");
+const isFileValue = (thing) => (0, guards_1.isPlainObject)(thing)
+    && Object.keys(thing).every(key => ['dataType', 'path', 'label', 'mimeType'].includes(key))
+    && thing.dataType === 'file'
+    && typeof thing.mimeType === 'string'
+    && typeof thing.path === 'string'
+    && typeof thing.label === 'string';
+exports.isFileValue = isFileValue;
+const isFolderValue = (thing) => (0, guards_1.isPlainObject)(thing)
+    && Object.keys(thing).every(key => ['dataType', 'files'].includes(key))
+    && thing.dataType === 'folder'
+    && thing.files instanceof Array
+    && thing.files.every(exports.isFileValue);
+exports.isFolderValue = isFolderValue;
+const isFileOrFolder = (thing) => (0, exports.isFileValue)(thing) || (0, exports.isFolderValue)(thing);
+exports.isFileOrFolder = isFileOrFolder;

package/dist/cjs/services/fileServer/localFileServer.d.ts

@@ -0,0 +1,13 @@
+import { ConfigProviderForConfig } from '../../config';
+import { FileServerAdapter } from '.';
+export declare type Config = {
+    storagePrefix: string;
+};
+interface Initializer<C> {
+    dataDir: string;
+    configSpace?: C;
+}
+export declare const localFileServer: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    storagePrefix: import("../../config").ConfigValueProvider<string>;
+}; }) => FileServerAdapter;
+export {};

package/dist/cjs/services/fileServer/localFileServer.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localFileServer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const localFileServer = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'local')];
+    const storagePrefix = (0, config_1.resolveConfigValue)(config.storagePrefix);
+    const fileDir = storagePrefix.then((prefix) => path_1.default.join(initializer.dataDir, prefix));
+    const getFileContent = async (source) => {
+        const filePath = path_1.default.join(await fileDir, source.path);
+        return fs_1.default.promises.readFile(filePath);
+    };
+    return {
+        getFileContent,
+    };
+};
+exports.localFileServer = localFileServer;

package/dist/cjs/services/fileServer/s3FileServer.d.ts

@@ -0,0 +1,16 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { ConfigProviderForConfig } from '../../config';
+import { FileServerAdapter } from '.';
+export declare type Config = {
+    bucketName: string;
+    bucketRegion: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    s3Client?: typeof S3Client;
+}
+export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    bucketName: import("../../config").ConfigValueProvider<string>;
+    bucketRegion: import("../../config").ConfigValueProvider<string>;
+}; }) => FileServerAdapter;
+export {};

package/dist/cjs/services/fileServer/s3FileServer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s3FileServer = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const __1 = require("../..");
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const s3FileServer = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'deployed')];
+    const bucketName = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.bucketName));
+    const bucketRegion = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.bucketRegion));
+    const client = (0, guards_1.ifDefined)(initializer.s3Client, client_s3_1.S3Client);
+    const s3Service = (0, __1.once)(async () => new client({ apiVersion: '2012-08-10', region: await bucketRegion() }));
+    const getFileContent = async (source) => {
+        const bucket = await bucketName();
+        const command = new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return Buffer.from(await (0, assertions_1.assertDefined)(response.Body, new Error('Invalid Response from s3')).transformToByteArray());
+    };
+    return {
+        getFileContent,
+    };
+};
+exports.s3FileServer = s3FileServer;

package/dist/cjs/services/launchParams/index.d.ts

@@ -0,0 +1,2 @@
+export { createLaunchSigner } from './signer';
+export { createLaunchVerifier } from './verifier';

package/dist/cjs/services/launchParams/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchVerifier = exports.createLaunchSigner = void 0;
+var signer_1 = require("./signer");
+Object.defineProperty(exports, "createLaunchSigner", { enumerable: true, get: function () { return signer_1.createLaunchSigner; } });
+var verifier_1 = require("./verifier");
+Object.defineProperty(exports, "createLaunchVerifier", { enumerable: true, get: function () { return verifier_1.createLaunchVerifier; } });

package/dist/cjs/services/launchParams/signer.d.ts

@@ -0,0 +1,27 @@
+import { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+declare type Config = {
+    alg: string;
+    expiresIn: string;
+    iss: string;
+    privateKey: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+}
+/**
+ * Creates a class that can sign launch params
+ */
+export declare const createLaunchSigner: <C extends string = "launch">({ configSpace }: Initializer<C>) => (configProvider: { [key in C]: {
+    alg: import("../../config").ConfigValueProvider<string>;
+    expiresIn: import("../../config").ConfigValueProvider<string>;
+    iss: import("../../config").ConfigValueProvider<string>;
+    privateKey: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    jwks: () => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+    sign: (subject: string, maxExp?: number | null | undefined) => Promise<string>;
+};
+export declare type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
+export {};

package/dist/cjs/services/launchParams/signer.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchSigner = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const ms_1 = __importDefault(require("ms"));
+const node_jose_1 = require("node-jose");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const SUPPORTED_ALGORITHMS = [
+    'RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'PS256', 'PS384', 'PS512'
+];
+const assertAlg = (alg) => {
+    if ((SUPPORTED_ALGORITHMS).includes(alg)) {
+        return alg;
+    }
+    throw new Error(`"${alg}" is not a valid algorithm`);
+};
+/**
+ * Creates a class that can sign launch params
+ */
+const createLaunchSigner = ({ configSpace }) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'launch')];
+    const getAlg = (0, __1.once)(async () => assertAlg(await (0, config_1.resolveConfigValue)(config.alg)));
+    const getExpiresIn = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.expiresIn));
+    const getIss = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.iss));
+    const getPrivateKey = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.privateKey));
+    const getKeyStore = (0, __1.once)(async () => {
+        const keystore = node_jose_1.JWK.createKeyStore();
+        await keystore.add(await getPrivateKey(), 'pem');
+        return keystore;
+    });
+    const jwks = async () => (await getKeyStore()).toJSON(false);
+    const getExpiresInWithMax = async (maxExp) => {
+        const expiresIn = await getExpiresIn();
+        // The ms library used by jsonwebtoken can handle a value in seconds as well as a string like '1d'
+        if (!maxExp) {
+            return expiresIn;
+        }
+        // Convert both values to seconds for comparison
+        const expiresInSeconds = Math.floor((0, ms_1.default)(expiresIn) / 1000);
+        const maxExpSeconds = maxExp - Math.floor(Date.now() / 1000);
+        return Math.min(expiresInSeconds, maxExpSeconds);
+    };
+    const sign = async (subject, maxExp) => {
+        const alg = await getAlg();
+        // expiresIn can be a number of seconds or a string like '1h' or '1d'
+        const expiresIn = await getExpiresInWithMax(maxExp);
+        const iss = await getIss();
+        const header = { alg, iss };
+        return jsonwebtoken_1.default.sign({}, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
+    };
+    return { jwks, sign };
+};
+exports.createLaunchSigner = createLaunchSigner;

package/dist/cjs/services/launchParams/verifier.d.ts

@@ -0,0 +1,22 @@
+import jwt from 'jsonwebtoken';
+import type { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+declare type Config = {
+    trustedDomain: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetcher?: (uri: string) => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+}
+/**
+ * Creates a class that can verify launch params
+ */
+export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [key in C]: {
+    trustedDomain: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    verify: <T = undefined>(...[token, validator]: T extends undefined ? [string] : [string, (input: any) => T]) => Promise<T extends undefined ? jwt.JwtPayload : T>;
+};
+export declare type LaunchVerifier = ReturnType<ReturnType<typeof createLaunchVerifier>>;
+export {};

package/dist/cjs/services/launchParams/verifier.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchVerifier = void 0;
+const jsonwebtoken_1 = __importStar(require("jsonwebtoken"));
+const jwks_rsa_1 = require("jwks-rsa");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const guards_1 = require("../../guards");
+/**
+ * Creates a class that can verify launch params
+ */
+const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'launch')];
+    const getJwksClient = (0, __1.memoize)((jwksUri) => new jwks_rsa_1.JwksClient({ fetcher, jwksUri }));
+    const getJwksKey = (0, __1.memoize)(async (jwksUri, kid) => {
+        const client = getJwksClient(jwksUri);
+        const key = await client.getSigningKey(kid);
+        return key.getPublicKey();
+    });
+    const getKey = async (header, callback) => {
+        // The JWT spec allows iss in the header as a copy of the iss claim, but we require it
+        if (!header.iss) {
+            return callback(new Error('JWT header missing iss claim'));
+        }
+        const { iss, kid } = header;
+        try {
+            const jwksUrl = new URL('/.well-known/jwks.json', iss);
+            const launchDomain = jwksUrl.hostname;
+            const trustedDomain = await (0, config_1.resolveConfigValue)(config.trustedDomain);
+            if (launchDomain !== trustedDomain && !launchDomain.endsWith(`.${trustedDomain}`)) {
+                return callback(new Error(`Untrusted launch domain: "${launchDomain}"`));
+            }
+            callback(null, await getJwksKey(jwksUrl.toString(), kid));
+        }
+        catch (error) {
+            callback(error);
+        }
+    };
+    const verify = (...[token, validator]) => new Promise((resolve, reject) => jsonwebtoken_1.default.verify(token, getKey, {}, (err, payload) => {
+        if (err && err instanceof jsonwebtoken_1.TokenExpiredError) {
+            reject(new errors_1.SessionExpiredError());
+        }
+        else if (err) {
+            reject(err);
+        }
+        else if (typeof payload !== 'object') {
+            reject(new Error('received JWT token with unexpected non-JSON payload'));
+        }
+        else if (!payload.sub) {
+            reject(new Error('JWT payload missing sub claim'));
+        }
+        else {
+            // we are migrating away from json encoding all the parameters into the `sub` claim
+            // and into using separate claims for each parameter. in transition, we check if the sub
+            // is json and return it if it is. this is still a breaking change when using this
+            // utility because applications no longer need to independently json parse the result
+            // starting now.
+            const parsed = payload;
+            try {
+                const jsonSubContents = JSON.parse(payload.sub);
+                Object.assign(parsed, jsonSubContents);
+            }
+            catch (e) { } // eslint-disable-line no-empty
+            // conditional return types are annoying
+            resolve((validator ? validator(parsed) : parsed));
+        }
+    }));
+    return { verify };
+};
+exports.createLaunchVerifier = createLaunchVerifier;

package/dist/cjs/services/logger/console.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates a logger that logs to the console.
+ */
+export declare const createConsoleLogger: () => import(".").Logger;

package/dist/cjs/services/logger/console.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConsoleLogger = void 0;
+const _1 = require(".");
+/**
+ * Creates a logger that logs to the console.
+ */
+const createConsoleLogger = () => (0, _1.createCoreLogger)((level, event) => console[level](JSON.stringify({
+    eventType: level.toUpperCase(),
+    ...event,
+})));
+exports.createConsoleLogger = createConsoleLogger;

package/dist/cjs/services/logger/index.d.ts

@@ -0,0 +1,39 @@
+import { JsonCompatibleStruct } from '../../routing';
+/**
+ * The log level
+ */
+export declare enum Level {
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+/**
+ * A function that logs an event at a certain level.
+ *
+ * @param level - log level
+ * @param event - event to log
+ */
+export declare type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
+/**
+ * A logger that can be used to log events.
+ *
+ * @property setContext - sets a context object to be included in all future logged events
+ * @property logEvent - logs an arbitrary event at a certain level, without context
+ * @property log - logs a message and the context at a certain level
+ * @property createSubContext - creates a new logger that inherits the context of this logger
+ */
+export interface Logger {
+    setContext: (obj: JsonCompatibleStruct) => void;
+    logEvent: LogEvent;
+    log: (message: string, level?: Level) => void;
+    createSubContext: () => Logger;
+}
+/**
+ * Creates a logger that logs events using the given driver and context provider.
+ *
+ * @param driver the driver that logs events
+ * @param getParentContext a provider that returns the context to use for this logger
+ *   (the context is returned when messages are logged with the logger)
+ * @returns a Logger
+ */
+export declare const createCoreLogger: (driver: LogEvent, getParentContext?: (() => JsonCompatibleStruct) | undefined) => Logger;