forge-type 1.0.0

package/README.md

@@ -0,0 +1,68 @@
+# TypeForge
+
+TypeForge is a TypeScript utility library that **automatically generates types/interfaces** from backend JSON data.  
+It also supports **enum detection** for short string fields and helps speed up frontend development by reducing boilerplate code.
+
+## Features
+
+- Automatically generate TypeScript interfaces from any JSON data
+- Detects enums for fields like `gender`, `role`, `status`, and more
+- Handles nested objects and arrays
+- Optional modification of existing types
+- Clean, maintainable code generation for frontend teams
+
+## Installation
+
+```bash
+# Scoped package (public)
+npm install type-forge-lib
+
+import { createTypeFromData } from 'type-forge-lib'
+
+const userData = {
+  id: 1,
+  name: 'John Doe',
+  gender: 'male',
+  role: 'admin',
+  status: 'active',
+  friends: [
+    {
+      id: 2,
+      name: 'Jane Smith',
+      age: '24',
+      gender: 'female',
+      city: 'many'
+    }
+  ],
+  profile: {
+    bio: 'I love art',
+    website: 'https://example.com'
+  }
+}
+
+// Generate or update a TypeScript interface
+const result = createTypeFromData('User', userData, { modify: true })
+
+console.log('--- Generated Type ---')
+console.log(result.type)
+
+console.log('--- File Path ---')
+console.log(result.filePath)
+
+export interface User {
+  id: number;
+  name: string;
+  gender: "male" | "female";
+  role: "admin" | "user";
+  status: "active" | "inactive";
+  friends: Friend[];
+  profile: { bio: string; website: string };
+}
+
+export interface Friend {
+  id: number;
+  name: string;
+  age: string;
+  gender: "male" | "female";
+  city: string;
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "forge-type",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "test": "ts-node src/test/test.ts",
+    "clean": "rm -rf dist types/generated"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/node": "^25.0.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/generator/interfaceGenerator.ts

@@ -0,0 +1,121 @@
+import { inferType } from '../infer/inferType'
+import { saveTypeFile, readTypeFile } from '../storage/fileWriter'
+import { capitalize, singularize } from '../utils/opt-func'
+
+const generatedInterfaces = new Set<string>()
+const generatedEnums = new Set<string>()
+const fieldValuesMap: Record<string, Set<string>> = {}
+
+// Fields allowed as enums
+const allowedEnumFields = [
+  'gender', 'role', 'status', 'accountType', 'subscription', 'membership', 'accessLevel',
+  'visibility', 'type', 'priority', 'category',
+  'paymentMethod', 'paymentStatus', 'deliveryStatus',
+  'level', 'mode', 'subscriptionStatus', 'confirmation'
+]
+
+export function generateInterface(
+  name: string,
+  data: any,
+  options?: { modify?: boolean }
+): string {
+  const allInterfaces: string[] = []
+  const enumDefinitions: string[] = []
+
+  function helper(name: string, data: any) {
+    let existingProps: Record<string, string> = {}
+
+    if (options?.modify) {
+      const existingContent = readTypeFile(name)
+      if (existingContent) existingProps = parseInterface(existingContent)
+    }
+
+    const bodyLines: string[] = []
+
+    Object.entries(data).forEach(([key, value]) => {
+      let typeStr = inferType(value, key)
+      const optional = value === null || value === undefined ? '?' : ''
+
+      // Handle nested arrays of objects
+      if (Array.isArray(value) && typeof value[0] === 'object' && value[0] !== null) {
+        const typeName = capitalize(singularize(key))
+        if (!generatedInterfaces.has(typeName)) {
+          generatedInterfaces.add(typeName)
+          helper(typeName, value[0])
+
+          Object.entries(value[0]).forEach(([k, v]) => {
+            if (typeof v === 'string') detectEnum(k, v, enumDefinitions)
+          })
+        }
+        typeStr = `${typeName}[]`
+      }
+
+      // Handle nested objects
+      if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+        typeStr = `{ ${Object.entries(value)
+          .map(([k, v]) => {
+            if (typeof v === 'string') detectEnum(k, v, enumDefinitions)
+            return `${k}: ${inferType(v, k)};`
+          })
+          .join(' ')} }`
+      }
+
+      // Top-level enums
+      if (typeof value === 'string') {
+        const enumType = detectEnum(key, value, enumDefinitions)
+        if (enumType) typeStr = enumType
+      }
+
+      existingProps[key] = typeStr
+      bodyLines.push(`  ${key}${optional}: ${typeStr};`)
+    })
+
+    // Optional fields from existing interface
+    Object.keys(existingProps).forEach(key => {
+      if (!(key in data)) bodyLines.push(`  ${key}?: ${existingProps[key]};`)
+    })
+
+    const content = `export interface ${name} {\n${bodyLines.join('\n')}\n}`
+    allInterfaces.push(content)
+  }
+
+  helper(name, data)
+
+  const finalContent = [...enumDefinitions, ...allInterfaces].join('\n\n')
+  saveTypeFile(name, finalContent)
+
+  return finalContent
+}
+
+function parseInterface(content: string): Record<string, string> {
+  const props: Record<string, string> = {}
+  content.split('\n').forEach(line => {
+    const match = line.trim().match(/^(\w+)\??:\s(.+);$/)
+    if (match) {
+      const [_, key, type] = match
+      if (key && type) props[key] = type
+    }
+  })
+  return props
+}
+
+function detectEnum(key: string, value: string, enumDefinitions: string[]): string | null {
+  if (!allowedEnumFields.includes(key)) return null
+  if (typeof value !== 'string') return null
+
+  if (!fieldValuesMap[key]) fieldValuesMap[key] = new Set()
+  fieldValuesMap[key].add(value)
+
+  const uniqueValues = Array.from(fieldValuesMap[key])
+  if (uniqueValues.length > 1 && uniqueValues.length <= 10) {
+    const typeName = capitalize(key)
+    if (!generatedEnums.has(typeName)) {
+      generatedEnums.add(typeName)
+      const unionType = uniqueValues.map(v => `"${v}"`).join(' | ')
+      enumDefinitions.push(`export type ${typeName} = ${unionType};`)
+    }
+    return typeName
+  }
+
+  return null
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+import { generateInterface } from './generator/interfaceGenerator'
+import { saveTypeFile } from './storage/fileWriter'
+
+export function createTypeFromData(
+  name: string,
+  data: any,
+  options?: { modify?: boolean } // pass { modify: true } to update existing interface
+) {
+  const typeString = generateInterface(name, data, options)
+  const filePath = saveTypeFile(name, typeString) // saves all generated interfaces (including nested)
+
+  return {
+    name,
+    filePath,
+    type: typeString,
+  }
+}

package/src/infer/inferType.ts

@@ -0,0 +1,45 @@
+const generated = new Set<string>()
+
+export function inferType(
+  value: any,
+  key?: string
+): string {
+  if (value === null) return 'null'
+
+  // ARRAY
+  if (Array.isArray(value)) {
+    if (value.length === 0) return 'any[]'
+
+    const first = value[0]
+
+    if (typeof first === 'object' && first !== null) {
+      const typeName = capitalize(singularize(key || 'Item'))
+
+      // Return reference to type name
+      // Generation will be handled in generateInterface
+      return `${typeName}[]`
+    }
+
+    return `${typeof first}[]`
+  }
+
+  // OBJECT
+  if (typeof value === 'object') {
+    // Inline object
+    const entries = Object.entries(value)
+      .map(([k, v]) => `${k}: ${inferType(v, k)};`)
+      .join(' ')
+    return `{ ${entries} }`
+  }
+
+  return typeof value
+}
+
+// Helpers
+function singularize(word: string) {
+  return word.endsWith('s') ? word.slice(0, -1) : word
+}
+
+function capitalize(word: string) {
+  return word.charAt(0).toUpperCase() + word.slice(1)
+}

package/src/storage/fileWriter.ts

@@ -0,0 +1,22 @@
+import fs from 'fs'
+import path from 'path'
+
+export function saveTypeFile(name: string, content: string) {
+  const dir = path.resolve(process.cwd(), 'types/')
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  const filePath = path.join(dir, `${name}.ts`)
+  fs.writeFileSync(filePath, content)
+
+  return filePath
+}
+
+// Add helper to read existing interface
+export function readTypeFile(name: string) {
+  const filePath = path.join(process.cwd(), 'types', `${name}.ts`)
+  if (!fs.existsSync(filePath)) return null
+  return fs.readFileSync(filePath, 'utf-8')
+}

package/src/utils/opt-func.ts

@@ -0,0 +1,9 @@
+// ------------------- Helpers -------------------
+
+export function singularize(word: string) {
+  return word.endsWith('s') ? word.slice(0, -1) : word
+}
+
+export function capitalize(word: string) {
+  return word.charAt(0).toUpperCase() + word.slice(1)
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2020",
+
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}