@openstax/ts-utils 1.23.0 → 1.24.1

package/dist/cjs/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<FileValue>;
+    getSignedViewerUrl: (source: FileValue) => Promise<string>;
     getFileContent: (source: FileValue) => Promise<Buffer>;
 }
 export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

package/dist/cjs/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> | undefined;
+    host?: import("../../config").ConfigValueProvider<string> | undefined;
     storagePrefix: import("../../config").ConfigValueProvider<string>;
 }; }) => FileServerAdapter;
 export {};

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

@@ -4,20 +4,78 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localFileServer = void 0;
+/* cspell:ignore originalname */
 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 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.once)((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 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;
+    };
     return {
+        getSignedViewerUrl,
         getFileContent,
+        putFileContent,
     };
 };
 exports.localFileServer = localFileServer;

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.s3FileServer = void 0;
+/* cspell:ignore presigner */
 const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
 const __1 = require("../..");
 const assertions_1 = require("../../assertions");
 const config_1 = require("../../config");
@@ -12,14 +14,37 @@ const s3FileServer = (initializer) => (configProvider) => {
     const bucketRegion = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.bucketRegion));
     const client = (0, guards_1.ifDefined)(initializer.s3Client, client_s3_1.S3Client);
     const s3Service = (0, __1.once)(async () => new client({ apiVersion: '2012-08-10', region: await bucketRegion() }));
+    /*
+     * 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 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;
+    };
     return {
         getFileContent,
+        putFileContent,
+        getSignedViewerUrl,
     };
 };
 exports.s3FileServer = s3FileServer;

package/dist/cjs/services/openSearch.d.ts

@@ -0,0 +1,29 @@
+import { RequestBody } from '@opensearch-project/opensearch/lib/Transport';
+import { ConfigProviderForConfig } from '../config';
+import { IndexOptions, SearchOptions } from './searchProvider';
+export declare type Config = {
+    node: string;
+    region: string;
+};
+export interface Initializer<C> {
+    configSpace?: C;
+}
+export declare type IndexConfig = {
+    name: string;
+    mappings: Record<string, any>;
+    pageSize?: number;
+};
+export declare const openSearchService: <T extends RequestBody<Record<string, any>>, C extends string = "deployed">(initializer?: Initializer<C>) => (indexConfig: IndexConfig, configProvider: { [key in C]: {
+    node: import("../config").ConfigValueProvider<string>;
+    region: import("../config").ConfigValueProvider<string>;
+}; }) => {
+    ensureIndexCreated: () => Promise<void>;
+    index: (params: IndexOptions<T>) => Promise<void>;
+    search: (options: SearchOptions) => Promise<{
+        items: Exclude<T, undefined>[];
+        pageSize: number;
+        currentPage: number;
+        totalItems: number;
+        totalPages: number;
+    }>;
+};

package/dist/cjs/services/openSearch.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSearchService = void 0;
+// cspell:ignore opensearch, Sigv
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const opensearch_1 = require("@opensearch-project/opensearch");
+const aws_1 = require("@opensearch-project/opensearch/aws");
+const config_1 = require("../config");
+const guards_1 = require("../guards");
+const helpers_1 = require("../misc/helpers");
+const openSearchService = (initializer = {}) => (indexConfig, configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'deployed')];
+    const pageSize = indexConfig.pageSize || 10;
+    const client = (0, helpers_1.once)(async () => new opensearch_1.Client({
+        ...(0, aws_1.AwsSigv4Signer)({
+            getCredentials: () => (0, credential_provider_node_1.defaultProvider)()(),
+            region: await (0, config_1.resolveConfigValue)(config.region),
+            service: 'es',
+        }),
+        node: await (0, config_1.resolveConfigValue)(config.node),
+    }));
+    const createIndexIfNotExists = async (indices, params) => {
+        const { index } = params;
+        const { body } = await indices.exists({ index });
+        if (!body) {
+            await indices.create(params);
+        }
+    };
+    const ensureIndexCreated = async () => {
+        const { indices } = await client();
+        await createIndexIfNotExists(indices, {
+            index: indexConfig.name,
+            body: {
+                mappings: {
+                    dynamic: false,
+                    properties: indexConfig.mappings
+                }
+            }
+        });
+    };
+    const index = async (params) => {
+        const openSearchClient = await client();
+        await openSearchClient.index({
+            index: indexConfig.name,
+            body: params.body,
+            id: params.id,
+            refresh: true
+        });
+    };
+    const search = async (options) => {
+        const body = { query: { bool: {} } };
+        if (options.query) {
+            body.query.bool.must = {
+                multi_match: {
+                    fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
+                    query: options.query
+                }
+            };
+        }
+        const { must_not } = options;
+        const must = 'filter' in options ? options.filter : options.must;
+        if (must && must.length > 0) {
+            body.query.bool.filter = [];
+            must.forEach((filter) => {
+                const { key } = filter;
+                const values = filter.value instanceof Array ? filter.value : [filter.value];
+                body.query.bool.filter.push({ terms: { [key]: values } });
+            });
+        }
+        if (must_not && must_not.length > 0) {
+            body.query.bool.must_not = [];
+            must_not.forEach((filter) => {
+                const { key } = filter;
+                const values = filter.value instanceof Array ? filter.value : [filter.value];
+                values.forEach((value) => body.query.bool.must_not.push({ term: { [key]: value } }));
+            });
+        }
+        if (options.should && options.should.length > 0) {
+            body.query.bool.should = options.should.map(term => {
+                const { key } = term;
+                const values = term.value instanceof Array ? term.value : [term.value];
+                return { terms: { [key]: values } };
+            });
+            body.query.bool.minimum_should_match = 1;
+        }
+        if (options.page) {
+            body.size = pageSize;
+            body.from = (options.page - 1) * pageSize;
+        }
+        const response = await (await client()).search({
+            body,
+            index: indexConfig.name
+        });
+        if (response.statusCode !== 200) {
+            throw new Error(`Unexpected status code: ${response.statusCode} from OpenSearch`);
+        }
+        const hits = response.body.hits;
+        const items = hits.hits.map((hit) => hit._source).filter(guards_1.isDefined);
+        const currentPage = options.page || 1;
+        const { total } = hits;
+        const totalItems = typeof total === 'number' ? total : total.value;
+        const totalPages = Math.ceil(totalItems / pageSize) || 1;
+        return { items, pageSize, currentPage, totalItems, totalPages };
+    };
+    return { ensureIndexCreated, index, search };
+};
+exports.openSearchService = openSearchService;

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

@@ -18,7 +18,9 @@ const postgresConnection = (initializer) => (configProvider) => {
         database: await (0, config_1.resolveConfigValue)(config.database),
         username: await (0, config_1.resolveConfigValue)(config.username),
         password: await (0, config_1.resolveConfigValue)(config.password),
-        transform: postgres_1.default.camel,
+        transform: {
+            column: { to: postgres_1.default.fromCamel, from: postgres_1.default.toCamel },
+        },
     }));
     const connections = [];
     const sql = (0, helpers_1.once)(async () => {

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

@@ -27,5 +27,6 @@ export interface SearchOptions {
     filter?: Filter[];
     must?: Filter[];
     must_not?: Filter[];
+    should?: Filter[];
 }
 export {};

package/dist/cjs/services/searchProvider/memorySearchTheBadWay.js

@@ -10,6 +10,7 @@ var MatchType;
 (function (MatchType) {
     MatchType[MatchType["Must"] = 0] = "Must";
     MatchType[MatchType["MustNot"] = 1] = "MustNot";
+    MatchType[MatchType["Should"] = 2] = "Should";
 })(MatchType || (MatchType = {}));
 const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
 const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
@@ -21,7 +22,7 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
             const results = (await loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
-                const matchFilters = (filters, mustMatch) => {
+                const matchFilters = (filters, matchType) => {
                     for (const field of filters) {
                         const docValues = (0, __1.coerceArray)(resolveField(document, field));
                         const coerceValue = getFieldType(field) === 'boolean'
@@ -36,11 +37,14 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                             }
                             : (x) => x;
                         const hasMatch = (0, __1.coerceArray)(field.value).map(coerceValue).some(v => docValues.includes(v));
-                        if ((mustMatch === MatchType.Must && !hasMatch) || (mustMatch === MatchType.MustNot && hasMatch)) {
+                        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
                             return false;
                         }
+                        else if (matchType === MatchType.Should && hasMatch) {
+                            return true;
+                        }
                     }
-                    return true;
+                    return matchType !== MatchType.Should;
                 };
                 if (options.query !== undefined) {
                     for (const field of options.fields) {
@@ -61,7 +65,7 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                         }
                     }
                 }
-                const { must_not } = options;
+                const { must_not, should } = options;
                 const must = 'filter' in options ? options.filter : options.must;
                 if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(must, MatchType.Must)) {
                     return undefined;
@@ -69,6 +73,9 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                 if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(must_not, MatchType.MustNot)) {
                     return undefined;
                 }
+                if ((should === null || should === void 0 ? void 0 : should.length) && !matchFilters(should, MatchType.Should)) {
+                    return undefined;
+                }
                 return { document, weight };
             })
                 .filter(guards_1.isDefined)