@openstax/ts-utils 1.21.1 → 1.21.3

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

@@ -12,6 +12,8 @@ export declare type FolderValue = {
 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<void>;
+    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/localFileServer.d.ts

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

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

@@ -2,15 +2,69 @@ 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]) => 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);
+        return fs.promises.writeFile(filePath, content);
+    };
     return {
+        getSignedViewerUrl,
         getFileContent,
+        putFileContent,
     };
 };

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

@@ -1,4 +1,5 @@
-import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { once } from '../..';
 import { assertDefined } from '../../assertions';
 import { resolveConfigValue } from '../../config';
@@ -9,13 +10,35 @@ export const s3FileServer = (initializer) => (configProvider) => {
     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() }));
+    /*
+     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
+     */
+    const getSignedViewerUrl = async (source) => {
+        const bucket = (await bucketName());
+        const command = new GetObjectCommand({ Bucket: bucket, Key: source.path });
+        return getSignedUrl(await s3Service(), command, {
+            expiresIn: 3600, // 1 hour
+        });
+    };
     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());
     };
+    const putFileContent = async (source, content) => {
+        const bucket = await bucketName();
+        const command = new PutObjectCommand({
+            Bucket: bucket,
+            Key: source.path,
+            Body: content,
+            ContentType: source.mimeType,
+        });
+        await (await s3Service()).send(command);
+    };
     return {
         getFileContent,
+        putFileContent,
+        getSignedViewerUrl,
     };
 };