@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/http/server/node/node-http-server.js

@@ -1,236 +1,258 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_http_server_exports = {};
+__export(node_http_server_exports, {
+  NodeHttpServer: () => NodeHttpServer
+});
+module.exports = __toCommonJS(node_http_server_exports);
+var Http = __toESM(require("node:http"), 1);
+var import_disposable = require("../../../disposable/index.js");
+var import_http_headers = require("../../../http/http-headers.js");
+var import_http_query = require("../../../http/http-query.js");
+var import_injector = require("../../../injector/index.js");
+var import_logger = require("../../../logger/index.js");
+var import_cancellation_token = require("../../../utils/cancellation-token.js");
+var import_encoding = require("../../../utils/encoding.js");
+var import_feedable_async_iterable = require("../../../utils/feedable-async-iterable.js");
+var import_readable_stream_adapter = require("../../../utils/stream/readable-stream-adapter.js");
+var import_timer = require("../../../utils/timer.js");
+var import_timing = require("../../../utils/timing.js");
+var import_type_guards = require("../../../utils/type-guards.js");
+var import_rxjs = require("rxjs");
+var import_http_server_request = require("../http-server-request.js");
+var import_http_server = require("../http-server.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import * as Http from 'node:http';
-import { afterResolve, resolveArg, singleton } from '../../../container/index.js';
-import { disposer } from '../../../core.js';
-import { disposeAsync } from '../../../disposable/index.js';
-import { HttpHeaders } from '../../../http/http-headers.js';
-import { HttpQuery } from '../../../http/http-query.js';
-import { Logger } from '../../../logger/index.js';
-import { CancellationToken } from '../../../utils/cancellation-token.js';
-import { encodeUtf8 } from '../../../utils/encoding.js';
-import { FeedableAsyncIterable } from '../../../utils/feedable-async-iterable.js';
-import { getReadableStreamIterable } from '../../../utils/stream/readable-stream-adapter.js';
-import { Timer } from '../../../utils/timer.js';
-import { cancelableTimeout } from '../../../utils/timing.js';
-import { isDefined, isNullOrUndefined, isString } from '../../../utils/type-guards.js';
-import { bindNodeCallback, share } from 'rxjs';
-import { HttpServerRequest } from '../http-server-request.js';
-import { HttpServer } from '../http-server.js';
-export let NodeHttpServer = class NodeHttpServer extends HttpServer {
-    httpServer;
-    sockets;
-    requestIterable;
-    logger;
-    untrackConnectedSockets;
-    get connectedSocketsCount() {
-        return this.sockets.size;
-    }
-    constructor(logger) {
-        super();
-        this.logger = logger;
-        this.httpServer = new Http.Server();
-        this.sockets = new Set();
-        this.requestIterable = new FeedableAsyncIterable();
-        this.httpServer.on('request', (request, response) => {
-            this.logger.verbose(`${request.method} from "${request.socket.remoteAddress}" to "${request.url}"`);
-            this.requestIterable.feed({ request, response });
-        });
-    }
-    [afterResolve]() {
-        disposer.add(() => this[disposeAsync]);
-    }
-    async [disposeAsync]() {
-        await this.close(3000);
-        this.requestIterable.end();
-    }
-    async listen(port) {
-        if (this.httpServer.listening) {
-            throw new Error('http server is already listening');
-        }
-        this.httpServer.listen(port);
-        return new Promise((resolve, reject) => {
-            let listeningListener;
-            let errorListener; // eslint-disable-line prefer-const
-            listeningListener = () => {
-                this.logger.info(`Listening on port ${port}`);
-                this.untrackConnectedSockets = trackConnectedSockets(this.httpServer, this.sockets);
-                this.httpServer.removeListener('error', errorListener);
-                resolve();
-            };
-            errorListener = (error) => {
-                this.httpServer.removeListener('listening', listeningListener);
-                reject(error);
-            };
-            this.httpServer.once('listening', listeningListener);
-            this.httpServer.once('error', errorListener);
-        });
-    }
-    async close(timeout) {
-        this.logger.info('Closing http server');
-        const timer = new Timer(true);
-        const close$ = bindNodeCallback(this.httpServer.close.bind(this.httpServer))().pipe(share());
-        close$.subscribe();
-        while (true) {
-            const connections = await getConnectionsCount(this.httpServer);
-            if (connections == 0) {
-                break;
-            }
-            if (timer.milliseconds >= timeout) {
-                this.logger.info(`Force closing of ${connections} remaining sockets after waiting for ${timeout} milliseconds`);
-                destroySockets(this.sockets);
-                break;
-            }
-            if (connections > 0) {
-                this.logger.info(`Waiting for ${connections} connections to end`);
-                await cancelableTimeout(250, CancellationToken.from(close$));
-            }
-        }
-        this.untrackConnectedSockets?.();
-        this.untrackConnectedSockets = undefined;
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+let NodeHttpServer = class NodeHttpServer2 extends import_http_server.HttpServer {
+  httpServer;
+  sockets;
+  requestIterable;
+  logger;
+  untrackConnectedSockets;
+  get connectedSocketsCount() {
+    return this.sockets.size;
+  }
+  constructor(logger) {
+    super();
+    this.logger = logger;
+    this.httpServer = new Http.Server();
+    this.sockets = /* @__PURE__ */ new Set();
+    this.requestIterable = new import_feedable_async_iterable.FeedableAsyncIterable();
+    this.httpServer.on("request", (request, response) => {
+      this.logger.verbose(`${request.method} from "${request.socket.remoteAddress}" to "${request.url}"`);
+      this.requestIterable.feed({ request, response });
+    });
+  }
+  async [import_disposable.disposeAsync]() {
+    await this.close(3e3);
+    this.requestIterable.end();
+  }
+  async listen(port) {
+    if (this.httpServer.listening) {
+      throw new Error("http server is already listening");
     }
-    async *[Symbol.asyncIterator]() {
-        for await (const { request, response } of this.requestIterable) {
-            yield this.handleRequest(request, response);
-        }
+    this.httpServer.listen(port);
+    return new Promise((resolve, reject) => {
+      let listeningListener;
+      let errorListener;
+      listeningListener = () => {
+        this.logger.info(`Listening on port ${port}`);
+        this.untrackConnectedSockets = trackConnectedSockets(this.httpServer, this.sockets);
+        this.httpServer.removeListener("error", errorListener);
+        resolve();
+      };
+      errorListener = (error) => {
+        this.httpServer.removeListener("listening", listeningListener);
+        reject(error);
+      };
+      this.httpServer.once("listening", listeningListener);
+      this.httpServer.once("error", errorListener);
+    });
+  }
+  async close(timeout) {
+    this.logger.info("Closing http server");
+    const timer = new import_timer.Timer(true);
+    const close$ = (0, import_rxjs.bindNodeCallback)(this.httpServer.close.bind(this.httpServer))().pipe((0, import_rxjs.share)());
+    close$.subscribe();
+    while (true) {
+      const connections = await getConnectionsCount(this.httpServer);
+      if (connections == 0) {
+        break;
+      }
+      if (timer.milliseconds >= timeout) {
+        this.logger.info(`Force closing of ${connections} remaining sockets after waiting for ${timeout} milliseconds`);
+        destroySockets(this.sockets);
+        break;
+      }
+      if (connections > 0) {
+        this.logger.info(`Waiting for ${connections} connections to end`);
+        await (0, import_timing.cancelableTimeout)(250, import_cancellation_token.CancellationToken.from(close$));
+      }
     }
-    handleRequest(request, response) {
-        const method = request.method;
-        const url = new URL(request.url, `http://${request.headers.host}`);
-        const headers = new HttpHeaders(request.headers);
-        const query = HttpQuery.fromURLSearchParams(url.searchParams);
-        const context = { nodeRequest: request, nodeResponse: response };
-        const httpRequest = new HttpServerRequest({
-            url,
-            method,
-            headers,
-            query,
-            ip: request.socket.remoteAddress,
-            body: request
-        });
-        const item = {
-            request: httpRequest,
-            respond: getResponder(response),
-            context,
-            async close() {
-                return new Promise((resolve) => response.end(resolve));
-            }
-        };
-        return item;
+    this.untrackConnectedSockets?.();
+    this.untrackConnectedSockets = void 0;
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const { request, response } of this.requestIterable) {
+      yield this.handleRequest(request, response);
     }
+  }
+  handleRequest(request, response) {
+    const method = request.method;
+    const url = new URL(request.url, `http://${request.headers.host}`);
+    const headers = new import_http_headers.HttpHeaders(request.headers);
+    const query = import_http_query.HttpQuery.fromURLSearchParams(url.searchParams);
+    const context = { nodeRequest: request, nodeResponse: response };
+    const httpRequest = new import_http_server_request.HttpServerRequest({
+      url,
+      method,
+      headers,
+      query,
+      ip: request.socket.remoteAddress,
+      body: request
+    });
+    const item = {
+      request: httpRequest,
+      respond: getResponder(response),
+      context,
+      async close() {
+        return new Promise((resolve) => response.end(resolve));
+      }
+    };
+    return item;
+  }
 };
 NodeHttpServer = __decorate([
-    singleton(),
-    __param(0, resolveArg('NodeHttpServer')),
-    __metadata("design:paramtypes", [Logger])
+  (0, import_injector.Singleton)(),
+  __param(0, (0, import_injector.ResolveArg)("NodeHttpServer")),
+  __metadata("design:paramtypes", [import_logger.Logger])
 ], NodeHttpServer);
-// eslint-disable-next-line max-lines-per-function
 function getResponder(httpResponse) {
-    // eslint-disable-next-line max-statements
-    async function respond(response) {
-        writeHeaders(response, httpResponse);
-        return writeResponseBody(response, httpResponse);
-    }
-    return respond;
+  async function respond(response) {
+    writeHeaders(response, httpResponse);
+    return writeResponseBody(response, httpResponse);
+  }
+  return respond;
 }
 function writeHeaders(response, httpResponse) {
-    if (isDefined(response.body?.json)) {
-        httpResponse.setHeader('Content-Type', 'application/json; charset=utf-8');
-    }
-    else if (isDefined(response.body?.text)) {
-        httpResponse.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    }
-    else if (isDefined(response.body?.buffer)) {
-        httpResponse.setHeader('Content-Type', 'application/octet-stream');
-    }
-    else if (isDefined(response.body?.stream)) {
-        httpResponse.setHeader('Content-Type', 'application/octet-stream');
-    }
-    else if (isDefined(response.body?.events)) {
-        httpResponse.setHeader('Content-Type', 'text/event-stream');
-    }
-    for (const [name, value] of response.headers.normalizedEntries()) {
-        httpResponse.setHeader(name, value);
-    }
-    if (isDefined(response.statusCode)) {
-        httpResponse.statusCode = response.statusCode;
-    }
-    if (isDefined(response.statusMessage)) {
-        httpResponse.statusMessage = response.statusMessage;
-    }
+  if ((0, import_type_guards.isDefined)(response.body?.json)) {
+    httpResponse.setHeader("Content-Type", "application/json; charset=utf-8");
+  } else if ((0, import_type_guards.isDefined)(response.body?.text)) {
+    httpResponse.setHeader("Content-Type", "text/plain; charset=utf-8");
+  } else if ((0, import_type_guards.isDefined)(response.body?.buffer)) {
+    httpResponse.setHeader("Content-Type", "application/octet-stream");
+  } else if ((0, import_type_guards.isDefined)(response.body?.stream)) {
+    httpResponse.setHeader("Content-Type", "application/octet-stream");
+  } else if ((0, import_type_guards.isDefined)(response.body?.events)) {
+    httpResponse.setHeader("Content-Type", "text/event-stream");
+  }
+  for (const [name, value] of response.headers.normalizedEntries()) {
+    httpResponse.setHeader(name, value);
+  }
+  if ((0, import_type_guards.isDefined)(response.statusCode)) {
+    httpResponse.statusCode = response.statusCode;
+  }
+  if ((0, import_type_guards.isDefined)(response.statusMessage)) {
+    httpResponse.statusMessage = response.statusMessage;
+  }
 }
 async function writeResponseBody(response, httpResponse) {
-    const simpleData = isDefined(response.body?.json) ? JSON.stringify(response.body.json)
-        : isDefined(response.body?.text) ? response.body.text
-            : isDefined(response.body?.buffer) ? response.body.buffer
-                : undefined;
-    const streamData = isDefined(simpleData) ? undefined
-        : isDefined(response.body?.stream) ? response.body.stream
-            : isDefined(response.body?.events) ? response.body.events.readable
-                : undefined;
-    if (isDefined(simpleData)) {
-        const bytes = isString(simpleData) ? encodeUtf8(simpleData) : simpleData;
-        if (!httpResponse.hasHeader('Content-Length')) {
-            httpResponse.setHeader('Content-Length', bytes.byteLength);
-        }
-        await write(httpResponse, bytes);
+  const simpleData = (0, import_type_guards.isDefined)(response.body?.json) ? JSON.stringify(response.body.json) : (0, import_type_guards.isDefined)(response.body?.text) ? response.body.text : (0, import_type_guards.isDefined)(response.body?.buffer) ? response.body.buffer : void 0;
+  const streamData = (0, import_type_guards.isDefined)(simpleData) ? void 0 : (0, import_type_guards.isDefined)(response.body?.stream) ? response.body.stream : (0, import_type_guards.isDefined)(response.body?.events) ? response.body.events.readable : void 0;
+  if ((0, import_type_guards.isDefined)(simpleData)) {
+    const bytes = (0, import_type_guards.isString)(simpleData) ? (0, import_encoding.encodeUtf8)(simpleData) : simpleData;
+    if (!httpResponse.hasHeader("Content-Length")) {
+      httpResponse.setHeader("Content-Length", bytes.byteLength);
     }
-    else if (isDefined(streamData)) {
-        for await (const chunk of getReadableStreamIterable(streamData)) {
-            await write(httpResponse, chunk);
-        }
+    await write(httpResponse, bytes);
+  } else if ((0, import_type_guards.isDefined)(streamData)) {
+    for await (const chunk of (0, import_readable_stream_adapter.getReadableStreamIterable)(streamData)) {
+      await write(httpResponse, chunk);
     }
-    return new Promise((resolve) => {
-        httpResponse.end(resolve);
-    });
+  }
+  return new Promise((resolve) => {
+    httpResponse.end(resolve);
+  });
 }
 async function write(httpResponse, bytes) {
-    return new Promise((resolve, reject) => {
-        httpResponse.write(bytes, (error) => {
-            if (isNullOrUndefined(error)) {
-                resolve();
-            }
-            else {
-                reject(error);
-            }
-        });
+  return new Promise((resolve, reject) => {
+    httpResponse.write(bytes, (error) => {
+      if ((0, import_type_guards.isNullOrUndefined)(error)) {
+        resolve();
+      } else {
+        reject(error);
+      }
     });
+  });
 }
 function trackConnectedSockets(server, sockets) {
-    const connectionListener = (socket) => {
-        sockets.add(socket);
-        const closeListener = () => {
-            sockets.delete(socket);
-            socket.removeListener('close', closeListener);
-        };
-        socket.on('close', closeListener);
+  const connectionListener = (socket) => {
+    sockets.add(socket);
+    const closeListener = () => {
+      sockets.delete(socket);
+      socket.removeListener("close", closeListener);
     };
-    server.on('connection', connectionListener);
-    return () => server.removeListener('connection', connectionListener);
+    socket.on("close", closeListener);
+  };
+  server.on("connection", connectionListener);
+  return () => server.removeListener("connection", connectionListener);
 }
 async function getConnectionsCount(server) {
-    return new Promise((resolve, reject) => {
-        server.getConnections((error, count) => {
-            if (error != undefined) {
-                reject(error);
-                return;
-            }
-            resolve(count);
-        });
+  return new Promise((resolve, reject) => {
+    server.getConnections((error, count) => {
+      if (error != void 0) {
+        reject(error);
+        return;
+      }
+      resolve(count);
     });
+  });
 }
 function destroySockets(sockets) {
-    for (const socket of sockets) {
-        socket.destroy();
-    }
+  for (const socket of sockets) {
+    socket.destroy();
+  }
 }

package/http/types.js

@@ -1,25 +1,51 @@
-import { isArray, isNull } from '../utils/type-guards.js';
-export function normalizeHttpValue(value) {
-    if (isArray(value)) {
-        return value.map(normalizeSingleHttpValue);
-    }
-    return normalizeSingleHttpValue(value);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  denormalizeHttpValue: () => denormalizeHttpValue,
+  denormlizeSingleHttpValue: () => denormlizeSingleHttpValue,
+  normalizeHttpValue: () => normalizeHttpValue,
+  normalizeSingleHttpValue: () => normalizeSingleHttpValue
+});
+module.exports = __toCommonJS(types_exports);
+var import_type_guards = require("../utils/type-guards.js");
+function normalizeHttpValue(value) {
+  if ((0, import_type_guards.isArray)(value)) {
+    return value.map(normalizeSingleHttpValue);
+  }
+  return normalizeSingleHttpValue(value);
 }
-export function normalizeSingleHttpValue(value) {
-    if (isNull(value)) {
-        return '[[null]]';
-    }
-    return value.toString();
+function normalizeSingleHttpValue(value) {
+  if ((0, import_type_guards.isNull)(value)) {
+    return "[[null]]";
+  }
+  return value.toString();
 }
-export function denormalizeHttpValue(value) {
-    if (isArray(value)) {
-        return value.map(denormlizeSingleHttpValue);
-    }
-    return denormlizeSingleHttpValue(value);
+function denormalizeHttpValue(value) {
+  if ((0, import_type_guards.isArray)(value)) {
+    return value.map(denormlizeSingleHttpValue);
+  }
+  return denormlizeSingleHttpValue(value);
 }
-export function denormlizeSingleHttpValue(value) {
-    if (value == '[[null]]') {
-        return null;
-    }
-    return value;
+function denormlizeSingleHttpValue(value) {
+  if (value == "[[null]]") {
+    return null;
+  }
+  return value;
 }