Unexpected behavior of name.firstName() function

[TadasPa]

Please help understand behaviour of name.firstName in general, observed when in sequence of name.firstName() I insert new usage of name.lastName() the result of following name.firstName() sequence results starts to differ:

    faker.seed(10);
    faker.name.firstName(), // results Olen
    faker.name.firstName(), // results Eliezer
    faker.name.firstName(), // results Al
    // faker.name.lastName(), // if uncommented following starts to be different
    faker.name.firstName(), // results Jermaine
    faker.name.firstName(), // results Lorena
    faker.name.firstName() // results Imelda

Which seems to be a problem for example in tests if I decide write assertion against "Jermaine" text string, but later extend my model somewhere in the middle. This observation makes me thing that I can't assert to actual string values?

Code sandbox to try it out https://codesandbox.io/s/faker-forked-75kozx?file=/src/index.js

[prisis]

Hey :),

kind of the same problem https://discord.com/channels/929487054990110771/929487054990110779/973169629725851668

Current possible solutions, https://discord.com/channels/929487054990110771/929487054990110779/973350813260984320 and https://discord.com/channels/929487054990110771/929487054990110779/973351060976586792

We will try to discuss this behavior in our faker meeting :)

[ST-DDT]

Just to give you a hint why there is no easy solution to this, please have a look at this example.

const person = {
    firstName: faker.name.firstName(),
    lastName: faker.name.lastName(),
}

Now, lets introduce a middleName:

const person = {
    firstName: faker.name.firstName(),
    middleName: faker.name.firstName(),
    lastName: faker.name.lastName(),
}

Sure enough, the last name changes unexpectedly. So lets assume, we fix faker to handle the lastName method independently from the rest.

So now lets assume that - for whatever reason - the firstName and the middleName generation get swapped.

const middleName = faker.name.firstName();
const person = {
    firstName: faker.name.firstName(),
    middleName,
    middleNameAbbr: middleName.substring(0, 1) + '.',
    lastName: faker.name.lastName(),
}

So the firstName and the middleName both have changed and we all know why, its just something we dont really want.
So whats the problem? The generated values aren't only dependent on the method that generates them, but also their context, unfortunately that will never gets passed to them.

So what is the solution?
For now, you can only separate the faker instance or seed by context.

faker1.seed(seed + 1337);
faker2.seed(seed + 2022);
faker3.seed(seed + 42);
const person = {
    firstName: faker1.name.firstName(),
    middleName: faker2.name.firstName(),
    lastName: faker3.name.lastName(),
}

Or

faker.seed(seed + 1337);
const firstName = ...;
faker.seed(seed + 2022);
const middleName = ...;
faker.seed(seed + 42);
const lastName = ...;

(the magic numbers here are used as randomizers, so firstName and middleName are different from each other)

Now, you can add, rearange or remove methods as you like.

[pavelmickevic]

I wish faker would accept at least an argument of seed:
(else it makes pretty dirty code; imagine creating new instances every time in original example:

import faker from "@faker-js/faker";

faker.seed(10);
...

I suggest something like this:

const person = {
-    firstName: faker1.name.firstName(),
+    firstName: faker({ seed: 1 }).name.firstName(),
-    middleName: faker2.name.firstName(),
+    middleName: faker({ seed: 2 }).name.firstName(),
-    lastName: faker3.name.lastName(),
+    lastName: faker({ seed: 3 }).name.lastName(),
}

here instead of hardcoding the numbers, I can use some constants:

lastName: faker({ seed: MY_LAST_NAME_COLUMN_ID }).name.lastName(),

[ST-DDT]

This might be a good extension for the fork() method I have considered.

const person = {
    firstName: faker.fork({ seed: 1 }).name.firstName(),
    middleName: faker.fork({ seed: 2 }).name.firstName(),
    lastName: faker.fork({ seed: 3 }).name.lastName(),
}

Fork creates a copy of the faker instance and (usually) would retain the same seed and locales.
We could modify it though to allow overwriting some things.
I also considered adding some explicit contextualization to it.

const person = {
    firstName: faker.fork({ context: 'firstName' }).name.firstName(),
    middleName: faker.fork({ context: 2 }).name.firstName(),
    lastName: faker.fork('blub').name.lastName(),
}

And do some magic behind the scenes (current seed + numberize(context) -> new seed).

[pavelmickevic]

instead of method name .fork, I suggest .clone (inspired by momentjs)

[import-brain]

instead of method name .fork, I suggest .clone (inspired by momentjs)

I really like .clone, good suggestion!

[pavelmickevic]

also why the .fork method can be needed?
Maybe better if faker's constructor returns you an individual instance (optionally)?

// traditional use-case
import faker from 'faker'

console.log(firstName: faker.name.firstName()); // no constructor call 
...

const table = [
  { id: 1 }
  { id: 2 }
  { id: 3 }
]

test.each(table)((id) => { // 
  return (
    <tr>
        <td>{ id }
        <td>{ faker({ seed: id }).name.firstName() }
    </tr>
  )
})