Revert "lib: throw from localStorage getter on missing storage path" · nodejs/node@a4dee61

'use strict';

const {

ObjectDefineProperties,

Proxy,

} = primordials;

const { getOptionValue } = require('internal/options');

const { lazyDOMException } = require('internal/util');

const { kConstructorKey, Storage } = internalBinding('webstorage');

const { getValidatedPath } = require('internal/fs/utils');

const kInMemoryPath = ':memory:';

enumerable: true,

get() {

if (lazyLocalStorage === undefined) {

// For consistency with the web specification, throw from the accessor

// if the local storage path is not provided.

const location = getOptionValue('--localstorage-file');

if (location === '') {

throw lazyDOMException(

'Cannot initialize local storage without a `--localstorage-file` path',

'SecurityError',

);

}

let warningEmitted = false;

const handler = {

__proto__: null,

get(target, prop) {

if (!warningEmitted) {

process.emitWarning('`--localstorage-file` was provided without a valid path');

warningEmitted = true;

}

return undefined;

},

set(target, prop, value) {

if (!warningEmitted) {

process.emitWarning('`--localstorage-file` was provided without a valid path');

warningEmitted = true;

}

lazyLocalStorage = new Storage(kConstructorKey, getValidatedPath(location));

return false;

},

};

lazyLocalStorage = new Proxy({}, handler);

} else {

lazyLocalStorage = new Storage(kConstructorKey, getValidatedPath(location));

}

}

return lazyLocalStorage;

const hasQuic = hasCrypto && !!process.features.quic;

const hasLocalStorage = (() => {

try {

return hasSQLite && globalThis.localStorage !== undefined;

} catch {

return false;

}

})();

/**

* Parse test metadata from the specified file.

* @param {string} filename - The name of the file to parse.

'CompressionStream',

'DecompressionStream',

'Storage',

'localStorage',

'sessionStorage',

].forEach((i) => {

if (globalThis[i] !== undefined) {

knownGlobals.add(globalThis.SubtleCrypto);

}

if (hasLocalStorage) {

knownGlobals.add(globalThis.localStorage);

}

const { Worker } = require('node:worker_threads');

knownGlobals.add(Worker);

if (val === 'crypto' && !hasCrypto) {

continue;

}

// globalThis.localStorage is a getter that throws if Node.js was

// executed without a --localstorage-file path.

if (val === 'localStorage' && !hasLocalStorage) {

continue;

}

if (!knownGlobals.has(globalThis[val])) {

leaked.push(val);

}

hasQuic,

hasInspector,

hasSQLite,

hasLocalStorage,

invalidArgTypeHelper,

isAlive,

isASan,

hasQuic,

hasInspector,

hasSQLite,

hasLocalStorage,

hasIntl,

hasIPv6,

isAIX,

hasQuic,

hasInspector,

hasSQLite,

hasLocalStorage,

hasIntl,

hasIPv6,

isAIX,

'use strict';

const { hasCrypto, hasLocalStorage } = require('../common');

const { hasCrypto } = require('../common');

const { test } = require('node:test');

const assert = require('assert');

if (process.stdout.isTTY)

process.env.NODE_DISABLE_COLORS = '1';

test({ skip: !hasCrypto || !hasLocalStorage }, () => {

test('', { skip: !hasCrypto }, () => {

// See https://github.com/nodejs/node/issues/10258

{

const date = new Date('2016');

assert.strictEqual((await readdir(tmpdir.path)).length, 0);

});

test('localStorage throws without --localstorage-file', async () => {

test('localStorage emits a warning when used without --localstorage-file ', async () => {

const cp = await spawnPromisified(process.execPath, [

'-e', 'localStorage',

'-pe', 'localStorage.length',

]);

assert.strictEqual(cp.code, 1);

assert.strictEqual(cp.code, 0);

assert.strictEqual(cp.signal, null);

assert.match(cp.stderr, /SecurityError:/);

assert.match(cp.stderr, /Warning: `--localstorage-file` was provided without a valid path/);

});

test('localStorage is not persisted if it is unused', async () => {