@fluentcommerce/fc-connect-sdk 0.1.51 → 0.1.53

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

@@ -95,6 +95,70 @@ 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: unknown;
+    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;

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>;

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

@@ -424,6 +424,79 @@ export class FluentVersoriClient {
             return { success: true, statusCode: response.status, message: text };
         }
     }
+    async getEvents(params = {}) {
+        const query = this.buildEventQueryString(params);
+        const endpoint = query ? `/api/v4.1/event?${query}` : '/api/v4.1/event';
+        this.ctx.log.info('[fc-connect-sdk: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,
+        });
+        const response = await this.fetchWithRetry(endpoint, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const text = response.text;
+        if (!response.ok) {
+            this.ctx.log.error('[fc-connect-sdk:event] Failed to search events', {
+                status: response.status,
+                body: text,
+            });
+            this.throwApiError('Get events failed', response.status, text);
+        }
+        try {
+            const result = JSON.parse(text);
+            this.ctx.log.info('[fc-connect-sdk:event] Event search completed', {
+                resultCount: result.count,
+                hasMore: result.hasMore,
+                start: result.start,
+            });
+            return result;
+        }
+        catch {
+            throw new FluentAPIError('Failed to parse event log response', response.status, text);
+        }
+    }
+    async getEventById(eventId) {
+        if (!eventId) {
+            throw new FluentValidationError('eventId is required');
+        }
+        this.ctx.log.info(`[fc-connect-sdk:event] Getting event by ID: ${eventId}`, { eventId });
+        const response = await this.fetchWithRetry(`/api/v4.1/event/${eventId}`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const text = response.text;
+        if (!response.ok) {
+            this.ctx.log.error(`[fc-connect-sdk:event] Failed to get event ${eventId}`, {
+                eventId,
+                status: response.status,
+                body: text,
+            });
+            this.throwApiError(`Get event ${eventId} failed`, response.status, text);
+        }
+        try {
+            const event = JSON.parse(text);
+            this.ctx.log.info(`[fc-connect-sdk:event] Event retrieved: ${event.name}`, {
+                eventId: event.id,
+                name: event.name,
+                type: event.type,
+                eventStatus: event.eventStatus,
+                entityType: event.context?.entityType,
+            });
+            return event;
+        }
+        catch {
+            throw new FluentAPIError('Failed to parse event response', response.status, text);
+        }
+    }
     async createJob(payload) {
         this.ctx.log.info(`[fc-connect-sdk:job] Creating job "${payload.name}"`, {
             name: payload.name,
@@ -571,6 +644,16 @@ export class FluentVersoriClient {
         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();
+    }
     throwApiError(message, status, responseText) {
         if (status === 401) {
             throw new AuthenticationError(`${message}: ${responseText}`, { response: responseText });