typify

A command-line tool to convert JavaScript files to TypeScript with automatic type inference.

Features

- Converts JavaScript files to TypeScript by just running the command.
- Automatically infers basic types for function parameters
- Converts var declarations to let or const
- Transforms CommonJS require() to ES6 import statements
- Preserves existing code structure and comments
- Smart type inference for common patterns:
- Core Patterns:
- Basic types (string, number, boolean)
- Array methods → Array
- Object patterns → Record
- Error handling → Error | null
- Web Development:
- Express (Request, Response, NextFunction)
- Socket.IO (Socket, Server)
- JWT (JwtPayload)
- React (FC, ReactNode)
- Webpack (Configuration)
- Axios (AxiosInstance, AxiosResponse)
- Databases:
- MongoDB (Db, Collection, Document)
- Mongoose (Model, Schema)
- SQL (Connection, Pool, Query)
- Testing:
- Jest (Mock, SpyInstance)
- Utilities:
- Lodash (LoDashStatic)
- Date handling (Date/string/number)
- Validation (Joi/Yup schemas)
- Node.js FS (typeof fs)
- Cloud/Infra:
- AWS SDK (S3, DynamoDB)
- Node.js streams (Readable/Writable)

Installation

``bash
npm install @sliderzz/typify
`

Usage

`bash
typify
`

This will create a new TypeScript file (filename.ts) in the same directory.

Examples

$3

Input (example.js):

`javascript
function greet(name) {
return 'Hello ' + name;
}
function calculate(value) {
return value * 2;
}
function processUser(user) {
return user.name;
}
`

Output (example.ts):

`typescript
function greet(name: string) {
return 'Hello ' + name;
}
function calculate(value: number) {
return value * 2;
}
function processUser(user: Record) {
return user.name;
}
`

$3

Input (db-example.js):

`javascript
async function findUsers(db, query) {
const collection = db.collection('users');
return collection.find(query);
}
`

Output (db-example.ts):

`typescript
import { Db, Collection } from 'mongodb';

async function findUsers(db: Db, query: Record) {
const collection: Collection = db.collection('users');
return collection.find(query);
}
`

$3

Input (web-example.js):

`javascript
function handleSocket(socket) {
socket.on('message', (data) => {
socket.emit('response', data);
});
}

async function verifyToken(token) {
return jwt.verify(token, process.env.SECRET);
}
`

Output (web-example.ts):

`typescript
import { Socket } from 'socket.io';
import { JwtPayload } from 'jsonwebtoken';

function handleSocket(socket: Socket) {
socket.on('message', (data: any) => {
socket.emit('response', data);
});
}

async function verifyToken(token: string): Promise {
return jwt.verify(token, process.env.SECRET);
}
`

$3

Input (component.js):

`javascript
function Button(props) {
return {props.children};
}
`

Output (component.tsx):

`typescript
import { FC } from 'react';

const Button: FC<{ children?: ReactNode }> = (props) => {
return {props.children};
};
`

$3

Input (test.js):

`javascript
test('user login', async (mock) => {
const user = mock.user.create();
await user.login();
});
`

Output (test.ts):

`typescript
import { Mock } from 'jest';

test('user login', async (mock: jest.Mock) => {
const user = mock.user.create();
await user.login();
});
`

$3

Input (webpack.config.js):

`javascript
module.exports = (env) => ({
entry: './src/index.js',
mode: env.production ? 'production' : 'development',
});
`

Output (webpack.config.ts):

`typescript
import { Configuration } from 'webpack';

export default (env: Record): Configuration => ({
entry: './src/index.js',
mode: env.production ? 'production' : 'development',
});
`

Type Inference Improvements

$3

- Detects props/state parameters
- Adds FC type with children prop
- Infers component return types

$3

- Recognizes Jest mock functions
- Types test/mock parameters
- Adds proper async test typing

$3

- AWS service client detection (S3, DynamoDB)
- Node.js stream type inference

$3

- Detects error/err parameters
- Adds Error | null union type
- Infers try/catch error types

$3

- Recognizes MongoDB collection patterns
- Types Mongoose models and schemas
- Infers SQL connection pools

$3

- Detects Axios instance usage
- Types fetch API parameters
- Infers response data shapes

Limitations

- Complex generic types may need manual annotation
- AWS SDK v2 requires separate @types/aws-sdk`
- Custom Express middleware types might need refinement
- Axios interceptors may require additional typing
- Date format detection has basic pattern matching

Do try it out! I'm always looking for feedback and suggestions.
Or let's collaborate for any cool stuff!
Reach out to me on linkedin