deneric2

Zero-dependency JSON-to-Entity parser with schema support.
Safe, typed, and works with all modern bundlers (Vite, Webpack, Rollup, esbuild).

✨ What's New in v2.0.0

• Zero dependencies — no more lodash, bundle size reduced from 23KB to ~7KB
• Dual CJS/ESM output — works seamlessly with Vite, Webpack, Rollup, and Node.js
• Modern TypeScript — full type declarations for both ESM and CJS consumers

Getting Started

Install

npm install deneric2

yarn add deneric2

Basic Usage

1. Define your schema & class (extend from Deneric)
2. Use fromJson(data) to parse a JSON object into your entity
3. Use toJson() to transform your entity back to a JSON object

API Reference

Deneric

Deneric is an abstract class. Your class must extend it and pass a schema to super().

| Method | Description | | -------------- | ------------------------ | | clone() | Deep clone the instance | | fromJson(json, strict?) | Parse JSON into entity (strict mode by default) | | toJson() | Transform entity to JSON |

Example

import Deneric from 'deneric2'
import type { DenericSchema } from 'deneric2'

const SCHEMA: DenericSchema = {
  fullName: ['profile.full_name', String],
  age: ['profile.age', Number],
}

class User extends Deneric {
  fullName: string = ''
  age: number = 0

  constructor(data?: any) {
    super(SCHEMA)
    this.fromJson(data)
  }
}

DenericSchema

Schema is an object where each key maps to a tuple: [dataPath, dataType, jsonIgnore?, defaultValue?]

| Field | Type | Description | | --------------- | ---------------- | ---------------------------------------------- | | dataPath | string | Dot-notation path to the value in JSON | | dataType | DenericDataType| The expected data type | | jsonIgnore | boolean? | If true, skip this field in toJson() output | | defaultValue | any? | Custom default value |

DenericDataType

| DataType | Description | Example | | ------------------- | ------------------------ | -------------------------------------------- | | String | string | ['path', String] | | Number | number | ['path', Number] | | Boolean | boolean | ['path', Boolean] | | Array | Array of anything | ['path', Array] | | Object | Plain object | ['path', Object] | | Deneric.Array(T) | Typed array | ['path', Deneric.Array(Number)] | | Deneric.Map(T) | Map (Record) of type T | ['path', Deneric.Map(MyClass)] | | Deneric subclass | Nested entity | ['path', MyClass] |

Full Example

Given this JSON:

const json = {
  profile: {
    full_name: 'John Smith',
    age: 12
  },
  others: {
    is_male: true,
    roles: ['admin', 'user']
  },
  jobs: {
    2021: ['Dev', 'Lead'],
    2025: ['CTO']
  }
}

Define your entity:

import Deneric from 'deneric2'

class Student extends Deneric {
  fullName: string = 'noname'
  age: number = -1
  isMale: boolean = false
  roles: string[] = []
  jobs: Record<string, string[]> = {}

  constructor(data?: any) {
    super({
      fullName: ['profile.full_name', String],
      age: ['profile.age', Number],
      isMale: ['others.is_male', Boolean],
      roles: ['others.roles', Deneric.Array(String)],
      jobs: ['jobs', Object],
    })
    this.fromJson(data)
  }
}

const student = new Student(json)
// student.fullName → 'John Smith'
// student.age → 12
// student.roles → ['admin', 'user']

student.toJson()
// → { profile: { full_name: 'John Smith', age: 12 }, others: { is_male: true, roles: ['admin', 'user'] }, jobs: { ... } }

Nested Entities

class ClassRoom extends Deneric {
  monitor!: Student
  students!: Student[]
  mapStudents!: Record<string, Student>

  constructor() {
    super({
      monitor: ['class_monitor', Student],
      students: ['my_student', Deneric.Array(Student)],
      mapStudents: ['map_student', Deneric.Map(Student)]
    })
  }
}

JSON Ignore

class StudentIgnoreJob extends Deneric {
  fullName: string = 'noname'
  jobs: Record<string, string[]> = {}

  constructor(data?: any) {
    super({
      fullName: ['profile.full_name', String],
      jobs: ['jobs', Deneric.Map(Deneric.Array(String)), true] // ignored in toJson()
    })
    this.fromJson(data)
  }
}

const temp = new StudentIgnoreJob(json)
temp.toJson()
// → { profile: { full_name: 'John Smith' } }
// 'jobs' is excluded from output

Strict vs Non-Strict Mode

By default, fromJson uses strict mode — values with wrong types fallback to defaults.

// Strict (default): wrong type → default value
student.fromJson({ profile: { age: '12' } })      // age → -1 (default)

// Non-strict: wrong type → coerced
student.fromJson({ profile: { age: '12' } }, false) // age → 12 (coerced to number)

Migration from v1.x

The public API is 100% backward compatible. No code changes needed in your application.

Changes under the hood:

• lodash is no longer bundled (zero dependencies)
• Output format changed from UMD to dual CJS + ESM
• Proper exports map in package.json for modern bundler compatibility

License

ISC