@usermaven/sdk-js 1.0.3 → 1.0.6

package/dist/npm/usermaven.d.ts

@@ -24,7 +24,7 @@ export type UsermavenClient = {
   //  * additional detection (user-agent, url and so on will be done). No payload structure is enforced
   //  * @param payload
   //  */
-  rawTrack: (payload: any) => void
+  rawTrack: (payload: any) => Promise<void>
 
   /**
    * Sets a user data including organization/company data
@@ -87,10 +87,23 @@ export type Policy = 'strict' | 'keep' | 'comply'
  */
 export type UsermavenOptions = {
 
+   /**
+   * A custom fetch implementation. Here's how Jitsu decides what functions to use to execute HTTP requests
+   *
+   * - If Jitsu runs in browser, this parameter will be ignored. The best available API (most likely, XMLHttpRequest)
+   *   will be used for sending reqs
+   * - For node Jitsu will use this param. If it's not set, Jitsu will try to search for fetch in global environment
+   *   and will fail if it's absent
+   *
+   *
+   *
+   */
+  fetch?: any,
+
   /**
-   * If auto-capturing is enabled on all sort of events | for future work
+   * Forces Jitsu SDK to use the fetch implementation (custom or default) even in browser
    */
-  autocapture?: boolean,
+  force_use_fetch?: any,
 
   /**
    * If Usermaven should work in compatibility mode. If set to true:
@@ -185,24 +198,79 @@ export type UsermavenOptions = {
    * Log level. 'WARN' if not set
    */
   log_level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'NONE';
+  
+  /**
+   * Headers that should be added to each request. Could be either static dict or function that returns the dict
+   */
+  custom_headers?: Record<string, string> | (() => Record<string, string>)
 
   /**
    * Type of persistence required
    * Possible values: cookie | localStorage | localStorage+cookie | memory
-   * Default value: cookie
+   * 
+   * @default cookie
    */
-   persistence?: PersistenceType;
+  persistence?: PersistenceType;
 
   /**
    * Persistent connection name
    */
-   persistence_name?: string;
+  persistence_name?: string;
+
+  /**
+   * Session tracking time in seconds (x)
+   * After x seconds of inactivity, new session will be created. Default time is 30 minutes i.e 1800 seconds
+   * 
+   * @default 1800
+   */
+  persistence_time?: number;
+
+  /**
+   * Disable session tracking here
+   * 
+   * @default false
+   */
+  disable_persistence?: boolean;
+
+  /**
+   * Auto-capturing is disabled by default
+   * 
+   * @default false
+   */
+  autocapture?: boolean,
+
+  /**
+   * Should a page_view event be triggered on page load
+   * 
+   * @default true
+   */
+  capture_pageview?: boolean,
+
+  /**
+   * To control the payload properties character limit. Defaults to null that means there is no limit. i.e 65535
+   * 
+   * @default null
+   */
+  properties_string_max_length?: number | null,
+
+  /**
+  * Property names that must be exempted from the payload of capture call
+  * 
+  * @default []
+  */
+  property_blacklist?: string[],
 
   /**
    * Persistent connection version
    */
   project_id?: string;
 
+  /**
+   * Enable cookie across subdomain
+   * Default value: true
+   */
+  cross_subdomain_cookie?: boolean;
+
   //NOTE: If any property is added here, please make sure it's added to browser.ts usermavenProps as well
   
 };
@@ -213,6 +281,7 @@ export type UsermavenOptions = {
 export interface CompanyProps {
   id: string; // Company ID
   name: string; // Company Name
+  created_at: string; // Company creation date
   custom: any; // Optional attributes such as industry, website, employee count etc.
 }
 
@@ -255,31 +324,109 @@ export type EventCtx = {
   user: UserProps                  //user properties
   company?: CompanyProps           //company properties
   ids?: ThirdpartyIds              //user ids from external systems
-  user_agent: string               //user
   utc_time: string                 //current UTC time in ISO 8601
   local_tz_offset: number          //local timezone offset (in minutes)
+
+  utm: Record<string, string>      //utm tags (without utm prefix, e.g key will be "source", not utm_source. See
+  click_id: Record<string, string> //all external click ids (passed through URL). See CLICK_IDS for supported all supported click ids
+  [propName: string]: any          //context is extendable, any extra properties can be added here
+  
+}
+
+
+/**
+ * Tracking environment. Encapsulates environment such as Node browser or
+ */
+export type TrackingEnvironment = {
+  /**
+   * Describes "client": page title, url, etc. See type definition
+   */
+  describeClient(): Partial<ClientProperties>;
+  /**
+   * Returns source ip. If IP should be resolved by Jitsu server, this method should return undefined
+   */
+  getSourceIp(): string | undefined;
+
+  /**
+   * Gets (and persists) anonymous id. Example implementation: id can be persisted in cookies or in other way.
+   *
+   */
+  getAnonymousId(cookieOpts: { name: string, domain?: string }): string;
+};
+/**
+ * List of environments where Jitsu tracker can work. See TrackingEnvironment above
+ * to learn what is the environment
+ */
+export type Envs = {
+  // /**
+  //  * Environment where requests and responses are based on fetch API Request & Response object.
+  //  * Example: NextJS Middleware (https://nextjs.org/docs/middleware) is based on this API
+  //  */
+  // fetchApi(req, res);
+  // /**
+  //  * Alias of fetchApi
+  //  */
+  // nextjsMiddleware(req, res);
+
+  /**
+   * Environment where requests and responses are based on core Node.js http APIs (IncomingMessage and Server Response)
+   * Example: NextJS APIs (except Middleware) is based on this one, or Express
+   */
+  httpApi(req, res);
+  /**
+   * Alias of httpApi
+   */
+  nextjsApi(req, res);
+  /**
+   * Alias of httpApi. For requests handled by Express
+   */
+  express(req, res);
+  /**
+   * Browser environment (based on window, document and etc globals)
+   */
+  browser();
+  /**
+   * Empty environment
+   */
+  empty();
+}
+
+declare const envs: Envs;
+
+
+/**
+ * Environment where the event have happened.
+ */
+export type ClientProperties = {
+  screen_resolution: string        //screen resolution
+  user_agent: string               //user
   referer: string                  //document referer
   url: string                      //current url
   page_title: string               //page title
-  //see UTM_TYPES for all supported utm tags
+                                   //see UTM_TYPES for all supported utm tags
   doc_path: string                 //document path
   doc_host: string                 //document host
   doc_search: string               //document search string
-  screen_resolution: string        //screen resolution
+
   vp_size: string                  //viewport size
   user_language: string            //user language
-
   doc_encoding: string
-
-  utm: Record<string, string>      //utm tags (without utm prefix, e.g key will be "source", not utm_source. See
-  click_id: Record<string, string> //all external click ids (passed through URL). See CLICK_IDS for supported all supported click ids
-  [propName: string]: any          //context is extendable, any extra properties can be added here
 }
 
 /**
  * Optional data that can be added to each event. Consist from optional fields,
  */
-export type EventPayload = {
+export type EventPayload = Partial<ClientProperties> & {
+  /**
+   * If track() is called in node env, it's possible to provide
+   * request/response. In this case Jitsu will try to use it for
+   * getting request data (url, referer and etc). Also, it will be used for
+   * setting and getting cookies
+   */
+  req?: Request
+  res?: Response
+  env?: TrackingEnvironment
+
   conversion?: Conversion          //Conversion data if events indicates a conversion
   src_payload?: any,               //Third-party payload if event is intercepted from third-party source
   [propName: string]: any          //payload is extendable, any extra properties can be added here