API pages option to return just literal fields

[RafaelGB]

I have a function on dbfolder plugin where you can obtain all possible fields. To evict duplicates, I was mapping the results to lowercase because if the field has the first char on uppercase, the API also returns lowercase one.

Is there an option to do not duplicate that result?
Thanks in advance

I leave an example with the lowercase map removed:

RafaelGB/obsidian-db-folder#269

[RafaelGB]

In case it doesn't exist, I can fix my use case it with the following function.

export async function obtainColumnsFromRows(
  view: DatabaseView,
  ddbbConfig: LocalSettings,
  filters: FilterSettings,
  tableColumns: TableColumn[]
): Promise<Record<string, DatabaseColumn>> {
  const columns: Record<string, DatabaseColumn> = {};
  const rows = await obtainAllPossibleRows(
    view.file.parent.path,
    ddbbConfig,
    filters,
    tableColumns
  );
  // Obtain unique keys from source
  const keys = rows.reduce((acc, row) => {
    const keys = Object.keys(row).map((key) => key);
    // Remove duplicates
    return [...new Set([...acc, ...keys])];
  }, [] as string[]);

  const uppercaseFields: string[] = [];
  let lowercaseFields: string[] = [];
  keys.forEach((key) => {
    if (containsUpper(key)) {
      uppercaseFields.push(key);
    } else {
      lowercaseFields.push(key);
    }
  });
  const uppercaseFieldsToFilter = uppercaseFields.map((ucf) =>
    ucf.toLowerCase()
  );
  lowercaseFields = lowercaseFields.filter(
    (field) => !uppercaseFieldsToFilter.contains(field)
  );

  const uniqueKeys = [...new Set([...uppercaseFields, ...lowercaseFields])];
  // Add keys to columns
  uniqueKeys
    // Check metadata columns to not be added
    .filter((key) => validateColumnKey(key))
    .forEach((key, index) => {
      columns[key] = {
        input: InputType.TEXT,
        accessorKey: key,
        label: key,
        key: key,
        position: index,
        config: DEFAULT_COLUMN_CONFIG,
      };
    });

  return columns;
}

[toroworx]

I didn't test your workaround @RafaelGB . I wrote the following workaround which I use in stead of dv.current().
An API fix would be best but until then this works for me (using this workaround for a different plugin than yours @RafaelGB).

function getProperDataviewEntries(curPage)
{
    // 1. Generate an array with count, keys and value info
    let entriesArray = [];
    for (let [key, value] of Object.entries(curPage))
    {
        let lowercaseKey = key.toLowerCase();

        // If lowercaseKey does not exist, create obj
        if (entriesArray[lowercaseKey] === undefined)
        {
            let obj = {
                'count': 1,
                'keys': [key],
                'value': value,
            };

            entriesArray[lowercaseKey] = obj;
        }
        else
        {
            entriesArray[lowercaseKey].count++;
            entriesArray[lowercaseKey].keys.push(key);
        }
    }

    // 2. Generate finalArray with the proper keys
    let finalArray = [];
    for (let [key, obj] of Object.entries(entriesArray))
    {
        let count = entriesArray[key].count;

        // - if count > 1, the proper key we need is the one which have uppercase
        if (count > 1)
        {
            obj.keys.forEach((key) => {
                // Check if key containsUpperCase
                if (/[A-Z]/.test(key)) {
                    finalArray[key] = obj.value;
                }
            });
        }
        else
        {
            // count = 1
            finalArray[key] = obj.value;
        }
    }

    return finalArray;
}

// dv.current() returns duplicated keys when camelCase is used. This function includes a workaround.
function getFixedDvCurrent()
{
    let curPage = dv.current();
    let curPageFixed = getProperDataviewEntries(curPage);

    return curPageFixed;
}

[toroworx]

I can confirm this issue. If you add a YAML header which uses camelCase tags, it indeed returns duplicated results: camelcase and camelCase. This result can be seen with console.log(dv.current());

It's probably somewhere an issue with the Dataview API (lovely plugin btw, thanks!).

[blacksmithgu]

It's legacy behavior to support people who both wanted case-sensitive and case-insensitive variable names; I can't fix it without breaking existing scripts unfortunately. I am looking at adding file.fields as an alternative metadata which only contains exact fields (and also handles duplicates differently).

[toroworx]

Thanks for your reply @blacksmithgu, I understand.

I am looking at adding file.fields as an alternative metadata which only contains exact fields (and also handles duplicates differently).

I don't think adding another field to the metadata, and cluttering the .md files, is the proper way.
I understand you don't want to break backward compatibility. I see the following options:

1. How about adding a global option to the plugin's settings. For example Case sensitive variable names: true / false. Perhaps set it to true for new installations, because I don't think case insensitive, with duplicated results of e.g. dv.current(), should be the default.
2. Another approach could be adding a parameter to functions like dv.current(caseSensitive = false). Then users can request dv.current(true) to get case sensitive, non-duplicated results. dv.current() would still return the same values. This has to be added to every function which returns case insensitive results. I don't like about this that the default version is case insensitive, but it has to if you want to contain backward compatibility. I think I prefer the previous global approach.

Also, please be aware the current case insensitive implementation is not working fully correctly. Nested tags don't return the duplicated values, they're case sensitive.

-edit-
If you only implement option 1, third party plugin developers like @RafaelGB are still unable to consistently get a non-duplicated list, for example if the user sets it to case insensitive. I think option 2 would be required for that. Please correct me if I'm wrong.

-edit2-
Regarding option 2:
The current approach is not actually case insensitive. For example if your YAML key is camelCase and you want to get its value with CAMELCASE, it's not going to work. A better parameter name for option 2 might be something like incToLowerCase. The default would then be dv.current(incToLowerCase = true).

[RafaelGB]

A third option could be expose another method with the case sensitive and the config of option 2, then you can mark as deprecated the other one.

I was able to apply the solution I shared about obtainColumnsFromRows and it would be solved.

Thanks for your reply