@sliderzz/typify NPM

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<T>
  - Object patterns → Record<string, any>
  - 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

npm install @sliderzz/typify

Usage

typify <filename>

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

Examples

Basic Function Conversion

Input (example.js):

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

Output (example.ts):

function greet(name: string) {
  return 'Hello ' + name;
}
function calculate(value: number) {
  return value * 2;
}
function processUser(user: Record<string, any>) {
  return user.name;
}

Database Pattern Detection

Input (db-example.js):

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

Output (db-example.ts):

import { Db, Collection } from 'mongodb';

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

Web Pattern Detection

Input (web-example.js):

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):

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<JwtPayload> {
  return jwt.verify(token, process.env.SECRET);
}

React Component Detection

Input (component.js):

function Button(props) {
  return <button>{props.children}</button>;
}

Output (component.tsx):

import { FC } from 'react';

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

Jest Test Patterns

Input (test.js):

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

Output (test.ts):

import { Mock } from 'jest';

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

Webpack Configuration

Input (webpack.config.js):

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

Output (webpack.config.ts):

import { Configuration } from 'webpack';

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