@forestadmin-experimental/datasource-cosmos 1.6.2 → 1.6.4

package/dist/utils/pagination-cache.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+/**
+ * Cache for storing Cosmos DB continuation tokens to enable efficient cursor-based pagination
+ *
+ * This cache stores continuation tokens indexed by query hash and offset, allowing
+ * the system to resume pagination from the nearest cached position rather than
+ * fetching all items from the beginning.
+ *
+ * Example:
+ * - User requests offset=1000, limit=10
+ * - Cache has token for offset=900
+ * - System resumes from offset=900 and skips only 100 items instead of 1000
+ */
+class PaginationCache {
+    constructor(options = {}) {
+        this.cache = new Map();
+        this.options = {
+            maxEntriesPerQuery: options.maxEntriesPerQuery ?? 100,
+            ttlMs: options.ttlMs ?? 300000, // 5 minutes default
+            maxOffset: options.maxOffset ?? 100000,
+            cacheInterval: options.cacheInterval ?? 1000,
+        };
+    }
+    /**
+     * Get the maximum allowed offset
+     */
+    getMaxOffset() {
+        return this.options.maxOffset;
+    }
+    /**
+     * Get the cache interval (how often to store continuation tokens)
+     */
+    getCacheInterval() {
+        return this.options.cacheInterval;
+    }
+    /**
+     * Generate a unique hash for a query to use as cache key
+     * @param queryString The SQL query string
+     * @param parameters Query parameters
+     * @param partitionKey Optional partition key
+     */
+    generateQueryHash(queryString, parameters, partitionKey) {
+        const hashInput = JSON.stringify({
+            query: queryString,
+            parameters: parameters || [],
+            partitionKey,
+        });
+        return (0, crypto_1.createHash)('sha256').update(hashInput).digest('hex').substring(0, 16);
+    }
+    /**
+     * Find the best cached continuation token for a given offset
+     * Returns the token with the highest offset that is still <= requested offset
+     *
+     * @param queryHash The query hash
+     * @param targetOffset The target offset to reach
+     * @returns The best matching cache entry, or null if none found
+     */
+    findBestToken(queryHash, targetOffset) {
+        const entries = this.cache.get(queryHash);
+        if (!entries || entries.length === 0) {
+            return null;
+        }
+        // Clean expired entries first
+        const now = Date.now();
+        const validEntries = entries.filter(e => now - e.createdAt < this.options.ttlMs);
+        if (validEntries.length !== entries.length) {
+            // Update cache with only valid entries
+            if (validEntries.length > 0) {
+                this.cache.set(queryHash, validEntries);
+            }
+            else {
+                this.cache.delete(queryHash);
+                return null;
+            }
+        }
+        // Find the entry with the highest offset that is <= targetOffset
+        let bestEntry = null;
+        for (const entry of validEntries) {
+            if (entry.offset <= targetOffset) {
+                if (!bestEntry || entry.offset > bestEntry.offset) {
+                    bestEntry = entry;
+                }
+            }
+        }
+        return bestEntry;
+    }
+    /**
+     * Store a continuation token for a specific offset
+     *
+     * @param queryHash The query hash
+     * @param offset The offset this token represents
+     * @param continuationToken The Cosmos DB continuation token
+     */
+    storeToken(queryHash, offset, continuationToken) {
+        let entries = this.cache.get(queryHash);
+        if (!entries) {
+            entries = [];
+            this.cache.set(queryHash, entries);
+        }
+        // Check if we already have an entry for this offset
+        const existingIndex = entries.findIndex(e => e.offset === offset);
+        if (existingIndex >= 0) {
+            // Update existing entry
+            entries[existingIndex] = {
+                continuationToken,
+                offset,
+                createdAt: Date.now(),
+            };
+        }
+        else {
+            // Add new entry
+            entries.push({
+                continuationToken,
+                offset,
+                createdAt: Date.now(),
+            });
+            // Sort by offset for efficient lookup
+            entries.sort((a, b) => a.offset - b.offset);
+            // Trim to max entries (remove oldest based on createdAt if over limit)
+            if (entries.length > this.options.maxEntriesPerQuery) {
+                entries.sort((a, b) => b.createdAt - a.createdAt);
+                entries.length = this.options.maxEntriesPerQuery;
+                entries.sort((a, b) => a.offset - b.offset);
+            }
+        }
+    }
+    /**
+     * Clear all cached tokens for a specific query
+     * @param queryHash The query hash
+     */
+    clearQuery(queryHash) {
+        this.cache.delete(queryHash);
+    }
+    /**
+     * Clear all cached tokens
+     */
+    clearAll() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics for monitoring
+     */
+    getStats() {
+        let totalEntries = 0;
+        for (const entries of this.cache.values()) {
+            totalEntries += entries.length;
+        }
+        return {
+            totalQueries: this.cache.size,
+            totalEntries,
+        };
+    }
+}
+exports.default = PaginationCache;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/partition-key-extractor.d.ts

@@ -0,0 +1,19 @@
+import { ConditionTree } from '@forestadmin/datasource-toolkit';
+export type PartitionKeyValue = string | number | undefined;
+/**
+ * Extracts the partition key value from a ConditionTree if present.
+ *
+ * This optimization allows Cosmos DB to target a single partition instead of
+ * performing a cross-partition query, significantly reducing RU consumption.
+ *
+ * The extraction works when:
+ * - There's an equality condition (operator = 'Equal') on the partition key field
+ * - The condition is at the root level or within an AND branch
+ *
+ * The extraction does NOT work when:
+ * - The partition key is filtered with IN, NotEqual, or range operators
+ * - The partition key condition is inside an OR branch (multiple partitions needed)
+ * - No filter on partition key exists
+ */
+export declare function extractPartitionKeyFromFilter(conditionTree: ConditionTree | undefined, partitionKeyPath: string): PartitionKeyValue;
+//# sourceMappingURL=partition-key-extractor.d.ts.map

package/dist/utils/partition-key-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-key-extractor.d.ts","sourceRoot":"","sources":["../../src/utils/partition-key-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAGd,MAAM,iCAAiC,CAAC;AAEzC,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AA6C5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,aAAa,GAAG,SAAS,EACxC,gBAAgB,EAAE,MAAM,GACvB,iBAAiB,CAUnB"}

package/dist/utils/partition-key-extractor.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPartitionKeyFromFilter = void 0;
+function extractFromTree(conditionTree, partitionKeyField) {
+    // Handle leaf nodes (single conditions)
+    if (conditionTree.operator !== undefined) {
+        const leaf = conditionTree;
+        // Only extract if it's an equality condition on the partition key field
+        if (leaf.field === partitionKeyField && leaf.operator === 'Equal') {
+            const { value } = leaf;
+            // Partition keys must be string or number
+            if (typeof value === 'string' || typeof value === 'number') {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    // Handle branch nodes (AND/OR conditions)
+    if (conditionTree.aggregator !== undefined) {
+        const branch = conditionTree;
+        // Only extract from AND branches - OR branches require multiple partitions
+        if (branch.aggregator === 'And') {
+            for (const condition of branch.conditions) {
+                const extracted = extractFromTree(condition, partitionKeyField);
+                if (extracted !== undefined) {
+                    return extracted;
+                }
+            }
+        }
+        // For OR branches, we cannot optimize as we'd need multiple partitions
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Extracts the partition key value from a ConditionTree if present.
+ *
+ * This optimization allows Cosmos DB to target a single partition instead of
+ * performing a cross-partition query, significantly reducing RU consumption.
+ *
+ * The extraction works when:
+ * - There's an equality condition (operator = 'Equal') on the partition key field
+ * - The condition is at the root level or within an AND branch
+ *
+ * The extraction does NOT work when:
+ * - The partition key is filtered with IN, NotEqual, or range operators
+ * - The partition key condition is inside an OR branch (multiple partitions needed)
+ * - No filter on partition key exists
+ */
+function extractPartitionKeyFromFilter(conditionTree, partitionKeyPath) {
+    if (!conditionTree)
+        return undefined;
+    // Convert partition key path (e.g., "/tenantId" or "/address/city")
+    // to field notation (e.g., "tenantId" or "address->city")
+    const partitionKeyField = partitionKeyPath
+        .replace(/^\//, '') // Remove leading slash
+        .replace(/\//g, '->'); // Convert nested paths to arrow notation
+    return extractFromTree(conditionTree, partitionKeyField);
+}
+exports.extractPartitionKeyFromFilter = extractPartitionKeyFromFilter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGl0aW9uLWtleS1leHRyYWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvcGFydGl0aW9uLWtleS1leHRyYWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBUUEsU0FBUyxlQUFlLENBQ3RCLGFBQTRCLEVBQzVCLGlCQUF5QjtJQUV6Qix3Q0FBd0M7SUFDeEMsSUFBSyxhQUFtQyxDQUFDLFFBQVEsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUNoRSxNQUFNLElBQUksR0FBRyxhQUFrQyxDQUFDO1FBRWhELHdFQUF3RTtRQUN4RSxJQUFJLElBQUksQ0FBQyxLQUFLLEtBQUssaUJBQWlCLElBQUksSUFBSSxDQUFDLFFBQVEsS0FBSyxPQUFPLEVBQUUsQ0FBQztZQUNsRSxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsSUFBSSxDQUFDO1lBRXZCLDBDQUEwQztZQUMxQyxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFDM0QsT0FBTyxLQUFLLENBQUM7WUFDZixDQUFDO1FBQ0gsQ0FBQztRQUVELE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFRCwwQ0FBMEM7SUFDMUMsSUFBSyxhQUFxQyxDQUFDLFVBQVUsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUNwRSxNQUFNLE1BQU0sR0FBRyxhQUFvQyxDQUFDO1FBRXBELDJFQUEyRTtRQUMzRSxJQUFJLE1BQU0sQ0FBQyxVQUFVLEtBQUssS0FBSyxFQUFFLENBQUM7WUFDaEMsS0FBSyxNQUFNLFNBQVMsSUFBSSxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7Z0JBQzFDLE1BQU0sU0FBUyxHQUFHLGVBQWUsQ0FBQyxTQUFTLEVBQUUsaUJBQWlCLENBQUMsQ0FBQztnQkFFaEUsSUFBSSxTQUFTLEtBQUssU0FBUyxFQUFFLENBQUM7b0JBQzVCLE9BQU8sU0FBUyxDQUFDO2dCQUNuQixDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7UUFFRCx1RUFBdUU7UUFDdkUsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFFRDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILFNBQWdCLDZCQUE2QixDQUMzQyxhQUF3QyxFQUN4QyxnQkFBd0I7SUFFeEIsSUFBSSxDQUFDLGFBQWE7UUFBRSxPQUFPLFNBQVMsQ0FBQztJQUVyQyxvRUFBb0U7SUFDcEUsMERBQTBEO0lBQzFELE1BQU0saUJBQWlCLEdBQUcsZ0JBQWdCO1NBQ3ZDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsdUJBQXVCO1NBQzFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyx5Q0FBeUM7SUFFbEUsT0FBTyxlQUFlLENBQUMsYUFBYSxFQUFFLGlCQUFpQixDQUFDLENBQUM7QUFDM0QsQ0FBQztBQWJELHNFQWFDIn0=

package/dist/utils/query-converter.d.ts

@@ -1,8 +1,28 @@
 import { SqlParameter, SqlQuerySpec } from '@azure/cosmos';
 import { ConditionTree, Sort } from '@forestadmin/datasource-toolkit';
+import { QueryValidatorOptions } from './query-validator';
+export interface QueryConverterOptions {
+    /**
+     * Schema fields for validation (field names in Forest Admin notation)
+     * If not provided, only basic security validation is performed
+     */
+    schemaFields?: string[];
+    /**
+     * Validation options
+     */
+    validationOptions?: QueryValidatorOptions;
+    /**
+     * Whether to skip validation entirely (not recommended for production)
+     * Default: false
+     */
+    skipValidation?: boolean;
+}
 export default class QueryConverter {
     private parameterCounter;
     private parameters;
+    private validator;
+    private skipValidation;
+    constructor(options?: QueryConverterOptions);
     /**
      * Reset the converter state for a new query
      */

package/dist/utils/query-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-converter.d.ts","sourceRoot":"","sources":["../../src/utils/query-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,aAAa,EAIb,IAAI,EACL,MAAM,iCAAiC,CAAC;AAEzC,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,UAAU,CAAsB;IAExC;;OAEG;IACH,OAAO,CAAC,KAAK;IAKb;;OAEG;IACH,OAAO,CAAC,YAAY;IAepB;;OAEG;IACH,OAAO,CAAC,eAAe;IA4HvB;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAyCvC;;OAEG;IACI,eAAe,CACpB,aAAa,CAAC,EAAE,aAAa,EAC7B,IAAI,CAAC,EAAE,IAAI,EACX,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,YAAY;IAuDf;;OAEG;IACI,gBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM;IAe5C;;OAEG;IACI,cAAc,CAAC,aAAa,CAAC,EAAE,aAAa,GAAG;QACpD,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,YAAY,EAAE,CAAC;KAC5B;CAMF"}
+{"version":3,"file":"query-converter.d.ts","sourceRoot":"","sources":["../../src/utils/query-converter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,aAAa,EAIb,IAAI,EACL,MAAM,iCAAiC,CAAC;AAEzC,OAAuB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;OAEG;IACH,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAE1C;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,cAAc,CAAU;gBAEpB,OAAO,CAAC,EAAE,qBAAqB;IAQ3C;;OAEG;IACH,OAAO,CAAC,KAAK;IAKb;;OAEG;IACH,OAAO,CAAC,YAAY;IAepB;;OAEG;IACH,OAAO,CAAC,eAAe;IA4HvB;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAyCvC;;OAEG;IACI,eAAe,CACpB,aAAa,CAAC,EAAE,aAAa,EAC7B,IAAI,CAAC,EAAE,IAAI,EACX,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,YAAY;IA4Df;;OAEG;IACI,gBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM;IAe5C;;OAEG;IACI,cAAc,CAAC,aAAa,CAAC,EAAE,aAAa,GAAG;QACpD,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,YAAY,EAAE,CAAC;KAC5B;CAYF"}

package/dist/utils/query-converter.js

@@ -1,9 +1,18 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const query_validator_1 = __importDefault(require("./query-validator"));
 class QueryConverter {
-    constructor() {
+    constructor(options) {
         this.parameterCounter = 0;
         this.parameters = [];
+        this.validator = null;
+        this.skipValidation = options?.skipValidation ?? false;
+        if (!this.skipValidation) {
+            this.validator = new query_validator_1.default(options?.schemaFields, options?.validationOptions);
+        }
     }
     /**
      * Reset the converter state for a new query
@@ -162,6 +171,10 @@ class QueryConverter {
     getSqlQuerySpec(conditionTree, sort, projection) {
         // Reset state for new query
         this.reset();
+        // Validate query parameters if validation is enabled
+        if (this.validator) {
+            this.validator.validateQuery(conditionTree, sort, projection);
+        }
         // Build SELECT clause
         // Cosmos DB doesn't handle well selecting individual nested properties
         // (e.g., c.accountingBalance.currency). Instead, select parent objects.
@@ -224,9 +237,13 @@ class QueryConverter {
      */
     getWhereClause(conditionTree) {
         this.reset();
+        // Validate condition tree if validation is enabled
+        if (this.validator) {
+            this.validator.validateConditionTree(conditionTree);
+        }
         const where = this.getWhereClauseFromConditionTree(conditionTree);
         return { where, parameters: this.parameters };
     }
 }
 exports.default = QueryConverter;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-converter.js","sourceRoot":"","sources":["../../src/utils/query-converter.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-converter.js","sourceRoot":"","sources":["../../src/utils/query-converter.ts"],"names":[],"mappings":"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"}

package/dist/utils/query-validation-error.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Error codes for query validation failures
+ */
+export declare enum QueryValidationErrorCode {
+    INVALID_FIELD_NAME = "INVALID_FIELD_NAME",
+    FIELD_NOT_IN_SCHEMA = "FIELD_NOT_IN_SCHEMA",
+    INVALID_VALUE_TYPE = "INVALID_VALUE_TYPE",
+    POTENTIAL_INJECTION = "POTENTIAL_INJECTION",
+    MAX_DEPTH_EXCEEDED = "MAX_DEPTH_EXCEEDED",
+    INVALID_SORT_FIELD = "INVALID_SORT_FIELD",
+    INVALID_PROJECTION_FIELD = "INVALID_PROJECTION_FIELD"
+}
+/**
+ * Security and validation errors for query operations
+ */
+export default class QueryValidationError extends Error {
+    readonly code: QueryValidationErrorCode;
+    readonly field?: string;
+    constructor(message: string, code: QueryValidationErrorCode, field?: string);
+}
+//# sourceMappingURL=query-validation-error.d.ts.map

package/dist/utils/query-validation-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-validation-error.d.ts","sourceRoot":"","sources":["../../src/utils/query-validation-error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,wBAAwB;IAClC,kBAAkB,uBAAuB;IACzC,mBAAmB,wBAAwB;IAC3C,kBAAkB,uBAAuB;IACzC,mBAAmB,wBAAwB;IAC3C,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,wBAAwB,6BAA6B;CACtD;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,KAAK;aAGnC,IAAI,EAAE,wBAAwB;aAC9B,KAAK,CAAC,EAAE,MAAM;gBAF9B,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,wBAAwB,EAC9B,KAAK,CAAC,EAAE,MAAM;CAKjC"}

package/dist/utils/query-validation-error.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryValidationErrorCode = void 0;
+/**
+ * Error codes for query validation failures
+ */
+var QueryValidationErrorCode;
+(function (QueryValidationErrorCode) {
+    QueryValidationErrorCode["INVALID_FIELD_NAME"] = "INVALID_FIELD_NAME";
+    QueryValidationErrorCode["FIELD_NOT_IN_SCHEMA"] = "FIELD_NOT_IN_SCHEMA";
+    QueryValidationErrorCode["INVALID_VALUE_TYPE"] = "INVALID_VALUE_TYPE";
+    QueryValidationErrorCode["POTENTIAL_INJECTION"] = "POTENTIAL_INJECTION";
+    QueryValidationErrorCode["MAX_DEPTH_EXCEEDED"] = "MAX_DEPTH_EXCEEDED";
+    QueryValidationErrorCode["INVALID_SORT_FIELD"] = "INVALID_SORT_FIELD";
+    QueryValidationErrorCode["INVALID_PROJECTION_FIELD"] = "INVALID_PROJECTION_FIELD";
+})(QueryValidationErrorCode || (exports.QueryValidationErrorCode = QueryValidationErrorCode = {}));
+/**
+ * Security and validation errors for query operations
+ */
+class QueryValidationError extends Error {
+    constructor(message, code, field) {
+        super(message);
+        this.code = code;
+        this.field = field;
+        this.name = 'QueryValidationError';
+    }
+}
+exports.default = QueryValidationError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnktdmFsaWRhdGlvbi1lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9xdWVyeS12YWxpZGF0aW9uLWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOztHQUVHO0FBQ0gsSUFBWSx3QkFRWDtBQVJELFdBQVksd0JBQXdCO0lBQ2xDLHFFQUF5QyxDQUFBO0lBQ3pDLHVFQUEyQyxDQUFBO0lBQzNDLHFFQUF5QyxDQUFBO0lBQ3pDLHVFQUEyQyxDQUFBO0lBQzNDLHFFQUF5QyxDQUFBO0lBQ3pDLHFFQUF5QyxDQUFBO0lBQ3pDLGlGQUFxRCxDQUFBO0FBQ3ZELENBQUMsRUFSVyx3QkFBd0Isd0NBQXhCLHdCQUF3QixRQVFuQztBQUVEOztHQUVHO0FBQ0gsTUFBcUIsb0JBQXFCLFNBQVEsS0FBSztJQUNyRCxZQUNFLE9BQWUsRUFDQyxJQUE4QixFQUM5QixLQUFjO1FBRTlCLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUhDLFNBQUksR0FBSixJQUFJLENBQTBCO1FBQzlCLFVBQUssR0FBTCxLQUFLLENBQVM7UUFHOUIsSUFBSSxDQUFDLElBQUksR0FBRyxzQkFBc0IsQ0FBQztJQUNyQyxDQUFDO0NBQ0Y7QUFURCx1Q0FTQyJ9

package/dist/utils/query-validator.d.ts

@@ -0,0 +1,66 @@
+import { ConditionTree, Sort } from '@forestadmin/datasource-toolkit';
+import QueryValidationError, { QueryValidationErrorCode } from './query-validation-error';
+export { QueryValidationError, QueryValidationErrorCode };
+export interface QueryValidatorOptions {
+    /**
+     * Maximum allowed nesting depth for field paths (e.g., 'a->b->c' has depth 3)
+     * Default: 10
+     */
+    maxFieldDepth?: number;
+    /**
+     * Whether to validate fields against schema (requires schema to be provided)
+     * Default: true when schema is provided
+     */
+    validateAgainstSchema?: boolean;
+    /**
+     * Whether to allow unknown fields not in schema
+     * Default: false (strict mode)
+     */
+    allowUnknownFields?: boolean;
+    /**
+     * Maximum length for field names
+     * Default: 256
+     */
+    maxFieldNameLength?: number;
+    /**
+     * Maximum number of conditions in a condition tree
+     * Default: 100
+     */
+    maxConditions?: number;
+}
+export default class QueryValidator {
+    private options;
+    private schema;
+    private conditionCount;
+    constructor(schemaFields?: string[], options?: QueryValidatorOptions);
+    /**
+     * Validate a field name for security and correctness
+     */
+    validateFieldName(field: string, context?: string): void;
+    /**
+     * Validate a complete condition tree
+     */
+    validateConditionTree(conditionTree?: ConditionTree): void;
+    private validateConditionTreeRecursive;
+    /**
+     * Validate a value for potential injection
+     */
+    validateValue(value: unknown, field?: string): void;
+    /**
+     * Validate sort fields
+     */
+    validateSort(sort?: Sort): void;
+    /**
+     * Validate projection fields
+     */
+    validateProjection(projection?: string[]): void;
+    /**
+     * Validate all query parameters at once
+     */
+    validateQuery(conditionTree?: ConditionTree, sort?: Sort, projection?: string[]): void;
+}
+/**
+ * Create a validator instance for a given schema
+ */
+export declare function createQueryValidator(schemaFields?: string[], options?: QueryValidatorOptions): QueryValidator;
+//# sourceMappingURL=query-validator.d.ts.map

package/dist/utils/query-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-validator.d.ts","sourceRoot":"","sources":["../../src/utils/query-validator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAGb,IAAI,EACL,MAAM,iCAAiC,CAAC;AAEzC,OAAO,oBAAoB,EAAE,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAE1F,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,CAAC;AAE1D,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AA4BD,MAAM,CAAC,OAAO,OAAO,cAAc;IACjC,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,cAAc,CAAK;gBAEf,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,qBAA0B;IA0BxE;;OAEG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAU,GAAG,IAAI;IAqEhE;;OAEG;IACI,qBAAqB,CAAC,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI;IAOjE,OAAO,CAAC,8BAA8B;IA8BtC;;OAEG;IACI,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAkC1D;;OAEG;IACI,YAAY,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI;IAiBtC;;OAEG;IACI,kBAAkB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IAQtD;;OAEG;IACI,aAAa,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;CAK9F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,CAAC,EAAE,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAEhB"}