@mercurjs/client 2.0.0-canary.0

package/dist/index.d.mts

@@ -0,0 +1,59 @@
+import { MedusaResponse } from '@medusajs/framework/http';
+
+type DecrementDepth = [never, 0, 1, 2, 3, 4, 5, 6];
+type PrettifyDeep<T, Depth extends number = 4> = Depth extends never ? T : T extends (...args: any[]) => any ? T : T extends Array<infer U> ? Array<PrettifyDeep<U, DecrementDepth[Depth]>> : T extends Date ? T : T extends object ? {
+    [K in keyof T]: PrettifyDeep<T[K], DecrementDepth[Depth]>;
+} & {} : T;
+type TypeError<TMessage extends string> = TMessage;
+type InferInput<TRequest> = TRequest extends {
+    validatedBody: infer Input;
+} ? Input : void;
+type InferOutput<TResponse> = TResponse extends MedusaResponse<infer Output> ? Output : void;
+type HttpMethod = "GET" | "POST" | "DELETE";
+type ChildKeys<T> = Exclude<keyof T, HttpMethod | "__esModule">;
+
+type ClientOptions = {
+    baseUrl: string;
+    fetchOptions?: RequestInit;
+};
+type AddParamsToFn<Fn, TParams> = keyof TParams extends never ? Fn : Fn extends (input?: infer TInput) => infer TOutput ? (input: (TInput extends Record<string, any> ? Omit<TInput, 'fetchOptions'> : {}) & TParams & {
+    fetchOptions?: RequestInit;
+}) => TOutput : Fn extends (input: infer TInput) => infer TOutput ? (input: (TInput extends Record<string, any> ? Omit<TInput, 'fetchOptions'> : {}) & TParams & {
+    fetchOptions?: RequestInit;
+}) => TOutput : Fn;
+type InferFetchFn<TRequest, TResponse, TInput = PrettifyDeep<InferInput<TRequest>>, TOutput = PrettifyDeep<InferOutput<TResponse>>> = [TInput] extends [Record<string, any>] ? (input: TInput & {
+    fetchOptions?: RequestInit;
+}) => Promise<TOutput> : (input?: {
+    fetchOptions?: RequestInit;
+}) => Promise<TOutput>;
+type InferEndpointMethods<TRoutes, TParams> = (TRoutes extends {
+    GET: (req: infer TReq, res: infer TRes) => any;
+} ? {
+    query: AddParamsToFn<InferFetchFn<TReq, TRes>, TParams>;
+} : {}) & (TRoutes extends {
+    POST: (req: infer TReq, res: infer TRes) => any;
+} ? {
+    mutate: AddParamsToFn<InferFetchFn<TReq, TRes>, TParams>;
+} : {}) & (TRoutes extends {
+    DELETE: (req: infer TReq, res: infer TRes) => any;
+} ? {
+    delete: AddParamsToFn<InferFetchFn<TReq, TRes>, TParams>;
+} : {});
+type ProcessRoutes<TRoutes, TParams = {}> = InferEndpointMethods<TRoutes, TParams> & {
+    [K in ChildKeys<TRoutes>]: K extends `$${string}` ? ProcessRoutes<TRoutes[K], TParams & {
+        [P in K]: string;
+    }> : ProcessRoutes<TRoutes[K], TParams>;
+};
+type InferClient<TRoutes> = TRoutes extends Record<string, any> ? ProcessRoutes<TRoutes> : TypeError<`Looks like you forgot to pass the \`Routes\` generic type to the \`createClient\` function.`>;
+
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+type InferClientInput<T> = T extends (input: infer I) => any ? PrettifyDeep<DistributiveOmit<I, 'fetchOptions'>> : T extends (input?: infer I) => any ? PrettifyDeep<DistributiveOmit<NonNullable<I>, 'fetchOptions'>> : never;
+type InferClientOutput<T> = T extends (...args: any[]) => Promise<infer O> ? PrettifyDeep<O> : never;
+declare class ClientError extends Error {
+    status: number | undefined;
+    statusText: string | undefined;
+    constructor(message: string, statusText?: string, status?: number);
+}
+declare function createClient(options: ClientOptions): any;
+
+export { ClientError, type InferClient, type InferClientInput, type InferClientOutput, createClient };

package/dist/index.mjs

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import { stringify } from "qs";
+
+// src/create-proxy.ts
+function createRecursiveProxy(callback, path = []) {
+  return new Proxy(function() {
+  }, {
+    get(_, prop) {
+      if (typeof prop !== "string") {
+        return void 0;
+      }
+      if (prop === "then" || prop === "catch" || prop === "finally") {
+        return void 0;
+      }
+      return createRecursiveProxy(callback, [...path, prop]);
+    },
+    apply(_, __, args) {
+      return callback(path, args);
+    }
+  });
+}
+
+// src/utils.ts
+var kebabCase = (string) => string.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+
+// src/index.ts
+var ClientError = class extends Error {
+  constructor(message, statusText, status) {
+    super(message);
+    this.statusText = statusText;
+    this.status = status;
+  }
+};
+function createClient(options) {
+  const { baseUrl, fetchOptions: defaultFetchOptions } = options;
+  return createRecursiveProxy((path, args) => {
+    var _a;
+    const action = path.pop();
+    const input = (_a = args[0]) != null ? _a : {};
+    const method = action === "query" ? "GET" : action === "mutate" ? "POST" : action === "delete" ? "DELETE" : null;
+    if (!method) {
+      throw new Error(`Action '${action}' is not a valid action.`);
+    }
+    const _b = input, { fetchOptions: inputFetchOptions } = _b, rest = __objRest(_b, ["fetchOptions"]);
+    const urlParts = path.map((segment) => {
+      if (segment.startsWith("$")) {
+        const value = rest[segment];
+        delete rest[segment];
+        return String(value);
+      }
+      return kebabCase(segment);
+    });
+    const urlPath = "/" + urlParts.join("/");
+    const base = new URL(baseUrl);
+    const fullPath = `${base.pathname.replace(/\/$/, "")}/${urlPath.replace(/^\//, "")}`;
+    const url = new URL(fullPath, base.origin);
+    let body;
+    if (method === "GET" && Object.keys(rest).length > 0) {
+      url.search = stringify(rest, { skipNulls: true });
+    } else if (method !== "GET" && Object.keys(rest).length > 0) {
+      body = JSON.stringify(rest);
+    }
+    const headers = new Headers(__spreadValues(__spreadValues({
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    }, defaultFetchOptions == null ? void 0 : defaultFetchOptions.headers), inputFetchOptions == null ? void 0 : inputFetchOptions.headers));
+    return fetch(url, __spreadProps(__spreadValues(__spreadValues({}, defaultFetchOptions), inputFetchOptions), {
+      method,
+      body,
+      headers
+    })).then((response) => __async(null, null, function* () {
+      var _a2, _b2;
+      if (response.status >= 300) {
+        const jsonError = yield response.json().catch(() => ({}));
+        throw new ClientError(
+          (_a2 = jsonError.message) != null ? _a2 : response.statusText,
+          response.statusText,
+          response.status
+        );
+      }
+      const isJsonRequest = (_b2 = headers.get("accept")) == null ? void 0 : _b2.includes("application/json");
+      return isJsonRequest ? yield response.json() : response;
+    }));
+  });
+}
+export {
+  ClientError,
+  createClient
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@mercurjs/client",
+  "version": "2.0.0-canary.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mercurjs/mercur",
+    "directory": "packages/client"
+  },
+  "type": "commonjs",
+  "author": "MercurJS (https://github.com/mercurjs)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "dev": "tsup --watch",
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@tanstack/react-query": "^5.64.2",
+    "qs": "^6.14.0"
+  },
+  "devDependencies": {
+    "@medusajs/framework": "^2.13.0",
+    "@types/qs": "^6.9.18",
+    "tsup": "^8.5.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.8.0"
+  }
+}