@kadoa/node-sdk 0.3.0 → 0.4.0

package/dist/index.js

@@ -2,14 +2,14 @@
 
 var events = require('events');
 var globalAxios2 = require('axios');
-var object = require('es-toolkit/object');
 var url = require('url');
+var object = require('es-toolkit/object');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var globalAxios2__default = /*#__PURE__*/_interopDefault(globalAxios2);
 
-// src/events/index.ts
+// src/core/events/event-emitter.ts
 var KadoaEventEmitter = class extends events.EventEmitter {
   /**
    * Emit a typed SDK event
@@ -50,8 +50,8 @@ var KadoaEventEmitter = class extends events.EventEmitter {
   }
 };
 
-// src/exceptions/kadoa-sdk.exception.ts
-var KadoaSdkException = class _KadoaSdkException extends Error {
+// src/core/exceptions/base.exception.ts
+var _KadoaSdkException = class _KadoaSdkException extends Error {
   constructor(message, options) {
     super(message);
     this.name = "KadoaSdkException";
@@ -80,9 +80,54 @@ var KadoaSdkException = class _KadoaSdkException extends Error {
   toString() {
     return [this.name, this.code, this.message].filter(Boolean).join(": ");
   }
+  toDetailedString() {
+    const parts = [`${this.name}: ${this.message}`, `Code: ${this.code}`];
+    if (this.details && Object.keys(this.details).length > 0) {
+      parts.push(`Details: ${JSON.stringify(this.details, null, 2)}`);
+    }
+    if (this.cause) {
+      parts.push(`Cause: ${this.cause}`);
+    }
+    return parts.join("\n");
+  }
+  static isInstance(error) {
+    return error instanceof _KadoaSdkException;
+  }
+  static wrap(error, extra) {
+    if (error instanceof _KadoaSdkException) return error;
+    const message = extra?.message || (error instanceof Error ? error.message : typeof error === "string" ? error : "Unexpected error");
+    return new _KadoaSdkException(message, {
+      code: "UNKNOWN",
+      details: extra?.details,
+      cause: error
+    });
+  }
 };
-
-// src/exceptions/http.exception.ts
+_KadoaSdkException.ERROR_MESSAGES = {
+  // General errors
+  CONFIG_ERROR: "Invalid configuration provided",
+  AUTH_FAILED: "Authentication failed. Please check your API key",
+  RATE_LIMITED: "Rate limit exceeded. Please try again later",
+  NETWORK_ERROR: "Network error occurred",
+  SERVER_ERROR: "Server error occurred",
+  PARSE_ERROR: "Failed to parse response",
+  // Workflow specific errors
+  NO_WORKFLOW_ID: "Failed to start extraction process - no ID received",
+  WORKFLOW_CREATE_FAILED: "Failed to create workflow",
+  WORKFLOW_TIMEOUT: "Workflow processing timed out",
+  WORKFLOW_UNEXPECTED_STATUS: "Extraction completed with unexpected status",
+  PROGRESS_CHECK_FAILED: "Failed to check extraction progress",
+  DATA_FETCH_FAILED: "Failed to retrieve extracted data from workflow",
+  // Extraction specific errors
+  NO_URLS: "At least one URL is required for extraction",
+  NO_API_KEY: "API key is required for entity detection",
+  LINK_REQUIRED: "Link is required for entity field detection",
+  NO_PREDICTIONS: "No entity predictions returned from the API",
+  EXTRACTION_FAILED: "Data extraction failed for the provided URLs",
+  ENTITY_FETCH_FAILED: "Failed to fetch entity fields"
+};
+var KadoaSdkException = _KadoaSdkException;
+var ERROR_MESSAGES = KadoaSdkException.ERROR_MESSAGES;
 var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
   constructor(message, options) {
     super(message, {
@@ -123,10 +168,43 @@ var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
       responseBody: this.responseBody
     };
   }
-  static mapStatusToCode(error) {
-    const status = error.response?.status;
+  toDetailedString() {
+    const parts = [`${this.name}: ${this.message}`, `Code: ${this.code}`];
+    if (this.httpStatus) {
+      parts.push(`HTTP Status: ${this.httpStatus}`);
+    }
+    if (this.method && this.endpoint) {
+      parts.push(`Request: ${this.method} ${this.endpoint}`);
+    }
+    if (this.requestId) {
+      parts.push(`Request ID: ${this.requestId}`);
+    }
+    if (this.responseBody) {
+      parts.push(
+        `Response Body: ${JSON.stringify(this.responseBody, null, 2)}`
+      );
+    }
+    if (this.details && Object.keys(this.details).length > 0) {
+      parts.push(`Details: ${JSON.stringify(this.details, null, 2)}`);
+    }
+    if (this.cause) {
+      parts.push(`Cause: ${this.cause}`);
+    }
+    return parts.join("\n");
+  }
+  static wrap(error, extra) {
+    if (error instanceof _KadoaHttpException) return error;
+    if (error instanceof KadoaSdkException) return error;
+    if (globalAxios2.isAxiosError(error)) {
+      return _KadoaHttpException.fromAxiosError(error, extra);
+    }
+    return KadoaSdkException.wrap(error, extra);
+  }
+  static mapStatusToCode(errorOrStatus) {
+    const status = typeof errorOrStatus === "number" ? errorOrStatus : errorOrStatus.response?.status;
     if (!status) {
-      return error.code === "ECONNABORTED" ? "TIMEOUT" : error.request ? "NETWORK_ERROR" : "UNKNOWN";
+      if (typeof errorOrStatus === "number") return "UNKNOWN";
+      return errorOrStatus.code === "ECONNABORTED" ? "TIMEOUT" : errorOrStatus.request ? "NETWORK_ERROR" : "UNKNOWN";
     }
     if (status === 401 || status === 403) return "AUTH_ERROR";
     if (status === 404) return "NOT_FOUND";
@@ -137,53 +215,6 @@ var KadoaHttpException = class _KadoaHttpException extends KadoaSdkException {
     return "UNKNOWN";
   }
 };
-function isKadoaSdkException(error) {
-  return error instanceof KadoaSdkException;
-}
-function isKadoaHttpException(error) {
-  return error instanceof KadoaHttpException;
-}
-function wrapKadoaError(error, extra) {
-  if (error instanceof globalAxios2.AxiosError)
-    return KadoaHttpException.fromAxiosError(error, extra);
-  return KadoaSdkException.from(error, extra?.details);
-}
-
-// src/extraction/constants.ts
-var DEFAULT_OPTIONS = {
-  pollingInterval: 5e3,
-  maxWaitTime: 3e5,
-  navigationMode: "single-page",
-  location: { type: "auto" },
-  name: "Untitled Workflow",
-  maxRecords: 99999
-};
-var TERMINAL_RUN_STATES = /* @__PURE__ */ new Set([
-  "FINISHED",
-  "SUCCESS",
-  "FAILED",
-  "ERROR",
-  "STOPPED",
-  "CANCELLED"
-]);
-var SUCCESSFUL_RUN_STATES = /* @__PURE__ */ new Set(["FINISHED", "SUCCESS"]);
-var ENTITY_API_ENDPOINT = "/v4/entity";
-var DEFAULT_API_BASE_URL = "https://api.kadoa.com";
-var ERROR_MESSAGES = {
-  NO_URLS: "At least one URL is required for extraction",
-  NO_API_KEY: "API key is required for entity detection",
-  LINK_REQUIRED: "Link is required for entity field detection",
-  NO_WORKFLOW_ID: "Failed to start extraction process - no ID received",
-  NO_PREDICTIONS: "No entity predictions returned from the API",
-  PARSE_ERROR: "Failed to parse entity response",
-  NETWORK_ERROR: "Network error while fetching entity fields",
-  AUTH_FAILED: "Authentication failed. Please check your API key",
-  RATE_LIMITED: "Rate limit exceeded. Please try again later",
-  SERVER_ERROR: "Server error while fetching entity fields",
-  DATA_FETCH_FAILED: "Failed to retrieve extracted data from workflow",
-  PROGRESS_CHECK_FAILED: "Failed to check extraction progress",
-  EXTRACTION_FAILED: "Data extraction failed for the provided URLs"
-};
 var BASE_PATH = "https://api.kadoa.com".replace(/\/+$/, "");
 var BaseAPI = class {
   constructor(configuration, basePath = BASE_PATH, axios2 = globalAxios2__default.default) {
@@ -1869,411 +1900,549 @@ var Configuration = class {
   }
 };
 
-// src/api-client.ts
+// src/core/patterns/command.ts
+var Command = class {
+};
+
+// src/core/http/client-factory.ts
 var workflowsApiCache = /* @__PURE__ */ new WeakMap();
-function getWorkflowsApi(sdk) {
-  let api = workflowsApiCache.get(sdk);
+function getWorkflowsApi(client) {
+  let api = workflowsApiCache.get(client);
   if (!api) {
-    api = new WorkflowsApi(sdk.configuration, sdk.baseUrl, sdk.axiosInstance);
-    workflowsApiCache.set(sdk, api);
+    api = new WorkflowsApi(
+      client.configuration,
+      client.baseUrl,
+      client.axiosInstance
+    );
+    workflowsApiCache.set(client, api);
   }
   return api;
 }
 
-// src/extraction/data-fetcher.ts
-async function fetchWorkflowData(sdkInstance, workflowId, limit = DEFAULT_OPTIONS.dataLimit) {
-  const workflowsApi = getWorkflowsApi(sdkInstance);
-  try {
-    const response = await workflowsApi.v4WorkflowsWorkflowIdDataGet({
-      workflowId,
-      limit
-    });
-    return response.data.data ?? [];
-  } catch (error) {
-    throw wrapKadoaError(error, {
-      message: ERROR_MESSAGES.DATA_FETCH_FAILED,
-      details: { workflowId, limit }
-    });
+// src/modules/extraction/services/data-fetcher.service.ts
+var DataFetcherService = class {
+  constructor(client) {
+    this.client = client;
   }
-}
+  /**
+   * Fetch extracted data from a workflow
+   *
+   * @param workflowId The workflow ID to fetch data from
+   * @param limit Maximum number of records to retrieve
+   * @returns Array of extracted data objects
+   */
+  async fetchWorkflowData(workflowId, limit) {
+    const workflowsApi = getWorkflowsApi(this.client);
+    try {
+      const response = await workflowsApi.v4WorkflowsWorkflowIdDataGet({
+        workflowId,
+        limit
+      });
+      return response.data.data ?? [];
+    } catch (error) {
+      throw KadoaHttpException.wrap(error, {
+        message: ERROR_MESSAGES.DATA_FETCH_FAILED,
+        details: { workflowId, limit }
+      });
+    }
+  }
+};
 
-// src/extraction/entity-detector.ts
-function validateEntityOptions(options) {
-  if (!options.link) {
-    throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
-      code: "VALIDATION_ERROR",
-      details: { options }
-    });
+// src/core/config/constants.ts
+var DEFAULT_API_BASE_URL = "https://api.kadoa.com";
+
+// src/modules/extraction/services/entity-detector.service.ts
+var ENTITY_API_ENDPOINT = "/v4/entity";
+var EntityDetectorService = class {
+  constructor(client) {
+    this.client = client;
   }
-}
-async function buildRequestHeaders(config) {
-  const headers = {
-    "Content-Type": "application/json",
-    Accept: "application/json"
-  };
-  if (config?.apiKey) {
-    if (typeof config.apiKey === "function") {
-      const apiKeyValue = await config.apiKey("X-API-Key");
-      if (apiKeyValue) {
-        headers["X-API-Key"] = apiKeyValue;
-      }
-    } else if (typeof config.apiKey === "string") {
-      headers["X-API-Key"] = config.apiKey;
+  /**
+   * Fetches entity fields dynamically from the /v4/entity endpoint.
+   * This is a workaround implementation using native fetch since the endpoint
+   * is not yet included in the OpenAPI specification.
+   *
+   * @param options Request options including the link to analyze
+   * @returns EntityPrediction containing the detected entity type and fields
+   */
+  async fetchEntityFields(options) {
+    this.validateEntityOptions(options);
+    const url = `${this.client.baseUrl || DEFAULT_API_BASE_URL}${ENTITY_API_ENDPOINT}`;
+    const headers = await this.buildRequestHeaders();
+    const requestBody = options;
+    try {
+      const response = await this.client.axiosInstance.post(url, requestBody, {
+        headers
+      });
+      const data = response.data;
+      if (!data.success || !data.entityPrediction || data.entityPrediction.length === 0) {
+        throw new KadoaSdkException(ERROR_MESSAGES.NO_PREDICTIONS, {
+          code: "NOT_FOUND",
+          details: {
+            success: data.success,
+            hasPredictions: !!data.entityPrediction,
+            predictionCount: data.entityPrediction?.length || 0,
+            link: options.link
+          }
+        });
+      }
+      return data.entityPrediction[0];
+    } catch (error) {
+      throw KadoaHttpException.wrap(error, {
+        details: {
+          url,
+          link: options.link
+        }
+      });
     }
-  } else {
-    throw new KadoaSdkException(ERROR_MESSAGES.NO_API_KEY, {
-      code: "AUTH_ERROR",
-      details: { hasConfig: !!config, hasApiKey: !!config?.apiKey }
-    });
   }
-  return headers;
-}
-function getErrorCodeFromStatus(status) {
-  if (status === 401 || status === 403) return "AUTH_ERROR";
-  if (status === 404) return "NOT_FOUND";
-  if (status === 429) return "RATE_LIMITED";
-  if (status >= 400 && status < 500) return "VALIDATION_ERROR";
-  if (status >= 500) return "HTTP_ERROR";
-  return "UNKNOWN";
-}
-async function handleErrorResponse(response, url, link) {
-  let errorData;
-  let errorText = "";
-  try {
-    errorText = await response.text();
-    errorData = JSON.parse(errorText);
-  } catch {
-    errorData = { message: errorText || response.statusText };
-  }
-  const baseErrorOptions = {
-    httpStatus: response.status,
-    endpoint: url.toString(),
-    method: "POST",
-    responseBody: errorData,
-    details: {
-      url: url.toString(),
-      link
+  /**
+   * Validates entity request options
+   */
+  validateEntityOptions(options) {
+    if (!options.link) {
+      throw new KadoaSdkException(ERROR_MESSAGES.LINK_REQUIRED, {
+        code: "VALIDATION_ERROR",
+        details: { options }
+      });
     }
-  };
-  if (response.status === 401) {
-    throw new KadoaHttpException(ERROR_MESSAGES.AUTH_FAILED, {
-      ...baseErrorOptions,
-      code: "AUTH_ERROR"
-    });
   }
-  if (response.status === 429) {
-    throw new KadoaHttpException(ERROR_MESSAGES.RATE_LIMITED, {
-      ...baseErrorOptions,
-      code: "RATE_LIMITED"
-    });
-  }
-  if (response.status >= 500) {
-    throw new KadoaHttpException(ERROR_MESSAGES.SERVER_ERROR, {
-      ...baseErrorOptions,
-      code: "HTTP_ERROR"
-    });
-  }
-  throw new KadoaHttpException(
-    `Failed to fetch entity fields: ${errorData?.message || response.statusText}`,
-    {
-      ...baseErrorOptions,
-      code: getErrorCodeFromStatus(response.status)
+  /**
+   * Builds request headers including API key authentication
+   */
+  async buildRequestHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    const config = this.client.configuration;
+    if (config?.apiKey) {
+      if (typeof config.apiKey === "function") {
+        const apiKeyValue = await config.apiKey("X-API-Key");
+        if (apiKeyValue) {
+          headers["X-API-Key"] = apiKeyValue;
+        }
+      } else if (typeof config.apiKey === "string") {
+        headers["X-API-Key"] = config.apiKey;
+      }
+    } else {
+      throw new KadoaSdkException(ERROR_MESSAGES.NO_API_KEY, {
+        code: "AUTH_ERROR",
+        details: { hasConfig: !!config, hasApiKey: !!config?.apiKey }
+      });
     }
-  );
-}
-async function fetchEntityFields(sdk, options) {
-  validateEntityOptions(options);
-  const url = new URL(ENTITY_API_ENDPOINT, sdk.baseUrl || DEFAULT_API_BASE_URL);
-  const headers = await buildRequestHeaders(sdk.configuration);
-  const requestBody = options;
-  let response;
-  try {
-    response = await fetch(url.toString(), {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody)
-    });
-  } catch (error) {
-    throw new KadoaSdkException(ERROR_MESSAGES.NETWORK_ERROR, {
-      code: "NETWORK_ERROR",
-      details: {
-        url: url.toString(),
-        link: options.link
-      },
-      cause: error
-    });
-  }
-  if (!response.ok) {
-    await handleErrorResponse(response, url, options.link);
+    return headers;
   }
-  let data;
-  try {
-    data = await response.json();
-  } catch (error) {
-    throw new KadoaSdkException(ERROR_MESSAGES.PARSE_ERROR, {
-      code: "INTERNAL_ERROR",
-      details: {
-        url: url.toString(),
-        link: options.link
-      },
-      cause: error
-    });
+};
+
+// src/modules/extraction/services/workflow-manager.service.ts
+var TERMINAL_RUN_STATES = /* @__PURE__ */ new Set([
+  "FINISHED",
+  "SUCCESS",
+  "FAILED",
+  "ERROR",
+  "STOPPED",
+  "CANCELLED"
+]);
+var WorkflowManagerService = class {
+  constructor(client) {
+    this.client = client;
   }
-  if (!data.success || !data.entityPrediction || data.entityPrediction.length === 0) {
-    throw new KadoaSdkException(ERROR_MESSAGES.NO_PREDICTIONS, {
-      code: "NOT_FOUND",
-      details: {
-        success: data.success,
-        hasPredictions: !!data.entityPrediction,
-        predictionCount: data.entityPrediction?.length || 0,
-        link: options.link
-      }
-    });
+  /**
+   * Check if a workflow runState is terminal (finished processing)
+   */
+  isTerminalRunState(runState) {
+    if (!runState) return false;
+    return TERMINAL_RUN_STATES.has(runState.toUpperCase());
   }
-  return data.entityPrediction[0];
-}
-
-// src/extraction/workflow-manager.ts
-function isTerminalRunState(runState) {
-  if (!runState) return false;
-  return TERMINAL_RUN_STATES.has(runState.toUpperCase());
-}
-async function createWorkflow(sdkInstance, config) {
-  const workflowsApi = getWorkflowsApi(sdkInstance);
-  const request = {
-    urls: config.urls,
-    navigationMode: config.navigationMode,
-    entity: config.entity,
-    name: config.name,
-    fields: config.fields,
-    bypassPreview: true,
-    limit: config.maxRecords,
-    tags: ["sdk"]
-  };
-  try {
-    const response = await workflowsApi.v4WorkflowsPost({
-      v4WorkflowsPostRequest: request
-    });
-    const workflowId = response.data.workflowId;
-    if (!workflowId) {
-      throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
-        code: "INTERNAL_ERROR",
-        details: { urls: config.urls }
+  /**
+   * Creates a new workflow with the provided configuration
+   */
+  async createWorkflow(config) {
+    const workflowsApi = getWorkflowsApi(this.client);
+    const request = {
+      urls: config.urls,
+      navigationMode: config.navigationMode,
+      entity: config.entity,
+      name: config.name,
+      fields: config.fields,
+      bypassPreview: true,
+      limit: config.maxRecords,
+      tags: ["sdk"]
+    };
+    try {
+      const response = await workflowsApi.v4WorkflowsPost({
+        v4WorkflowsPostRequest: request
+      });
+      const workflowId = response.data.workflowId;
+      if (!workflowId) {
+        throw new KadoaSdkException(ERROR_MESSAGES.NO_WORKFLOW_ID, {
+          code: "INTERNAL_ERROR",
+          details: { response: response.data }
+        });
+      }
+      return workflowId;
+    } catch (error) {
+      throw KadoaHttpException.wrap(error, {
+        message: ERROR_MESSAGES.WORKFLOW_CREATE_FAILED,
+        details: config
       });
     }
-    return workflowId;
-  } catch (error) {
-    throw wrapKadoaError(error, {
-      message: "Failed to create workflow",
-      details: config
-    });
   }
-}
-async function getWorkflowStatus(sdkInstance, workflowId) {
-  const workflowsApi = getWorkflowsApi(sdkInstance);
-  try {
-    const response = await workflowsApi.v4WorkflowsWorkflowIdGet({
-      workflowId
-    });
-    return response.data;
-  } catch (error) {
-    throw wrapKadoaError(error, {
-      message: ERROR_MESSAGES.PROGRESS_CHECK_FAILED,
-      details: { workflowId }
-    });
+  /**
+   * Gets the current status of a workflow
+   */
+  async getWorkflowStatus(workflowId) {
+    const workflowsApi = getWorkflowsApi(this.client);
+    try {
+      const response = await workflowsApi.v4WorkflowsWorkflowIdGet({
+        workflowId
+      });
+      return response.data;
+    } catch (error) {
+      throw KadoaHttpException.wrap(error, {
+        message: ERROR_MESSAGES.PROGRESS_CHECK_FAILED,
+        details: { workflowId }
+      });
+    }
   }
-}
-async function waitForWorkflowCompletion(sdkInstance, workflowId, options) {
-  const pollingInterval = options.pollingInterval;
-  const maxWaitTime = options.maxWaitTime;
-  const startTime = Date.now();
-  let previousState;
-  let previousRunState;
-  while (Date.now() - startTime < maxWaitTime) {
-    const workflow = await getWorkflowStatus(sdkInstance, workflowId);
-    if (workflow.state !== previousState || workflow.runState !== previousRunState) {
-      const statusChange = {
-        workflowId,
-        previousState,
-        previousRunState,
-        currentState: workflow.state,
-        currentRunState: workflow.runState
-      };
-      sdkInstance.emit("extraction:status_changed", statusChange, "extraction");
-      if (options?.onStatusChange) {
-        options.onStatusChange(statusChange);
+  /**
+   * Waits for a workflow to complete processing
+   *
+   * @param workflowId The workflow ID to monitor
+   * @param pollingInterval How often to check the status (in milliseconds)
+   * @param maxWaitTime Maximum time to wait before timing out (in milliseconds)
+   * @param onStatusChange Optional callback for status changes
+   * @returns The final workflow status
+   */
+  async waitForWorkflowCompletion(workflowId, pollingInterval, maxWaitTime, onStatusChange) {
+    const startTime = Date.now();
+    let lastStatus;
+    while (Date.now() - startTime < maxWaitTime) {
+      const currentStatus = await this.getWorkflowStatus(workflowId);
+      if (lastStatus?.state !== currentStatus.state || lastStatus?.runState !== currentStatus.runState) {
+        const eventPayload = {
+          workflowId,
+          previousState: lastStatus?.state,
+          previousRunState: lastStatus?.runState,
+          currentState: currentStatus.state,
+          currentRunState: currentStatus.runState
+        };
+        this.client.emit(
+          "extraction:status_changed",
+          eventPayload,
+          "extraction"
+        );
+        if (onStatusChange) {
+          onStatusChange(lastStatus, currentStatus);
+        }
       }
-      previousState = workflow.state;
-      previousRunState = workflow.runState;
-    }
-    if (isTerminalRunState(workflow.runState)) {
-      return workflow;
+      if (this.isTerminalRunState(currentStatus.runState)) {
+        return currentStatus;
+      }
+      lastStatus = currentStatus;
+      await new Promise((resolve) => setTimeout(resolve, pollingInterval));
     }
-    await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+    throw new KadoaSdkException(ERROR_MESSAGES.WORKFLOW_TIMEOUT, {
+      code: "TIMEOUT",
+      details: {
+        workflowId,
+        maxWaitTime,
+        lastState: lastStatus?.state,
+        lastRunState: lastStatus?.runState
+      }
+    });
   }
-  throw new KadoaSdkException(
-    `Extraction did not complete within ${maxWaitTime / 1e3} seconds`,
-    { code: "TIMEOUT", details: { workflowId, maxWaitTime } }
-  );
-}
+};
 
-// src/extraction/extraction-runner.ts
-function validateExtractionOptions(options) {
-  if (!options.urls || options.urls.length === 0) {
-    throw new KadoaSdkException(ERROR_MESSAGES.NO_URLS, {
-      code: "VALIDATION_ERROR"
-    });
+// src/modules/extraction/commands/run-extraction.command.ts
+var SUCCESSFUL_RUN_STATES = /* @__PURE__ */ new Set(["FINISHED", "SUCCESS"]);
+var DEFAULT_OPTIONS = {
+  pollingInterval: 5e3,
+  maxWaitTime: 3e5,
+  navigationMode: "single-page",
+  location: { type: "auto" },
+  name: "Untitled Workflow",
+  maxRecords: 1e3
+};
+var RunExtractionCommand = class extends Command {
+  constructor(client) {
+    super();
+    this.client = client;
+    this.dataFetcher = new DataFetcherService(client);
+    this.entityDetector = new EntityDetectorService(client);
+    this.workflowManager = new WorkflowManagerService(client);
   }
-}
-function isExtractionSuccessful(runState) {
-  return runState ? SUCCESSFUL_RUN_STATES.has(runState.toUpperCase()) : false;
-}
-async function runExtraction(sdkInstance, options) {
-  validateExtractionOptions(options);
-  const config = object.merge(
-    DEFAULT_OPTIONS,
-    options
-  );
-  try {
-    const entityPrediction = await fetchEntityFields(sdkInstance, {
-      link: config.urls[0],
-      location: config.location,
-      navigationMode: config.navigationMode
-    });
-    sdkInstance.emit(
-      "entity:detected",
-      {
-        entity: entityPrediction.entity,
-        fields: entityPrediction.fields,
-        url: config.urls[0]
-      },
-      "extraction",
-      {
-        navigationMode: config.navigationMode,
-        location: config.location
-      }
-    );
-    const workflowId = await createWorkflow(sdkInstance, {
-      entity: entityPrediction.entity,
-      fields: entityPrediction.fields,
-      ...config
-    });
-    sdkInstance.emit(
-      "extraction:started",
-      {
-        workflowId,
-        name: config.name,
-        urls: config.urls
-      },
-      "extraction"
+  /**
+   * Execute the extraction workflow
+   */
+  async execute(options) {
+    this.validateOptions(options);
+    const config = object.merge(
+      DEFAULT_OPTIONS,
+      options
     );
-    const workflow = await waitForWorkflowCompletion(sdkInstance, workflowId, {
-      ...config,
-      pollingInterval: config.pollingInterval,
-      maxWaitTime: config.maxWaitTime
-    });
-    let data;
-    const isSuccess = isExtractionSuccessful(workflow.runState);
-    if (isSuccess) {
-      data = await fetchWorkflowData(sdkInstance, workflowId);
-      if (data) {
-        sdkInstance.emit(
-          "extraction:data_available",
-          {
-            workflowId,
-            recordCount: data.length,
-            isPartial: false
-          },
-          "extraction"
-        );
-      }
-      sdkInstance.emit(
-        "extraction:completed",
+    try {
+      const entityPrediction = await this.entityDetector.fetchEntityFields({
+        link: config.urls[0],
+        location: config.location,
+        navigationMode: config.navigationMode
+      });
+      this.client.emit(
+        "entity:detected",
         {
-          workflowId,
-          success: true,
-          finalRunState: workflow.runState,
-          finalState: workflow.state,
-          recordCount: data?.length
+          entity: entityPrediction.entity,
+          fields: entityPrediction.fields,
+          url: config.urls[0]
         },
-        "extraction"
+        "extraction",
+        {
+          navigationMode: config.navigationMode,
+          location: config.location
+        }
       );
-    } else {
-      sdkInstance.emit(
-        "extraction:completed",
+      const workflowId = await this.workflowManager.createWorkflow({
+        entity: entityPrediction.entity,
+        fields: entityPrediction.fields,
+        ...config
+      });
+      this.client.emit(
+        "extraction:started",
         {
           workflowId,
-          success: false,
-          finalRunState: workflow.runState,
-          finalState: workflow.state,
-          error: `Extraction completed with unexpected status: ${workflow.runState}`
+          name: config.name,
+          urls: config.urls
         },
         "extraction"
       );
-      throw new KadoaSdkException(
-        `Extraction completed with unexpected status: ${workflow.runState}`,
-        {
-          code: "INTERNAL_ERROR",
-          details: {
+      const workflow = await this.workflowManager.waitForWorkflowCompletion(
+        workflowId,
+        config.pollingInterval,
+        config.maxWaitTime
+      );
+      let data;
+      const isSuccess = this.isExtractionSuccessful(workflow.runState);
+      if (isSuccess) {
+        data = await this.dataFetcher.fetchWorkflowData(
+          workflowId,
+          config.maxRecords
+        );
+        if (data) {
+          this.client.emit(
+            "extraction:data_available",
+            {
+              workflowId,
+              recordCount: data.length,
+              isPartial: false
+            },
+            "extraction"
+          );
+        }
+        this.client.emit(
+          "extraction:completed",
+          {
+            workflowId,
+            success: true,
+            finalRunState: workflow.runState,
+            finalState: workflow.state,
+            recordCount: data?.length
+          },
+          "extraction"
+        );
+      } else {
+        this.client.emit(
+          "extraction:completed",
+          {
             workflowId,
-            runState: workflow.runState,
-            state: workflow.state
+            success: false,
+            finalRunState: workflow.runState,
+            finalState: workflow.state,
+            error: `Extraction completed with unexpected status: ${workflow.runState}`
+          },
+          "extraction"
+        );
+        throw new KadoaSdkException(
+          `${ERROR_MESSAGES.WORKFLOW_UNEXPECTED_STATUS}: ${workflow.runState}`,
+          {
+            code: "INTERNAL_ERROR",
+            details: {
+              workflowId,
+              runState: workflow.runState,
+              state: workflow.state
+            }
           }
-        }
-      );
+        );
+      }
+      return {
+        workflowId,
+        workflow,
+        data
+      };
+    } catch (error) {
+      throw KadoaHttpException.wrap(error, {
+        message: ERROR_MESSAGES.EXTRACTION_FAILED,
+        details: { urls: options.urls }
+      });
     }
-    return {
-      workflowId,
-      workflow,
-      data
+  }
+  /**
+   * Validates extraction options
+   * @private
+   */
+  validateOptions(options) {
+    if (!options.urls || options.urls.length === 0) {
+      throw new KadoaSdkException(ERROR_MESSAGES.NO_URLS, {
+        code: "VALIDATION_ERROR"
+      });
+    }
+  }
+  /**
+   * Checks if extraction was successful
+   * @private
+   */
+  isExtractionSuccessful(runState) {
+    return runState ? SUCCESSFUL_RUN_STATES.has(runState.toUpperCase()) : false;
+  }
+};
+
+// src/modules/extraction/extraction.module.ts
+var ExtractionModule = class {
+  constructor(client) {
+    this.runExtractionCommand = new RunExtractionCommand(client);
+  }
+  /**
+   * Run extraction workflow using dynamic entity detection
+   *
+   * @param options Extraction configuration options
+   * @returns ExtractionResult containing workflow ID, workflow details, and extracted data
+   *
+   * @example
+   * ```typescript
+   * const result = await client.extraction.run({
+   *   urls: ['https://example.com'],
+   *   name: 'My Extraction'
+   * });
+   * ```
+   */
+  async run(options) {
+    return this.runExtractionCommand.execute(options);
+  }
+};
+
+// src/version.ts
+var SDK_VERSION = "0.4.0";
+var SDK_NAME = "kadoa-node-sdk";
+var SDK_LANGUAGE = "node";
+
+// src/kadoa-client.ts
+var KadoaClient = class {
+  constructor(config) {
+    this._baseUrl = config.baseUrl || "https://api.kadoa.com";
+    this._timeout = config.timeout || 3e4;
+    const configParams = {
+      apiKey: config.apiKey,
+      basePath: this._baseUrl,
+      baseOptions: {
+        headers: {
+          "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
+          "X-SDK-Version": SDK_VERSION,
+          "X-SDK-Language": SDK_LANGUAGE
+        }
+      }
     };
-  } catch (error) {
-    throw wrapKadoaError(error, {
-      message: ERROR_MESSAGES.EXTRACTION_FAILED,
-      details: { urls: options.urls }
+    this._configuration = new Configuration(configParams);
+    this._axiosInstance = globalAxios2__default.default.create({
+      timeout: this._timeout,
+      headers: {
+        "User-Agent": `${SDK_NAME}/${SDK_VERSION}`,
+        "X-SDK-Version": SDK_VERSION,
+        "X-SDK-Language": SDK_LANGUAGE
+      }
     });
+    this._events = new KadoaEventEmitter();
+    this.extraction = new ExtractionModule(this);
   }
-}
-function initializeSdk(config) {
-  const baseUrl = config.baseUrl || "https://api.kadoa.com";
-  const configParams = {
-    apiKey: config.apiKey,
-    basePath: baseUrl
-  };
-  const configuration = new Configuration(configParams);
-  const axiosInstance = globalAxios2__default.default.create({
-    timeout: config.timeout || 3e4
-  });
-  const events = new KadoaEventEmitter();
-  return {
-    configuration,
-    axiosInstance,
-    baseUrl,
-    events,
-    emit: (eventName, payload, source, metadata) => {
-      events.emit(eventName, payload, source, metadata);
-    },
-    onEvent: (listener) => {
-      events.onEvent(listener);
-    },
-    offEvent: (listener) => {
-      events.offEvent(listener);
-    }
-  };
-}
-function dispose(sdkInstance) {
-  if (sdkInstance?.events) {
-    sdkInstance.events.removeAllListeners();
+  /**
+   * Register an event listener
+   *
+   * @param listener Function to handle events
+   */
+  onEvent(listener) {
+    this._events.onEvent(listener);
   }
-}
+  /**
+   * Remove an event listener
+   *
+   * @param listener Function to remove from event handlers
+   */
+  offEvent(listener) {
+    this._events.offEvent(listener);
+  }
+  /**
+   * Emit an event
+   * @internal
+   *
+   * @param eventName The name of the event
+   * @param payload The event payload
+   * @param source Optional source identifier
+   * @param metadata Optional metadata
+   */
+  emit(eventName, payload, source, metadata) {
+    this._events.emit(eventName, payload, source, metadata);
+  }
+  /**
+   * Get the underlying configuration
+   *
+   * @returns The configuration object
+   */
+  get configuration() {
+    return this._configuration;
+  }
+  /**
+   * Get the axios instance
+   *
+   * @returns The axios instance
+   */
+  get axiosInstance() {
+    return this._axiosInstance;
+  }
+  /**
+   * Get the base URL
+   *
+   * @returns The base URL
+   */
+  get baseUrl() {
+    return this._baseUrl;
+  }
+  /**
+   * Get the timeout value
+   *
+   * @returns The timeout in milliseconds
+   */
+  get timeout() {
+    return this._timeout;
+  }
+  /**
+   * Get the event emitter
+   * @internal
+   *
+   * @returns The event emitter
+   */
+  get events() {
+    return this._events;
+  }
+  /**
+   * Dispose of the client and clean up resources
+   */
+  dispose() {
+    this._events?.removeAllListeners();
+  }
+};
 
+exports.ERROR_MESSAGES = ERROR_MESSAGES;
+exports.KadoaClient = KadoaClient;
 exports.KadoaEventEmitter = KadoaEventEmitter;
 exports.KadoaHttpException = KadoaHttpException;
 exports.KadoaSdkException = KadoaSdkException;
-exports.dispose = dispose;
-exports.initializeSdk = initializeSdk;
-exports.isKadoaHttpException = isKadoaHttpException;
-exports.isKadoaSdkException = isKadoaSdkException;
-exports.runExtraction = runExtraction;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map