BREAKING CHANGE(core): major architectural refactoring with fetch-like API

ts/core/index.ts

@@ -0,0 +1,4 @@
+// Core exports
+export * from './types.js';
+export * from './response.js';
+export { request, coreRequest, isUnixSocket, parseUnixSocketUrl } from './request.js';

ts/core/plugins.ts

@@ -0,0 +1,19 @@
+// node native scope
+import * as fs from 'fs';
+import * as http from 'http';
+import * as https from 'https';
+import * as path from 'path';
+
+export { http, https, fs, path };
+
+// pushrocks scope
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smarturl from '@push.rocks/smarturl';
+
+export { smartpromise, smarturl };
+
+// third party scope
+import agentkeepalive from 'agentkeepalive';
+import formData from 'form-data';
+
+export { agentkeepalive, formData };

ts/core/request.ts

@@ -0,0 +1,159 @@
+import * as plugins from './plugins.js';
+import * as types from './types.js';
+import { SmartResponse } from './response.js';
+
+// Keep-alive agents for connection pooling
+const httpAgent = new plugins.agentkeepalive({
+  keepAlive: true,
+  maxFreeSockets: 10,
+  maxSockets: 100,
+  maxTotalSockets: 1000,
+});
+
+const httpAgentKeepAliveFalse = new plugins.agentkeepalive({
+  keepAlive: false,
+});
+
+const httpsAgent = new plugins.agentkeepalive.HttpsAgent({
+  keepAlive: true,
+  maxFreeSockets: 10,
+  maxSockets: 100,
+  maxTotalSockets: 1000,
+});
+
+const httpsAgentKeepAliveFalse = new plugins.agentkeepalive.HttpsAgent({
+  keepAlive: false,
+});
+
+/**
+ * Tests if a URL is a unix socket
+ */
+export const isUnixSocket = (url: string): boolean => {
+  const unixRegex = /^(http:\/\/|https:\/\/|)unix:/;
+  return unixRegex.test(url);
+};
+
+/**
+ * Parses socket path and route from unix socket URL
+ */
+export const parseUnixSocketUrl = (url: string): { socketPath: string; path: string } => {
+  const parseRegex = /(.*):(.*)/;
+  const result = parseRegex.exec(url);
+  return {
+    socketPath: result[1],
+    path: result[2],
+  };
+};
+
+
+/**
+ * Core request function that handles all HTTP/HTTPS requests
+ */
+export async function coreRequest(
+  urlArg: string,
+  optionsArg: types.ICoreRequestOptions = {},
+  requestDataFunc: ((req: plugins.http.ClientRequest) => void) | null = null
+): Promise<plugins.http.IncomingMessage> {
+  const done = plugins.smartpromise.defer<plugins.http.IncomingMessage>();
+
+  // No defaults - let users explicitly set options to match fetch behavior
+
+  // Parse URL
+  const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(urlArg, {
+    searchParams: optionsArg.queryParams || {},
+  });
+  
+  optionsArg.hostname = parsedUrl.hostname;
+  if (parsedUrl.port) {
+    optionsArg.port = parseInt(parsedUrl.port, 10);
+  }
+  optionsArg.path = parsedUrl.path;
+
+  // Handle unix socket URLs
+  if (isUnixSocket(urlArg)) {
+    const { socketPath, path } = parseUnixSocketUrl(optionsArg.path);
+    optionsArg.socketPath = socketPath;
+    optionsArg.path = path;
+  }
+
+  // Determine agent based on protocol and keep-alive setting
+  if (!optionsArg.agent) {
+    // Only use keep-alive agents if explicitly requested
+    if (optionsArg.keepAlive === true) {
+      optionsArg.agent = parsedUrl.protocol === 'https:' ? httpsAgent : httpAgent;
+    } else if (optionsArg.keepAlive === false) {
+      optionsArg.agent = parsedUrl.protocol === 'https:' ? httpsAgentKeepAliveFalse : httpAgentKeepAliveFalse;
+    }
+    // If keepAlive is undefined, don't set any agent (more fetch-like behavior)
+  }
+
+  // Determine request module
+  const requestModule = parsedUrl.protocol === 'https:' ? plugins.https : plugins.http;
+
+  if (!requestModule) {
+    throw new Error(`The request to ${urlArg} is missing a viable protocol. Must be http or https`);
+  }
+
+  // Perform the request
+  const request = requestModule.request(optionsArg, async (response) => {
+    // Handle hard timeout
+    if (optionsArg.hardDataCuttingTimeout) {
+      setTimeout(() => {
+        response.destroy();
+        done.reject(new Error('Request timed out'));
+      }, optionsArg.hardDataCuttingTimeout);
+    }
+
+    // Always return the raw stream
+    done.resolve(response);
+  });
+
+  // Write request body
+  if (optionsArg.requestBody) {
+    if (optionsArg.requestBody instanceof plugins.formData) {
+      optionsArg.requestBody.pipe(request).on('finish', () => {
+        request.end();
+      });
+    } else {
+      // Write body as-is - caller is responsible for serialization
+      const bodyData = typeof optionsArg.requestBody === 'string' 
+        ? optionsArg.requestBody 
+        : optionsArg.requestBody instanceof Buffer 
+          ? optionsArg.requestBody
+          : JSON.stringify(optionsArg.requestBody); // Still stringify for backward compatibility
+      request.write(bodyData);
+      request.end();
+    }
+  } else if (requestDataFunc) {
+    requestDataFunc(request);
+  } else {
+    request.end();
+  }
+
+  // Handle request errors
+  request.on('error', (e) => {
+    console.error(e);
+    request.destroy();
+    done.reject(e);
+  });
+
+  // Get response and handle response errors
+  const response = await done.promise;
+  response.on('error', (err) => {
+    console.error(err);
+    response.destroy();
+  });
+
+  return response;
+}
+
+/**
+ * Modern request function that returns a SmartResponse
+ */
+export async function request(
+  urlArg: string,
+  optionsArg: types.ICoreRequestOptions = {}
+): Promise<SmartResponse> {
+  const response = await coreRequest(urlArg, optionsArg);
+  return new SmartResponse(response, urlArg);
+}

ts/core/response.ts

@@ -0,0 +1,110 @@
+import * as plugins from './plugins.js';
+import * as types from './types.js';
+
+/**
+ * Modern Response class that provides a fetch-like API
+ */
+export class SmartResponse<T = any> implements types.ICoreResponse<T> {
+  private incomingMessage: plugins.http.IncomingMessage;
+  private bodyBufferPromise: Promise<Buffer> | null = null;
+  private consumed = false;
+
+  // Public properties
+  public readonly ok: boolean;
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly headers: plugins.http.IncomingHttpHeaders;
+  public readonly url: string;
+
+  constructor(incomingMessage: plugins.http.IncomingMessage, url: string) {
+    this.incomingMessage = incomingMessage;
+    this.url = url;
+    this.status = incomingMessage.statusCode || 0;
+    this.statusText = incomingMessage.statusMessage || '';
+    this.ok = this.status >= 200 && this.status < 300;
+    this.headers = incomingMessage.headers;
+  }
+
+  /**
+   * Ensures the body can only be consumed once
+   */
+  private ensureNotConsumed(): void {
+    if (this.consumed) {
+      throw new Error('Body has already been consumed');
+    }
+    this.consumed = true;
+  }
+
+  /**
+   * Collects the body as a buffer
+   */
+  private async collectBody(): Promise<Buffer> {
+    this.ensureNotConsumed();
+    
+    if (this.bodyBufferPromise) {
+      return this.bodyBufferPromise;
+    }
+
+    this.bodyBufferPromise = new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      
+      this.incomingMessage.on('data', (chunk: Buffer) => {
+        chunks.push(chunk);
+      });
+      
+      this.incomingMessage.on('end', () => {
+        resolve(Buffer.concat(chunks));
+      });
+      
+      this.incomingMessage.on('error', reject);
+    });
+
+    return this.bodyBufferPromise;
+  }
+
+  /**
+   * Parse response as JSON
+   */
+  async json(): Promise<T> {
+    const buffer = await this.collectBody();
+    const text = buffer.toString('utf-8');
+    
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get response as text
+   */
+  async text(): Promise<string> {
+    const buffer = await this.collectBody();
+    return buffer.toString('utf-8');
+  }
+
+  /**
+   * Get response as ArrayBuffer
+   */
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    const buffer = await this.collectBody();
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+
+  /**
+   * Get response as a readable stream
+   */
+  stream(): NodeJS.ReadableStream {
+    this.ensureNotConsumed();
+    return this.incomingMessage;
+  }
+
+  /**
+   * Get the raw IncomingMessage (for legacy compatibility)
+   */
+  raw(): plugins.http.IncomingMessage {
+    return this.incomingMessage;
+  }
+
+}

ts/core/types.ts

@@ -0,0 +1,67 @@
+import * as plugins from './plugins.js';
+
+/**
+ * Core request options extending Node.js RequestOptions
+ */
+export interface ICoreRequestOptions extends plugins.https.RequestOptions {
+  keepAlive?: boolean;
+  requestBody?: any;
+  queryParams?: { [key: string]: string };
+  hardDataCuttingTimeout?: number;
+}
+
+/**
+ * HTTP Methods supported
+ */
+export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+
+/**
+ * Response types supported
+ */
+export type ResponseType = 'json' | 'text' | 'binary' | 'stream';
+
+/**
+ * Extended IncomingMessage with body property (legacy compatibility)
+ */
+export interface IExtendedIncomingMessage<T = any> extends plugins.http.IncomingMessage {
+  body: T;
+}
+
+/**
+ * Form field data for multipart/form-data requests
+ */
+export interface IFormField {
+  name: string;
+  value: string | Buffer;
+  filename?: string;
+  contentType?: string;
+}
+
+/**
+ * URL encoded form field
+ */
+export interface IUrlEncodedField {
+  key: string;
+  value: string;
+}
+
+/**
+ * Core response object that provides fetch-like API
+ */
+export interface ICoreResponse<T = any> {
+  // Properties
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: plugins.http.IncomingHttpHeaders;
+  url: string;
+  
+  // Methods
+  json(): Promise<T>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  stream(): NodeJS.ReadableStream;
+  
+  // Legacy compatibility
+  raw(): plugins.http.IncomingMessage;
+}