tablevu 0.2.22 → 0.3.0-beta.2

package/dist/tablevu-odata.esm.js

@@ -0,0 +1,507 @@
+/* ==========================================================================
+ * 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 = filter.filters || [];
+    if (filters.length === 0)
+        return '';
+    return filters
+        .map(buildFilter)
+        .map(expression => `(${expression})`)
+        .join(` ${operator} `);
+}
+function buildNot(filter) {
+    const filters = filter.filters || [];
+    if (filters.length !== 1)
+        return '';
+    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 = filter.filters || [];
+    if (filters.length !== 1)
+        return '';
+    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) {
+    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.filters.length > 0) ||
+            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.filters.length > 0) ||
+            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                                                                */
+    /* ---------------------------------------------------------------------- */
+    const requestInit = options.headers ? { headers: options.headers } : undefined;
+    return new Request(url, requestInit);
+}
+
+export { odata as default, toODataFilter };