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

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

@@ -1,65 +1,66 @@
import * as _LIST from './_LIST'; import _LIST from './_LIST';
import * as ALTER from './ALTER'; // import ALTER from './ALTER';
import * as AGGREGATE_WITHCURSOR from './AGGREGATE_WITHCURSOR'; // import AGGREGATE_WITHCURSOR from './AGGREGATE_WITHCURSOR';
import * as AGGREGATE from './AGGREGATE'; // import AGGREGATE from './AGGREGATE';
import * as ALIASADD from './ALIASADD'; // import ALIASADD from './ALIASADD';
import * as ALIASDEL from './ALIASDEL'; // import ALIASDEL from './ALIASDEL';
import * as ALIASUPDATE from './ALIASUPDATE'; // import ALIASUPDATE from './ALIASUPDATE';
import * as CONFIG_GET from './CONFIG_GET'; // import CONFIG_GET from './CONFIG_GET';
import * as CONFIG_SET from './CONFIG_SET'; // import CONFIG_SET from './CONFIG_SET';
import * as CREATE from './CREATE'; import CREATE from './CREATE';
import * as CURSOR_DEL from './CURSOR_DEL'; // import CURSOR_DEL from './CURSOR_DEL';
import * as CURSOR_READ from './CURSOR_READ'; // import CURSOR_READ from './CURSOR_READ';
import * as DICTADD from './DICTADD'; import DICTADD from './DICTADD';
import * as DICTDEL from './DICTDEL'; import DICTDEL from './DICTDEL';
import * as DICTDUMP from './DICTDUMP'; import DICTDUMP from './DICTDUMP';
import * as DROPINDEX from './DROPINDEX'; import DROPINDEX from './DROPINDEX';
import * as EXPLAIN from './EXPLAIN'; import EXPLAIN from './EXPLAIN';
import * as EXPLAINCLI from './EXPLAINCLI'; import EXPLAINCLI from './EXPLAINCLI';
import * as INFO from './INFO'; // import INFO from './INFO';
import * as PROFILESEARCH from './PROFILE_SEARCH'; // import PROFILESEARCH from './PROFILE_SEARCH';
import * as PROFILEAGGREGATE from './PROFILE_AGGREGATE'; // import PROFILEAGGREGATE from './PROFILE_AGGREGATE';
import * as SEARCH from './SEARCH'; // import SEARCH from './SEARCH';
import * as SPELLCHECK from './SPELLCHECK'; // import SPELLCHECK from './SPELLCHECK';
import * as SUGADD from './SUGADD'; import SUGADD from './SUGADD';
import * as SUGDEL from './SUGDEL'; import SUGDEL from './SUGDEL';
import * as SUGGET_WITHPAYLOADS from './SUGGET_WITHPAYLOADS'; // import SUGGET_WITHPAYLOADS from './SUGGET_WITHPAYLOADS';
import * as SUGGET_WITHSCORES_WITHPAYLOADS from './SUGGET_WITHSCORES_WITHPAYLOADS'; // import SUGGET_WITHSCORES_WITHPAYLOADS from './SUGGET_WITHSCORES_WITHPAYLOADS';
import * as SUGGET_WITHSCORES from './SUGGET_WITHSCORES'; // import SUGGET_WITHSCORES from './SUGGET_WITHSCORES';
import * as SUGGET from './SUGGET'; // import SUGGET from './SUGGET';
import * as SUGLEN from './SUGLEN'; import SUGLEN from './SUGLEN';
import * as SYNDUMP from './SYNDUMP'; // import SYNDUMP from './SYNDUMP';
import * as SYNUPDATE from './SYNUPDATE'; // import SYNUPDATE from './SYNUPDATE';
import * as TAGVALS from './TAGVALS'; import TAGVALS from './TAGVALS';
import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands'; // import { RedisCommandArgument, RedisCommandArguments } from '@redis/client/dist/lib/commands';
import { pushOptionalVariadicArgument, pushVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers'; import { pushOptionalVariadicArgument, pushVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
import { SearchOptions } from './SEARCH'; import { SearchOptions } from './SEARCH';
import { CommandArguments } from '@redis/client/dist/lib/RESP/types';
export default { export default {
_LIST, _LIST,
_list: _LIST, _list: _LIST,
ALTER, // ALTER,
alter: ALTER, // alter: ALTER,
AGGREGATE_WITHCURSOR, // AGGREGATE_WITHCURSOR,
aggregateWithCursor: AGGREGATE_WITHCURSOR, // aggregateWithCursor: AGGREGATE_WITHCURSOR,
AGGREGATE, // AGGREGATE,
aggregate: AGGREGATE, // aggregate: AGGREGATE,
ALIASADD, // ALIASADD,
aliasAdd: ALIASADD, // aliasAdd: ALIASADD,
ALIASDEL, // ALIASDEL,
aliasDel: ALIASDEL, // aliasDel: ALIASDEL,
ALIASUPDATE, // ALIASUPDATE,
aliasUpdate: ALIASUPDATE, // aliasUpdate: ALIASUPDATE,
CONFIG_GET, // CONFIG_GET,
configGet: CONFIG_GET, // configGet: CONFIG_GET,
CONFIG_SET, // CONFIG_SET,
configSet: CONFIG_SET, // configSet: CONFIG_SET,
CREATE, CREATE,
create: CREATE, create: CREATE,
CURSOR_DEL, // CURSOR_DEL,
cursorDel: CURSOR_DEL, // cursorDel: CURSOR_DEL,
CURSOR_READ, // CURSOR_READ,
cursorRead: CURSOR_READ, // cursorRead: CURSOR_READ,
DICTADD, DICTADD,
dictAdd: DICTADD, dictAdd: DICTADD,
DICTDEL, DICTDEL,
@@ -72,65 +73,65 @@ export default {
explain: EXPLAIN, explain: EXPLAIN,
EXPLAINCLI, EXPLAINCLI,
explainCli: EXPLAINCLI, explainCli: EXPLAINCLI,
INFO, // INFO,
info: INFO, // info: INFO,
PROFILESEARCH, // PROFILESEARCH,
profileSearch: PROFILESEARCH, // profileSearch: PROFILESEARCH,
PROFILEAGGREGATE, // PROFILEAGGREGATE,
profileAggregate: PROFILEAGGREGATE, // profileAggregate: PROFILEAGGREGATE,
SEARCH, // SEARCH,
search: SEARCH, // search: SEARCH,
SPELLCHECK, // SPELLCHECK,
spellCheck: SPELLCHECK, // spellCheck: SPELLCHECK,
SUGADD, SUGADD,
sugAdd: SUGADD, sugAdd: SUGADD,
SUGDEL, SUGDEL,
sugDel: SUGDEL, sugDel: SUGDEL,
SUGGET_WITHPAYLOADS, // SUGGET_WITHPAYLOADS,
sugGetWithPayloads: SUGGET_WITHPAYLOADS, // sugGetWithPayloads: SUGGET_WITHPAYLOADS,
SUGGET_WITHSCORES_WITHPAYLOADS, // SUGGET_WITHSCORES_WITHPAYLOADS,
sugGetWithScoresWithPayloads: SUGGET_WITHSCORES_WITHPAYLOADS, // sugGetWithScoresWithPayloads: SUGGET_WITHSCORES_WITHPAYLOADS,
SUGGET_WITHSCORES, // SUGGET_WITHSCORES,
sugGetWithScores: SUGGET_WITHSCORES, // sugGetWithScores: SUGGET_WITHSCORES,
SUGGET, // SUGGET,
sugGet: SUGGET, // sugGet: SUGGET,
SUGLEN, SUGLEN,
sugLen: SUGLEN, sugLen: SUGLEN,
SYNDUMP, // SYNDUMP,
synDump: SYNDUMP, // synDump: SYNDUMP,
SYNUPDATE, // SYNUPDATE,
synUpdate: SYNUPDATE, // synUpdate: SYNUPDATE,
TAGVALS, TAGVALS,
tagVals: TAGVALS tagVals: TAGVALS
}; };
export enum RedisSearchLanguages { // export enum RedisSearchLanguages {
ARABIC = 'Arabic', // ARABIC = 'Arabic',
BASQUE = 'Basque', // BASQUE = 'Basque',
CATALANA = 'Catalan', // CATALANA = 'Catalan',
DANISH = 'Danish', // DANISH = 'Danish',
DUTCH = 'Dutch', // DUTCH = 'Dutch',
ENGLISH = 'English', // ENGLISH = 'English',
FINNISH = 'Finnish', // FINNISH = 'Finnish',
FRENCH = 'French', // FRENCH = 'French',
GERMAN = 'German', // GERMAN = 'German',
GREEK = 'Greek', // GREEK = 'Greek',
HUNGARIAN = 'Hungarian', // HUNGARIAN = 'Hungarian',
INDONESAIN = 'Indonesian', // INDONESAIN = 'Indonesian',
IRISH = 'Irish', // IRISH = 'Irish',
ITALIAN = 'Italian', // ITALIAN = 'Italian',
LITHUANIAN = 'Lithuanian', // LITHUANIAN = 'Lithuanian',
NEPALI = 'Nepali', // NEPALI = 'Nepali',
NORWEIGAN = 'Norwegian', // NORWEIGAN = 'Norwegian',
PORTUGUESE = 'Portuguese', // PORTUGUESE = 'Portuguese',
ROMANIAN = 'Romanian', // ROMANIAN = 'Romanian',
RUSSIAN = 'Russian', // RUSSIAN = 'Russian',
SPANISH = 'Spanish', // SPANISH = 'Spanish',
SWEDISH = 'Swedish', // SWEDISH = 'Swedish',
TAMIL = 'Tamil', // TAMIL = 'Tamil',
TURKISH = 'Turkish', // TURKISH = 'Turkish',
CHINESE = 'Chinese' // CHINESE = 'Chinese'
} // }
export type PropertyName = `${'@' | '$.'}${string}`; export type PropertyName = `${'@' | '$.'}${string}`;
@@ -170,209 +171,209 @@ export function pushSortByArguments(args: RedisCommandArguments, name: string, s
return args; return args;
} }
export function pushArgumentsWithLength(args: RedisCommandArguments, fn: (args: RedisCommandArguments) => void): RedisCommandArguments { // export function pushArgumentsWithLength(args: CommandArguments, fn: (args: CommandArguments) => void) {
const lengthIndex = args.push('') - 1; // const lengthIndex = args.push('') - 1;
fn(args); // fn(args);
args[lengthIndex] = (args.length - lengthIndex - 1).toString(); // args[lengthIndex] = (args.length - lengthIndex - 1).toString();
return args; // return args;
} // }
export enum SchemaFieldTypes { // export enum SchemaFieldTypes {
TEXT = 'TEXT', // TEXT = 'TEXT',
NUMERIC = 'NUMERIC', // NUMERIC = 'NUMERIC',
GEO = 'GEO', // GEO = 'GEO',
TAG = 'TAG', // TAG = 'TAG',
VECTOR = 'VECTOR' // VECTOR = 'VECTOR'
} // }
type CreateSchemaField< // type CreateSchemaField<
T extends SchemaFieldTypes, // T extends SchemaFieldTypes,
E = Record<PropertyKey, unknown> // E = Record<PropertyKey, unknown>
> = T | ({ // > = T | ({
type: T; // type: T;
AS?: string; // AS?: string;
} & E); // } & E);
type CreateSchemaCommonField< // type CreateSchemaCommonField<
T extends SchemaFieldTypes, // T extends SchemaFieldTypes,
E = Record<PropertyKey, unknown> // E = Record<PropertyKey, unknown>
> = CreateSchemaField< // > = CreateSchemaField<
T, // T,
({ // ({
SORTABLE?: true | 'UNF'; // SORTABLE?: true | 'UNF';
NOINDEX?: true; // NOINDEX?: true;
} & E) // } & E)
>; // >;
export enum SchemaTextFieldPhonetics { // export enum SchemaTextFieldPhonetics {
DM_EN = 'dm:en', // DM_EN = 'dm:en',
DM_FR = 'dm:fr', // DM_FR = 'dm:fr',
FM_PT = 'dm:pt', // FM_PT = 'dm:pt',
DM_ES = 'dm:es' // DM_ES = 'dm:es'
} // }
type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, { // type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
NOSTEM?: true; // NOSTEM?: true;
WEIGHT?: number; // WEIGHT?: number;
PHONETIC?: SchemaTextFieldPhonetics; // PHONETIC?: SchemaTextFieldPhonetics;
WITHSUFFIXTRIE?: boolean; // 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, { // type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
SEPARATOR?: string; // SEPARATOR?: string;
CASESENSITIVE?: true; // CASESENSITIVE?: true;
WITHSUFFIXTRIE?: boolean; // WITHSUFFIXTRIE?: boolean;
}>; // }>;
export enum VectorAlgorithms { // export enum VectorAlgorithms {
FLAT = 'FLAT', // FLAT = 'FLAT',
HNSW = 'HNSW' // HNSW = 'HNSW'
} // }
type CreateSchemaVectorField< // type CreateSchemaVectorField<
T extends VectorAlgorithms, // T extends VectorAlgorithms,
A extends Record<string, unknown> // A extends Record<string, unknown>
> = CreateSchemaField<SchemaFieldTypes.VECTOR, { // > = CreateSchemaField<SchemaFieldTypes.VECTOR, {
ALGORITHM: T; // ALGORITHM: T;
TYPE: string; // TYPE: string;
DIM: number; // DIM: number;
DISTANCE_METRIC: 'L2' | 'IP' | 'COSINE'; // DISTANCE_METRIC: 'L2' | 'IP' | 'COSINE';
INITIAL_CAP?: number; // INITIAL_CAP?: number;
} & A>; // } & A>;
type CreateSchemaFlatVectorField = CreateSchemaVectorField<VectorAlgorithms.FLAT, { // type CreateSchemaFlatVectorField = CreateSchemaVectorField<VectorAlgorithms.FLAT, {
BLOCK_SIZE?: number; // BLOCK_SIZE?: number;
}>; // }>;
type CreateSchemaHNSWVectorField = CreateSchemaVectorField<VectorAlgorithms.HNSW, { // type CreateSchemaHNSWVectorField = CreateSchemaVectorField<VectorAlgorithms.HNSW, {
M?: number; // M?: number;
EF_CONSTRUCTION?: number; // EF_CONSTRUCTION?: number;
EF_RUNTIME?: number; // EF_RUNTIME?: number;
}>; // }>;
export interface RediSearchSchema { // export interface RediSearchSchema {
[field: string]: // [field: string]:
CreateSchemaTextField | // CreateSchemaTextField |
CreateSchemaNumericField | // CreateSchemaNumericField |
CreateSchemaGeoField | // CreateSchemaGeoField |
CreateSchemaTagField | // CreateSchemaTagField |
CreateSchemaFlatVectorField | // CreateSchemaFlatVectorField |
CreateSchemaHNSWVectorField; // CreateSchemaHNSWVectorField;
} // }
export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema) { // export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema) {
for (const [field, fieldOptions] of Object.entries(schema)) { // for (const [field, fieldOptions] of Object.entries(schema)) {
args.push(field); // args.push(field);
if (typeof fieldOptions === 'string') { // if (typeof fieldOptions === 'string') {
args.push(fieldOptions); // args.push(fieldOptions);
continue; // continue;
} // }
if (fieldOptions.AS) { // if (fieldOptions.AS) {
args.push('AS', fieldOptions.AS); // args.push('AS', fieldOptions.AS);
} // }
args.push(fieldOptions.type); // args.push(fieldOptions.type);
switch (fieldOptions.type) { // switch (fieldOptions.type) {
case SchemaFieldTypes.TEXT: // case SchemaFieldTypes.TEXT:
if (fieldOptions.NOSTEM) { // if (fieldOptions.NOSTEM) {
args.push('NOSTEM'); // args.push('NOSTEM');
} // }
if (fieldOptions.WEIGHT) { // if (fieldOptions.WEIGHT) {
args.push('WEIGHT', fieldOptions.WEIGHT.toString()); // args.push('WEIGHT', fieldOptions.WEIGHT.toString());
} // }
if (fieldOptions.PHONETIC) { // if (fieldOptions.PHONETIC) {
args.push('PHONETIC', fieldOptions.PHONETIC); // args.push('PHONETIC', fieldOptions.PHONETIC);
} // }
if (fieldOptions.WITHSUFFIXTRIE) { // if (fieldOptions.WITHSUFFIXTRIE) {
args.push('WITHSUFFIXTRIE'); // args.push('WITHSUFFIXTRIE');
} // }
break;
// case SchemaFieldTypes.NUMERIC:
// case SchemaFieldTypes.GEO:
// break; // break;
case SchemaFieldTypes.TAG: // // case SchemaFieldTypes.NUMERIC:
if (fieldOptions.SEPARATOR) { // // case SchemaFieldTypes.GEO:
args.push('SEPARATOR', fieldOptions.SEPARATOR); // // break;
}
if (fieldOptions.CASESENSITIVE) { // case SchemaFieldTypes.TAG:
args.push('CASESENSITIVE'); // if (fieldOptions.SEPARATOR) {
} // args.push('SEPARATOR', fieldOptions.SEPARATOR);
// }
if (fieldOptions.WITHSUFFIXTRIE) { // if (fieldOptions.CASESENSITIVE) {
args.push('WITHSUFFIXTRIE'); // args.push('CASESENSITIVE');
} // }
break; // if (fieldOptions.WITHSUFFIXTRIE) {
// args.push('WITHSUFFIXTRIE');
// }
case SchemaFieldTypes.VECTOR: // break;
args.push(fieldOptions.ALGORITHM);
pushArgumentsWithLength(args, () => { // case SchemaFieldTypes.VECTOR:
args.push( // args.push(fieldOptions.ALGORITHM);
'TYPE', fieldOptions.TYPE,
'DIM', fieldOptions.DIM.toString(),
'DISTANCE_METRIC', fieldOptions.DISTANCE_METRIC
);
if (fieldOptions.INITIAL_CAP) { // pushArgumentsWithLength(args, () => {
args.push('INITIAL_CAP', fieldOptions.INITIAL_CAP.toString()); // args.push(
} // 'TYPE', fieldOptions.TYPE,
// 'DIM', fieldOptions.DIM.toString(),
// 'DISTANCE_METRIC', fieldOptions.DISTANCE_METRIC
// );
switch (fieldOptions.ALGORITHM) { // if (fieldOptions.INITIAL_CAP) {
case VectorAlgorithms.FLAT: // args.push('INITIAL_CAP', fieldOptions.INITIAL_CAP.toString());
if (fieldOptions.BLOCK_SIZE) { // }
args.push('BLOCK_SIZE', fieldOptions.BLOCK_SIZE.toString());
}
break; // switch (fieldOptions.ALGORITHM) {
// case VectorAlgorithms.FLAT:
// if (fieldOptions.BLOCK_SIZE) {
// args.push('BLOCK_SIZE', fieldOptions.BLOCK_SIZE.toString());
// }
case VectorAlgorithms.HNSW: // break;
if (fieldOptions.M) {
args.push('M', fieldOptions.M.toString());
}
if (fieldOptions.EF_CONSTRUCTION) { // case VectorAlgorithms.HNSW:
args.push('EF_CONSTRUCTION', fieldOptions.EF_CONSTRUCTION.toString()); // if (fieldOptions.M) {
} // args.push('M', fieldOptions.M.toString());
// }
if (fieldOptions.EF_RUNTIME) { // if (fieldOptions.EF_CONSTRUCTION) {
args.push('EF_RUNTIME', fieldOptions.EF_RUNTIME.toString()); // args.push('EF_CONSTRUCTION', fieldOptions.EF_CONSTRUCTION.toString());
} // }
break; // if (fieldOptions.EF_RUNTIME) {
} // args.push('EF_RUNTIME', fieldOptions.EF_RUNTIME.toString());
}); // }
continue; // vector fields do not contain SORTABLE and NOINDEX options // break;
} // }
// });
if (fieldOptions.SORTABLE) { // continue; // vector fields do not contain SORTABLE and NOINDEX options
args.push('SORTABLE'); // }
if (fieldOptions.SORTABLE === 'UNF') { // if (fieldOptions.SORTABLE) {
args.push('UNF'); // args.push('SORTABLE');
}
}
if (fieldOptions.NOINDEX) { // if (fieldOptions.SORTABLE === 'UNF') {
args.push('NOINDEX'); // args.push('UNF');
} // }
} // }
}
// if (fieldOptions.NOINDEX) {
// args.push('NOINDEX');
// }
// }
// }
export type Params = Record<string, RedisCommandArgument | number>; export type Params = Record<string, RedisCommandArgument | number>;