Create tree structure from array of objects with recursion or loop

I wrote this code snippet in Typescript, but the concept is the same in C#. It's by no means the fastest algorithm to do this, but it's simple and readable:

type OrgType = {
    id: number;
    organizationName: string;
    fatherOrganizationId: number;
    subOrganizations: OrgType[];
    isActive: boolean;
}

const orgListFromData = JSON.parse(readFileSync("./data.json", 'utf-8')).list as OrgType[];

/**
 * populate organization object 
 * with child organizations 
 */
const populateOrgWithChildren = (organizationsList: OrgType[], organization: OrgType): OrgType => {

    /**
     * get sub organizations, with their subOrganizations already populated,
     * - gets recursive here -
     */
    const subOrganizations = organizationsList
        .filter(org => org.fatherOrganizationId === organization.id)
        .map(org => populateOrgWithChildren(organizationsList, org));

    /**
     * create a new object and spread properties from original, 
     * to avoid mutating original object trough this mem referenence 
     */
    return {
        ...organization,
        subOrganizations
    }
}

/**
 * populate a list of organizations with
 * their child organizations 
 */
const populateOrgs = (organizationsList: OrgType[]) => {

    const rootOrgs = organizationsList
        .filter(x => x.fatherOrganizationId === null);


    const populatedRootOrgs = rootOrgs
        .map(rootOrg => populateOrgWithChildren(organizationsList, rootOrg));

    return populatedRootOrgs;
}

/**
 * Results
 */
const populated = populateOrgs(orgListFromData);

Hope it helps. Tested it myself, works fine. Something that you might want to pay attention to, is that this task is split in 2 parts: you want to find the "root" organizations, and you want to create a hierarchical structure of the rest of the organizations. This is why I split the code into 2 funcitons, populateOrgWithChildren and populateOrgs. The first being the recursive function that can organize the organizations into a tree under a root organization. The second being the function that finds all the root organizations.

Another solution might be to preprocess your data, and assign every organization with null parent id a parent id of let's say -1, and add a new node called "root" with the id -1. (- to denote that it's not a real id from the DB). After this, you can run only the populateOrgWithChildren on the node that has -1 as it's id, since the whole tree will be of the same structure, there's not going to be null id's anywhere. The resut would be a tree that starts with a single root node, which has a made up id, and all the other organizations would rest under that node.

A little help: TS's .filter() equals to C# (LINQ's) .Where().