make-service 0.0.1 → 0.0.2

package/README.md

@@ -34,93 +34,80 @@ Or you can use it with Deno:
 import { makeService } from "https://deno.land/x/make_service/mod.ts";
 ```
 
-# Public API
+# 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.
+This library exports the `makeService` function and some primitives used to build it. You can use the primitives as you wish but the `makeService` will have all the features combined.
 
-## addQueryToInput
+# makeService
 
-Adds an object of query parameters to a string or URL.
+The main function of this lib is built on top of the primitives described in the following sections. It allows you to create an "API" object with a `baseURL` and common `headers` for every request.
 
-```ts
-import { addQueryToInput } from 'make-service'
+This "api" object can be called with every HTTP method and it will return a [`typedResponse`](#typedresponse) object as it uses the [`enhancedFetch`](#enhancedfetch) internally.
 
-const input = addQueryToInput("https://example.com", { page: "1" })
-// input = "https://example.com?page=1"
+```ts
+import { makeService } from 'make-service'
 
-const input = addQueryToInput("https://example.com?page=1", { admin: "true" })
-// input = "https://example.com?page=1&admin=true"
+const api = makeService("https://example.com/api", {
+  authorization: "Bearer 123"
+})
 
-const input = addQueryToInput(new URL("https://example.com"), { page: "1" })
-// input.toString() = "https://example.com?page=1"
+const response = await api.get("/users")
+const json = await response.json()
+//    ^? unknown
 ```
 
-## makeGetApiUrl
-
-Creates a function that will add an endpoint and a query to the base URL.
-It uses the `addQueryToInput` function internally.
+On the example above, the `api.get` will call the [`enhancedFetch`](#enhancedfetch) with the following arguments:
 
 ```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"
+// "https://example.com/api/users"
+// {
+//   method: 'GET',
+//   headers: {
+//    'content-type': 'application/json',
+//    'authorization': 'Bearer 123',
+//   }
+// }
 ```
 
-## ensureStringBody
+The `api` object can be called with the same arguments as the [`enhancedFetch`](#enhancedfetch), such as `query`, object-like `body`, and `trace`.
 
-Ensures that the body is a string. If it's not, it will be stringified.
+Its [`typedResponse`](#typedresponse) can also be parsed with a zod schema. Here follows a little more complex example:
 
 ```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
+const response = await api.get("/users", {
+  query: { search: "John" },
+  trace: (input, requestInit) => console.log(input, requestInit),
 })
+const json = await response.json(
+  z.object({
+    data: z.object({
+      users: z.array(z.object({
+        name: z.string()
+      }))
+    })
+  })
+  // transformed and caught
+  .transform(({ data: { users } }) => users)
+  .catch([])
+)
+// type of json will be { name: string }[]
+// the URL called will be "https://example.com/api/users?search=John"
 ```
 
-## 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.
-
+It accepts more HTTP verbs:
 ```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
+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")
 ```
 
 ## enhancedFetch
 
 A wrapper around the `fetch` API.
-It uses the `addQueryToInput`, `ensureStringBody` function internally and returns a `typedResponse` instead of a `Response`.
+It returns a [`typedResponse`](#typedresponse) instead of a `Response`.
 
 ```ts
 import { enhancedFetch } from 'make-service'
@@ -134,7 +121,7 @@ const json = await response.json()
 // 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.
+This function accepts the same arguments as the `fetch` API - with exception of [JSON-like body](/src/make-service.ts) -, and it also accepts an object-like [`query`](/src/make-service.ts) and a `trace` function that will be called with the `input` and `requestInit` arguments.
 
 ```ts
 import { enhancedFetch } from 'make-service'
@@ -157,70 +144,30 @@ await enhancedFetch("https://example.com/api/users", {
 
 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.
+## typedResponse
 
-This "api" object can be called with every HTTP method and it will return a `typedResponse` object as it uses the `enhancedFetch` internally.
+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 { makeService } from 'make-service'
-
-const api = makeService("https://example.com/api", {
-  authorization: "Bearer 123"
-})
+import { typedResponse } from 'make-service'
 
-const response = await api.get("/users")
-const json = await response.json()
+// With JSON
+const response = new Response(JSON.stringify({ foo: "bar" }))
+const json = await typedResponse(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"
-```
+const json = await typedResponse(response).json<{ foo: string }>()
+//    ^? { foo: string }
+const json = await typedResponse(response).json(z.object({ foo: z.string() }))
+//    ^? { foo: string }
 
-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")
+// 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
 ```
 
 ## Thank you

package/{types/make-service.d.ts → dist/index.d.ts}

@@ -1,7 +1,23 @@
-/// <reference types="node" />
-import * as dntShim from "./_dnt.shims.js";
-import { getJson, getText } from './internals.js';
-import { JSONValue, SearchParams } from './types.js';
+type Schema<T> = {
+    parse: (d: unknown) => T;
+};
+type JSONValue = string | number | boolean | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;
+type SearchParams = ConstructorParameters<typeof URLSearchParams>[0];
+
+/**
+ * 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: 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: Response): <T extends string = string>(schema?: Schema<T> | undefined) => Promise<T>;
+
 /**
  * @param input a string or URL to which the query parameters will be added
  * @param searchParams the query parameters
@@ -27,7 +43,7 @@ declare function makeGetApiUrl(baseURL: string): (path: string, searchParams?: S
  * const typedJson = await response.json<User[]>();
  * //    ^? User[]
  */
-declare function typedResponse(response: dntShim.Response): Omit<dntShim.Response, "json" | "text"> & {
+declare function typedResponse(response: Response): Omit<Response, "json" | "text"> & {
     json: ReturnType<typeof getJson>;
     text: ReturnType<typeof getText>;
 };
@@ -36,10 +52,10 @@ declare function typedResponse(response: dntShim.Response): Omit<dntShim.Respons
  * @returns the body stringified if it is not a string
  */
 declare function ensureStringBody(body?: JSONValue): string | undefined;
-type Options = Omit<dntShim.RequestInit, 'body'> & {
+type Options = Omit<RequestInit, 'body'> & {
     body?: JSONValue;
     query?: SearchParams;
-    trace?: (...args: Parameters<typeof dntShim.fetch>) => void;
+    trace?: (...args: Parameters<typeof fetch>) => void;
 };
 /**
  *
@@ -55,9 +71,9 @@ type Options = Omit<dntShim.RequestInit, 'body'> & {
  * 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>;
+declare function enhancedFetch(input: string | URL, options?: Options): Promise<Omit<Response, "json" | "text"> & {
+    json: <T = unknown>(schema?: Schema<T> | undefined) => Promise<T>;
+    text: <T_1 extends string = string>(schema?: Schema<T_1> | undefined) => Promise<T_1>;
 }>;
 /**
  *
@@ -70,8 +86,9 @@ declare function enhancedFetch(input: string | URL, options?: Options): Promise<
  * 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>;
+declare function makeService(baseURL: string, baseHeaders?: HeadersInit): Record<"get" | "post" | "put" | "delete" | "patch" | "options" | "head", (path: string, options?: Omit<Options, 'method'>) => Promise<Omit<Response, "json" | "text"> & {
+    json: <T = unknown>(schema?: Schema<T> | undefined) => Promise<T>;
+    text: <T_1 extends string = string>(schema?: Schema<T_1> | undefined) => Promise<T_1>;
 }>>;
-export { addQueryToInput, ensureStringBody, enhancedFetch, makeService, makeGetApiUrl, typedResponse, };
+
+export { addQueryToInput, enhancedFetch, ensureStringBody, makeGetApiUrl, makeService, typedResponse };

package/dist/index.js

@@ -0,0 +1,135 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  addQueryToInput: () => addQueryToInput,
+  enhancedFetch: () => enhancedFetch,
+  ensureStringBody: () => ensureStringBody,
+  makeGetApiUrl: () => makeGetApiUrl,
+  makeService: () => makeService,
+  typedResponse: () => typedResponse
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "options",
+  "head"
+];
+
+// src/internals.ts
+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;
+  };
+}
+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);
+}
+
+// src/make-service.ts
+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;
+}
+function makeGetApiUrl(baseURL) {
+  return (path, searchParams) => addQueryToInput(`${baseURL}${path}`, searchParams);
+}
+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];
+    }
+  });
+}
+function ensureStringBody(body) {
+  if (typeof body === "undefined")
+    return;
+  if (typeof body === "string")
+    return body;
+  return JSON.stringify(body);
+}
+async function enhancedFetch(input, options) {
+  const { query, trace, ...reqInit } = options != null ? 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 == null ? void 0 : trace(url, requestInit);
+  const request = new Request(url, requestInit);
+  const response = await fetch(request);
+  return typedResponse(response);
+}
+function makeService(baseURL, baseHeaders) {
+  const api = (method) => {
+    return async (path, options = {}) => {
+      const response = await enhancedFetch(`${baseURL}${path}`, {
+        ...options,
+        method,
+        headers: { ...baseHeaders, ...options == null ? void 0 : options.headers }
+      });
+      return response;
+    };
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (isHTTPMethod(prop))
+        return api(prop);
+      throw new Error(`Invalid HTTP method: ${prop.toString()}`);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addQueryToInput,
+  enhancedFetch,
+  ensureStringBody,
+  makeGetApiUrl,
+  makeService,
+  typedResponse
+});

package/dist/index.mjs

@@ -0,0 +1,103 @@
+// src/constants.ts
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "options",
+  "head"
+];
+
+// src/internals.ts
+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;
+  };
+}
+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);
+}
+
+// src/make-service.ts
+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;
+}
+function makeGetApiUrl(baseURL) {
+  return (path, searchParams) => addQueryToInput(`${baseURL}${path}`, searchParams);
+}
+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];
+    }
+  });
+}
+function ensureStringBody(body) {
+  if (typeof body === "undefined")
+    return;
+  if (typeof body === "string")
+    return body;
+  return JSON.stringify(body);
+}
+async function enhancedFetch(input, options) {
+  const { query, trace, ...reqInit } = options != null ? 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 == null ? void 0 : trace(url, requestInit);
+  const request = new Request(url, requestInit);
+  const response = await fetch(request);
+  return typedResponse(response);
+}
+function makeService(baseURL, baseHeaders) {
+  const api = (method) => {
+    return async (path, options = {}) => {
+      const response = await enhancedFetch(`${baseURL}${path}`, {
+        ...options,
+        method,
+        headers: { ...baseHeaders, ...options == null ? void 0 : options.headers }
+      });
+      return response;
+    };
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (isHTTPMethod(prop))
+        return api(prop);
+      throw new Error(`Invalid HTTP method: ${prop.toString()}`);
+    }
+  });
+}
+export {
+  addQueryToInput,
+  enhancedFetch,
+  ensureStringBody,
+  makeGetApiUrl,
+  makeService,
+  typedResponse
+};

package/package.json

@@ -1,33 +1,37 @@
 {
-  "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.",
+  "version": "0.0.2",
+  "description": "Some utilities to extend the 'fetch' API to better interact with external APIs.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "author": "Gustavo Guichard <@gugaguichard>",
   "license": "MIT",
-  "author": "Gustavo Guichard",
-  "bugs": {
-    "url": "https://github.com/gustavoguichard/make-service/issues"
+  "scripts": {
+    "build": "tsup ./src/index.ts --format esm,cjs --dts",
+    "dev": "tsup ./src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint *.ts*",
+    "tsc": "tsc",
+    "test": "vitest run"
   },
-  "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"
-      }
-    }
+  "devDependencies": {
+    "eslint": "latest",
+    "jsdom": "^21.1.1",
+    "prettier": "latest",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4",
+    "vitest": "latest",
+    "zod": "latest"
   },
-  "dependencies": {
-    "@deno/shim-deno": "~0.12.0",
-    "undici": "^5.14.0"
+  "files": [
+    "README.md",
+    "./dist/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gugaguichard/make-service.git"
   },
-  "devDependencies": {
-    "@types/node": "^18.11.9"
+  "bugs": {
+    "url": "https://github.com/gugaguichard/make-service/issues"
   }
-}
+}

package/esm/_dnt.shims.js

@@ -1,70 +0,0 @@
-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

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

package/esm/index.js

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

package/esm/internals.js

@@ -1,29 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

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

package/esm/types.js

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

package/script/_dnt.shims.js

@@ -1,80 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-"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

@@ -1,34 +0,0 @@
-"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

@@ -1,157 +0,0 @@
-"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

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

package/script/types.js

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

package/types/_dnt.shims.d.ts

@@ -1,13 +0,0 @@
-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

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

package/types/index.d.ts

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

package/types/internals.d.ts

@@ -1,15 +0,0 @@
-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/types.d.ts

@@ -1,11 +0,0 @@
-/// <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 };