make-service 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Gustavo Guichard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,227 @@
+# make-service
+
+A type-safe thin wrapper around the `fetch` API to better interact with external APIs.
+
+It adds a set of little features and allows you to parse responses with [zod](https://github.com/colinhacks/zod).
+
+## Features
+- 🤩 Type-safe return of `response.json()` and `response.text()`. Defaults to `unknown` instead of `any`.
+- 🚦 Easily setup an API with a `baseURL` and common `headers` for every request.
+- 🏗️ Compose URL from the base by just calling the endpoints and an object-like `query`.
+- 🧙‍♀️ Automatically stringifies the `body` of a request so you can give it a JSON-like structure.
+- 🐛 Accepts a `trace` function for debugging.
+
+## Example
+
+```ts
+const api = makeService("https://example.com/api", {
+  Authorization: "Bearer 123",
+});
+
+const response = await api.get("/users")
+const users = await response.json(usersSchema);
+//    ^? User[]
+```
+
+## Installation
+
+```sh
+npm install make-service
+```
+Or you can use it with Deno:
+
+```ts
+import { makeService } from "https://deno.land/x/make_service/mod.ts";
+```
+
+# Public API
+
+This library exports the `makeService` function and all primitives used to build it. You can use the primitives as you wish but the `makeService` will have all the features combined.
+
+## addQueryToInput
+
+Adds an object of query parameters to a string or URL.
+
+```ts
+import { addQueryToInput } from 'make-service'
+
+const input = addQueryToInput("https://example.com", { page: "1" })
+// input = "https://example.com?page=1"
+
+const input = addQueryToInput("https://example.com?page=1", { admin: "true" })
+// input = "https://example.com?page=1&admin=true"
+
+const input = addQueryToInput(new URL("https://example.com"), { page: "1" })
+// input.toString() = "https://example.com?page=1"
+```
+
+## makeGetApiUrl
+
+Creates a function that will add an endpoint and a query to the base URL.
+It uses the `addQueryToInput` function internally.
+
+```ts
+import { makeGetApiUrl } from 'make-service'
+
+const getApiUrl = makeGetApiUrl("https://example.com/api")
+
+const url = getApiUrl("/users", { page: "1" })
+// url = "https://example.com/api/users?page=1"
+```
+
+## ensureStringBody
+
+Ensures that the body is a string. If it's not, it will be stringified.
+
+```ts
+import { ensureStringBody } from 'make-service'
+
+const body1 = ensureStringBody({ foo: "bar" })
+// body1 = '{"foo":"bar"}'
+await fetch("https://example.com/api/users", {
+  method: 'POST',
+  body: body1
+})
+
+const body2 = ensureStringBody('{"foo":"bar"}')
+// body2 = '{"foo":"bar"}'
+await fetch("https://example.com/api/users", {
+  method: 'POST',
+  body: body2
+})
+```
+
+## typedResponse
+
+A type-safe wrapper around the `Response` object. It adds a `json` and `text` method that will parse the response with a given zod schema. If you don't provide a schema, it will return `unknown` instead of `any`, then you can also give it a generic to type cast the result.
+
+```ts
+import { typedResponse } from 'make-service'
+
+// With JSON
+const response = new Response(JSON.stringify({ foo: "bar" }))
+const json = await typedResponse(response).json()
+//    ^? unknown
+const json = await typedResponse(response).json<{ foo: string }>()
+//    ^? { foo: string }
+const json = await typedResponse(response).json(z.object({ foo: z.string() }))
+//    ^? { foo: string }
+
+// With text
+const response = new Response("foo")
+const text = await typedResponse(response).text()
+//    ^? string
+const text = await typedResponse(response).text<`foo${string}`>()
+//    ^? `foo${string}`
+const text = await typedResponse(response).text(z.string().email())
+//    ^? string
+```
+
+## enhancedFetch
+
+A wrapper around the `fetch` API.
+It uses the `addQueryToInput`, `ensureStringBody` function internally and returns a `typedResponse` instead of a `Response`.
+
+```ts
+import { enhancedFetch } from 'make-service'
+
+const response = await enhancedFetch("https://example.com/api/users", {
+  method: 'POST',
+  body: { some: { object: { as: { body } } } }
+})
+const json = await response.json()
+//    ^? unknown
+// You can pass it a generic or schema to type the result
+```
+
+This function accepts the same arguments as the `fetch` API - with exception of JSON-like body -, and it also accepts an object-like `query` and a `trace` function that will be called with the `input` and `requestInit` arguments.
+
+```ts
+import { enhancedFetch } from 'make-service'
+
+await enhancedFetch("https://example.com/api/users", {
+  method: 'POST',
+  body: { some: { object: { as: { body } } } },
+  query: { page: "1" },
+  trace: (input, requestInit) => console.log(input, requestInit)
+})
+
+// The trace function will be called with the following arguments:
+// "https://example.com/api/users?page=1"
+// {
+//   method: 'POST',
+//   body: '{"some":{"object":{"as":{"body":{}}}}}',
+//   headers: { 'content-type': 'application/json' }
+// }
+```
+
+Notice: the `enhancedFetch` adds a `'content-type': 'application/json'` header by default.
+
+# makeService
+
+The main function of this lib is built on top of the previous primitives and it allows you to create an "API" object with a `baseURL` and common `headers` for every request.
+
+This "api" object can be called with every HTTP method and it will return a `typedResponse` object as it uses the `enhancedFetch` internally.
+
+```ts
+import { makeService } from 'make-service'
+
+const api = makeService("https://example.com/api", {
+  authorization: "Bearer 123"
+})
+
+const response = await api.get("/users")
+const json = await response.json()
+//    ^? unknown
+```
+
+On the example above, the `api.get` will call the `enhancedFetch` with the following arguments:
+
+```ts
+// "https://example.com/api/users"
+// {
+//   method: 'GET',
+//   headers: {
+//    'content-type': 'application/json',
+//    'authorization': 'Bearer 123',
+//   }
+// }
+```
+
+The `api` object can be called with the same arguments as the `enhancedFetch`, such as `query`, object-like `body`, and `trace`.
+
+Its `typedResponse` can also be parsed with a zod schema. Here follows a little more complex example:
+
+```ts
+const response = await api.get("/users", {
+  query: { search: "John" },
+  trace: (...args: any[]) => console.log(...args)
+})
+const json = await response.json(
+  z.object({
+    data: z.object({
+      users: z.array(z.object({
+        name: z.string()
+      }))
+    })
+  })
+  // transformed and catched
+  .transform(({ data: { users } }) => users)
+  .catch([])
+)
+// type of json will be { name: string }[]
+// the URL called will be "https://example.com/api/users?search=John"
+```
+
+It accepts more HTTP verbs:
+```ts
+await api.post("/users", { body: { name: "John" } })
+await api.put("/users/1", { body: { name: "John" } })
+await api.patch("/users/1", { body: { name: "John" } })
+await api.delete("/users/1")
+await api.head("/users")
+await api.options("/users")
+```
+
+## Thank you
+I really appreciate your feedback and contributions. If you have any questions, feel free to open an issue or contact me on [Twitter](https://twitter.com/gugaguichard).

package/esm/_dnt.shims.js

@@ -0,0 +1,70 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+import { fetch, File, FormData, Headers, Request, Response } from "undici";
+export { fetch, File, FormData, Headers, Request, Response } from "undici";
+const dntGlobals = {
+    Deno,
+    fetch,
+    File,
+    FormData,
+    Headers,
+    Request,
+    Response,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/constants.js

@@ -0,0 +1,10 @@
+const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head',
+];
+export { HTTP_METHODS };

package/esm/index.js

@@ -0,0 +1 @@
+export { addQueryToInput, ensureStringBody, enhancedFetch, makeService, makeGetApiUrl, typedResponse, } from './make-service.js';

package/esm/internals.js

@@ -0,0 +1,29 @@
+import { HTTP_METHODS } from './constants.js';
+/**
+ * It returns the JSON object or throws an error if the response is not ok.
+ * @param response the Response to be parsed
+ * @returns the response.json method that accepts a type or Zod schema for a typed json response
+ */
+function getJson(response) {
+    return async (schema) => {
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const json = await response.json();
+        return schema ? schema.parse(json) : json;
+    };
+}
+/**
+ * @param response the Response to be parsed
+ * @returns the response.text method that accepts a type or Zod schema for a typed response
+ */
+function getText(response) {
+    return async (schema) => {
+        const text = await response.text();
+        return schema ? schema.parse(text) : text;
+    };
+}
+function isHTTPMethod(method) {
+    return HTTP_METHODS.includes(method);
+}
+export { getJson, getText, isHTTPMethod };

package/esm/make-service.js

@@ -0,0 +1,126 @@
+import * as dntShim from "./_dnt.shims.js";
+import { getJson, getText, isHTTPMethod } from './internals.js';
+/**
+ * @param input a string or URL to which the query parameters will be added
+ * @param searchParams the query parameters
+ * @returns the input with the query parameters added with the same type as the input
+ */
+function addQueryToInput(input, searchParams) {
+    if (!searchParams)
+        return input;
+    if (searchParams && typeof input === 'string') {
+        const separator = input.includes('?') ? '&' : '?';
+        return `${input}${separator}${new URLSearchParams(searchParams)}`;
+    }
+    if (searchParams && input instanceof URL) {
+        input.search = new URLSearchParams(searchParams).toString();
+    }
+    return input;
+}
+/**
+ * @param baseURL the base path to the API
+ * @returns a function that receives a path and an object of query parameters and returns a URL
+ */
+function makeGetApiUrl(baseURL) {
+    return (path, searchParams) => addQueryToInput(`${baseURL}${path}`, searchParams);
+}
+/**
+ * It hacks the Response object to add typed json and text methods
+ * @param response the Response to be proxied
+ * @returns a Response with typed json and text methods
+ * @example const response = await fetch("https://example.com/api/users");
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ * const untyped = await response.json();
+ * //    ^? unknown
+ * const text = await response.text();
+ * //    ^? string
+ * const typedJson = await response.json<User[]>();
+ * //    ^? User[]
+ */
+function typedResponse(response) {
+    return new Proxy(response, {
+        get(target, prop) {
+            if (prop === 'json')
+                return getJson(target);
+            if (prop === 'text')
+                return getText(target);
+            return target[prop];
+        },
+    });
+}
+/**
+ * @param body the JSON-like body of the request
+ * @returns the body stringified if it is not a string
+ */
+function ensureStringBody(body) {
+    if (typeof body === 'undefined')
+        return;
+    if (typeof body === 'string')
+        return body;
+    return JSON.stringify(body);
+}
+/**
+ *
+ * @param input a string or URL to be fetched
+ * @param options the options to be passed to the fetch request. It is the same as the `RequestInit` type, but it also accepts a JSON-like `body` and an object-like `query` parameter.
+ * @param options.body the body of the request. It will be automatically stringified so you can send a JSON-like object
+ * @param options.query the query parameters to be added to the URL
+ * @param options.trace a function that receives the URL and the requestInit and can be used to log the request
+ * @returns a Response with typed json and text methods
+ * @example const response = await fetch("https://example.com/api/users");
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ * const untyped = await response.json();
+ * //    ^? unknown
+ */
+async function enhancedFetch(input, options) {
+    const { query, trace, ...reqInit } = options ?? {};
+    const headers = { 'content-type': 'application/json', ...reqInit.headers };
+    const url = addQueryToInput(input, query);
+    const body = ensureStringBody(reqInit.body);
+    const requestInit = { ...reqInit, headers, body };
+    trace?.(url, requestInit);
+    const request = new dntShim.Request(url, requestInit);
+    const response = await dntShim.fetch(request);
+    return typedResponse(response);
+}
+/**
+ *
+ * @param baseURL the base URL to the API
+ * @param baseHeaders any headers that should be sent with every request
+ * @returns an API object with HTTP methods that are functions that receive a path and options and return a serialized json response that can be typed or not.
+ * @example const headers = { Authorization: "Bearer 123" }
+ * const api = makeService("https://example.com/api", headers);
+ * const response = await api.get("/users")
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ */
+function makeService(baseURL, baseHeaders) {
+    /**
+     * A function that receives a path and options and returns a serialized json response that can be typed or not.
+     * @param method the HTTP method
+     * @returns the API function for the given HTTP method
+     */
+    const api = (method) => {
+        return async (path, options = {}) => {
+            const response = await enhancedFetch(`${baseURL}${path}`, {
+                ...options,
+                method,
+                headers: { ...baseHeaders, ...options?.headers },
+            });
+            return response;
+        };
+    };
+    /**
+     * It returns a proxy that returns the api function for each HTTP method
+     */
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (isHTTPMethod(prop))
+                return api(prop);
+            throw new Error(`Invalid HTTP method: ${prop.toString()}`);
+        },
+    });
+}
+export { addQueryToInput, ensureStringBody, enhancedFetch, makeService, makeGetApiUrl, typedResponse, };

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "module": "./esm/index.js",
+  "main": "./script/index.js",
+  "types": "./types/index.d.ts",
+  "name": "make-service",
+  "version": "0.0.1",
+  "description": "Some utilities to extend the \"fetch\" API to better interact with external APIs.",
+  "license": "MIT",
+  "author": "Gustavo Guichard",
+  "bugs": {
+    "url": "https://github.com/gustavoguichard/make-service/issues"
+  },
+  "homepage": "https://github.com/gustavoguichard/make-service",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.ts",
+        "default": "./script/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@deno/shim-deno": "~0.12.0",
+    "undici": "^5.14.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9"
+  }
+}

package/script/_dnt.shims.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Response = exports.Request = exports.Headers = exports.FormData = exports.File = exports.fetch = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const undici_1 = require("undici");
+var undici_2 = require("undici");
+Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return undici_2.fetch; } });
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return undici_2.File; } });
+Object.defineProperty(exports, "FormData", { enumerable: true, get: function () { return undici_2.FormData; } });
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return undici_2.Headers; } });
+Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return undici_2.Request; } });
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return undici_2.Response; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+    fetch: undici_1.fetch,
+    File: undici_1.File,
+    FormData: undici_1.FormData,
+    Headers: undici_1.Headers,
+    Request: undici_1.Request,
+    Response: undici_1.Response,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+// deno-lint-ignore ban-types
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_METHODS = void 0;
+const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head',
+];
+exports.HTTP_METHODS = HTTP_METHODS;

package/script/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedResponse = exports.makeGetApiUrl = exports.makeService = exports.enhancedFetch = exports.ensureStringBody = exports.addQueryToInput = void 0;
+var make_service_js_1 = require("./make-service.js");
+Object.defineProperty(exports, "addQueryToInput", { enumerable: true, get: function () { return make_service_js_1.addQueryToInput; } });
+Object.defineProperty(exports, "ensureStringBody", { enumerable: true, get: function () { return make_service_js_1.ensureStringBody; } });
+Object.defineProperty(exports, "enhancedFetch", { enumerable: true, get: function () { return make_service_js_1.enhancedFetch; } });
+Object.defineProperty(exports, "makeService", { enumerable: true, get: function () { return make_service_js_1.makeService; } });
+Object.defineProperty(exports, "makeGetApiUrl", { enumerable: true, get: function () { return make_service_js_1.makeGetApiUrl; } });
+Object.defineProperty(exports, "typedResponse", { enumerable: true, get: function () { return make_service_js_1.typedResponse; } });

package/script/internals.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHTTPMethod = exports.getText = exports.getJson = void 0;
+const constants_js_1 = require("./constants.js");
+/**
+ * It returns the JSON object or throws an error if the response is not ok.
+ * @param response the Response to be parsed
+ * @returns the response.json method that accepts a type or Zod schema for a typed json response
+ */
+function getJson(response) {
+    return async (schema) => {
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const json = await response.json();
+        return schema ? schema.parse(json) : json;
+    };
+}
+exports.getJson = getJson;
+/**
+ * @param response the Response to be parsed
+ * @returns the response.text method that accepts a type or Zod schema for a typed response
+ */
+function getText(response) {
+    return async (schema) => {
+        const text = await response.text();
+        return schema ? schema.parse(text) : text;
+    };
+}
+exports.getText = getText;
+function isHTTPMethod(method) {
+    return constants_js_1.HTTP_METHODS.includes(method);
+}
+exports.isHTTPMethod = isHTTPMethod;

package/script/make-service.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedResponse = exports.makeGetApiUrl = exports.makeService = exports.enhancedFetch = exports.ensureStringBody = exports.addQueryToInput = void 0;
+const dntShim = __importStar(require("./_dnt.shims.js"));
+const internals_js_1 = require("./internals.js");
+/**
+ * @param input a string or URL to which the query parameters will be added
+ * @param searchParams the query parameters
+ * @returns the input with the query parameters added with the same type as the input
+ */
+function addQueryToInput(input, searchParams) {
+    if (!searchParams)
+        return input;
+    if (searchParams && typeof input === 'string') {
+        const separator = input.includes('?') ? '&' : '?';
+        return `${input}${separator}${new URLSearchParams(searchParams)}`;
+    }
+    if (searchParams && input instanceof URL) {
+        input.search = new URLSearchParams(searchParams).toString();
+    }
+    return input;
+}
+exports.addQueryToInput = addQueryToInput;
+/**
+ * @param baseURL the base path to the API
+ * @returns a function that receives a path and an object of query parameters and returns a URL
+ */
+function makeGetApiUrl(baseURL) {
+    return (path, searchParams) => addQueryToInput(`${baseURL}${path}`, searchParams);
+}
+exports.makeGetApiUrl = makeGetApiUrl;
+/**
+ * It hacks the Response object to add typed json and text methods
+ * @param response the Response to be proxied
+ * @returns a Response with typed json and text methods
+ * @example const response = await fetch("https://example.com/api/users");
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ * const untyped = await response.json();
+ * //    ^? unknown
+ * const text = await response.text();
+ * //    ^? string
+ * const typedJson = await response.json<User[]>();
+ * //    ^? User[]
+ */
+function typedResponse(response) {
+    return new Proxy(response, {
+        get(target, prop) {
+            if (prop === 'json')
+                return (0, internals_js_1.getJson)(target);
+            if (prop === 'text')
+                return (0, internals_js_1.getText)(target);
+            return target[prop];
+        },
+    });
+}
+exports.typedResponse = typedResponse;
+/**
+ * @param body the JSON-like body of the request
+ * @returns the body stringified if it is not a string
+ */
+function ensureStringBody(body) {
+    if (typeof body === 'undefined')
+        return;
+    if (typeof body === 'string')
+        return body;
+    return JSON.stringify(body);
+}
+exports.ensureStringBody = ensureStringBody;
+/**
+ *
+ * @param input a string or URL to be fetched
+ * @param options the options to be passed to the fetch request. It is the same as the `RequestInit` type, but it also accepts a JSON-like `body` and an object-like `query` parameter.
+ * @param options.body the body of the request. It will be automatically stringified so you can send a JSON-like object
+ * @param options.query the query parameters to be added to the URL
+ * @param options.trace a function that receives the URL and the requestInit and can be used to log the request
+ * @returns a Response with typed json and text methods
+ * @example const response = await fetch("https://example.com/api/users");
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ * const untyped = await response.json();
+ * //    ^? unknown
+ */
+async function enhancedFetch(input, options) {
+    const { query, trace, ...reqInit } = options ?? {};
+    const headers = { 'content-type': 'application/json', ...reqInit.headers };
+    const url = addQueryToInput(input, query);
+    const body = ensureStringBody(reqInit.body);
+    const requestInit = { ...reqInit, headers, body };
+    trace?.(url, requestInit);
+    const request = new dntShim.Request(url, requestInit);
+    const response = await dntShim.fetch(request);
+    return typedResponse(response);
+}
+exports.enhancedFetch = enhancedFetch;
+/**
+ *
+ * @param baseURL the base URL to the API
+ * @param baseHeaders any headers that should be sent with every request
+ * @returns an API object with HTTP methods that are functions that receive a path and options and return a serialized json response that can be typed or not.
+ * @example const headers = { Authorization: "Bearer 123" }
+ * const api = makeService("https://example.com/api", headers);
+ * const response = await api.get("/users")
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ */
+function makeService(baseURL, baseHeaders) {
+    /**
+     * A function that receives a path and options and returns a serialized json response that can be typed or not.
+     * @param method the HTTP method
+     * @returns the API function for the given HTTP method
+     */
+    const api = (method) => {
+        return async (path, options = {}) => {
+            const response = await enhancedFetch(`${baseURL}${path}`, {
+                ...options,
+                method,
+                headers: { ...baseHeaders, ...options?.headers },
+            });
+            return response;
+        };
+    };
+    /**
+     * It returns a proxy that returns the api function for each HTTP method
+     */
+    return new Proxy({}, {
+        get(_target, prop) {
+            if ((0, internals_js_1.isHTTPMethod)(prop))
+                return api(prop);
+            throw new Error(`Invalid HTTP method: ${prop.toString()}`);
+        },
+    });
+}
+exports.makeService = makeService;

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/_dnt.shims.d.ts

@@ -0,0 +1,13 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+import { fetch, File, FormData, Headers, Request, Response } from "undici";
+export { fetch, File, FormData, Headers, Request, Response, type BodyInit, type HeadersInit, type RequestInit, type ResponseInit } from "undici";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno" | "fetch" | "File" | "FormData" | "Headers" | "Request" | "Response"> & {
+    Deno: typeof Deno;
+    fetch: typeof fetch;
+    File: typeof File;
+    FormData: typeof FormData;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+};

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+declare const HTTP_METHODS: readonly ["get", "post", "put", "delete", "patch", "options", "head"];
+export { HTTP_METHODS };

package/types/index.d.ts

@@ -0,0 +1 @@
+export { addQueryToInput, ensureStringBody, enhancedFetch, makeService, makeGetApiUrl, typedResponse, } from './make-service.js';

package/types/internals.d.ts

@@ -0,0 +1,15 @@
+import * as dntShim from "./_dnt.shims.js";
+import { HTTPMethod, Schema } from './types.js';
+/**
+ * It returns the JSON object or throws an error if the response is not ok.
+ * @param response the Response to be parsed
+ * @returns the response.json method that accepts a type or Zod schema for a typed json response
+ */
+declare function getJson(response: dntShim.Response): <T = unknown>(schema?: Schema<T> | undefined) => Promise<T>;
+/**
+ * @param response the Response to be parsed
+ * @returns the response.text method that accepts a type or Zod schema for a typed response
+ */
+declare function getText(response: dntShim.Response): <T extends string = string>(schema?: Schema<T> | undefined) => Promise<T>;
+declare function isHTTPMethod(method: string | symbol): method is HTTPMethod;
+export { getJson, getText, isHTTPMethod };

package/types/make-service.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import * as dntShim from "./_dnt.shims.js";
+import { getJson, getText } from './internals.js';
+import { JSONValue, SearchParams } from './types.js';
+/**
+ * @param input a string or URL to which the query parameters will be added
+ * @param searchParams the query parameters
+ * @returns the input with the query parameters added with the same type as the input
+ */
+declare function addQueryToInput(input: string | URL, searchParams?: SearchParams): string | URL;
+/**
+ * @param baseURL the base path to the API
+ * @returns a function that receives a path and an object of query parameters and returns a URL
+ */
+declare function makeGetApiUrl(baseURL: string): (path: string, searchParams?: SearchParams) => string | URL;
+/**
+ * It hacks the Response object to add typed json and text methods
+ * @param response the Response to be proxied
+ * @returns a Response with typed json and text methods
+ * @example const response = await fetch("https://example.com/api/users");
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ * const untyped = await response.json();
+ * //    ^? unknown
+ * const text = await response.text();
+ * //    ^? string
+ * const typedJson = await response.json<User[]>();
+ * //    ^? User[]
+ */
+declare function typedResponse(response: dntShim.Response): Omit<dntShim.Response, "json" | "text"> & {
+    json: ReturnType<typeof getJson>;
+    text: ReturnType<typeof getText>;
+};
+/**
+ * @param body the JSON-like body of the request
+ * @returns the body stringified if it is not a string
+ */
+declare function ensureStringBody(body?: JSONValue): string | undefined;
+type Options = Omit<dntShim.RequestInit, 'body'> & {
+    body?: JSONValue;
+    query?: SearchParams;
+    trace?: (...args: Parameters<typeof dntShim.fetch>) => void;
+};
+/**
+ *
+ * @param input a string or URL to be fetched
+ * @param options the options to be passed to the fetch request. It is the same as the `RequestInit` type, but it also accepts a JSON-like `body` and an object-like `query` parameter.
+ * @param options.body the body of the request. It will be automatically stringified so you can send a JSON-like object
+ * @param options.query the query parameters to be added to the URL
+ * @param options.trace a function that receives the URL and the requestInit and can be used to log the request
+ * @returns a Response with typed json and text methods
+ * @example const response = await fetch("https://example.com/api/users");
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ * const untyped = await response.json();
+ * //    ^? unknown
+ */
+declare function enhancedFetch(input: string | URL, options?: Options): Promise<Omit<dntShim.Response, "json" | "text"> & {
+    json: <T = unknown>(schema?: import("./types.js").Schema<T> | undefined) => Promise<T>;
+    text: <T_1 extends string = string>(schema?: import("./types.js").Schema<T_1> | undefined) => Promise<T_1>;
+}>;
+/**
+ *
+ * @param baseURL the base URL to the API
+ * @param baseHeaders any headers that should be sent with every request
+ * @returns an API object with HTTP methods that are functions that receive a path and options and return a serialized json response that can be typed or not.
+ * @example const headers = { Authorization: "Bearer 123" }
+ * const api = makeService("https://example.com/api", headers);
+ * const response = await api.get("/users")
+ * const users = await response.json(userSchema);
+ * //    ^? User[]
+ */
+declare function makeService(baseURL: string, baseHeaders?: dntShim.HeadersInit): Record<"get" | "post" | "put" | "delete" | "patch" | "options" | "head", (path: string, options?: Omit<Options, 'method'>) => Promise<Omit<dntShim.Response, "json" | "text"> & {
+    json: <T = unknown>(schema?: import("./types.js").Schema<T> | undefined) => Promise<T>;
+    text: <T_1 extends string = string>(schema?: import("./types.js").Schema<T_1> | undefined) => Promise<T_1>;
+}>>;
+export { addQueryToInput, ensureStringBody, enhancedFetch, makeService, makeGetApiUrl, typedResponse, };

package/types/types.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { HTTP_METHODS } from './constants.js';
+type Schema<T> = {
+    parse: (d: unknown) => T;
+};
+type JSONValue = string | number | boolean | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;
+type SearchParams = ConstructorParameters<typeof URLSearchParams>[0];
+type HTTPMethod = typeof HTTP_METHODS[number];
+export type { HTTPMethod, JSONValue, Schema, SearchParams };