@openstax/ts-utils 1.23.0 → 1.24.2-pre1

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

@@ -1,16 +1,74 @@
+/* cspell:ignore originalname */
 import fs from 'fs';
+import https from 'https';
 import path from 'path';
+import cors from 'cors';
+import express from 'express';
+import multer from 'multer';
+import { assertString } from '../../assertions';
 import { resolveConfigValue } from '../../config';
 import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+/* 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.js

@@ -1,4 +1,6 @@
-import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+/* cspell:ignore presigner */
+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 +11,36 @@ 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 source;
+    };
     return {
         getFileContent,
+        putFileContent,
+        getSignedViewerUrl,
     };
 };

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

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

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

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

package/dist/esm/services/searchProvider/memorySearchTheBadWay.d.ts

@@ -1,6 +1,8 @@
 import { IndexOptions, SearchOptions } from '.';
-export declare const memorySearchTheBadWay: <T>({ loadAllDocumentsTheBadWay }: {
-    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+export declare const memorySearchTheBadWay: <T>({ store }: {
+    store: {
+        loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    };
 }) => {
     ensureIndexCreated: () => Promise<undefined>;
     index: (_options: IndexOptions<T>) => Promise<undefined>;

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

@@ -7,18 +7,19 @@ 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);
-export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
+export const memorySearchTheBadWay = ({ store }) => {
     return {
         ensureIndexCreated: async () => undefined,
         index: async (_options) => undefined,
         search: async (options) => {
             const getFieldType = (field) => { var _a; return (_a = options.fields.find(f => f.key == field.key)) === null || _a === void 0 ? void 0 : _a.type; };
-            const results = (await loadAllDocumentsTheBadWay())
+            const results = (await store.loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
-                const matchFilters = (filters, mustMatch) => {
+                const matchFilters = (filters, matchType) => {
                     for (const field of filters) {
                         const docValues = coerceArray(resolveField(document, field));
                         const coerceValue = getFieldType(field) === 'boolean'
@@ -33,11 +34,14 @@ export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                             }
                             : (x) => x;
                         const hasMatch = 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) {
@@ -58,7 +62,7 @@ export 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;
@@ -66,6 +70,9 @@ export 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(isDefined)

package/dist/esm/services/searchProvider/openSearch.d.ts

@@ -0,0 +1,29 @@
+import { RequestBody } from '@opensearch-project/opensearch/lib/Transport';
+import { ConfigProviderForConfig } from '../../config';
+import { IndexOptions, SearchOptions } from '.';
+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/esm/services/searchProvider/openSearch.js

@@ -0,0 +1,103 @@
+// cspell:ignore opensearch, Sigv
+import { defaultProvider } from '@aws-sdk/credential-provider-node';
+import { Client } from '@opensearch-project/opensearch';
+import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
+import { resolveConfigValue } from '../../config';
+import { ifDefined, isDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+export const openSearchService = (initializer = {}) => (indexConfig, configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
+    const pageSize = indexConfig.pageSize || 10;
+    const client = once(async () => new Client({
+        ...AwsSigv4Signer({
+            getCredentials: () => defaultProvider()(),
+            region: await resolveConfigValue(config.region),
+            service: 'es',
+        }),
+        node: await 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(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 };
+};