@openstax/ts-utils 1.34.0 → 1.34.1

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

@@ -0,0 +1,25 @@
+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]: ConfigProviderForConfig<Config>; }) => <K extends keyof T, A extends undefined | ((...a: any[]) => Promise<VersionedDocumentAuthor>)>(_: {}, hashKey: K, options?: {
+    getAuthor?: A;
+    skipAssert?: boolean;
+}) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getVersions: (id: T[K], startVersion?: number) => Promise<{
+        items: T[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number) => 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">>) => Promise<T>;
+    }>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileSystemVersionedDocumentStore = void 0;
+const fileSystemAssert_1 = require("../fileSystemAssert");
+const file_system_1 = require("../unversioned/file-system");
+const PAGE_LIMIT = 5;
+const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
+    var _a;
+    const skipAssert = (_a = options === null || options === void 0 ? void 0 : options.skipAssert) !== null && _a !== void 0 ? _a : false;
+    const unversionedDocuments = (0, file_system_1.fileSystemUnversionedDocumentStore)(initializer)()(configProvider)({}, 'id', { skipAssert });
+    return {
+        loadAllDocumentsTheBadWay: () => {
+            return unversionedDocuments.loadAllDocumentsTheBadWay().then(documents => documents.map(document => {
+                return document.items[document.items.length - 1];
+            }));
+        },
+        getVersions: async (id, startVersion) => {
+            if (!skipAssert)
+                (0, fileSystemAssert_1.assertNoUndefined)(id, ['id']);
+            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) => {
+            if (!skipAssert)
+                (0, fileSystemAssert_1.assertNoUndefined)(id, ['id']);
+            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 = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.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 };
+                    if (!skipAssert)
+                        (0, fileSystemAssert_1.assertNoUndefined)(document);
+                    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 = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
+            const document = { ...item, timestamp: new Date().getTime(), author };
+            if (!skipAssert)
+                (0, fileSystemAssert_1.assertNoUndefined)(document);
+            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 type VersionedDocumentAuthor = {
+    type: 'user';
+    uuid: string;
+    name: string;
+    reason?: string;
+} | {
+    type: 'system';
+    reason: string;
+};
+export type VersionedDocumentRequiredFields = {
+    timestamp: number;
+    author: VersionedDocumentAuthor;
+};
+export type VersionedTDocument<T> = TDocument<T> & VersionedDocumentRequiredFields;
+export 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,67 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+export type Config = {
+    defaultCorrectness?: string;
+    exercisesHost: string;
+    exercisesAuthToken: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export type Answer = {
+    id: number;
+    content_html: string;
+    correctness?: string;
+    feedback_html?: string;
+};
+export type Solution = {
+    images: any[];
+    solution_type: string;
+    content_html: string;
+};
+export 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 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 type ExercisesSearchResults = {
+    total_count: number;
+    items: Exercise[];
+};
+export type ExercisesSearchResultsWithDigest = ExercisesSearchResults & {
+    digest: string;
+};
+export declare const exercisesGateway: <C extends string = "exercises">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => (_: {}) => {
+    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 type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
+export {};

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

@@ -0,0 +1,107 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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,30 @@
+export type FileValue = {
+    dataType: 'file';
+    mimeType: string;
+    path: string;
+    label: string;
+};
+export 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 {
+    putFileContent: (source: FileValue, content: string) => Promise<FileValue>;
+    getSignedViewerUrl: (source: FileValue) => Promise<string>;
+    getPublicViewerUrl: (source: FileValue) => Promise<string>;
+    getFileContent: (source: FileValue) => Promise<Buffer>;
+    getSignedFileUploadConfig: () => Promise<{
+        url: string;
+        payload: {
+            [key: string]: string;
+        };
+    }>;
+    copyFileTo: (source: FileValue, destinationPath: string) => Promise<FileValue>;
+    copyFileToDirectory: (source: FileValue, destinationDirectory: string) => Promise<FileValue>;
+    isTemporaryUpload: (source: FileValue) => boolean;
+    getFileChecksum: (source: FileValue) => Promise<string>;
+    filesEqual: (sourceA: FileValue, sourceB: FileValue) => Promise<boolean>;
+}
+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 type Config = {
+    port?: string;
+    host?: string;
+    storagePrefix: string;
+};
+interface Initializer<C> {
+    dataDir: string;
+    configSpace?: C;
+}
+export declare const localFileServer: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => FileServerAdapter;
+export {};

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

@@ -0,0 +1,132 @@
+"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;
+/* cspell:ignore originalname */
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const multer_1 = __importDefault(require("multer"));
+const uuid_1 = require("uuid");
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const helpers_1 = require("../../misc/helpers");
+/* istanbul ignore next */
+const startServer = (0, helpers_1.memoize)((port, uploadDir) => {
+    // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
+    const upload = (0, multer_1.default)({ dest: uploadDir, preservePath: true });
+    const fileServerApp = (0, express_1.default)();
+    fileServerApp.use((0, cors_1.default)());
+    fileServerApp.use(express_1.default.static(uploadDir));
+    fileServerApp.post('/', upload.single('file'), async (req, res) => {
+        const file = req.file;
+        if (!file) {
+            return res.status(400).send({ message: 'file is required' });
+        }
+        const destinationName = req.body.key.replace('${filename}', file.originalname);
+        const destinationPath = path_1.default.join(uploadDir, destinationName);
+        const destinationDirectory = path_1.default.dirname(destinationPath);
+        await fs_1.default.promises.mkdir(destinationDirectory, { recursive: true });
+        await fs_1.default.promises.rename(file.path, destinationPath);
+        res.status(201).send();
+    });
+    const server = https_1.default.createServer({
+        key: fs_1.default.readFileSync((0, assertions_1.assertString)(process.env.SSL_KEY_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
+        cert: fs_1.default.readFileSync((0, assertions_1.assertString)(process.env.SSL_CRT_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
+    }, fileServerApp);
+    server.once('error', function (err) {
+        if (err.code === 'EADDRINUSE') {
+            // when the local dev server reloads files on every request it doesn't
+            // actually tear down the old modules, so this server only starts on the
+            // first execution and changes in its code will not be reloaded
+            return;
+        }
+        throw err;
+    });
+    server.listen(port);
+    return true;
+});
+const localFileServer = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'local')];
+    const port = (0, config_1.resolveConfigValue)(config.port || '');
+    const host = (0, config_1.resolveConfigValue)(config.host || '');
+    const storagePrefix = (0, config_1.resolveConfigValue)(config.storagePrefix);
+    const fileDir = storagePrefix.then((prefix) => path_1.default.join(initializer.dataDir, prefix));
+    Promise.all([port, fileDir])
+        .then(([port, fileDir]) => port && startServer(port, fileDir));
+    const getSignedViewerUrl = async (source) => {
+        return `https://${await host}:${await port}/${source.path}`;
+    };
+    const getPublicViewerUrl = async (source) => {
+        return `https://${await host}:${await port}/${source.path}`;
+    };
+    const getFileContent = async (source) => {
+        const filePath = path_1.default.join(await fileDir, source.path);
+        return fs_1.default.promises.readFile(filePath);
+    };
+    const putFileContent = async (source, content) => {
+        const filePath = path_1.default.join(await fileDir, source.path);
+        const directory = path_1.default.dirname(filePath);
+        await fs_1.default.promises.mkdir(directory, { recursive: true });
+        await fs_1.default.promises.writeFile(filePath, content);
+        return source;
+    };
+    const getSignedFileUploadConfig = async () => {
+        const prefix = 'uploads/' + (0, uuid_1.v4)();
+        return {
+            url: `https://${await host}:${await port}/`,
+            payload: {
+                key: prefix + '/${filename}',
+            }
+        };
+    };
+    const copyFileTo = async (source, destinationPath) => {
+        const sourcePath = path_1.default.join(await fileDir, source.path);
+        const destPath = path_1.default.join(await fileDir, destinationPath);
+        const destDirectory = path_1.default.dirname(destPath);
+        await fs_1.default.promises.mkdir(destDirectory, { recursive: true });
+        await fs_1.default.promises.copyFile(sourcePath, destPath);
+        return {
+            ...source,
+            path: destinationPath
+        };
+    };
+    const copyFileToDirectory = async (source, destination) => {
+        const destinationPath = path_1.default.join(destination, source.label);
+        return copyFileTo(source, destinationPath);
+    };
+    const isTemporaryUpload = (source) => {
+        return source.path.indexOf('uploads/') === 0;
+    };
+    const getFileChecksum = async (source) => {
+        const filePath = path_1.default.join(await fileDir, source.path);
+        const fileContent = await fs_1.default.promises.readFile(filePath);
+        return crypto_1.default.createHash('md5').update(fileContent).digest('hex');
+    };
+    const filesEqual = async (sourceA, sourceB) => {
+        const [aSum, bSum] = await Promise.all([
+            getFileChecksum(sourceA),
+            getFileChecksum(sourceB)
+        ]);
+        return aSum === bSum;
+    };
+    return {
+        getSignedViewerUrl,
+        getPublicViewerUrl,
+        getFileContent,
+        putFileContent,
+        getSignedFileUploadConfig,
+        copyFileTo,
+        copyFileToDirectory,
+        isTemporaryUpload,
+        getFileChecksum,
+        filesEqual,
+    };
+};
+exports.localFileServer = localFileServer;

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

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

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

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s3FileServer = void 0;
+/* cspell:ignore presigner */
+const path_1 = __importDefault(require("path"));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_presigned_post_1 = require("@aws-sdk/s3-presigned-post");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const uuid_1 = require("uuid");
+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 publicViewerDomain = (0, __1.once)(() => 'publicViewerDomain' in config && config.publicViewerDomain
+        ? (0, config_1.resolveConfigValue)(config.publicViewerDomain)
+        : undefined);
+    const s3Service = (0, __1.once)(async () => {
+        var _a, _b;
+        const args = { apiVersion: '2012-08-10', region: await bucketRegion() };
+        return (_b = (_a = initializer.getS3Client) === null || _a === void 0 ? void 0 : _a.call(initializer, args)) !== null && _b !== void 0 ? _b : new client_s3_1.S3Client(args);
+    });
+    /*
+     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
+     */
+    const getSignedViewerUrl = async (source) => {
+        const bucket = (await bucketName());
+        const command = new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: source.path });
+        return (0, s3_request_presigner_1.getSignedUrl)(await s3Service(), command, {
+            expiresIn: 3600, // 1 hour
+        });
+    };
+    const getPublicViewerUrl = async (source) => {
+        const host = (0, assertions_1.assertDefined)(await publicViewerDomain(), new Error(`Tried to get public viewer URL for ${source.path} but no publicViewerDomain configured`));
+        return `https://${host}/${source.path}`;
+    };
+    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());
+    };
+    const putFileContent = async (source, content) => {
+        const bucket = await bucketName();
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: bucket,
+            Key: source.path,
+            Body: content,
+            ContentType: source.mimeType,
+        });
+        await (await s3Service()).send(command);
+        return source;
+    };
+    /*
+     * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_s3_presigned_post.html
+     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/HTTPPOSTExamples.html
+     * https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html
+     */
+    const getSignedFileUploadConfig = async () => {
+        const prefix = 'uploads/' + (0, uuid_1.v4)();
+        const bucket = (await bucketName());
+        const Conditions = [
+            { acl: 'private' },
+            { bucket },
+            ['starts-with', '$key', prefix]
+        ];
+        const defaultFields = {
+            acl: 'private',
+        };
+        const { url, fields } = await (0, s3_presigned_post_1.createPresignedPost)(await s3Service(), {
+            Bucket: bucket,
+            Key: prefix + '/${filename}',
+            Conditions,
+            Fields: defaultFields,
+            Expires: 3600, // 1 hour
+        });
+        return {
+            url, payload: fields
+        };
+    };
+    const copyFileTo = async (source, destinationPath) => {
+        const bucket = (await bucketName());
+        const destinationPathWithoutLeadingSlash = destinationPath.replace(/^\//, '');
+        const command = new client_s3_1.CopyObjectCommand({
+            Bucket: bucket,
+            Key: destinationPathWithoutLeadingSlash,
+            CopySource: path_1.default.join(bucket, source.path),
+        });
+        await (await s3Service()).send(command);
+        return {
+            ...source,
+            path: destinationPathWithoutLeadingSlash
+        };
+    };
+    const copyFileToDirectory = async (source, destination) => {
+        const destinationPath = path_1.default.join(destination, source.label);
+        return copyFileTo(source, destinationPath);
+    };
+    const isTemporaryUpload = (source) => {
+        return source.path.indexOf('uploads/') === 0;
+    };
+    const getFileChecksum = async (source) => {
+        const bucket = (await bucketName());
+        const command = new client_s3_1.HeadObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return (0, assertions_1.assertDefined)(response.ETag);
+    };
+    const filesEqual = async (sourceA, sourceB) => {
+        const [aSum, bSum] = await Promise.all([getFileChecksum(sourceA), getFileChecksum(sourceB)]);
+        return aSum === bSum;
+    };
+    return {
+        getFileContent,
+        putFileContent,
+        getSignedViewerUrl,
+        getPublicViewerUrl,
+        getSignedFileUploadConfig,
+        copyFileTo,
+        copyFileToDirectory,
+        isTemporaryUpload,
+        getFileChecksum,
+        filesEqual,
+    };
+};
+exports.s3FileServer = s3FileServer;

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; } });