@openstax/ts-utils 1.21.10 → 1.21.11

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

@@ -1,91 +0,0 @@
-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

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

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

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

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

@@ -1,22 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

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

@@ -1,71 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,19 +0,0 @@
-/// <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 {
-    putFileContent: (source: FileValue, content: string) => Promise<FileValue>;
-    getSignedViewerUrl: (source: FileValue) => Promise<string>;
-    getFileContent: (source: FileValue) => Promise<Buffer>;
-}
-export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

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

@@ -1,13 +0,0 @@
-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

@@ -1,17 +0,0 @@
-import { ConfigProviderForConfig } from '../../config';
-import { FileServerAdapter } from '.';
-export declare 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]: {
-    port?: import("../../config").ConfigValueProvider<string> | undefined;
-    host?: import("../../config").ConfigValueProvider<string> | undefined;
-    storagePrefix: import("../../config").ConfigValueProvider<string>;
-}; }) => FileServerAdapter;
-export {};

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

@@ -1,73 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
-import cors from 'cors';
-import express from 'express';
-import multer from 'multer';
-import https from 'https';
-import { once } from "../../misc/helpers";
-import { assertString } from "../../assertions";
-/* istanbul ignore next */
-const startServer = once((port, uploadDir) => {
-    // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
-    const upload = multer({ dest: uploadDir, preservePath: true });
-    const fileServerApp = express();
-    fileServerApp.use(cors());
-    fileServerApp.use(express.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.join(uploadDir, destinationName);
-        const destinationDirectory = path.dirname(destinationPath);
-        await fs.promises.mkdir(destinationDirectory, { recursive: true });
-        await fs.promises.rename(file.path, destinationPath);
-        res.status(201).send();
-    });
-    const server = https.createServer({
-        key: fs.readFileSync(assertString(process.env.SSL_KEY_FILE, new Error('ssl key is required for localFileServer')), 'utf8'),
-        cert: fs.readFileSync(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;
-});
-export const localFileServer = (initializer) => (configProvider) => {
-    const config = configProvider[ifDefined(initializer.configSpace, 'local')];
-    const port = resolveConfigValue(config.port || '');
-    const host = resolveConfigValue(config.host || '');
-    const storagePrefix = resolveConfigValue(config.storagePrefix);
-    const fileDir = storagePrefix.then((prefix) => path.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 getFileContent = async (source) => {
-        const filePath = path.join(await fileDir, source.path);
-        return fs.promises.readFile(filePath);
-    };
-    const putFileContent = async (source, content) => {
-        const filePath = path.join(await fileDir, source.path);
-        const directory = path.dirname(filePath);
-        await fs.promises.mkdir(directory, { recursive: true });
-        await fs.promises.writeFile(filePath, content);
-        return source;
-    };
-    return {
-        getSignedViewerUrl,
-        getFileContent,
-        putFileContent,
-    };
-};

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

@@ -1,16 +0,0 @@
-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 {};