tablevu 0.2.21 → 0.3.0-beta.1

package/dist/tablevu-odata.umd.cjs.js

@@ -0,0 +1,519 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.tablevu = {}));
+})(this, (function (exports) { 'use strict';
+
+    /* ==========================================================================
+     * OData DataTable Query Builder
+     * ========================================================================== */
+    /* ==========================================================================
+     * Value
+     * ========================================================================== */
+    function formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${escapeODataString(value)}'`;
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new Error('Invalid numeric value.');
+            return String(value);
+        }
+        if (typeof value === 'boolean')
+            return value ? 'true' : 'false';
+        if (value instanceof Date)
+            return value.toISOString();
+        /*
+         * Backward compatibility with:
+         *
+         * {
+         *     func: 'now',
+         *     params: []
+         * }
+         */
+        if (typeof value === 'object' &&
+            value !== null &&
+            'func' in value &&
+            'params' in value) {
+            const funcValue = value;
+            return (funcValue.func +
+                '(' +
+                funcValue.params
+                    .map(m => formatValue(m))
+                    .join(',') +
+                ')');
+        }
+        throw new Error(`Unsupported OData value type: ${typeof value}`);
+    }
+    function escapeODataString(value) {
+        /*
+         * OData escapes a single quote by doubling it.
+         *
+         * O'Reilly
+         * ↓
+         * 'O''Reilly'
+         */
+        return value.replace(/'/g, "''");
+    }
+    /* ==========================================================================
+     * Filter
+     * ========================================================================== */
+    function toODataFilter(filter) {
+        return buildFilter(filter);
+    }
+    function buildFilter(filter) {
+        if (!filter)
+            throw new Error('Invalid filter.');
+        /*
+         * Backward compatibility:
+         *
+         * {
+         *     func: 'contains',
+         *     params: [...]
+         * }
+         */
+        if (filter.func) {
+            return buildFunctionObject(filter);
+        }
+        switch (filter.operator) {
+            /* ------------------------------------------------------------------ */
+            /* Logical                                                            */
+            /* ------------------------------------------------------------------ */
+            case 'and':
+                return buildLogical(filter, 'and');
+            case 'or':
+                return buildLogical(filter, 'or');
+            case 'not':
+                return buildNot(filter);
+            /* ------------------------------------------------------------------ */
+            /* Comparison                                                         */
+            /* ------------------------------------------------------------------ */
+            case 'eq':
+            case 'ne':
+            case 'gt':
+            case 'ge':
+            case 'lt':
+            case 'le':
+                return buildComparison(filter);
+            /* ------------------------------------------------------------------ */
+            /* String                                                             */
+            /* ------------------------------------------------------------------ */
+            case 'contains':
+                return buildFunction(filter, 'contains');
+            case 'startsWith':
+                return buildFunction(filter, 'startswith');
+            case 'endsWith':
+                return buildFunction(filter, 'endswith');
+            /* ------------------------------------------------------------------ */
+            /* Value                                                              */
+            /* ------------------------------------------------------------------ */
+            case 'in':
+                return buildIn(filter);
+            case 'between':
+                return buildBetween(filter);
+            case 'isNull':
+                return `${getColumn(filter)} eq null`;
+            case 'isNotNull':
+                return `${getColumn(filter)} ne null`;
+            /* ------------------------------------------------------------------ */
+            /* Collection                                                         */
+            /* ------------------------------------------------------------------ */
+            case 'any':
+                return buildAny(filter);
+            case 'all':
+                return buildAll(filter);
+            /* ------------------------------------------------------------------ */
+            /* Collection count                                                   */
+            /* ------------------------------------------------------------------ */
+            case 'countGt':
+            case 'countGe':
+            case 'countLt':
+            case 'countLe':
+                return buildCount(filter);
+            default:
+                throw new Error(`Unsupported OData operator: ${filter.operator}`);
+        }
+    }
+    /* ==========================================================================
+     * Logical
+     * ========================================================================== */
+    function buildLogical(filter, operator) {
+        const filters = requireFilters(filter);
+        if (filters.length === 0)
+            throw new Error(`Operator '${filter.operator}' requires at least one filter.`);
+        return filters
+            .map(buildFilter)
+            .map(expression => `(${expression})`)
+            .join(` ${operator} `);
+    }
+    function buildNot(filter) {
+        const filters = requireFilters(filter);
+        if (filters.length !== 1)
+            throw new Error("Operator 'not' requires exactly one filter.");
+        return `not (${buildFilter(filters[0])})`;
+    }
+    /* ==========================================================================
+     * Comparison
+     * ========================================================================== */
+    function buildComparison(filter) {
+        const column = getColumn(filter);
+        return (`${column} ` +
+            `${filter.operator} ` +
+            `${formatValue(filter.value)}`);
+    }
+    /* ==========================================================================
+     * String functions
+     * ========================================================================== */
+    function buildFunction(filter, functionName) {
+        const column = getColumn(filter);
+        return (`${functionName}(` +
+            `${column},` +
+            `${formatValue(filter.value)}` +
+            `)`);
+    }
+    /* ==========================================================================
+     * Function object
+     *
+     * Backward compatibility with the old:
+     *
+     * {
+     *     func: 'contains',
+     *     params: [...]
+     * }
+     * ========================================================================== */
+    function buildFunctionObject(filter) {
+        if (!filter.func)
+            throw new Error('Function is required.');
+        return (filter.func +
+            '(' +
+            (filter.params ?? [])
+                .map(m => formatValue(m))
+                .join(',') +
+            ')');
+    }
+    /* ==========================================================================
+     * IN
+     * ========================================================================== */
+    function buildIn(filter) {
+        const column = getColumn(filter);
+        if (!Array.isArray(filter.value))
+            throw new Error("Operator 'in' requires an array value.");
+        if (filter.value.length === 0)
+            throw new Error("Operator 'in' requires at least one value.");
+        return (`${column} in (` +
+            filter.value
+                .map(formatValue)
+                .join(',') +
+            `)`);
+    }
+    /* ==========================================================================
+     * BETWEEN
+     * ========================================================================== */
+    function buildBetween(filter) {
+        const column = getColumn(filter);
+        if (!Array.isArray(filter.value) ||
+            filter.value.length !== 2) {
+            throw new Error("Operator 'between' requires exactly two values.");
+        }
+        const [min, max] = filter.value;
+        return (`(${column} ge ${formatValue(min)} ` +
+            `and ${column} le ${formatValue(max)})`);
+    }
+    /* ==========================================================================
+     * ANY
+     * ========================================================================== */
+    function buildAny(filter) {
+        const column = getColumn(filter);
+        /*
+         * orders/any()
+         */
+        if (!filter.filters?.length)
+            return `${column}/any()`;
+        if (filter.filters.length !== 1)
+            throw new Error("Operator 'any' requires exactly one filter.");
+        return (`${column}/any(x: ` +
+            `${buildLambdaFilter(filter.filters[0], 'x')}` +
+            `)`);
+    }
+    /* ==========================================================================
+     * ALL
+     * ========================================================================== */
+    function buildAll(filter) {
+        const column = getColumn(filter);
+        const filters = requireFilters(filter);
+        if (filters.length !== 1)
+            throw new Error("Operator 'all' requires exactly one filter.");
+        return (`${column}/all(x: ` +
+            `${buildLambdaFilter(filters[0], 'x')}` +
+            `)`);
+    }
+    /* ==========================================================================
+     * Lambda filter
+     * ========================================================================== */
+    function buildLambdaFilter(filter, variable) {
+        /*
+         * Logical
+         */
+        if (filter.operator === 'and')
+            return buildLambdaLogical(filter, variable, 'and');
+        if (filter.operator === 'or')
+            return buildLambdaLogical(filter, variable, 'or');
+        if (filter.operator === 'not') {
+            const filters = requireFilters(filter);
+            if (filters.length !== 1)
+                throw new Error("Operator 'not' requires exactly one filter.");
+            return (`not (` +
+                `${buildLambdaFilter(filters[0], variable)}` +
+                `)`);
+        }
+        /*
+         * Comparison
+         */
+        switch (filter.operator) {
+            case 'eq':
+            case 'ne':
+            case 'gt':
+            case 'ge':
+            case 'lt':
+            case 'le':
+                return (`${variable}/${getColumn(filter)} ` +
+                    `${filter.operator} ` +
+                    `${formatValue(filter.value)}`);
+            /*
+             * String
+             */
+            case 'contains':
+                return (`contains(` +
+                    `${getLambdaColumn(filter, variable)},` +
+                    `${formatValue(filter.value)}` +
+                    `)`);
+            case 'startsWith':
+                return (`startswith(` +
+                    `${getLambdaColumn(filter, variable)},` +
+                    `${formatValue(filter.value)}` +
+                    `)`);
+            case 'endsWith':
+                return (`endswith(` +
+                    `${getLambdaColumn(filter, variable)},` +
+                    `${formatValue(filter.value)}` +
+                    `)`);
+            /*
+             * Null
+             */
+            case 'isNull':
+                return (`${getLambdaColumn(filter, variable)} eq null`);
+            case 'isNotNull':
+                return (`${getLambdaColumn(filter, variable)} ne null`);
+            default:
+                throw new Error(`Operator '${filter.operator}' ` +
+                    `is not supported inside any/all.`);
+        }
+    }
+    function buildLambdaLogical(filter, variable, operator) {
+        const filters = requireFilters(filter);
+        if (filters.length === 0)
+            throw new Error(`Operator '${filter.operator}' requires at least one filter.`);
+        return filters
+            .map(item => buildLambdaFilter(item, variable))
+            .map(expression => `(${expression})`)
+            .join(` ${operator} `);
+    }
+    /* ==========================================================================
+     * Collection count
+     * ========================================================================== */
+    function buildCount(filter) {
+        const column = getColumn(filter);
+        const operators = {
+            countGt: 'gt',
+            countGe: 'ge',
+            countLt: 'lt',
+            countLe: 'le'
+        };
+        return (`${column}/$count ` +
+            `${operators[filter.operator]} ` +
+            `${formatValue(filter.value)}`);
+    }
+    /* ==========================================================================
+     * Helpers
+     * ========================================================================== */
+    function getColumn(filter) {
+        if (!filter.column ||
+            filter.column.trim().length === 0) {
+            throw new Error(`Operator '${filter.operator}' requires a column.`);
+        }
+        /*
+         * Allow:
+         *
+         * customer.name
+         * customer.address.city
+         *
+         * to become:
+         *
+         * customer/name
+         * customer/address/city
+         */
+        return filter.column.replace(/\./g, '/');
+    }
+    function getLambdaColumn(filter, variable) {
+        return (`${variable}/` +
+            `${getColumn(filter)}`);
+    }
+    function requireFilters(filter) {
+        if (!filter.filters)
+            throw new Error(`Operator '${filter.operator}' requires filters.`);
+        return filter.filters;
+    }
+    /* ==========================================================================
+     * OData Request
+     * ========================================================================== */
+    function odata(options, props = {}) {
+        const url = new URL(options.url);
+        /* ---------------------------------------------------------------------- */
+        /* Paging                                                                 */
+        /* ---------------------------------------------------------------------- */
+        if (props.pageSize &&
+            props.pageSize > 0) {
+            const currPage = props.currPage && props.currPage > 0
+                ? props.currPage
+                : 1;
+            const skip = props.pageSize * (currPage - 1);
+            url.searchParams.set('$skip', String(skip));
+            url.searchParams.set('$top', String(props.pageSize));
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Count                                                                  */
+        /* ---------------------------------------------------------------------- */
+        if (options.count === true) {
+            url.searchParams.set('$count', 'true');
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Select                                                                 */
+        /* ---------------------------------------------------------------------- */
+        if (options.select &&
+            options.select.length > 0) {
+            url.searchParams.set('$select', options.select
+                .map(m => m.replace(/\./g, '/'))
+                .join(','));
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Expand                                                                 */
+        /* ---------------------------------------------------------------------- */
+        if (options.expand &&
+            options.expand.length > 0) {
+            const expand = options.expand
+                .map(expand => {
+                const name = expand.name.replace(/\./g, '/');
+                if (expand.select &&
+                    expand.select.length > 0) {
+                    return (`${name}` +
+                        `($select=` +
+                        `${expand.select
+                        .map(m => m.replace(/\./g, '/'))
+                        .join(',')}` +
+                        `)`);
+                }
+                return name;
+            })
+                .join(',');
+            url.searchParams.set('$expand', expand);
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Filter                                                                 */
+        /* ---------------------------------------------------------------------- */
+        const filters = [];
+        /*
+         * Static filter from options
+         */
+        if (options.filter &&
+            (options.filter.filters ||
+                options.filter.column ||
+                options.filter.func)) {
+            const expression = toODataFilter(options.filter);
+            if (expression)
+                filters.push(`(${expression})`);
+        }
+        /*
+         * Runtime filter from DataTable
+         */
+        if (props.filter &&
+            (props.filter.filters ||
+                props.filter.column ||
+                props.filter.func)) {
+            const expression = toODataFilter(props.filter);
+            if (expression)
+                filters.push(`(${expression})`);
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Search                                                                 */
+        /* ---------------------------------------------------------------------- */
+        if (props.search &&
+            props.search.trim() &&
+            props.cols &&
+            props.cols.length > 0) {
+            const searchValue = escapeODataString(props.search.trim());
+            const searchExpressions = props.cols
+                .filter(column => column.searchable === undefined ||
+                column.searchable === true)
+                .map(column => {
+                const name = column.name.replace(/\./g, '/');
+                return (`contains(` +
+                    `${name},` +
+                    `'${searchValue}'` +
+                    `)`);
+            });
+            if (searchExpressions.length > 0) {
+                filters.push(`(${searchExpressions.join(' or ')})`);
+            }
+        }
+        /*
+         * Combine all filters with AND.
+         */
+        if (filters.length > 0) {
+            url.searchParams.set('$filter', filters.join(' and '));
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Order By                                                               */
+        /* ---------------------------------------------------------------------- */
+        if (props.sort &&
+            props.sort.length > 0) {
+            const orderBy = props.sort
+                .map(sort => {
+                let column;
+                if (sort.index !== undefined &&
+                    sort.index >= 0) {
+                    if (!props.cols ||
+                        !props.cols[sort.index]) {
+                        throw new Error(`Invalid sort column index: ${sort.index}`);
+                    }
+                    column =
+                        props.cols[sort.index].name;
+                }
+                else if (sort.name) {
+                    column = sort.name;
+                }
+                else {
+                    throw new Error('Sort requires either index or name.');
+                }
+                column =
+                    column.replace(/\./g, '/');
+                return (column +
+                    (sort.dir
+                        ? ` ${sort.dir}`
+                        : ''));
+            })
+                .join(',');
+            url.searchParams.set('$orderby', orderBy);
+        }
+        /* ---------------------------------------------------------------------- */
+        /* Request                                                                */
+        /* ---------------------------------------------------------------------- */
+        return new Request(url, options.header);
+    }
+
+    exports.default = odata;
+    exports.toODataFilter = toODataFilter;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));