@openstax/ts-utils 1.27.5 → 1.28.1

package/dist/esm/errors/index.d.ts

@@ -75,3 +75,14 @@ export declare class SessionExpiredError extends Error {
     static matches: (e: any) => e is typeof SessionExpiredError;
     constructor(message?: string);
 }
+/**
+ * Conflict error
+ *
+ * `ConflictError.matches(error)` is a reliable way to check if an error is a
+ * `ConflictError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ConflictError extends Error {
+    static readonly TYPE = "ConflictError";
+    static matches: (e: any) => e is typeof ConflictError;
+    constructor(message?: string);
+}

package/dist/esm/errors/index.js

@@ -97,3 +97,16 @@ export class SessionExpiredError extends Error {
 }
 SessionExpiredError.TYPE = 'SessionExpiredError';
 SessionExpiredError.matches = errorIsType(SessionExpiredError);
+/**
+ * Conflict error
+ *
+ * `ConflictError.matches(error)` is a reliable way to check if an error is a
+ * `ConflictError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export class ConflictError extends Error {
+    constructor(message) {
+        super(message || ConflictError.TYPE);
+    }
+}
+ConflictError.TYPE = 'ConflictError';
+ConflictError.matches = errorIsType(ConflictError);

package/dist/esm/fetch/fetchStatusRetry.d.ts

@@ -2,6 +2,7 @@ import { RetryOptions } from '../misc/helpers';
 import { GenericFetch } from '.';
 interface Options extends RetryOptions {
     status?: number[];
+    timeout?: number;
 }
 export declare const fetchStatusRetry: (base: GenericFetch, options: Options) => GenericFetch;
 export {};

package/dist/esm/fetch/fetchStatusRetry.js

@@ -1,12 +1,23 @@
 import { retryWithDelay } from '../misc/helpers';
 export const fetchStatusRetry = (base, options) => {
-    return (...params) => retryWithDelay(() => base(...params).then(r => {
-        var _a;
-        if ((_a = options.status) === null || _a === void 0 ? void 0 : _a.includes(r.status)) {
-            return r.text().then(text => {
-                throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
+    return (...params) => retryWithDelay(() => {
+        const fetchPromise = base(...params).then(r => {
+            var _a;
+            if ((_a = options.status) === null || _a === void 0 ? void 0 : _a.includes(r.status)) {
+                return r.text().then(text => {
+                    throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
+                });
+            }
+            return r;
+        });
+        if (options.timeout) {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`fetch timeout after ${options.timeout}ms: ${params[0]}`));
+                }, options.timeout);
             });
+            return Promise.race([fetchPromise, timeoutPromise]);
         }
-        return r;
-    }), options);
+        return fetchPromise;
+    }, options);
 };

package/dist/esm/guards/index.d.ts

@@ -6,6 +6,14 @@
  * `const result = (array as Array<string | undefined>).filter(isDefined);`
  */
 export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
+/**
+ * checks if a thing is not null. while often easy to do with a simple if statement,
+ * in certain situations the guard is required and its nice to have one pre-defined.
+ * E.g. in the following example, the result is `Array<string>`.
+ *
+ * `const result = (array as Array<string | null>).filter(isNotNull);`
+ */
+export declare const isNotNull: <X>(x: X) => x is Exclude<X, null>;
 /**
  * checks if a thing is a number. while often easy to do with a simple if statement, in certain
  * situations the guard is required and its nice to have one pre-defined. E.g. in the following

package/dist/esm/guards/index.js

@@ -6,6 +6,14 @@
  * `const result = (array as Array<string | undefined>).filter(isDefined);`
  */
 export const isDefined = (x) => x !== undefined;
+/**
+ * checks if a thing is not null. while often easy to do with a simple if statement,
+ * in certain situations the guard is required and its nice to have one pre-defined.
+ * E.g. in the following example, the result is `Array<string>`.
+ *
+ * `const result = (array as Array<string | null>).filter(isNotNull);`
+ */
+export const isNotNull = (x) => x !== null;
 /**
  * checks if a thing is a number. while often easy to do with a simple if statement, in certain
  * situations the guard is required and its nice to have one pre-defined. E.g. in the following

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

@@ -9,6 +9,7 @@ export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamo
     tableName: import("../../../config").ConfigValueProvider<string>;
 }; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
     afterWrite?: ((item: T) => void | Promise<void>) | undefined;
+    batchAfterWrite?: ((items: T[]) => void | Promise<void>) | undefined;
 } | undefined) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getItemsByField: (key: keyof T, value: T[K], pageKey?: string | undefined) => Promise<{
@@ -20,5 +21,13 @@ export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamo
     incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
     patchItem: (item: Partial<T>) => Promise<T>;
     putItem: (item: T) => Promise<T>;
+    createItem: (item: T) => Promise<T>;
+    batchCreateItem: (items: T[], concurrency?: number) => Promise<{
+        successful: T[];
+        failed: {
+            item: T;
+            error: Error;
+        }[];
+    }>;
 };
 export {};

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

@@ -1,7 +1,8 @@
 import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, QueryCommand, ScanCommand, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
+import asyncPool from 'tiny-async-pool';
 import { once } from '../../..';
 import { resolveConfigValue } from '../../../config';
-import { NotFoundError } from '../../../errors';
+import { ConflictError, NotFoundError } from '../../../errors';
 import { ifDefined } from '../../../guards';
 import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
 export const dynamoUnversionedDocumentStore = (initializer) => {
@@ -157,6 +158,69 @@ export const dynamoUnversionedDocumentStore = (initializer) => {
                 await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
                 return updatedDoc;
             },
+            /* creates a new document, fails if the primary key already exists */
+            createItem: async (item) => {
+                const cmd = new PutItemCommand({
+                    TableName: await tableName(),
+                    Item: encodeDynamoDocument(item),
+                    ConditionExpression: 'attribute_not_exists(#k)',
+                    ExpressionAttributeNames: {
+                        '#k': hashKey.toString(),
+                    },
+                });
+                return await dynamodb().send(cmd).then(() => item).catch((error) => {
+                    throw error.name === 'ConditionalCheckFailedException' ?
+                        new ConflictError(`Item with ${String(hashKey)} "${item[hashKey]}" already exists`) : error;
+                }).then(async (createdDoc) => {
+                    var _a;
+                    await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, createdDoc));
+                    return createdDoc;
+                });
+            },
+            /* creates multiple new documents, returns successful and failed items separately */
+            batchCreateItem: async (items, concurrency = 10) => {
+                if (items.length === 0)
+                    return { successful: [], failed: [] };
+                const successful = [];
+                const failed = [];
+                // Process using async iterator (tiny-async-pool v2)
+                for await (const result of asyncPool(concurrency, items, async (item) => {
+                    var _a;
+                    try {
+                        const cmd = new PutItemCommand({
+                            TableName: await tableName(),
+                            Item: encodeDynamoDocument(item),
+                            ConditionExpression: 'attribute_not_exists(#k)',
+                            ExpressionAttributeNames: {
+                                '#k': hashKey.toString(),
+                            },
+                        });
+                        await dynamodb().send(cmd);
+                        // Only call individual afterWrite if batchAfterWrite is not defined
+                        if (!(options === null || options === void 0 ? void 0 : options.batchAfterWrite)) {
+                            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, item));
+                        }
+                        return { success: true, item };
+                    }
+                    catch (error) {
+                        const processedError = error.name === 'ConditionalCheckFailedException' ?
+                            new ConflictError(`Item with ${String(hashKey)} "${item[hashKey]}" already exists`) : error;
+                        return { success: false, item, error: processedError };
+                    }
+                })) {
+                    if (result.success) {
+                        successful.push(result.item);
+                    }
+                    else {
+                        failed.push({ item: result.item, error: result.error });
+                    }
+                }
+                // Call batchAfterWrite with all successful items if defined
+                if ((options === null || options === void 0 ? void 0 : options.batchAfterWrite) && successful.length > 0) {
+                    await options.batchAfterWrite(successful);
+                }
+                return { successful, failed };
+            },
         };
     };
 };

package/dist/esm/services/documentStore/unversioned/file-system.d.ts

@@ -7,7 +7,10 @@ interface Initializer<C> {
 }
 export declare const fileSystemUnversionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
     tableName: import("../../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T>(_: {}, hashKey: K) => {
+}; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
+    afterWrite?: ((item: T) => void | Promise<void>) | undefined;
+    batchAfterWrite?: ((items: T[]) => void | Promise<void>) | undefined;
+} | undefined) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getItemsByField: (key: keyof T, value: T[K], pageKey?: string | undefined) => Promise<{
         items: T[];
@@ -18,5 +21,13 @@ export declare const fileSystemUnversionedDocumentStore: <C extends string = "fi
     incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
     patchItem: (item: Partial<T>) => Promise<T>;
     putItem: (item: T) => Promise<T>;
+    createItem: (item: T) => Promise<T>;
+    batchCreateItem: (items: T[], _concurrency?: number) => Promise<{
+        successful: T[];
+        failed: {
+            item: T;
+            error: Error;
+        }[];
+    }>;
 };
 export {};

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

@@ -2,9 +2,9 @@ import * as fsModule from 'fs';
 import path from 'path';
 import { hashValue } from '../../..';
 import { resolveConfigValue } from '../../../config';
-import { NotFoundError } from '../../../errors';
+import { ConflictError, NotFoundError } from '../../../errors';
 import { ifDefined, isDefined } from '../../../guards';
-export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey) => {
+export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
     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);
@@ -99,5 +99,53 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
                 writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
             });
         },
+        createItem: async (item) => {
+            const hashed = hashFilename(item[hashKey]);
+            const existingItem = await load(hashed);
+            if (existingItem) {
+                throw new ConflictError(`Item with ${String(hashKey)} "${item[hashKey]}" already exists`);
+            }
+            const path = await filePath(hashed);
+            await mkTableDir;
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
+            });
+        },
+        batchCreateItem: async (items, _concurrency = 1) => {
+            var _a;
+            if (items.length === 0)
+                return { successful: [], failed: [] };
+            const successful = [];
+            const failed = [];
+            // Process items sequentially to ensure consistent conflict detection
+            // Note: concurrency parameter is ignored for filesystem to avoid race conditions
+            for (const item of items) {
+                try {
+                    const hashed = hashFilename(item[hashKey]);
+                    const existingItem = await load(hashed);
+                    if (existingItem) {
+                        throw new ConflictError(`Item with ${String(hashKey)} "${item[hashKey]}" already exists`);
+                    }
+                    const path = await filePath(hashed);
+                    await mkTableDir;
+                    const createdItem = await new Promise((resolve, reject) => {
+                        writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
+                    });
+                    successful.push(createdItem);
+                    // Only call individual afterWrite if batchAfterWrite is not defined
+                    if (!(options === null || options === void 0 ? void 0 : options.batchAfterWrite)) {
+                        await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, createdItem));
+                    }
+                }
+                catch (error) {
+                    failed.push({ item, error: error });
+                }
+            }
+            // Call batchAfterWrite with all successful items if defined
+            if ((options === null || options === void 0 ? void 0 : options.batchAfterWrite) && successful.length > 0) {
+                await options.batchAfterWrite(successful);
+            }
+            return { successful, failed };
+        },
     };
 };

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

@@ -1,6 +1,8 @@
 export declare type FieldType = string | string[] | number | boolean;
 export declare type ESFilter = {
     terms: Record<string, FieldType>;
+} | {
+    term: Record<string, FieldType>;
 } | {
     exists: {
         field: string;

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

@@ -84,6 +84,8 @@ const matchClause = (context, clause) => {
         : clause;
     if ('terms' in filter)
         return matchTerms(context, filter.terms);
+    else if ('term' in filter)
+        return matchTerms(context, filter.term);
     else if ('exists' in filter)
         return matchExists(context, filter.exists);
     else if ('bool' in filter)

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

@@ -23,6 +23,9 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
             region: await resolveConfigValue(config.region),
             service: 'es',
         }),
+        maxRetries: 3,
+        requestTimeout: 3000,
+        pingTimeout: 1000,
         node: await resolveConfigValue(config.node),
     }));
     return (indexConfig) => {