@tstdl/base 0.93.36 → 0.93.38

package/source/http/http-headers.ts

@@ -1,124 +0,0 @@
-import { BadRequestError } from '#/errors/bad-request.error.js';
-import { numberPattern } from '#/utils/patterns.js';
-import { isNotNumber, isNotString, isNullOrUndefined, isNumber, isString, isUndefined } from '#/utils/type-guards.js';
-import type { HttpValueMapInput } from './http-value-map.js';
-import { HttpValueMap } from './http-value-map.js';
-import type { HttpValueObject, NormalizedHttpValueObject } from './types.js';
-
-export type HttpHeadersObject = HttpValueObject;
-
-export type HttpHeadersInput = HttpValueMapInput;
-
-export type NormalizedHttpHeadersObject = NormalizedHttpValueObject;
-
-export class HttpHeaders extends HttpValueMap<HttpHeaders> {
-  get accept(): string | undefined {
-    return this.tryGetStringHeader('Accept');
-  }
-
-  set accept(value: string | undefined) {
-    this.set('Accept', value);
-  }
-
-  get contentType(): string | undefined {
-    return this.tryGetStringHeader('Content-Type');
-  }
-
-  set contentType(value: string | undefined) {
-    this.set('Content-Type', value);
-  }
-
-  get contentLength(): number | undefined {
-    return this.tryGetNumberHeader('Content-Length');
-  }
-
-  set contentLength(value: number | undefined) {
-    this.set('Content-Length', value);
-  }
-
-  get contentDisposition(): string | undefined {
-    return this.tryGetStringHeader('Content-Disposition');
-  }
-
-  set contentDisposition(value: string | undefined) {
-    this.set('Content-Disposition', value);
-  }
-
-  get contentEncoding(): string | undefined {
-    return this.tryGetStringHeader('Content-Encoding');
-  }
-
-  set contentEncoding(value: string | undefined) {
-    this.set('Content-Encoding', value);
-  }
-
-  get authorization(): string | undefined {
-    return this.tryGetStringHeader('Authorization');
-  }
-
-  set authorization(value: string | undefined) {
-    this.set('Authorization', value);
-  }
-
-  /** get charset from {@link contentType} */
-  get charset(): string | undefined {
-    const contentType = this.contentType;
-
-    if (isUndefined(contentType)) {
-      return undefined;
-    }
-
-    const charset = contentType.split(';').find((value) => value.trim().startsWith('charset='));
-    return charset?.split('=')[1]?.trim();
-  }
-
-  constructor(input?: HttpValueMapInput) {
-    super('header', true, input);
-  }
-
-  clone(): HttpHeaders {
-    return new HttpHeaders(this);
-  }
-
-  private tryGetNumberHeader(name: string): number | undefined {
-    const value = this.tryGet(name);
-
-    if (isNullOrUndefined(value)) {
-      return undefined;
-    }
-
-    if (isNumber(value)) {
-      return value;
-    }
-
-    if (isString(value) && numberPattern.test(value)) {
-      const numberValue = Number(value);
-
-      if (Number.isNaN(numberValue)) {
-        throw new BadRequestError(`Invalid ${name} header.`);
-      }
-
-      return numberValue;
-    }
-
-    if (isNotNumber(value)) {
-      throw new BadRequestError(`Invalid ${name} header.`);
-    }
-
-    return value;
-  }
-
-  private tryGetStringHeader(name: string): string | undefined {
-    const value = this.tryGet(name);
-
-    if (isNullOrUndefined(value)) {
-      return undefined;
-    }
-
-    if (isNotString(value)) {
-      throw new BadRequestError(`Invalid ${name} header.`);
-    }
-
-    return value;
-  }
-}

package/source/http/http-query.ts

@@ -1,26 +0,0 @@
-import { HttpValueMap, type HttpValueMapInput } from './http-value-map.js';
-import type { HttpValueObject, NormalizedHttpValueObject } from './types.js';
-
-export type HttpQueryObject = HttpValueObject;
-
-export type NormalizedHttpQueryObject = NormalizedHttpValueObject;
-
-export class HttpQuery extends HttpValueMap<HttpQuery> {
-  constructor(input?: HttpValueMapInput) {
-    super('query', false, input);
-  }
-
-  static fromURLSearchParams(urlSearchParams: URLSearchParams): HttpQuery {
-    const query = new HttpQuery();
-
-    for (const [key, value] of urlSearchParams) {
-      query.append(key, value);
-    }
-
-    return query;
-  }
-
-  clone(): HttpQuery {
-    return new HttpQuery(this);
-  }
-}

package/source/http/http-url-parameters.ts

@@ -1,17 +0,0 @@
-import type { HttpValueMapInput } from './http-value-map.js';
-import { HttpValueMap } from './http-value-map.js';
-import type { HttpValueObject, NormalizedHttpValueObject } from './types.js';
-
-export type HttpUrlParametersObject = HttpValueObject;
-
-export type NormalizedHttpUrlParametersObject = NormalizedHttpValueObject;
-
-export class HttpUrlParameters extends HttpValueMap<HttpUrlParameters> {
-  constructor(input?: HttpValueMapInput) {
-    super('url-parameter', false, input);
-  }
-
-  clone(): HttpUrlParameters {
-    return new HttpUrlParameters(this);
-  }
-}

package/source/http/http-value-map.ts

@@ -1,147 +0,0 @@
-import { BadRequestError } from '#/errors/bad-request.error.js';
-import type { OneOrMany, Record } from '#/types/index.js';
-import { toArray } from '#/utils/array/array.js';
-import { isIterable } from '#/utils/iterable-helpers/is-iterable.js';
-import { objectEntries } from '#/utils/object/object.js';
-import { isArray, isDefined, isUndefined } from '#/utils/type-guards.js';
-import type { HttpValue, NormalizedHttpValue, NormalizedHttpValueObject } from './types.js';
-import { denormalizeHttpValue, normalizeHttpValue } from './types.js';
-
-export type HttpValueMapInput = Record<string, OneOrMany<HttpValue> | undefined> | Iterable<[string, OneOrMany<HttpValue> | undefined]>;
-
-export abstract class HttpValueMap<TThis extends HttpValueMap<any>> implements Iterable<[string, OneOrMany<HttpValue>]> {
-  private readonly valueType: string;
-  private readonly caseInsensitive: boolean;
-  private readonly map: Map<string, { actualKey: string, value: OneOrMany<HttpValue> }>;
-
-  constructor(valueType: string, caseInsensitive: boolean, input?: HttpValueMapInput) {
-    this.valueType = valueType;
-    this.caseInsensitive = caseInsensitive;
-
-    this.map = new Map();
-
-    if (isDefined(input)) {
-      this.setMany(input);
-    }
-  }
-
-  /** check if entry is available */
-  has(key: string): boolean {
-    return this.map.has(this.normalizeKey(key));
-  }
-
-  /** get value. Throws if entry not set */
-  get(key: string): OneOrMany<HttpValue> {
-    const normalizedKey = this.normalizeKey(key);
-
-    if (!this.has(normalizedKey)) {
-      throw new BadRequestError(`Missing ${normalizedKey} ${this.valueType}`);
-    }
-
-    return this.map.get(normalizedKey)!.value;
-  }
-
-  /** try to get value */
-  tryGet(key: string): OneOrMany<HttpValue> | undefined {
-    return this.map.get(this.normalizeKey(key))?.value;
-  }
-
-  /** get single value, throws if multiple values are set */
-  getSingle(key: string): HttpValue {
-    const value = this.tryGetSingle(key);
-
-    if (isUndefined(value)) {
-      throw new BadRequestError(`Missing ${key} ${this.valueType}`);
-    }
-
-    return value;
-  }
-
-  /** try to get single value, throws if multiple values are set */
-  tryGetSingle(key: string): HttpValue | undefined {
-    const normalizedKey = this.normalizeKey(key);
-    const value = this.map.get(normalizedKey)?.value;
-
-    if (isArray(value)) {
-      throw new BadRequestError(`Invalid ${key} ${this.valueType}. Expected single value.`);
-    }
-
-    return value;
-  }
-
-  /** replace entry */
-  set(key: string, value: OneOrMany<HttpValue> | undefined): void {
-    if (isUndefined(value)) {
-      this.remove(key);
-      return;
-    }
-
-    this.map.set(this.normalizeKey(key), { actualKey: key, value: denormalizeHttpValue(value) });
-  }
-
-  /** set entry if missing */
-  setIfMissing(key: string, value: OneOrMany<HttpValue> | undefined): void {
-    if (!this.has(key)) {
-      this.set(key, value);
-    }
-  }
-
-  setMany(input: HttpValueMapInput): void {
-    const iterable = isIterable(input) ? input : objectEntries(input);
-
-    for (const [key, value] of iterable) {
-      if (isDefined(value)) {
-        this.set(key, value);
-      }
-    }
-  }
-
-  /** add value to existing entry or create new entry */
-  append(key: string, value: OneOrMany<HttpValue>): void {
-    const existing = this.tryGet(key);
-    const newValue = isUndefined(existing) ? value : [...toArray(existing), ...toArray(value)];
-
-    this.set(key, newValue);
-  }
-
-  /** remove entry */
-  remove(key: string): void {
-    this.map.delete(this.normalizeKey(key));
-  }
-
-  /** remove all entries */
-  clear(): void {
-    this.map.clear();
-  }
-
-  asObject(): Record<string, OneOrMany<HttpValue>> {
-    return Object.fromEntries(this);
-  }
-
-  asNormalizedObject(): NormalizedHttpValueObject {
-    const entries = [...this].map(([key, value]) => [key, normalizeHttpValue(value)] as const);
-    return Object.fromEntries(entries);
-  }
-
-  *normalizedEntries(): Iterable<[string, OneOrMany<NormalizedHttpValue>]> {
-    for (const [key, value] of this) {
-      yield [key, normalizeHttpValue(value)];
-    }
-  }
-
-  *[Symbol.iterator](): Iterator<[string, OneOrMany<HttpValue>]> {
-    for (const [, { actualKey, value }] of this.map) {
-      yield [actualKey, value];
-    }
-  }
-
-  private normalizeKey(key: string): string {
-    if (this.caseInsensitive) {
-      return key.toLowerCase();
-    }
-
-    return key;
-  }
-
-  abstract clone(): TThis;
-}

package/source/http/http.error.ts

@@ -1,89 +0,0 @@
-import type { Record, TypedOmit, UndefinableJson } from '#/types/index.js';
-import type { ErrorExtraInfo } from '#/utils/format-error.js';
-import { propertyNameOf } from '#/utils/object/property-name.js';
-import { isDefined, isNotString, isString } from '#/utils/type-guards.js';
-import { CustomError } from '../errors/custom.error.js';
-import type { HttpClientRequest, HttpClientRequestObject, HttpClientResponse, HttpClientResponseObject } from './client/index.js';
-
-export enum HttpErrorReason {
-  Unknown = 'Unknown',
-  Cancelled = 'Cancelled',
-  Network = 'Network',
-  InvalidRequest = 'InvalidRequest',
-  StatusCode = 'StatusCode',
-
-  /** Valid http response containing an error */
-  ErrorResponse = 'ErrorResponse',
-
-  /** Invalid http response */
-  ResponseError = 'ResponseError',
-
-  Timeout = 'Timeout',
-}
-
-export class HttpError extends CustomError implements ErrorExtraInfo {
-  static readonly errorName = 'HttpError';
-
-  readonly reason: HttpErrorReason;
-  readonly request: HttpClientRequestObject;
-  readonly response: TypedOmit<HttpClientResponseObject, 'request'> | undefined;
-  readonly responseBody: UndefinableJson | Uint8Array;
-  readonly requestInstance: HttpClientRequest;
-  readonly responseInstance: HttpClientResponse | undefined;
-
-  constructor(reason: HttpErrorReason, request: HttpClientRequest, { response, responseBody, cause }: { response?: HttpClientResponse, responseBody?: UndefinableJson | Uint8Array, cause?: Error | string } = {}) {
-    super({ message: (isString(cause) ? cause : cause?.message) ?? 'An error occurred', cause: (isNotString(cause) ? cause : new Error(cause)) });
-
-    this.reason = reason;
-    this.request = request.asObject();
-    this.response = response?.asObject();
-
-    if (isDefined(this.response)) {
-      Reflect.deleteProperty(this.response, 'request');
-    }
-
-    if (isDefined(responseBody)) {
-      this.responseBody = responseBody;
-    }
-
-    Object.defineProperty(this, propertyNameOf<this>((instance) => instance.requestInstance), {
-      value: request,
-      enumerable: false,
-    });
-
-    Object.defineProperty(this, propertyNameOf<this>((instance) => instance.responseInstance), {
-      value: response,
-      enumerable: false,
-    });
-  }
-
-  static async create(reason: HttpErrorReason, request: HttpClientRequest, response: HttpClientResponse | undefined, cause?: Error | string): Promise<HttpError> {
-    const body = (response?.body.available == true) ? await response.body.read() : undefined;
-    return new HttpError(reason, request, { response, responseBody: body, cause });
-  }
-
-  getExtraInfo(): UndefinableJson | undefined {
-    const extraInfo: Record<string> = {
-      url: this.request.url,
-      method: this.request.method,
-    };
-
-    if (isDefined(this.response)) {
-      const responseExtraInfo: Record<string> = {};
-
-      responseExtraInfo['statusCode'] = this.response.statusCode;
-      responseExtraInfo['statusMessage'] = this.response.statusMessage;
-      responseExtraInfo['headers'] = this.response.headers;
-
-      if (isDefined(this.responseBody)) {
-        responseExtraInfo['body'] = (this.responseBody instanceof Uint8Array)
-          ? '[Uint8Array]'
-          : this.responseBody;
-      }
-
-      extraInfo['response'] = responseExtraInfo;
-    }
-
-    return extraInfo;
-  }
-}

package/source/http/index.ts

@@ -1,19 +0,0 @@
-/**
- * HTTP Server and Client
- *
- * @module HTTP
- */
-
-export * from './client/index.js';
-export * from './cookie-parser.js';
-export * from './http-body.js';
-export * from './http-form.js';
-export * from './http-headers.js';
-export * from './http-query.js';
-export * from './http-url-parameters.js';
-export * from './http-value-map.js';
-export * from './http.error.js';
-export * from './server/index.js';
-export * from './tokens.js';
-export * from './types.js';
-export * from './utils.js';

package/source/http/server/http-server-request.ts

@@ -1,40 +0,0 @@
-import type { Record } from '#/types/index.js';
-import { CookieParser } from '../cookie-parser.js';
-import type { HttpBodySource } from '../http-body.js';
-import { HttpBody } from '../http-body.js';
-import type { HttpHeaders } from '../http-headers.js';
-import type { HttpQuery } from '../http-query.js';
-import type { HttpMethod } from '../types.js';
-
-export type HttpServerRequestObject = Pick<HttpServerRequest, 'url' | 'method' | 'headers' | 'query' | 'ip'> & {
-  body: HttpBody | HttpBodySource,
-  context?: Record<string>,
-};
-
-export class HttpServerRequest {
-  readonly url: URL;
-  readonly method: HttpMethod;
-  readonly headers: HttpHeaders;
-  readonly cookies: CookieParser;
-  readonly query: HttpQuery;
-  readonly body: HttpBody;
-  readonly ip: string;
-
-  context: Record<string>;
-
-  get hasBody(): boolean {
-    return this.body.available;
-  }
-
-  constructor(data: HttpServerRequestObject) {
-    this.url = data.url;
-    this.method = data.method;
-    this.headers = data.headers;
-    this.cookies = new CookieParser(this.headers);
-    this.query = data.query;
-    this.ip = data.ip;
-    this.body = (data.body instanceof HttpBody) ? data.body : new HttpBody(data.body, this.headers);
-
-    this.context = data.context ?? {};
-  }
-}

package/source/http/server/http-server-response.ts

@@ -1,75 +0,0 @@
-import type { SetCookieOptions } from '#/cookie/cookie.js';
-import { formatSetCookie } from '#/cookie/cookie.js';
-import type { ServerSentEventsSource } from '#/sse/server-sent-events-source.js';
-import type { Record } from '#/types/index.js';
-import { objectEntries } from '#/utils/object/object.js';
-import { isDefined } from '#/utils/type-guards.js';
-import type { HttpHeadersInput } from '../http-headers.js';
-import { HttpHeaders } from '../http-headers.js';
-
-export type SetCookieObject = SetCookieOptions & {
-  value: string,
-};
-
-export type HttpServerResponseOptions = {
-  statusCode?: number | undefined,
-  statusMessage?: string | undefined,
-  headers?: HttpHeadersInput | HttpHeaders,
-  cookies?: Record<string, SetCookieObject>,
-  body?: {
-    stream?: ReadableStream<Uint8Array>,
-    buffer?: Uint8Array,
-    text?: string,
-    json?: unknown,
-    events?: ServerSentEventsSource,
-  },
-};
-
-export class HttpServerResponse {
-  statusCode: number | undefined;
-  statusMessage: string | undefined;
-  headers: HttpHeaders;
-  body: undefined | {
-    stream?: ReadableStream<Uint8Array>,
-    buffer?: Uint8Array,
-    text?: string,
-    json?: unknown,
-    events?: ServerSentEventsSource,
-  };
-
-  constructor(response: HttpServerResponseOptions = {}) {
-    this.update(response);
-  }
-
-  static fromObject(options?: HttpServerResponseOptions): HttpServerResponse {
-    return new HttpServerResponse(options);
-  }
-
-  static redirect(url: string, options?: HttpServerResponseOptions) {
-    return new HttpServerResponse({
-      statusCode: 303,
-      ...options,
-      headers: {
-        Location: url,
-        ...options?.headers,
-      },
-    });
-  }
-
-  update(options: HttpServerResponseOptions): void {
-    this.statusCode = options.statusCode;
-    this.statusMessage = options.statusMessage;
-    this.headers = new HttpHeaders(options.headers);
-    this.body = options.body;
-
-    if (isDefined(options.cookies)) {
-      for (const [name, cookie] of objectEntries(options.cookies)) {
-        this.headers.append('Set-Cookie', formatSetCookie(name, cookie.value, cookie));
-      }
-    }
-  }
-}
-
-export function redirect(url: string, options?: HttpServerResponseOptions): HttpServerResponse {
-  return HttpServerResponse.redirect(url, options);
-}

package/source/http/server/http-server.ts

@@ -1,18 +0,0 @@
-import type { HttpServerRequest, HttpServerResponse } from '#/http/server/index.js';
-
-export type HttpServerRequestContext<Context = unknown> = {
-  request: HttpServerRequest,
-  context: Context,
-  respond(response: HttpServerResponse): Promise<void>,
-  close(): Promise<void>,
-};
-
-export abstract class HttpServer<Context = unknown> implements AsyncIterable<HttpServerRequestContext<Context>>, AsyncDisposable {
-  abstract readonly connectedSocketsCount: number;
-
-  abstract listen(port: number): Promise<void>;
-  abstract close(timeout: number): Promise<void>;
-
-  abstract [Symbol.asyncIterator](): AsyncIterator<HttpServerRequestContext<Context>>;
-  abstract [Symbol.asyncDispose](): Promise<void>;
-}

package/source/http/server/index.ts

@@ -1,3 +0,0 @@
-export * from './http-server-request.js';
-export * from './http-server-response.js';
-export * from './http-server.js';

package/source/http/server/node/index.ts

@@ -1,2 +0,0 @@
-export * from './module.js';
-export * from './node-http-server.js';

package/source/http/server/node/module.ts

@@ -1,20 +0,0 @@
-import { Injector } from '#/injector/injector.js';
-import { HttpServer } from '../http-server.js';
-import { NodeHttpServer } from './node-http-server.js';
-
-export class NodeHttpServerConfiguration {
-  trustedProxiesCount: number;
-};
-
-/**
- * registers {@link HttpServer} in global container
- */
-export function configureNodeHttpServer(configuration: Partial<NodeHttpServerConfiguration> = {}): void {
-  Injector.register(NodeHttpServerConfiguration, {
-    useValue: {
-      trustedProxiesCount: configuration.trustedProxiesCount ?? 0,
-    },
-  });
-
-  Injector.registerSingleton(HttpServer, { useToken: NodeHttpServer });
-}