@nkmc/agent-fs 0.1.0

package/dist/testing.cjs

@@ -0,0 +1,842 @@
+"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/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  HttpBackend: () => HttpBackend,
+  MemoryBackend: () => MemoryBackend,
+  RpcBackend: () => RpcBackend
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/backends/memory.ts
+var MemoryBackend = class {
+  collections = /* @__PURE__ */ new Map();
+  nextId = 1;
+  /** Pre-seed a collection with data */
+  seed(collection, records) {
+    const col = this.getOrCreateCollection(collection);
+    for (const record of records) {
+      col.set(record.id, { ...record });
+    }
+  }
+  async list(path) {
+    const { collection, id } = this.parsePath(path);
+    if (!collection) {
+      return Array.from(this.collections.keys()).map((c) => c + "/");
+    }
+    if (!id) {
+      const col = this.collections.get(collection);
+      if (!col) return [];
+      return Array.from(col.keys()).map((k) => `${k}.json`);
+    }
+    return [];
+  }
+  async read(path) {
+    const { collection, id } = this.parsePath(path);
+    if (!collection) {
+      throw new NotFoundError(path);
+    }
+    const col = this.collections.get(collection);
+    if (!col) {
+      throw new NotFoundError(path);
+    }
+    if (id === "_schema") {
+      return this.getSchema(collection);
+    }
+    if (id === "_count") {
+      return { count: col.size };
+    }
+    if (!id) {
+      return Array.from(col.values());
+    }
+    const record = col.get(id);
+    if (!record) {
+      throw new NotFoundError(path);
+    }
+    return record;
+  }
+  async write(path, data) {
+    const { collection, id } = this.parsePath(path);
+    if (!collection) {
+      throw new Error("Cannot write to root");
+    }
+    const col = this.getOrCreateCollection(collection);
+    const record = data;
+    if (id) {
+      const existing = col.get(id);
+      if (!existing) {
+        throw new NotFoundError(path);
+      }
+      const updated = { ...existing, ...record, id };
+      col.set(id, updated);
+      return { id };
+    }
+    const newId = record.id ?? String(this.nextId++);
+    const newRecord = { ...record, id: newId };
+    col.set(newId, newRecord);
+    return { id: newId };
+  }
+  async remove(path) {
+    const { collection, id } = this.parsePath(path);
+    if (!collection || !id) {
+      throw new Error("Cannot remove a collection, specify a record path");
+    }
+    const col = this.collections.get(collection);
+    if (!col || !col.has(id)) {
+      throw new NotFoundError(path);
+    }
+    col.delete(id);
+  }
+  async search(path, pattern) {
+    const { collection } = this.parsePath(path);
+    if (!collection) {
+      throw new Error("grep requires a collection path");
+    }
+    const col = this.collections.get(collection);
+    if (!col) return [];
+    const results = [];
+    for (const record of col.values()) {
+      const json = JSON.stringify(record);
+      if (json.includes(pattern)) {
+        results.push(record);
+      }
+    }
+    return results;
+  }
+  parsePath(path) {
+    const cleaned = path.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!cleaned) return {};
+    const parts = cleaned.split("/");
+    const collection = parts[0];
+    let id = parts[1];
+    if (id?.endsWith(".json")) {
+      id = id.slice(0, -5);
+    }
+    return { collection, id };
+  }
+  getOrCreateCollection(name) {
+    let col = this.collections.get(name);
+    if (!col) {
+      col = /* @__PURE__ */ new Map();
+      this.collections.set(name, col);
+    }
+    return col;
+  }
+  getSchema(collection) {
+    const col = this.collections.get(collection);
+    if (!col || col.size === 0) {
+      return { collection, fields: [] };
+    }
+    const first = col.values().next().value;
+    const fields = Object.entries(first).map(([name, value]) => ({
+      name,
+      type: typeof value
+    }));
+    return { collection, fields };
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(path) {
+    super(`Not found: ${path}`);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/backends/http.ts
+var HttpBackend = class {
+  baseUrl;
+  auth;
+  resourceList;
+  endpoints;
+  params;
+  _fetch;
+  bodyEncoding;
+  pagination;
+  retryConfig;
+  /** Cached OAuth2 access token */
+  _oauth2Token;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.auth = config.auth;
+    this.resourceList = config.resources ?? [];
+    this.endpoints = new Map(
+      (config.endpoints ?? []).map((e) => [e.name, e])
+    );
+    this.params = config.params ?? {};
+    this._fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.bodyEncoding = config.bodyEncoding ?? "json";
+    this.retryConfig = {
+      maxRetries: config.retry?.maxRetries ?? 3,
+      baseDelayMs: config.retry?.baseDelayMs ?? 1e3
+    };
+    if (config.pagination) {
+      this.pagination = {
+        ...config.pagination,
+        maxPages: config.pagination.maxPages ?? 10
+      };
+    }
+  }
+  async list(path) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "root") {
+      const entries = [];
+      for (const r of this.resourceList) {
+        entries.push(r.name + "/");
+      }
+      if (this.endpoints.size > 0) {
+        entries.push("_api/");
+      }
+      return entries;
+    }
+    if (parsed.type === "api-list") {
+      return Array.from(this.endpoints.values()).map(
+        (e) => `${e.name} [${e.method}]`
+      );
+    }
+    if (parsed.type === "resource-list") {
+      const { resource, resolvedApiPath } = parsed;
+      const items = await this.fetchAllItems(resource, resolvedApiPath);
+      if (!Array.isArray(items)) return [];
+      return this.formatListItems(resource, items);
+    }
+    if (parsed.type === "passthrough") {
+      const resp = await this.request("GET", parsed.apiPath);
+      if (!resp.ok) return [];
+      const data = await safeJson(resp);
+      if (data === null) return [];
+      if (Array.isArray(data)) return data.map((item) => String(item.id ?? item.name ?? JSON.stringify(item)));
+      return Object.keys(data);
+    }
+    if (parsed.type === "resource-item") {
+      const { resource, resolvedApiPath, id } = parsed;
+      if (resource.pathMode === "tree") {
+        const resp = await this.request("GET", `${resolvedApiPath}/${id}`);
+        if (!resp.ok) return [];
+        const data = await safeJson(resp);
+        if (data === null) return [];
+        if (Array.isArray(data)) {
+          return this.formatListItems(resource, data);
+        }
+        return [];
+      }
+      if (resource.children && resource.children.length > 0) {
+        return resource.children.map((c) => c.name + "/");
+      }
+      return [];
+    }
+    return [];
+  }
+  async read(path) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-item") {
+      const { resource, resolvedApiPath, id } = parsed;
+      if (id === "_schema") {
+        return {
+          resource: resource.name,
+          fields: resource.fields ?? []
+        };
+      }
+      if (id === "_count") {
+        const resp2 = await this.request("GET", resolvedApiPath);
+        const data = await safeJson(resp2) ?? {};
+        const items = extractList(data, resource.listKey);
+        return { count: Array.isArray(items) ? items.length : 0 };
+      }
+      const resp = await this.request("GET", `${resolvedApiPath}/${id}`);
+      if (!resp.ok) throw new NotFoundError(path);
+      let result = await safeJson(resp);
+      if (resource.transform?.read) result = resource.transform.read(result);
+      return result;
+    }
+    if (parsed.type === "resource-list") {
+      const { resource, resolvedApiPath } = parsed;
+      const resp = await this.request("GET", resolvedApiPath);
+      const data = await safeJson(resp);
+      return data === null ? [] : extractList(data, resource.listKey) ?? data;
+    }
+    if (parsed.type === "api-call") {
+      const endpoint = this.getEndpoint(parsed.endpoint);
+      const resp = await this.request(endpoint.method, endpoint.apiPath);
+      return safeJson(resp);
+    }
+    if (parsed.type === "passthrough") {
+      const resp = await this.request("GET", parsed.apiPath);
+      if (!resp.ok) throw new NotFoundError(path);
+      return safeJson(resp);
+    }
+    throw new NotFoundError(path);
+  }
+  async write(path, data) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "root" && this.resourceList.length === 0 && this.endpoints.size === 0) {
+      const resp = await this.request("POST", "/", data);
+      const result = await safeJson(resp) ?? {};
+      return { id: String(result.id ?? "ok") };
+    }
+    if (parsed.type === "resource-item" && parsed.id) {
+      const { resource, resolvedApiPath, id } = parsed;
+      let writeData = data;
+      if (resource.readBeforeWrite) {
+        try {
+          const readResp = await this.request(
+            "GET",
+            `${resolvedApiPath}/${id}`
+          );
+          if (readResp.ok) {
+            const readResult = await safeJson(readResp);
+            if (readResult) writeData = resource.readBeforeWrite.inject(readResult, writeData);
+          }
+        } catch {
+        }
+      }
+      if (resource.transform?.write) writeData = resource.transform.write(writeData);
+      const method = resource.updateMethod ?? "PUT";
+      const resp = await this.request(
+        method,
+        `${resolvedApiPath}/${id}`,
+        writeData
+      );
+      if (!resp.ok) throw new NotFoundError(path);
+      const result = await safeJson(resp) ?? {};
+      const idField = resource.idField ?? "id";
+      return { id: String(result[idField] ?? id) };
+    }
+    if (parsed.type === "resource-list") {
+      const { resource, resolvedApiPath } = parsed;
+      let writeData = data;
+      if (resource.transform?.write) writeData = resource.transform.write(writeData);
+      const resp = await this.request("POST", resolvedApiPath, writeData);
+      const result = await safeJson(resp) ?? {};
+      const idField = resource.idField ?? "id";
+      return { id: String(result[idField] ?? "unknown") };
+    }
+    if (parsed.type === "api-call") {
+      const endpoint = this.getEndpoint(parsed.endpoint);
+      const resp = await this.request(endpoint.method, endpoint.apiPath, data);
+      const result = await safeJson(resp) ?? {};
+      return { id: result.id ?? "ok" };
+    }
+    if (parsed.type === "passthrough") {
+      const method = parsed.apiPath === "/" ? "POST" : "PUT";
+      const resp = await this.request(method, parsed.apiPath, data);
+      const result = await safeJson(resp) ?? {};
+      return { id: String(result.id ?? "ok") };
+    }
+    throw new Error(`Cannot write to path: ${path}`);
+  }
+  async remove(path) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-item" && parsed.id) {
+      const { resource, resolvedApiPath, id } = parsed;
+      let deleteBody;
+      if (resource.readBeforeWrite) {
+        const readResp = await this.request(
+          "GET",
+          `${resolvedApiPath}/${id}`
+        );
+        if (!readResp.ok) throw new NotFoundError(path);
+        const readResult = await safeJson(readResp);
+        if (resource.transform?.remove) {
+          deleteBody = resource.transform.remove(readResult);
+        }
+      } else if (resource.transform?.remove) {
+        deleteBody = resource.transform.remove(null);
+      }
+      const resp = await this.request(
+        "DELETE",
+        `${resolvedApiPath}/${id}`,
+        deleteBody
+      );
+      if (!resp.ok) throw new NotFoundError(path);
+      return;
+    }
+    if (parsed.type === "passthrough") {
+      const resp = await this.request("DELETE", parsed.apiPath);
+      if (!resp.ok) throw new NotFoundError(path);
+      return;
+    }
+    throw new Error(`Cannot remove path: ${path}`);
+  }
+  async search(path, pattern) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-list" || parsed.type === "resource-item") {
+      const { resource, resolvedApiPath } = parsed;
+      const resp = await this.request(
+        "GET",
+        `${resolvedApiPath}?q=${encodeURIComponent(pattern)}`
+      );
+      const data = await safeJson(resp) ?? {};
+      const items = extractList(data, resource.listKey);
+      if (Array.isArray(items)) return items;
+      const allResp = await this.request("GET", resolvedApiPath);
+      const allData = await safeJson(allResp) ?? {};
+      const allItems = extractList(allData, resource.listKey);
+      if (!Array.isArray(allItems)) return [];
+      return allItems.filter(
+        (item) => JSON.stringify(item).includes(pattern)
+      );
+    }
+    if (parsed.type === "passthrough") {
+      const resp = await this.request("GET", `${parsed.apiPath}?q=${encodeURIComponent(pattern)}`);
+      const data = await safeJson(resp);
+      return Array.isArray(data) ? data : [];
+    }
+    return [];
+  }
+  // --- Internal helpers ---
+  async request(method, apiPath, body, absoluteUrl) {
+    const url = absoluteUrl ? apiPath : `${this.baseUrl}${apiPath}`;
+    const useForm = this.bodyEncoding === "form";
+    const headers = {
+      "Content-Type": useForm ? "application/x-www-form-urlencoded" : "application/json",
+      Accept: "application/json",
+      "User-Agent": "nkmc-gateway/1.0"
+    };
+    if (this.auth) {
+      switch (this.auth.type) {
+        case "bearer": {
+          const prefix = this.auth.prefix ?? "Bearer";
+          headers["Authorization"] = `${prefix} ${this.auth.token}`;
+          break;
+        }
+        case "api-key":
+          headers[this.auth.header] = this.auth.key;
+          break;
+        case "basic":
+          headers["Authorization"] = `Basic ${btoa(`${this.auth.username}:${this.auth.password}`)}`;
+          break;
+        case "oauth2": {
+          const token = await this.getOAuth2Token();
+          headers["Authorization"] = `Bearer ${token}`;
+          break;
+        }
+      }
+    }
+    let encodedBody;
+    if (body !== void 0) {
+      encodedBody = useForm ? encodeFormBody(body) : JSON.stringify(body);
+    }
+    let lastResp;
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      lastResp = await this._fetch(url, {
+        method,
+        headers,
+        body: encodedBody
+      });
+      if (lastResp.ok || lastResp.status >= 400 && lastResp.status < 500 && lastResp.status !== 429) {
+        return lastResp;
+      }
+      if (attempt === this.retryConfig.maxRetries) break;
+      let delayMs;
+      const retryAfter = lastResp.headers.get("retry-after");
+      if (retryAfter) {
+        const seconds = Number(retryAfter);
+        delayMs = isNaN(seconds) ? this.retryConfig.baseDelayMs : seconds * 1e3;
+      } else {
+        delayMs = this.retryConfig.baseDelayMs * Math.pow(2, attempt) * (0.5 + Math.random() * 0.5);
+      }
+      await sleep(delayMs);
+    }
+    return lastResp;
+  }
+  /** Obtain (or refresh) OAuth2 access token via client_credentials grant */
+  async getOAuth2Token() {
+    if (this.auth?.type !== "oauth2") throw new Error("Not OAuth2 auth");
+    if (this._oauth2Token && Date.now() < this._oauth2Token.expiresAt - 3e4) {
+      return this._oauth2Token.token;
+    }
+    const { tokenUrl, clientId, clientSecret, scope } = this.auth;
+    const params = new URLSearchParams({ grant_type: "client_credentials" });
+    if (scope) params.set("scope", scope);
+    const resp = await this._fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`
+      },
+      body: params.toString()
+    });
+    if (!resp.ok) {
+      throw new Error(`OAuth2 token request failed: ${resp.status} ${resp.statusText}`);
+    }
+    const data = await resp.json();
+    const expiresIn = data.expires_in ?? 3600;
+    this._oauth2Token = {
+      token: data.access_token,
+      expiresAt: Date.now() + expiresIn * 1e3
+    };
+    return this._oauth2Token.token;
+  }
+  /** Parse Link header to extract rel="next" URL */
+  getNextPageUrl(resp) {
+    const link = resp.headers.get("link");
+    if (!link) return null;
+    const match = link.match(/<([^>]+)>;\s*rel="next"/);
+    return match ? match[1] : null;
+  }
+  /** Fetch all items with optional pagination */
+  async fetchAllItems(resource, apiPath) {
+    const resp = await this.request("GET", apiPath);
+    const data = await safeJson(resp);
+    if (data === null) return [];
+    let items = extractList(data, resource.listKey);
+    if (!Array.isArray(items)) return [];
+    if (this.pagination) {
+      const maxPages = this.pagination.maxPages;
+      let pages = 1;
+      if (this.pagination.type === "link-header") {
+        let nextUrl = this.getNextPageUrl(resp);
+        while (nextUrl && pages < maxPages) {
+          const nextResp = await this.request("GET", nextUrl, void 0, true);
+          const nextData = await safeJson(nextResp);
+          if (!nextData) break;
+          const nextItems = extractList(nextData, resource.listKey);
+          if (!Array.isArray(nextItems) || nextItems.length === 0) break;
+          items = items.concat(nextItems);
+          nextUrl = this.getNextPageUrl(nextResp);
+          pages++;
+        }
+      } else if (this.pagination.type === "cursor") {
+        const { cursorParam, cursorPath } = this.pagination;
+        let cursor = getNestedValue(data, cursorPath);
+        while (cursor && pages < maxPages) {
+          const sep = apiPath.includes("?") ? "&" : "?";
+          const nextResp = await this.request("GET", `${apiPath}${sep}${cursorParam}=${encodeURIComponent(String(cursor))}`);
+          const nextData = await safeJson(nextResp);
+          if (!nextData) break;
+          const nextItems = extractList(nextData, resource.listKey);
+          if (!Array.isArray(nextItems) || nextItems.length === 0) break;
+          items = items.concat(nextItems);
+          cursor = getNestedValue(nextData, cursorPath);
+          pages++;
+        }
+      } else if (this.pagination.type === "offset") {
+        const { offsetParam = "offset", limitParam = "limit", pageSize = 100 } = this.pagination;
+        let offset = items.length;
+        while (pages < maxPages) {
+          const sep = apiPath.includes("?") ? "&" : "?";
+          const nextResp = await this.request("GET", `${apiPath}${sep}${offsetParam}=${offset}&${limitParam}=${pageSize}`);
+          const nextData = await safeJson(nextResp);
+          if (!nextData) break;
+          const nextItems = extractList(nextData, resource.listKey);
+          if (!Array.isArray(nextItems) || nextItems.length === 0) break;
+          items = items.concat(nextItems);
+          offset += nextItems.length;
+          pages++;
+        }
+      } else if (this.pagination.type === "page") {
+        const { pageParam = "page" } = this.pagination;
+        let page = 2;
+        while (pages < maxPages) {
+          const sep = apiPath.includes("?") ? "&" : "?";
+          const nextResp = await this.request("GET", `${apiPath}${sep}${pageParam}=${page}`);
+          const nextData = await safeJson(nextResp);
+          if (!nextData) break;
+          const nextItems = extractList(nextData, resource.listKey);
+          if (!Array.isArray(nextItems) || nextItems.length === 0) break;
+          items = items.concat(nextItems);
+          page++;
+          pages++;
+        }
+      }
+    }
+    return items;
+  }
+  /** Format list items using transform.list or default idField + ".json" */
+  formatListItems(resource, items) {
+    if (resource.transform?.list) {
+      return items.map((item) => resource.transform.list(item));
+    }
+    const idField = resource.idField ?? "id";
+    return items.map(
+      (item) => String(item[idField]) + ".json"
+    );
+  }
+  getEndpoint(name) {
+    const endpoint = this.endpoints.get(name);
+    if (!endpoint) throw new NotFoundError(`Endpoint not found: ${name}`);
+    return endpoint;
+  }
+  /** Replace :param and {param} placeholders in API paths with values from config.params */
+  resolveTemplate(path) {
+    return path.replace(/:(\w+)/g, (_, key) => {
+      const value = this.params[key];
+      if (value === void 0) throw new Error(`Missing param: ${key}`);
+      return value;
+    }).replace(/\{(\w+)\}/g, (_, key) => {
+      const value = this.params[key];
+      if (value === void 0) throw new Error(`Missing param: ${key}`);
+      return value;
+    });
+  }
+  /** Recursively resolve a filesystem path against the resource tree */
+  resolveResourcePath(parts, pos, resources, parentApiPath) {
+    if (pos >= parts.length) return null;
+    const resourceName = parts[pos];
+    const resource = resources.find((r) => r.name === resourceName);
+    if (!resource) return null;
+    const rawSegment = resource.apiPath ?? `/${resource.name}`;
+    const resolvedSegment = this.resolveTemplate(rawSegment);
+    const baseApiPath = parentApiPath + resolvedSegment;
+    const remaining = parts.length - pos - 1;
+    if (resource.pathMode === "tree") {
+      if (remaining === 0) {
+        return { type: "resource-list", resource, resolvedApiPath: baseApiPath };
+      }
+      const id2 = parts.slice(pos + 1).join("/");
+      return { type: "resource-item", resource, resolvedApiPath: baseApiPath, id: id2 };
+    }
+    if (remaining === 0) {
+      return { type: "resource-list", resource, resolvedApiPath: baseApiPath };
+    }
+    const rawId = parts[pos + 1];
+    if (remaining >= 2) {
+      if (resource.children) {
+        const childResult = this.resolveResourcePath(
+          parts,
+          pos + 2,
+          resource.children,
+          baseApiPath + "/" + rawId
+        );
+        if (childResult) return childResult;
+      }
+      return null;
+    }
+    let id = rawId;
+    if (id.endsWith(".json")) id = id.slice(0, -5);
+    return { type: "resource-item", resource, resolvedApiPath: baseApiPath, id };
+  }
+  parsePath(path) {
+    const cleaned = path.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!cleaned) return { type: "root" };
+    const parts = cleaned.split("/");
+    if (parts[0] === "_api") {
+      if (parts.length === 1) return { type: "api-list" };
+      return { type: "api-call", endpoint: parts[1] };
+    }
+    const result = this.resolveResourcePath(
+      parts,
+      0,
+      this.resourceList,
+      ""
+    );
+    if (!result) {
+      return { type: "passthrough", apiPath: "/" + cleaned };
+    }
+    return result;
+  }
+};
+async function safeJson(resp) {
+  if (resp.status === 204) return null;
+  const text = await resp.text();
+  if (!text || !text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function extractList(data, listKey) {
+  if (Array.isArray(data)) return data;
+  if (typeof data !== "object" || data === null) return data;
+  if (listKey) return data[listKey];
+  let firstEmpty = null;
+  for (const value of Object.values(data)) {
+    if (Array.isArray(value)) {
+      if (value.length > 0) return value;
+      if (!firstEmpty) firstEmpty = value;
+    }
+  }
+  if (firstEmpty) return firstEmpty;
+  return data;
+}
+function getNestedValue(obj, path) {
+  let current = obj;
+  for (const key of path.split(".")) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function encodeFormBody(data, prefix) {
+  if (data === null || data === void 0) return "";
+  if (typeof data !== "object") {
+    return prefix ? `${encodeURIComponent(prefix)}=${encodeURIComponent(String(data))}` : "";
+  }
+  const parts = [];
+  const obj = data;
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}[${key}]` : key;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        parts.push(`${encodeURIComponent(`${fullKey}[]`)}=${encodeURIComponent(String(item))}`);
+      }
+    } else if (value !== null && typeof value === "object") {
+      const nested = encodeFormBody(value, fullKey);
+      if (nested) parts.push(nested);
+    } else if (value !== void 0) {
+      parts.push(`${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  return parts.join("&");
+}
+
+// src/backends/rpc.ts
+var RpcBackend = class {
+  transport;
+  resources;
+  constructor(config) {
+    this.transport = config.transport;
+    this.resources = config.resources;
+  }
+  async list(path) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "root") {
+      return this.resources.filter((r) => r.methods.list || r.methods.read).map((r) => r.name + "/");
+    }
+    if (parsed.type === "resource-list") {
+      const { resource } = parsed;
+      if (!resource.methods.list) return [];
+      const { method, params } = resource.methods.list;
+      const result = await this.transport.call(method, params({}));
+      if (resource.transform?.list) {
+        const transformed = resource.transform.list(result);
+        return Array.isArray(transformed) ? transformed : [transformed];
+      }
+      if (Array.isArray(result)) {
+        const idField = resource.idField ?? "id";
+        return result.map(
+          (item) => String(item[idField]) + ".json"
+        );
+      }
+      return [];
+    }
+    return [];
+  }
+  async read(path) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-item") {
+      const { resource, id } = parsed;
+      if (!resource.methods.read) {
+        throw new NotFoundError(path);
+      }
+      const { method, params } = resource.methods.read;
+      const result = await this.transport.call(method, params({ id }));
+      if (result === null || result === void 0) {
+        throw new NotFoundError(path);
+      }
+      return resource.transform?.read ? resource.transform.read(result) : result;
+    }
+    if (parsed.type === "resource-list") {
+      const { resource } = parsed;
+      if (!resource.methods.list) {
+        throw new NotFoundError(path);
+      }
+      const { method, params } = resource.methods.list;
+      return this.transport.call(method, params({}));
+    }
+    throw new NotFoundError(path);
+  }
+  async write(path, data) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-item") {
+      const { resource, id } = parsed;
+      const rpcMethod = resource.methods.write ?? resource.methods.create;
+      if (!rpcMethod) throw new Error(`Cannot write to path: ${path}`);
+      const writeData = resource.transform?.write ? resource.transform.write(data) : data;
+      const { method, params } = rpcMethod;
+      const result = await this.transport.call(method, params({ id, data: writeData }));
+      return { id: String(result ?? id) };
+    }
+    if (parsed.type === "resource-list") {
+      const { resource } = parsed;
+      const rpcMethod = resource.methods.create ?? resource.methods.write;
+      if (!rpcMethod) throw new Error(`Cannot write to path: ${path}`);
+      const writeData = resource.transform?.write ? resource.transform.write(data) : data;
+      const { method, params } = rpcMethod;
+      const result = await this.transport.call(method, params({ data: writeData }));
+      return { id: String(result ?? "unknown") };
+    }
+    throw new Error(`Cannot write to path: ${path}`);
+  }
+  async remove(path) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-item") {
+      const { resource, id } = parsed;
+      if (!resource.methods.remove) {
+        throw new Error(`Cannot remove path: ${path}`);
+      }
+      const { method, params } = resource.methods.remove;
+      await this.transport.call(method, params({ id }));
+      return;
+    }
+    throw new Error(`Cannot remove path: ${path}`);
+  }
+  async search(path, pattern) {
+    const parsed = this.parsePath(path);
+    if (parsed.type === "resource-list" || parsed.type === "resource-item") {
+      const { resource } = parsed;
+      if (resource.methods.search) {
+        const { method, params } = resource.methods.search;
+        const result = await this.transport.call(method, params({ pattern }));
+        if (Array.isArray(result)) return result;
+        return [result];
+      }
+      if (resource.methods.list) {
+        const { method, params } = resource.methods.list;
+        const result = await this.transport.call(method, params({}));
+        if (Array.isArray(result)) {
+          return result.filter(
+            (item) => JSON.stringify(item).includes(pattern)
+          );
+        }
+        if (JSON.stringify(result).includes(pattern)) {
+          return [result];
+        }
+      }
+    }
+    return [];
+  }
+  // --- Internal ---
+  parsePath(path) {
+    const cleaned = path.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!cleaned) return { type: "root" };
+    const parts = cleaned.split("/");
+    const resourceName = parts[0];
+    const resource = this.resources.find((r) => r.name === resourceName);
+    if (!resource) throw new NotFoundError(`Invalid path: ${path}`);
+    if (parts.length === 1) {
+      return { type: "resource-list", resource };
+    }
+    let id = parts.slice(1).join("/");
+    if (id.endsWith(".json")) id = id.slice(0, -5);
+    return { type: "resource-item", resource, id };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpBackend,
+  MemoryBackend,
+  RpcBackend
+});