@duplojs/http 0.1.0 → 0.4.0

package/dist/core/response/base.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+class Response extends utils.kindHeritage("response", kind.createCoreLibKind("response")) {
+    code;
+    information;
+    body;
+    headers = undefined;
+    constructor(code, information, body) {
+        super();
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+    setHeaders(headers) {
+        this.headers = utils.O.override(this.headers ?? {}, headers);
+        return this;
+    }
+    setHeader(key, header) {
+        if (!this.headers) {
+            this.headers = {};
+        }
+        if (typeof header !== "undefined") {
+            this.headers[key] = header;
+        }
+        return this;
+    }
+    deleteHeader(key) {
+        if (!this.headers) {
+            return this;
+        }
+        const { [key]: deleteHeader, ...rest } = this.headers;
+        this.headers = rest;
+        return this;
+    }
+}
+
+exports.Response = Response;

package/dist/core/response/base.d.ts

@@ -0,0 +1,21 @@
+import { type S } from "@duplojs/utils";
+export type InformationResponseCode = `1${S.Digit}${S.Digit}`;
+export type SuccessResponseCode = `2${S.Digit}${S.Digit}`;
+export type RedirectionResponseCode = `3${S.Digit}${S.Digit}`;
+export type ClientErrorResponseCode = `4${S.Digit}${S.Digit}`;
+export type ServerErrorResponseCode = `5${S.Digit}${S.Digit}`;
+export type ResponseCode = (InformationResponseCode | SuccessResponseCode | RedirectionResponseCode | ClientErrorResponseCode | ServerErrorResponseCode);
+declare const Response_base: new (params?: {
+    "@DuplojsHttpCore/response"?: unknown;
+} | undefined) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"response", unknown>, unknown>;
+export declare class Response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends Response_base {
+    code: GenericCode;
+    information: GenericInformation;
+    body: GenericBody;
+    headers: Record<string, string | string[]> | undefined;
+    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
+    setHeaders(headers: Partial<Record<string, string | string[]>>): this;
+    setHeader(key: string, header?: string | string[]): this;
+    deleteHeader(key: string): this;
+}
+export {};

package/dist/core/response/base.mjs

@@ -0,0 +1,38 @@
+import { kindHeritage, O } from '@duplojs/utils';
+import { createCoreLibKind } from '../kind.mjs';
+
+class Response extends kindHeritage("response", createCoreLibKind("response")) {
+    code;
+    information;
+    body;
+    headers = undefined;
+    constructor(code, information, body) {
+        super();
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+    setHeaders(headers) {
+        this.headers = O.override(this.headers ?? {}, headers);
+        return this;
+    }
+    setHeader(key, header) {
+        if (!this.headers) {
+            this.headers = {};
+        }
+        if (typeof header !== "undefined") {
+            this.headers[key] = header;
+        }
+        return this;
+    }
+    deleteHeader(key) {
+        if (!this.headers) {
+            return this;
+        }
+        const { [key]: deleteHeader, ...rest } = this.headers;
+        this.headers = rest;
+        return this;
+    }
+}
+
+export { Response };

package/dist/core/response/contract.cjs

@@ -3,7 +3,7 @@
 var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
 
-const errorClass = Error;
+const ErrorClass = Error;
 exports.ResponseContract = void 0;
 (function (ResponseContract) {
     ResponseContract.contractKind = kind.createCoreLibKind("response-contract");
@@ -11,7 +11,7 @@ exports.ResponseContract = void 0;
         return (information, ...[schema]) => utils.pipe({
             code,
             information,
-            schema: (schema ?? options?.defaultSchema ?? utils.DP.empty()),
+            body: (schema ?? options?.defaultSchema ?? utils.DP.empty()),
         }, ResponseContract.contractKind.setTo);
     }
     const defaultSchema = utils.DP.empty();
@@ -23,21 +23,21 @@ exports.ResponseContract = void 0;
     ResponseContract.created = createContractBuilder("201", { defaultSchema });
     ResponseContract.accepted = createContractBuilder("202", { defaultSchema });
     ResponseContract.nonAuthoritativeInformation = createContractBuilder("203", { defaultSchema });
-    ResponseContract.noContent = createContractBuilder("204", { });
+    ResponseContract.noContent = createContractBuilder("204", { noSchema: true });
     ResponseContract.resetContent = createContractBuilder("205", { defaultSchema });
     ResponseContract.partialContent = createContractBuilder("206", { defaultSchema });
     ResponseContract.multiStatus = createContractBuilder("207", { defaultSchema });
     ResponseContract.alreadyReported = createContractBuilder("208", { defaultSchema });
     ResponseContract.imUsed = createContractBuilder("226", { defaultSchema });
-    ResponseContract.multipleChoices = createContractBuilder("300", { });
-    ResponseContract.movedPermanently = createContractBuilder("301", { });
-    ResponseContract.found = createContractBuilder("302", { });
-    ResponseContract.seeOther = createContractBuilder("303", { });
-    ResponseContract.notModified = createContractBuilder("304", { });
-    ResponseContract.useProxy = createContractBuilder("305", { });
-    ResponseContract.switchProxy = createContractBuilder("306", { });
-    ResponseContract.temporaryRedirect = createContractBuilder("307", { });
-    ResponseContract.permanentRedirect = createContractBuilder("308", { });
+    ResponseContract.multipleChoices = createContractBuilder("300", { noSchema: true });
+    ResponseContract.movedPermanently = createContractBuilder("301", { noSchema: true });
+    ResponseContract.found = createContractBuilder("302", { noSchema: true });
+    ResponseContract.seeOther = createContractBuilder("303", { noSchema: true });
+    ResponseContract.notModified = createContractBuilder("304", { noSchema: true });
+    ResponseContract.useProxy = createContractBuilder("305", { noSchema: true });
+    ResponseContract.switchProxy = createContractBuilder("306", { noSchema: true });
+    ResponseContract.temporaryRedirect = createContractBuilder("307", { noSchema: true });
+    ResponseContract.permanentRedirect = createContractBuilder("308", { noSchema: true });
     ResponseContract.badRequest = createContractBuilder("400", { defaultSchema });
     ResponseContract.unauthorized = createContractBuilder("401", { defaultSchema });
     ResponseContract.paymentRequired = createContractBuilder("402", { defaultSchema });
@@ -78,7 +78,7 @@ exports.ResponseContract = void 0;
     ResponseContract.loopDetected = createContractBuilder("508", { defaultSchema });
     ResponseContract.notExtended = createContractBuilder("510", { defaultSchema });
     ResponseContract.networkAuthenticationRequired = createContractBuilder("511", { defaultSchema });
-    class Error extends utils.kindHeritage("contract-error", kind.createCoreLibKind("contract-error"), errorClass) {
+    class Error extends utils.kindHeritage("contract-error", kind.createCoreLibKind("contract-error"), ErrorClass) {
         information;
         dataParserError;
         constructor(information, dataParserError) {