@redis/search 1.0.6

package/dist/commands/index.d.ts

@@ -0,0 +1,240 @@
+import * as _LIST from './_LIST';
+import * as ALTER from './ALTER';
+import * as AGGREGATE from './AGGREGATE';
+import * as ALIASADD from './ALIASADD';
+import * as ALIASDEL from './ALIASDEL';
+import * as ALIASUPDATE from './ALIASUPDATE';
+import * as CONFIG_GET from './CONFIG_GET';
+import * as CONFIG_SET from './CONFIG_SET';
+import * as CREATE from './CREATE';
+import * as DICTADD from './DICTADD';
+import * as DICTDEL from './DICTDEL';
+import * as DICTDUMP from './DICTDUMP';
+import * as DROPINDEX from './DROPINDEX';
+import * as EXPLAIN from './EXPLAIN';
+import * as EXPLAINCLI from './EXPLAINCLI';
+import * as INFO from './INFO';
+import * as PROFILESEARCH from './PROFILE_SEARCH';
+import * as PROFILEAGGREGATE from './PROFILE_AGGREGATE';
+import * as SEARCH from './SEARCH';
+import * as SPELLCHECK from './SPELLCHECK';
+import * as SUGADD from './SUGADD';
+import * as SUGDEL from './SUGDEL';
+import * as SUGGET_WITHPAYLOADS from './SUGGET_WITHPAYLOADS';
+import * as SUGGET_WITHSCORES_WITHPAYLOADS from './SUGGET_WITHSCORES_WITHPAYLOADS';
+import * as SUGGET_WITHSCORES from './SUGGET_WITHSCORES';
+import * as SUGGET from './SUGGET';
+import * as SUGLEN from './SUGLEN';
+import * as SYNDUMP from './SYNDUMP';
+import * as SYNUPDATE from './SYNUPDATE';
+import * as TAGVALS from './TAGVALS';
+import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { SearchOptions } from './SEARCH';
+declare const _default: {
+    _LIST: typeof _LIST;
+    _list: typeof _LIST;
+    ALTER: typeof ALTER;
+    alter: typeof ALTER;
+    AGGREGATE: typeof AGGREGATE;
+    aggregate: typeof AGGREGATE;
+    ALIASADD: typeof ALIASADD;
+    aliasAdd: typeof ALIASADD;
+    ALIASDEL: typeof ALIASDEL;
+    aliasDel: typeof ALIASDEL;
+    ALIASUPDATE: typeof ALIASUPDATE;
+    aliasUpdate: typeof ALIASUPDATE;
+    CONFIG_GET: typeof CONFIG_GET;
+    configGet: typeof CONFIG_GET;
+    CONFIG_SET: typeof CONFIG_SET;
+    configSet: typeof CONFIG_SET;
+    CREATE: typeof CREATE;
+    create: typeof CREATE;
+    DICTADD: typeof DICTADD;
+    dictAdd: typeof DICTADD;
+    DICTDEL: typeof DICTDEL;
+    dictDel: typeof DICTDEL;
+    DICTDUMP: typeof DICTDUMP;
+    dictDump: typeof DICTDUMP;
+    DROPINDEX: typeof DROPINDEX;
+    dropIndex: typeof DROPINDEX;
+    EXPLAIN: typeof EXPLAIN;
+    explain: typeof EXPLAIN;
+    EXPLAINCLI: typeof EXPLAINCLI;
+    explainCli: typeof EXPLAINCLI;
+    INFO: typeof INFO;
+    info: typeof INFO;
+    PROFILESEARCH: typeof PROFILESEARCH;
+    profileSearch: typeof PROFILESEARCH;
+    PROFILEAGGREGATE: typeof PROFILEAGGREGATE;
+    profileAggregate: typeof PROFILEAGGREGATE;
+    SEARCH: typeof SEARCH;
+    search: typeof SEARCH;
+    SPELLCHECK: typeof SPELLCHECK;
+    spellCheck: typeof SPELLCHECK;
+    SUGADD: typeof SUGADD;
+    sugAdd: typeof SUGADD;
+    SUGDEL: typeof SUGDEL;
+    sugDel: typeof SUGDEL;
+    SUGGET_WITHPAYLOADS: typeof SUGGET_WITHPAYLOADS;
+    sugGetWithPayloads: typeof SUGGET_WITHPAYLOADS;
+    SUGGET_WITHSCORES_WITHPAYLOADS: typeof SUGGET_WITHSCORES_WITHPAYLOADS;
+    sugGetWithScoresWithPayloads: typeof SUGGET_WITHSCORES_WITHPAYLOADS;
+    SUGGET_WITHSCORES: typeof SUGGET_WITHSCORES;
+    sugGetWithScores: typeof SUGGET_WITHSCORES;
+    SUGGET: typeof SUGGET;
+    sugGet: typeof SUGGET;
+    SUGLEN: typeof SUGLEN;
+    sugLen: typeof SUGLEN;
+    SYNDUMP: typeof SYNDUMP;
+    synDump: typeof SYNDUMP;
+    SYNUPDATE: typeof SYNUPDATE;
+    synUpdate: typeof SYNUPDATE;
+    TAGVALS: typeof TAGVALS;
+    tagVals: typeof TAGVALS;
+};
+export default _default;
+export declare enum RedisSearchLanguages {
+    ARABIC = "Arabic",
+    BASQUE = "Basque",
+    CATALANA = "Catalan",
+    DANISH = "Danish",
+    DUTCH = "Dutch",
+    ENGLISH = "English",
+    FINNISH = "Finnish",
+    FRENCH = "French",
+    GERMAN = "German",
+    GREEK = "Greek",
+    HUNGARIAN = "Hungarian",
+    INDONESAIN = "Indonesian",
+    IRISH = "Irish",
+    ITALIAN = "Italian",
+    LITHUANIAN = "Lithuanian",
+    NEPALI = "Nepali",
+    NORWEIGAN = "Norwegian",
+    PORTUGUESE = "Portuguese",
+    ROMANIAN = "Romanian",
+    RUSSIAN = "Russian",
+    SPANISH = "Spanish",
+    SWEDISH = "Swedish",
+    TAMIL = "Tamil",
+    TURKISH = "Turkish",
+    CHINESE = "Chinese"
+}
+export declare type PropertyName = `${'@' | '$.'}${string}`;
+export declare type SortByProperty = PropertyName | {
+    BY: PropertyName;
+    DIRECTION?: 'ASC' | 'DESC';
+};
+export declare function pushSortByProperty(args: RedisCommandArguments, sortBy: SortByProperty): void;
+export declare function pushSortByArguments(args: RedisCommandArguments, name: string, sortBy: SortByProperty | Array<SortByProperty>): RedisCommandArguments;
+export declare function pushArgumentsWithLength(args: RedisCommandArguments, fn: (args: RedisCommandArguments) => void): RedisCommandArguments;
+export declare enum SchemaFieldTypes {
+    TEXT = "TEXT",
+    NUMERIC = "NUMERIC",
+    GEO = "GEO",
+    TAG = "TAG",
+    VECTOR = "VECTOR"
+}
+declare type CreateSchemaField<T extends SchemaFieldTypes, E = Record<keyof any, any>> = T | ({
+    type: T;
+    AS?: string;
+} & E);
+declare type CreateSchemaCommonField<T extends SchemaFieldTypes, E = Record<string, never>> = CreateSchemaField<T, ({
+    SORTABLE?: true | 'UNF';
+    NOINDEX?: true;
+} & E)>;
+export declare enum SchemaTextFieldPhonetics {
+    DM_EN = "dm:en",
+    DM_FR = "dm:fr",
+    FM_PT = "dm:pt",
+    DM_ES = "dm:es"
+}
+declare type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
+    NOSTEM?: true;
+    WEIGHT?: number;
+    PHONETIC?: SchemaTextFieldPhonetics;
+}>;
+declare type CreateSchemaNumericField = CreateSchemaCommonField<SchemaFieldTypes.NUMERIC>;
+declare type CreateSchemaGeoField = CreateSchemaCommonField<SchemaFieldTypes.GEO>;
+declare type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
+    SEPARATOR?: string;
+    CASESENSITIVE?: true;
+}>;
+export declare enum VectorAlgorithms {
+    FLAT = "FLAT",
+    HNSW = "HNSW"
+}
+declare type CreateSchemaVectorField<T extends VectorAlgorithms, A extends Record<string, unknown>> = CreateSchemaField<SchemaFieldTypes.VECTOR, {
+    ALGORITHM: T;
+    TYPE: string;
+    DIM: number;
+    DISTANCE_METRIC: 'L2' | 'IP' | 'COSINE';
+    INITIAL_CAP?: number;
+} & A>;
+declare type CreateSchemaFlatVectorField = CreateSchemaVectorField<VectorAlgorithms.FLAT, {
+    BLOCK_SIZE?: number;
+}>;
+declare type CreateSchemaHNSWVectorField = CreateSchemaVectorField<VectorAlgorithms.HNSW, {
+    M?: number;
+    EF_CONSTRUCTION?: number;
+    EF_RUNTIME?: number;
+}>;
+export interface RediSearchSchema {
+    [field: string]: CreateSchemaTextField | CreateSchemaNumericField | CreateSchemaGeoField | CreateSchemaTagField | CreateSchemaFlatVectorField | CreateSchemaHNSWVectorField;
+}
+export declare function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema): void;
+export declare type Params = Record<string, RedisCommandArgument | number>;
+export declare function pushParamsArgs(args: RedisCommandArguments, params?: Params): RedisCommandArguments;
+export declare function pushSearchOptions(args: RedisCommandArguments, options?: SearchOptions): RedisCommandArguments;
+interface SearchDocumentValue {
+    [key: string]: string | number | null | Array<SearchDocumentValue> | SearchDocumentValue;
+}
+export interface SearchReply {
+    total: number;
+    documents: Array<{
+        id: string;
+        value: SearchDocumentValue;
+    }>;
+}
+export interface ProfileOptions {
+    LIMITED?: true;
+}
+export declare type ProfileRawReply<T> = [
+    results: T,
+    profile: [
+        _: string,
+        TotalProfileTime: string,
+        _: string,
+        ParsingTime: string,
+        _: string,
+        PipelineCreationTime: string,
+        _: string,
+        IteratorsProfile: Array<any>
+    ]
+];
+export interface ProfileReply {
+    results: SearchReply | AGGREGATE.AggregateReply;
+    profile: ProfileData;
+}
+interface ChildIterator {
+    type?: string;
+    counter?: number;
+    term?: string;
+    size?: number;
+    time?: string;
+    childIterators?: Array<ChildIterator>;
+}
+interface IteratorsProfile {
+    type?: string;
+    counter?: number;
+    queryType?: string;
+    time?: string;
+    childIterators?: Array<ChildIterator>;
+}
+interface ProfileData {
+    totalProfileTime: string;
+    parsingTime: string;
+    pipelineCreationTime: string;
+    iteratorsProfile: IteratorsProfile;
+}
+export declare function transformProfile(reply: Array<any>): ProfileData;

package/dist/commands/index.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformProfile = exports.pushSearchOptions = exports.pushParamsArgs = exports.pushSchema = exports.VectorAlgorithms = exports.SchemaTextFieldPhonetics = exports.SchemaFieldTypes = exports.pushArgumentsWithLength = exports.pushSortByArguments = exports.pushSortByProperty = exports.RedisSearchLanguages = void 0;
+const _LIST = require("./_LIST");
+const ALTER = require("./ALTER");
+const AGGREGATE = require("./AGGREGATE");
+const ALIASADD = require("./ALIASADD");
+const ALIASDEL = require("./ALIASDEL");
+const ALIASUPDATE = require("./ALIASUPDATE");
+const CONFIG_GET = require("./CONFIG_GET");
+const CONFIG_SET = require("./CONFIG_SET");
+const CREATE = require("./CREATE");
+const DICTADD = require("./DICTADD");
+const DICTDEL = require("./DICTDEL");
+const DICTDUMP = require("./DICTDUMP");
+const DROPINDEX = require("./DROPINDEX");
+const EXPLAIN = require("./EXPLAIN");
+const EXPLAINCLI = require("./EXPLAINCLI");
+const INFO = require("./INFO");
+const PROFILESEARCH = require("./PROFILE_SEARCH");
+const PROFILEAGGREGATE = require("./PROFILE_AGGREGATE");
+const SEARCH = require("./SEARCH");
+const SPELLCHECK = require("./SPELLCHECK");
+const SUGADD = require("./SUGADD");
+const SUGDEL = require("./SUGDEL");
+const SUGGET_WITHPAYLOADS = require("./SUGGET_WITHPAYLOADS");
+const SUGGET_WITHSCORES_WITHPAYLOADS = require("./SUGGET_WITHSCORES_WITHPAYLOADS");
+const SUGGET_WITHSCORES = require("./SUGGET_WITHSCORES");
+const SUGGET = require("./SUGGET");
+const SUGLEN = require("./SUGLEN");
+const SYNDUMP = require("./SYNDUMP");
+const SYNUPDATE = require("./SYNUPDATE");
+const TAGVALS = require("./TAGVALS");
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    _LIST,
+    _list: _LIST,
+    ALTER,
+    alter: ALTER,
+    AGGREGATE,
+    aggregate: AGGREGATE,
+    ALIASADD,
+    aliasAdd: ALIASADD,
+    ALIASDEL,
+    aliasDel: ALIASDEL,
+    ALIASUPDATE,
+    aliasUpdate: ALIASUPDATE,
+    CONFIG_GET,
+    configGet: CONFIG_GET,
+    CONFIG_SET,
+    configSet: CONFIG_SET,
+    CREATE,
+    create: CREATE,
+    DICTADD,
+    dictAdd: DICTADD,
+    DICTDEL,
+    dictDel: DICTDEL,
+    DICTDUMP,
+    dictDump: DICTDUMP,
+    DROPINDEX,
+    dropIndex: DROPINDEX,
+    EXPLAIN,
+    explain: EXPLAIN,
+    EXPLAINCLI,
+    explainCli: EXPLAINCLI,
+    INFO,
+    info: INFO,
+    PROFILESEARCH,
+    profileSearch: PROFILESEARCH,
+    PROFILEAGGREGATE,
+    profileAggregate: PROFILEAGGREGATE,
+    SEARCH,
+    search: SEARCH,
+    SPELLCHECK,
+    spellCheck: SPELLCHECK,
+    SUGADD,
+    sugAdd: SUGADD,
+    SUGDEL,
+    sugDel: SUGDEL,
+    SUGGET_WITHPAYLOADS,
+    sugGetWithPayloads: SUGGET_WITHPAYLOADS,
+    SUGGET_WITHSCORES_WITHPAYLOADS,
+    sugGetWithScoresWithPayloads: SUGGET_WITHSCORES_WITHPAYLOADS,
+    SUGGET_WITHSCORES,
+    sugGetWithScores: SUGGET_WITHSCORES,
+    SUGGET,
+    sugGet: SUGGET,
+    SUGLEN,
+    sugLen: SUGLEN,
+    SYNDUMP,
+    synDump: SYNDUMP,
+    SYNUPDATE,
+    synUpdate: SYNUPDATE,
+    TAGVALS,
+    tagVals: TAGVALS
+};
+var RedisSearchLanguages;
+(function (RedisSearchLanguages) {
+    RedisSearchLanguages["ARABIC"] = "Arabic";
+    RedisSearchLanguages["BASQUE"] = "Basque";
+    RedisSearchLanguages["CATALANA"] = "Catalan";
+    RedisSearchLanguages["DANISH"] = "Danish";
+    RedisSearchLanguages["DUTCH"] = "Dutch";
+    RedisSearchLanguages["ENGLISH"] = "English";
+    RedisSearchLanguages["FINNISH"] = "Finnish";
+    RedisSearchLanguages["FRENCH"] = "French";
+    RedisSearchLanguages["GERMAN"] = "German";
+    RedisSearchLanguages["GREEK"] = "Greek";
+    RedisSearchLanguages["HUNGARIAN"] = "Hungarian";
+    RedisSearchLanguages["INDONESAIN"] = "Indonesian";
+    RedisSearchLanguages["IRISH"] = "Irish";
+    RedisSearchLanguages["ITALIAN"] = "Italian";
+    RedisSearchLanguages["LITHUANIAN"] = "Lithuanian";
+    RedisSearchLanguages["NEPALI"] = "Nepali";
+    RedisSearchLanguages["NORWEIGAN"] = "Norwegian";
+    RedisSearchLanguages["PORTUGUESE"] = "Portuguese";
+    RedisSearchLanguages["ROMANIAN"] = "Romanian";
+    RedisSearchLanguages["RUSSIAN"] = "Russian";
+    RedisSearchLanguages["SPANISH"] = "Spanish";
+    RedisSearchLanguages["SWEDISH"] = "Swedish";
+    RedisSearchLanguages["TAMIL"] = "Tamil";
+    RedisSearchLanguages["TURKISH"] = "Turkish";
+    RedisSearchLanguages["CHINESE"] = "Chinese";
+})(RedisSearchLanguages = exports.RedisSearchLanguages || (exports.RedisSearchLanguages = {}));
+function pushSortByProperty(args, sortBy) {
+    if (typeof sortBy === 'string') {
+        args.push(sortBy);
+    }
+    else {
+        args.push(sortBy.BY);
+        if (sortBy.DIRECTION) {
+            args.push(sortBy.DIRECTION);
+        }
+    }
+}
+exports.pushSortByProperty = pushSortByProperty;
+function pushSortByArguments(args, name, sortBy) {
+    const lengthBefore = args.push(name, '' // will be overwritten
+    );
+    if (Array.isArray(sortBy)) {
+        for (const field of sortBy) {
+            pushSortByProperty(args, field);
+        }
+    }
+    else {
+        pushSortByProperty(args, sortBy);
+    }
+    args[lengthBefore - 1] = (args.length - lengthBefore).toString();
+    return args;
+}
+exports.pushSortByArguments = pushSortByArguments;
+function pushArgumentsWithLength(args, fn) {
+    const lengthIndex = args.push('') - 1;
+    fn(args);
+    args[lengthIndex] = (args.length - lengthIndex - 1).toString();
+    return args;
+}
+exports.pushArgumentsWithLength = pushArgumentsWithLength;
+var SchemaFieldTypes;
+(function (SchemaFieldTypes) {
+    SchemaFieldTypes["TEXT"] = "TEXT";
+    SchemaFieldTypes["NUMERIC"] = "NUMERIC";
+    SchemaFieldTypes["GEO"] = "GEO";
+    SchemaFieldTypes["TAG"] = "TAG";
+    SchemaFieldTypes["VECTOR"] = "VECTOR";
+})(SchemaFieldTypes = exports.SchemaFieldTypes || (exports.SchemaFieldTypes = {}));
+var SchemaTextFieldPhonetics;
+(function (SchemaTextFieldPhonetics) {
+    SchemaTextFieldPhonetics["DM_EN"] = "dm:en";
+    SchemaTextFieldPhonetics["DM_FR"] = "dm:fr";
+    SchemaTextFieldPhonetics["FM_PT"] = "dm:pt";
+    SchemaTextFieldPhonetics["DM_ES"] = "dm:es";
+})(SchemaTextFieldPhonetics = exports.SchemaTextFieldPhonetics || (exports.SchemaTextFieldPhonetics = {}));
+var VectorAlgorithms;
+(function (VectorAlgorithms) {
+    VectorAlgorithms["FLAT"] = "FLAT";
+    VectorAlgorithms["HNSW"] = "HNSW";
+})(VectorAlgorithms = exports.VectorAlgorithms || (exports.VectorAlgorithms = {}));
+function pushSchema(args, schema) {
+    for (const [field, fieldOptions] of Object.entries(schema)) {
+        args.push(field);
+        if (typeof fieldOptions === 'string') {
+            args.push(fieldOptions);
+            continue;
+        }
+        if (fieldOptions.AS) {
+            args.push('AS', fieldOptions.AS);
+        }
+        args.push(fieldOptions.type);
+        switch (fieldOptions.type) {
+            case SchemaFieldTypes.TEXT:
+                if (fieldOptions.NOSTEM) {
+                    args.push('NOSTEM');
+                }
+                if (fieldOptions.WEIGHT) {
+                    args.push('WEIGHT', fieldOptions.WEIGHT.toString());
+                }
+                if (fieldOptions.PHONETIC) {
+                    args.push('PHONETIC', fieldOptions.PHONETIC);
+                }
+                break;
+            // case SchemaFieldTypes.NUMERIC:
+            // case SchemaFieldTypes.GEO:
+            //     break;
+            case SchemaFieldTypes.TAG:
+                if (fieldOptions.SEPARATOR) {
+                    args.push('SEPARATOR', fieldOptions.SEPARATOR);
+                }
+                if (fieldOptions.CASESENSITIVE) {
+                    args.push('CASESENSITIVE');
+                }
+                break;
+            case SchemaFieldTypes.VECTOR:
+                args.push(fieldOptions.ALGORITHM);
+                pushArgumentsWithLength(args, () => {
+                    args.push('TYPE', fieldOptions.TYPE, 'DIM', fieldOptions.DIM.toString(), 'DISTANCE_METRIC', fieldOptions.DISTANCE_METRIC);
+                    if (fieldOptions.INITIAL_CAP) {
+                        args.push('INITIAL_CAP', fieldOptions.INITIAL_CAP.toString());
+                    }
+                    switch (fieldOptions.ALGORITHM) {
+                        case VectorAlgorithms.FLAT:
+                            if (fieldOptions.BLOCK_SIZE) {
+                                args.push('BLOCK_SIZE', fieldOptions.BLOCK_SIZE.toString());
+                            }
+                            break;
+                        case VectorAlgorithms.HNSW:
+                            if (fieldOptions.M) {
+                                args.push('M', fieldOptions.M.toString());
+                            }
+                            if (fieldOptions.EF_CONSTRUCTION) {
+                                args.push('EF_CONSTRUCTION', fieldOptions.EF_CONSTRUCTION.toString());
+                            }
+                            if (fieldOptions.EF_RUNTIME) {
+                                args.push('EF_RUNTIME', fieldOptions.EF_RUNTIME.toString());
+                            }
+                            break;
+                    }
+                });
+                continue; // vector fields do not contain SORTABLE and NOINDEX options
+        }
+        if (fieldOptions.SORTABLE) {
+            args.push('SORTABLE');
+            if (fieldOptions.SORTABLE === 'UNF') {
+                args.push('UNF');
+            }
+        }
+        if (fieldOptions.NOINDEX) {
+            args.push('NOINDEX');
+        }
+    }
+}
+exports.pushSchema = pushSchema;
+function pushParamsArgs(args, params) {
+    if (params) {
+        const enrties = Object.entries(params);
+        args.push('PARAMS', (enrties.length * 2).toString());
+        for (const [key, value] of enrties) {
+            args.push(key, typeof value === 'number' ? value.toString() : value);
+        }
+    }
+    return args;
+}
+exports.pushParamsArgs = pushParamsArgs;
+function pushSearchOptions(args, options) {
+    if (options?.VERBATIM) {
+        args.push('VERBATIM');
+    }
+    if (options?.NOSTOPWORDS) {
+        args.push('NOSTOPWORDS');
+    }
+    // if (options?.WITHSCORES) {
+    //     args.push('WITHSCORES');
+    // }
+    // if (options?.WITHPAYLOADS) {
+    //     args.push('WITHPAYLOADS');
+    // }
+    (0, generic_transformers_1.pushOptionalVerdictArgument)(args, 'INKEYS', options?.INKEYS);
+    (0, generic_transformers_1.pushOptionalVerdictArgument)(args, 'INFIELDS', options?.INFIELDS);
+    (0, generic_transformers_1.pushOptionalVerdictArgument)(args, 'RETURN', options?.RETURN);
+    if (options?.SUMMARIZE) {
+        args.push('SUMMARIZE');
+        if (typeof options.SUMMARIZE === 'object') {
+            if (options.SUMMARIZE.FIELDS) {
+                args.push('FIELDS');
+                (0, generic_transformers_1.pushVerdictArgument)(args, options.SUMMARIZE.FIELDS);
+            }
+            if (options.SUMMARIZE.FRAGS) {
+                args.push('FRAGS', options.SUMMARIZE.FRAGS.toString());
+            }
+            if (options.SUMMARIZE.LEN) {
+                args.push('LEN', options.SUMMARIZE.LEN.toString());
+            }
+            if (options.SUMMARIZE.SEPARATOR) {
+                args.push('SEPARATOR', options.SUMMARIZE.SEPARATOR);
+            }
+        }
+    }
+    if (options?.HIGHLIGHT) {
+        args.push('HIGHLIGHT');
+        if (typeof options.HIGHLIGHT === 'object') {
+            if (options.HIGHLIGHT.FIELDS) {
+                args.push('FIELDS');
+                (0, generic_transformers_1.pushVerdictArgument)(args, options.HIGHLIGHT.FIELDS);
+            }
+            if (options.HIGHLIGHT.TAGS) {
+                args.push('TAGS', options.HIGHLIGHT.TAGS.open, options.HIGHLIGHT.TAGS.close);
+            }
+        }
+    }
+    if (options?.SLOP) {
+        args.push('SLOP', options.SLOP.toString());
+    }
+    if (options?.INORDER) {
+        args.push('INORDER');
+    }
+    if (options?.LANGUAGE) {
+        args.push('LANGUAGE', options.LANGUAGE);
+    }
+    if (options?.EXPANDER) {
+        args.push('EXPANDER', options.EXPANDER);
+    }
+    if (options?.SCORER) {
+        args.push('SCORER', options.SCORER);
+    }
+    // if (options?.EXPLAINSCORE) {
+    //     args.push('EXPLAINSCORE');
+    // }
+    // if (options?.PAYLOAD) {
+    //     args.push('PAYLOAD', options.PAYLOAD);
+    // }
+    if (options?.SORTBY) {
+        args.push('SORTBY');
+        pushSortByProperty(args, options.SORTBY);
+    }
+    // if (options?.MSORTBY) {
+    //     pushSortByArguments(args, 'MSORTBY', options.MSORTBY);
+    // }
+    if (options?.LIMIT) {
+        args.push('LIMIT', options.LIMIT.from.toString(), options.LIMIT.size.toString());
+    }
+    if (options?.PARAMS) {
+        pushParamsArgs(args, options.PARAMS);
+    }
+    if (options?.DIALECT) {
+        args.push('DIALECT', options.DIALECT.toString());
+    }
+    return args;
+}
+exports.pushSearchOptions = pushSearchOptions;
+function transformProfile(reply) {
+    return {
+        totalProfileTime: reply[0][1],
+        parsingTime: reply[1][1],
+        pipelineCreationTime: reply[2][1],
+        iteratorsProfile: transformIterators(reply[3][1])
+    };
+}
+exports.transformProfile = transformProfile;
+function transformIterators(IteratorsProfile) {
+    var res = {};
+    for (let i = 0; i < IteratorsProfile.length; i += 2) {
+        const value = IteratorsProfile[i + 1];
+        switch (IteratorsProfile[i]) {
+            case 'Type':
+                res.type = value;
+                break;
+            case 'Counter':
+                res.counter = value;
+                break;
+            case 'Time':
+                res.time = value;
+                break;
+            case 'Query type':
+                res.queryType = value;
+                break;
+            case 'Child iterators':
+                res.childIterators = value.map(transformChildIterators);
+                break;
+        }
+    }
+    return res;
+}
+function transformChildIterators(IteratorsProfile) {
+    var res = {};
+    for (let i = 1; i < IteratorsProfile.length; i += 2) {
+        const value = IteratorsProfile[i + 1];
+        switch (IteratorsProfile[i]) {
+            case 'Type':
+                res.type = value;
+                break;
+            case 'Counter':
+                res.counter = value;
+                break;
+            case 'Time':
+                res.time = value;
+                break;
+            case 'Size':
+                res.size = value;
+                break;
+            case 'Term':
+                res.term = value;
+                break;
+            case 'Child iterators':
+                res.childIterators = value.map(transformChildIterators);
+                break;
+        }
+    }
+    return res;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './commands';
+export { RediSearchSchema, SchemaFieldTypes, SchemaTextFieldPhonetics, SearchReply, VectorAlgorithms } from './commands';
+export { AggregateSteps, AggregateGroupByReducers } from './commands/AGGREGATE';
+export { SearchOptions } from './commands/SEARCH';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateGroupByReducers = exports.AggregateSteps = exports.VectorAlgorithms = exports.SchemaTextFieldPhonetics = exports.SchemaFieldTypes = exports.default = void 0;
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return commands_1.default; } });
+var commands_2 = require("./commands");
+Object.defineProperty(exports, "SchemaFieldTypes", { enumerable: true, get: function () { return commands_2.SchemaFieldTypes; } });
+Object.defineProperty(exports, "SchemaTextFieldPhonetics", { enumerable: true, get: function () { return commands_2.SchemaTextFieldPhonetics; } });
+Object.defineProperty(exports, "VectorAlgorithms", { enumerable: true, get: function () { return commands_2.VectorAlgorithms; } });
+var AGGREGATE_1 = require("./commands/AGGREGATE");
+Object.defineProperty(exports, "AggregateSteps", { enumerable: true, get: function () { return AGGREGATE_1.AggregateSteps; } });
+Object.defineProperty(exports, "AggregateGroupByReducers", { enumerable: true, get: function () { return AGGREGATE_1.AggregateGroupByReducers; } });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@redis/search",
+  "version": "1.0.6",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "test": "nyc -r text-summary -r lcov mocha -r source-map-support/register -r ts-node/register './lib/**/*.spec.ts'",
+    "build": "tsc",
+    "documentation": "typedoc"
+  },
+  "peerDependencies": {
+    "@redis/client": "^1.0.0"
+  },
+  "devDependencies": {
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
+    "@redis/test-utils": "*",
+    "@types/node": "^17.0.31",
+    "nyc": "^15.1.0",
+    "release-it": "^15.0.0",
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.7.0",
+    "typedoc": "^0.22.15",
+    "typescript": "^4.6.4"
+  }
+}