Research
Security News
Malicious npm Packages Inject SSH Backdoors via Typosquatted Libraries
Socket’s threat research team has detected six malicious npm packages typosquatting popular libraries to insert SSH backdoors.
properties-file
Advanced tools
The properties-file npm package allows you to read, write, and manipulate .properties files, which are commonly used for configuration settings in Java applications. This package provides a simple API to handle these files in a Node.js environment.
Read properties file
This feature allows you to read a .properties file and parse its contents into a JavaScript object. The `read` method takes the file path as an argument and returns an object with key-value pairs.
const properties = require('properties-file');
const config = properties.read('config.properties');
console.log(config);
Write properties file
This feature allows you to write a JavaScript object to a .properties file. The `write` method takes the file path and the object to be written as arguments.
const properties = require('properties-file');
const config = { key1: 'value1', key2: 'value2' };
properties.write('config.properties', config);
Update properties file
This feature allows you to update an existing .properties file. You can read the file into a JavaScript object, modify the object, and then write it back to the file.
const properties = require('properties-file');
let config = properties.read('config.properties');
config.key3 = 'value3';
properties.write('config.properties', config);
The properties-reader package provides similar functionality for reading and manipulating .properties files. It offers a more fluent API for accessing properties and supports nested properties. Compared to properties-file, it may be more user-friendly for complex configurations.
The node-properties package is another alternative for handling .properties files. It provides basic read and write capabilities but lacks some of the advanced features found in properties-file. It is a simpler option for straightforward use cases.
The config package is a more comprehensive solution for managing configuration files in Node.js applications. It supports multiple file formats, including .properties, JSON, and YAML. While it offers more features, it may be overkill for simple .properties file manipulation.
.properties
file parser, editor, formatter and Webpack loader.
⚠ In April 2023, we released version 3 of this package, which includes breaking changes. Please refer to the migration guide before upgrading.
Add the package as a dependency:
npm install properties-file
getProperties
converts the content of .properties
files to a key-value pair object.Properties
class provides insights into parsing data.PropertiesEditor
class enables the addition, edition, and removal of entries.escapeKey
and escapeValue
allow the conversion of any content to a .properties
compatible format..properties
files directly into your application..properties
packages have been inactive for years).We have put a lot of effort into incorporating TSDoc into all our APIs. If you are unsure about how to use certain APIs provided in our examples, please check directly in your IDE.
getProperties
(converting .properties
to an object)The most common use case for .properties
files is for Node.js applications that need to read the file's content into a simple key-value pair object. Here is how this can be done with a single API call:
import { readFileSync } from 'node:fs'
import { getProperties } from 'properties-file'
console.log(getProperties(readFileSync('hello-world.properties')))
Output:
{ hello: 'hello', world: 'world' }
Properties
(using parsing metadata)The Properties
object is what makes getProperties
work under the hood, but when using it directly, you can access granular parsing metadata. Here is an example of how the object can be used to find key collisions:
import { Properties } from 'properties-file'
const properties = new Properties(
'hello = hello1\nworld = world1\nworld = world2\nhello = hello2\nworld = world3'
)
console.log(properties.format())
/**
* Outputs:
*
* hello = hello1
* world = world1
* world = world2
* hello = hello2
* world = world3
*/
properties.collection.forEach((property) => {
console.log(`${property.key} = ${property.value}`)
})
/**
* Outputs:
*
* hello = hello2
* world = world3
*/
const keyCollisions = properties.getKeyCollisions()
keyCollisions.forEach((keyCollision) => {
console.warn(
`Found a key collision for key '${
keyCollision.key
}' on lines ${keyCollision.startingLineNumbers.join(
', '
)} (will use the value at line ${keyCollision.getApplicableLineNumber()}).`
)
})
/**
* Outputs:
*
* Found a key collision for key 'hello' on lines 1, 4 (will use the value at line 4).
* Found a key collision for key 'world' on lines 2, 3, 5 (will use the value at line 5).
*/
For purposes where you require more parsing metadata, such as building a syntax highlighter, it is recommended that you access the Property
objects included in the Properties.collection
. These objects provide comprehensive information about each key-value pair.
PropertiesEditor
(editing .properties
content)In certain scenarios, it may be necessary to modify the content of the .properties
key-value pair objects. This can be achieved easily using the Properties
object, with the assistance of the escapeKey
and escapeValue
APIs, as demonstrated below:
import { Properties } from 'properties-file'
import { escapeKey, escapeValue } from 'properties-file/escape'
const properties = new Properties('hello = hello\n# This is a comment\nworld = world')
const newProperties: string[] = []
properties.collection.forEach((property) => {
const key = property.key === 'world' ? 'new world' : property.key
const value = property.value === 'world' ? 'new world' : property.value
newProperties.push(`${escapeKey(key)} = ${escapeValue(value)}`)
})
console.log(newProperties.join('\n'))
/**
* Outputs:
*
* hello = hello
* new\ world = new world
*/
The limitation of this approach is that its output contains only valid keys, without any comments or whitespace. However, if you require a more advanced editor that preserves these original elements, then the PropertiesEditor
object is exactly what you need.
import { PropertiesEditor } from 'properties-file/editor'
const properties = new PropertiesEditor('hello = hello\n# This is a comment\nworld = world')
console.log(properties.format())
/**
* Outputs:
*
* hello = hello
* # This is a comment
* world = world
*/
properties.insertComment('This is a multiline\ncomment before `newKey3`')
properties.insert('newKey3', 'This is my third key')
properties.insert('newKey1', 'This is my first new key', {
referenceKey: 'newKey3',
position: 'before',
comment: 'Below are the new keys being edited',
commentDelimiter: '!',
})
properties.insert('newKey2', 'こんにちは', {
referenceKey: 'newKey1',
position: 'after',
escapeUnicode: true,
})
properties.delete('hello')
properties.update('world', {
newValue: 'new world',
})
console.log(properties.format())
/**
* Outputs:
*
* # This is a comment
* world = new world
* ! Below are the new keys being edited
* newKey1 = This is my first new key
* newKey2 = \u3053\u3093\u306b\u3061\u306f
* # This is a multiline
* # comment before `newKey3`
* newKey3 = This is my third key
*/
For convenience, we also added an upsert
method that allows updating a key if it exists or adding it at the end, when it doesn't. Make sure to check in your IDE for all available methods and options in our TSDoc.
If you would like to import .properties
directly using import
, this package comes with its own Webpack file loader located under properties-file/webpack-loader
. Here is an example of how to configure it:
// webpack.config.js
module.exports = {
module: {
rules: [
{
test: /\.properties$/i,
use: [
{
loader: 'properties-file/webpack-loader',
},
],
},
],
},
}
As soon as you configure Webpack, the .properties
type should be available in your IDE when using import
. If you ever need to add it manually, you can add a *.properties
type declaration file at the root of your application, like this:
// properties-file.d.ts
declare module '*.properties' {
const properties: { readonly [key: string]: string };
export default properties;
}
By adding these configurations you should now be able to import directly .properties
files just like this:
import helloWorld from './hello-world.properties'
console.dir(helloWorld)
Output:
{ "hello": "world" }
.properties
file package?There are probably over 20 similar packages available, but:
Unfortunately, the .properties
file specification is not well-documented. One reason for this is that it was originally used in Java to store configurations. Today, most applications handle this using JSON, YAML, or other modern formats because these formats are more flexible.
.properties
files?While many options exist today to handle configurations, .properties
files remain one of the best options to store localizable strings (also known as messages). On the Java side, PropertyResourceBundle
is how most implementations handle localization today. Because of its simplicity and maturity, .properties
files remain one of the best options today when it comes to internationalization (i18n):
File format | Key/value based | Supports inline comments | Built for localization | Good linguistic tools support |
---|---|---|---|---|
.properties | Yes | Yes | Yes (Resource Bundles) | Yes |
JSON | No (can do more) | No (requires JSON5) | No | Depends on the schema |
YAML | No (can do more) | Yes | No | Depends on the schema |
Having good JavaScript/TypeScript support for .properties files offers more internationalization (i18n) options.
Basically, our goal was to offer parity with the Java implementation, which is the closest thing to a specification for .properties
files. Here is the logic behind this package in a nutshell:
Property
objects that:
Just like Java, if a Unicode-escaped character (\u
) is malformed, an error will be thrown. However, we do not recommend using Unicode-escaped characters, but rather using UTF-8 encoding that supports more characters.
Properties
class documentationPropertyResourceBundle
documentationThanks to @calibr, the creator of properties-file version 1.0, for letting us use the https://www.npmjs.com/package/properties-file package name. We hope that it will make it easier to find our package.
FAQs
.properties file parser, editor, formatter and Webpack loader.
The npm package properties-file receives a total of 218,698 weekly downloads. As such, properties-file popularity was classified as popular.
We found that properties-file demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket’s threat research team has detected six malicious npm packages typosquatting popular libraries to insert SSH backdoors.
Security News
MITRE's 2024 CWE Top 25 highlights critical software vulnerabilities like XSS, SQL Injection, and CSRF, reflecting shifts due to a refined ranking methodology.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.