@gershy/util-http 0.0.1 → 0.0.3

package/cmp/cjs/main.d.ts

@@ -1,4 +1,58 @@
 import '../sideEffects.js';
-import '@gershy/clearing';
-declare const _default: null;
+export type NetProc = {
+    proto: 'ws' | 'wss' | 'http' | 'https';
+    addr: string;
+    port: number;
+};
+type Built<T> = T | {
+    [k: string]: Built<T>;
+};
+export type HttpReq = {
+    path: string[];
+    method: 'head' | 'get' | 'post' | 'put' | 'patch' | 'delete' | 'sokt';
+    cookies: Obj<Built<string>>;
+    query?: Obj<Built<string>>;
+    body?: Json;
+};
+export type HttpRes = {
+    code: number;
+    headers?: {
+        [key: string]: string | string[];
+    };
+    body: Json | Buffer;
+};
+export type HttpArgs<Req extends HttpReq, Res extends HttpRes> = {} & {
+    $req: Req;
+    $res: Res;
+} & {
+    netProc: NetProc;
+} & Omit<Req, 'cookies'> & {
+    headers?: Obj<string>;
+};
+export type HttpResult<Res extends HttpRes> = {
+    reqArgs: {
+        url: string;
+        method: string;
+        headers: [string, string][];
+        body: string | null;
+    };
+    code: number;
+    body: Res['body'];
+};
+export type HttpRet<Res extends HttpRes> = Promise<HttpResult<Res>> & {
+    end: () => void;
+};
+declare const _default: <Args extends HttpArgs<HttpReq, HttpRes>>(args: Args, params: Pick<Args, "query" | "body">) => Promise<{
+    reqArgs: ({
+        method: "HEAD" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "SOKT";
+        headers: [string, string][];
+        body: string | null;
+    } & {
+        url: string;
+    });
+    code: number;
+    body: Args["$res"]["body"];
+}> & {
+    end: () => void;
+};
 export default _default;

package/cmp/cjs/main.js

@@ -1,4 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("@gershy/clearing");
-exports.default = null;
+const clearing_1 = require("@gershy/clearing");
+exports.default = (args, params) => {
+    // Note this function is sovereign - can't reference jargon/http for `formatNetProc` :(
+    const { netProc, path, headers = {} } = args;
+    const { query = {}, body: reqBody = null } = params;
+    const defPorts = { http: 80, https: 443 };
+    const url = [
+        // E.g. "http://pasta.com"
+        `${netProc.proto}:/${''}/${netProc.addr}`,
+        // E.g. "http://pasta.com:3000"
+        netProc.port !== defPorts[netProc.proto] ? `:${netProc.port.toString(10)}` : null,
+        // E.g. "http://pasta.com:3000/path/to/resource"
+        path ? `/${path.join('/')}` : null,
+        (() => {
+            if (query[empty]())
+                return null;
+            const chains = function* (val, chain = []) {
+                if (!(0, clearing_1.isCls)(val, Object))
+                    return yield { chain, val };
+                for (const [k, v] of val)
+                    yield* chains(v, [...chain, k]);
+            };
+            // E.g. "http://pasta.com:3000/path/to/resource?query=spaghetti&offset=10"
+            return [...chains(query)][map](({ chain, val }) => `${encodeURIComponent(chain.join('.'))}=${encodeURIComponent(val)}`)
+                .join('&');
+        })()
+    ].filter(Boolean).join('');
+    const reqArgs = {
+        method: args.method[upper](),
+        headers: headers[toArr]((v, k) => [k.replace(/([A-Z])/g, '-$1')[lower](), v]), // Avoid `camelCase` util - want to keep this sovereign
+        body: [Object, Array].some(C => (0, clearing_1.isCls)(reqBody, C)) ? JSON.stringify(reqBody) : reqBody !== null ? `${reqBody}` : null
+    };
+    const abort = new AbortController();
+    const prm = fetch(url, { ...reqArgs, signal: abort.signal }).then(async (res) => {
+        const resBody = await (async () => {
+            const t = await res.text();
+            try {
+                return JSON.parse(t);
+            }
+            catch (err) { }
+            return t;
+        })();
+        const http = {
+            reqArgs: Object.assign(reqArgs, { url, body: reqBody }),
+            code: res.status,
+            body: resBody
+        };
+        if (res.status >= 500)
+            throw Error('http glitch')[mod](http);
+        if (res.status >= 400)
+            throw Error('http reject')[mod](http);
+        return http; // TODO: Return something like `{ ...http.body, http: { status: res.status } }`? Works as long as `http.body` is Json and not a Buffer
+    }, err => {
+        while ((0, clearing_1.isCls)(err.cause, Error))
+            err = err.cause; // `fetch` natively wraps errors - pretty annoying; unwrap them
+        if (err.code === 'ENOTFOUND')
+            return err[fire]({ retry: false });
+        throw err;
+    });
+    // Note that fetch abortion errors are suppressed!! By default we short-circuit any logic
+    // which depended on the http return value.
+    return Object.assign(prm, { end: () => abort.abort(Error('fetch aborted')[suppress]()) });
+};

package/cmp/mjs/main.d.ts

@@ -1,4 +1,58 @@
 import '../sideEffects.js';
-import '@gershy/clearing';
-declare const _default: null;
+export type NetProc = {
+    proto: 'ws' | 'wss' | 'http' | 'https';
+    addr: string;
+    port: number;
+};
+type Built<T> = T | {
+    [k: string]: Built<T>;
+};
+export type HttpReq = {
+    path: string[];
+    method: 'head' | 'get' | 'post' | 'put' | 'patch' | 'delete' | 'sokt';
+    cookies: Obj<Built<string>>;
+    query?: Obj<Built<string>>;
+    body?: Json;
+};
+export type HttpRes = {
+    code: number;
+    headers?: {
+        [key: string]: string | string[];
+    };
+    body: Json | Buffer;
+};
+export type HttpArgs<Req extends HttpReq, Res extends HttpRes> = {} & {
+    $req: Req;
+    $res: Res;
+} & {
+    netProc: NetProc;
+} & Omit<Req, 'cookies'> & {
+    headers?: Obj<string>;
+};
+export type HttpResult<Res extends HttpRes> = {
+    reqArgs: {
+        url: string;
+        method: string;
+        headers: [string, string][];
+        body: string | null;
+    };
+    code: number;
+    body: Res['body'];
+};
+export type HttpRet<Res extends HttpRes> = Promise<HttpResult<Res>> & {
+    end: () => void;
+};
+declare const _default: <Args extends HttpArgs<HttpReq, HttpRes>>(args: Args, params: Pick<Args, "query" | "body">) => Promise<{
+    reqArgs: ({
+        method: "HEAD" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "SOKT";
+        headers: [string, string][];
+        body: string | null;
+    } & {
+        url: string;
+    });
+    code: number;
+    body: Args["$res"]["body"];
+}> & {
+    end: () => void;
+};
 export default _default;

package/cmp/mjs/main.js

@@ -1,2 +1,63 @@
-import '@gershy/clearing';
-export default null;
+import { isCls } from '@gershy/clearing';
+export default (args, params) => {
+    // Note this function is sovereign - can't reference jargon/http for `formatNetProc` :(
+    const { netProc, path, headers = {} } = args;
+    const { query = {}, body: reqBody = null } = params;
+    const defPorts = { http: 80, https: 443 };
+    const url = [
+        // E.g. "http://pasta.com"
+        `${netProc.proto}:/${''}/${netProc.addr}`,
+        // E.g. "http://pasta.com:3000"
+        netProc.port !== defPorts[netProc.proto] ? `:${netProc.port.toString(10)}` : null,
+        // E.g. "http://pasta.com:3000/path/to/resource"
+        path ? `/${path.join('/')}` : null,
+        (() => {
+            if (query[empty]())
+                return null;
+            const chains = function* (val, chain = []) {
+                if (!isCls(val, Object))
+                    return yield { chain, val };
+                for (const [k, v] of val)
+                    yield* chains(v, [...chain, k]);
+            };
+            // E.g. "http://pasta.com:3000/path/to/resource?query=spaghetti&offset=10"
+            return [...chains(query)][map](({ chain, val }) => `${encodeURIComponent(chain.join('.'))}=${encodeURIComponent(val)}`)
+                .join('&');
+        })()
+    ].filter(Boolean).join('');
+    const reqArgs = {
+        method: args.method[upper](),
+        headers: headers[toArr]((v, k) => [k.replace(/([A-Z])/g, '-$1')[lower](), v]), // Avoid `camelCase` util - want to keep this sovereign
+        body: [Object, Array].some(C => isCls(reqBody, C)) ? JSON.stringify(reqBody) : reqBody !== null ? `${reqBody}` : null
+    };
+    const abort = new AbortController();
+    const prm = fetch(url, { ...reqArgs, signal: abort.signal }).then(async (res) => {
+        const resBody = await (async () => {
+            const t = await res.text();
+            try {
+                return JSON.parse(t);
+            }
+            catch (err) { }
+            return t;
+        })();
+        const http = {
+            reqArgs: Object.assign(reqArgs, { url, body: reqBody }),
+            code: res.status,
+            body: resBody
+        };
+        if (res.status >= 500)
+            throw Error('http glitch')[mod](http);
+        if (res.status >= 400)
+            throw Error('http reject')[mod](http);
+        return http; // TODO: Return something like `{ ...http.body, http: { status: res.status } }`? Works as long as `http.body` is Json and not a Buffer
+    }, err => {
+        while (isCls(err.cause, Error))
+            err = err.cause; // `fetch` natively wraps errors - pretty annoying; unwrap them
+        if (err.code === 'ENOTFOUND')
+            return err[fire]({ retry: false });
+        throw err;
+    });
+    // Note that fetch abortion errors are suppressed!! By default we short-circuit any logic
+    // which depended on the http return value.
+    return Object.assign(prm, { end: () => abort.abort(Error('fetch aborted')[suppress]()) });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gershy/util-http",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "TODO",
   "keywords": [
     "TODO"
@@ -16,7 +16,7 @@
   "homepage": "https://github.com/gershy/utilHttp#readme",
   "license": "ISC",
   "peerDependencies": {
-    "@gershy/clearing": "^0.0.24"
+    "@gershy/clearing": "^0.0.28"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",