@everyonesoftware/common 2.0.0 → 4.0.0

package/sources/httpHeaders.ts

@@ -1,216 +0,0 @@
-import { EqualFunctions } from "./equalFunctions";
-import { HttpHeader } from "./httpHeader";
-import { Iterable } from "./iterable";
-import { Iterator } from "./iterator";
-import { JavascriptIterable, JavascriptIterator } from "./javascript";
-import { MutableHttpHeaders } from "./mutableHttpHeaders";
-import { NotFoundError } from "./notFoundError";
-import { AsyncResult } from "./asyncResult";
-import { SyncResult } from "./syncResult";
-import { ToStringFunctions } from "./toStringFunctions";
-import { Type } from "./types";
-
-/**
- * A collection of {@link HttpHeader}s.
- */
-export abstract class HttpHeaders implements Iterable<HttpHeader>
-{
-    public static readonly contentTypeHeaderName: string = "Content-Type";
-
-    public static create(headers?: JavascriptIterable<HttpHeader>): MutableHttpHeaders
-    {
-        return MutableHttpHeaders.create(headers);
-    }
-
-    /**
-     * Get the header with the provided name.
-     * @param headerName The name of the header.
-     */
-    public abstract get(headerName: string): SyncResult<HttpHeader>;
-
-    /**
-     * Get the value of the header with the provided name.
-     * @param headerName The name of the header.
-     */
-    public abstract getValue(headerName: string): SyncResult<string>;
-
-    public getContentType(): AsyncResult<HttpHeader>
-    {
-        return HttpHeaders.getContentType(this);
-    }
-
-    public static getContentType(headers: HttpHeaders): AsyncResult<HttpHeader>
-    {
-        return headers.get(HttpHeaders.contentTypeHeaderName);
-    }
-
-    public getContentTypeValue(): AsyncResult<string>
-    {
-        return HttpHeaders.getContentTypeValue(this);
-    }
-
-    public static getContentTypeValue(headers: HttpHeaders): AsyncResult<string>
-    {
-        return headers.getValue(HttpHeaders.contentTypeHeaderName);
-    }
-
-    /**
-     * Get an {@link Iterator} that can be used to iterate through the {@link HttpHeader}s in this
-     * collection.
-     */
-    public abstract iterate(): Iterator<HttpHeader>;
-
-    /**
-     * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
-     */
-    public toArray(): SyncResult<HttpHeader[]>
-    {
-        return HttpHeaders.toArray(this);
-    }
-
-    public static toArray(headers: HttpHeaders): SyncResult<HttpHeader[]>
-    {
-        return Iterable.toArray(headers);
-    }
-
-    public any(): SyncResult<boolean>
-    {
-        return HttpHeaders.any(this);
-    }
-
-    public static any(headers: HttpHeaders): SyncResult<boolean>
-    {
-        return Iterable.any(headers);
-    }
-
-    public getCount(): SyncResult<number>
-    {
-        return HttpHeaders.getCount(this);
-    }
-
-    public static getCount(headers: HttpHeaders): SyncResult<number>
-    {
-        return Iterable.getCount(headers);
-    }
-
-    public equals(right: JavascriptIterable<HttpHeader>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return HttpHeaders.equals(this, right, equalFunctions);
-    }
-
-    public static equals(headers: HttpHeaders, right: JavascriptIterable<HttpHeader>, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return Iterable.equals(headers, right, equalFunctions);
-    }
-
-    public toString(toStringFunctions?: ToStringFunctions): string
-    {
-        return HttpHeaders.toString(this, toStringFunctions);
-    }
-
-    public static toString(headers: HttpHeaders, toStringFunctions?: ToStringFunctions): string
-    {
-        return Iterable.toString(headers, toStringFunctions);
-    }
-
-    public concatenate(...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable<HttpHeader>
-    {
-        return HttpHeaders.concatenate(this, ...toConcatenate);
-    }
-
-    public static concatenate(headers: HttpHeaders, ...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable<HttpHeader>
-    {
-        return Iterable.concatenate(headers, ...toConcatenate);
-    }
-
-    public map<TOutput>(mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return HttpHeaders.map(this, mapping);
-    }
-
-    public static map<TOutput>(headers: HttpHeaders, mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>
-    {
-        return Iterable.map(headers, mapping);
-    }
-
-    public flatMap<TOutput>(mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return HttpHeaders.flatMap(this, mapping);
-    }
-
-    public static flatMap<TOutput>(headers: HttpHeaders, mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable<TOutput>
-    {
-        return Iterable.flatMap(headers, mapping);
-    }
-
-    public where(condition: (value: HttpHeader) => boolean): Iterable<HttpHeader>
-    {
-        return HttpHeaders.where(this, condition);
-    }
-
-    public static where(headers: HttpHeaders, condition: (value: HttpHeader) => (boolean | SyncResult<boolean>)): Iterable<HttpHeader>
-    {
-        return Iterable.where(headers, condition);
-    }
-
-    public instanceOf<TOutput extends HttpHeader>(typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable<TOutput>
-    {
-        return HttpHeaders.instanceOf(this, typeOrTypeCheck);
-    }
-
-    public static instanceOf<TOutput extends HttpHeader>(headers: HttpHeaders, typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable<TOutput>
-    {
-        return Iterable.instanceOf(headers, typeOrTypeCheck);
-    }
-
-    public first(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>
-    {
-        return HttpHeaders.first(this, condition);
-    }
-
-    public static first(headers: HttpHeaders, condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>
-    {
-        return Iterable.first(headers, condition);
-    }
-
-    public last(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>
-    {
-        return HttpHeaders.last(this, condition);
-    }
-
-    public static last(headers: HttpHeaders, condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>
-    {
-        return Iterable.last(headers, condition);
-    }
-
-    public [Symbol.iterator](): JavascriptIterator<HttpHeader>
-    {
-        return HttpHeaders[Symbol.iterator](this);
-    }
-
-    public static [Symbol.iterator](headers: HttpHeaders): JavascriptIterator<HttpHeader>
-    {
-        return Iterable[Symbol.iterator](headers);
-    }
-
-    public contains(value: HttpHeader, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return HttpHeaders.contains(this, value, equalFunctions);
-    }
-
-    public static contains(headers: HttpHeaders, value: HttpHeader, equalFunctions?: EqualFunctions): SyncResult<boolean>
-    {
-        return SyncResult.create(() =>
-        {
-            if (!equalFunctions)
-            {
-                equalFunctions = EqualFunctions.create();
-            }
-
-            return headers.getValue(value.getName())
-                .then((headerValue: string) => equalFunctions!.areEqual(headerValue, value.getValue()).await())
-                .catch(NotFoundError, () => false)
-                .await();
-        });
-    }
-}

package/sources/httpIncomingRequest.ts

@@ -1,30 +0,0 @@
-import { HttpHeader } from "./httpHeader";
-import { HttpHeaders } from "./httpHeaders";
-import { HttpMethod } from "./httpMethod";
-import { AsyncResult } from "./asyncResult";
-
-/**
- * A HTTP request that is received by a {@link HttpServer}.
- */
-export abstract class HttpIncomingRequest
-{
-    /**
-     * Get the {@link HttpMethod} of the request.
-     */
-    public abstract getMethod(): HttpMethod;
-
-    public abstract getHost(): AsyncResult<string>;
-
-    /**
-     * Get the path component of the requested URL.
-     */
-    public abstract getURLPath(): string;
-
-    public abstract getHeaders(): AsyncResult<HttpHeaders>;
-
-    public abstract getHeader(headerName: string): AsyncResult<HttpHeader>;
-
-    public abstract getHeaderValue(headerName: string): AsyncResult<string>;
-
-    public abstract getBody(): AsyncResult<string>;
-}

package/sources/httpIncomingResponse.ts

@@ -1,19 +0,0 @@
-import { HttpHeader } from "./httpHeader";
-import { HttpHeaders } from "./httpHeaders";
-import { AsyncResult } from "./asyncResult";
-
-/**
- * The response from a {@link HttpClient}'s sendRequest() method.
- */
-export abstract class HttpIncomingResponse
-{
-    public abstract getStatusCode(): number;
-
-    public abstract getHeaders(): AsyncResult<HttpHeaders>;
-
-    public abstract getHeader(headerName: string): AsyncResult<HttpHeader>;
-
-    public abstract getHeaderValue(headerName: string): AsyncResult<string>;
-
-    public abstract getBody(): AsyncResult<string>;
-}

package/sources/httpMethod.ts

@@ -1,164 +0,0 @@
-import { NotFoundError } from "./notFoundError";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-
-export enum HttpMethod
-{
-    /**
-     * The GET method requests a representation of the specified resource. Requests using GET should
-     * only retrieve data and should not contain a request content.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/GET
-     */
-    GET,
-    /**
-     * The HEAD method asks for a response identical to a GET request, but without a response body.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/HEAD
-     */
-    HEAD,
-    /**
-     * The POST method submits an entity to the specified resource, often causing a change in state
-     * or side effects on the server.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/POST
-     */
-    POST,
-    /**
-     * The PUT method replaces all current representations of the target resource with the request
-     * content.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/PUT
-     */
-    PUT,
-    /**
-     * The DELETE method deletes the specified resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/DELETE
-     */
-    DELETE,
-    /**
-     * The CONNECT method establishes a tunnel to the server identified by the target resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/CONNECT
-     */
-    CONNECT,
-    /**
-     * The OPTIONS method describes the communication options for the target resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/OPTIONS
-     */
-    OPTIONS,
-    /**
-     * The TRACE method performs a message loop-back test along the path to the target resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/TRACE
-     */
-    TRACE,
-    /**
-     * The PATCH method applies partial modifications to a resource.
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/PATCH
-     */
-    PATCH,
-}
-
-/**
- * Parse a {@link HttpMethod} from the provided text.
- * @param text The text to parse.
- */
-export function parseHttpMethod(text: string): SyncResult<HttpMethod>
-{
-    return SyncResult.create(() =>
-    {
-        let result: HttpMethod;
-
-        switch (text.toUpperCase())
-        {
-            case "GET":
-                result = HttpMethod.GET;
-                break;
-
-            case "HEAD":
-                result = HttpMethod.HEAD;
-                break;
-
-            case "POST":
-                result = HttpMethod.POST;
-                break;
-
-            case "PUT":
-                result = HttpMethod.PUT;
-                break;
-
-            case "DELETE":
-                result = HttpMethod.DELETE;
-                break;
-
-            case "CONNECT":
-                result = HttpMethod.CONNECT;
-                break;
-
-            case "OPTIONS":
-                result = HttpMethod.OPTIONS;
-                break;
-
-            case "TRACE":
-                result = HttpMethod.TRACE;
-                break;
-
-            case "PATCH":
-                result = HttpMethod.PATCH;
-                break;
-
-            default:
-                throw new NotFoundError(`No HttpMethod exists for the text "${text}".`);
-        }
-
-        return result;
-    });
-}
-
-/**
- * Get the string representation of the provided {@link HttpMethod}.
- * @param httpMethod The {@link HttpMethod} to get the string representation of.
- */
-export function httpMethodToString(httpMethod: HttpMethod): string
-{
-    PreCondition.assertNotUndefinedAndNotNull(httpMethod, "httpMethod");
-
-    let result: string;
-    switch (httpMethod)
-    {
-        case HttpMethod.GET:
-            result = "GET";
-            break;
-
-        case HttpMethod.HEAD:
-            result = "HEAD";
-            break;
-
-        case HttpMethod.POST:
-            result = "POST";
-            break;
-
-        case HttpMethod.PUT:
-            result = "PUT";
-            break;
-
-        case HttpMethod.DELETE:
-            result = "DELETE";
-            break;
-
-        case HttpMethod.CONNECT:
-            result = "CONNECT";
-            break;
-
-        case HttpMethod.OPTIONS:
-            result = "OPTIONS";
-            break;
-
-        case HttpMethod.TRACE:
-            result = "TRACE";
-            break;
-
-        case HttpMethod.PATCH:
-            result = "PATCH";
-            break;
-
-        default:
-            throw new NotFoundError(`Unrecognized HttpMethod: ${httpMethod}`);
-    }
-    return result;
-}

package/sources/httpOutgoingRequest.ts

@@ -1,119 +0,0 @@
-import { HttpHeader } from "./httpHeader";
-import { HttpHeaders } from "./httpHeaders";
-import { HttpMethod } from "./httpMethod";
-import { MutableHttpHeaders } from "./mutableHttpHeaders";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-
-/**
- * A HTTP request that is sent out by a {@link HttpClient}.
- */
-export class HttpOutgoingRequest
-{
-    private method: HttpMethod;
-    private url: string;
-    private readonly headers: MutableHttpHeaders;
-    private body: string;
-
-    private constructor(method: HttpMethod, url: string)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(method, "method");
-        PreCondition.assertNotEmpty(url, "url");
-
-        this.method = method;
-        this.url = url;
-        this.headers = HttpHeaders.create();
-        this.body = "";
-    }
-
-    public static create(method: HttpMethod, url: string): HttpOutgoingRequest
-    {
-        return new HttpOutgoingRequest(method, url);
-    }
-
-    /**
-     * Create a new {@link HttpOutgoingRequest} with a GET {@link HttpMethod}.
-     * @param url The target URL for the {@link HttpOutgoingRequest}.
-     */
-    public static get(url: string): HttpOutgoingRequest
-    {
-        return HttpOutgoingRequest.create(HttpMethod.GET, url);
-    }
-
-    /**
-     * Get the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
-     */
-    public getMethod(): HttpMethod
-    {
-        return this.method;
-    }
-
-    /**
-     * Set the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
-     * @param method The {@link HttpMethod} for this {@link HttpOutgoingRequest}.
-     */
-    public setMethod(method: HttpMethod): this
-    {
-        PreCondition.assertNotUndefinedAndNotNull(method, "method");
-
-        this.method = method;
-
-        return this;
-    }
-
-    /**
-     * Get this {@link HttpOutgoingRequest}'s target URL.
-     */
-    public getURL(): string
-    {
-        return this.url;
-    }
-
-    /**
-     * Set the URL that this request will be sent to.
-     * @param url The URL to send this request to.
-     */
-    public setURL(url: string): this
-    {
-        PreCondition.assertNotEmpty(url, "url");
-
-        this.url = url;
-
-        return this;
-    }
-
-    /**
-     * Get the {@link HttpHeaders} that will be sent.
-     */
-    public getHeaders(): HttpHeaders
-    {
-        return this.headers;
-    }
-
-    public getHeader(headerName: string): SyncResult<HttpHeader>
-    {
-        return this.headers.get(headerName);
-    }
-
-    public getHeaderValue(headerName: string): SyncResult<string>
-    {
-        return this.headers.getValue(headerName);
-    }
-
-    /**
-     * Get the body that will be sent.
-     */
-    public getBody(): string
-    {
-        return this.body;
-    }
-
-    public setBody(body: string): this
-    {
-        PreCondition.assertNotUndefinedAndNotNull(body, "body");
-
-        this.body = body;
-
-        return this;
-    }
-}

package/sources/httpOutgoingResponse.ts

@@ -1,113 +0,0 @@
-import { HttpHeader } from "./httpHeader";
-import { HttpHeaders } from "./httpHeaders";
-import { MutableHttpHeaders } from "./mutableHttpHeaders";
-import { PreCondition } from "./preCondition";
-import { SyncResult } from "./syncResult";
-
-/**
- * A HTTP response that is sent out by an {@link HttpServer}.
- */
-export class HttpOutgoingResponse
-{
-    private statusCode: number;
-    private readonly headers: MutableHttpHeaders;
-    private body: string;
-
-    private constructor()
-    {
-        this.statusCode = 200;
-        this.headers = MutableHttpHeaders.create();
-        this.body = "";
-    }
-
-    public static create(): HttpOutgoingResponse
-    {
-        return new HttpOutgoingResponse();
-    }
-
-    /**
-     * Get the status code of this {@link HttpOutgoingResponse}.
-     */
-    public getStatusCode(): number
-    {
-        return this.statusCode;
-    }
-
-    /**
-     * Set the status code of this {@link HttpOutgoingResponse}.
-     * @param statusCode The status code of this {@link HttpOutgoingResponse}.
-     */
-    public setStatusCode(statusCode: number): this
-    {
-        PreCondition.assertBetween(100, statusCode, 599, "statusCode");
-
-        this.statusCode = statusCode;
-
-        return this;
-    }
-
-    public getHeaders(): HttpHeaders
-    {
-        return this.headers;
-    }
-
-    /**
-     * Get the HTTP header with the provided name or return a {@link NotFoundError} if the header
-     * doesn't exist.
-     * @param headerName The name of the header to get.
-     */
-    public getHeader(headerName: string): SyncResult<HttpHeader>
-    {
-        return this.headers.get(headerName);
-    }
-
-    /**
-     * Get the value of the header with the provided name or return a {@link NotFoundError} if the
-     * header doesn't exist.
-     * @param headerName The name of the header value to get.
-     */
-    public getHeaderValue(headerName: string): SyncResult<string>
-    {
-        return this.headers.getValue(headerName);
-    }
-
-    /**
-     * Set the HTTP header in this {@link HttpOutgoingResponse}.
-     * @param headerName The name of the HTTP header.
-     * @param headerValue The value of the HTTP header.
-     */
-    public setHeader(headerName: string, headerValue: string): this
-    {
-        this.headers.set(headerName, headerValue);
-
-        return this;
-    }
-
-    public setContentTypeHeader(contentType: string): this
-    {
-        this.headers.setContentType(contentType);
-
-        return this;
-    }
-
-    /**
-     * Get the body of this {@link HttpOutgoingResponse}.
-     */
-    public getBody(): string
-    {
-        return this.body;
-    }
-
-    /**
-     * Set the body of this {@link HttpOutgoingResponse}.
-     * @param body The body for this {@link HttpOutgoingResponse}.
-     */
-    public setBody(body: string): this
-    {
-        PreCondition.assertNotUndefinedAndNotNull(body, "body");
-
-        this.body = body;
-
-        return this;
-    }
-}

package/sources/httpServer.ts

@@ -1,34 +0,0 @@
-import { Disposable } from "./disposable";
-import { HttpIncomingRequest } from "./httpIncomingRequest";
-import { HttpOutgoingResponse } from "./httpOutgoingResponse";
-import { AsyncResult } from "./asyncResult";
-
-export abstract class HttpServer implements Disposable
-{
-    public abstract dispose(): AsyncResult<boolean>;
-
-    public abstract isDisposed(): boolean;
-
-    /**
-     * Add the provided request handler so it will be invoked when a request is received for the
-     * provided path.
-     * @param requestPath The path that will cause the provided handler to be invoked.
-     * @param handler The function that will be invoked when the 
-     */
-    public abstract addRequestHandler(requestPath: string, handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void;
-
-    /**
-     * Set the default request handler that will be invoked when no other request handlers match an
-     * {@link HttpIncomingRequest}.
-     * @param handler The handler that will be invoked when no other request handlers match an
-     * {@link HttpIncomingRequest}.
-     */
-    public abstract setDefaultRequestHandler(handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void;
-
-    /**
-     * Start listening for incoming connections on the provided port number. The returned
-     * {@link AsyncResult} will complete when the server is disposed.
-     * @param portNumber The port number to start listening on.
-     */
-    public abstract start(portNumber: number): AsyncResult<void>;
-}