redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-09 00:22:08 +03:00
Code Activity

FT.CREATE

Browse Source
This commit is contained in:
Leibale
2023-07-27 12:58:07 -04:00
parent bfe5a8c881
commit 7ce9e9bf25
3 changed files with 1194 additions and 957 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
packages/search/lib/commands/CREATE.spec.ts
View File

@@ -1,13 +1,12 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CREATE';
import { SchemaFieldTypes, SchemaTextFieldPhonetics, RedisSearchLanguages, VectorAlgorithms } from '.';
import CREATE, { SCHEMA_FIELD_TYPE, SCHEMA_TEXT_FIELD_PHONETIC, SCHEMA_VECTOR_FIELD_ALGORITHM, REDISEARCH_LANGUAGE } from './CREATE';
describe('CREATE', () => {
describe.only('FT.CREATE', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('index', {}),
CREATE.transformArguments('index', {}),
['FT.CREATE', 'index', 'SCHEMA']
);
});
@@ -16,8 +15,8 @@ describe('CREATE', () => {
describe('TEXT', () => {
it('without options', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.TEXT
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.TEXT
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT']
);
@@ -25,9 +24,9 @@ describe('CREATE', () => {
it('with NOSTEM', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
NOSTEM: true
}
}),
@@ -37,9 +36,9 @@ describe('CREATE', () => {
it('with WEIGHT', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
WEIGHT: 1
}
}),
@@ -49,21 +48,21 @@ describe('CREATE', () => {
it('with PHONETIC', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
PHONETIC: SchemaTextFieldPhonetics.DM_EN
type: SCHEMA_FIELD_TYPE.TEXT,
PHONETIC: SCHEMA_TEXT_FIELD_PHONETIC.DM_EN
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'PHONETIC', SchemaTextFieldPhonetics.DM_EN]
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'PHONETIC', SCHEMA_TEXT_FIELD_PHONETIC.DM_EN]
);
});
it('with WITHSUFFIXTRIE', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
WITHSUFFIXTRIE: true
}
}),
@@ -74,8 +73,8 @@ describe('CREATE', () => {
it('NUMERIC', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.NUMERIC
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.NUMERIC
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'NUMERIC']
);
@@ -83,8 +82,8 @@ describe('CREATE', () => {
it('GEO', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.GEO
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.GEO
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'GEO']
);
@@ -92,20 +91,20 @@ describe('CREATE', () => {
describe('TAG', () => {
describe('without options', () => {
it('SchemaFieldTypes.TAG', () => {
it('SCHEMA_FIELD_TYPE.TAG', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.TAG
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.TAG
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
);
});
it('{ type: SchemaFieldTypes.TAG }', () => {
it('{ type: SCHEMA_FIELD_TYPE.TAG }', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG
type: SCHEMA_FIELD_TYPE.TAG
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
@@ -115,9 +114,9 @@ describe('CREATE', () => {
it('with SEPARATOR', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG,
type: SCHEMA_FIELD_TYPE.TAG,
SEPARATOR: 'separator'
}
}),
@@ -127,9 +126,9 @@ describe('CREATE', () => {
it('with CASESENSITIVE', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG,
type: SCHEMA_FIELD_TYPE.TAG,
CASESENSITIVE: true
}
}),
@@ -139,9 +138,9 @@ describe('CREATE', () => {
it('with WITHSUFFIXTRIE', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG,
type: SCHEMA_FIELD_TYPE.TAG,
WITHSUFFIXTRIE: true
}
}),
@@ -153,10 +152,10 @@ describe('CREATE', () => {
describe('VECTOR', () => {
it('Flat algorithm', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.VECTOR,
ALGORITHM: VectorAlgorithms.FLAT,
type: SCHEMA_FIELD_TYPE.VECTOR,
ALGORITHM: SCHEMA_VECTOR_FIELD_ALGORITHM.FLAT,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
@@ -174,10 +173,10 @@ describe('CREATE', () => {
it('HNSW algorithm', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.VECTOR,
ALGORITHM: VectorAlgorithms.HNSW,
type: SCHEMA_FIELD_TYPE.VECTOR,
ALGORITHM: SCHEMA_VECTOR_FIELD_ALGORITHM.HNSW,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
@@ -196,12 +195,11 @@ describe('CREATE', () => {
});
});
describe('with generic options', () => {
it('with AS', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
AS: 'as'
}
}),
@@ -212,9 +210,9 @@ describe('CREATE', () => {
describe('with SORTABLE', () => {
it('true', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
SORTABLE: true
}
}),
@@ -224,9 +222,9 @@ describe('CREATE', () => {
it('UNF', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
SORTABLE: 'UNF'
}
}),
@@ -237,9 +235,9 @@ describe('CREATE', () => {
it('with NOINDEX', () => {
assert.deepEqual(
transformArguments('index', {
CREATE.transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
type: SCHEMA_FIELD_TYPE.TEXT,
NOINDEX: true
}
}),
@@ -247,11 +245,10 @@ describe('CREATE', () => {
);
});
});
});
it('with ON', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
ON: 'HASH'
}),
['FT.CREATE', 'index', 'ON', 'HASH', 'SCHEMA']
@@ -261,7 +258,7 @@ describe('CREATE', () => {
describe('with PREFIX', () => {
it('string', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
PREFIX: 'prefix'
}),
['FT.CREATE', 'index', 'PREFIX', '1', 'prefix', 'SCHEMA']
@@ -270,7 +267,7 @@ describe('CREATE', () => {
it('Array', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
PREFIX: ['1', '2']
}),
['FT.CREATE', 'index', 'PREFIX', '2', '1', '2', 'SCHEMA']
@@ -280,7 +277,7 @@ describe('CREATE', () => {
it('with FILTER', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
FILTER: '@field != ""'
}),
['FT.CREATE', 'index', 'FILTER', '@field != ""', 'SCHEMA']
@@ -289,16 +286,16 @@ describe('CREATE', () => {
it('with LANGUAGE', () => {
assert.deepEqual(
transformArguments('index', {}, {
LANGUAGE: RedisSearchLanguages.ARABIC
CREATE.transformArguments('index', {}, {
LANGUAGE: REDISEARCH_LANGUAGE.ARABIC
}),
['FT.CREATE', 'index', 'LANGUAGE', RedisSearchLanguages.ARABIC, 'SCHEMA']
['FT.CREATE', 'index', 'LANGUAGE', REDISEARCH_LANGUAGE.ARABIC, 'SCHEMA']
);
});
it('with LANGUAGE_FIELD', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
LANGUAGE_FIELD: '@field'
}),
['FT.CREATE', 'index', 'LANGUAGE_FIELD', '@field', 'SCHEMA']
@@ -307,7 +304,7 @@ describe('CREATE', () => {
it('with SCORE', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
SCORE: 1
}),
['FT.CREATE', 'index', 'SCORE', '1', 'SCHEMA']
@@ -316,7 +313,7 @@ describe('CREATE', () => {
it('with SCORE_FIELD', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
SCORE_FIELD: '@field'
}),
['FT.CREATE', 'index', 'SCORE_FIELD', '@field', 'SCHEMA']
@@ -325,7 +322,7 @@ describe('CREATE', () => {
it('with MAXTEXTFIELDS', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
MAXTEXTFIELDS: true
}),
['FT.CREATE', 'index', 'MAXTEXTFIELDS', 'SCHEMA']
@@ -334,7 +331,7 @@ describe('CREATE', () => {
it('with TEMPORARY', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
TEMPORARY: 1
}),
['FT.CREATE', 'index', 'TEMPORARY', '1', 'SCHEMA']
@@ -343,7 +340,7 @@ describe('CREATE', () => {
it('with NOOFFSETS', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
NOOFFSETS: true
}),
['FT.CREATE', 'index', 'NOOFFSETS', 'SCHEMA']
@@ -352,7 +349,7 @@ describe('CREATE', () => {
it('with NOHL', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
NOHL: true
}),
['FT.CREATE', 'index', 'NOHL', 'SCHEMA']
@@ -361,7 +358,7 @@ describe('CREATE', () => {
it('with NOFIELDS', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
NOFIELDS: true
}),
['FT.CREATE', 'index', 'NOFIELDS', 'SCHEMA']
@@ -370,7 +367,7 @@ describe('CREATE', () => {
it('with NOFREQS', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
NOFREQS: true
}),
['FT.CREATE', 'index', 'NOFREQS', 'SCHEMA']
@@ -379,7 +376,7 @@ describe('CREATE', () => {
it('with SKIPINITIALSCAN', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
SKIPINITIALSCAN: true
}),
['FT.CREATE', 'index', 'SKIPINITIALSCAN', 'SCHEMA']
@@ -389,7 +386,7 @@ describe('CREATE', () => {
describe('with STOPWORDS', () => {
it('string', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
STOPWORDS: 'stopword'
}),
['FT.CREATE', 'index', 'STOPWORDS', '1', 'stopword', 'SCHEMA']
@@ -398,7 +395,7 @@ describe('CREATE', () => {
it('Array', () => {
assert.deepEqual(
transformArguments('index', {}, {
CREATE.transformArguments('index', {}, {
STOPWORDS: ['1', '2']
}),
['FT.CREATE', 'index', 'STOPWORDS', '2', '1', '2', 'SCHEMA']
@@ -410,7 +407,7 @@ describe('CREATE', () => {
testUtils.testWithClient('client.ft.create', async client => {
assert.equal(
await client.ft.create('index', {
field: SchemaFieldTypes.TEXT
field: SCHEMA_FIELD_TYPE.TEXT
}),
'OK'
);

273
packages/search/lib/commands/CREATE.ts
View File

@@ -1,26 +1,265 @@
import { pushOptionalVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
import { RedisSearchLanguages, PropertyName, RediSearchSchema, pushSchema } from '.';
import { RedisArgument, SimpleStringReply, Command, CommandArguments } from '@redis/client/dist/lib/RESP/types';
import { RedisVariadicArgument, pushOptionalVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
import { PropertyName } from '.';
interface CreateOptions {
export const SCHEMA_FIELD_TYPE = {
TEXT: 'TEXT',
NUMERIC: 'NUMERIC',
GEO: 'GEO',
TAG: 'TAG',
VECTOR: 'VECTOR'
} as const;
export type SchemaFieldType = typeof SCHEMA_FIELD_TYPE[keyof typeof SCHEMA_FIELD_TYPE];
type SchemaField<
T extends SchemaFieldType,
E = Record<PropertyKey, unknown>
> = T | ({
type: T;
AS?: RedisArgument;
} & E);
type SchemaCommonField<
T extends SchemaFieldType,
E = Record<PropertyKey, unknown>
> = SchemaField<
T,
({
SORTABLE?: boolean | 'UNF';
NOINDEX?: boolean;
} & E)
>;
export const SCHEMA_TEXT_FIELD_PHONETIC = {
DM_EN: 'dm:en',
DM_FR: 'dm:fr',
FM_PT: 'dm:pt',
DM_ES: 'dm:es'
} as const;
export type SchemaTextFieldPhonetic = typeof SCHEMA_TEXT_FIELD_PHONETIC[keyof typeof SCHEMA_TEXT_FIELD_PHONETIC];
type SchemaTextField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['TEXT'], {
NOSTEM?: boolean;
WEIGHT?: number;
PHONETIC?: SchemaTextFieldPhonetic;
WITHSUFFIXTRIE?: boolean;
}>;
type SchemaNumericField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['NUMERIC']>;
type SchemaGeoField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['GEO']>;
type SchemaTagField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['TAG'], {
SEPARATOR?: RedisArgument;
CASESENSITIVE?: boolean;
WITHSUFFIXTRIE?: boolean;
}>;
export const SCHEMA_VECTOR_FIELD_ALGORITHM = {
FLAT: 'FLAT',
HNSW: 'HNSW'
} as const;
export type SchemaVectorFieldAlgorithm = typeof SCHEMA_VECTOR_FIELD_ALGORITHM[keyof typeof SCHEMA_VECTOR_FIELD_ALGORITHM];
type SchemaVectorField<
T extends SchemaVectorFieldAlgorithm,
A extends Record<string, unknown>
> = SchemaField<typeof SCHEMA_FIELD_TYPE['VECTOR'], {
ALGORITHM: T;
TYPE: string;
DIM: number;
DISTANCE_METRIC: 'L2' | 'IP' | 'COSINE';
INITIAL_CAP?: number;
} & A>;
type SchemaFlatVectorField = SchemaVectorField<typeof SCHEMA_VECTOR_FIELD_ALGORITHM['FLAT'], {
BLOCK_SIZE?: number;
}>;
type SchemaHNSWVectorField = SchemaVectorField<typeof SCHEMA_VECTOR_FIELD_ALGORITHM['HNSW'], {
M?: number;
EF_CONSTRUCTION?: number;
EF_RUNTIME?: number;
}>;
export interface RediSearchSchema {
[field: string]:(
SchemaTextField |
SchemaNumericField |
SchemaGeoField |
SchemaTagField |
SchemaFlatVectorField |
SchemaHNSWVectorField
);
}
export function pushSchema(args: CommandArguments, schema: RediSearchSchema) {
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 SCHEMA_FIELD_TYPE.TEXT:
if (fieldOptions.NOSTEM) {
args.push('NOSTEM');
}
if (fieldOptions.WEIGHT) {
args.push('WEIGHT', fieldOptions.WEIGHT.toString());
}
if (fieldOptions.PHONETIC) {
args.push('PHONETIC', fieldOptions.PHONETIC);
}
if (fieldOptions.WITHSUFFIXTRIE) {
args.push('WITHSUFFIXTRIE');
}
break;
// case SchemaFieldTypes.NUMERIC:
// case SchemaFieldTypes.GEO:
// break;
case SCHEMA_FIELD_TYPE.TAG:
if (fieldOptions.SEPARATOR) {
args.push('SEPARATOR', fieldOptions.SEPARATOR);
}
if (fieldOptions.CASESENSITIVE) {
args.push('CASESENSITIVE');
}
if (fieldOptions.WITHSUFFIXTRIE) {
args.push('WITHSUFFIXTRIE');
}
break;
case SCHEMA_FIELD_TYPE.VECTOR:
args.push(fieldOptions.ALGORITHM);
const lengthIndex = args.push('') - 1;
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 SCHEMA_VECTOR_FIELD_ALGORITHM.FLAT:
if (fieldOptions.BLOCK_SIZE) {
args.push('BLOCK_SIZE', fieldOptions.BLOCK_SIZE.toString());
}
break;
case SCHEMA_VECTOR_FIELD_ALGORITHM.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;
}
args[lengthIndex] = (args.length - lengthIndex - 1).toString();
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');
}
}
}
export const REDISEARCH_LANGUAGE = {
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'
} as const;
export type RediSearchLanguage = typeof REDISEARCH_LANGUAGE[keyof typeof REDISEARCH_LANGUAGE];
export interface CreateOptions {
ON?: 'HASH' | 'JSON';
PREFIX?: string | Array<string>;
FILTER?: string;
LANGUAGE?: RedisSearchLanguages;
PREFIX?: RedisVariadicArgument;
FILTER?: RedisArgument;
LANGUAGE?: RediSearchLanguage;
LANGUAGE_FIELD?: PropertyName;
SCORE?: number;
SCORE_FIELD?: PropertyName;
// PAYLOAD_FIELD?: string;
MAXTEXTFIELDS?: true;
MAXTEXTFIELDS?: boolean;
TEMPORARY?: number;
NOOFFSETS?: true;
NOHL?: true;
NOFIELDS?: true;
NOFREQS?: true;
SKIPINITIALSCAN?: true;
STOPWORDS?: string | Array<string>;
NOOFFSETS?: boolean;
NOHL?: boolean;
NOFIELDS?: boolean;
NOFREQS?: boolean;
SKIPINITIALSCAN?: boolean;
STOPWORDS?: RedisVariadicArgument;
}
export function transformArguments(index: string, schema: RediSearchSchema, options?: CreateOptions): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(index: RedisArgument, schema: RediSearchSchema, options?: CreateOptions) {
const args = ['FT.CREATE', index];
if (options?.ON) {
@@ -86,6 +325,6 @@ export function transformArguments(index: string, schema: RediSearchSchema, opti
pushSchema(args, schema);
return args;
}
export declare function transformReply(): 'OK';
},
transformReply: undefined as unknown as () => SimpleStringReply<'OK'>
} as const satisfies Command;

539
packages/search/lib/commands/index.ts
View File

@@ -1,65 +1,66 @@
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';
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';
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 _LIST from './_LIST';
// import ALTER from './ALTER';
// import AGGREGATE_WITHCURSOR from './AGGREGATE_WITHCURSOR';
// import AGGREGATE from './AGGREGATE';
// import ALIASADD from './ALIASADD';
// import ALIASDEL from './ALIASDEL';
// import ALIASUPDATE from './ALIASUPDATE';
// import CONFIG_GET from './CONFIG_GET';
// import CONFIG_SET from './CONFIG_SET';
import CREATE from './CREATE';
// import CURSOR_DEL from './CURSOR_DEL';
// import CURSOR_READ from './CURSOR_READ';
import DICTADD from './DICTADD';
import DICTDEL from './DICTDEL';
import DICTDUMP from './DICTDUMP';
import DROPINDEX from './DROPINDEX';
import EXPLAIN from './EXPLAIN';
import EXPLAINCLI from './EXPLAINCLI';
// import INFO from './INFO';
// import PROFILESEARCH from './PROFILE_SEARCH';
// import PROFILEAGGREGATE from './PROFILE_AGGREGATE';
// import SEARCH from './SEARCH';
// import SPELLCHECK from './SPELLCHECK';
import SUGADD from './SUGADD';
import SUGDEL from './SUGDEL';
// import SUGGET_WITHPAYLOADS from './SUGGET_WITHPAYLOADS';
// import SUGGET_WITHSCORES_WITHPAYLOADS from './SUGGET_WITHSCORES_WITHPAYLOADS';
// import SUGGET_WITHSCORES from './SUGGET_WITHSCORES';
// import SUGGET from './SUGGET';
import SUGLEN from './SUGLEN';
// import SYNDUMP from './SYNDUMP';
// import SYNUPDATE from './SYNUPDATE';
import TAGVALS from './TAGVALS';
// import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
import { pushOptionalVariadicArgument, pushVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
import { SearchOptions } from './SEARCH';
import { CommandArguments } from '@redis/client/dist/lib/RESP/types';
export default {
_LIST,
_list: _LIST,
ALTER,
alter: ALTER,
AGGREGATE_WITHCURSOR,
aggregateWithCursor: AGGREGATE_WITHCURSOR,
AGGREGATE,
aggregate: AGGREGATE,
ALIASADD,
aliasAdd: ALIASADD,
ALIASDEL,
aliasDel: ALIASDEL,
ALIASUPDATE,
aliasUpdate: ALIASUPDATE,
CONFIG_GET,
configGet: CONFIG_GET,
CONFIG_SET,
configSet: CONFIG_SET,
// ALTER,
// alter: ALTER,
// AGGREGATE_WITHCURSOR,
// aggregateWithCursor: AGGREGATE_WITHCURSOR,
// 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,
CURSOR_DEL,
cursorDel: CURSOR_DEL,
CURSOR_READ,
cursorRead: CURSOR_READ,
// CURSOR_DEL,
// cursorDel: CURSOR_DEL,
// CURSOR_READ,
// cursorRead: CURSOR_READ,
DICTADD,
dictAdd: DICTADD,
DICTDEL,
@@ -72,65 +73,65 @@ export default {
explain: EXPLAIN,
EXPLAINCLI,
explainCli: EXPLAINCLI,
INFO,
info: INFO,
PROFILESEARCH,
profileSearch: PROFILESEARCH,
PROFILEAGGREGATE,
profileAggregate: PROFILEAGGREGATE,
SEARCH,
search: SEARCH,
SPELLCHECK,
spellCheck: SPELLCHECK,
// 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,
// 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,
// SYNDUMP,
// synDump: SYNDUMP,
// SYNUPDATE,
// synUpdate: SYNUPDATE,
TAGVALS,
tagVals: TAGVALS
};
export 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 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 type PropertyName = `${'@' | '$.'}${string}`;
@@ -170,209 +171,209 @@ export function pushSortByArguments(args: RedisCommandArguments, name: string, s
return args;
}
export function pushArgumentsWithLength(args: RedisCommandArguments, fn: (args: RedisCommandArguments) => void): RedisCommandArguments {
const lengthIndex = args.push('') - 1;
fn(args);
args[lengthIndex] = (args.length - lengthIndex - 1).toString();
return args;
}
// export function pushArgumentsWithLength(args: CommandArguments, fn: (args: CommandArguments) => void) {
// const lengthIndex = args.push('') - 1;
// fn(args);
// args[lengthIndex] = (args.length - lengthIndex - 1).toString();
// return args;
// }
export enum SchemaFieldTypes {
TEXT = 'TEXT',
NUMERIC = 'NUMERIC',
GEO = 'GEO',
TAG = 'TAG',
VECTOR = 'VECTOR'
}
// export enum SchemaFieldTypes {
// TEXT = 'TEXT',
// NUMERIC = 'NUMERIC',
// GEO = 'GEO',
// TAG = 'TAG',
// VECTOR = 'VECTOR'
// }
type CreateSchemaField<
T extends SchemaFieldTypes,
E = Record<PropertyKey, unknown>
> = T | ({
type: T;
AS?: string;
} & E);
// type CreateSchemaField<
// T extends SchemaFieldTypes,
// E = Record<PropertyKey, unknown>
// > = T | ({
// type: T;
// AS?: string;
// } & E);
type CreateSchemaCommonField<
T extends SchemaFieldTypes,
E = Record<PropertyKey, unknown>
> = CreateSchemaField<
T,
({
SORTABLE?: true | 'UNF';
NOINDEX?: true;
} & E)
>;
// type CreateSchemaCommonField<
// T extends SchemaFieldTypes,
// E = Record<PropertyKey, unknown>
// > = CreateSchemaField<
// T,
// ({
// SORTABLE?: true | 'UNF';
// NOINDEX?: true;
// } & E)
// >;
export enum SchemaTextFieldPhonetics {
DM_EN = 'dm:en',
DM_FR = 'dm:fr',
FM_PT = 'dm:pt',
DM_ES = 'dm:es'
}
// export enum SchemaTextFieldPhonetics {
// DM_EN = 'dm:en',
// DM_FR = 'dm:fr',
// FM_PT = 'dm:pt',
// DM_ES = 'dm:es'
// }
type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
NOSTEM?: true;
WEIGHT?: number;
PHONETIC?: SchemaTextFieldPhonetics;
WITHSUFFIXTRIE?: boolean;
}>;
// type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
// NOSTEM?: true;
// WEIGHT?: number;
// PHONETIC?: SchemaTextFieldPhonetics;
// WITHSUFFIXTRIE?: boolean;
// }>;
type CreateSchemaNumericField = CreateSchemaCommonField<SchemaFieldTypes.NUMERIC>;
// type CreateSchemaNumericField = CreateSchemaCommonField<SchemaFieldTypes.NUMERIC>;
type CreateSchemaGeoField = CreateSchemaCommonField<SchemaFieldTypes.GEO>;
// type CreateSchemaGeoField = CreateSchemaCommonField<SchemaFieldTypes.GEO>;
type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
SEPARATOR?: string;
CASESENSITIVE?: true;
WITHSUFFIXTRIE?: boolean;
}>;
// type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
// SEPARATOR?: string;
// CASESENSITIVE?: true;
// WITHSUFFIXTRIE?: boolean;
// }>;
export enum VectorAlgorithms {
FLAT = 'FLAT',
HNSW = 'HNSW'
}
// export enum VectorAlgorithms {
// FLAT = 'FLAT',
// HNSW = 'HNSW'
// }
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>;
// 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>;
type CreateSchemaFlatVectorField = CreateSchemaVectorField<VectorAlgorithms.FLAT, {
BLOCK_SIZE?: number;
}>;
// type CreateSchemaFlatVectorField = CreateSchemaVectorField<VectorAlgorithms.FLAT, {
// BLOCK_SIZE?: number;
// }>;
type CreateSchemaHNSWVectorField = CreateSchemaVectorField<VectorAlgorithms.HNSW, {
M?: number;
EF_CONSTRUCTION?: number;
EF_RUNTIME?: number;
}>;
// 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 interface RediSearchSchema {
// [field: string]:
// CreateSchemaTextField |
// CreateSchemaNumericField |
// CreateSchemaGeoField |
// CreateSchemaTagField |
// CreateSchemaFlatVectorField |
// CreateSchemaHNSWVectorField;
// }
export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema) {
for (const [field, fieldOptions] of Object.entries(schema)) {
args.push(field);
// export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema) {
// for (const [field, fieldOptions] of Object.entries(schema)) {
// args.push(field);
if (typeof fieldOptions === 'string') {
args.push(fieldOptions);
continue;
}
// if (typeof fieldOptions === 'string') {
// args.push(fieldOptions);
// continue;
// }
if (fieldOptions.AS) {
args.push('AS', fieldOptions.AS);
}
// if (fieldOptions.AS) {
// args.push('AS', fieldOptions.AS);
// }
args.push(fieldOptions.type);
// args.push(fieldOptions.type);
switch (fieldOptions.type) {
case SchemaFieldTypes.TEXT:
if (fieldOptions.NOSTEM) {
args.push('NOSTEM');
}
// switch (fieldOptions.type) {
// case SchemaFieldTypes.TEXT:
// if (fieldOptions.NOSTEM) {
// args.push('NOSTEM');
// }
if (fieldOptions.WEIGHT) {
args.push('WEIGHT', fieldOptions.WEIGHT.toString());
}
// if (fieldOptions.WEIGHT) {
// args.push('WEIGHT', fieldOptions.WEIGHT.toString());
// }
if (fieldOptions.PHONETIC) {
args.push('PHONETIC', fieldOptions.PHONETIC);
}
// if (fieldOptions.PHONETIC) {
// args.push('PHONETIC', fieldOptions.PHONETIC);
// }
if (fieldOptions.WITHSUFFIXTRIE) {
args.push('WITHSUFFIXTRIE');
}
// if (fieldOptions.WITHSUFFIXTRIE) {
// args.push('WITHSUFFIXTRIE');
// }
break;
// break;
// case SchemaFieldTypes.NUMERIC:
// case SchemaFieldTypes.GEO:
// break;
// // case SchemaFieldTypes.NUMERIC:
// // case SchemaFieldTypes.GEO:
// // break;
case SchemaFieldTypes.TAG:
if (fieldOptions.SEPARATOR) {
args.push('SEPARATOR', fieldOptions.SEPARATOR);
}
// case SchemaFieldTypes.TAG:
// if (fieldOptions.SEPARATOR) {
// args.push('SEPARATOR', fieldOptions.SEPARATOR);
// }
if (fieldOptions.CASESENSITIVE) {
args.push('CASESENSITIVE');
}
// if (fieldOptions.CASESENSITIVE) {
// args.push('CASESENSITIVE');
// }
if (fieldOptions.WITHSUFFIXTRIE) {
args.push('WITHSUFFIXTRIE');
}
// if (fieldOptions.WITHSUFFIXTRIE) {
// args.push('WITHSUFFIXTRIE');
// }
break;
// break;
case SchemaFieldTypes.VECTOR:
args.push(fieldOptions.ALGORITHM);
// case SchemaFieldTypes.VECTOR:
// args.push(fieldOptions.ALGORITHM);
pushArgumentsWithLength(args, () => {
args.push(
'TYPE', fieldOptions.TYPE,
'DIM', fieldOptions.DIM.toString(),
'DISTANCE_METRIC', fieldOptions.DISTANCE_METRIC
);
// 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());
}
// 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());
}
// switch (fieldOptions.ALGORITHM) {
// case VectorAlgorithms.FLAT:
// if (fieldOptions.BLOCK_SIZE) {
// args.push('BLOCK_SIZE', fieldOptions.BLOCK_SIZE.toString());
// }
break;
// break;
case VectorAlgorithms.HNSW:
if (fieldOptions.M) {
args.push('M', fieldOptions.M.toString());
}
// 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_CONSTRUCTION) {
// args.push('EF_CONSTRUCTION', fieldOptions.EF_CONSTRUCTION.toString());
// }
if (fieldOptions.EF_RUNTIME) {
args.push('EF_RUNTIME', fieldOptions.EF_RUNTIME.toString());
}
// if (fieldOptions.EF_RUNTIME) {
// args.push('EF_RUNTIME', fieldOptions.EF_RUNTIME.toString());
// }
break;
}
});
// break;
// }
// });
continue; // vector fields do not contain SORTABLE and NOINDEX options
}
// continue; // vector fields do not contain SORTABLE and NOINDEX options
// }
if (fieldOptions.SORTABLE) {
args.push('SORTABLE');
// if (fieldOptions.SORTABLE) {
// args.push('SORTABLE');
if (fieldOptions.SORTABLE === 'UNF') {
args.push('UNF');
}
}
// if (fieldOptions.SORTABLE === 'UNF') {
// args.push('UNF');
// }
// }
if (fieldOptions.NOINDEX) {
args.push('NOINDEX');
}
}
}
// if (fieldOptions.NOINDEX) {
// args.push('NOINDEX');
// }
// }
// }
export type Params = Record<string, RedisCommandArgument | number>;
@@ -576,7 +577,7 @@ interface ProfileData {
iteratorsProfile: IteratorsProfile
}
export function transformProfile(reply: Array<any>): ProfileData{
export function transformProfile(reply: Array<any>): ProfileData {
return {
totalProfileTime: reply[0][1],
parsingTime: reply[1][1],
@@ -588,7 +589,7 @@ export function transformProfile(reply: Array<any>): ProfileData{
function transformIterators(IteratorsProfile: Array<any>): IteratorsProfile {
var res: IteratorsProfile = {};
for (let i = 0; i < IteratorsProfile.length; i += 2) {
const value = IteratorsProfile[i+1];
const value = IteratorsProfile[i + 1];
switch (IteratorsProfile[i]) {
case 'Type':
res.type = value;
@@ -614,7 +615,7 @@ function transformIterators(IteratorsProfile: Array<any>): IteratorsProfile {
function transformChildIterators(IteratorsProfile: Array<any>): ChildIterator {
var res: ChildIterator = {};
for (let i = 1; i < IteratorsProfile.length; i += 2) {
const value = IteratorsProfile[i+1];
const value = IteratorsProfile[i + 1];
switch (IteratorsProfile[i]) {
case 'Type':
res.type = value;