volter 0.0.0 → 0.0.1

package/README.md

@@ -1 +1,15 @@
-# VolterJS
+# volter
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.21. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/biome.json

@@ -0,0 +1,40 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.1.2/schema.json",
+	"vcs": {
+		"enabled": false,
+		"clientKind": "git",
+		"useIgnoreFile": false
+	},
+	"files": {
+		"ignoreUnknown": false
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double",
+			"semicolons": "asNeeded",
+			"lineWidth": 160,
+			"arrowParentheses": "asNeeded"
+		},
+		"linter": {
+			"enabled": true
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "off"
+			}
+		}
+	}
+}

package/index.ts

@@ -0,0 +1,182 @@
+import type { RedisClient, SocketAddress } from "bun"
+import { createID } from "./utils"
+import type { BunSQLDatabase } from "drizzle-orm/bun-sql"
+
+declare global {
+	interface Request {
+		ip: SocketAddress
+	}
+}
+
+export namespace Volter {
+	export namespace Cache {
+		export interface Options {
+			expiry?: number
+			limit?: number
+			/** FIFO */
+			max?: number
+		}
+		export interface KV {
+			value: string
+			getch: number
+			expiry?: NodeJS.Timeout
+			limit?: number
+		}
+	}
+	export class Cache {
+		constructor(options?: Cache.Options) {
+			this.expiry = options?.expiry
+			this.limit = options?.limit
+			this.max = options?.max
+		}
+		expiry?: number
+		limit?: number
+		max?: number
+		hasher = new Bun.CryptoHasher("sha256")
+		store: { [x: string]: Cache.KV } = {}
+		hash(password: string): string {
+			return this.hasher.update(password).digest("base64")
+		}
+		pop(): void {
+			const keys = Object.keys(this.store)
+			delete this.store[keys[keys.length - 1]]
+		}
+		has(key: string): boolean {
+			return this.store[key] !== undefined
+		}
+		get(key: string): string | null {
+			if (this.store[key] !== undefined) {
+				const record = this.store[key]
+				this.store[key].getch += 1
+				if (record.limit !== undefined) {
+					if (record.getch >= record.limit) {
+						delete this.store[key]
+						return null
+					}
+				}
+				return record.value
+			}
+			return null
+		}
+		set(key: string, value: string, expiry?: number, limit?: number): boolean {
+			if (this.max !== undefined && this.size() >= this.max) this.pop()
+			this.store[key] = {
+				value,
+				getch: 0,
+				limit: limit ?? this.limit,
+				expiry: expiry
+					? setTimeout(() => delete this.store[key], expiry * 1000)
+					: this.expiry
+						? setTimeout(() => delete this.store[key], this.expiry * 1000)
+						: undefined,
+			}
+			return true
+		}
+		del(key: string): boolean {
+			if (this.store[key]) {
+				if (this.store[key].expiry !== undefined) {
+					clearTimeout(this.store[key].expiry)
+				} else {
+					delete this.store[key]
+				}
+				return true
+			}
+			return false
+		}
+		clear(): void {
+			this.store = {}
+		}
+		size(): number {
+			return Object.keys(this.store).length
+		}
+	}
+
+	export interface RatelimitOptions {
+		redis: RedisClient
+		limit: number
+		duration: number
+		max: number
+	}
+	export interface RatelimitResult {
+		success: boolean
+		remaining: number
+	}
+
+	export class Ratelimit {
+		private redis: RedisClient
+		private limiter: number
+		private duration: number
+		private max: number
+
+		constructor(options: RatelimitOptions) {
+			this.redis = options.redis
+			this.limiter = options.limit
+			this.duration = options.duration
+			this.max = options.max
+		}
+
+		async limit(identifier: string): Promise<RatelimitResult> {
+			const blocked = await this.redis.exists(`ratelimited:${identifier}`)
+			if (blocked) {
+				return {
+					success: false,
+					remaining: 0,
+				}
+			}
+
+			const key = `ratelimit:${identifier}`
+
+			const count = await this.redis.incr(key)
+			if (count === 1) {
+				await this.redis.expire(key, this.duration)
+			}
+
+			if (count >= this.max) {
+				await this.redis.set(`ratelimited:${identifier}`, "1")
+				await this.redis.expire(`ratelimited:${identifier}`, this.limiter)
+			}
+
+			return {
+				success: true,
+				remaining: this.max - count,
+			}
+		}
+	}
+
+	export interface SessionsOptions {
+		redis: RedisClient
+		db: BunSQLDatabase
+	}
+	export class Sessions {
+		constructor(options: SessionsOptions) {
+			this.redis = options.redis
+			this.db = options.db
+		}
+		redis: RedisClient
+		db: BunSQLDatabase
+		async create(id: string) {
+			const session = createID()
+			const lookup = hash(session)
+			await this.redis.set(`session:${lookup}`, id, "EX", 2592000) // 30 days
+			return session
+		} // create
+		async validate(token: string) {
+			const lookup = hash(token)
+			// todo: login
+			return await this.redis.get(`session:${lookup}`)
+		} // read
+		async rotate(token: string) {
+			const isValid = await this.validate(token)
+			if (!isValid) return undefined
+			await this.revoke(token)
+			return await this.create(token)
+		}
+		async revoke(token: string) {
+			const lookup = hash(token)
+			await this.redis.del(`session:${lookup}`)
+			return true
+		} // delete
+	}
+}
+
+export default Volter

package/package.json

@@ -1,53 +1,21 @@
 {
-  "name": "volter",
-  "main": "./src/volter.ts",
-  "module": "./src/volter.ts",
-  "types": "./volter.d.ts",
-  "type": "module",
-  "files": [
-    "*.d.ts"
-  ],
-  "devDependencies": {
-    "@biomejs/biome": "1.5.3",
-    "@types/bun": "latest",
-    "@types/showdown": "^2.0.6"
-  },
-  "description": "⚡ Volter a React Meta Framework",
-  "version": "0.0.0",
-  "dependencies": {
-    "@elysiajs/cors": "^0.8.0",
-    "@elysiajs/static": "^0.8.1",
-    "bun-types": "^1.0.26",
-    "csstype": "^3.1.3",
-    "elysia": "latest",
-    "showdown": "^2.1.0",
-    "typescript": "latest",
-    "undici-types": "^5.26.5"
-  },
-  "exports": {
-    ".": {
-      "import": "./src/volter.ts",
-      "require": "./src/volter.ts",
-      "types": "./volter.d.ts"
-    }
-  },
-  "scripts": {
-    "udp": "bun src/udp.ts",
-    "ftp": "bun src/ftp.ts",
-    "test": "bun tests/index.test.ts",
-    "test:j": "bun tests/json.test.ts"
-  },
-  "repository": {
-    "type": "git",
-    "url": "invalid"
-  },
-  "keywords": [
-    "JavaScript",
-    "Framework"
-  ],
-  "author": "Modlin Inc",
-  "license": "MIT",
-  "directories": {
-    "test": "tests"
-  }
+	"name": "volter",
+	"version": "0.0.1",
+	"description": "Secure, lightweight, and user-friendly modern JavaScript toolchain optimized for performance and minimalism.",
+	"main": "index.ts",
+	"module": "index.ts",
+	"type": "module",
+	"devDependencies": {
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"dependencies": {
+		"@paralleldrive/cuid2": "^2.2.2",
+		"@signalapp/libsignal-client": "^0.79.1",
+		"chalk": "^5.6.0",
+		"drizzle-orm": "^0.44.5",
+		"zod": "^4.1.7"
+	}
 }

package/session.ts

@@ -0,0 +1,37 @@
+import { getRandomValues, randomBytes } from "node:crypto"
+
+function pad(input: string) {
+	const result: string[] = []
+	for (let i = 0; i < input.length; i++) {
+		result.push(input[i] as string)
+		if ((i + 1) % 4 === 0 && i !== input.length - 1) {
+			result.push("-")
+		}
+	}
+	return result.join("")
+}
+
+export function randomID() {
+	const session = randomBytes(16).toHex()
+
+	return pad(session)
+}
+export function randomPN(): string {
+	const MAX = 100_000_000
+	const LIMIT = Math.floor(0x1_0000_0000 / MAX) * MAX
+	const buf = new Uint32Array(1)
+
+	let v: number
+	while (true) {
+		getRandomValues(buf)
+		v = buf[0] as number
+		if (v < LIMIT) break
+	}
+
+	const padded = (v % MAX).toString().padStart(8, "0")
+	return `${padded.slice(0, 4)} ${padded.slice(4)}`
+}
+
+do {
+	console.log(randomID())
+} while (true)

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/utils.ts

@@ -0,0 +1,142 @@
+import { privateDecrypt, publicEncrypt, randomInt } from "node:crypto"
+import os from "node:os"
+import chalk from "chalk"
+import cuid2 from "@paralleldrive/cuid2"
+
+export const pin = z.string().min(6).max(6).regex(/\d{6}/)
+
+export function createPIN(): string {
+	return randomInt(0, 1000000).toString().padStart(6, "0")
+}
+export const createID = cuid2.init({ length: 32 })
+
+const hasher = new Bun.CryptoHasher("sha256")
+export function hash(password: string): string {
+	return hasher.update(password).digest("hex")
+}
+
+export function timestamp(): string
+export function timestamp(date: Date): string
+export function timestamp(date?: Date): string {
+	if (!date) date = new Date()
+	return date.toISOString().slice(0, 19).replace("T", " ")
+}
+
+export function log(...message: unknown[]) {
+	console.log(chalk.gray(timestamp()), ...message)
+}
+export function error(...message: unknown[]) {
+	console.error(chalk.red(timestamp()), ...message)
+}
+
+export async function input(prompt: string = chalk.black("> ")) {
+	await Bun.stdout.write(prompt)
+	for await (const line of console) {
+		return line
+	}
+}
+
+export type HTTPLog = {
+	timestamp: string
+	method: string
+	url: string
+	IP: string
+	request_id?: string
+	service?: string
+	level: "info" | "warn" | "error"
+}
+
+/**
+ * Returns a structured JSON log of the request
+ */
+export function formatRequest(req: Request): HTTPLog {
+	return {
+		timestamp: new Date().toISOString(),
+		method: req.method,
+		url: new URL(req.url).pathname,
+		IP: req.headers.get("x-forwarded-for") ?? "unknown",
+		request_id: req.headers.get("x-request-id") ?? "none",
+		service: "app",
+		level: "info",
+	}
+}
+
+/**
+ * Returns a one-line pretty string with colors using chalk
+ */
+export function prettifyRequest(req: Request): string {
+	const url = chalk.white(new URL(req.url).pathname)
+	return `${chalk.gray(timestamp())} ${chalk.red(req.ip.address)} ${chalk.green(req.method)} ${url}`
+}
+
+interface Adapter {
+	adapter: string
+	networks: Bun.SocketAddress[]
+}
+
+export function listAdapters(): Adapter[] {
+	const interfaces = os.networkInterfaces()
+	const results: Adapter[] = []
+
+	for (const [name, infos] of Object.entries(interfaces)) {
+		if (!infos) continue
+
+		const networks: Bun.SocketAddress[] = []
+
+		for (const info of infos) {
+			if (!info.address) continue
+
+			networks.push({
+				address: info.address,
+				family: info.family,
+				port: 0,
+			})
+		}
+
+		results.push({
+			adapter: name,
+			networks,
+		})
+	}
+
+	return results
+}
+
+import { generateKeyPairSync } from "node:crypto"
+import z from "zod"
+
+type KeyPair = {
+	public: string
+	private: string
+}
+
+export async function key(): Promise<KeyPair> {
+	const { publicKey, privateKey } = generateKeyPairSync("rsa", {
+		modulusLength: 2048,
+		publicKeyEncoding: {
+			type: "spki",
+			format: "pem",
+		},
+		privateKeyEncoding: {
+			type: "pkcs8",
+			format: "pem",
+		},
+	})
+
+	return {
+		public: publicKey,
+		private: privateKey,
+	}
+}
+
+export function encrypt(key: string, data: string) {
+	const buffer = Buffer.from(data, "utf-8")
+	const encrypted = publicEncrypt(key, buffer)
+	return encrypted.toString("hex")
+}
+
+export function decrypt(key: string, encrypted: string) {
+	const buffer = Buffer.from(encrypted, "hex")
+	const decrypted = privateDecrypt(key, buffer)
+	return decrypted.toString("utf-8")
+}

package/global.d.ts

@@ -1,3 +0,0 @@
-declare global {
-    var Volter: typeof import("volter");
-}

package/volter.d.ts

@@ -1,80 +0,0 @@
-declare module 'volter' {
-  import type { Elysia } from 'elysia'
-  import type { ConverterOptions } from 'showdown'
-
-  //! Properties //!
-  export const HTTPMethods: [
-    'ACL',
-    'BIND',
-    'CHECKOUT',
-    'CONNECT',
-    'COPY',
-    'DELETE',
-    'GET',
-    'HEAD',
-    'LINK',
-    'LOCK',
-    'M-SEARCH',
-    'MERGE',
-    'MKACTIVITY',
-    'MKCALENDAR',
-    'MKCOL',
-    'MOVE',
-    'NOTIFY',
-    'OPTIONS',
-    'PATCH',
-    'POST',
-    'PROPFIND',
-    'PROPPATCH',
-    'PURGE',
-    'PUT',
-    'REBIND',
-    'REPORT',
-    'SEARCH',
-    'SOURCE',
-    'SUBSCRIBE',
-    'TRACE',
-    'UNBIND',
-    'UNLINK',
-    'UNLOCK',
-    'UNSUBSCRIBE',
-    'ALL'
-  ]
-
-  //! Tools //!
-  export function readFilesSync(dir: string): Generator<string>
-
-  /**
-   * Markdown to HTML converter using [Showdown](https://github.com/showdownjs/showdown).
-   *
-   * [MDN Guide](https://developer.mozilla.org/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN)
-   *
-   * @param markdown as a String
-   * @param options to customize the converter
-   */
-  export function markdown(markdown: string, options?: ConverterOptions): string
-
-  //! Interfaces & Types //!
-  export interface StaticOptions {
-    path?: string
-    prefix?: string
-  }
-
-  export type jsExt = '.js' | '.jsx' | '.ts' | '.tsx' | '.mjs' | '.cjs'
-
-  //! Plugins //!
-  /**
-   * ElysiaJS plugin for File System Routing
-   * @param options The options to use when creating the router
-   * @param options.dir The root directory containing the files to route
-   */
-  export function FileSystemRouter<D extends string>(options: {
-    dir: D,
-    fileExtensions?: jsExt[] | string[]
-  }): Elysia
-
-  export function staticFiles(options?: StaticOptions): Elysia
-  
-  //! 3rd Party Modules //!
-  export * from '@elysiajs/cors'
-}