orcaq 1.1.1 → 1.1.2

package/.output/server/node_modules/@redis/search/dist/lib/commands/SEARCH.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSearchOptions = exports.parseParamsArgument = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const default_1 = require("../dialect/default");
+function parseParamsArgument(parser, params) {
+    if (params) {
+        parser.push('PARAMS');
+        const args = [];
+        for (const key in params) {
+            if (!Object.hasOwn(params, key))
+                continue;
+            const value = params[key];
+            args.push(key, typeof value === 'number' ? value.toString() : value);
+        }
+        parser.pushVariadicWithLength(args);
+    }
+}
+exports.parseParamsArgument = parseParamsArgument;
+function parseSearchOptions(parser, options) {
+    if (options?.VERBATIM) {
+        parser.push('VERBATIM');
+    }
+    if (options?.NOSTOPWORDS) {
+        parser.push('NOSTOPWORDS');
+    }
+    (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'INKEYS', options?.INKEYS);
+    (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'INFIELDS', options?.INFIELDS);
+    (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'RETURN', options?.RETURN);
+    if (options?.SUMMARIZE) {
+        parser.push('SUMMARIZE');
+        if (typeof options.SUMMARIZE === 'object') {
+            (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'FIELDS', options.SUMMARIZE.FIELDS);
+            if (options.SUMMARIZE.FRAGS !== undefined) {
+                parser.push('FRAGS', options.SUMMARIZE.FRAGS.toString());
+            }
+            if (options.SUMMARIZE.LEN !== undefined) {
+                parser.push('LEN', options.SUMMARIZE.LEN.toString());
+            }
+            if (options.SUMMARIZE.SEPARATOR !== undefined) {
+                parser.push('SEPARATOR', options.SUMMARIZE.SEPARATOR);
+            }
+        }
+    }
+    if (options?.HIGHLIGHT) {
+        parser.push('HIGHLIGHT');
+        if (typeof options.HIGHLIGHT === 'object') {
+            (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'FIELDS', options.HIGHLIGHT.FIELDS);
+            if (options.HIGHLIGHT.TAGS) {
+                parser.push('TAGS', options.HIGHLIGHT.TAGS.open, options.HIGHLIGHT.TAGS.close);
+            }
+        }
+    }
+    if (options?.SLOP !== undefined) {
+        parser.push('SLOP', options.SLOP.toString());
+    }
+    if (options?.TIMEOUT !== undefined) {
+        parser.push('TIMEOUT', options.TIMEOUT.toString());
+    }
+    if (options?.INORDER) {
+        parser.push('INORDER');
+    }
+    if (options?.LANGUAGE) {
+        parser.push('LANGUAGE', options.LANGUAGE);
+    }
+    if (options?.EXPANDER) {
+        parser.push('EXPANDER', options.EXPANDER);
+    }
+    if (options?.SCORER) {
+        parser.push('SCORER', options.SCORER);
+    }
+    if (options?.SORTBY) {
+        parser.push('SORTBY');
+        if (typeof options.SORTBY === 'string' || options.SORTBY instanceof Buffer) {
+            parser.push(options.SORTBY);
+        }
+        else {
+            parser.push(options.SORTBY.BY);
+            if (options.SORTBY.DIRECTION) {
+                parser.push(options.SORTBY.DIRECTION);
+            }
+        }
+    }
+    if (options?.LIMIT) {
+        parser.push('LIMIT', options.LIMIT.from.toString(), options.LIMIT.size.toString());
+    }
+    parseParamsArgument(parser, options?.PARAMS);
+    if (options?.DIALECT) {
+        parser.push('DIALECT', options.DIALECT.toString());
+    }
+    else {
+        parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+    }
+}
+exports.parseSearchOptions = parseSearchOptions;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Searches a RediSearch index with the given query.
+     * @param parser - The command parser
+     * @param index - The index name to search
+     * @param query - The text query to search. For syntax, see https://redis.io/docs/stack/search/reference/query_syntax
+     * @param options - Optional search parameters including:
+     *   - VERBATIM: do not try to use stemming for query expansion
+     *   - NOSTOPWORDS: do not filter stopwords from the query
+     *   - INKEYS/INFIELDS: restrict the search to specific keys/fields
+     *   - RETURN: limit which fields are returned
+     *   - SUMMARIZE/HIGHLIGHT: create search result highlights
+     *   - LIMIT: pagination control
+     *   - SORTBY: sort results by a specific field
+     *   - PARAMS: bind parameters to the query
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.SEARCH', index, query);
+        parseSearchOptions(parser, options);
+    },
+    transformReply: {
+        2: (reply) => {
+            // if reply[2] is array, then we have content/documents. Otherwise, only ids
+            const withoutDocuments = reply.length > 2 && !Array.isArray(reply[2]);
+            const documents = [];
+            let i = 1;
+            while (i < reply.length) {
+                documents.push({
+                    id: reply[i++],
+                    value: withoutDocuments ? Object.create(null) : documentValue(reply[i++])
+                });
+            }
+            return {
+                total: reply[0],
+                documents
+            };
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+function documentValue(tuples) {
+    const message = Object.create(null);
+    if (!tuples) {
+        return message;
+    }
+    let i = 0;
+    while (i < tuples.length) {
+        const key = tuples[i++], value = tuples[i++];
+        if (key === '$') { // might be a JSON reply
+            try {
+                Object.assign(message, JSON.parse(value));
+                continue;
+            }
+            catch {
+                // set as a regular property if not a valid JSON
+            }
+        }
+        message[key] = value;
+    }
+    return message;
+}
+//# sourceMappingURL=SEARCH.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SEARCH_NOCONTENT.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SEARCH_1 = __importDefault(require("./SEARCH"));
+exports.default = {
+    NOT_KEYED_COMMAND: SEARCH_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: SEARCH_1.default.IS_READ_ONLY,
+    /**
+     * Performs a search query but returns only document ids without their contents.
+     * @param args - Same parameters as FT.SEARCH:
+     *   - parser: The command parser
+     *   - index: Name of the index to search
+     *   - query: The text query to search
+     *   - options: Optional search parameters
+     */
+    parseCommand(...args) {
+        SEARCH_1.default.parseCommand(...args);
+        args[0].push('NOCONTENT');
+    },
+    transformReply: {
+        2: (reply) => {
+            return {
+                total: reply[0],
+                documents: reply.slice(1)
+            };
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+;
+//# sourceMappingURL=SEARCH_NOCONTENT.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SPELLCHECK.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = require("../dialect/default");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Performs spelling correction on a search query.
+     * @param parser - The command parser
+     * @param index - Name of the index to use for spelling corrections
+     * @param query - The search query to check for spelling
+     * @param options - Optional parameters:
+     *   - DISTANCE: Maximum Levenshtein distance for spelling suggestions
+     *   - TERMS: Custom dictionary terms to include/exclude
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.SPELLCHECK', index, query);
+        if (options?.DISTANCE) {
+            parser.push('DISTANCE', options.DISTANCE.toString());
+        }
+        if (options?.TERMS) {
+            if (Array.isArray(options.TERMS)) {
+                for (const term of options.TERMS) {
+                    parseTerms(parser, term);
+                }
+            }
+            else {
+                parseTerms(parser, options.TERMS);
+            }
+        }
+        if (options?.DIALECT) {
+            parser.push('DIALECT', options.DIALECT.toString());
+        }
+        else {
+            parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+        }
+    },
+    transformReply: {
+        2: (rawReply) => {
+            return rawReply.map(([, term, suggestions]) => ({
+                term,
+                suggestions: suggestions.map(([score, suggestion]) => ({
+                    score: Number(score),
+                    suggestion
+                }))
+            }));
+        },
+        3: undefined,
+    },
+    unstableResp3: true
+};
+function parseTerms(parser, { mode, dictionary }) {
+    parser.push('TERMS', mode, dictionary);
+}
+//# sourceMappingURL=SPELLCHECK.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGADD.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Adds a suggestion string to an auto-complete suggestion dictionary.
+     * @param parser - The command parser
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to add
+     * @param score - The suggestion score used for sorting
+     * @param options - Optional parameters:
+     *   - INCR: If true, increment the existing entry's score
+     *   - PAYLOAD: Optional payload to associate with the suggestion
+     */
+    parseCommand(parser, key, string, score, options) {
+        parser.push('FT.SUGADD');
+        parser.pushKey(key);
+        parser.push(string, score.toString());
+        if (options?.INCR) {
+            parser.push('INCR');
+        }
+        if (options?.PAYLOAD) {
+            parser.push('PAYLOAD', options.PAYLOAD);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGADD.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGDEL.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Deletes a string from a suggestion dictionary.
+     * @param parser - The command parser
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to delete
+     */
+    parseCommand(parser, key, string) {
+        parser.push('FT.SUGDEL');
+        parser.pushKey(key);
+        parser.push(string);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGDEL.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGGET.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Gets completion suggestions for a prefix from a suggestion dictionary.
+     * @param parser - The command parser
+     * @param key - The suggestion dictionary key
+     * @param prefix - The prefix to get completion suggestions for
+     * @param options - Optional parameters:
+     *   - FUZZY: Enable fuzzy prefix matching
+     *   - MAX: Maximum number of results to return
+     */
+    parseCommand(parser, key, prefix, options) {
+        parser.push('FT.SUGGET');
+        parser.pushKey(key);
+        parser.push(prefix);
+        if (options?.FUZZY) {
+            parser.push('FUZZY');
+        }
+        if (options?.MAX !== undefined) {
+            parser.push('MAX', options.MAX.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGGET.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHPAYLOADS.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+exports.default = {
+    IS_READ_ONLY: SUGGET_1.default.IS_READ_ONLY,
+    /**
+     * Gets completion suggestions with their payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    parseCommand(...args) {
+        SUGGET_1.default.parseCommand(...args);
+        args[0].push('WITHPAYLOADS');
+    },
+    transformReply(reply) {
+        if ((0, generic_transformers_1.isNullReply)(reply))
+            return null;
+        const transformedReply = new Array(reply.length / 2);
+        let replyIndex = 0, arrIndex = 0;
+        while (replyIndex < reply.length) {
+            transformedReply[arrIndex++] = {
+                suggestion: reply[replyIndex++],
+                payload: reply[replyIndex++]
+            };
+        }
+        return transformedReply;
+    }
+};
+//# sourceMappingURL=SUGGET_WITHPAYLOADS.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+exports.default = {
+    IS_READ_ONLY: SUGGET_1.default.IS_READ_ONLY,
+    /**
+     * Gets completion suggestions with their scores from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    parseCommand(...args) {
+        SUGGET_1.default.parseCommand(...args);
+        args[0].push('WITHSCORES');
+    },
+    transformReply: {
+        2: (reply, preserve, typeMapping) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 2);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: generic_transformers_1.transformDoubleReply[2](reply[replyIndex++], preserve, typeMapping)
+                };
+            }
+            return transformedReply;
+        },
+        3: (reply) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 2);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: reply[replyIndex++]
+                };
+            }
+            return transformedReply;
+        }
+    }
+};
+//# sourceMappingURL=SUGGET_WITHSCORES.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+exports.default = {
+    IS_READ_ONLY: SUGGET_1.default.IS_READ_ONLY,
+    /**
+     * Gets completion suggestions with their scores and payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    parseCommand(...args) {
+        SUGGET_1.default.parseCommand(...args);
+        args[0].push('WITHSCORES', 'WITHPAYLOADS');
+    },
+    transformReply: {
+        2: (reply, preserve, typeMapping) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 3);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: generic_transformers_1.transformDoubleReply[2](reply[replyIndex++], preserve, typeMapping),
+                    payload: reply[replyIndex++]
+                };
+            }
+            return transformedReply;
+        },
+        3: (reply) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 3);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: reply[replyIndex++],
+                    payload: reply[replyIndex++]
+                };
+            }
+            return transformedReply;
+        }
+    }
+};
+//# sourceMappingURL=SUGGET_WITHSCORES_WITHPAYLOADS.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SUGLEN.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Gets the size of a suggestion dictionary.
+     * @param parser - The command parser
+     * @param key - The suggestion dictionary key
+     */
+    parseCommand(parser, key) {
+        parser.push('FT.SUGLEN', key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGLEN.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SYNDUMP.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Dumps the contents of a synonym group.
+     * @param parser - The command parser
+     * @param index - Name of the index that contains the synonym group
+     */
+    parseCommand(parser, index) {
+        parser.push('FT.SYNDUMP', index);
+    },
+    transformReply: {
+        2: (reply) => {
+            const result = {};
+            let i = 0;
+            while (i < reply.length) {
+                const key = reply[i++].toString(), value = reply[i++];
+                result[key] = value;
+            }
+            return result;
+        },
+        3: undefined
+    }
+};
+//# sourceMappingURL=SYNDUMP.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/SYNUPDATE.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Updates a synonym group with new terms.
+     * @param parser - The command parser
+     * @param index - Name of the index that contains the synonym group
+     * @param groupId - ID of the synonym group to update
+     * @param terms - One or more synonym terms to add to the group
+     * @param options - Optional parameters:
+     *   - SKIPINITIALSCAN: Skip the initial scan for existing documents
+     */
+    parseCommand(parser, index, groupId, terms, options) {
+        parser.push('FT.SYNUPDATE', index, groupId);
+        if (options?.SKIPINITIALSCAN) {
+            parser.push('SKIPINITIALSCAN');
+        }
+        parser.pushVariadic(terms);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SYNUPDATE.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/TAGVALS.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the distinct values in a TAG field.
+     * @param parser - The command parser
+     * @param index - Name of the index
+     * @param fieldName - Name of the TAG field to get values from
+     */
+    parseCommand(parser, index, fieldName) {
+        parser.push('FT.TAGVALS', index, fieldName);
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=TAGVALS.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/_LIST.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Lists all existing indexes in the database.
+     * @param parser - The command parser
+     */
+    parseCommand(parser) {
+        parser.push('FT._LIST');
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=_LIST.js.map