feat: add support for nested objects to fromJSON()

[FlorianLoch]

This adds support for nested object (literals) to fromJSON(). It reads much nicer and makes tests look cleaner (at least that is my personal opinion). One of the features I miss most not being able to use mock-fs.

I added this functionality to fromJSON() itself, one could argue having an additional method like fromNestedJSON() might be better regarding to backward compatibility. I don't think this is a problem at all, but the rather exotic corner case of calling fromJSON() with something like {'dir1': {'dir2'}} just created dir1 so far, but would also create dir2 from now on...

Feedback on this is highly appreciated!

Additionally this fixes a bug (at least I think it's one): so far fromJSON() only took the cwd parameter into account when creating files, not when creating directories.

[G-Rath]

Awesome, this will be cool.

I actually wrote a utility function for this back when I first started using memfs that I meant to pr back, and it looks very similar aside from using the array methods for looping.

I'll include it here if you want to have a look - looking over it I'm pretty sure they're identical in logic 😂

code

import * as path from 'path';

type Contents = string | null;

export interface Directory {
  [key: string]: Directory | Contents;
}

/**
 * Flattens an object representing nested directories, so that it can be used with `memfs`.
 *
 * `memfs` expects a single level JSON object, with directories being represented by slashes.
 * This function generates such an object from a nested object.
 *
 * `root` is the "root" of the dir - by default this is the actual root ('/').
 * You should only have to manually set this if you merge directories, using the spread operator.
 *
 * @example
 *  vol.fromJSON(
 *    flatDirJSON({
 *      dir: {
 *        'file.txt': 'contents'
 *      }
 *    })
 *  );
 *
 * @param {Directory | null} dir
 * @param {string} [root='/']
 *
 * @return {Record<string, string>}
 */
export const flatDirJSON = (dir: Directory | null, root = '/'): Record<string, Contents> => {
  if (dir === null) {
    return { [root]: dir };
  }

  const flattenDir: Record<string, Contents> = {};

  Object.keys(dir).reduce<Array<[string, Contents]>>((files, folderName) => {
    const flattenName = path.posix.join(root, folderName);
    const folderValue = dir[folderName];

    const directory: Array<[string, Contents]> = (
      typeof folderValue !== 'string'
        ? Object.entries(flatDirJSON(folderValue, flattenName))
        : [[flattenName, folderValue]]
    );

    return files.concat(directory);
  }, []).forEach(([name, value]) => flattenDir[name] = value);

  return flattenDir;
};

[streamich]

I wonder if it could be a separate function or a separate library that given nested object keys flattens it?

const data = {
  dir1: {
    file: 'foobar',
  },
};

flattenObject(data);
/*
{
  'dir1/file': 'foobar'
}
*/

[streamich]

@G-Rath ah, you beat me :D

[G-Rath]

you beat me

I think we clicked submit on the same second 😂

I wonder if it could be a separate function or a separate library

I don't have a strong preference - I think it's nice to have fromJSON doing the flattening, but in saying that the function might be a better starting point since otherwise you raise the question of what to do with toJSON.

I feel while it's not a big deal, it's still a deal that fromJSON takes a nested structure (regardless of how it works internally), and then toJSON always returns a flattened one.

Maybe the answer is fromNestedJSON?

---

I did just think of a good question tho: what happens when you pass in an array, since that's an object 😬

[FlorianLoch]

For me the best two options are integrating it into fromJSON() directly or adding a utility function. The first way seems preferential to me, as I think it's quite intuitive to call fromJSON() with a nested object. I actually tried it like that initially before I realized that a flat object is required.
But if you prefer fromNestedJSON() is also fine with me.

Regarding passing an array: well, it will not really work as expected - but that's the case right now too :D
I mean it's JavaScript - passing wrong arguments usually does not fail (gracefully).

[FlorianLoch]

I did some general cleanup to the fromJSON() method - I think its much easier to read now. If I got a little too excited I am sorry ;)

[streamich]

I'm a bit concerned about overloading fromJSON function, maybe we can instead create another method? Like fromNestedJSON:

fromNestedJSON(dir) {
  return this.fromJSON(flatDirJSON(dir));
}

[FlorianLoch]

Ok, I think its more intuitive that way but it's of course your decision ;)
If adding it as extra method, should there be an additional static method on Volume too?
And would you want to expose the (internal) helper flattenDirJSON()?

[streamich]

@FlorianLoch We can do only the static method, without the instance method. Let's not expose flattenDirJSON for now.

[streamich]

Thanks! Looks good, just one questions and a nit see below.

[streamich]

Since we have a similar static method, do we need this one on the instance?

[FlorianLoch]

I just thought it would be more consistent this way two have both methods as static and as member ones.

[streamich]

Thank you!

[streamich]

🎉 This PR is included in version 3.2.0 🎉

The release is available on:

• npm package (@latest dist-tag)
• GitHub release

Your semantic-release bot 📦🚀