Type assignment in Typescript

The essence of the problem lies in misunderstanding string literals, the limitations of type inferencing and duck typing. That is quite a lot, but I will try to explain it bit by bit.

Duck Typing

"If it walks like a duck and it quacks like a duck, then it must be a duck."

One of the nice things in Typescript that you do not need to instantiate a class in order for it to adhere to an interface.

interface Bird {
   featherCount: number
}

class Duck implements Bird {
    featherCount: number;
    constructor(featherInHundreds: number){
        this.featherCount = featherInHundreds * 100;
    }
}

function AddFeathers(d1: Bird, d2: Bird) {
   return d1.featherCount + d2.featherCount;
}

// The objects just need to have the same structure as the
// expected object. There is no need to have 
AddFeathers(new Duck(2), {featherCount: 200});

This creates a lot of flexibility in the language. Flexibility you are using in the map function. You either create an entirely new object where you adjust some things or you adjust the existing dataFile. In this case that might easily be solved by creating a constructor or method that returns a new class. If there are a lot of transformations this might lead to very large classes.

Type Inferencing

However this flexibility comes at a cost in certain cases. Typescript needs to be able to infer the type, but in this case that goes wrong. When you create the new object, the type property is perceived as a string not the template literal "unknown". This exposes two problems in your code.

1. The type property can only contain a single value "unknown" because it is typed as a string literal with just one value as opposed to a union of multiple literals. The type should at least have the type of "unknown" | "csv" for this value to work. However I expect that this is just a problem in this example since adding the <Array<DataFileLoadingInstructionType>> seems to solve the problem for you, while in this example it would break the example.
2. But even if you would adjust this or pass the only allowed value "unknown" here it would still complain. This is how Typescript infers types, since you just assign a value here, it presumes that it is the more generic string as opposed to the more narrow literal "csv".

Solution

The trick is helping Typescript type the object you are creating. My suggestion would be to assert the type of the property type, so that Typescript knows that the string assignment is actually a string literal.

Example

import {
    Literal,
    Number,
    Partial as RTPartial,
    Record,
    Static,
    String,
    Union,
} from "runtypes";
import * as path from "path";

// Create separate type, so that we don't need to assert the type inline.
type FileTypes = "unknown" | "csv"

const UnknownDataFileLoadingInstructionTypeOptions = Record({
    type: Literal<FileTypes>("unknown"),
});

export const DataFileLoadingInstructionType = Record({ file_path: String })
    .And(
        RTPartial({
            file_info: String,
            file_name_suffix: String,
            // Threw an error, commented it out for now.
            // command_parameters: Array(String),
        })
    )
    .And(Union(UnknownDataFileLoadingInstructionTypeOptions));

export type DataFileLoadingInstructionType = Static<
    typeof DataFileLoadingInstructionType
>;



type DataFile = {
    file_path: string;
    type: FileTypes;
};

const originalDataFiles: Array<DataFile> = [];
originalDataFiles.push({ file_path: "myFile.txt", type: "unknown" });

let dataFiles: Array<DataFileLoadingInstructionType>;

async function convertPathIfLocal(dataFile: string) {
    if (dataFile.indexOf("://") === -1 && !path.isAbsolute(dataFile)) {
        dataFile = path.join("my_dir/", dataFile);
    }
    return dataFile;
}

(async () => {
    //here, I have to add <Array<DataFileLoadingInstructionType>> to work
    dataFiles = await Promise.all(
        originalDataFiles
            .filter((f) => f !== undefined)
            .map(async (dataFile) => {
                if (typeof dataFile === "string") {
                    return {
                        file_path: await convertPathIfLocal(dataFile),
                        header_line: 0,
                        sheets: [],
                        type: "csv" as FileTypes,
                    };
                } else {
                    dataFile.file_path = await convertPathIfLocal(dataFile.file_path);
                    return dataFile;
                }
            })
    );

    console.log(
        `OUTPUT: ${JSON.stringify(
            dataFiles
        )} - type of dataFiles: ${typeof dataFiles}`
    );
})();