@fluentcommerce/fc-connect-sdk 0.1.48 → 0.1.52

package/dist/esm/clients/fluent-client.js

@@ -75,8 +75,9 @@ export class FluentClient {
             paginationEnabled,
             direction: paginationVars.direction,
         });
+        const errorHandling = payload.errorHandling ?? 'throw';
         if (!paginationEnabled) {
-            return this.executeSinglePage(payload);
+            return this.executeSinglePage(payload, errorHandling);
         }
         let direction = payload.pagination?.direction ?? paginationVars.direction;
         if (paginationVars.direction === 'none' && !payload.pagination?.direction) {
@@ -96,16 +97,18 @@ export class FluentClient {
             abortSignal: payload.pagination?.abortSignal,
             onProgress: payload.pagination?.onProgress ?? (() => { }),
             onWarning: payload.pagination?.onWarning ?? ((msg) => this.log('warn', msg)),
+            errorHandling,
         };
         this.log('info', '[FluentClient:graphql] Auto-pagination enabled', {
             maxPages: config.maxPages,
             maxRecords: config.maxRecords,
             timeoutMs: config.timeoutMs,
             direction: config.direction,
+            errorHandling: config.errorHandling,
         });
         return this.executeWithAutoPagination(payload, paginationVars, config);
     }
-    async executeSinglePage(payload) {
+    async executeSinglePage(payload, errorHandling = 'throw') {
         const operationName = payload.operationName || 'unnamed';
         try {
             const apiPayload = {
@@ -122,9 +125,21 @@ export class FluentClient {
                 body: apiPayload,
             });
             if (response.data.errors?.length) {
+                if (errorHandling === 'partial') {
+                    this.log('warn', `[FluentClient:graphql] GraphQL operation "${operationName}" returned partial data with ${response.data.errors.length} error(s)`, {
+                        operationName,
+                        errorMessages: response.data.errors.map(e => e.message),
+                        errorCount: response.data.errors.length,
+                        hasData: !!response.data.data,
+                    });
+                    return {
+                        ...response.data,
+                        hasPartialData: true,
+                    };
+                }
                 this.log('error', `[FluentClient:graphql] GraphQL operation "${operationName}" returned ${response.data.errors.length} error(s)`, {
                     operationName,
-                    errors: response.data.errors,
+                    errorMessages: response.data.errors.map(e => e.message),
                     errorCount: response.data.errors.length,
                 });
                 const firstError = response.data.errors[0];
@@ -149,6 +164,7 @@ export class FluentClient {
         let lastCursor = null;
         let emptyPageCount = 0;
         const MAX_EMPTY_PAGES = FluentClient.DEFAULT_PAGINATION_CONFIG.maxEmptyPages;
+        const accumulatedErrors = [];
         while (true) {
             if (config.abortSignal?.aborted) {
                 truncated = true;
@@ -169,17 +185,29 @@ export class FluentClient {
             const response = await this.executeSinglePage({
                 query: payload.query,
                 variables: currentVariables,
-            });
+            }, 'partial');
             lastExtensions = response.extensions;
             if (response.errors && response.errors.length > 0) {
-                this.log('error', `[FluentClient:pagination] GraphQL errors during pagination (page ${pageNumber + 1}, ${totalRecords} records fetched so far)`, {
-                    errors: response.errors,
-                    pagesCompleted: pageNumber,
-                    totalRecordsBeforeError: totalRecords,
-                    errorCount: response.errors.length,
-                });
-                const firstError = response.errors[0];
-                throw new GraphQLExecutionError(`GraphQL error during pagination (page ${pageNumber}): ${firstError.message || 'Unknown error'}`, response.errors, payload.query, currentVariables);
+                if (config.errorHandling === 'partial') {
+                    this.log('warn', `[FluentClient:pagination] Page ${pageNumber + 1} returned partial data with ${response.errors.length} error(s)`, {
+                        errorMessages: response.errors.map(e => e.message),
+                        pagesCompleted: pageNumber,
+                        totalRecordsSoFar: totalRecords,
+                        errorCount: response.errors.length,
+                        hasData: !!response.data,
+                    });
+                    accumulatedErrors.push(...response.errors);
+                }
+                else {
+                    this.log('error', `[FluentClient:pagination] GraphQL errors during pagination (page ${pageNumber + 1}, ${totalRecords} records fetched so far)`, {
+                        errorMessages: response.errors.map(e => e.message),
+                        pagesCompleted: pageNumber,
+                        totalRecordsBeforeError: totalRecords,
+                        errorCount: response.errors.length,
+                    });
+                    const firstError = response.errors[0];
+                    throw new GraphQLExecutionError(`GraphQL error during pagination (page ${pageNumber}): ${firstError.message || 'Unknown error'}`, response.errors, payload.query, currentVariables);
+                }
             }
             pageNumber++;
             const connection = extractConnection(response.data, config.connectionPath);
@@ -257,14 +285,17 @@ export class FluentClient {
                 await new Promise(resolve => setTimeout(resolve, config.delayMs));
             }
         }
-        this.log('info', `[FluentClient:pagination] Pagination complete (${pageNumber} pages, ${totalRecords} records${truncated ? `, truncated: ${truncationReason}` : ''})`, {
+        const hasPartialErrors = accumulatedErrors.length > 0;
+        this.log('info', `[FluentClient:pagination] Pagination complete (${pageNumber} pages, ${totalRecords} records${truncated ? `, truncated: ${truncationReason}` : ''}${hasPartialErrors ? `, ${accumulatedErrors.length} errors` : ''})`, {
             totalPages: pageNumber,
             totalRecords,
             truncated,
             truncationReason,
             duration: Date.now() - startTime,
+            hasPartialErrors,
+            errorCount: accumulatedErrors.length,
         });
-        return {
+        const response = {
             data: allData,
             extensions: {
                 ...(lastExtensions || {}),
@@ -277,6 +308,11 @@ export class FluentClient {
                 },
             },
         };
+        if (hasPartialErrors) {
+            response.errors = accumulatedErrors;
+            response.hasPartialData = true;
+        }
+        return response;
     }
     mergeConnectionData(allData, newData, connection, direction) {
         const allConnection = extractConnection(allData);
@@ -474,6 +510,56 @@ export class FluentClient {
             throw error;
         }
     }
+    async getEvents(params = {}) {
+        const queryString = this.buildEventQueryString(params);
+        const endpoint = queryString ? `/api/v4.1/event?${queryString}` : '/api/v4.1/event';
+        this.log('info', '[FluentClient:event] Searching event logs', {
+            endpoint,
+            filterCount: Object.keys(params).length,
+            hasDateRange: !!(params.from || params.to),
+            entityType: params['context.entityType'],
+            rootEntityType: params['context.rootEntityType'],
+            eventStatus: params.eventStatus,
+        });
+        try {
+            const response = await this.request(endpoint, {
+                method: 'GET',
+            });
+            this.log('info', '[FluentClient:event] Event search completed', {
+                resultCount: response.data.count,
+                hasMore: response.data.hasMore,
+                start: response.data.start,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.log('error', '[FluentClient:event] Failed to search events', error);
+            throw error;
+        }
+    }
+    async getEventById(eventId) {
+        if (!eventId) {
+            throw new FluentValidationError('eventId is required');
+        }
+        this.log('info', `[FluentClient:event] Getting event by ID: ${eventId}`, { eventId });
+        try {
+            const response = await this.request(`/api/v4.1/event/${eventId}`, {
+                method: 'GET',
+            });
+            this.log('info', `[FluentClient:event] Event retrieved: ${response.data.name}`, {
+                eventId: response.data.id,
+                name: response.data.name,
+                type: response.data.type,
+                eventStatus: response.data.eventStatus,
+                entityType: response.data.context?.entityType,
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.log('error', `[FluentClient:event] Failed to get event ${eventId}`, error);
+            throw error;
+        }
+    }
     async validateWebhook(payload, signature, rawPayload) {
         this.log('info', `[FluentClient:webhook] Validating webhook for event "${payload.name || 'unknown'}"`, {
             hasSignature: !!signature,
@@ -553,6 +639,16 @@ export class FluentClient {
         const result = await this.graphql(payload);
         return result.data;
     }
+    buildEventQueryString(params) {
+        const searchParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined || value === null || value === '') {
+                continue;
+            }
+            searchParams.append(key, String(value));
+        }
+        return searchParams.toString();
+    }
     async request(endpoint, config = {}) {
         const isVersoriContext = this.context?.fetch && this.context?.fetch !== globalThis.fetch;
         this.log('debug', 'Request mode detection', {

package/dist/esm/data-sources/s3-data-source.js

@@ -342,7 +342,7 @@ export class S3DataSource extends AbstractDataSource {
             return Buffer.from('PAR1\x00\x00\x00\x00PAR1', 'ascii');
         }
         try {
-            const parquet = await import('parquetjs');
+            const parquet = await import('@dsnp/parquetjs');
             const ParquetWriter = parquet.ParquetWriter;
             const ParquetSchema = parquet.ParquetSchema;
             const fs = await import('fs');

package/dist/esm/data-sources/sftp-data-source.js

@@ -322,7 +322,7 @@ export class SftpDataSource extends AbstractDataSource {
             return Buffer.from('PAR1\x00\x00\x00\x00PAR1', 'ascii');
         }
         try {
-            const parquet = await import('parquetjs');
+            const parquet = await import('@dsnp/parquetjs');
             const ParquetWriter = parquet.ParquetWriter;
             const ParquetSchema = parquet.ParquetSchema;
             const fs = await import('fs');

package/dist/esm/index.d.ts

@@ -34,7 +34,7 @@ export { GraphQLTemplateGenerator } from './services/mapping/query/graphql-templ
 export { MappingError, ResolverError } from './errors/index.js';
 export type { NodeConfig, NodesConfig, FieldConfig, FieldsConfig, NodesContext, MappingContext, ResolverFunction, ResolverHelpers, ResolverContext, ResolversMap, MapResult, MapWithNodesResult, NodeValidationResult, MappingOptions, } from './services/mapping/types/index.js';
 export { CsvDelimiter, FileEncoding, JobStrategy, FileType, BatchAction, EntityType, AwsRegion, ValidationMode, ProcessingStatus, } from './types/enums.js';
-export type { FluentClientConfig, FluentBatchPayload, FluentInventoryBatchEntity, FluentInventoryBatchRequest, FluentBatchResponse, FluentBatchStatus, FluentJobPayload, FluentJobResponse, FluentJobMetadata, FluentJobStatus, FluentJobResults, FluentEvent, FluentEventMode, CreateEventOptions, GraphQLPayload, GraphQLResponse, PaginationConfig, PageInfo, PaginatedResponse, FluentWebhookPayload, WebhookRequestContext, GraphQLValidationResult, BatchConfiguration, DataSourceConfig, FileMetadata, Logger, StructuredLogger, LogContext, LoggerConfig, PerformanceMetrics, InventoryDataRecord, ParquetDataRecord, FieldMappingConfig, FieldMappingRule, ProcessingMetadata, AttributeValue, } from './types/index.js';
+export type { FluentClientConfig, FluentBatchPayload, FluentInventoryBatchEntity, FluentInventoryBatchRequest, FluentBatchResponse, FluentBatchStatus, FluentJobPayload, FluentJobResponse, FluentJobMetadata, FluentJobStatus, FluentJobResults, FluentEvent, FluentEventMode, CreateEventOptions, FluentEventRootEntityType, FluentEventEntityType, FluentEventCategory, FluentEventType, FluentEventStatus, FluentEventQueryParamValue, FluentEventQueryParams, FluentEventLogAttribute, FluentEventLogContext, FluentEventLogItem, FluentEventLogResponse, GraphQLPayload, GraphQLResponse, GraphQLErrorMode, GraphQLError, PaginationConfig, PageInfo, PaginatedResponse, FluentWebhookPayload, WebhookRequestContext, GraphQLValidationResult, BatchConfiguration, DataSourceConfig, FileMetadata, Logger, StructuredLogger, LogContext, LoggerConfig, PerformanceMetrics, InventoryDataRecord, ParquetDataRecord, FieldMappingConfig, FieldMappingRule, ProcessingMetadata, AttributeValue, } from './types/index.js';
 export type { VersoriContext, WebhookContext, DirectContext } from './types/index.js';
 export { S3SDKTester, S3PresignedTester, S3ComparisonTester, FluentConnectionTester, type TestResult, type FluentTestConfig, type S3TestConfig, } from './testing/index.js';
 export { S3Service, S3ServiceError, type S3ServiceConfig, type S3Config, type S3Object, type ListOptions, type PutOptions, type CopyOptions, type S3Location, } from './services/s3/index.js';

package/dist/esm/services/extraction/extraction-orchestrator.d.ts

@@ -1,5 +1,5 @@
 import type { FluentClient } from '../../clients/fluent-client.js';
-import type { Logger } from '../../types/index.js';
+import type { Logger, GraphQLErrorMode, GraphQLError } from '../../types/index.js';
 export interface ExtractionOptions<T = any> {
     query: string;
     resultPath: string;
@@ -10,6 +10,8 @@ export interface ExtractionOptions<T = any> {
     direction?: 'forward' | 'backward';
     timeout?: number;
     validateItem?: (item: T) => boolean;
+    operationName?: string;
+    errorHandling?: GraphQLErrorMode;
 }
 export interface ExtractionStats {
     totalRecords: number;
@@ -20,6 +22,7 @@ export interface ExtractionStats {
     validRecords?: number;
     invalidRecords?: number;
     direction?: 'forward' | 'backward';
+    partialErrors?: GraphQLError[];
 }
 export interface ExtractionError {
     type: 'graphql' | 'network' | 'validation' | 'parsing';

package/dist/esm/services/extraction/extraction-orchestrator.js

@@ -17,13 +17,17 @@ export class ExtractionOrchestrator {
         const pageSize = options.pageSize || this.DEFAULT_PAGE_SIZE;
         const timeout = options.timeout || this.DEFAULT_TIMEOUT;
         const direction = options.direction || 'forward';
+        const errorHandling = options.errorHandling || 'throw';
+        const accumulatedGraphQLErrors = [];
         this.logger.info('Starting data extraction', {
+            operationName: options.operationName || 'unnamed',
             resultPath: options.resultPath,
             pageSize,
             maxRecords: options.maxRecords,
             maxPages: options.maxPages,
             timeout,
             direction,
+            errorHandling,
         });
         try {
             const variables = {
@@ -33,16 +37,39 @@ export class ExtractionOrchestrator {
             const response = await this.executeWithTimeout(this.client.graphql({
                 query: options.query,
                 variables,
+                ...(options.operationName && { operationName: options.operationName }),
+                errorHandling,
             }), timeout);
             if (response.errors && response.errors.length > 0) {
-                const graphqlError = new Error(`GraphQL errors: ${response.errors.map((e) => e.message).join(', ')}`);
-                this.logger.error('GraphQL query returned errors', graphqlError, {
-                    errors: response.errors,
+                if (errorHandling === 'partial') {
+                    this.logger.warn('GraphQL query returned partial data with errors (page 1)', {
+                        errors: response.errors,
+                        errorCount: response.errors.length,
+                        hasData: !!response.data,
+                    });
+                    accumulatedGraphQLErrors.push(...response.errors);
+                }
+                else {
+                    const graphqlError = new Error(`GraphQL errors: ${response.errors.map((e) => e.message).join(', ')}`);
+                    this.logger.error('GraphQL query returned errors', graphqlError, {
+                        errors: response.errors,
+                        errorCount: response.errors.length,
+                    });
+                    throw graphqlError;
+                }
+            }
+            let records = [];
+            if (response.data) {
+                records = this.extractFromPath(response.data, options.resultPath);
+            }
+            else if (errorHandling === 'partial' && response.errors && response.errors.length > 0) {
+                this.logger.warn('GraphQL response has errors but no data (page 1), returning empty records', {
                     errorCount: response.errors.length,
                 });
-                throw graphqlError;
             }
-            let records = this.extractFromPath(response.data, options.resultPath);
+            else if (!response.data) {
+                records = this.extractFromPath(response.data, options.resultPath);
+            }
             if (options.maxRecords && records.length > options.maxRecords) {
                 records = records.slice(0, options.maxRecords);
             }
@@ -56,14 +83,21 @@ export class ExtractionOrchestrator {
             const rootPath = edgesIdx >= 0 ? pathParts.slice(0, edgesIdx).join('.') : pathParts.slice(0, -1).join('.');
             const pageInfoPath = rootPath ? `${rootPath}.pageInfo` : 'pageInfo';
             const edgesPath = edgesIdx >= 0 ? `${rootPath}.edges` : options.resultPath;
-            const firstPageInfo = this.safeGet(response.data, pageInfoPath) || {};
+            const firstPageInfo = response.data ? this.safeGet(response.data, pageInfoPath) || {} : {};
             let hasMore = direction === 'forward'
                 ? Boolean(firstPageInfo?.hasNextPage)
                 : Boolean(firstPageInfo?.hasPreviousPage);
-            if (direction === 'backward' && firstPageInfo?.hasPreviousPage === undefined) {
+            if (direction === 'backward' &&
+                response.data &&
+                firstPageInfo?.hasPreviousPage === undefined) {
                 throw new Error('Backward pagination requested but pageInfo.hasPreviousPage is missing from query response');
             }
-            let cursor = this.pickCursor(response.data, edgesPath, direction);
+            if (!response.data && errorHandling === 'partial' && accumulatedGraphQLErrors.length > 0) {
+                hasMore = false;
+            }
+            let cursor = response.data
+                ? this.pickCursor(response.data, edgesPath, direction)
+                : undefined;
             while (hasMore) {
                 if (options.maxPages && totalPages >= options.maxPages) {
                     truncated = true;
@@ -87,11 +121,40 @@ export class ExtractionOrchestrator {
                 const nextPage = await this.executeWithTimeout(this.client.graphql({
                     query: options.query,
                     variables: nextVariables,
+                    ...(options.operationName && { operationName: options.operationName }),
+                    errorHandling,
                 }), timeout);
-                if (!nextPage || nextPage.errors) {
-                    throw new Error(`GraphQL extraction failed on subsequent page${nextPage?.errors ? `: ${JSON.stringify(nextPage.errors)}` : ''}`);
+                if (nextPage?.errors && nextPage.errors.length > 0) {
+                    if (errorHandling === 'partial') {
+                        this.logger.warn(`GraphQL query returned partial data with errors (page ${totalPages + 1})`, {
+                            errors: nextPage.errors,
+                            errorCount: nextPage.errors.length,
+                            hasData: !!nextPage.data,
+                        });
+                        accumulatedGraphQLErrors.push(...nextPage.errors);
+                    }
+                    else {
+                        throw new Error(`GraphQL extraction failed on subsequent page: ${JSON.stringify(nextPage.errors)}`);
+                    }
+                }
+                if (!nextPage) {
+                    throw new Error('GraphQL extraction failed on subsequent page: no response');
+                }
+                let pageRecords = [];
+                if (nextPage.data) {
+                    pageRecords = this.extractFromPath(nextPage.data, options.resultPath);
+                }
+                else if (errorHandling === 'partial' && nextPage.errors && nextPage.errors.length > 0) {
+                    this.logger.warn(`GraphQL response has errors but no data (page ${totalPages + 1}), stopping pagination`, {
+                        errorCount: nextPage.errors.length,
+                    });
+                    hasMore = false;
+                    cursor = undefined;
+                    continue;
+                }
+                else if (!nextPage.data) {
+                    pageRecords = this.extractFromPath(nextPage.data, options.resultPath);
                 }
-                let pageRecords = this.extractFromPath(nextPage.data, options.resultPath);
                 this.validateRecords(pageRecords, options.validateItem);
                 if (options.maxRecords && records.length + pageRecords.length > options.maxRecords) {
                     const remaining = options.maxRecords - records.length;
@@ -125,6 +188,7 @@ export class ExtractionOrchestrator {
                 validRecords: finalValidation.validRecords,
                 invalidRecords: finalValidation.invalidRecords,
                 direction,
+                ...(accumulatedGraphQLErrors.length > 0 && { partialErrors: accumulatedGraphQLErrors }),
             };
             this.logger.info('Data extraction completed', {
                 totalRecords: stats.totalRecords,
@@ -133,7 +197,16 @@ export class ExtractionOrchestrator {
                 truncated: stats.truncated,
                 truncationReason: stats.truncationReason,
                 direction,
+                hasPartialErrors: accumulatedGraphQLErrors.length > 0,
+                partialErrorCount: accumulatedGraphQLErrors.length,
             });
+            if (accumulatedGraphQLErrors.length > 0) {
+                this.logger.warn('Extraction completed with partial errors', {
+                    errorCount: accumulatedGraphQLErrors.length,
+                    recordsExtracted: stats.totalRecords,
+                    message: 'Some GraphQL errors occurred but extraction continued with available data.',
+                });
+            }
             if (stats.truncated) {
                 this.logger.warn('Extraction was truncated', {
                     reason: stats.truncationReason,

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

@@ -95,23 +95,91 @@ export interface FluentEvent {
 export interface CreateEventOptions {
     mode?: FluentEventMode;
 }
+export type FluentEventRootEntityType = 'ORDER' | 'LOCATION' | 'FULFILMENT_OPTIONS' | 'PRODUCT_CATALOGUE' | 'INVENTORY_CATALOGUE' | 'VIRTUAL_CATALOGUE' | 'CONTROL_GROUP' | 'RETURN_ORDER' | 'BILLING_ACCOUNT' | 'JOB';
+export type FluentEventEntityType = 'ORDER' | 'FULFILMENT' | 'ARTICLE' | 'CONSIGNMENT' | 'LOCATION' | 'WAVE' | 'FULFILMENT_OPTIONS' | 'FULFILMENT_PLAN' | 'PRODUCT_CATALOGUE' | 'CATEGORY' | 'PRODUCT' | 'INVENTORY_CATALOGUE' | 'INVENTORY_POSITION' | 'INVENTORY_QUANTITY' | 'VIRTUAL_CATALOGUE' | 'VIRTUAL_POSITION' | 'CONTROL_GROUP' | 'CONTROL' | 'RETURN_ORDER' | 'RETURN_FULFILMENT' | 'BILLING_ACCOUNT' | 'CREDIT_MEMO' | 'BATCH';
+export type FluentEventCategory = 'snapshot' | 'ruleSet' | 'rule' | 'ACTION' | 'CUSTOM' | 'exception' | 'ORDER_WORKFLOW';
+export type FluentEventType = 'ORCHESTRATION' | 'ORCHESTRATION_AUDIT' | 'API' | 'INTEGRATION' | 'SECURITY' | 'GENERAL';
+export type FluentEventStatus = 'PENDING' | 'SCHEDULED' | 'NO_MATCH' | 'SUCCESS' | 'FAILED' | 'COMPLETE';
+export type FluentEventQueryParamValue = string | number | boolean;
+export interface FluentEventQueryParams {
+    start?: number;
+    count?: number;
+    from?: string;
+    to?: string;
+    name?: string;
+    category?: FluentEventCategory | string;
+    retailerId?: string | number;
+    eventType?: FluentEventType | string;
+    eventStatus?: FluentEventStatus | string;
+    eventId?: string;
+    'context.rootEntityType'?: FluentEventRootEntityType | string;
+    'context.rootEntityId'?: string | number;
+    'context.rootEntityRef'?: string;
+    'context.entityType'?: FluentEventEntityType | string;
+    'context.entityId'?: string | number;
+    'context.entityRef'?: string;
+    'context.sourceEvents'?: string;
+    [key: string]: FluentEventQueryParamValue | undefined;
+}
+export interface FluentEventLogContext {
+    sourceEvents?: string[];
+    entityType?: FluentEventEntityType | string;
+    entityId?: string;
+    entityRef?: string;
+    rootEntityType?: FluentEventRootEntityType | string;
+    rootEntityId?: string;
+    rootEntityRef?: string;
+    [key: string]: JsonValue | undefined;
+}
+export interface FluentEventLogAttribute {
+    name: string;
+    value: string;
+    type?: string;
+    [key: string]: unknown;
+}
+export interface FluentEventLogItem {
+    id: string;
+    name: string;
+    type?: FluentEventType | string;
+    accountId?: string;
+    retailerId?: string;
+    category?: FluentEventCategory | string;
+    context?: FluentEventLogContext;
+    eventStatus?: FluentEventStatus | string;
+    attributes?: FluentEventLogAttribute[] | Record<string, JsonValue> | null;
+    source?: string | null;
+    generatedBy?: string;
+    generatedOn?: string;
+    [key: string]: unknown;
+}
+export interface FluentEventLogResponse {
+    start: number;
+    count: number;
+    hasMore: boolean;
+    results: FluentEventLogItem[];
+    [key: string]: unknown;
+}
+export type GraphQLErrorMode = 'throw' | 'partial';
 export interface GraphQLPayload<T = Record<string, JsonValue>> {
     query: string;
     variables?: T;
     operationName?: string;
     pagination?: PaginationConfig;
+    errorHandling?: GraphQLErrorMode;
+}
+export interface GraphQLError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: (string | number)[];
+    extensions?: Record<string, JsonValue>;
+    [key: string]: unknown;
 }
 export interface GraphQLResponse<T = JsonValue> {
     data?: T;
-    errors?: Array<{
-        message: string;
-        locations?: Array<{
-            line: number;
-            column: number;
-        }>;
-        path?: (string | number)[];
-        extensions?: Record<string, JsonValue>;
-    }>;
+    errors?: GraphQLError[];
     extensions?: Record<string, unknown> & {
         autoPagination?: {
             totalPages: number;
@@ -121,6 +189,7 @@ export interface GraphQLResponse<T = JsonValue> {
             direction?: 'forward' | 'backward';
         };
     };
+    hasPartialData?: boolean;
 }
 export interface FluentInventoryBatchEntity {
     locationRef: string;
@@ -359,7 +428,7 @@ export interface Logger {
     debug(message: string, meta?: Record<string, unknown> | undefined): void;
     info(message: string, meta?: Record<string, unknown> | undefined): void;
     warn(message: string, meta?: Record<string, unknown> | undefined): void;
-    error(message: string, error?: Error, meta?: Record<string, unknown> | undefined): void;
+    error(message: string, errorOrMeta?: unknown, meta?: Record<string, unknown>): void;
 }
 export interface LogContext {
     [key: string]: MetadataValue;

package/dist/esm/versori/fluent-versori-client.d.ts

@@ -1,4 +1,4 @@
-import type { FluentEvent, GraphQLPayload, GraphQLResponse, FluentEventMode, JsonValue, FluentBatchPayload, FluentBatchResponse, FluentBatchStatus, FluentJobPayload, FluentJobResponse, FluentJobStatus, FluentJobResults } from '../types/index.js';
+import type { FluentEvent, GraphQLPayload, GraphQLResponse, FluentEventMode, FluentEventLogResponse, FluentEventLogItem, FluentEventQueryParams, JsonValue, FluentBatchPayload, FluentBatchResponse, FluentBatchStatus, FluentJobPayload, FluentJobResponse, FluentJobStatus, FluentJobResults } from '../types/index.js';
 import type { FluentWebhookPayload, EventResponse } from '../types/index.js';
 export declare class FluentVersoriClient {
     private ctx;
@@ -13,6 +13,8 @@ export declare class FluentVersoriClient {
     private executeSinglePage;
     private executeWithAutoPagination;
     sendEvent(event: FluentEvent, mode?: FluentEventMode): Promise<EventResponse>;
+    getEvents(params?: FluentEventQueryParams): Promise<FluentEventLogResponse>;
+    getEventById(eventId: string): Promise<FluentEventLogItem>;
     createJob(payload: FluentJobPayload): Promise<FluentJobResponse>;
     sendBatch(jobId: string, payload: FluentBatchPayload): Promise<FluentBatchResponse>;
     getJobStatus(jobId: string): Promise<FluentJobStatus>;
@@ -20,6 +22,7 @@ export declare class FluentVersoriClient {
     getJobResults(jobId: string): Promise<FluentJobResults>;
     query<T = JsonValue>(queryOrPayload: string | GraphQLPayload, variables?: Record<string, any>): Promise<T | undefined>;
     mutate<T = JsonValue>(mutationOrPayload: string | GraphQLPayload, variables?: Record<string, any>): Promise<T | undefined>;
+    private buildEventQueryString;
     private throwApiError;
     private fetchWithRetry;
     validateWebhook(payload: FluentWebhookPayload, signature?: string, rawPayload?: string, publicKey?: string): Promise<boolean>;