Creating immutable class for Node CommonJS module

Question

I'm creating a basic class in a Node project, and I want to test it using Jest. I'm getting an error that is implying the use of 'strict' mode in the test, which I want to avoid/fix

---

~/lib/LogRecord.js

module.exports = class LogRecord {
    constructor(level, message, timestamp) {
        this.level = level;
        this.message = message;
        this.timestamp = timestamp ? timestamp : Date.now();
    }

    get level() {
        return this.level;
    }

    get message() {
        return this.message;
    }

    get timestamp() {
        return this.timestamp;
    }
}

I'm testing it with this:

let LogRecord = require('../lib/logRecord');

describe('Test LogRecord functionality', () => {
    test('LogRecord constructor', () => {
        let timestamp = Date.now();
        let logRecord = new LogRecord('INFO', 'Test Message', timestamp);
        expect(logRecord.level).toBe('INFO');
        expect(logRecord.message).toBe('Test Message');
        expect(logRecord.timestamp).toBe(timestamp);
    });
    test('LogRecord is read-only', () => {
        let timestamp = Date.now();
        let logRecord = new LogRecord('INFO', 'Test Message', timestamp);

        logRecord.level = 'WARN'
        logRecord.message = 'New Message'
        logRecord.timestamp = Date.now();

        expect(logRecord.level).toBe('INFO');
        expect(logRecord.message).toBe('Test Message');
        expect(logRecord.timestamp).toBe(timestamp);
    });
});

When I run npm test I get the following error on both of the LogRecord tests:

Test LogRecord functionality › LogRecord constructor

TypeError: Cannot set property level of #<LogRecord> which has only a getter

  1 | module.exports = class LogRecord {
  2 |     constructor(level, message, timestamp) {
> 3 |         this.level = level;
    |         ^
  4 |         this.message = message;
  5 |         this.timestamp = timestamp ? timestamp : Date.now();
  6 |     }

  at new LogRecord (lib/logRecord.js:3:9)
  at Object.test (test/logRecord.test.js:6:25)

Edit - Working class

const data = new WeakMap();

let levelKey = {id:'level'};
let messageKey = {id:'message'};
let timestampKey = {id:'timestamp'};

module.exports = class LogRecord {
    constructor(level, message, timestamp) {
        data.set(levelKey, level);
        data.set(messageKey, message);
        data.set(timestampKey, timestamp ? timestamp : Date.now());
    }

    get level () {
        return data.get(levelKey)
    }

    get message () {
        return data.get(messageKey)
    }

    get timestamp () {
        return data.get(timestampKey)
    }
}

Answer 1

Testing is about making sure that your code does what you think it does. Consider the following class:

class Foo {
  constructor (bar) {
    this._bar = bar;
  }

  get bar () {
    return this._bar;
  }
}

Here bar is read-only, there is no way to set the bar property:

let foo = new Foo('a foo');
foo.bar; // 'a foo'
foo.bar = 'am not'; // TypeError!

The modules question isn't really relevant: as Logar linked in the comments class bodies are always strict mode irregardless.

So if you want a property to be read only, you don't need to worry about writing it. Workflow might look something like this:

1. Write empty class Foo class Foo {} and construct an instance foo = new Foo()
2. Write test that checks for bar which fails because we have an empty class
3. Add constructor parameter and getter
4. Check that test now passes
5. Add test to ensure that trying to set bar throws expected error*

If you don't want read-only properties you can just add a setter:

class Foo {
  constructor (bar) {
    this._bar = bar;
  }

  get bar () {
    return this._bar;
  }

  set bar (value) {
    this._bar = value;
  }
}

In which case you'd add a test that sets bar and the reads the altered value back out.

* You might be wondering why this test is here when this behavior is guaranteed by the spec and I would argue that the test is necessary since someone could (transparently to the callers) refactor the class to be an old-school constructor and create a vector for bugs:

// post refactor Foo
const Foo = function Foo(bar) {
  this.bar = bar; // danger! now writable!
};

Hopefully this sort of thing would be caught by a knowledgable reviewer, but I'd write the test anyways.

Update

If what you want is a guaranteed read-only property that you set in the constructor, here is a recipe for such:

const data = new WeakMap();

module.exports = class Foo () {
  constructor (bar) {
    data.set(this, bar);
  }

  get bar () {
    return data.get(this);
  }
};

Because data is not exported no outside code can change it. Attempting to set the bar property of an instance will throw. This is a bit more complicated that just defining an underscore property with getters and setters, but if it's what you want, well... I know this pattern because I've used it.

Update 2

You only create one weakmap per module, not per class or instance. The weakmap stores a unique data entry keyed to individual instances (i.e. this):

const data = new WeakMap();

module.exports = {
  Foo: class Foo () {
    constructor (bar) {
      data.set(this, bar);
    }

    get bar () {
      return data.get(this);
    }
  },

  Bar: class Bar () {
    constructor (prop1, prop2) {

      // for multiple props we'll store an object...
      data.set(this, { prop2, prop1 });
    }

    get prop1 () {
      // ...and retrieve it and access it's props to return
      return data.get(this).prop1;
    }

    get prop2 () {
      return data.get(this).prop2;
    }
  }
};

Note that setting the props with a getter but no setter will still throw...

// in someotherfile.js
const { Foo } = require('path/to/file/with/foo.js');
const foo = new Foo('imma foo');
foo.bar; // 'imma foo'
foo.bar = 'no not really'; // TypeError!

// you can still set random properties that don't have a getter:
foo.baz = 'I do not throw';
foo.baz; // 'I do not throw'

Answer 2

If you want your properties to be read only after object initialization, you can use Object.freeze in the constructor, and remove your getters :

class LogRecord {
    constructor(level, message, timestamp) {
        this.level = level;
        this.message = message;
        this.timestamp = timestamp ? timestamp : Date.now();
        Object.freeze(this);
    }
}

But this will freeze all of your object's properties. You won't be able to modify, remove, or add any after that. Didn't dive too deep into this so it may have some flaws as well