oriid
Version:
Oriid – Ultra-Fast, Collision-Free Unique ID Generator
129 lines (87 loc) • 4.65 kB
Markdown
**Oriid** is a blazing-fast, high-throughput JavaScript library for generating **unique, 10-character alphanumeric IDs** at a rate of **20 million+ per second**, using only the characters `a-z`, `A-Z`, and `0-9`.
Traditional ID generators like MongoDB’s ObjectId or MySQL’s AUTO_INCREMENT come with limitations:
| Feature | Oriid | MongoDB ObjectId | MySQL Auto ID |
|--------------------------|-------------|------------------|----------------|
| Custom length | ✅ Yes (10+) | ❌ Fixed (24 hex) | ❌ Fixed-size integers |
| URL-safe / Alphanumeric | ✅ Yes | ❌ Hex only | ❌ Numeric only |
| High throughput | ✅ 20M/sec+ | ⚠️ Limited | ⚠️ Risk of lock contention |
| No DB dependency | ✅ Yes | ❌ Tied to MongoDB| ❌ Tied to RDBMS |
| Collision resistant | ✅ Yes | ✅ Yes | ❌ Needs locking |
| Sortable (time-based) | ✅ Optional | ✅ Yes | ✅ Yes |
| Works offline | ✅ Yes | ❌ No | ❌ No |
| Distributed-safe | ✅ Yes | ⚠️ Needs config | ❌ Hard to scale |
✅ Key Benefits
- **10+ character compact IDs**
- **Base62 encoding** (a–z, A–Z, 0–9)
- **No external dependencies**
- **No collisions**, even under extreme load
- **Perfect for distributed systems**
- **Fast enough for real-time analytics, logs, and microservices**
```bash
npm install oriid
```
🚀 Quick Start
```js
import { oriid } from "oriid";
let OrderTrackingId = oriid(); // Example: "aX8rT9LpQv"
```
🔍 Example Output
```js
console.log(oriid()); // "bQ9xLpZrKd"
console.log(oriid()); // "Xv4Kp9AmR2"
console.log(oriid()); // "af9RWxLpO0"
```
This returns a unique 10-character ID, safe for use in:
URLs - File names - Offline devices - High-performance services
📚 API Reference
```js
oriid(): string
```
Returns a new **unique 10-character alphanumeric string**.
Details:
**Type**: `Function`
**Returns**: `string` – 10-character ID
**Alphabet**: `a–z`, `A–Z`, `0–9`
**Safe for**: URLs, filenames, logs, offline use
🔍 Verify Oriid
```js
verifyOriid(id: string): boolean
```
```js
import { oriid, verifyOriid } from 'oriid';
const id = oriid();
console.log(id); // Example: "aP9Tx8LmQz"
console.log(verifyOriid(id)); // true
console.log(verifyOriid("bad-id")); // false
```
Checks whether a given string is a valid Oriid.
- ✅ Must be exactly 10 characters
- ✅ Only a–z, A–Z, 0–9 allowed
```js
verifyOriid("aP9Tx8LmQz"); // true
verifyOriid("1234567890"); // true
verifyOriid("bad-id!"); // false
verifyOriid("toolong12345"); // false
```
Oriid is perfect for high-frequency systems like logs, telemetry, real-time transactions, and distributed environments where coordination is hard. It generates short, URL-friendly, globally unique IDs — ideal for short URLs or filenames. Using 62 characters (a–z, A–Z, 0–9), Oriid can produce over 839 trillion unique 10-character IDs, enough to generate 2 million IDs per second for 13,000+ years. Unlike MongoDB ObjectId (longer, hex-based) or MySQL AUTO_INCREMENT (requires DB access and isn’t globally unique), Oriid is lightweight, in-memory, DB-independent, and safe for offline use — with no memory leaks, no database lock-in, and no performance trade-offs.
🆚 Why Not Mongo ObjectId?
* MongoDB ObjectIds are **24-character hex strings** → **larger storage & URLs**
* Oriid IDs are **shorter, alphanumeric**, and **URL-safe**
* No database dependency or cluster configuration required
🆚 Why Not MySQL AUTO\_INCREMENT?
* MySQL’s auto-increment requires a **database roundtrip**
* It’s **not globally unique** (dangerous in distributed setups)
* Can't be safely merged across servers
Oriid solves these by being:
* In-memory
* Globally unique (based on time + counter)
* Independent of DB locks or sequences
**Reporting Bugs**
If you find an issue with EasyCSS, please report it via the GitHub issue tracker and via E-mail : github@jalsonic.com.
Designed, Built and Maintained by [Imran Amanat](https://www.imranamanat.com) imran@imranamanat.com and [Jalsonic Networks Teams](https://www.jalsonic.com) 2025.
A Division of [Jalsonic Networks](http://jalsonic.com) 2025.