@palbase/backend-client 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Palbase
+
+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/dist/index.cjs

@@ -0,0 +1,100 @@
+"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 index_exports = {};
+__export(index_exports, {
+  BackendClient: () => BackendClient,
+  BackendInvocationBuilder: () => BackendInvocationBuilder
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/backend-client.ts
+var BackendInvocationBuilder = class {
+  httpClient;
+  path;
+  constructor(httpClient, path) {
+    this.httpClient = httpClient;
+    this.path = path.replace(/^\/+/, "");
+  }
+  get(options) {
+    return this.call("GET", options);
+  }
+  post(body, options) {
+    return this.call("POST", { ...options, body });
+  }
+  put(body, options) {
+    return this.call("PUT", { ...options, body });
+  }
+  patch(body, options) {
+    return this.call("PATCH", { ...options, body });
+  }
+  del(options) {
+    return this.call("DELETE", options);
+  }
+  call(method, options) {
+    const qs = options?.query ? this.buildQuery(options.query) : "";
+    const fullPath = `/api/${this.path}${qs}`;
+    const reqOpts = {
+      headers: options?.headers,
+      signal: options?.signal
+    };
+    if (options?.body !== void 0) {
+      reqOpts.body = options.body;
+    }
+    return this.httpClient.request(method, fullPath, reqOpts);
+  }
+  buildQuery(q) {
+    const parts = [];
+    for (const [k, v] of Object.entries(q)) {
+      if (v === void 0 || v === null) continue;
+      parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    }
+    return parts.length ? `?${parts.join("&")}` : "";
+  }
+};
+var BackendClient = class {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Build a request for one of the user's defineEndpoint handlers.
+   * Path mirrors the file-based routing: `endpoints/users/get.ts`
+   * → `pb.backend.invoke('users')`. Subdirectories add segments:
+   * `endpoints/orders/[id]/get.ts` → `pb.backend.invoke('orders/123')`.
+   */
+  invoke(path) {
+    return new BackendInvocationBuilder(this.httpClient, path);
+  }
+  /**
+   * One-shot fetch helper. Same semantics as `invoke(path).call(method, options)`.
+   * Useful for dynamic method+path combinations where the chained
+   * builder reads worse, e.g. when the method is a runtime variable.
+   */
+  call(method, path, options) {
+    return this.invoke(path).call(method, options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BackendClient,
+  BackendInvocationBuilder
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/backend-client.ts"],"sourcesContent":["export { BackendClient, BackendInvocationBuilder } from './backend-client.js';\nexport type { InvokeOptions } from './backend-client.js';\n","import type { HttpClient, PalbaseResponse, RequestOptions } from '@palbase/core';\n\n/**\n * Options accepted by every backend invocation. `body` is JSON-encoded\n * for POST/PUT/PATCH; `query` is appended as a query string. `signal`\n * lets callers wire AbortController for cancellation.\n */\nexport interface InvokeOptions {\n  body?: unknown;\n  query?: Record<string, string | number | boolean | null | undefined>;\n  headers?: Record<string, string>;\n  signal?: AbortSignal;\n}\n\n/**\n * BackendInvocationBuilder is the chainable handle returned by\n * `pb.backend.invoke('<path>')`. Each terminal method (`get`, `post`,\n * `put`, `patch`, `del`, `call`) issues a request to\n * `<host>/api/<path>` with the given HTTP verb. The builder is\n * intentionally tiny — backend endpoints are user-defined, so we\n * don't bake any DSL on top.\n */\nexport class BackendInvocationBuilder<T = unknown> {\n  private readonly httpClient: HttpClient;\n  private readonly path: string;\n\n  constructor(httpClient: HttpClient, path: string) {\n    this.httpClient = httpClient;\n    // Strip exactly one leading slash so callers can type either\n    // `pb.backend.invoke('hello')` or `pb.backend.invoke('/hello')`.\n    this.path = path.replace(/^\\/+/, '');\n  }\n\n  get(options?: InvokeOptions): Promise<PalbaseResponse<T>> {\n    return this.call<T>('GET', options);\n  }\n  post(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>> {\n    return this.call<T>('POST', { ...options, body });\n  }\n  put(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>> {\n    return this.call<T>('PUT', { ...options, body });\n  }\n  patch(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>> {\n    return this.call<T>('PATCH', { ...options, body });\n  }\n  del(options?: InvokeOptions): Promise<PalbaseResponse<T>> {\n    return this.call<T>('DELETE', options);\n  }\n\n  call<R = T>(method: string, options?: InvokeOptions): Promise<PalbaseResponse<R>> {\n    const qs = options?.query ? this.buildQuery(options.query) : '';\n    const fullPath = `/api/${this.path}${qs}`;\n    const reqOpts: RequestOptions = {\n      headers: options?.headers,\n      signal: options?.signal,\n    };\n    if (options?.body !== undefined) {\n      // HttpClient JSON-encodes body when content-type is unset.\n      // We pass through raw — caller can override Content-Type via\n      // headers if they need form-urlencoded etc.\n      (reqOpts as RequestOptions & { body?: unknown }).body = options.body;\n    }\n    return this.httpClient.request<R>(method, fullPath, reqOpts);\n  }\n\n  private buildQuery(q: NonNullable<InvokeOptions['query']>): string {\n    const parts: string[] = [];\n    for (const [k, v] of Object.entries(q)) {\n      if (v === undefined || v === null) continue;\n      parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);\n    }\n    return parts.length ? `?${parts.join('&')}` : '';\n  }\n}\n\n/**\n * BackendClient is the entry point exposed as `pb.backend` on the\n * unified client. It issues calls to per-tenant backend-runtime pods\n * routed through Kong as `<ref>.<host>/api/<path>`. Each defineEndpoint\n * a user ships in their `endpoints/` tree becomes one path here.\n */\nexport class BackendClient {\n  private readonly httpClient: HttpClient;\n\n  constructor(httpClient: HttpClient) {\n    this.httpClient = httpClient;\n  }\n\n  /**\n   * Build a request for one of the user's defineEndpoint handlers.\n   * Path mirrors the file-based routing: `endpoints/users/get.ts`\n   * → `pb.backend.invoke('users')`. Subdirectories add segments:\n   * `endpoints/orders/[id]/get.ts` → `pb.backend.invoke('orders/123')`.\n   */\n  invoke<T = unknown>(path: string): BackendInvocationBuilder<T> {\n    return new BackendInvocationBuilder<T>(this.httpClient, path);\n  }\n\n  /**\n   * One-shot fetch helper. Same semantics as `invoke(path).call(method, options)`.\n   * Useful for dynamic method+path combinations where the chained\n   * builder reads worse, e.g. when the method is a runtime variable.\n   */\n  call<T = unknown>(\n    method: string,\n    path: string,\n    options?: InvokeOptions,\n  ): Promise<PalbaseResponse<T>> {\n    return this.invoke<T>(path).call<T>(method, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsBO,IAAM,2BAAN,MAA4C;AAAA,EAChC;AAAA,EACA;AAAA,EAEjB,YAAY,YAAwB,MAAc;AAChD,SAAK,aAAa;AAGlB,SAAK,OAAO,KAAK,QAAQ,QAAQ,EAAE;AAAA,EACrC;AAAA,EAEA,IAAI,SAAsD;AACxD,WAAO,KAAK,KAAQ,OAAO,OAAO;AAAA,EACpC;AAAA,EACA,KAAK,MAAgB,SAAoE;AACvF,WAAO,KAAK,KAAQ,QAAQ,EAAE,GAAG,SAAS,KAAK,CAAC;AAAA,EAClD;AAAA,EACA,IAAI,MAAgB,SAAoE;AACtF,WAAO,KAAK,KAAQ,OAAO,EAAE,GAAG,SAAS,KAAK,CAAC;AAAA,EACjD;AAAA,EACA,MAAM,MAAgB,SAAoE;AACxF,WAAO,KAAK,KAAQ,SAAS,EAAE,GAAG,SAAS,KAAK,CAAC;AAAA,EACnD;AAAA,EACA,IAAI,SAAsD;AACxD,WAAO,KAAK,KAAQ,UAAU,OAAO;AAAA,EACvC;AAAA,EAEA,KAAY,QAAgB,SAAsD;AAChF,UAAM,KAAK,SAAS,QAAQ,KAAK,WAAW,QAAQ,KAAK,IAAI;AAC7D,UAAM,WAAW,QAAQ,KAAK,IAAI,GAAG,EAAE;AACvC,UAAM,UAA0B;AAAA,MAC9B,SAAS,SAAS;AAAA,MAClB,QAAQ,SAAS;AAAA,IACnB;AACA,QAAI,SAAS,SAAS,QAAW;AAI/B,MAAC,QAAgD,OAAO,QAAQ;AAAA,IAClE;AACA,WAAO,KAAK,WAAW,QAAW,QAAQ,UAAU,OAAO;AAAA,EAC7D;AAAA,EAEQ,WAAW,GAAgD;AACjE,UAAM,QAAkB,CAAC;AACzB,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,CAAC,GAAG;AACtC,UAAI,MAAM,UAAa,MAAM,KAAM;AACnC,YAAM,KAAK,GAAG,mBAAmB,CAAC,CAAC,IAAI,mBAAmB,OAAO,CAAC,CAAC,CAAC,EAAE;AAAA,IACxE;AACA,WAAO,MAAM,SAAS,IAAI,MAAM,KAAK,GAAG,CAAC,KAAK;AAAA,EAChD;AACF;AAQO,IAAM,gBAAN,MAAoB;AAAA,EACR;AAAA,EAEjB,YAAY,YAAwB;AAClC,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAoB,MAA2C;AAC7D,WAAO,IAAI,yBAA4B,KAAK,YAAY,IAAI;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,KACE,QACA,MACA,SAC6B;AAC7B,WAAO,KAAK,OAAU,IAAI,EAAE,KAAQ,QAAQ,OAAO;AAAA,EACrD;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,58 @@
+import { HttpClient, PalbaseResponse } from '@palbase/core';
+
+/**
+ * Options accepted by every backend invocation. `body` is JSON-encoded
+ * for POST/PUT/PATCH; `query` is appended as a query string. `signal`
+ * lets callers wire AbortController for cancellation.
+ */
+interface InvokeOptions {
+    body?: unknown;
+    query?: Record<string, string | number | boolean | null | undefined>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * BackendInvocationBuilder is the chainable handle returned by
+ * `pb.backend.invoke('<path>')`. Each terminal method (`get`, `post`,
+ * `put`, `patch`, `del`, `call`) issues a request to
+ * `<host>/api/<path>` with the given HTTP verb. The builder is
+ * intentionally tiny — backend endpoints are user-defined, so we
+ * don't bake any DSL on top.
+ */
+declare class BackendInvocationBuilder<T = unknown> {
+    private readonly httpClient;
+    private readonly path;
+    constructor(httpClient: HttpClient, path: string);
+    get(options?: InvokeOptions): Promise<PalbaseResponse<T>>;
+    post(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>>;
+    put(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>>;
+    patch(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>>;
+    del(options?: InvokeOptions): Promise<PalbaseResponse<T>>;
+    call<R = T>(method: string, options?: InvokeOptions): Promise<PalbaseResponse<R>>;
+    private buildQuery;
+}
+/**
+ * BackendClient is the entry point exposed as `pb.backend` on the
+ * unified client. It issues calls to per-tenant backend-runtime pods
+ * routed through Kong as `<ref>.<host>/api/<path>`. Each defineEndpoint
+ * a user ships in their `endpoints/` tree becomes one path here.
+ */
+declare class BackendClient {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Build a request for one of the user's defineEndpoint handlers.
+     * Path mirrors the file-based routing: `endpoints/users/get.ts`
+     * → `pb.backend.invoke('users')`. Subdirectories add segments:
+     * `endpoints/orders/[id]/get.ts` → `pb.backend.invoke('orders/123')`.
+     */
+    invoke<T = unknown>(path: string): BackendInvocationBuilder<T>;
+    /**
+     * One-shot fetch helper. Same semantics as `invoke(path).call(method, options)`.
+     * Useful for dynamic method+path combinations where the chained
+     * builder reads worse, e.g. when the method is a runtime variable.
+     */
+    call<T = unknown>(method: string, path: string, options?: InvokeOptions): Promise<PalbaseResponse<T>>;
+}
+
+export { BackendClient, BackendInvocationBuilder, type InvokeOptions };

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { HttpClient, PalbaseResponse } from '@palbase/core';
+
+/**
+ * Options accepted by every backend invocation. `body` is JSON-encoded
+ * for POST/PUT/PATCH; `query` is appended as a query string. `signal`
+ * lets callers wire AbortController for cancellation.
+ */
+interface InvokeOptions {
+    body?: unknown;
+    query?: Record<string, string | number | boolean | null | undefined>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+/**
+ * BackendInvocationBuilder is the chainable handle returned by
+ * `pb.backend.invoke('<path>')`. Each terminal method (`get`, `post`,
+ * `put`, `patch`, `del`, `call`) issues a request to
+ * `<host>/api/<path>` with the given HTTP verb. The builder is
+ * intentionally tiny — backend endpoints are user-defined, so we
+ * don't bake any DSL on top.
+ */
+declare class BackendInvocationBuilder<T = unknown> {
+    private readonly httpClient;
+    private readonly path;
+    constructor(httpClient: HttpClient, path: string);
+    get(options?: InvokeOptions): Promise<PalbaseResponse<T>>;
+    post(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>>;
+    put(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>>;
+    patch(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>>;
+    del(options?: InvokeOptions): Promise<PalbaseResponse<T>>;
+    call<R = T>(method: string, options?: InvokeOptions): Promise<PalbaseResponse<R>>;
+    private buildQuery;
+}
+/**
+ * BackendClient is the entry point exposed as `pb.backend` on the
+ * unified client. It issues calls to per-tenant backend-runtime pods
+ * routed through Kong as `<ref>.<host>/api/<path>`. Each defineEndpoint
+ * a user ships in their `endpoints/` tree becomes one path here.
+ */
+declare class BackendClient {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Build a request for one of the user's defineEndpoint handlers.
+     * Path mirrors the file-based routing: `endpoints/users/get.ts`
+     * → `pb.backend.invoke('users')`. Subdirectories add segments:
+     * `endpoints/orders/[id]/get.ts` → `pb.backend.invoke('orders/123')`.
+     */
+    invoke<T = unknown>(path: string): BackendInvocationBuilder<T>;
+    /**
+     * One-shot fetch helper. Same semantics as `invoke(path).call(method, options)`.
+     * Useful for dynamic method+path combinations where the chained
+     * builder reads worse, e.g. when the method is a runtime variable.
+     */
+    call<T = unknown>(method: string, path: string, options?: InvokeOptions): Promise<PalbaseResponse<T>>;
+}
+
+export { BackendClient, BackendInvocationBuilder, type InvokeOptions };

package/dist/index.js

@@ -0,0 +1,72 @@
+// src/backend-client.ts
+var BackendInvocationBuilder = class {
+  httpClient;
+  path;
+  constructor(httpClient, path) {
+    this.httpClient = httpClient;
+    this.path = path.replace(/^\/+/, "");
+  }
+  get(options) {
+    return this.call("GET", options);
+  }
+  post(body, options) {
+    return this.call("POST", { ...options, body });
+  }
+  put(body, options) {
+    return this.call("PUT", { ...options, body });
+  }
+  patch(body, options) {
+    return this.call("PATCH", { ...options, body });
+  }
+  del(options) {
+    return this.call("DELETE", options);
+  }
+  call(method, options) {
+    const qs = options?.query ? this.buildQuery(options.query) : "";
+    const fullPath = `/api/${this.path}${qs}`;
+    const reqOpts = {
+      headers: options?.headers,
+      signal: options?.signal
+    };
+    if (options?.body !== void 0) {
+      reqOpts.body = options.body;
+    }
+    return this.httpClient.request(method, fullPath, reqOpts);
+  }
+  buildQuery(q) {
+    const parts = [];
+    for (const [k, v] of Object.entries(q)) {
+      if (v === void 0 || v === null) continue;
+      parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    }
+    return parts.length ? `?${parts.join("&")}` : "";
+  }
+};
+var BackendClient = class {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Build a request for one of the user's defineEndpoint handlers.
+   * Path mirrors the file-based routing: `endpoints/users/get.ts`
+   * → `pb.backend.invoke('users')`. Subdirectories add segments:
+   * `endpoints/orders/[id]/get.ts` → `pb.backend.invoke('orders/123')`.
+   */
+  invoke(path) {
+    return new BackendInvocationBuilder(this.httpClient, path);
+  }
+  /**
+   * One-shot fetch helper. Same semantics as `invoke(path).call(method, options)`.
+   * Useful for dynamic method+path combinations where the chained
+   * builder reads worse, e.g. when the method is a runtime variable.
+   */
+  call(method, path, options) {
+    return this.invoke(path).call(method, options);
+  }
+};
+export {
+  BackendClient,
+  BackendInvocationBuilder
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend-client.ts"],"sourcesContent":["import type { HttpClient, PalbaseResponse, RequestOptions } from '@palbase/core';\n\n/**\n * Options accepted by every backend invocation. `body` is JSON-encoded\n * for POST/PUT/PATCH; `query` is appended as a query string. `signal`\n * lets callers wire AbortController for cancellation.\n */\nexport interface InvokeOptions {\n  body?: unknown;\n  query?: Record<string, string | number | boolean | null | undefined>;\n  headers?: Record<string, string>;\n  signal?: AbortSignal;\n}\n\n/**\n * BackendInvocationBuilder is the chainable handle returned by\n * `pb.backend.invoke('<path>')`. Each terminal method (`get`, `post`,\n * `put`, `patch`, `del`, `call`) issues a request to\n * `<host>/api/<path>` with the given HTTP verb. The builder is\n * intentionally tiny — backend endpoints are user-defined, so we\n * don't bake any DSL on top.\n */\nexport class BackendInvocationBuilder<T = unknown> {\n  private readonly httpClient: HttpClient;\n  private readonly path: string;\n\n  constructor(httpClient: HttpClient, path: string) {\n    this.httpClient = httpClient;\n    // Strip exactly one leading slash so callers can type either\n    // `pb.backend.invoke('hello')` or `pb.backend.invoke('/hello')`.\n    this.path = path.replace(/^\\/+/, '');\n  }\n\n  get(options?: InvokeOptions): Promise<PalbaseResponse<T>> {\n    return this.call<T>('GET', options);\n  }\n  post(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>> {\n    return this.call<T>('POST', { ...options, body });\n  }\n  put(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>> {\n    return this.call<T>('PUT', { ...options, body });\n  }\n  patch(body?: unknown, options?: Omit<InvokeOptions, 'body'>): Promise<PalbaseResponse<T>> {\n    return this.call<T>('PATCH', { ...options, body });\n  }\n  del(options?: InvokeOptions): Promise<PalbaseResponse<T>> {\n    return this.call<T>('DELETE', options);\n  }\n\n  call<R = T>(method: string, options?: InvokeOptions): Promise<PalbaseResponse<R>> {\n    const qs = options?.query ? this.buildQuery(options.query) : '';\n    const fullPath = `/api/${this.path}${qs}`;\n    const reqOpts: RequestOptions = {\n      headers: options?.headers,\n      signal: options?.signal,\n    };\n    if (options?.body !== undefined) {\n      // HttpClient JSON-encodes body when content-type is unset.\n      // We pass through raw — caller can override Content-Type via\n      // headers if they need form-urlencoded etc.\n      (reqOpts as RequestOptions & { body?: unknown }).body = options.body;\n    }\n    return this.httpClient.request<R>(method, fullPath, reqOpts);\n  }\n\n  private buildQuery(q: NonNullable<InvokeOptions['query']>): string {\n    const parts: string[] = [];\n    for (const [k, v] of Object.entries(q)) {\n      if (v === undefined || v === null) continue;\n      parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);\n    }\n    return parts.length ? `?${parts.join('&')}` : '';\n  }\n}\n\n/**\n * BackendClient is the entry point exposed as `pb.backend` on the\n * unified client. It issues calls to per-tenant backend-runtime pods\n * routed through Kong as `<ref>.<host>/api/<path>`. Each defineEndpoint\n * a user ships in their `endpoints/` tree becomes one path here.\n */\nexport class BackendClient {\n  private readonly httpClient: HttpClient;\n\n  constructor(httpClient: HttpClient) {\n    this.httpClient = httpClient;\n  }\n\n  /**\n   * Build a request for one of the user's defineEndpoint handlers.\n   * Path mirrors the file-based routing: `endpoints/users/get.ts`\n   * → `pb.backend.invoke('users')`. Subdirectories add segments:\n   * `endpoints/orders/[id]/get.ts` → `pb.backend.invoke('orders/123')`.\n   */\n  invoke<T = unknown>(path: string): BackendInvocationBuilder<T> {\n    return new BackendInvocationBuilder<T>(this.httpClient, path);\n  }\n\n  /**\n   * One-shot fetch helper. Same semantics as `invoke(path).call(method, options)`.\n   * Useful for dynamic method+path combinations where the chained\n   * builder reads worse, e.g. when the method is a runtime variable.\n   */\n  call<T = unknown>(\n    method: string,\n    path: string,\n    options?: InvokeOptions,\n  ): Promise<PalbaseResponse<T>> {\n    return this.invoke<T>(path).call<T>(method, options);\n  }\n}\n"],"mappings":";AAsBO,IAAM,2BAAN,MAA4C;AAAA,EAChC;AAAA,EACA;AAAA,EAEjB,YAAY,YAAwB,MAAc;AAChD,SAAK,aAAa;AAGlB,SAAK,OAAO,KAAK,QAAQ,QAAQ,EAAE;AAAA,EACrC;AAAA,EAEA,IAAI,SAAsD;AACxD,WAAO,KAAK,KAAQ,OAAO,OAAO;AAAA,EACpC;AAAA,EACA,KAAK,MAAgB,SAAoE;AACvF,WAAO,KAAK,KAAQ,QAAQ,EAAE,GAAG,SAAS,KAAK,CAAC;AAAA,EAClD;AAAA,EACA,IAAI,MAAgB,SAAoE;AACtF,WAAO,KAAK,KAAQ,OAAO,EAAE,GAAG,SAAS,KAAK,CAAC;AAAA,EACjD;AAAA,EACA,MAAM,MAAgB,SAAoE;AACxF,WAAO,KAAK,KAAQ,SAAS,EAAE,GAAG,SAAS,KAAK,CAAC;AAAA,EACnD;AAAA,EACA,IAAI,SAAsD;AACxD,WAAO,KAAK,KAAQ,UAAU,OAAO;AAAA,EACvC;AAAA,EAEA,KAAY,QAAgB,SAAsD;AAChF,UAAM,KAAK,SAAS,QAAQ,KAAK,WAAW,QAAQ,KAAK,IAAI;AAC7D,UAAM,WAAW,QAAQ,KAAK,IAAI,GAAG,EAAE;AACvC,UAAM,UAA0B;AAAA,MAC9B,SAAS,SAAS;AAAA,MAClB,QAAQ,SAAS;AAAA,IACnB;AACA,QAAI,SAAS,SAAS,QAAW;AAI/B,MAAC,QAAgD,OAAO,QAAQ;AAAA,IAClE;AACA,WAAO,KAAK,WAAW,QAAW,QAAQ,UAAU,OAAO;AAAA,EAC7D;AAAA,EAEQ,WAAW,GAAgD;AACjE,UAAM,QAAkB,CAAC;AACzB,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,CAAC,GAAG;AACtC,UAAI,MAAM,UAAa,MAAM,KAAM;AACnC,YAAM,KAAK,GAAG,mBAAmB,CAAC,CAAC,IAAI,mBAAmB,OAAO,CAAC,CAAC,CAAC,EAAE;AAAA,IACxE;AACA,WAAO,MAAM,SAAS,IAAI,MAAM,KAAK,GAAG,CAAC,KAAK;AAAA,EAChD;AACF;AAQO,IAAM,gBAAN,MAAoB;AAAA,EACR;AAAA,EAEjB,YAAY,YAAwB;AAClC,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAoB,MAA2C;AAC7D,WAAO,IAAI,yBAA4B,KAAK,YAAY,IAAI;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,KACE,QACA,MACA,SAC6B;AAC7B,WAAO,KAAK,OAAU,IAAI,EAAE,KAAQ,QAAQ,OAAO;AAAA,EACrD;AACF;","names":[]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@palbase/backend-client",
+  "version": "0.7.0",
+  "description": "Palbase backend client — call your project's defineEndpoint handlers from the browser/server",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/palgroup/palbase-ts.git",
+    "directory": "modules/backend-client"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@palbase/core": "^0.7.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "biome check src/ __tests__/"
+  }
+}