@drichdev/genata 1.0.2 → 1.0.5

package/README.md

@@ -2,47 +2,90 @@
 
 A lightweight, secure, and TypeScript-first library for generating realistic fake data for testing, development, and documentation.
 
-## 🚀 Features
+---
+
+## Features
+
+* Simple and intuitive API
+* Batch data generation
+* Reproducible data with seed support
+* Full TypeScript support
+* Built-in validation and sanitization
+* No runtime dependencies except `@faker-js/faker`
+* 25+ data generators
+
+---
+
+## Why Genata?
 
-- **Simple API**: `genata.email()`, `genata.firstName()`, etc.
-- **Batch Generation**: Generate multiple records at once
-- **Seeding Support**: Reproducible data with seed values
-- **Type-Safe**: Full TypeScript support with strict typing
-- **Secure**: Input validation and sanitization built-in
-- **No Dependencies**: Only depends on @faker-js/faker
-- **25+ Data Types**: From emails to credit cards
+* Cleaner and simpler API than typical faker usage
+* Built-in batch generation without extra tooling
+* Consistent seeding across all generators
+* Type-safe by default
+
+---
 
-## 📦 Installation
+## Installation
 
 ```bash
-npm install genata
+npm install @drichdev/genata
 # or
-yarn add genata
+yarn add @drichdev/genata
 # or
-pnpm add genata
+pnpm add @drichdev/genata
 ```
 
-## 🎯 Quick Start
+---
+
+## Import
 
-### Basic Usage
+### ES Modules (recommended)
 
 ```javascript
-import genata from "genata";
+import genata from '@drichdev/genata';
+```
+
+### CommonJS
+
+```javascript
+const genata = require('@drichdev/genata');
+```
+
+### TypeScript
+
+```typescript
+import genata, { type FieldDefinition } from '@drichdev/genata';
+```
+
+---
+
+## Quick Start
+
+```javascript
+import genata from '@drichdev/genata';
 
-// Generate single values
 const email = genata.email();
 const firstName = genata.firstName();
 const phone = genata.phone();
-
-// Generate with options
-const password = genata.password({ length: 20 });
-const randomInt = genata.datatype.integer({ min: 1, max: 100 });
 ```
 
-### Using Generators by Category
+---
+
+## Naming Convention
+
+* Direct API uses camelCase
+  `genata.firstName()`
+
+* Batch generation uses snake_case
+  `type: "first_name"`
+
+---
+
+## Generators
+
+### Person
 
 ```javascript
-// Person generators
 genata.person.firstName();
 genata.person.lastName();
 genata.person.fullName();
@@ -50,46 +93,64 @@ genata.person.email();
 genata.person.username();
 genata.person.password();
 genata.person.phone();
+```
 
-// Location generators
+### Location
+
+```javascript
 genata.location.address();
 genata.location.city();
 genata.location.country();
 genata.location.zipCode();
+```
+
+### Internet
 
-// Internet generators
+```javascript
 genata.internet.url();
 genata.internet.ipv4();
 genata.internet.ipv6();
 genata.internet.creditCard();
+```
 
-// Company generators
+### Company
+
+```javascript
 genata.company.company();
 genata.company.jobTitle();
+```
+
+### Date
 
-// Date generators
+```javascript
 genata.date.date();
 genata.date.dateTime();
 genata.date.futureDate();
+```
+
+### Data Types
 
-// Data type generators
+```javascript
 genata.datatype.uuid();
 genata.datatype.boolean();
 genata.datatype.integer({ min: 0, max: 100 });
 genata.datatype.float({ min: 0, max: 100, decimals: 2 });
 genata.datatype.color();
 genata.datatype.hex({ length: 16 });
+```
 
-// Text generators
+### Text
+
+```javascript
 genata.text.sentence();
 genata.text.paragraph({ sentences: 5 });
 genata.text.word();
 genata.text.slug();
 ```
 
-### Batch Generation
+---
 
-Generate multiple records at once:
+## Batch Generation
 
 ```javascript
 const fields = [
@@ -101,44 +162,22 @@ const fields = [
   { name: "createdAt", type: "datetime" },
 ];
 
-// Generate 100 records (default)
+// Default (100 records)
 const users = genata.generateBatch(fields);
 
-// Generate 1000 records
+// Custom count
 const largeDataset = genata.generateBatch(fields, { count: 1000 });
 
-// With progress tracking
+// With progress
 const data = genata.generateBatchWithProgress(fields, {
   count: 10000,
   onProgress: (progress) => console.log(`${progress}% complete`),
 });
 ```
 
-### Seeding for Reproducible Data
-
-```javascript
-// Set a seed for reproducible results
-genata.setSeed(12345);
-
-const email1 = genata.email(); // Always the same value
-const email2 = genata.email(); // Always the same value
-
-// Reset to random generation
-genata.resetSeed();
-```
-
-## 🔒 Security Features
-
-- **Input Validation**: All options are validated before use
-- **Sanitization**: User inputs are sanitized to prevent injection
-- **Type Safety**: TypeScript strict mode ensures type correctness
-- **Error Handling**: Proper error messages for invalid inputs
-- **No Shell Execution**: No dynamic code execution
-- **Immutable Defaults**: Safe default values that can't be modified
-
-## 📋 Available Field Types
+---
 
-When using batch generation, supported field types are:
+## Supported Field Types
 
 ```
 Person: first_name, last_name, full_name, email, username, password, phone
@@ -146,159 +185,184 @@ Location: address, city, country, zip
 Internet: url, ipv4, ipv6, credit_card
 Company: company, job_title
 Date: date, datetime
-Data Types: uuid, boolean, int, float, number, zero_one, id_increment, color
-Text: sentence, paragraph
+Data Types: uuid, boolean, int, float, number, zero_one, id_increment, color, hex
+Text: sentence, paragraph, word, slug
 ```
 
-## 🎛️ API Reference
+---
+
+## Seeding (Reproducible Data)
+
+```javascript
+genata.setSeed(12345);
+
+const email1 = genata.email();
+const email2 = genata.email();
+
+// Reset randomness
+genata.resetSeed();
+```
+
+---
 
-### Core Methods
+## API Reference
 
-#### `genata.email()`
+### `genata.email()`
 
-Generate a random email address.
+Generate a random email.
 
 ```javascript
 const email = genata.email();
-// "alice.johnson@example.com"
 ```
 
-#### `genata.generateBatch(fields, options?)`
+---
+
+### `genata.generateBatch(fields, options?)`
 
 Generate multiple records.
 
 **Parameters:**
 
-- `fields` (FieldDefinition[]): Array of field definitions
-- `options` (BatchGeneratorOptions?):
-  - `count` (number): Number of records to generate (default: 100)
-  - `seed` (number): Seed for reproducible data
-  - `locale` (string): Locale for faker
+* `fields`: Array of field definitions
+* `options`:
 
-**Returns:** Array of objects with generated data
+  * `count` (default: 100)
+  * `seed`
+  * `locale`
 
-#### `genata.setSeed(seed)`
+**Returns:** Array of objects
 
-Set a seed for reproducible data generation.
+---
 
-**Parameters:**
+### `genata.setSeed(seed)`
 
-- `seed` (number): Non-negative integer seed value
+Set a seed for reproducible results.
 
-#### `genata.resetSeed()`
+---
 
-Reset to random generation without a seed.
+### `genata.resetSeed()`
 
-## 🏗️ Architecture
+Reset random generation.
 
-The library is organized into modules:
+---
 
-- **generators**: Data generation logic (basic, batch, field-level)
-- **types**: TypeScript type definitions
-- **validators**: Input validation and sanitization
-- **utils**: Helper functions (faker initialization)
+## Examples
 
-## 🧪 Testing
+### Generate Users
 
-```bash
-npm test
+```javascript
+const users = genata.generateBatch(
+  [
+    { name: "id", type: "id_increment" },
+    { name: "email", type: "email" },
+    { name: "firstName", type: "first_name" },
+    { name: "lastName", type: "last_name" },
+    { name: "phone", type: "phone" },
+    { name: "company", type: "company" },
+    { name: "jobTitle", type: "job_title" },
+    { name: "createdAt", type: "datetime" },
+  ],
+  { count: 50 }
+);
 ```
 
-## 📄 License
+---
 
-MIT
+### Generate Products
 
-## 🤝 Contributing
+```javascript
+const products = genata.generateBatch(
+  [
+    { name: "id", type: "uuid" },
+    { name: "name", type: "sentence" },
+    { name: "description", type: "paragraph", options: { sentences: 3 } },
+    { name: "price", type: "float", options: { min: 10, max: 1000, decimals: 2 } },
+    { name: "stock", type: "int", options: { min: 0, max: 1000 } },
+    { name: "color", type: "color" },
+  ],
+  { count: 20 }
+);
+```
 
-Contributions are welcome! Please ensure:
+---
 
-- All code is TypeScript
-- Security-first approach
-- Input validation for all public methods
-- Comprehensive error messages
+### Reproducible Tests
 
-## 📚 Examples
+```javascript
+beforeEach(() => {
+  genata.setSeed(42);
+});
 
-### Generate Test Users
+const user1 = { email: genata.email() };
 
-```javascript
-import genata from "genata";
-
-const generateTestUsers = (count = 10) => {
-  return genata.generateBatch(
-    [
-      { name: "id", type: "id_increment" },
-      { name: "email", type: "email" },
-      { name: "firstName", type: "first_name" },
-      { name: "lastName", type: "last_name" },
-      { name: "phone", type: "phone" },
-      { name: "company", type: "company" },
-      { name: "jobTitle", type: "job_title" },
-      { name: "createdAt", type: "datetime" },
-    ],
-    { count }
-  );
-};
-
-const users = generateTestUsers(50);
-console.log(users);
+genata.setSeed(42);
+const user2 = { email: genata.email() };
 ```
 
-### Generate E-commerce Products
+---
 
-```javascript
-const generateProducts = (count = 20) => {
-  return genata.generateBatch(
-    [
-      { name: "id", type: "uuid" },
-      { name: "name", type: "sentence" },
-      { name: "description", type: "paragraph", options: { sentences: 3 } },
-      { name: "price", type: "float", options: { min: 10, max: 1000, decimals: 2 } },
-      { name: "stock", type: "int", options: { min: 0, max: 1000 } },
-      { name: "color", type: "color" },
-    ],
-    { count }
-  );
-};
-```
+## Security
 
-### Reproducible Data for Tests
+* Input validation on all public methods
+* Sanitization of user-provided options
+* No dynamic code execution
+* Safe default values
 
-```javascript
-describe("User Service", () => {
-  beforeEach(() => {
-    genata.setSeed(42);
-  });
-
-  test("should process user data consistently", () => {
-    const user1 = { email: genata.email() };
-    
-    genata.setSeed(42);
-    const user2 = { email: genata.email() };
-
-    expect(user1.email).toBe(user2.email);
-  });
-});
+---
+
+## Architecture
+
+* `generators`: data generation logic
+* `types`: TypeScript definitions
+* `validators`: input validation
+* `utils`: internal helpers
+
+---
+
+## Testing
+
+```bash
+npm test
 ```
 
-## 🐛 Troubleshooting
+---
+
+## Troubleshooting
+
+### Invalid field type
+
+Ensure the field type exists in the supported list.
+
+### Seed not working
 
-### "Invalid field type" error
+Set the seed before generating data and avoid mixing seeded and non-seeded calls.
 
-Make sure you're using a valid field type from the supported list.
+### Performance issues
 
-### Data is not reproducible with seed
+For very large datasets:
 
-Make sure to set the seed before generating data and don't mix generator calls without resetting.
+* Generate in chunks
+* Use progress tracking
+* Consider worker threads in browser environments
 
-### Performance issues with large batches
+---
+
+## Contributing
 
-For very large batches (>100K records), consider:
+* TypeScript only
+* Validate all inputs
+* Maintain strong error handling
+* Follow a security-first approach
 
-- Generating in chunks
-- Using `generateBatchWithProgress` to show progress
-- Running in a worker thread if in browser
 
 ---
 
-Made with ❤️ by Drichdev
+## Documentation
+
+See [USAGE.md](./USAGE.md) for advanced usage.
+
+---
+
+## Author
+
+Created by Drichdev

package/dist/index.d.ts

@@ -7,7 +7,6 @@
  * - genata.person.firstName() - generates a first name
  * - genata.generateBatch([...]) - generates multiple records
  */
-import { PersonGenerators, LocationGenerators, InternetGenerators, CompanyGenerators, DateGenerators, DataTypeGenerators, TextGenerators, generateBatch, generateBatchWithProgress } from "./generators";
 import type { FieldDefinition, BatchGeneratorOptions } from "./types";
 /**
  * Main Genata API
@@ -89,8 +88,5 @@ declare const genata: {
     resetSeed: () => void;
     setLocale: (locale: string) => void;
 };
-export default genata;
-export * from "./types";
-export * from "./validators";
-export { PersonGenerators, LocationGenerators, InternetGenerators, CompanyGenerators, DateGenerators, DataTypeGenerators, TextGenerators, generateBatch, generateBatchWithProgress, };
+export = genata;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,yBAAyB,EAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAItE;;GAEG;AACH,QAAA,MAAM,MAAM;;;;;;yBAOW;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;kBAOnC,CAAC;;;;;;;;;;;;;;;;;;;;;;kBA+C+3C,CAAC;;;;;;;;;eAAq+B,CAAC;eAAa,CAAC;;;eAAkW,CAAC;eAAa,CAAC;oBAAkB,CAAC;;;kBAAwhB,CAAC;;;;;;;qBAA2uB,CAAC;;;;;4BAvCz/H,eAAe,EAAE,YACf,qBAAqB;wCAIvB,eAAe,EAAE,YACf,qBAAqB,GAAG;QAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE;oBAI/D,MAAM;;wBASF,MAAM;CAI3B,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,yBAAyB,GAC1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAItE;;GAEG;AACH,QAAA,MAAM,MAAM;;;;;;yBAOW;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;kBAOnC,CAAC;;;;;;;;;;;;;;;;;;;;;;kBAkCqoD,CAAC;;;;;;;;;eAAq+B,CAAC;eAAa,CAAC;;;eAAkW,CAAC;eAAa,CAAC;oBAAkB,CAAC;;;kBAAwhB,CAAC;;;;;;;qBAA2uB,CAAC;;;;;4BA1B/vI,eAAe,EAAE,YACf,qBAAqB;wCAIvB,eAAe,EAAE,YACf,qBAAqB,GAAG;QAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE;oBAI/D,MAAM;;wBASF,MAAM;CAI3B,CAAC;AAEF,SAAS,MAAM,CAAC"}

package/dist/index.js

@@ -8,32 +8,7 @@
  * - genata.person.firstName() - generates a first name
  * - genata.generateBatch([...]) - generates multiple records
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateBatchWithProgress = exports.generateBatch = exports.TextGenerators = exports.DataTypeGenerators = exports.DateGenerators = exports.CompanyGenerators = exports.InternetGenerators = exports.LocationGenerators = exports.PersonGenerators = void 0;
 const generators_1 = require("./generators");
-Object.defineProperty(exports, "PersonGenerators", { enumerable: true, get: function () { return generators_1.PersonGenerators; } });
-Object.defineProperty(exports, "LocationGenerators", { enumerable: true, get: function () { return generators_1.LocationGenerators; } });
-Object.defineProperty(exports, "InternetGenerators", { enumerable: true, get: function () { return generators_1.InternetGenerators; } });
-Object.defineProperty(exports, "CompanyGenerators", { enumerable: true, get: function () { return generators_1.CompanyGenerators; } });
-Object.defineProperty(exports, "DateGenerators", { enumerable: true, get: function () { return generators_1.DateGenerators; } });
-Object.defineProperty(exports, "DataTypeGenerators", { enumerable: true, get: function () { return generators_1.DataTypeGenerators; } });
-Object.defineProperty(exports, "TextGenerators", { enumerable: true, get: function () { return generators_1.TextGenerators; } });
-Object.defineProperty(exports, "generateBatch", { enumerable: true, get: function () { return generators_1.generateBatch; } });
-Object.defineProperty(exports, "generateBatchWithProgress", { enumerable: true, get: function () { return generators_1.generateBatchWithProgress; } });
 const faker_1 = require("./utils/faker");
 const validators_1 = require("./validators");
 /**
@@ -72,6 +47,4 @@ const genata = {
         (0, faker_1.initializeFaker)({ locale });
     },
 };
-exports.default = genata;
-__exportStar(require("./types"), exports);
-__exportStar(require("./validators"), exports);
+module.exports = genata;

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@drichdev/genata",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "Generate realistic fake data easily",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "module": "dist/index.esm.js",
   "files": [
     "dist"
   ],
@@ -22,7 +21,7 @@
     "testing",
     "data-generator"
   ],
-  "author": "Genata",
+  "author": "Drichdev",
   "license": "MIT",
   "dependencies": {
     "@faker-js/faker": "^10.0.0"