@redis/search 1.0.6 → 1.1.1

package/README.md

@@ -18,15 +18,14 @@ Before we can perform any searches, we need to tell RediSearch how to index our
 await client.ft.create('idx:animals', {
   name: {
     type: SchemaFieldTypes.TEXT,
-    sortable: true
+    SORTABLE: true
   },
-    species: SchemaFieldTypes.TAG,
-    age: SchemaFieldTypes.NUMERIC
-  }, {
-    ON: 'HASH',
-    PREFIX: 'noderedis:animals'
-  }
-);
+  species: SchemaFieldTypes.TAG,
+  age: SchemaFieldTypes.NUMERIC
+}, {
+  ON: 'HASH',
+  PREFIX: 'noderedis:animals'
+});
 ```
 
 See the [`FT.CREATE` documentation](https://oss.redis.com/redisearch/Commands/#ftcreate) for information about the different field types and additional options.

package/dist/commands/AGGREGATE.d.ts

@@ -29,7 +29,7 @@ interface GroupByReducer<T extends AggregateGroupByReducers> {
     type: T;
     AS?: string;
 }
-declare type CountReducer = GroupByReducer<AggregateGroupByReducers.COUNT>;
+type CountReducer = GroupByReducer<AggregateGroupByReducers.COUNT>;
 interface CountDistinctReducer extends GroupByReducer<AggregateGroupByReducers.COUNT_DISTINCT> {
     property: PropertyName;
 }
@@ -69,7 +69,7 @@ interface RandomSampleReducer extends GroupByReducer<AggregateGroupByReducers.RA
     property: PropertyName;
     sampleSize: number;
 }
-declare type GroupByReducers = CountReducer | CountDistinctReducer | CountDistinctishReducer | SumReducer | MinReducer | MaxReducer | AvgReducer | StdDevReducer | QuantileReducer | ToListReducer | FirstValueReducer | RandomSampleReducer;
+type GroupByReducers = CountReducer | CountDistinctReducer | CountDistinctishReducer | SumReducer | MinReducer | MaxReducer | AvgReducer | StdDevReducer | QuantileReducer | ToListReducer | FirstValueReducer | RandomSampleReducer;
 interface GroupByStep extends AggregateStep<AggregateSteps.GROUPBY> {
     properties?: PropertyName | Array<PropertyName>;
     REDUCE: GroupByReducers | Array<GroupByReducers>;
@@ -89,7 +89,7 @@ interface LimitStep extends AggregateStep<AggregateSteps.LIMIT> {
 interface FilterStep extends AggregateStep<AggregateSteps.FILTER> {
     expression: string;
 }
-declare type LoadField = PropertyName | {
+type LoadField = PropertyName | {
     identifier: PropertyName;
     AS?: string;
 };
@@ -100,9 +100,11 @@ export interface AggregateOptions {
     PARAMS?: Params;
     DIALECT?: number;
 }
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
 export declare function transformArguments(index: string, query: string, options?: AggregateOptions): RedisCommandArguments;
 export declare function pushAggregatehOptions(args: RedisCommandArguments, options?: AggregateOptions): RedisCommandArguments;
-export declare type AggregateRawReply = [
+export type AggregateRawReply = [
     total: number,
     ...results: Array<Array<RedisCommandArgument>>
 ];

package/dist/commands/AGGREGATE.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReply = exports.pushAggregatehOptions = exports.transformArguments = exports.AggregateGroupByReducers = exports.AggregateSteps = void 0;
+exports.transformReply = exports.pushAggregatehOptions = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = exports.AggregateGroupByReducers = exports.AggregateSteps = void 0;
 const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
 const _1 = require(".");
 var AggregateSteps;
@@ -27,6 +27,8 @@ var AggregateGroupByReducers;
     AggregateGroupByReducers["FIRST_VALUE"] = "FIRST_VALUE";
     AggregateGroupByReducers["RANDOM_SAMPLE"] = "RANDOM_SAMPLE";
 })(AggregateGroupByReducers = exports.AggregateGroupByReducers || (exports.AggregateGroupByReducers = {}));
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
 function transformArguments(index, query, options) {
     return pushAggregatehOptions(['FT.AGGREGATE', index, query], options);
 }

package/dist/commands/AGGREGATE_WITHCURSOR.d.ts

@@ -0,0 +1,14 @@
+import { AggregateOptions, AggregateRawReply, AggregateReply } from './AGGREGATE';
+export { FIRST_KEY_INDEX, IS_READ_ONLY } from './AGGREGATE';
+interface AggregateWithCursorOptions extends AggregateOptions {
+    COUNT?: number;
+}
+export declare function transformArguments(index: string, query: string, options?: AggregateWithCursorOptions): import("@redis/client/dist/lib/commands").RedisCommandArguments;
+type AggregateWithCursorRawReply = [
+    result: AggregateRawReply,
+    cursor: number
+];
+interface AggregateWithCursorReply extends AggregateReply {
+    cursor: number;
+}
+export declare function transformReply(reply: AggregateWithCursorRawReply): AggregateWithCursorReply;

package/dist/commands/AGGREGATE_WITHCURSOR.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+const AGGREGATE_1 = require("./AGGREGATE");
+var AGGREGATE_2 = require("./AGGREGATE");
+Object.defineProperty(exports, "FIRST_KEY_INDEX", { enumerable: true, get: function () { return AGGREGATE_2.FIRST_KEY_INDEX; } });
+Object.defineProperty(exports, "IS_READ_ONLY", { enumerable: true, get: function () { return AGGREGATE_2.IS_READ_ONLY; } });
+function transformArguments(index, query, options) {
+    const args = (0, AGGREGATE_1.transformArguments)(index, query, options);
+    args.push('WITHCURSOR');
+    if (options?.COUNT) {
+        args.push('COUNT', options.COUNT.toString());
+    }
+    return args;
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return {
+        ...(0, AGGREGATE_1.transformReply)(reply[0]),
+        cursor: reply[1]
+    };
+}
+exports.transformReply = transformReply;

package/dist/commands/CURSOR_DEL.d.ts

@@ -0,0 +1,4 @@
+import { RedisCommandArgument } from '@redis/client/dist/lib/commands';
+export declare const FIRST_KEY_INDEX = 1;
+export declare function transformArguments(index: RedisCommandArgument, cursorId: number): RedisCommandArgument[];
+export declare function transformReply(): 'OK';

package/dist/commands/CURSOR_DEL.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(index, cursorId) {
+    return [
+        'FT.CURSOR',
+        'DEL',
+        index,
+        cursorId.toString()
+    ];
+}
+exports.transformArguments = transformArguments;

package/dist/commands/CURSOR_READ.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(index: RedisCommandArgument, cursor: number): RedisCommandArguments;
+export { transformReply } from './AGGREGATE_WITHCURSOR';

package/dist/commands/CURSOR_READ.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
+function transformArguments(index, cursor) {
+    return [
+        'FT.CURSOR',
+        'READ',
+        index,
+        cursor.toString()
+    ];
+}
+exports.transformArguments = transformArguments;
+var AGGREGATE_WITHCURSOR_1 = require("./AGGREGATE_WITHCURSOR");
+Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return AGGREGATE_WITHCURSOR_1.transformReply; } });

package/dist/commands/INFO.d.ts

@@ -1,6 +1,6 @@
 import { RedisCommandArgument } from '@redis/client/dist/lib/commands';
 export declare function transformArguments(index: string): Array<string>;
-declare type InfoRawReply = [
+type InfoRawReply = [
     'index_name',
     RedisCommandArgument,
     'index_options',

package/dist/commands/PROFILE_AGGREGATE.d.ts

@@ -2,6 +2,6 @@ import { AggregateOptions, AggregateRawReply } from './AGGREGATE';
 import { ProfileOptions, ProfileRawReply, ProfileReply } from '.';
 export declare const IS_READ_ONLY = true;
 export declare function transformArguments(index: string, query: string, options?: ProfileOptions & AggregateOptions): Array<string>;
-declare type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>;
+type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>;
 export declare function transformReply(reply: ProfileAggeregateRawReply): ProfileReply;
 export {};

package/dist/commands/PROFILE_SEARCH.d.ts

@@ -3,6 +3,6 @@ import { ProfileOptions, ProfileRawReply, ProfileReply } from '.';
 import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
 export declare const IS_READ_ONLY = true;
 export declare function transformArguments(index: string, query: string, options?: ProfileOptions & SearchOptions): RedisCommandArguments;
-declare type ProfileSearchRawReply = ProfileRawReply<SearchRawReply>;
+type ProfileSearchRawReply = ProfileRawReply<SearchRawReply>;
 export declare function transformReply(reply: ProfileSearchRawReply): ProfileReply;
 export {};

package/dist/commands/SEARCH.d.ts

@@ -36,5 +36,5 @@ export interface SearchOptions {
     DIALECT?: number;
 }
 export declare function transformArguments(index: string, query: string, options?: SearchOptions): RedisCommandArguments;
-export declare type SearchRawReply = Array<any>;
+export type SearchRawReply = Array<any>;
 export declare function transformReply(reply: SearchRawReply): SearchReply;

package/dist/commands/SEARCH.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
 const _1 = require(".");
 exports.FIRST_KEY_INDEX = 1;
 exports.IS_READ_ONLY = true;
@@ -11,13 +10,11 @@ function transformArguments(index, query, options) {
 exports.transformArguments = transformArguments;
 function transformReply(reply) {
     const documents = [];
-    for (let i = 1; i < reply.length; i += 2) {
-        const tuples = reply[i + 1];
+    let i = 1;
+    while (i < reply.length) {
         documents.push({
-            id: reply[i],
-            value: tuples.length === 2 && tuples[0] === '$' ?
-                JSON.parse(tuples[1]) :
-                (0, generic_transformers_1.transformTuplesReply)(tuples)
+            id: reply[i++],
+            value: documentValue(reply[i++])
         });
     }
     return {
@@ -26,3 +23,23 @@ function transformReply(reply) {
     };
 }
 exports.transformReply = transformReply;
+function documentValue(tuples) {
+    const message = Object.create(null);
+    if (tuples === undefined)
+        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;
+}

package/dist/commands/SPELLCHECK.d.ts

@@ -8,12 +8,12 @@ interface SpellCheckOptions {
     DIALECT?: number;
 }
 export declare function transformArguments(index: string, query: string, options?: SpellCheckOptions): Array<string>;
-declare type SpellCheckRawReply = Array<[
+type SpellCheckRawReply = Array<[
     _: string,
     term: string,
     suggestions: Array<[score: string, suggestion: string]>
 ]>;
-declare type SpellCheckReply = Array<{
+type SpellCheckReply = Array<{
     term: string;
     suggestions: Array<{
         score: number;

package/dist/commands/SUGGET_WITHSCORES_WITHPAYLOADS.d.ts

@@ -3,5 +3,5 @@ import { SuggestionWithPayload } from './SUGGET_WITHPAYLOADS';
 import { SuggestionWithScores } from './SUGGET_WITHSCORES';
 export { IS_READ_ONLY } from './SUGGET';
 export declare function transformArguments(key: string, prefix: string, options?: SugGetOptions): Array<string>;
-declare type SuggestionWithScoresAndPayloads = SuggestionWithScores & SuggestionWithPayload;
+type SuggestionWithScoresAndPayloads = SuggestionWithScores & SuggestionWithPayload;
 export declare function transformReply(rawReply: Array<string | null> | null): Array<SuggestionWithScoresAndPayloads> | null;

package/dist/commands/index.d.ts

@@ -1,5 +1,6 @@
 import * as _LIST from './_LIST';
 import * as ALTER from './ALTER';
+import * as AGGREGATE_WITHCURSOR from './AGGREGATE_WITHCURSOR';
 import * as AGGREGATE from './AGGREGATE';
 import * as ALIASADD from './ALIASADD';
 import * as ALIASDEL from './ALIASDEL';
@@ -7,6 +8,8 @@ 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 CURSOR_DEL from './CURSOR_DEL';
+import * as CURSOR_READ from './CURSOR_READ';
 import * as DICTADD from './DICTADD';
 import * as DICTDEL from './DICTDEL';
 import * as DICTDUMP from './DICTDUMP';
@@ -35,6 +38,8 @@ declare const _default: {
     _list: typeof _LIST;
     ALTER: typeof ALTER;
     alter: typeof ALTER;
+    AGGREGATE_WITHCURSOR: typeof AGGREGATE_WITHCURSOR;
+    aggregateWithCursor: typeof AGGREGATE_WITHCURSOR;
     AGGREGATE: typeof AGGREGATE;
     aggregate: typeof AGGREGATE;
     ALIASADD: typeof ALIASADD;
@@ -49,6 +54,10 @@ declare const _default: {
     configSet: typeof CONFIG_SET;
     CREATE: typeof CREATE;
     create: typeof CREATE;
+    CURSOR_DEL: typeof CURSOR_DEL;
+    cursorDel: typeof CURSOR_DEL;
+    CURSOR_READ: typeof CURSOR_READ;
+    cursorRead: typeof CURSOR_READ;
     DICTADD: typeof DICTADD;
     dictAdd: typeof DICTADD;
     DICTDEL: typeof DICTDEL;
@@ -120,9 +129,9 @@ export declare enum RedisSearchLanguages {
     TURKISH = "Turkish",
     CHINESE = "Chinese"
 }
-export declare type PropertyName = `${'@' | '$.'}${string}`;
-export declare type SortByProperty = PropertyName | {
-    BY: PropertyName;
+export type PropertyName = `${'@' | '$.'}${string}`;
+export type SortByProperty = string | {
+    BY: string;
     DIRECTION?: 'ASC' | 'DESC';
 };
 export declare function pushSortByProperty(args: RedisCommandArguments, sortBy: SortByProperty): void;
@@ -135,11 +144,11 @@ export declare enum SchemaFieldTypes {
     TAG = "TAG",
     VECTOR = "VECTOR"
 }
-declare type CreateSchemaField<T extends SchemaFieldTypes, E = Record<keyof any, any>> = T | ({
+type CreateSchemaField<T extends SchemaFieldTypes, E = Record<PropertyKey, unknown>> = T | ({
     type: T;
     AS?: string;
 } & E);
-declare type CreateSchemaCommonField<T extends SchemaFieldTypes, E = Record<string, never>> = CreateSchemaField<T, ({
+type CreateSchemaCommonField<T extends SchemaFieldTypes, E = Record<PropertyKey, unknown>> = CreateSchemaField<T, ({
     SORTABLE?: true | 'UNF';
     NOINDEX?: true;
 } & E)>;
@@ -149,32 +158,34 @@ export declare enum SchemaTextFieldPhonetics {
     FM_PT = "dm:pt",
     DM_ES = "dm:es"
 }
-declare type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
+type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
     NOSTEM?: true;
     WEIGHT?: number;
     PHONETIC?: SchemaTextFieldPhonetics;
+    WITHSUFFIXTRIE?: boolean;
 }>;
-declare type CreateSchemaNumericField = CreateSchemaCommonField<SchemaFieldTypes.NUMERIC>;
-declare type CreateSchemaGeoField = CreateSchemaCommonField<SchemaFieldTypes.GEO>;
-declare type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
+type CreateSchemaNumericField = CreateSchemaCommonField<SchemaFieldTypes.NUMERIC>;
+type CreateSchemaGeoField = CreateSchemaCommonField<SchemaFieldTypes.GEO>;
+type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
     SEPARATOR?: string;
     CASESENSITIVE?: true;
+    WITHSUFFIXTRIE?: boolean;
 }>;
 export declare enum VectorAlgorithms {
     FLAT = "FLAT",
     HNSW = "HNSW"
 }
-declare type CreateSchemaVectorField<T extends VectorAlgorithms, A extends Record<string, unknown>> = CreateSchemaField<SchemaFieldTypes.VECTOR, {
+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, {
+type CreateSchemaFlatVectorField = CreateSchemaVectorField<VectorAlgorithms.FLAT, {
     BLOCK_SIZE?: number;
 }>;
-declare type CreateSchemaHNSWVectorField = CreateSchemaVectorField<VectorAlgorithms.HNSW, {
+type CreateSchemaHNSWVectorField = CreateSchemaVectorField<VectorAlgorithms.HNSW, {
     M?: number;
     EF_CONSTRUCTION?: number;
     EF_RUNTIME?: number;
@@ -183,7 +194,7 @@ 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 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 {
@@ -199,7 +210,7 @@ export interface SearchReply {
 export interface ProfileOptions {
     LIMITED?: true;
 }
-export declare type ProfileRawReply<T> = [
+export type ProfileRawReply<T> = [
     results: T,
     profile: [
         _: string,

package/dist/commands/index.js

@@ -3,6 +3,7 @@ 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_WITHCURSOR = require("./AGGREGATE_WITHCURSOR");
 const AGGREGATE = require("./AGGREGATE");
 const ALIASADD = require("./ALIASADD");
 const ALIASDEL = require("./ALIASDEL");
@@ -10,6 +11,8 @@ const ALIASUPDATE = require("./ALIASUPDATE");
 const CONFIG_GET = require("./CONFIG_GET");
 const CONFIG_SET = require("./CONFIG_SET");
 const CREATE = require("./CREATE");
+const CURSOR_DEL = require("./CURSOR_DEL");
+const CURSOR_READ = require("./CURSOR_READ");
 const DICTADD = require("./DICTADD");
 const DICTDEL = require("./DICTDEL");
 const DICTDUMP = require("./DICTDUMP");
@@ -37,6 +40,8 @@ exports.default = {
     _list: _LIST,
     ALTER,
     alter: ALTER,
+    AGGREGATE_WITHCURSOR,
+    aggregateWithCursor: AGGREGATE_WITHCURSOR,
     AGGREGATE,
     aggregate: AGGREGATE,
     ALIASADD,
@@ -51,6 +56,10 @@ exports.default = {
     configSet: CONFIG_SET,
     CREATE,
     create: CREATE,
+    CURSOR_DEL,
+    cursorDel: CURSOR_DEL,
+    CURSOR_READ,
+    cursorRead: CURSOR_READ,
     DICTADD,
     dictAdd: DICTADD,
     DICTDEL,
@@ -198,6 +207,9 @@ function pushSchema(args, schema) {
                 if (fieldOptions.PHONETIC) {
                     args.push('PHONETIC', fieldOptions.PHONETIC);
                 }
+                if (fieldOptions.WITHSUFFIXTRIE) {
+                    args.push('WITHSUFFIXTRIE');
+                }
                 break;
             // case SchemaFieldTypes.NUMERIC:
             // case SchemaFieldTypes.GEO:
@@ -209,6 +221,9 @@ function pushSchema(args, schema) {
                 if (fieldOptions.CASESENSITIVE) {
                     args.push('CASESENSITIVE');
                 }
+                if (fieldOptions.WITHSUFFIXTRIE) {
+                    args.push('WITHSUFFIXTRIE');
+                }
                 break;
             case SchemaFieldTypes.VECTOR:
                 args.push(fieldOptions.ALGORITHM);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redis/search",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -18,12 +18,12 @@
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@redis/test-utils": "*",
-    "@types/node": "^17.0.31",
+    "@types/node": "^18.11.18",
     "nyc": "^15.1.0",
-    "release-it": "^15.0.0",
+    "release-it": "^15.6.0",
     "source-map-support": "^0.5.21",
-    "ts-node": "^10.7.0",
-    "typedoc": "^0.22.15",
-    "typescript": "^4.6.4"
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.23.24",
+    "typescript": "^4.9.4"
   }
 }