@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/esm/services/documentStore/unversioned/file-system.js

@@ -0,0 +1,91 @@
+import * as fsModule from 'fs';
+import path from 'path';
+import { hashValue } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { NotFoundError } from '../../../errors';
+import { ifDefined, isDefined } from '../../../guards';
+export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey) => {
+    const tableName = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].tableName);
+    const tablePath = tableName.then((table) => path.join(initializer.dataDir, table));
+    const { mkdir, readdir, readFile, writeFile } = ifDefined(initializer.fs, fsModule);
+    const mkTableDir = new Promise((resolve, reject) => tablePath.then((path) => mkdir(path, { recursive: true }, (err) => err && err.code !== 'EEXIST' ? reject(err) : resolve())));
+    const hashFilename = (value) => `${hashValue(value)}.json`;
+    const filePath = async (filename) => path.join(await tablePath, filename);
+    const load = async (filename) => {
+        const path = await filePath(filename);
+        await mkTableDir;
+        return new Promise((resolve, reject) => {
+            readFile(path, (err, readData) => {
+                if (err) {
+                    err.code === 'ENOENT' ? resolve(undefined) : reject(err);
+                }
+                else {
+                    try {
+                        const data = JSON.parse(readData.toString());
+                        typeof data === 'object' ? resolve(data) : reject(new Error('unexpected non-object JSON'));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }
+            });
+        });
+    };
+    return {
+        loadAllDocumentsTheBadWay: async () => {
+            const path = await tablePath;
+            await mkTableDir;
+            return new Promise((resolve, reject) => readdir(path, (err, files) => err ?
+                reject(err) :
+                Promise.all(files.map((file) => load(file)))
+                    .then((allData) => resolve(allData.filter(isDefined)), (err) => reject(err))));
+        },
+        batchGetItem: async (ids) => {
+            const items = await Promise.all(ids.map((id) => load(hashFilename(id))));
+            return items.filter(isDefined);
+        },
+        getItem: (id) => load(hashFilename(id)),
+        incrementItemAttribute: async (id, attribute) => {
+            const filename = hashFilename(id);
+            const path = await filePath(filename);
+            await mkTableDir;
+            const data = await load(filename);
+            if (!data) {
+                throw new NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
+            }
+            const newValue = typeof data[attribute] === 'number' ? data[attribute] + 1 : 1;
+            const newItem = { ...data, [hashKey]: id, [attribute]: newValue };
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newValue));
+            });
+        },
+        patchItem: async (item) => {
+            const id = item[hashKey];
+            if (!id) {
+                throw new Error(`Key attribute "${hashKey.toString()}" is required for patchItem`);
+            }
+            // This check is just to make this adapter consistent with the dynamo adapter
+            if (Object.keys(item).filter((key) => key !== hashKey.toString()).length === 0) {
+                throw new Error('No attributes to update');
+            }
+            const filename = hashFilename(id);
+            const path = await filePath(filename);
+            await mkTableDir;
+            const data = await load(filename);
+            if (!data) {
+                throw new NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
+            }
+            const newItem = { ...data, ...item };
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newItem));
+            });
+        },
+        putItem: async (item) => {
+            const path = await filePath(hashFilename(item[hashKey]));
+            await mkTableDir;
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
+            });
+        },
+    };
+};

package/dist/esm/services/documentStore/unversioned/index.d.ts

@@ -0,0 +1,2 @@
+import { dynamoUnversionedDocumentStore } from './dynamodb';
+export declare type UnversionedDocumentStoreCreator = typeof dynamoUnversionedDocumentStore;

package/dist/esm/services/documentStore/unversioned/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/documentStore/versioned/dynamodb.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+import { VersionedDocumentAuthor, VersionedTDocument } from '.';
+interface Initializer<C> {
+    configSpace?: C;
+}
+export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends VersionedTDocument<T>>() => (configProvider: { [key in C]: {
+    tableName: import("../../../config").ConfigValueProvider<string>;
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(_: {}, hashKey: K, getAuthor: A) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
+        items: T[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    prepareItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<{
+        document: T;
+        save: (changes?: Partial<Omit<T, "timestamp" | "author">> | undefined) => Promise<T>;
+    }>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};

package/dist/esm/services/documentStore/versioned/dynamodb.js

@@ -0,0 +1,131 @@
+import { DynamoDB, PutItemCommand, QueryCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { once } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { ifDefined } from '../../../guards';
+import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
+const dynamodb = once(() => new DynamoDB({ apiVersion: '2012-08-10' }));
+// i'm not really excited about getAuthor being required, but ts is getting confused about the type when unspecified
+export const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, getAuthor) => {
+    const options = ifDefined(initializer, {});
+    const tableName = once(() => resolveConfigValue(configProvider[ifDefined(options.configSpace, 'dynamodb')].tableName));
+    return {
+        loadAllDocumentsTheBadWay: async () => {
+            const loadAllResults = async (ExclusiveStartKey) => {
+                var _a;
+                const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                const result = await dynamodb().send(cmd);
+                const resultItems = ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)) || [];
+                if (result.LastEvaluatedKey) {
+                    return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                }
+                return resultItems;
+            };
+            const allResults = await loadAllResults().then(results => results.reduce((result, document) => {
+                const current = result.get(document[hashKey]);
+                if (!current || current.timestamp < document.timestamp) {
+                    return result.set(document[hashKey], document);
+                }
+                return result;
+            }, new Map()));
+            return Array.from(allResults.values());
+        },
+        getVersions: async (id, startVersion) => {
+            const cmd = new QueryCommand({
+                TableName: await tableName(),
+                KeyConditionExpression: '#hk = :hkv',
+                ExpressionAttributeValues: {
+                    ':hkv': encodeDynamoAttribute(id)
+                },
+                ExpressionAttributeNames: {
+                    '#hk': hashKey.toString()
+                },
+                ...(startVersion
+                    ? { ExclusiveStartKey: {
+                            [hashKey]: encodeDynamoAttribute(id),
+                            timestamp: { N: startVersion.toString() }
+                        } }
+                    : {}),
+                ScanIndexForward: false,
+            });
+            return dynamodb().send(cmd).then(result => {
+                var _a;
+                const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument);
+                if (!items || items.length === 0) {
+                    return undefined;
+                }
+                return {
+                    items,
+                    nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                };
+            });
+        },
+        getItem: async (id, timestamp) => {
+            let keyConditionExpression = '#hk = :hkv';
+            const expressionAttributeNames = {
+                '#hk': hashKey.toString()
+            };
+            const expressionAttributeValues = {
+                ':hkv': encodeDynamoAttribute(id)
+            };
+            if (timestamp) {
+                keyConditionExpression += ' and #ts = :tsv';
+                expressionAttributeNames['#ts'] = 'timestamp';
+                expressionAttributeValues[':tsv'] = encodeDynamoAttribute(timestamp);
+            }
+            const cmd = new QueryCommand({
+                TableName: await tableName(),
+                KeyConditionExpression: keyConditionExpression,
+                ExpressionAttributeNames: expressionAttributeNames,
+                ExpressionAttributeValues: expressionAttributeValues,
+                ScanIndexForward: false,
+                Limit: 1
+            });
+            return dynamodb().send(cmd).then(result => {
+                var _a;
+                return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
+            });
+        },
+        /* prepares a new version of a document with the given data, then allows some additional
+         * changes to be input to a `save` function that actually saves it. useful for additional
+         * changes based on the new document version or author. the document version and author
+         * cannot be modified */
+        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) => {
+                    const document = {
+                        ...item,
+                        ...changes,
+                        timestamp,
+                        author
+                    };
+                    const cmd = new PutItemCommand({
+                        TableName: await tableName(),
+                        Item: encodeDynamoDocument(document),
+                    });
+                    return dynamodb().send(cmd)
+                        .then(() => document);
+                }
+            };
+        },
+        /* saves a new version of a document with the given data */
+        putItem: async (item, ...authorArgs) => {
+            // this getAuthor type is terrible
+            const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+            const document = {
+                ...item,
+                timestamp: new Date().getTime(),
+                author
+            };
+            const cmd = new PutItemCommand({
+                TableName: await tableName(),
+                Item: encodeDynamoDocument(document),
+            });
+            return dynamodb().send(cmd)
+                .then(() => document);
+        },
+    };
+};

package/dist/esm/services/documentStore/versioned/file-system.d.ts

@@ -0,0 +1,24 @@
+import { Config } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+import { VersionedDocumentAuthor, VersionedTDocument } from '.';
+interface Initializer<C> {
+    dataDir: string;
+    fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
+    configSpace?: C;
+}
+export declare const fileSystemVersionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends VersionedTDocument<T>>() => (configProvider: { [key in C]: {
+    tableName: import("../../../config").ConfigValueProvider<string>;
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(_: {}, hashKey: K, getAuthor: A) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
+        items: T[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    prepareItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<{
+        document: T;
+        save: (changes?: Partial<Omit<T, "timestamp" | "author">> | undefined) => Promise<T>;
+    }>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,58 @@
+import { fileSystemUnversionedDocumentStore } from '../unversioned/file-system';
+const PAGE_LIMIT = 5;
+export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, getAuthor) => {
+    const unversionedDocuments = 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;
+        },
+    };
+};

package/dist/esm/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/esm/services/documentStore/versioned/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/services/exercisesGateway/index.js

@@ -0,0 +1,70 @@
+import * as queryString from 'query-string';
+import { once } from '../..';
+import { assertString } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+import { METHOD } from '../../routing';
+export const exercisesGateway = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'exercises')];
+    const exercisesHost = once(() => resolveConfigValue(config.exercisesHost));
+    const exercisesAuthToken = once(() => resolveConfigValue(config.exercisesAuthToken));
+    const defaultCorrectness = once(() => 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(METHOD.HEAD, 'exercises', { query, page, per_page });
+            return 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(METHOD.GET, 'exercises', { query, page, per_page });
+            const digest = 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(METHOD.GET, `exercises/${uuid}`);
+            return response.status === 404
+                ? undefined
+                : response.json().then(doDefaultCorrectness);
+        };
+        return {
+            searchDigest,
+            get,
+            search,
+        };
+    };
+};

package/dist/esm/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/esm/services/fileServer/index.js

@@ -0,0 +1,13 @@
+import { isPlainObject } from '../../guards';
+export const isFileValue = (thing) => 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';
+export const isFolderValue = (thing) => isPlainObject(thing)
+    && Object.keys(thing).every(key => ['dataType', 'files'].includes(key))
+    && thing.dataType === 'folder'
+    && thing.files instanceof Array
+    && thing.files.every(isFileValue);
+export const isFileOrFolder = (thing) => isFileValue(thing) || isFolderValue(thing);

package/dist/esm/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/esm/services/fileServer/localFileServer.js

@@ -0,0 +1,16 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+export const localFileServer = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'local')];
+    const storagePrefix = resolveConfigValue(config.storagePrefix);
+    const fileDir = storagePrefix.then((prefix) => path.join(initializer.dataDir, prefix));
+    const getFileContent = async (source) => {
+        const filePath = path.join(await fileDir, source.path);
+        return fs.promises.readFile(filePath);
+    };
+    return {
+        getFileContent,
+    };
+};

package/dist/esm/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/esm/services/fileServer/s3FileServer.js

@@ -0,0 +1,21 @@
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { once } from '../..';
+import { assertDefined } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+export const s3FileServer = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
+    const bucketName = once(() => resolveConfigValue(config.bucketName));
+    const bucketRegion = once(() => resolveConfigValue(config.bucketRegion));
+    const client = ifDefined(initializer.s3Client, S3Client);
+    const s3Service = once(async () => new client({ apiVersion: '2012-08-10', region: await bucketRegion() }));
+    const getFileContent = async (source) => {
+        const bucket = await bucketName();
+        const command = new GetObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return Buffer.from(await assertDefined(response.Body, new Error('Invalid Response from s3')).transformToByteArray());
+    };
+    return {
+        getFileContent,
+    };
+};

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

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

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

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

package/dist/esm/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 {};