small refactor per discussion with leibele (#2801)

* small refactor per discussion with leibele

* move true type to boolean type

* fix geoshape to support NOINDEX & SORTABLE, clean code

* fix for last commit

---------

Co-authored-by: Leibale Eidelman <me@leibale.com>

packages/search/lib/commands/CREATE.spec.ts

@@ -70,6 +70,18 @@ describe('CREATE', () => {
                         ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WITHSUFFIXTRIE']
                     );
                 });
+
+                it('with INDEXEMPTY', () => {
+                    assert.deepEqual(
+                        transformArguments('index', {
+                            field: {
+                                type: SchemaFieldTypes.TEXT,
+                                INDEXEMPTY: true
+                            }
+                        }),
+                        ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'INDEXEMPTY']
+                    );
+                });
             });
 
             it('NUMERIC', () => {
@@ -148,6 +160,18 @@ describe('CREATE', () => {
                         ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'WITHSUFFIXTRIE']
                     );
                 });
+
+                it('with INDEXEMPTY', () => {
+                    assert.deepEqual(
+                        transformArguments('index', {
+                            field: {
+                                type: SchemaFieldTypes.TAG,
+                                INDEXEMPTY: true
+                            }
+                        }),
+                        ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'INDEXEMPTY']
+                    );
+                });
             });
 
             describe('VECTOR', () => {
@@ -282,6 +306,18 @@ describe('CREATE', () => {
                         ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOINDEX']
                     );
                 });
+
+                it('with INDEXMISSING', () => {
+                    assert.deepEqual(
+                        transformArguments('index', {
+                            field: {
+                                type: SchemaFieldTypes.TEXT,
+                                INDEXMISSING: true
+                            }
+                        }),
+                        ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'INDEXMISSING']
+                    );
+                });
             });
         });
 
@@ -441,36 +477,6 @@ describe('CREATE', () => {
                 );
             });
         });
-
-        describe('Missing Values', () => {
-            it('with INDEXEMPTY', () => {
-                assert.deepEqual(
-                    transformArguments('index', {
-                        field: {
-                            type: SchemaFieldTypes.TEXT,
-                            MISSING_VALUES: {
-                                INDEXEMPTY: true
-                            }
-                        }
-                    }),
-                    ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'INDEXEMPTY']
-                );
-            });
-
-            it('with INDEXMISSING', () => {
-                assert.deepEqual(
-                    transformArguments('index', {
-                        field: {
-                            type: SchemaFieldTypes.TEXT,
-                            MISSING_VALUES: {
-                                INDEXMISSING: true
-                            }
-                        }
-                    }),
-                    ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'INDEXMISSING']
-                );
-            });
-        });
     });
 
     testUtils.testWithClient('client.ft.create', async client => {

packages/search/lib/commands/index.ts

@@ -189,45 +189,42 @@ export enum SchemaFieldTypes {
     GEOSHAPE = 'GEOSHAPE'
 }
   
-export interface MissingValues {
-    INDEXEMPTY?: boolean;
-    INDEXMISSING?: boolean;
-}
-
-function pushMissingValues(args: RedisCommandArguments, missingValues?: MissingValues) {
-    if (!missingValues) {
-        return;
-    }
-
-    if (missingValues.INDEXEMPTY) {
-        args.push("INDEXEMPTY");
-    }
-  
-    if (missingValues.INDEXMISSING) {
-        args.push("INDEXMISSING");
-    }
-}
-  
 type CreateSchemaField<
     T extends SchemaFieldTypes,
     E = Record<PropertyKey, unknown>
 > = T | ({
     type: T;
     AS?: string;
-    MISSING_VALUES?: MissingValues;
+    INDEXMISSING?: boolean;
 } & E);
 
+type CommonFieldArguments = {
+    SORTABLE?: boolean | 'UNF';
+    NOINDEX?: boolean;
+};
+
 type CreateSchemaCommonField<
     T extends SchemaFieldTypes,
     E = Record<PropertyKey, unknown>
 > = CreateSchemaField<
     T,
-    ({
+    (CommonFieldArguments & E)
-        SORTABLE?: true | 'UNF';
-        NOINDEX?: true;
-    } & E)
 >;
 
+function pushCommonFieldArguments(args: RedisCommandArguments, fieldOptions: CommonFieldArguments) {
+    if (fieldOptions.SORTABLE) {
+        args.push('SORTABLE');
+
+        if (fieldOptions.SORTABLE === 'UNF') {
+            args.push('UNF');
+        }
+    }
+
+    if (fieldOptions.NOINDEX) {
+        args.push('NOINDEX');
+    }
+}
+
 export enum SchemaTextFieldPhonetics {
     DM_EN = 'dm:en',
     DM_FR = 'dm:fr',
@@ -240,6 +237,7 @@ type CreateSchemaTextField = CreateSchemaCommonField<SchemaFieldTypes.TEXT, {
     WEIGHT?: number;
     PHONETIC?: SchemaTextFieldPhonetics;
     WITHSUFFIXTRIE?: boolean;
+    INDEXEMPTY?: boolean;
 }>;
 
 type CreateSchemaNumericField = CreateSchemaCommonField<SchemaFieldTypes.NUMERIC>;
@@ -250,6 +248,7 @@ type CreateSchemaTagField = CreateSchemaCommonField<SchemaFieldTypes.TAG, {
     SEPARATOR?: string;
     CASESENSITIVE?: true;
     WITHSUFFIXTRIE?: boolean;
+    INDEXEMPTY?: boolean;
 }>;
 
 export enum VectorAlgorithms {
@@ -297,7 +296,7 @@ export interface RediSearchSchema {
         CreateSchemaTagField |
         CreateSchemaFlatVectorField |
         CreateSchemaHNSWVectorField |
-        CreateSchemaGeoShapeField
+        CreateSchemaGeoShapeField;
 }
 
 export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema) {
@@ -333,13 +332,17 @@ export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema
                     args.push('WITHSUFFIXTRIE');
                 }
 
-                pushMissingValues(args, fieldOptions.MISSING_VALUES);
+                pushCommonFieldArguments(args, fieldOptions);
+
+                if (fieldOptions.INDEXEMPTY) {
+                    args.push('INDEXEMPTY');
+                }
 
                 break;
 
             case SchemaFieldTypes.NUMERIC:
             case SchemaFieldTypes.GEO:
-                pushMissingValues(args, fieldOptions.MISSING_VALUES);
+                pushCommonFieldArguments(args, fieldOptions);
                 break;
 
             case SchemaFieldTypes.TAG:
@@ -355,7 +358,11 @@ export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema
                     args.push('WITHSUFFIXTRIE');
                 }
 
-                pushMissingValues(args, fieldOptions.MISSING_VALUES);
+                pushCommonFieldArguments(args, fieldOptions);
+
+                if (fieldOptions.INDEXEMPTY) {
+                    args.push('INDEXEMPTY');
+                }
 
                 break;
 
@@ -398,30 +405,20 @@ export function pushSchema(args: RedisCommandArguments, schema: RediSearchSchema
                     }
                 });
 
-                pushMissingValues(args, fieldOptions.MISSING_VALUES);
+                break;
-
-                continue; // vector fields do not contain SORTABLE and NOINDEX options
 
             case SchemaFieldTypes.GEOSHAPE:
                 if (fieldOptions.COORD_SYSTEM !== undefined) {
                     args.push('COORD_SYSTEM', fieldOptions.COORD_SYSTEM);
                 }
 
-                pushMissingValues(args, fieldOptions.MISSING_VALUES);
+                pushCommonFieldArguments(args, fieldOptions);
 
-                continue; // geo shape fields do not contain SORTABLE and NOINDEX options
+                break;
         }
 
-        if (fieldOptions.SORTABLE) {
+        if (fieldOptions.INDEXMISSING) {
-            args.push('SORTABLE');
+            args.push('INDEXMISSING');
-
-            if (fieldOptions.SORTABLE === 'UNF') {
-                args.push('UNF');
-            }
-        }
-
-        if (fieldOptions.NOINDEX) {
-            args.push('NOINDEX');
         }
     }
 }