client.ft.search() always returning strings?

[quintesse]

Hi, it seems that regardless of the types I specify in my indices the .ft.search() command always returns my data as strings (when I use RETURN in the query). Is that expected behavior somehow? I would assume not, so am I doing something wrong?

For context, I'm storing JSON docs of the type:

{
  name: string;
  category: string;
  description: string;
  quantity: number;
}

and I created an index like this:

FT.CREATE idx:items
  ON JSON
    PREFIX 1 "item:"
  SCHEMA
    $.name AS name TEXT NOSTEM
    $.category AS category TAG
    $.description AS description TEXT NOSTEM
    $.quantity AS quantity NUMERIC SORTABLE

And when I do a search in Node like:

const options: SearchOptions = {
    SORTBY: "quantity",
    DIALECT: 2
};
const result = await this.client.ft.search("idx:items", "@category:{books}", options);

I actually get the expected result:

{"total":1,"documents":[{"id":"item:8","value":{"name":"The Art of War","category":"books","description":"...some long string...","quantity":3}}]}

But when I do a search using RETURN like this:

const options: SearchOptions = {
    SORTBY: "quantity",
    RETURN: ["name", "category", "quantity"],
    DIALECT: 2
};
const result = await this.client.ft.search("idx:items", "@category:{books}", options);

suddenly the result I get is:

{"total":1,"documents":[{"id":"item:8","value":{"name":"The Art of War","category":"books","quantity":"3"}}]}

As you can see the "quantity" field is returned as a string, not a number.

[slenin]

Hitting the same issue. Are there any workarounds?

[KemikalGeneral]

Yeah, really frustrating, any solutions?

[KemikalGeneral]

As this was the first result when searching the issue, I though I'd post what I did for anyone else that may need it.

The problem is that this FT.SEARCH with a RETURN only gave me strings.

const getEntitiesByWhereAndFields = async ({ entity, whereData, fieldsData }) => {

    // Example of incoming parameters:
    // entity: MassEmail
    // whereData: []
    // fieldsData: [
    //  { field: 'createdDateTime', type: 'number' },
    //  { field: 'massEmailText', type: 'string' },
    //  { field: 'massEmailSendToListUsers', type: 'array' }
    // ]

    try {

        // ...other validation code

        // Construct the index name dynamically
        const INDEX_NAME = `${entity}:index`;

        // Construct the query filter based on criteria
        let QUERY_FILTER = whereData.map(condition => `@${condition.whereKey}:{${condition.whereValue}}`).join(' ');
        QUERY_FILTER += ' @isDeleted:{false}';

        // Construct the raw query string with specified fields
        const RAW_QUERY = ['FT.SEARCH', INDEX_NAME, QUERY_FILTER, 'RETURN', String(fieldsData.length), ...fieldsData.map(f => f.field), 'LIMIT', '0', '10000'];
        console.log('RAW_QUERY:', RAW_QUERY);

        // Execute the raw search query directly using the Redis client
        const SEARCH_RESULTS = await client.execute(RAW_QUERY);
        console.log('SEARCH_RESULTS:', SEARCH_RESULTS);

        // ...process results

    } catch (error) {
        console.error('Error fetching getEntitiesByWhereAndFields:', error);
        throw error;
    }
};

I could identify and handle the string -> number conversions, but arrays were returned as a string containing the first element in the array.

SEARCH_RESULTS: [
    1,
    'MassEmail:01xxxxxxxxxx',
    [
        'createdDateTime',
        '1718702387252',
        'massEmailText',
        '<p>This is only sending to specific users.</p>',
        'massEmailSendToListUsers',
        '01xxxxxxxxxx'
    ]
]

...which is no good and I couldn't do anything with it.

Long story short, I worked out the RETURN was the culprit for this, so I dropped it and handled it differently:

const getEntitiesByWhereAndFields = async ({ entity, whereData, fieldsData }) => {

    // ...validate the input data

    try {

        // Construct the index name dynamically
        const INDEX_NAME = `${entity}:index`

        // Construct the query filter based on criteria
        let QUERY_FILTER = whereData.map(condition => `@${condition.whereKey}:{${condition.whereValue}}`).join(' ')
        QUERY_FILTER += ' @isDeleted:{false}'

        // Construct the raw query string
        const RAW_QUERY = ['FT.SEARCH', INDEX_NAME, QUERY_FILTER, 'LIMIT', '0', '10000']

        // Execute the raw search query directly using the Redis client
        const SEARCH_RESULTS = await client.execute(RAW_QUERY)

        // Check if result contains entities
        if (SEARCH_RESULTS.length <= 1) return []

        // Parse the results
        const ENTITIES = []
        const SEARCH_RESULTS_LENGTH = SEARCH_RESULTS.length
        const FIELDS_DATA_LENGTH = fieldsData.length
        for (let i = 1; i < SEARCH_RESULTS_LENGTH; i += 2) {

            // Extract the JSON string from the result
            const JSON_STRING = SEARCH_RESULTS[i + 1][1]

            // Parse the JSON string into an object
            const ENTITY_OBJECT = JSON.parse(JSON_STRING)
            console.log('ENTITY_OBJECT:', ENTITY_OBJECT)

            // ...lots of other processing and cool stuff as required
        }

        // Return the processed data as the response
        return ENTITIES

    } catch (error) {
        console.error('Error fetching getEntitiesByWhereAndFields: ', error)
        throw error
    }
}

Now, the console.log() of the ENTITY_OBJECT will give you the data as a simple JSON to play with, which I processed and returned as required 😎

All the best x

[ankurgar]

not so efficient for retrieving 1000 records.