We Keep Coding

Node script that reads and writes file (readFileSync and writeFileSync) reads the file different on second run

I am writing a node script that automates package updates within a package.json by reading the file, selecting the line with the package and giving the version a bump, and writing the new version of the file.
It runs fine when I run the script the first time. On the second run, readFileSync() gives a very different output, making the script break.
Here is the readFileSync function.
const data = fs.readFileSync("./package.json", {
encoding: "utf8",
});
On the first run, data logs like this:
PS C:\Projects\update-version-test> node updateversion.js
Updating package: webpack , version: patch
data {
"name": "update-version-test",
"version": "1.0.0",
"main": "index.js",
"author": "eendkonijn",
"license": "MIT",
"dependencies": {
"webpack": "^5.8.0"
}
}
The script works as expected, and the webpack package is bumped to 5.8.1. If I run the script again, however, the data logs like this:
PS C:\Projects\update-version-test> node updateversion.js
Updating package: webpack , version: patch
} } "webpack": "^5.8.1"",-test",
The package.json file is intact but somehow readFileSync() doesn't seem to pick it up correctly the second run?
When I make a manual change, the script seems to be working again. But only the one time.
I have a reproduction here:
https://github.com/eendkonijn/update-version-test

The problem is that you're trying to parse the json file using .split("\n") and later you assemble the resulting json content using .join(""). In the resulting file there will be no more line-breaks which is why your code does not work the second time.
Instead of manually parsing the json content, just parse it using JSON.parse, manipulate the webpack-property and finally overwrite the file content with the output of JSON.stringify. E.g:
const rawData = fs.readFileSync('./package.json', {
encoding: 'utf8',
});
const parsedData = JSON.parse(rawData);
parsedData.dependencies.webpack = 'callFunctionToManipulateTheVersionHere()';
fs.writeFileSync('./package.json', JSON.stringify(parsedData, null, 4));

Unexpected token v in JSON at position 0 Node.js

I'm developing code in php, in app engine flexible environment. I'm trying to set up the SDK Admin, web version, for Firebase.
Currently, I'm just struggling with the following code:
$.ajax({
type: 'GET',
url: "prueba.js",
dataType: 'json'
}).done(function(res){
console.log("Todo bien!");
}).fail(function(jqXHR,textStatus,err){
console.log(err);
});
Aforementioned code is calling through AJAX the following code (that is, 'prueba.js'):
var admin = require(firebase-admin');
var serviceAccount = require('path/to/json-key.json');
admin.initializeApp({
credential: admin.credential.cert(serviceAccount),
databaseURL: 'https://<database>.firebaseio.com'
});
These code throws the exception:
SyntaxError: Unexpected token v in JSON at position 0
at JSON.parse (<anonymous>)
at n.parseJSON (jquery.min.js:4)
at ub (jquery.min.js:4)
at x (jquery.min.js:4)
at XMLHttpRequest.<anonymous> (jquery.min.js:4)
...and last but not least, the folder and files organisation:
'node_modules', containing firebase-admin, is located in the root folder ('web'), along with index.js, package.json and package-lock.json
Prueba.html and prueba.js are located in the path 'web/asg/trm/admin'
package.json in the 'web' folder holds the following code:
{
"name": "web",
"version": "1.0.0",
"description": "",
"main": "index.js",
"dependencies": {
"firebase-admin": "^6.0.0"
},
"devDependencies": {},
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}
'index.js', on the opposite hand, does not contain any code.
I have tested the following:
In 'require' (in 'prueba.js'), I've been juggling with different locations for the 'node_modules' folder (pointing directly to the 'package.json' comprised in 'firebase-admin' as well).
Due to my short experience in Node.js, I've been spending the last two days trying to make ends meet, with no success. So any kind help would be more than welcome!
Many thanks in advance!

url: "prueba.js",
dataType: 'json'
You're asking for a JavaScript file, but telling jQuery to parse it as JSON.
This is the first line of that JavaScript file:
var admin = require(firebase-admin');
… that the first character in it is the v that is being reported as an unexpected token. JSON cannot start with a v, but as mentioned what you have is not JSON.
It isn't client-side JavaScript either, it looks like it is intended to be part of a server-side program run on Node.js, which you said you were trying to use.
For some reason, you aren't running it using Node.js at all, but are delivering the source code to the web browser.
You could write your server-side program as a web service (the express library is popular for this) and then run it with Node.js. You should then set the url to be the URL of the end point you create with that.

How to load all dependency of urijs by rquirejs config?

I want to include this library for use https://github.com/medialize/URI.js/tree/master
I have added it to bower.json
{
"name": "my-project",
"version": "1.0.0",
"dependencies": {
"urijs": "~1.16.1"
}
...
}
When I load my project in a browser, I got these error:
These scripts are all part of the urijs project. You can find them here: https://github.com/medialize/URI.js/tree/master/src
I would like to be able to resolve by requirejs configuration alone with minimal change (i.e. hopefully do not need to specify each dependent script indiviudally). What is the easiest way to define the dependency?
Is it possible? If so, how?
At the end I can resolve it by creating the final artefact and hosted the outcome in a forked project. I am hoping for a more elegant and/or simpler solution.

Looks like URI.js sets up a universal module loader that should work with RequireJS. It doesn't look like you have to reference every script in your config. Make your RequireJS config file look like their readme.md:
require.config({
paths: {
urijs: 'where-you-put-uri.js/src'
}
});
require(['urijs/URI'], function(URI) {
console.log("URI.js and dependencies: ", URI("//amazon.co.uk").is('sld') ? 'loaded' : 'failed');
});
require(['urijs/URITemplate'], function(URITemplate) {
console.log("URITemplate.js and dependencies: ", URITemplate._cache ? 'loaded' : 'failed');
});

Node-Red Editor and Library dependencies?

I'm in the process to create my first Node-RED contribution. The node will clean an incoming object based on a sample object provided in the editor. I'm using the RED.editor and the RED.library.
I'm wondering if I need to declare a dependency in my package file. Currently it looks like this:
{
"name" : "node-red-contrib-objectcleaner",
"version" : "0.0.1",
"description" : "Removes properties from incoming (payload) object, that are not in a template object",
"dependencies": { /*Do I need anything here? */
},
"keywords": [ "node-red", "validation", "flow" ],
"node-red" : {
"nodes": {
"objectcleaner": "objectcleaner/objectcleaner.js"
}
}
}
What, if anything, goes into the dependencies? I know I will put node.js dependencies there, but do I need to list the editor/library?

You'll probably do better asking questions like this on the mailing list here:
https://groups.google.com/forum/#!forum/node-red
You shouldn't need to list Node-RED in the dependencies as this will just pull in another copy into the node_modules tree.
You should be fine just using the reference to RED object that is passed in when the node is initialised

Updating file references in a json file via a grunt task

I'm a JavaScript developer and fairly new to creating a build process from scratch. I chose to use Grunt for my current project and have created a GruntFile that does about 90% of what I need it to do and it works great, except for this one issue. I have several JavaScript files that I reference while I'm developing a chrome extension in the manifest.json file. For my build process I am concatenating all of these files and minifying it into one file to be included in manifest.json. Is there anyway to update the file references in the manifest.json file during the build process so it points to the minified version?
Here is a snippet of the src manifest file:
{
"content_scripts": [{
"matches": [
"http://*/*"
],
"js": [
"js/lib/zepto.js",
"js/injection.js",
"js/plugins/plugin1.js",
"js/plugins/plugin2.js",
"js/plugins/plugin3.js",
"js/injection-init.js"
]
}],
"version": "2.0",
}
I have a grunt task that concatenates and minifies all the js files listed above into one file called injection.js and would like a grunt task that can modify the manifest file so it looks like this:
{
"content_scripts": [{
"matches": [
"http://*/*"
],
"js": [
"js/injection.js"
]
}],
"version": "2.0",
}
What I've done for now is have 2 versions of the manifest file, one for dev and one for build, during the build process it copies the build version instead. This means I need to maintain 2 versions which I'd rather not do. Is there anyway to do this more elegantly with Grunt?

Grunt gives its own api for reading and writing files, i feel that better than other dependencies like fs:
Edit/update json file using grunt with command grunt updatejson:key:value after putting this task in your gruntjs file
grunt.registerTask('updatejson', function (key, value) {
var projectFile = "path/to/json/file";
if (!grunt.file.exists(projectFile)) {
grunt.log.error("file " + projectFile + " not found");
return true;//return false to abort the execution
}
var project = grunt.file.readJSON(projectFile);//get file as json object
project[key]= value;//edit the value of json object, you can also use projec.key if you know what you are updating
grunt.file.write(projectFile, JSON.stringify(project, null, 2));//serialize it back to file
});

I do something similar - you can load your manifest, update the contents then serialize it out again. Something like:
grunt.registerTask('fixmanifest', function() {
var tmpPkg = require('./path/to/manifest/manifest.json');
tmpPkg.foo = "bar";
fs.writeFileSync('./new/path/to/manifest.json', JSON.stringify(tmpPkg,null,2));
});

I disagree with the other answers here.
1) Why use grunt.file.write instead of fs? grunt.file.write is just a wrapper for fs.writeFilySync (see code here).
2) Why use fs.writeFileSync when grunt makes it really easy to do stuff asynchronously? There's no doubt that you don't need async in a build process, but if it's easy to do, why wouldn't you? (It is, in fact, only a couple characters longer than the writeFileSync implementation.)
I'd suggest the following:
var fs = require('fs');
grunt.registerTask('writeManifest', 'Updates the project manifest', function() {
var manifest = require('./path/to/manifest'); // .json not necessary with require
manifest.fileReference = '/new/file/location';
// Calling this.async() returns an async callback and tells grunt that your
// task is asynchronous, and that it should wait till the callback is called
fs.writeFile('./path/to/manifest.json', JSON.stringify(manifest, null, 2), this.async());
// Note that "require" loads files relative to __dirname, while fs
// is relative to process.cwd(). It's easy to get burned by that.
});