@sisense/sdk-data 0.11.3

package/dist/dimensional-model/filters/factory.js

@@ -0,0 +1,404 @@
+import { TextOperators, NumericOperators, DateOperators, LogicalOperators, RankingOperators, LogicalAttributeFilter, MembersFilter, ExcludeFilter, NumericFilter, MeasureFilter, RankingFilter, TextFilter, DateRangeFilter, RelativeDateFilter, } from './filters.js';
+// LOGICAL FILTERS
+/**
+ * Creates a filter representing a union of multiple filters of the same attribute.
+ *
+ * @param filters - Filters, of the same attribute, to union
+ * @returns A filter representing a union of the given filters
+ */
+export function union(filters) {
+    return new LogicalAttributeFilter(filters, LogicalOperators.Union);
+}
+/**
+ * Creates a filter representing an intersection of multiple filters of the same attribute.
+ *
+ * @param filters - Filters, of the same attribute, to intersect
+ * @returns A filter representing an intersection of the given filters
+ */
+export function intersection(filters) {
+    return new LogicalAttributeFilter(filters, LogicalOperators.Intersection);
+}
+/**
+ * Creates a filter representing an exclusion of the given filter
+ * from all attribute members or from the optional input filter.
+ *
+ * @param filter - Filter to exclude
+ * @param input - Input filter to exclude from (optional)
+ * @returns A filter representing an exclusion of the given filter
+ * from all attribute members or from the optional input filter
+ */
+export function exclude(filter, input) {
+    return new ExcludeFilter(filter, input);
+}
+// TEXT / NUMERIC FILTERS
+/**
+ * Creates a "doesn't contain" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function doesntContain(attribute, value) {
+    return new TextFilter(attribute, TextOperators.DoesntContain, value);
+}
+/**
+ * Creates a "doesn't end with" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function doesntEndWith(attribute, value) {
+    return new TextFilter(attribute, TextOperators.DoesntEndWith, value);
+}
+/**
+ * Creates a "doesn't start with" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function doesntStartWith(attribute, value) {
+    return new TextFilter(attribute, TextOperators.DoesntStartWith, value);
+}
+/**
+ * Creates a "contains" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function contains(attribute, value) {
+    return new TextFilter(attribute, TextOperators.Contains, value);
+}
+/**
+ * Creates an "ends with" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function endsWith(attribute, value) {
+    return new TextFilter(attribute, TextOperators.EndsWith, value);
+}
+/**
+ * Creates a "starts with" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function startsWith(attribute, value) {
+    return new TextFilter(attribute, TextOperators.StartsWith, value);
+}
+/**
+ * Creates a "like" filter.
+ *
+ * @param attribute - Text attribute to filter
+ * @param value - Value to filter by
+ * @returns A text filter of the given attribute
+ */
+export function like(attribute, value) {
+    return new TextFilter(attribute, TextOperators.Like, value);
+}
+/**
+ * Creates a "doesn't equal" filter.
+ *
+ * @param attribute - Text or numeric attribute to filter
+ * @param value - Value to filter by
+ * @returns A filter of the given attribute
+ */
+export function doesntEqual(attribute, value) {
+    if (typeof value === 'string') {
+        return new TextFilter(attribute, TextOperators.DoesntEqual, value);
+    }
+    else {
+        return numeric(attribute, NumericOperators.DoesntEqual, value);
+    }
+}
+/**
+ * Creates an "equals" filter.
+ *
+ * @param attribute - Text or numeric attribute to filter
+ * @param value - Value to filter by
+ * @returns A filter of the given attribute
+ */
+export function equals(attribute, value) {
+    if (typeof value === 'string') {
+        return new TextFilter(attribute, TextOperators.Equals, value);
+    }
+    else {
+        return numeric(attribute, NumericOperators.Equals, value);
+    }
+}
+/**
+ * Creates a "greater than" filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param value - Value to filter by
+ * @returns A numeric filter of the given attribute
+ */
+export function greaterThan(attribute, value) {
+    return numeric(attribute, NumericOperators.FromNotEqual, value);
+}
+/**
+ * Creates a "greater than or equal" filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param value - Value to filter by
+ * @returns A numeric filter of the given attribute
+ */
+export function greaterThanOrEqual(attribute, value) {
+    return numeric(attribute, NumericOperators.From, value);
+}
+/**
+ * Creates a "less than" filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param value - Value to filter by
+ * @returns A numeric filter of the given attribute
+ */
+export function lessThan(attribute, value) {
+    return numeric(attribute, NumericOperators.ToNotEqual, value);
+}
+/**
+ * Creates a "less than or equal" filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param value - Value to filter by
+ * @returns A numeric filter of the given attribute
+ */
+export function lessThanOrEqual(attribute, value) {
+    return numeric(attribute, NumericOperators.To, value);
+}
+/**
+ * Creates a "between" filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param valueA - Value to filter from
+ * @param valueB - Value to filter to
+ * @returns A numeric filter of the given attribute
+ */
+export function between(attribute, valueA, valueB) {
+    return numeric(attribute, NumericOperators.From, valueA, NumericOperators.To, valueB);
+}
+/**
+ * Creates a "between, but not equal" filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param valueA - Value to filter from
+ * @param valueB - Value to filter to
+ * @returns A numeric filter of the given attribute
+ */
+export function betweenNotEqual(attribute, valueA, valueB) {
+    return numeric(attribute, NumericOperators.FromNotEqual, valueA, NumericOperators.ToNotEqual, valueB);
+}
+/**
+ * Creates a custom numeric filter.
+ *
+ * @param attribute - Numeric attribute to filter
+ * @param operatorA - First operator
+ * @param valueA - First value
+ * @param operatorB - Second operator
+ * @param valueB - Second value
+ * @returns A custom numeric filter of the given attribute
+ */
+export function numeric(attribute, operatorA, valueA, operatorB, valueB) {
+    return new NumericFilter(attribute, operatorA, valueA, operatorB, valueB);
+}
+/**
+ * Creates a filter on the given members of the given attribute.
+ *
+ * @param attribute - Attribute to filter
+ * @param members - Array of member values to filter by
+ * @returns A filter instance representing the given members of the given attribute
+ */
+export function members(attribute, members) {
+    return new MembersFilter(attribute, members);
+}
+// DATE FILTERS
+/**
+ * Creates a filter on all values starting at the given date of the given level.
+ *
+ * @param level - Date level attribute to filter. See {@link DateLevels} for supported levels.
+ * @param from - Date or String representing the value to filter from
+ * @returns A filter instance filtering all values starting at the given value
+ */
+export function dateFrom(level, from) {
+    return dateRange(level, from, undefined);
+}
+/**
+ * Creates a filter on all values ending at the given date of the given level.
+ *
+ * @param level - Date level attribute to filter. See {@link DateLevels} for supported levels.
+ * @param to - Date or String representing the last member to filter to
+ * @returns A filter instance filtering all values ending at the given value
+ */
+export function dateTo(level, to) {
+    return dateRange(level, undefined, to);
+}
+/**
+ * Creates a range filter between the given "from" and "to" arguments.
+ *
+ * @param level - Date level attribute to filter. See {@link DateLevels} for supported levels.
+ * @param from - Date or String representing the start member to filter from
+ * @param to - Date or String representing the end member to filter to
+ * @returns A filter instance filtering all values ending at the given value
+ */
+export function dateRange(level, from, to) {
+    return new DateRangeFilter(level, from, to);
+}
+/**
+ * Creates a relative date filter.
+ *
+ * @param level - Date level attribute to filter. See {@link DateLevels} for supported levels.
+ * @param offset - offset to skip from the given anchor, or Today if not provided,
+ * positive/negative to skip forward/backward
+ * @param count - number of members to filter
+ * @param anchor - Anchor to filter from, Today is used if not provided
+ * @returns A relative date filter
+ */
+export function dateRelative(level, offset, count, anchor) {
+    return new RelativeDateFilter(level, offset, count, undefined, anchor);
+}
+/**
+ * Creates a relative date filter from the given anchor date.
+ *
+ * @param level - Date level attribute to filter. See {@link DateLevels} for supported levels.
+ * @param offset - offset to skip from the given anchor, or Today if not provided
+ * @param count - number of members to filter
+ * @param anchor - Anchor to filter from, Today is used if not provided
+ * @returns A relative date filter
+ */
+export function dateRelativeFrom(level, offset, count, anchor) {
+    return new RelativeDateFilter(level, offset, count, DateOperators.Next, anchor);
+}
+/**
+ * Creates a relative date filter to the given anchor date.
+ *
+ * @param level - Date level attribute to filter. See {@link DateLevels} for supported levels.
+ * @param offset - offset to skip from the given anchor, or Today if not provided
+ * @param count - number of members to filter
+ * @param anchor - Anchor to filter from, Today is used if not provided
+ * @returns A relative date filter
+ */
+export function dateRelativeTo(level, offset, count, anchor) {
+    return new RelativeDateFilter(level, offset, count, DateOperators.Last, anchor);
+}
+/**
+ * Creates a filter on "This Year" of the given date dimension.
+ *
+ * @param dimension - date dimension to filter
+ * @returns A "This Year" filter of the given dimension
+ */
+export function thisYear(dimension) {
+    return dateRelativeTo(dimension.Years, 0, 1);
+}
+/**
+ * Creates a filter on "This Month" of the given date dimension.
+ *
+ * @param dimension - date dimension to filter
+ * @returns A "This Month" filter of the given dimension
+ */
+export function thisMonth(dimension) {
+    return dateRelativeTo(dimension.Months, 0, 1);
+}
+/**
+ * Creates a filter on "This Quarter" of the given date dimension.
+ *
+ * @param dimension - date dimension to filter
+ * @returns A "This Quarter" filter of the given dimension
+ */
+export function thisQuarter(dimension) {
+    return dateRelativeTo(dimension.Quarters, 0, 1);
+}
+/**
+ * Creates a filter on "Today" of the given date dimension.
+ *
+ * @param dimension - date dimension to filter
+ * @returns A "Today" filter of the given dimension
+ */
+export function today(dimension) {
+    return dateRelativeTo(dimension.Days, 0, 1);
+}
+// MEASURE-RELATED FILTERS
+/**
+ * Creates a filter on all measure values matching the provided criteria.
+ *
+ * @param attribute - Attribute to filter
+ * @param measure - Measure to filter by
+ * @param operatorA - Operator to apply on `valueA` ({@link NumericOperators})
+ * @param valueA - First value
+ * @param operatorB - Operator to apply on `valueB` ({@link NumericOperators})
+ * @param valueB - Second value
+ * @returns A filter representing the provided logic
+ * @internal
+ */
+export function measureBase(attribute, measure, operatorA, valueA, operatorB, valueB) {
+    return new MeasureFilter(attribute, measure, operatorA, valueA, operatorB, valueB);
+}
+/**
+ * Creates a filter on all measure values that are greater than or equal to the given value.
+ *
+ * @param measure - Measure to filter by
+ * @param value - Min value
+ * @returns A filter representing the "greater than or equal to" logic
+ */
+export function measureGreaterThanOrEqual(measure, value) {
+    return measureBase(measure.attribute, measure, NumericOperators.From, value);
+}
+/**
+ * Creates a filter on all measure values less than or equal to the given value.
+ *
+ * @param measure - Measure to filter by
+ * @param value - Max value
+ * @returns A filter representing the "less than or equal to" logic
+ */
+export function measureLessThanOrEqual(measure, value) {
+    return measureBase(measure.attribute, measure, NumericOperators.To, value);
+}
+/**
+ * Creates a filter on all measure values within a range.
+ *
+ * @param measure - Measure to filter by
+ * @param valueA - Min value
+ * @param valueB - Max value
+ * @returns A filter representing the "between" logic
+ */
+export function measureBetween(measure, valueA, valueB) {
+    return measureBase(measure.attribute, measure, NumericOperators.From, valueA, NumericOperators.To, valueB);
+}
+/**
+ * Creates a filter on all measure values within a range but not equal to the min and max values.
+ *
+ * @param measure - Measure to filter by
+ * @param valueA - Min value
+ * @param valueB - Max value
+ * @returns A filter representing the "between, not equal" logic
+ */
+export function measureBetweenNotEqual(measure, valueA, valueB) {
+    return measureBase(measure.attribute, measure, NumericOperators.FromNotEqual, valueA, NumericOperators.ToNotEqual, valueB);
+}
+// RANKING FILTERS
+/**
+ * Creates a filter representing a top ranking logic.
+ *
+ * @param attribute - Attribute to filter
+ * @param measure - Measure to filter by
+ * @param count - Number of members to return
+ * @returns A filter representing a top ranking logic on the given attribute by the given measure
+ */
+export function topRanking(attribute, measure, count) {
+    return new RankingFilter(attribute, measure, RankingOperators.Top, count);
+}
+/**
+ * Creates a filter representing a bottom ranking logic.
+ *
+ * @param attribute - Attribute to filter
+ * @param measure - Measure to filter by
+ * @param count - Number of members to return
+ * @returns A filter representing a bottom ranking logic on the given attribute by the given measure
+ */
+export function bottomRanking(attribute, measure, count) {
+    return new RankingFilter(attribute, measure, RankingOperators.Bottom, count);
+}

package/dist/dimensional-model/filters/filters.d.ts

@@ -0,0 +1,288 @@
+import { LevelAttribute, Attribute, Measure, Filter } from '../interfaces.js';
+import { DimensionalElement } from '../base.js';
+/**
+ * Different text operators that can be used with text filters
+ *
+ * @internal
+ */
+export declare const TextOperators: {
+    Contains: string;
+    StartsWith: string;
+    EndsWith: string;
+    Equals: string;
+    DoesntEqual: string;
+    DoesntStartWith: string;
+    DoesntContain: string;
+    DoesntEndWith: string;
+    Like: string;
+};
+/**
+ * Different numeric operators that can be used with numeric filters
+ */
+export declare const NumericOperators: {
+    Equals: string;
+    DoesntEqual: string;
+    From: string;
+    FromNotEqual: string;
+    To: string;
+    ToNotEqual: string;
+};
+/**
+ * Different date operators that can be used with date filters
+ *
+ * @internal
+ */
+export declare const DateOperators: {
+    From: string;
+    To: string;
+    Last: string;
+    Next: string;
+    Anchor: string;
+};
+/**
+ * Different logical operators that can be used with logical filters
+ *
+ * @internal
+ */
+export declare const LogicalOperators: {
+    Union: string;
+    Intersection: string;
+    Exclude: string;
+};
+/**
+ * Different ranking operators that can be used with ranking filter
+ *
+ * @internal
+ */
+export declare const RankingOperators: {
+    Top: string;
+    Bottom: string;
+};
+/**
+ * Different filter types
+ *
+ * @internal
+ */
+export declare const FilterTypes: {
+    logicalAttribute: string;
+    members: string;
+    exclude: string;
+    measure: string;
+    ranking: string;
+    text: string;
+    numeric: string;
+    date: string;
+    relativeDate: string;
+};
+/**
+ * base implementation for filter classes
+ *
+ * @internal
+ */
+declare abstract class AbstractFilter extends DimensionalElement implements Filter {
+    /**
+     * Attribute this filter instance is filtering
+     */
+    readonly attribute: Attribute;
+    /**
+     * Filter type
+     */
+    readonly filterType: string;
+    constructor(att: Attribute, filterType: string);
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    abstract filterJaql(): any;
+    /**
+     * gets the element's ID
+     */
+    abstract get id(): string;
+    /**
+     * Defines whether the filter is a scope filters
+     */
+    isScope: boolean;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets the JAQL representation of this instance
+     *
+     * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
+     */
+    jaql(nested?: boolean): any;
+    static checkAttributeSupport(attribute: Attribute): void;
+}
+/**
+ * @internal
+ */
+export declare class LogicalAttributeFilter extends AbstractFilter {
+    readonly filters: Filter[];
+    readonly operator: string;
+    constructor(filters: Filter[], operator: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class MembersFilter extends AbstractFilter {
+    readonly members: any[];
+    constructor(attribute: Attribute, members?: any[]);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class ExcludeFilter extends AbstractFilter {
+    readonly filter: Filter;
+    readonly input?: Filter;
+    constructor(filter: Filter, input?: Filter);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
+    operatorA?: string;
+    operatorB?: string;
+    valueA?: Type;
+    valueB?: Type;
+    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class MeasureFilter extends DoubleOperatorFilter<number> {
+    measure: Measure;
+    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    jaql(nested?: boolean | undefined): any;
+}
+/**
+ * @internal
+ */
+export declare class RankingFilter extends AbstractFilter {
+    count: number;
+    operator: string;
+    measure: Measure;
+    constructor(att: Attribute, measure: Measure, operator: string, count: number);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class NumericFilter extends DoubleOperatorFilter<number> {
+    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number);
+}
+/**
+ * @internal
+ */
+export declare class TextFilter extends DoubleOperatorFilter<string> {
+    constructor(att: Attribute, operator: string, value: string);
+}
+/**
+ * @internal
+ */
+export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string> {
+    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string);
+    get level(): LevelAttribute;
+    get from(): string;
+    get to(): string;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+}
+/**
+ * @internal
+ */
+export declare class RelativeDateFilter extends AbstractFilter {
+    readonly offset: number;
+    readonly count: number;
+    readonly operator: string;
+    readonly anchor?: Date | string;
+    constructor(l: LevelAttribute, offset: number, count: number, operator?: string, anchor?: Date | string);
+    get level(): LevelAttribute;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql(): any;
+}
+/**
+ * @param json
+ * @internal
+ */
+export declare function createFilter(json: any): Filter;
+export {};