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

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

@@ -1,418 +1,415 @@
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']
); );
});
describe('with fields', () => {
describe('TEXT', () => {
it('without options', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.TEXT
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT']
);
});
it('with NOSTEM', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
NOSTEM: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOSTEM']
);
});
it('with WEIGHT', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
WEIGHT: 1
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WEIGHT', '1']
);
});
it('with PHONETIC', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
PHONETIC: SchemaTextFieldPhonetics.DM_EN
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'PHONETIC', SchemaTextFieldPhonetics.DM_EN]
);
});
it('with WITHSUFFIXTRIE', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
WITHSUFFIXTRIE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WITHSUFFIXTRIE']
);
});
});
it('NUMERIC', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.NUMERIC
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'NUMERIC']
);
});
it('GEO', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.GEO
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'GEO']
);
});
describe('TAG', () => {
describe('without options', () => {
it('SchemaFieldTypes.TAG', () => {
assert.deepEqual(
transformArguments('index', {
field: SchemaFieldTypes.TAG
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
);
});
it('{ type: SchemaFieldTypes.TAG }', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
);
});
});
it('with SEPARATOR', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG,
SEPARATOR: 'separator'
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'SEPARATOR', 'separator']
);
});
it('with CASESENSITIVE', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG,
CASESENSITIVE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'CASESENSITIVE']
);
});
it('with WITHSUFFIXTRIE', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TAG,
WITHSUFFIXTRIE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'WITHSUFFIXTRIE']
);
});
});
describe('VECTOR', () => {
it('Flat algorithm', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.VECTOR,
ALGORITHM: VectorAlgorithms.FLAT,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
INITIAL_CAP: 1000000,
BLOCK_SIZE: 1000
}
}),
[
'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'FLAT', '10', 'TYPE',
'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
'BLOCK_SIZE', '1000'
]
);
});
it('HNSW algorithm', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.VECTOR,
ALGORITHM: VectorAlgorithms.HNSW,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
INITIAL_CAP: 1000000,
M: 40,
EF_CONSTRUCTION: 250,
EF_RUNTIME: 20
}
}),
[
'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'HNSW', '14', 'TYPE',
'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
'M', '40', 'EF_CONSTRUCTION', '250', 'EF_RUNTIME', '20'
]
);
});
});
describe('with generic options', () => {
it('with AS', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
AS: 'as'
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'AS', 'as', 'TEXT']
);
});
describe('with SORTABLE', () => {
it('true', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
SORTABLE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'SORTABLE']
);
});
it('UNF', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
SORTABLE: 'UNF'
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'SORTABLE', 'UNF']
);
});
});
it('with NOINDEX', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.TEXT,
NOINDEX: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOINDEX']
);
});
});
});
it('with ON', () => {
assert.deepEqual(
transformArguments('index', {}, {
ON: 'HASH'
}),
['FT.CREATE', 'index', 'ON', 'HASH', 'SCHEMA']
);
});
describe('with PREFIX', () => {
it('string', () => {
assert.deepEqual(
transformArguments('index', {}, {
PREFIX: 'prefix'
}),
['FT.CREATE', 'index', 'PREFIX', '1', 'prefix', 'SCHEMA']
);
});
it('Array', () => {
assert.deepEqual(
transformArguments('index', {}, {
PREFIX: ['1', '2']
}),
['FT.CREATE', 'index', 'PREFIX', '2', '1', '2', 'SCHEMA']
);
});
});
it('with FILTER', () => {
assert.deepEqual(
transformArguments('index', {}, {
FILTER: '@field != ""'
}),
['FT.CREATE', 'index', 'FILTER', '@field != ""', 'SCHEMA']
);
});
it('with LANGUAGE', () => {
assert.deepEqual(
transformArguments('index', {}, {
LANGUAGE: RedisSearchLanguages.ARABIC
}),
['FT.CREATE', 'index', 'LANGUAGE', RedisSearchLanguages.ARABIC, 'SCHEMA']
);
});
it('with LANGUAGE_FIELD', () => {
assert.deepEqual(
transformArguments('index', {}, {
LANGUAGE_FIELD: '@field'
}),
['FT.CREATE', 'index', 'LANGUAGE_FIELD', '@field', 'SCHEMA']
);
});
it('with SCORE', () => {
assert.deepEqual(
transformArguments('index', {}, {
SCORE: 1
}),
['FT.CREATE', 'index', 'SCORE', '1', 'SCHEMA']
);
});
it('with SCORE_FIELD', () => {
assert.deepEqual(
transformArguments('index', {}, {
SCORE_FIELD: '@field'
}),
['FT.CREATE', 'index', 'SCORE_FIELD', '@field', 'SCHEMA']
);
});
it('with MAXTEXTFIELDS', () => {
assert.deepEqual(
transformArguments('index', {}, {
MAXTEXTFIELDS: true
}),
['FT.CREATE', 'index', 'MAXTEXTFIELDS', 'SCHEMA']
);
});
it('with TEMPORARY', () => {
assert.deepEqual(
transformArguments('index', {}, {
TEMPORARY: 1
}),
['FT.CREATE', 'index', 'TEMPORARY', '1', 'SCHEMA']
);
});
it('with NOOFFSETS', () => {
assert.deepEqual(
transformArguments('index', {}, {
NOOFFSETS: true
}),
['FT.CREATE', 'index', 'NOOFFSETS', 'SCHEMA']
);
});
it('with NOHL', () => {
assert.deepEqual(
transformArguments('index', {}, {
NOHL: true
}),
['FT.CREATE', 'index', 'NOHL', 'SCHEMA']
);
});
it('with NOFIELDS', () => {
assert.deepEqual(
transformArguments('index', {}, {
NOFIELDS: true
}),
['FT.CREATE', 'index', 'NOFIELDS', 'SCHEMA']
);
});
it('with NOFREQS', () => {
assert.deepEqual(
transformArguments('index', {}, {
NOFREQS: true
}),
['FT.CREATE', 'index', 'NOFREQS', 'SCHEMA']
);
});
it('with SKIPINITIALSCAN', () => {
assert.deepEqual(
transformArguments('index', {}, {
SKIPINITIALSCAN: true
}),
['FT.CREATE', 'index', 'SKIPINITIALSCAN', 'SCHEMA']
);
});
describe('with STOPWORDS', () => {
it('string', () => {
assert.deepEqual(
transformArguments('index', {}, {
STOPWORDS: 'stopword'
}),
['FT.CREATE', 'index', 'STOPWORDS', '1', 'stopword', 'SCHEMA']
);
});
it('Array', () => {
assert.deepEqual(
transformArguments('index', {}, {
STOPWORDS: ['1', '2']
}),
['FT.CREATE', 'index', 'STOPWORDS', '2', '1', '2', 'SCHEMA']
);
});
});
}); });
testUtils.testWithClient('client.ft.create', async client => { describe('with fields', () => {
assert.equal( describe('TEXT', () => {
await client.ft.create('index', { it('without options', () => {
field: SchemaFieldTypes.TEXT assert.deepEqual(
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.TEXT
}), }),
'OK' ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT']
);
});
it('with NOSTEM', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
NOSTEM: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOSTEM']
);
});
it('with WEIGHT', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
WEIGHT: 1
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WEIGHT', '1']
);
});
it('with PHONETIC', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
PHONETIC: SCHEMA_TEXT_FIELD_PHONETIC.DM_EN
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'PHONETIC', SCHEMA_TEXT_FIELD_PHONETIC.DM_EN]
);
});
it('with WITHSUFFIXTRIE', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
WITHSUFFIXTRIE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WITHSUFFIXTRIE']
);
});
});
it('NUMERIC', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.NUMERIC
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'NUMERIC']
); );
}, GLOBAL.SERVERS.OPEN); });
it('GEO', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.GEO
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'GEO']
);
});
describe('TAG', () => {
describe('without options', () => {
it('SCHEMA_FIELD_TYPE.TAG', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: SCHEMA_FIELD_TYPE.TAG
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
);
});
it('{ type: SCHEMA_FIELD_TYPE.TAG }', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TAG
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
);
});
});
it('with SEPARATOR', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TAG,
SEPARATOR: 'separator'
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'SEPARATOR', 'separator']
);
});
it('with CASESENSITIVE', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TAG,
CASESENSITIVE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'CASESENSITIVE']
);
});
it('with WITHSUFFIXTRIE', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TAG,
WITHSUFFIXTRIE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'WITHSUFFIXTRIE']
);
});
});
describe('VECTOR', () => {
it('Flat algorithm', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.VECTOR,
ALGORITHM: SCHEMA_VECTOR_FIELD_ALGORITHM.FLAT,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
INITIAL_CAP: 1000000,
BLOCK_SIZE: 1000
}
}),
[
'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'FLAT', '10', 'TYPE',
'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
'BLOCK_SIZE', '1000'
]
);
});
it('HNSW algorithm', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.VECTOR,
ALGORITHM: SCHEMA_VECTOR_FIELD_ALGORITHM.HNSW,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
INITIAL_CAP: 1000000,
M: 40,
EF_CONSTRUCTION: 250,
EF_RUNTIME: 20
}
}),
[
'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'HNSW', '14', 'TYPE',
'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
'M', '40', 'EF_CONSTRUCTION', '250', 'EF_RUNTIME', '20'
]
);
});
});
it('with AS', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
AS: 'as'
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'AS', 'as', 'TEXT']
);
});
describe('with SORTABLE', () => {
it('true', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
SORTABLE: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'SORTABLE']
);
});
it('UNF', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
SORTABLE: 'UNF'
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'SORTABLE', 'UNF']
);
});
});
it('with NOINDEX', () => {
assert.deepEqual(
CREATE.transformArguments('index', {
field: {
type: SCHEMA_FIELD_TYPE.TEXT,
NOINDEX: true
}
}),
['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOINDEX']
);
});
});
it('with ON', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
ON: 'HASH'
}),
['FT.CREATE', 'index', 'ON', 'HASH', 'SCHEMA']
);
});
describe('with PREFIX', () => {
it('string', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
PREFIX: 'prefix'
}),
['FT.CREATE', 'index', 'PREFIX', '1', 'prefix', 'SCHEMA']
);
});
it('Array', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
PREFIX: ['1', '2']
}),
['FT.CREATE', 'index', 'PREFIX', '2', '1', '2', 'SCHEMA']
);
});
});
it('with FILTER', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
FILTER: '@field != ""'
}),
['FT.CREATE', 'index', 'FILTER', '@field != ""', 'SCHEMA']
);
});
it('with LANGUAGE', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
LANGUAGE: REDISEARCH_LANGUAGE.ARABIC
}),
['FT.CREATE', 'index', 'LANGUAGE', REDISEARCH_LANGUAGE.ARABIC, 'SCHEMA']
);
});
it('with LANGUAGE_FIELD', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
LANGUAGE_FIELD: '@field'
}),
['FT.CREATE', 'index', 'LANGUAGE_FIELD', '@field', 'SCHEMA']
);
});
it('with SCORE', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
SCORE: 1
}),
['FT.CREATE', 'index', 'SCORE', '1', 'SCHEMA']
);
});
it('with SCORE_FIELD', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
SCORE_FIELD: '@field'
}),
['FT.CREATE', 'index', 'SCORE_FIELD', '@field', 'SCHEMA']
);
});
it('with MAXTEXTFIELDS', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
MAXTEXTFIELDS: true
}),
['FT.CREATE', 'index', 'MAXTEXTFIELDS', 'SCHEMA']
);
});
it('with TEMPORARY', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
TEMPORARY: 1
}),
['FT.CREATE', 'index', 'TEMPORARY', '1', 'SCHEMA']
);
});
it('with NOOFFSETS', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
NOOFFSETS: true
}),
['FT.CREATE', 'index', 'NOOFFSETS', 'SCHEMA']
);
});
it('with NOHL', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
NOHL: true
}),
['FT.CREATE', 'index', 'NOHL', 'SCHEMA']
);
});
it('with NOFIELDS', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
NOFIELDS: true
}),
['FT.CREATE', 'index', 'NOFIELDS', 'SCHEMA']
);
});
it('with NOFREQS', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
NOFREQS: true
}),
['FT.CREATE', 'index', 'NOFREQS', 'SCHEMA']
);
});
it('with SKIPINITIALSCAN', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
SKIPINITIALSCAN: true
}),
['FT.CREATE', 'index', 'SKIPINITIALSCAN', 'SCHEMA']
);
});
describe('with STOPWORDS', () => {
it('string', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
STOPWORDS: 'stopword'
}),
['FT.CREATE', 'index', 'STOPWORDS', '1', 'stopword', 'SCHEMA']
);
});
it('Array', () => {
assert.deepEqual(
CREATE.transformArguments('index', {}, {
STOPWORDS: ['1', '2']
}),
['FT.CREATE', 'index', 'STOPWORDS', '2', '1', '2', 'SCHEMA']
);
});
});
});
testUtils.testWithClient('client.ft.create', async client => {
assert.equal(
await client.ft.create('index', {
field: SCHEMA_FIELD_TYPE.TEXT
}),
'OK'
);
}, GLOBAL.SERVERS.OPEN);
}); });

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

@@ -1,52 +1,291 @@
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 = {
ON?: 'HASH' | 'JSON'; TEXT: 'TEXT',
PREFIX?: string | Array<string>; NUMERIC: 'NUMERIC',
FILTER?: string; GEO: 'GEO',
LANGUAGE?: RedisSearchLanguages; TAG: 'TAG',
LANGUAGE_FIELD?: PropertyName; VECTOR: 'VECTOR'
SCORE?: number; } as const;
SCORE_FIELD?: PropertyName;
// PAYLOAD_FIELD?: string; export type SchemaFieldType = typeof SCHEMA_FIELD_TYPE[keyof typeof SCHEMA_FIELD_TYPE];
MAXTEXTFIELDS?: true;
TEMPORARY?: number; type SchemaField<
NOOFFSETS?: true; T extends SchemaFieldType,
NOHL?: true; E = Record<PropertyKey, unknown>
NOFIELDS?: true; > = T | ({
NOFREQS?: true; type: T;
SKIPINITIALSCAN?: true; AS?: RedisArgument;
STOPWORDS?: string | Array<string>; } & 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 transformArguments(index: string, schema: RediSearchSchema, options?: CreateOptions): Array<string> { 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?: RedisVariadicArgument;
FILTER?: RedisArgument;
LANGUAGE?: RediSearchLanguage;
LANGUAGE_FIELD?: PropertyName;
SCORE?: number;
SCORE_FIELD?: PropertyName;
// PAYLOAD_FIELD?: string;
MAXTEXTFIELDS?: boolean;
TEMPORARY?: number;
NOOFFSETS?: boolean;
NOHL?: boolean;
NOFIELDS?: boolean;
NOFREQS?: boolean;
SKIPINITIALSCAN?: boolean;
STOPWORDS?: RedisVariadicArgument;
}
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) {
args.push('ON', options.ON); args.push('ON', options.ON);
} }
pushOptionalVariadicArgument(args, 'PREFIX', options?.PREFIX); pushOptionalVariadicArgument(args, 'PREFIX', options?.PREFIX);
if (options?.FILTER) { if (options?.FILTER) {
args.push('FILTER', options.FILTER); args.push('FILTER', options.FILTER);
} }
if (options?.LANGUAGE) { if (options?.LANGUAGE) {
args.push('LANGUAGE', options.LANGUAGE); args.push('LANGUAGE', options.LANGUAGE);
} }
if (options?.LANGUAGE_FIELD) { if (options?.LANGUAGE_FIELD) {
args.push('LANGUAGE_FIELD', options.LANGUAGE_FIELD); args.push('LANGUAGE_FIELD', options.LANGUAGE_FIELD);
} }
if (options?.SCORE) { if (options?.SCORE) {
args.push('SCORE', options.SCORE.toString()); args.push('SCORE', options.SCORE.toString());
} }
if (options?.SCORE_FIELD) { if (options?.SCORE_FIELD) {
args.push('SCORE_FIELD', options.SCORE_FIELD); args.push('SCORE_FIELD', options.SCORE_FIELD);
} }
// if (options?.PAYLOAD_FIELD) { // if (options?.PAYLOAD_FIELD) {
@@ -54,31 +293,31 @@ export function transformArguments(index: string, schema: RediSearchSchema, opti
// } // }
if (options?.MAXTEXTFIELDS) { if (options?.MAXTEXTFIELDS) {
args.push('MAXTEXTFIELDS'); args.push('MAXTEXTFIELDS');
} }
if (options?.TEMPORARY) { if (options?.TEMPORARY) {
args.push('TEMPORARY', options.TEMPORARY.toString()); args.push('TEMPORARY', options.TEMPORARY.toString());
} }
if (options?.NOOFFSETS) { if (options?.NOOFFSETS) {
args.push('NOOFFSETS'); args.push('NOOFFSETS');
} }
if (options?.NOHL) { if (options?.NOHL) {
args.push('NOHL'); args.push('NOHL');
} }
if (options?.NOFIELDS) { if (options?.NOFIELDS) {
args.push('NOFIELDS'); args.push('NOFIELDS');
} }
if (options?.NOFREQS) { if (options?.NOFREQS) {
args.push('NOFREQS'); args.push('NOFREQS');
} }
if (options?.SKIPINITIALSCAN) { if (options?.SKIPINITIALSCAN) {
args.push('SKIPINITIALSCAN'); args.push('SKIPINITIALSCAN');
} }
pushOptionalVariadicArgument(args, 'STOPWORDS', options?.STOPWORDS); pushOptionalVariadicArgument(args, 'STOPWORDS', options?.STOPWORDS);
@@ -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;

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

File diff suppressed because it is too large Load Diff