miyavsanto 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,91 @@
-# Temporary Holding Version
+# miyavsanto
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+High performance native Rust TLS, HTTP/2, WebSocket, Gateway and Request Cache client for Node.js.
+
+## Installation
+
+```bash
+npm install miyavsanto
+```
+
+## Quick Start
+
+```javascript
+const client = require('miyavsanto');
+
+async function run() {
+  const res = await client.get('https://httpbin.org/get', {
+    cache: true,
+    tcp_nodelay: true,
+  });
+  console.log(res.status, res.version, res.cached);
+}
+
+run();
+```
+
+## API
+
+### HTTP Requests
+
+```javascript
+const client = require('miyavsanto');
+
+const res = await client.get('https://api.site.com/data');
+const json = await client.getJson('https://api.site.com/user');
+const postRes = await client.postJson('https://api.site.com/submit', { key: 'value' });
+
+const batchResults = await client.batch([
+  { url: 'https://httpbin.org/uuid' },
+  { url: 'https://httpbin.org/ip' }
+]);
+```
+
+### Request Cache
+
+```javascript
+const client = require('miyavsanto');
+
+const r1 = await client.get('https://api.site.com/items', { cache: true });
+const r2 = await client.get('https://api.site.com/items', { cache: true });
+
+console.log(client.cache.stats());
+client.cache.clear();
+```
+
+### WebSocket with Custom Settings & No Delay
+
+```javascript
+const client = require('miyavsanto');
+
+const ws = await client.ws('wss://echo.websocket.org', {
+  tcp_nodelay: true,
+  max_message_size: 16777216,
+  headers: [['user-agent', 'CustomClient']],
+}, (msg) => {
+  if (msg.kind === 'text') {
+    const data = JSON.parse(msg.text);
+    console.log(data);
+  }
+});
+
+ws.sendText(JSON.stringify({ hello: 'world' }));
+```
+
+### Gateway & Self Token
+
+```javascript
+const client = require('miyavsanto');
+
+const gw = await client.gateway({
+  tokenSource: 'file',
+  socketOptions: {
+    tcp_nodelay: true,
+  },
+}, (msg) => {
+  if (msg.kind === 'text') {
+    const packet = JSON.parse(msg.text);
+    console.log('Opcode:', packet.op);
+  }
+});
+```

package/client.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const native = require('./index.js');
+const config = require('./config.js');
+
+function normalizeResponse(res) {
+  if (!res) return res;
+  if (res.elapsed_ms === undefined && res.elapsedMs !== undefined) {
+    res.elapsed_ms = res.elapsedMs;
+  }
+  if (res.body_bytes === undefined && res.bodyBytes !== undefined) {
+    res.body_bytes = res.bodyBytes;
+  }
+  return res;
+}
+
+function parseHeaders(response) {
+  if (!response || !response.headers) return {};
+  try {
+    return typeof response.headers === 'string'
+      ? JSON.parse(response.headers)
+      : response.headers;
+  } catch {
+    return {};
+  }
+}
+
+function parseJson(response) {
+  if (!response || response.body == null) return null;
+  try {
+    return JSON.parse(response.body);
+  } catch {
+    return null;
+  }
+}
+
+function isOk(response) {
+  return response && response.status >= 200 && response.status < 300;
+}
+
+async function request(url, opts = {}) {
+  const res = await native.httpRequest(url, opts);
+  return normalizeResponse(res);
+}
+
+function get(url, opts = {}) {
+  return request(url, { ...opts, method: 'GET' });
+}
+
+function post(url, body = '', opts = {}) {
+  return request(url, {
+    ...opts,
+    method: 'POST',
+    body: typeof body === 'object' ? JSON.stringify(body) : String(body),
+  });
+}
+
+function put(url, body = '', opts = {}) {
+  return request(url, {
+    ...opts,
+    method: 'PUT',
+    body: typeof body === 'object' ? JSON.stringify(body) : String(body),
+  });
+}
+
+function patch(url, body = '', opts = {}) {
+  return request(url, {
+    ...opts,
+    method: 'PATCH',
+    body: typeof body === 'object' ? JSON.stringify(body) : String(body),
+  });
+}
+
+function del(url, opts = {}) {
+  return request(url, { ...opts, method: 'DELETE' });
+}
+
+async function getJson(url, opts = {}) {
+  const headers = [...(opts.headers || [])];
+  if (!headers.some(([k]) => k.toLowerCase() === 'accept')) {
+    headers.push(['Accept', 'application/json']);
+  }
+
+  const res = await get(url, { ...opts, headers });
+  return parseJson(res);
+}
+
+async function postJson(url, data = {}, opts = {}) {
+  const headers = [...(opts.headers || [])];
+  if (!headers.some(([k]) => k.toLowerCase() === 'content-type')) {
+    headers.push(['Content-Type', 'application/json']);
+  }
+  if (!headers.some(([k]) => k.toLowerCase() === 'accept')) {
+    headers.push(['Accept', 'application/json']);
+  }
+
+  const bodyStr = typeof data === 'string' ? data : JSON.stringify(data);
+  const res = await request(url, {
+    ...opts,
+    method: 'POST',
+    body: bodyStr,
+    headers,
+  });
+
+  return parseJson(res);
+}
+
+async function batch(items) {
+  const results = await native.httpRequestBatch(items);
+  for (const r of results) {
+    if (r.response) normalizeResponse(r.response);
+  }
+  return results;
+}
+
+function ws(url, opts = {}, onMessage) {
+  let options = opts;
+  let callback = onMessage;
+
+  if (typeof opts === 'function') {
+    callback = opts;
+    options = {};
+  }
+
+  return native.wsConnect(url, options, (arg1, arg2) => {
+    const payload = arg2 !== undefined ? arg2 : arg1;
+    if (typeof callback === 'function') {
+      callback(payload);
+    }
+  });
+}
+
+const cache = {
+  stats() {
+    const s = native.httpCacheStats();
+    if (s.hitRate !== undefined && s.hit_rate === undefined) {
+      s.hit_rate = s.hitRate;
+    }
+    return s;
+  },
+  clear() {
+    native.httpCacheClear();
+  },
+  invalidate(key) {
+    return native.httpCacheInvalidate(key);
+  },
+  get(key) {
+    const r = native.httpCacheGet(key);
+    return normalizeResponse(r);
+  },
+  set(key, response) {
+    native.httpCacheSet(key, response);
+  },
+};
+
+async function gateway(options = {}, onMessage) {
+  const token =
+    options.token ||
+    config.getToken(options.tokenSource || config.tokenSource);
+
+  const gatewayUrl = options.gatewayUrl || config.gatewayUrl;
+  const socketOptions = options.socketOptions || {};
+  const autoHeartbeat = options.autoHeartbeat !== false;
+  const autoIdentify = options.autoIdentify !== false;
+
+  let heartbeatTimer = null;
+  let lastSequence = null;
+
+  function sendJson(conn, data) {
+    conn.sendText(JSON.stringify(data));
+  }
+
+  function identify(conn) {
+    if (!token) return;
+    const identifyPayload = {
+      op: 2,
+      d: {
+        token: token,
+        capabilities: 16381,
+        properties: options.properties || {
+          os: 'Windows',
+          browser: 'Chrome',
+          device: '',
+        },
+        presence: options.presence || {
+          status: 'online',
+          since: 0,
+          activities: [],
+          afk: false,
+        },
+        compress: false,
+      },
+    };
+    sendJson(conn, identifyPayload);
+  }
+
+  let connection = null;
+
+  connection = await ws(gatewayUrl, socketOptions, (msg) => {
+    if (msg && msg.kind === 'text' && msg.text) {
+      try {
+        const payload = JSON.parse(msg.text);
+        if (payload.s !== null && payload.s !== undefined) {
+          lastSequence = payload.s;
+        }
+
+        if (payload.op === 10) {
+          const interval = payload.d?.heartbeat_interval;
+          if (interval && autoHeartbeat && connection) {
+            if (heartbeatTimer) clearInterval(heartbeatTimer);
+            heartbeatTimer = setInterval(() => {
+              if (connection) {
+                sendJson(connection, { op: 1, d: lastSequence });
+              }
+            }, interval);
+          }
+          if (autoIdentify && connection) {
+            identify(connection);
+          }
+        }
+      } catch {}
+    }
+
+    if (typeof onMessage === 'function') {
+      onMessage(msg, connection);
+    }
+  });
+
+  return {
+    connection,
+    sendText: (text) => connection.sendText(text),
+    sendJson: (data) => sendJson(connection, data),
+    sendBinary: (buf) => connection.sendBinary(buf),
+    ping: () => connection.ping(),
+    identify: () => identify(connection),
+    close: () => {
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      return connection.close();
+    },
+  };
+}
+
+const client = {
+  request,
+  get,
+  post,
+  put,
+  patch,
+  delete: del,
+  del,
+  getJson,
+  postJson,
+  batch,
+  ws,
+  wsConnect: ws,
+  gateway,
+  connectGateway: gateway,
+  cache,
+  config,
+  parseJson,
+  parseHeaders,
+  isOk,
+};
+
+module.exports = client;

package/config.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const path = require('path');
+
+const config = {
+  token: '',
+  tokenSource: 'config',
+  tokenFile: 'list.txt',
+  gatewayUrl: 'wss://gateway.discord.gg/?v=10&encoding=json',
+  getToken(source) {
+    const selectedSource = source || config.tokenSource;
+    if (selectedSource === 'file') {
+      const filePath = path.resolve(process.cwd(), config.tokenFile);
+      if (fs.existsSync(filePath)) {
+        const lines = fs
+          .readFileSync(filePath, 'utf-8')
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean);
+        if (lines.length > 0) {
+          return lines[0];
+        }
+      }
+    }
+    return config.token;
+  },
+  getTokens(source) {
+    const selectedSource = source || config.tokenSource;
+    if (selectedSource === 'file') {
+      const filePath = path.resolve(process.cwd(), config.tokenFile);
+      if (fs.existsSync(filePath)) {
+        return fs
+          .readFileSync(filePath, 'utf-8')
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter(Boolean);
+      }
+    }
+    return config.token ? [config.token] : [];
+  },
+};
+
+module.exports = config;

package/index.d.ts

@@ -0,0 +1,74 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export declare function httpCacheStats(): CacheStats
+export declare function httpCacheClear(): void
+export declare function httpCacheInvalidate(key: string): boolean
+export declare function httpCacheGet(key: string): HttpResponse | null
+export declare function httpCacheSet(key: string, response: HttpResponse): void
+export declare function httpRequest(url: string, opts?: RequestOptions | undefined | null): Promise<HttpResponse>
+export interface BatchItem {
+  url: string
+  opts?: RequestOptions
+}
+export interface BatchResult {
+  url: string
+  response?: HttpResponse
+  error?: string
+}
+export declare function httpRequestBatch(items: Array<BatchItem>): Promise<Array<BatchResult>>
+export interface RequestOptions {
+  method?: string
+  body?: string
+  headers?: Array<Array<string>>
+  timeoutMs?: number
+  forceHttp2?: boolean
+  dangerSkipVerify?: boolean
+  cache?: boolean
+  cacheKey?: string
+  forceRefresh?: boolean
+  caCert?: string
+  tcpNodelay?: boolean
+}
+export interface HttpResponse {
+  status: number
+  version: string
+  headers: string
+  body: string
+  bodyBytes: number
+  elapsedMs: number
+  cached: boolean
+}
+export interface CacheStats {
+  size: number
+  hits: number
+  misses: number
+  hitRate: number
+}
+export interface WsMessage {
+  kind: string
+  text?: string
+  binary?: string
+}
+export interface WsOptions {
+  headers?: Array<Array<string>>
+  protocols?: Array<string>
+  dangerSkipVerify?: boolean
+  maxMessageSize?: number
+  maxFrameSize?: number
+  writeBufferSize?: number
+  maxWriteBufferSize?: number
+  acceptUnmaskedFrames?: boolean
+  caCert?: string
+  tcpNodelay?: boolean
+}
+export declare function wsConnect(url: string, opts: WsOptions | undefined | null, onMessage: (msg: import('./types').WsMessage) => void): Promise<WsConnection>
+export declare class WsConnection {
+  sendText(text: string): void
+  sendBinary(data: Buffer): void
+  ping(): void
+  close(): void
+  get url(): string
+}

package/index.js

@@ -0,0 +1,323 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'index.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.android-arm64.node')
+          } else {
+            nativeBinding = require('miyavsanto-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'index.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('miyavsanto-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('miyavsanto-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('miyavsanto-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('miyavsanto-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'index.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./index.darwin-universal.node')
+      } else {
+        nativeBinding = require('miyavsanto-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'index.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.darwin-x64.node')
+          } else {
+            nativeBinding = require('miyavsanto-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.darwin-arm64.node')
+          } else {
+            nativeBinding = require('miyavsanto-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'index.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./index.freebsd-x64.node')
+      } else {
+        nativeBinding = require('miyavsanto-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('miyavsanto-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('miyavsanto-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { httpCacheStats, httpCacheClear, httpCacheInvalidate, httpCacheGet, httpCacheSet, httpRequest, httpRequestBatch, WsConnection, wsConnect } = nativeBinding
+
+module.exports.httpCacheStats = httpCacheStats
+module.exports.httpCacheClear = httpCacheClear
+module.exports.httpCacheInvalidate = httpCacheInvalidate
+module.exports.httpCacheGet = httpCacheGet
+module.exports.httpCacheSet = httpCacheSet
+module.exports.httpRequest = httpRequest
+module.exports.httpRequestBatch = httpRequestBatch
+module.exports.WsConnection = WsConnection
+module.exports.wsConnect = wsConnect

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "miyavsanto",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "High performance Rust TLS, HTTP/2, WebSocket and Gateway Client for Node.js",
+  "main": "client.js",
+  "types": "index.d.ts",
+  "files": [
+    "client.js",
+    "config.js",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "*.node"
+  ],
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi build --platform --release",
+    "test": "node test.js"
+  },
+  "keywords": [
+    "rust",
+    "http2",
+    "tls",
+    "rustls",
+    "websocket",
+    "gateway",
+    "cache",
+    "napi"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^2"
+  }
+}