quidproquo-actionprocessor-awslambda 0.0.256 → 0.0.257

package/lib/commonjs/logic/textract/transformExpenseResponse.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTextractExpenseResponse = transformTextractExpenseResponse;
+const FIELD_TYPE_MAPPINGS = {
+    'VENDOR_NAME': 'merchantName',
+    'NAME': 'merchantName',
+    'MERCHANT_NAME': 'merchantName',
+    'VENDOR_ADDRESS': 'merchantAddress',
+    'ADDRESS': 'merchantAddress',
+    'MERCHANT_ADDRESS': 'merchantAddress',
+    'INVOICE_RECEIPT_DATE': 'date',
+    'DATE': 'date',
+    'CURRENCY_CODE': 'currency',
+    'PAYMENT_METHOD': 'paymentMethod',
+    'SUBTOTAL': 'subtotal',
+    'TAX': 'tax',
+    'TOTAL': 'total',
+    'AMOUNT_DUE': 'total',
+    'AMOUNT_PAID': 'amountPaid',
+    'INVOICE_RECEIPT_ID': 'receiptNumber',
+    'INVOICE_ID': 'invoiceNumber',
+    'RECEIPT_ID': 'receiptNumber',
+    'TAX_PAYER_ID': 'taxId',
+    'VENDOR_ABN_NUMBER': 'vendorAbn',
+    'VENDOR_PHONE': 'vendorPhone',
+    'VENDOR_URL': 'vendorUrl',
+};
+const LINE_ITEM_FIELD_MAPPINGS = {
+    'ITEM': 'description',
+    'DESCRIPTION': 'description',
+    'PRODUCT_NAME': 'description',
+    'QUANTITY': 'quantity',
+    'UNIT_PRICE': 'unitPrice',
+    'PRICE': 'total',
+    'AMOUNT': 'total',
+};
+function extractFieldValue(field, forceString = false) {
+    var _a, _b;
+    const text = ((_a = field === null || field === void 0 ? void 0 : field.ValueDetection) === null || _a === void 0 ? void 0 : _a.Text) || ((_b = field === null || field === void 0 ? void 0 : field.Type) === null || _b === void 0 ? void 0 : _b.Text);
+    if (!text)
+        return undefined;
+    // For certain fields, always return as string (dates, IDs, etc.)
+    if (forceString)
+        return text;
+    // Only try to parse as number if it looks like a price/amount (has $ or is purely numeric)
+    const cleanedText = text.replace(/[$,]/g, '').trim();
+    // Check if it's a pure number or price
+    if (/^\d+\.?\d*$/.test(cleanedText) && !text.includes('/') && !text.includes('-')) {
+        const numericValue = parseFloat(cleanedText);
+        if (!isNaN(numericValue))
+            return numericValue;
+    }
+    return text;
+}
+function extractSummaryFields(summaryFields) {
+    var _a, _b, _c;
+    const metadata = {};
+    if (!summaryFields)
+        return metadata;
+    // Fields that should always be strings
+    const stringFields = new Set([
+        'DATE', 'INVOICE_RECEIPT_DATE', 'CURRENCY_CODE', 'PAYMENT_METHOD',
+        'INVOICE_RECEIPT_ID', 'INVOICE_ID', 'RECEIPT_ID', 'TAX_PAYER_ID',
+        'VENDOR_ABN_NUMBER', 'VENDOR_PHONE', 'VENDOR_URL'
+    ]);
+    // Track confidence scores for duplicate fields
+    const fieldConfidence = {};
+    for (const field of summaryFields) {
+        const fieldType = (_b = (_a = field === null || field === void 0 ? void 0 : field.Type) === null || _a === void 0 ? void 0 : _a.Text) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+        if (!fieldType)
+            continue;
+        const confidence = ((_c = field === null || field === void 0 ? void 0 : field.Type) === null || _c === void 0 ? void 0 : _c.Confidence) || 0;
+        const forceString = stringFields.has(fieldType) || fieldType.includes('DATE') || fieldType.includes('ID') || fieldType.includes('NUMBER') || fieldType.includes('PHONE') || fieldType.includes('URL');
+        if (FIELD_TYPE_MAPPINGS[fieldType]) {
+            const mappedKey = FIELD_TYPE_MAPPINGS[fieldType];
+            const value = extractFieldValue(field, forceString);
+            // Only update if value exists and has higher confidence than existing
+            if (value !== undefined) {
+                const existingConfidence = fieldConfidence[mappedKey] || 0;
+                if (confidence > existingConfidence) {
+                    metadata[mappedKey] = value;
+                    fieldConfidence[mappedKey] = confidence;
+                }
+            }
+        }
+        else {
+            // Skip fields that are clearly not useful
+            const fieldKey = fieldType.toLowerCase().replace(/_/g, '');
+            // Skip certain field types that aren't useful in our structure
+            if (['street', 'city', 'addressblock', 'expenserow', 'other'].includes(fieldKey)) {
+                continue;
+            }
+            // Store other unmapped fields for extensibility
+            const value = extractFieldValue(field, forceString);
+            if (value !== undefined && !fieldKey.startsWith('vendor_') && !fieldKey.startsWith('amount_')) {
+                // Use more readable field names
+                const cleanKey = fieldType.toLowerCase().replace(/_/g, '');
+                metadata[cleanKey] = value;
+            }
+        }
+    }
+    // Clean up merchant name - take the first line if multiline
+    if (metadata.merchantName && metadata.merchantName.includes('\n')) {
+        metadata.merchantName = metadata.merchantName.split('\n')[0].trim();
+    }
+    return metadata;
+}
+function extractLineItems(lineItemGroups) {
+    var _a, _b;
+    if (!lineItemGroups || lineItemGroups.length === 0)
+        return undefined;
+    const items = [];
+    for (const group of lineItemGroups) {
+        if (!group.LineItems)
+            continue;
+        for (const lineItem of group.LineItems) {
+            if (!lineItem.LineItemExpenseFields)
+                continue;
+            const item = { description: '' };
+            for (const field of lineItem.LineItemExpenseFields) {
+                const fieldType = (_b = (_a = field === null || field === void 0 ? void 0 : field.Type) === null || _a === void 0 ? void 0 : _a.Text) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+                if (!fieldType)
+                    continue;
+                // Determine if this field should be a string
+                const forceString = fieldType === 'ITEM' || fieldType === 'DESCRIPTION' || fieldType === 'PRODUCT_NAME';
+                if (LINE_ITEM_FIELD_MAPPINGS[fieldType]) {
+                    const mappedKey = LINE_ITEM_FIELD_MAPPINGS[fieldType];
+                    const value = extractFieldValue(field, forceString);
+                    if (value !== undefined) {
+                        item[mappedKey] = value;
+                    }
+                }
+                else if (fieldType !== 'EXPENSE_ROW') {
+                    // Store unmapped fields except expense_row which is just raw text
+                    const value = extractFieldValue(field, forceString);
+                    if (value !== undefined) {
+                        const cleanKey = fieldType.toLowerCase().replace(/_/g, '');
+                        item[cleanKey] = value;
+                    }
+                }
+            }
+            // Only add if we have at least a description or some meaningful data
+            if (item.description || (Object.keys(item).length > 1 && (item.total || item.quantity))) {
+                items.push(item);
+            }
+        }
+    }
+    return items.length > 0 ? items : undefined;
+}
+function extractRawText(blocks) {
+    if (!blocks)
+        return undefined;
+    const textBlocks = blocks
+        .filter(block => block.BlockType === 'LINE' && block.Text)
+        .map(block => block.Text)
+        .join('\n');
+    return textBlocks || undefined;
+}
+function transformTextractExpenseResponse(textractResponse, storageDrive, filePath, includeRaw = true) {
+    var _a;
+    // Process the first expense document (most receipts/invoices have just one)
+    const expenseDoc = (_a = textractResponse.ExpenseDocuments) === null || _a === void 0 ? void 0 : _a[0];
+    const metadata = extractSummaryFields(expenseDoc === null || expenseDoc === void 0 ? void 0 : expenseDoc.SummaryFields);
+    const lineItems = extractLineItems(expenseDoc === null || expenseDoc === void 0 ? void 0 : expenseDoc.LineItemGroups);
+    const rawText = extractRawText(expenseDoc === null || expenseDoc === void 0 ? void 0 : expenseDoc.Blocks);
+    const result = {
+        metadata,
+        lineItems,
+        rawText,
+        source: {
+            storageDrive: storageDrive,
+            filePath: filePath,
+        },
+    };
+    // Include raw response for debugging (can be disabled in production)
+    if (includeRaw) {
+        result._raw = textractResponse;
+    }
+    return result;
+}

package/lib/esm/getActionProcessor/core/file/getFileGenerateTemporaryUploadSecureUrlActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getFileGenerateTemporaryUploadSecureUrlActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/file/getFileGenerateTemporaryUploadSecureUrlActionProcessor.js

@@ -0,0 +1,20 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResultError, ErrorTypeEnum } from 'quidproquo-core';
+import { actionResult, FileActionType } from 'quidproquo-core';
+import { generatePresignedUploadUrl } from '../../../logic/s3/generatePresignedUploadUrl';
+import { resolveStorageDriveBucketName } from './utils';
+const getProcessFileGenerateTemporaryUploadSecureUrl = (qpqConfig) => {
+    return async ({ drive, filepath, expirationMs, contentType }, session) => {
+        try {
+            const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
+            const url = await generatePresignedUploadUrl(s3BucketName, filepath, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), expirationMs, session.correlation, contentType);
+            return actionResult(url);
+        }
+        catch (error) {
+            return actionResultError(ErrorTypeEnum.GenericError, 'Unable to generate temporary upload secure URL', error);
+        }
+    };
+};
+export const getFileGenerateTemporaryUploadSecureUrlActionProcessor = async (qpqConfig) => ({
+    [FileActionType.GenerateTemporaryUploadSecureUrl]: getProcessFileGenerateTemporaryUploadSecureUrl(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/file/index.js

@@ -1,6 +1,7 @@
 import { getFileDeleteActionProcessor } from './getFileDeleteActionProcessor';
 import { getFileExistsActionProcessor } from './getFileExistsActionProcessor';
 import { getFileGenerateTemporarySecureUrlActionProcessor } from './getFileGenerateTemporarySecureUrlActionProcessor';
+import { getFileGenerateTemporaryUploadSecureUrlActionProcessor } from './getFileGenerateTemporaryUploadSecureUrlActionProcessor';
 import { getFileIsColdStorageActionProcessor } from './getFileIsColdStorageActionProcessor';
 import { getFileListDirectoryActionProcessor } from './getFileListDirectoryActionProcessor';
 import { getFileReadBinaryContentsActionProcessor } from './getFileReadBinaryContentsActionProcessor';
@@ -13,6 +14,7 @@ export const getFileActionProcessor = async (qpqConfig, dynamicModuleLoader) =>
     ...(await getFileDeleteActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileExistsActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileGenerateTemporarySecureUrlActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getFileGenerateTemporaryUploadSecureUrlActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileIsColdStorageActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileListDirectoryActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileReadTextContentsActionProcessor(qpqConfig, dynamicModuleLoader)),

package/lib/esm/getActionProcessor/webserver/extract/getExtractExpenseActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getExtractExpenseActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/webserver/extract/getExtractExpenseActionProcessor.js

@@ -0,0 +1,40 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, qpqCoreUtils, } from 'quidproquo-core';
+import { ExtractActionType, ExtractExpenseErrorTypeEnum } from 'quidproquo-webserver';
+import { getConfigRuntimeResourceNameFromConfigWithServiceOverride } from '../../../awsNamingUtils';
+import { analyzeExpenseDocument, transformTextractExpenseResponse } from '../../../logic/textract';
+const resolveStorageDriveBucketName = (drive, qpqConfig) => {
+    const storageDriveConfig = qpqCoreUtils.getStorageDriveByName(drive, qpqConfig);
+    if (!storageDriveConfig) {
+        throw new Error(`Could not find storage drive config for [${drive}]`);
+    }
+    return getConfigRuntimeResourceNameFromConfigWithServiceOverride(storageDriveConfig.owner?.resourceNameOverride || drive, qpqConfig, storageDriveConfig.owner?.module);
+};
+const getProcessExtractExpense = (qpqConfig) => {
+    return async ({ storageDriveName, filePath }) => {
+        try {
+            const bucketName = resolveStorageDriveBucketName(storageDriveName, qpqConfig);
+            const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+            // Call Textract to analyze the expense document
+            const textractResponse = await analyzeExpenseDocument(bucketName, filePath, region);
+            // Transform the response to our format
+            const extractedDocument = transformTextractExpenseResponse(textractResponse, storageDriveName, filePath, true);
+            return actionResult(extractedDocument);
+        }
+        catch (error) {
+            // Handle specific AWS errors with proper error mapping
+            return actionResultErrorFromCaughtError(error, {
+                InvalidS3ObjectException: () => actionResultError(ExtractExpenseErrorTypeEnum.FileNotFound, 'The specified file could not be found or accessed'),
+                NoSuchKey: () => actionResultError(ExtractExpenseErrorTypeEnum.FileNotFound, 'The specified file does not exist'),
+                UnsupportedDocumentException: () => actionResultError(ExtractExpenseErrorTypeEnum.UnsupportedFormat, 'The document format is not supported for expense analysis'),
+                InvalidParameterException: () => actionResultError(ExtractExpenseErrorTypeEnum.InvalidParameter, 'Invalid parameters provided to the extraction service'),
+                ThrottlingException: () => actionResultError(ExtractExpenseErrorTypeEnum.RateLimited, 'Too many requests, please try again later'),
+                InvalidObjectState: () => actionResultError(ExtractExpenseErrorTypeEnum.InvalidStorageClass, 'File is in the wrong storage class'),
+                AccessDenied: () => actionResultError(ExtractExpenseErrorTypeEnum.AccessDenied, 'Access denied to the specified file'),
+            });
+        }
+    };
+};
+export const getExtractExpenseActionProcessor = async (qpqConfig) => ({
+    [ExtractActionType.Expense]: getProcessExtractExpense(qpqConfig),
+});

package/lib/esm/getActionProcessor/webserver/extract/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getExtractActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/webserver/extract/index.js

@@ -0,0 +1,4 @@
+import { getExtractExpenseActionProcessor } from './getExtractExpenseActionProcessor';
+export const getExtractActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getExtractExpenseActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/getActionProcessor/webserver/index.d.ts

@@ -1,3 +1,4 @@
+export * from './extract';
 export * from './serviceFunction';
 export * from './webEntry';
 export * from './websocket';

package/lib/esm/getActionProcessor/webserver/index.js

@@ -1,10 +1,13 @@
+import { getExtractActionProcessor } from './extract';
 import { getServiceFunctionActionProcessor } from './serviceFunction';
 import { getWebEntryActionProcessor } from './webEntry';
 import { getWebsocketActionProcessor } from './websocket';
+export * from './extract';
 export * from './serviceFunction';
 export * from './webEntry';
 export * from './websocket';
 export const getWebserverActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getExtractActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getWebEntryActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getServiceFunctionActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getWebsocketActionProcessor(qpqConfig, dynamicModuleLoader)),

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoUpdate.d.ts

@@ -1,4 +1,4 @@
-import { KvsUpdate, KvsUpdateActionType } from 'quidproquo-core';
+import { KvsUpdate } from 'quidproquo-core';
 import { AttributeValue } from '@aws-sdk/client-dynamodb';
 interface ExpressionAttributeNameMap {
     [key: string]: string;
@@ -7,6 +7,5 @@ export declare const buildUpdateExpressionAttributeNames: (updates: KvsUpdate) =
 export declare const buildUpdateExpressionAttributeValues: (updates: KvsUpdate) => {
     [key: string]: AttributeValue;
 } | undefined;
-export declare const buildDynamoUpdateExpressionForType: (type: KvsUpdateActionType, kvsUpdate: KvsUpdate) => string;
 export declare const buildDynamoUpdateExpression: (updates: KvsUpdate) => string;
 export {};

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoUpdate.js

@@ -31,6 +31,11 @@ export const buildUpdateExpressionAttributeValues = (updates) => {
             const valuePlaceholder = getValueName(update.value);
             attributeValues[valuePlaceholder] = buildAttributeValue(update.value);
         }
+        // Include defaultValue for Increment actions
+        if (update.defaultValue !== undefined && update.defaultValue !== null) {
+            const defaultPlaceholder = getValueName(update.defaultValue);
+            attributeValues[defaultPlaceholder] = buildAttributeValue(update.defaultValue);
+        }
     }
     return Object.keys(attributeValues).length > 0 ? attributeValues : undefined;
 };
@@ -57,6 +62,23 @@ const buildDynamoUpdateExpressionDelete = (update) => {
         return `${getNestedItemName(update.attributePath)}`;
     }
 };
+const buildDynamoUpdateExpressionSetIfNotExists = (update) => {
+    if (update.value === undefined || update.value === null) {
+        throw new Error("Value must be provided for 'SetIfNotExists' action");
+    }
+    const attrPath = getNestedItemName(update.attributePath);
+    return `${attrPath} = if_not_exists(${attrPath}, ${getValueName(update.value)})`;
+};
+const buildDynamoUpdateExpressionIncrement = (update) => {
+    if (update.value === undefined || update.value === null) {
+        throw new Error("Increment value must be provided for 'Increment' action");
+    }
+    if (update.defaultValue === undefined || update.defaultValue === null) {
+        throw new Error("Default value must be provided for 'Increment' action");
+    }
+    const attrPath = getNestedItemName(update.attributePath);
+    return `${attrPath} = if_not_exists(${attrPath}, ${getValueName(update.defaultValue)}) + ${getValueName(update.value)}`;
+};
 const getNestedItemName = (attributePath) => {
     if (Array.isArray(attributePath)) {
         let path = '';
@@ -84,35 +106,36 @@ const buildDynamoUpdateExpressionPart = (update, updateIndex) => {
             return buildDynamoUpdateExpressionAdd(update);
         case KvsUpdateActionType.Delete:
             return buildDynamoUpdateExpressionDelete(update);
+        case KvsUpdateActionType.SetIfNotExists:
+            return buildDynamoUpdateExpressionSetIfNotExists(update);
+        case KvsUpdateActionType.Increment:
+            return buildDynamoUpdateExpressionIncrement(update);
         default:
             throw new Error(`Invalid update action type: ${update.action}`);
     }
 };
-export const buildDynamoUpdateExpressionForType = (type, kvsUpdate) => {
-    const actions = kvsUpdate.filter((update) => update.action === type);
-    // If there are no actions of this type, return an empty string
+// Types that generate SET expressions
+const SET_ACTION_TYPES = [
+    KvsUpdateActionType.Set,
+    KvsUpdateActionType.SetIfNotExists,
+    KvsUpdateActionType.Increment
+];
+const buildDynamoUpdateExpressionForClause = (clause, actionTypes, kvsUpdate) => {
+    const actions = kvsUpdate.filter((update) => actionTypes.includes(update.action));
     if (actions.length === 0) {
         return '';
     }
     const expressions = actions.map((update, index) => buildDynamoUpdateExpressionPart(update, index)).join(', ');
-    switch (type) {
-        case KvsUpdateActionType.Set:
-            return `SET ${expressions}`;
-        case KvsUpdateActionType.Remove:
-            return `REMOVE ${expressions}`;
-        case KvsUpdateActionType.Add:
-            return `ADD ${expressions}`;
-        case KvsUpdateActionType.Delete:
-            return `DELETE ${expressions}`;
-        default:
-            throw new Error(`Invalid update action type: ${type}`);
-    }
+    return `${clause} ${expressions}`;
 };
 export const buildDynamoUpdateExpression = (updates) => {
-    const updatesExpressions = [KvsUpdateActionType.Set, KvsUpdateActionType.Remove, KvsUpdateActionType.Add, KvsUpdateActionType.Delete]
-        .map((kvsUpdateActionType) => buildDynamoUpdateExpressionForType(kvsUpdateActionType, updates))
-        .filter((expression) => !!expression);
-    const result = updatesExpressions.join(' ');
+    const clauses = [
+        buildDynamoUpdateExpressionForClause('SET', SET_ACTION_TYPES, updates),
+        buildDynamoUpdateExpressionForClause('REMOVE', [KvsUpdateActionType.Remove], updates),
+        buildDynamoUpdateExpressionForClause('ADD', [KvsUpdateActionType.Add], updates),
+        buildDynamoUpdateExpressionForClause('DELETE', [KvsUpdateActionType.Delete], updates),
+    ].filter((expression) => !!expression);
+    const result = clauses.join(' ');
     console.log('Update Expression: ', result);
     return result;
 };

package/lib/esm/logic/s3/generatePresignedUploadUrl.d.ts

@@ -0,0 +1 @@
+export declare const generatePresignedUploadUrl: (bucketName: string, objectKey: string, region: string, expirationMs: number, correlationId?: string, contentType?: string) => Promise<string>;

package/lib/esm/logic/s3/generatePresignedUploadUrl.js

@@ -0,0 +1,49 @@
+import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+// import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
+import { createAwsClient } from '../createAwsClient';
+// export const generatePresignedUploadFormUrl = async (
+//   bucketName: string, 
+//   objectKey: string, 
+//   region: string, 
+//   expirationMs: number,
+//   contentType: string | undefined,
+//   maxSizeBytes?: number | undefined
+// ): Promise<{ url: string; fields: Record<string, string> }> => {
+//   const s3Client = createAwsClient(S3Client, { region });
+//   const conditions: any[] = [];
+//   // Add content type condition if provided
+//   if (contentType) {
+//     conditions.push(['eq', '$Content-Type', contentType]);
+//   }
+//   // Add file size limit condition if provided
+//   if (maxSizeBytes) {
+//     conditions.push(['content-length-range', 0, maxSizeBytes]);
+//   }
+//   const presignedPost = await createPresignedPost(s3Client, {
+//     Bucket: bucketName,
+//     Key: objectKey,
+//     Conditions: conditions,
+//     Expires: Math.floor(expirationMs / 1000),
+//   });
+//   return {
+//     url: presignedPost.url,
+//     fields: presignedPost.fields
+//   };
+// };
+export const generatePresignedUploadUrl = async (bucketName, objectKey, region, expirationMs, correlationId, contentType) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    const putObjectCommand = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: objectKey,
+        ContentType: contentType,
+        Metadata: {
+            ...(correlationId && { 'correlation-id': correlationId }),
+            'upload-timestamp': Date.now().toString()
+        }
+    });
+    const url = await getSignedUrl(s3Client, putObjectCommand, {
+        expiresIn: expirationMs / 1000,
+    });
+    return url;
+};

package/lib/esm/logic/textract/analyzeExpense.d.ts

@@ -0,0 +1,51 @@
+export interface TextractExpenseAnalysis {
+    DocumentMetadata?: {
+        Pages?: number;
+    };
+    ExpenseDocuments?: Array<{
+        ExpenseIndex?: number;
+        SummaryFields?: Array<{
+            Type?: {
+                Text?: string;
+                Confidence?: number;
+            };
+            ValueDetection?: {
+                Text?: string;
+                Confidence?: number;
+            };
+            LabelDetection?: {
+                Text?: string;
+                Confidence?: number;
+            };
+            PageNumber?: number;
+        }>;
+        LineItemGroups?: Array<{
+            LineItemGroupIndex?: number;
+            LineItems?: Array<{
+                LineItemExpenseFields?: Array<{
+                    Type?: {
+                        Text?: string;
+                        Confidence?: number;
+                    };
+                    ValueDetection?: {
+                        Text?: string;
+                        Confidence?: number;
+                    };
+                    LabelDetection?: {
+                        Text?: string;
+                        Confidence?: number;
+                    };
+                    PageNumber?: number;
+                }>;
+            }>;
+        }>;
+        Blocks?: Array<{
+            BlockType?: string;
+            Text?: string;
+            Confidence?: number;
+            Page?: number;
+            Id?: string;
+        }>;
+    }>;
+}
+export declare const analyzeExpenseDocument: (bucketName: string, documentKey: string, region: string) => Promise<TextractExpenseAnalysis>;

package/lib/esm/logic/textract/analyzeExpense.js

@@ -0,0 +1,18 @@
+import { AnalyzeExpenseCommand, TextractClient } from '@aws-sdk/client-textract';
+import { createAwsClient } from '../createAwsClient';
+export const analyzeExpenseDocument = async (bucketName, documentKey, region) => {
+    const textractClient = createAwsClient(TextractClient, { region });
+    const command = new AnalyzeExpenseCommand({
+        Document: {
+            S3Object: {
+                Bucket: bucketName,
+                Name: documentKey,
+            },
+        },
+    });
+    const response = await textractClient.send(command);
+    return {
+        DocumentMetadata: response.DocumentMetadata,
+        ExpenseDocuments: response.ExpenseDocuments,
+    };
+};

package/lib/esm/logic/textract/index.d.ts

@@ -0,0 +1,2 @@
+export * from './analyzeExpense';
+export * from './transformExpenseResponse';

package/lib/esm/logic/textract/index.js

@@ -0,0 +1,2 @@
+export * from './analyzeExpense';
+export * from './transformExpenseResponse';

package/lib/esm/logic/textract/transformExpenseResponse.d.ts

@@ -0,0 +1,29 @@
+import { TextractExpenseAnalysis } from './analyzeExpense';
+export interface ExtractedExpenseDocument {
+    metadata: {
+        merchantName?: string;
+        merchantAddress?: string;
+        date?: string;
+        currency?: string;
+        paymentMethod?: string;
+        subtotal?: number;
+        tax?: number;
+        total?: number;
+        [key: string]: any;
+    };
+    lineItems?: Array<{
+        description: string;
+        quantity?: number;
+        unitPrice?: number;
+        total?: number;
+        [key: string]: any;
+    }>;
+    rawText?: string;
+    source: {
+        storageDrive: string;
+        filePath: string;
+        textractJobId?: string;
+    };
+    _raw?: any;
+}
+export declare function transformTextractExpenseResponse(textractResponse: TextractExpenseAnalysis, storageDrive: string, filePath: string, includeRaw?: boolean): ExtractedExpenseDocument;