@orion-js/helpers 3.11.8 → 3.11.15

package/lib/searchTokens.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSearchQueryForTokens = exports.getSearchTokens = void 0;
+const normalize_1 = require("./normalize");
+/**
+ * Generates an array of search tokens from input text and optional metadata.
+ *
+ * This function processes text by:
+ * 1. Converting it to an array of strings (if not already)
+ * 2. Filtering out falsy values
+ * 3. Normalizing each string (removing accents, special characters)
+ * 4. Splitting by spaces to create individual tokens
+ * 5. Optionally adding metadata tokens in the format "_key:value"
+ *
+ * @param text - String or array of strings to tokenize
+ * @param meta - Optional metadata object where each key-value pair becomes a token
+ * @returns Array of normalized search tokens
+ *
+ * @example
+ * // Returns ['hello', 'world']
+ * getSearchTokens('Hello, World!')
+ *
+ * @example
+ * // Returns ['hello', 'world', '_id:123']
+ * getSearchTokens('Hello, World!', { id: '123' })
+ */
+function getSearchTokens(text, meta) {
+    const stringArray = Array.isArray(text) ? text : [text];
+    const tokens = stringArray
+        .filter(Boolean)
+        .map(text => String(text))
+        .flatMap(word => {
+        return (0, normalize_1.normalizeForSearchToken)(word).split(' ').filter(Boolean);
+    });
+    if (meta) {
+        for (const key in meta) {
+            tokens.push(`_${key}:${meta[key]}`);
+        }
+    }
+    return tokens;
+}
+exports.getSearchTokens = getSearchTokens;
+/**
+ * Generates a MongoDB-compatible query object based on the provided parameters.
+ *
+ * This function:
+ * 1. Processes any filter text into RegExp tokens for prefix matching
+ * 2. Adds metadata filters based on additional properties in the params object
+ * 3. Returns a query object with the $all operator for MongoDB queries
+ *
+ * @param params - Parameters for generating the search query
+ * @param _options - Options for customizing search behavior (reserved for future use)
+ * @returns A MongoDB-compatible query object with format { $all: [...tokens] }
+ *
+ * @example
+ * // Returns { $all: [/^hello/, /^world/] }
+ * getSearchQueryForTokens({ filter: 'Hello World' })
+ *
+ * @example
+ * // Returns { $all: [/^search/, '_category:books'] }
+ * getSearchQueryForTokens({ filter: 'search', category: 'books' })
+ */
+function getSearchQueryForTokens(params = {}, _options = {}) {
+    const searchTokens = [];
+    if (params.filter) {
+        const filterTokens = getSearchTokens(params.filter).map(token => new RegExp(`^${token}`));
+        searchTokens.push(...filterTokens);
+    }
+    for (const key in params) {
+        if (key === 'filter')
+            continue;
+        if (!params[key])
+            continue;
+        searchTokens.push(`_${key}:${params[key]}`);
+    }
+    return { $all: searchTokens };
+}
+exports.getSearchQueryForTokens = getSearchQueryForTokens;

package/lib/searchTokens.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/searchTokens.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const searchTokens_1 = require("./searchTokens");
+describe('Search Tokens Utilities', () => {
+    describe('getSearchTokens', () => {
+        it('should convert a simple string to tokens', () => {
+            const result = (0, searchTokens_1.getSearchTokens)('Hello World');
+            expect(result).toEqual(['hello', 'world']);
+        });
+        it('should handle empty or falsy values', () => {
+            expect((0, searchTokens_1.getSearchTokens)('')).toEqual([]);
+            expect((0, searchTokens_1.getSearchTokens)(null)).toEqual([]);
+            expect((0, searchTokens_1.getSearchTokens)(undefined)).toEqual([]);
+        });
+        it('should normalize and split strings with special characters', () => {
+            const result = (0, searchTokens_1.getSearchTokens)('Héllô-Wôrld! 123');
+            expect(result).toEqual(['hello', 'world', '123']);
+        });
+        it('should process an array of strings', () => {
+            const result = (0, searchTokens_1.getSearchTokens)(['Hello', 'World']);
+            expect(result).toEqual(['hello', 'world']);
+        });
+        it('should filter out falsy values in arrays', () => {
+            const result = (0, searchTokens_1.getSearchTokens)(['Hello', '', null, undefined, 'World']);
+            expect(result).toEqual(['hello', 'world']);
+        });
+        it('should add metadata tokens when provided', () => {
+            const result = (0, searchTokens_1.getSearchTokens)('Hello World', { id: '123', category: 'test' });
+            expect(result).toEqual(['hello', 'world', '_id:123', '_category:test']);
+        });
+        it('should handle strings with multiple spaces correctly', () => {
+            const result = (0, searchTokens_1.getSearchTokens)('  Hello   World  ');
+            expect(result).toEqual(['hello', 'world']);
+        });
+    });
+    describe('getSearchQueryForTokens', () => {
+        it('should return empty query when no params provided', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)();
+            expect(result).toEqual({ $all: [] });
+        });
+        it('should convert filter string to RegExp tokens', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)({ filter: 'hello world' });
+            expect(result.$all.length).toBe(2);
+            expect(result.$all[0]).toBeInstanceOf(RegExp);
+            expect(result.$all[1]).toBeInstanceOf(RegExp);
+            // Test RegExp patterns
+            expect(result.$all[0].source).toBe('^hello');
+            expect(result.$all[1].source).toBe('^world');
+        });
+        it('should ignore empty filter', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)({ filter: '' });
+            expect(result).toEqual({ $all: [] });
+        });
+        it('should add metadata tokens for additional parameters', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)({
+                filter: 'search',
+                category: 'books',
+                id: '123'
+            });
+            // Should have one RegExp token from filter and two metadata tokens
+            expect(result.$all.length).toBe(3);
+            expect(result.$all[0]).toBeInstanceOf(RegExp);
+            expect(result.$all[1]).toBe('_category:books');
+            expect(result.$all[2]).toBe('_id:123');
+        });
+        it('should ignore empty metadata values', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)({
+                category: 'books',
+                author: '',
+                id: '123'
+            });
+            expect(result.$all.length).toBe(2);
+            expect(result.$all.includes('_category:books')).toBe(true);
+            expect(result.$all.includes('_id:123')).toBe(true);
+            expect(result.$all.includes('_author:')).toBe(false);
+        });
+        it('should handle complex filter with metadata', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)({
+                filter: 'Héllô Wôrld!',
+                status: 'active'
+            });
+            expect(result.$all.length).toBe(3);
+            // Check RegExp patterns
+            expect(result.$all[0].source).toBe('^hello');
+            expect(result.$all[1].source).toBe('^world');
+            // Check metadata token
+            expect(result.$all[2]).toBe('_status:active');
+        });
+        it('should maintain correct order with filter and metadata', () => {
+            const result = (0, searchTokens_1.getSearchQueryForTokens)({
+                filter: 'search term',
+                category: 'books'
+            });
+            // Filter tokens should come first, then metadata
+            expect(result.$all.length).toBe(3);
+            expect(result.$all[0]).toBeInstanceOf(RegExp);
+            expect(result.$all[1]).toBeInstanceOf(RegExp);
+            expect(result.$all[2]).toBe('_category:books');
+        });
+    });
+});

package/lib/shortenMongoId.d.ts

@@ -0,0 +1 @@
+export declare function shortenMongoId(string: string): string;

package/lib/shortenMongoId.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortenMongoId = void 0;
+function lastOfString(string, last) {
+    return string.substring(string.length - last, string.length);
+}
+function shortenMongoId(string) {
+    return lastOfString(string, 5).toUpperCase();
+}
+exports.shortenMongoId = shortenMongoId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/helpers",
-  "version": "3.11.8",
+  "version": "3.11.15",
   "main": "lib/index.js",
   "author": "nicolaslopezj",
   "license": "MIT",
@@ -25,5 +25,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "78d70ac414964ec657cc000cedfad8a5efff5cc3"
+  "gitHead": "a5c95d9fd18f779c834644eb757928cdb840643c"
 }