@openstax/ts-utils 1.34.0 → 1.35.0

package/dist/esm/services/documentStore/dynamoEncoding.js

@@ -0,0 +1,45 @@
+import { isPlainObject } from '../../guards';
+export const encodeDynamoAttribute = (value) => {
+    if (typeof value === 'string') {
+        return { S: value };
+    }
+    if (typeof value === 'number') {
+        return { N: value.toString() };
+    }
+    if (typeof value === 'boolean') {
+        return { BOOL: value };
+    }
+    if (value === null) {
+        return { NULL: true };
+    }
+    if (value instanceof Array) {
+        return { L: value.map(encodeDynamoAttribute) };
+    }
+    if (isPlainObject(value)) {
+        return { M: encodeDynamoDocument(value) };
+    }
+    throw new Error(`unknown attribute type ${typeof value} with value ${value}.`);
+};
+export const encodeDynamoDocument = (base) => Object.fromEntries(Object.entries(base).map(([key, value]) => ([key, encodeDynamoAttribute(value)])));
+export const decodeDynamoAttribute = (value) => {
+    if (value.S !== undefined) {
+        return value.S;
+    }
+    if (value.N !== undefined) {
+        return parseFloat(value.N);
+    }
+    if (value.BOOL !== undefined) {
+        return value.BOOL;
+    }
+    if (value.NULL !== undefined) {
+        return null;
+    }
+    if (value.L !== undefined) {
+        return value.L.map(decodeDynamoAttribute);
+    }
+    if (value.M !== undefined) {
+        return decodeDynamoDocument(value.M);
+    }
+    throw new Error(`unknown attribute type: ${JSON.stringify(value)}.`);
+};
+export const decodeDynamoDocument = (document) => Object.fromEntries(Object.entries(document).map(([key, value]) => ([key, decodeDynamoAttribute(value)])));

package/dist/esm/services/documentStore/fileSystemAssert.d.ts

@@ -0,0 +1 @@
+export declare const assertNoUndefined: (obj: any, path?: string[]) => void;

package/dist/esm/services/documentStore/fileSystemAssert.js

@@ -0,0 +1,10 @@
+export const assertNoUndefined = (obj, path = []) => {
+    if (obj === undefined) {
+        throw new Error(`unknown attribute type ${typeof obj} with value ${obj} at ${path.join('.') || 'root'}.`);
+    }
+    if (obj && typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+            assertNoUndefined(value, [...path, key]);
+        }
+    }
+};

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

@@ -0,0 +1,14 @@
+export type Config = {
+    tableName: string;
+};
+export type DocumentBaseMapType = {
+    [key: string]: DocumentBaseValueTypes;
+};
+export type DocumentBaseListType = DocumentBaseValueTypes[];
+export type DocumentBaseValueTypes = number | boolean | string | null | DocumentBaseMapType | DocumentBaseListType;
+export type DocumentBaseType = {
+    [key: string]: DocumentBaseValueTypes;
+};
+export type TDocument<T> = {
+    [_key in keyof T]: DocumentBaseValueTypes;
+};

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

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

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

@@ -0,0 +1,31 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { Config, TDocument } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+interface Initializer<C> {
+    configSpace?: C;
+    dynamoClient?: DynamoDB;
+}
+export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
+    afterWrite?: (item: T) => void | Promise<void>;
+    batchAfterWrite?: (items: T[]) => void | Promise<void>;
+}) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getItemsByField: (key: keyof T, value: T[K], pageKey?: string) => Promise<{
+        items: T[];
+        nextPageToken: string | undefined;
+    }>;
+    batchGetItem: (ids: T[K][]) => Promise<T[]>;
+    getItem: (id: T[K]) => Promise<T | undefined>;
+    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: Array<{
+            item: T;
+            error: Error;
+        }>;
+    }>;
+};
+export {};

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

@@ -0,0 +1,226 @@
+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 { ConflictError, NotFoundError } from '../../../errors';
+import { ifDefined } from '../../../guards';
+import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
+export const dynamoUnversionedDocumentStore = (initializer) => {
+    const init = ifDefined(initializer, {});
+    const dynamodb = once(() => { var _a; return (_a = init.dynamoClient) !== null && _a !== void 0 ? _a : new DynamoDB({ apiVersion: '2012-08-10' }); });
+    return () => (configProvider) => (_, hashKey, options) => {
+        const tableName = once(() => resolveConfigValue(configProvider[ifDefined(init.configSpace, 'dynamodb')].tableName));
+        return {
+            loadAllDocumentsTheBadWay: async () => {
+                const loadAllResults = async (ExclusiveStartKey) => {
+                    var _a, _b;
+                    const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                    const result = await dynamodb().send(cmd);
+                    const resultItems = (_b = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map((item) => decodeDynamoDocument(item))) !== null && _b !== void 0 ? _b : [];
+                    if (result.LastEvaluatedKey) {
+                        return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                    }
+                    return resultItems;
+                };
+                return loadAllResults();
+            },
+            /*
+             * requires that a global secondary index exist on the table
+             */
+            getItemsByField: async (key, value, pageKey) => {
+                var _a, _b;
+                const ExclusiveStartKey = pageKey
+                    ? JSON.parse(Buffer.from(pageKey, 'base64').toString('utf-8'))
+                    : undefined;
+                const table = await tableName();
+                const cmd = new QueryCommand({
+                    TableName: table,
+                    IndexName: key.toString(),
+                    ExclusiveStartKey,
+                    KeyConditionExpression: '#hk = :hkv',
+                    ExpressionAttributeValues: {
+                        ':hkv': encodeDynamoAttribute(value),
+                    },
+                    ExpressionAttributeNames: {
+                        '#hk': key.toString(),
+                    },
+                });
+                const response = await dynamodb().send(cmd);
+                const items = (_b = (_a = response.Items) === null || _a === void 0 ? void 0 : _a.map((item) => decodeDynamoDocument(item))) !== null && _b !== void 0 ? _b : [];
+                const nextPageToken = response.LastEvaluatedKey;
+                return {
+                    items,
+                    nextPageToken: nextPageToken
+                        ? Buffer.from(JSON.stringify(nextPageToken)).toString('base64')
+                        : undefined,
+                };
+            },
+            batchGetItem: async (ids) => {
+                const table = await tableName();
+                const key = hashKey.toString();
+                const getBatches = async (requestItems) => {
+                    const cmd = new BatchGetItemCommand({
+                        RequestItems: requestItems !== null && requestItems !== void 0 ? requestItems : { [table]: { Keys: ids.map((id) => ({ [key]: encodeDynamoAttribute(id) })) } },
+                    });
+                    const response = await dynamodb().send(cmd);
+                    const currentResponses = response.Responses ?
+                        response.Responses[table].map(response => decodeDynamoDocument(response)) : [];
+                    return currentResponses.concat(response.UnprocessedKeys ? await getBatches(response.UnprocessedKeys) : []);
+                };
+                return getBatches();
+            },
+            getItem: async (id) => {
+                const cmd = new GetItemCommand({
+                    Key: { [hashKey.toString()]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                });
+                return dynamodb().send(cmd).then(result => result.Item ? decodeDynamoDocument(result.Item) : undefined);
+            },
+            /* atomically increments the given item attribute by 1 */
+            incrementItemAttribute: async (id, attribute) => {
+                const key = hashKey.toString();
+                const field = attribute.toString();
+                const cmd = new UpdateItemCommand({
+                    Key: { [key]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                    UpdateExpression: 'ADD #f :one',
+                    ConditionExpression: 'attribute_exists(#k)',
+                    ExpressionAttributeNames: { '#k': hashKey.toString(), '#f': field },
+                    ExpressionAttributeValues: { ':one': { N: '1' } },
+                    ReturnValues: 'ALL_NEW',
+                });
+                return dynamodb().send(cmd).then(async (item) => {
+                    var _a, _b, _c;
+                    const result = (_b = (_a = item.Attributes) === null || _a === void 0 ? void 0 : _a[field]) === null || _b === void 0 ? void 0 : _b['N'];
+                    if (!item.Attributes) {
+                        throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                    }
+                    if (!result) {
+                        throw new NotFoundError(`Item with ${key} "${id}" did not produce field "${field}"`);
+                    }
+                    const updatedDoc = decodeDynamoDocument(item.Attributes);
+                    await ((_c = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _c === void 0 ? void 0 : _c.call(options, updatedDoc));
+                    return parseFloat(result);
+                }).catch((error) => {
+                    throw error.name === 'ConditionalCheckFailedException' ?
+                        new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
+                });
+            },
+            /* replaces only specified attributes with the given data */
+            patchItem: async (item) => {
+                const id = item[hashKey];
+                const key = hashKey.toString();
+                if (!id) {
+                    throw new Error(`Key attribute "${key}" is required for patchItem`);
+                }
+                const entries = Object.entries(item).filter(([field]) => field !== key);
+                if (entries.length === 0) {
+                    throw new Error('No attributes to update');
+                }
+                const updates = [];
+                const expressionAttributeNames = { '#k': key };
+                const expressionAttributeValues = {};
+                entries.forEach(([field, value], index) => {
+                    updates.push(`#f${index} = :f${index}`);
+                    expressionAttributeNames[`#f${index}`] = field;
+                    expressionAttributeValues[`:f${index}`] = encodeDynamoAttribute(value);
+                });
+                const cmd = new UpdateItemCommand({
+                    Key: { [key]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                    UpdateExpression: `SET ${updates.join(', ')}`,
+                    ConditionExpression: 'attribute_exists(#k)',
+                    ExpressionAttributeNames: expressionAttributeNames,
+                    ExpressionAttributeValues: expressionAttributeValues,
+                    ReturnValues: 'ALL_NEW',
+                });
+                return dynamodb().send(cmd).then(async (item) => {
+                    var _a;
+                    if (!item.Attributes) {
+                        throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                    }
+                    const updatedDoc = decodeDynamoDocument(item.Attributes);
+                    await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
+                    return updatedDoc;
+                }).catch((error) => {
+                    throw error.name === 'ConditionalCheckFailedException' ?
+                        new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
+                });
+            },
+            /* replaces the entire document with the given data */
+            putItem: async (item) => {
+                var _a;
+                const cmd = new PutItemCommand({
+                    TableName: await tableName(),
+                    Item: encodeDynamoDocument(item),
+                });
+                const updatedDoc = await dynamodb().send(cmd).then(() => item);
+                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

@@ -0,0 +1,32 @@
+import { Config, TDocument } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+interface Initializer<C> {
+    dataDir: string;
+    fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
+    configSpace?: C;
+}
+export declare const fileSystemUnversionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
+    afterWrite?: (item: T) => void | Promise<void>;
+    batchAfterWrite?: (items: T[]) => void | Promise<void>;
+    skipAssert?: boolean;
+}) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getItemsByField: (key: keyof T, value: T[K], pageKey?: string) => Promise<{
+        items: T[];
+        nextPageToken: string | undefined;
+    }>;
+    batchGetItem: (ids: T[K][]) => Promise<Exclude<Awaited<T>, undefined>[]>;
+    getItem: (id: T[K]) => Promise<T | undefined>;
+    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: Array<{
+            item: T;
+            error: Error;
+        }>;
+    }>;
+};
+export {};

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

@@ -0,0 +1,174 @@
+import * as fsModule from 'fs';
+import path from 'path';
+import { hashValue } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { ConflictError, NotFoundError } from '../../../errors';
+import { ifDefined, isDefined } from '../../../guards';
+import { assertNoUndefined } from '../fileSystemAssert';
+export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
+    var _a;
+    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 skipAssert = (_a = options === null || options === void 0 ? void 0 : options.skipAssert) !== null && _a !== void 0 ? _a : false;
+    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);
+                    }
+                }
+            });
+        });
+    };
+    const 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))));
+    };
+    return {
+        loadAllDocumentsTheBadWay,
+        getItemsByField: async (key, value, pageKey) => {
+            if (!skipAssert)
+                assertNoUndefined(value, [key]);
+            const pageSize = 10;
+            const items = await loadAllDocumentsTheBadWay();
+            const filteredItems = items.filter((item) => item[key] === value);
+            const startIndex = pageKey ? parseInt(pageKey, 10) : 0;
+            const paginatedItems = filteredItems.slice(startIndex, startIndex + pageSize);
+            const nextPageToken = startIndex + pageSize < filteredItems.length
+                ? (startIndex + pageSize).toString()
+                : undefined;
+            return { items: paginatedItems, nextPageToken };
+        },
+        batchGetItem: async (ids) => {
+            const items = await Promise.all(ids.map((id) => {
+                if (!skipAssert)
+                    assertNoUndefined(id, ['id']);
+                return load(hashFilename(id));
+            }));
+            return items.filter(isDefined);
+        },
+        getItem: (id) => {
+            if (!skipAssert)
+                assertNoUndefined(id, ['id']);
+            return load(hashFilename(id));
+        },
+        incrementItemAttribute: async (id, attribute) => {
+            if (!skipAssert)
+                assertNoUndefined(id, ['id']);
+            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 };
+            if (!skipAssert)
+                assertNoUndefined(newItem);
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newItem));
+            });
+        },
+        putItem: async (item) => {
+            if (!skipAssert)
+                assertNoUndefined(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));
+            });
+        },
+        createItem: async (item) => {
+            if (!skipAssert)
+                assertNoUndefined(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) {
+                if (!skipAssert)
+                    assertNoUndefined(item);
+                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/documentStore/unversioned/index.d.ts

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

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

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

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

@@ -0,0 +1,25 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { Config } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+import { VersionedDocumentAuthor, VersionedTDocument } from '.';
+interface Initializer<C> {
+    configSpace?: C;
+    dynamoClient?: DynamoDB;
+}
+export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C>) => <T extends VersionedTDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T, A extends undefined | ((...a: any[]) => Promise<VersionedDocumentAuthor>)>(_: {}, hashKey: K, options?: {
+    afterWrite?: (item: T) => void | Promise<void>;
+    getAuthor?: A;
+}) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getVersions: (id: T[K], startVersion?: number) => Promise<{
+        items: T[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number) => 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">>) => Promise<T>;
+    }>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};