Security News
Research
Data Theft Repackaged: A Case Study in Malicious Wrapper Packages on npm
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
camelize-ts
Advanced tools
A typescript typed camelCase function that recursively camel cases a snake cased or pascal cased object structure. It camel cases a simple string too, if you need that.
camelize-ts
is snakify-ts
’ twin 👯.
This has obviously been done before, and the "new" thing with this pacakge is not camel casing itself but the fact that it is a generic that, given the form of the input data structure, will provide you with typing for the returned object structure so that it fits with other types.
As an example I've been using it to camelize PostgreSQL rows (returned with snake case) before passing them to other functions in our GraphQL server (using camel cased property names).
import camelize from 'camelize-ts'
// Expects camel case
function nameIt({
firstName,
lastName
}: {
id: number,
firstName: string,
lastName: string,
roles: string[]
}) { return `${firstName} ${lastName}` }
// camel case snake_cased stuff from postgres
const camelizedUser = camelize({
id: 1,
first_name: 'Grim',
last_name: 'Reaper',
roles: ['user', 'admin']
})
console.log(JSON.stringify(camelizedUser, null, 2))
console.log(nameIt(camelizedUser)
output:
{
"id": 1,
"firstName": "Grim",
"lastName": "Reaper",
"roles": [
"user",
"admin"
]
}
Grim Reaper
It also converts pascal cased object fields to camel case.
import camelize from 'camelize-ts'
const camelizedUser = camelize({
Id: 1,
first_name: 'Grim',
last_name: 'Reaper',
greetings: {
Morning: 'Good morning!',
Night: 'Good night!'
},
roles: ['user', 'admin'],
UpdatedAt: '2000-01-01T00:00:00.000Z'
})
console.log(JSON.stringify(camelizedUser, null, 2))
output:
{
"id": 1,
"firstName": "Grim",
"lastName": "Reaper",
"greetings": {
"morning": "Good morning!",
"night": "Good night!"
},
"roles": [
"user",
"admin"
],
"updatedAt": "2000-01-01T00:00:00.000Z"
}
By default camelize will traverse to the bottom of the object/array structure you pass. If you want to perform a shallow camelize, touching only the top level of the value you can pass true for the shallow
option (second argument).
You don't need to pass a type to camelize
since it uses argument inference to find the type to convert. But if you need to, you can pass a type like this:
camelize<
// type of value to camelize
{ first_name: string },
// whether or not to perform shallow camelization
true
>(
// value to camelize, type must match the specified type
value,
// shallow, must match what's set as the second type argument above (after the type)
true
)
If you need to convert just a type, you can use the Camelize
generic type to do this:
import { Camelize } from 'camelize-ts'
type MySnakePerson = { first_name: string }
type MyCamelPerson = Camelize<MySnakePerson>
npm run test // one time/CI
npm run test:watch // on each file change
MIT
FAQs
Recursive camel casing of object property names with proper typing
We found that camelize-ts demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 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.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.
Security News
The Ultralytics' PyPI Package was compromised four times in one weekend through GitHub Actions cache poisoning and failure to rotate previously compromised API tokens.