@mdxui/do 4.0.0 → 4.0.8

package/dist/{chunk-OVLO7UOH.js → chunk-KLN5OTQH.js}

@@ -1,20 +1,60 @@
-import { retryWithBackoff } from './chunk-Y52IEYVM.js';
-import { newWebSocketRpcSession } from 'capnweb';
-import { useState, useRef, useCallback, useEffect } from 'react';
+import { createDOApiClient } from '@dotdo/do/sdk';
 
-function createCapnwebClient(baseUrl, options = {}) {
-  const httpUrl = `${baseUrl.replace(/\/$/, "").replace(/\/rpc$/, "")}/rpc`;
-  const wsUrl = httpUrl.replace(/^http/, "ws");
-  const rpcUrl = options.authToken ? `${wsUrl}?token=${encodeURIComponent(options.authToken)}` : wsUrl;
-  const session = newWebSocketRpcSession(rpcUrl);
-  const rpc = session;
+// src/client/dotdo-client.ts
+function normalizeApiItem(item, defaultNs) {
+  if (!item || typeof item !== "object") {
+    return null;
+  }
+  const {
+    id,
+    $id,
+    // Canonical format
+    $type,
+    name,
+    createdAt,
+    updatedAt,
+    data,
+    // Canonical format has nested data
+    ...restData
+  } = item;
+  const entityId = $id ?? id ?? crypto.randomUUID();
+  const type = $type ?? item.type ?? "Unknown";
+  const entityData = data && typeof data === "object" ? data : restData;
+  const derivedName = name ?? entityData.title ?? entityData.label ?? entityData.displayName ?? entityData.email ?? entityData.username ?? `${type} ${entityId.slice(0, 8)}`;
+  return {
+    id: entityId,
+    ns: defaultNs,
+    type,
+    name: derivedName,
+    createdAt: createdAt ? new Date(createdAt) : /* @__PURE__ */ new Date(),
+    updatedAt: updatedAt ? new Date(updatedAt) : /* @__PURE__ */ new Date(),
+    data: entityData
+  };
+}
+function createDOClient(baseUrl, options = {}) {
+  const rpc = createDOApiClient({
+    baseURL: baseUrl,
+    token: options.authToken,
+    transport: options.transport ?? "http"
+  });
   return {
     /**
      * Namespace operations
      */
     Namespace: {
       async list(_params) {
-        return [{ id: "default", name: "default" }];
+        try {
+          const result = await rpc.namespaces?.list?.();
+          if (Array.isArray(result)) {
+            return result;
+          }
+          if (result?.items) {
+            return result.items;
+          }
+          return [{ id: "default", name: "default" }];
+        } catch {
+          return [{ id: "default", name: "default" }];
+        }
       }
     },
     /**
@@ -23,20 +63,23 @@ function createCapnwebClient(baseUrl, options = {}) {
     Schema: {
       async discover(_params) {
         try {
-          const schemas = await rpc.getSchemas();
+          const result = await rpc.schemas?.list?.();
+          const types = Array.isArray(result) ? result : result?.items ?? result?.data ?? [];
           return {
             namespaces: ["default"],
-            types: schemas ?? [],
-            schemas: schemas ?? []
+            types: types.map(
+              (t) => typeof t === "string" ? t : t?.name ?? t
+            ),
+            schemas: types
           };
         } catch (error) {
-          console.error("[@mdxui/do] Failed to get schemas:", error);
+          console.error("[@mdxui/do] Failed to discover schemas:", error);
           return { namespaces: ["default"], types: [], schemas: [] };
         }
       },
       async get(params) {
         try {
-          const result = await rpc.getSchema(params.type);
+          const result = await rpc.schemas?.get?.(params.type);
           return result;
         } catch {
           return null;
@@ -48,11 +91,35 @@ function createCapnwebClient(baseUrl, options = {}) {
      */
     Thing: {
       async types(params) {
+        const ns = params.ns ?? "default";
         try {
-          const schemas = await rpc.getSchemas();
-          return (schemas ?? []).map((name) => ({
-            name,
-            ns: params.ns || "default"
+          const result = await rpc.types?.list?.();
+          const types = Array.isArray(result) ? result : result?.items ?? result?.data ?? [];
+          if (types.length > 0) {
+            return types.map((t) => {
+              if (typeof t === "string") {
+                return { name: t, ns };
+              }
+              return { name: t?.name ?? t, ns };
+            });
+          }
+          const thingsResult = await rpc.things?.list?.({ limit: 1e3 });
+          let rawItems = [];
+          if (Array.isArray(thingsResult)) {
+            rawItems = thingsResult;
+          } else if (thingsResult) {
+            rawItems = thingsResult.data || thingsResult.items || thingsResult.result || [];
+          }
+          const uniqueTypes = /* @__PURE__ */ new Set();
+          for (const item of rawItems) {
+            const type = item.$type ?? item.type;
+            if (type) {
+              uniqueTypes.add(type);
+            }
+          }
+          return Array.from(uniqueTypes).map((typeName) => ({
+            name: typeName,
+            ns
           }));
         } catch (error) {
           console.error("[@mdxui/do] Failed to get types:", error);
@@ -61,19 +128,26 @@ function createCapnwebClient(baseUrl, options = {}) {
       },
       async list(params) {
         try {
+          const ns = params.ns ?? "default";
           const options2 = {};
           if (params.type) options2.type = params.type;
+          if (params.type) options2.$type = params.type;
           if (params.limit !== void 0) options2.limit = params.limit;
           if (params.offset !== void 0) options2.offset = params.offset;
-          const result = await rpc.list(options2);
+          const result = await rpc.things?.list?.(options2);
+          let rawItems = [];
+          let total = 0;
           if (Array.isArray(result)) {
-            return { data: result, total: result.length };
-          }
-          if (result) {
-            const items = result.data || result.items || result.result || [];
-            return { data: items, total: result.count ?? items.length };
+            rawItems = result;
+            total = result.length;
+          } else if (result) {
+            rawItems = result.data || result.items || result.result || [];
+            total = result.total ?? result.count ?? rawItems.length;
           }
-          return { data: [], total: 0 };
+          const normalizedItems = rawItems.map(
+            (item) => normalizeApiItem(item, ns)
+          );
+          return { data: normalizedItems, total };
         } catch (error) {
           console.error("[@mdxui/do] Failed to list things:", error);
           return { data: [], total: 0 };
@@ -81,22 +155,42 @@ function createCapnwebClient(baseUrl, options = {}) {
       },
       async get(params) {
         try {
-          const result = await rpc.get({ type: params.type, id: params.id });
-          return result;
+          const ns = params.ns ?? "default";
+          let result = await rpc.things?.get?.(params.id);
+          if (!result && params.type) {
+            result = await rpc.things?.get?.({
+              id: params.id,
+              type: params.type,
+              $type: params.type
+            });
+          }
+          if (result) {
+            return normalizeApiItem(result, ns);
+          }
+          return null;
         } catch {
           return null;
         }
       },
       async create(params) {
-        const result = await rpc.create({ type: params.type, data: params.data });
+        const payload = {
+          $type: params.type,
+          ...params.data
+        };
+        const result = await rpc.things?.create?.(payload);
         return result;
       },
       async update(params) {
-        const result = await rpc.update({ type: params.type, id: params.id, data: params.data });
+        const payload = {
+          $type: params.type,
+          id: params.id,
+          ...params.data
+        };
+        const result = await rpc.things?.update?.(params.id, payload);
         return result;
       },
       async delete(params) {
-        await rpc.delete({ type: params.type, id: params.id });
+        await rpc.things?.delete?.(params.id);
         return { success: true };
       },
       async versions(_params) {
@@ -106,7 +200,7 @@ function createCapnwebClient(baseUrl, options = {}) {
         try {
           const options2 = {};
           if (_params.type) options2.type = _params.type;
-          const result = await rpc.getStats(options2);
+          const result = await rpc.things?.stats?.(options2);
           return {
             total: result?.total ?? 0,
             byType: result?.byType ?? {}
@@ -115,209 +209,19 @@ function createCapnwebClient(baseUrl, options = {}) {
           console.error("[@mdxui/do] Failed to get stats:", error);
           return { total: 0, byType: {} };
         }
-      }
-    },
-    /**
-     * SQL operations (not supported by capnweb servers)
-     */
-    SQL: {
-      async execute(_params) {
-        throw new Error("SQL execution is not supported by this server");
-      }
-    },
-    // Required for interface compatibility
-    dup: () => createCapnwebClient(baseUrl, options),
-    onRpcBroken: (callback) => {
-      if ("onRpcBroken" in session && typeof session.onRpcBroken === "function") {
-        session.onRpcBroken(callback);
-      }
-    },
-    [Symbol.dispose]: () => {
-      if (Symbol.dispose in session) {
-        session[Symbol.dispose]();
-      }
-    }
-  };
-}
-function $CapnwebContext(url, options) {
-  return createCapnwebClient(url, options);
-}
-
-// src/lib/json-rpc-client.ts
-var endpointCache = /* @__PURE__ */ new Map();
-function createJsonRpcClient(baseUrl, options = {}) {
-  const rpcUrl = baseUrl.replace(/\/$/, "").replace(/\/rpc$/, "");
-  function getAuthHeaders() {
-    if (options.authToken) {
-      return { Authorization: `Bearer ${options.authToken}` };
-    }
-    return {};
-  }
-  async function rpcCall(method, args = []) {
-    const response = await fetch(`${rpcUrl}/rpc`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...getAuthHeaders()
       },
-      body: JSON.stringify({ method, args })
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (data.error) {
-      throw new Error(data.error.message || data.error.code);
-    }
-    return data.result;
-  }
-  async function restCall(path, init) {
-    const response = await fetch(`${rpcUrl}${path}`, {
-      ...init,
-      headers: {
-        "Content-Type": "application/json",
-        ...getAuthHeaders(),
-        ...init?.headers
-      }
-    });
-    if (!response.ok) {
-      const method = init?.method?.toUpperCase() ?? "GET";
-      if (response.status === 404 && method === "GET") {
-        return { data: [], count: 0 };
-      }
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return response.json();
-  }
-  return {
-    /**
-     * Namespace operations
-     */
-    Namespace: {
-      async list(_params) {
-        return [{ id: "default", name: "default" }];
-      }
-    },
-    /**
-     * Schema operations
-     */
-    Schema: {
-      async discover(_params) {
-        const schemas = await rpcCall("schemas.list", []);
+      /**
+       * Subscribe to real-time Thing updates
+       * @returns Subscription object with unsubscribe method
+       */
+      subscribe(_params, _callbacks) {
+        console.warn(
+          '[@mdxui/do] Thing.subscribe() requires WebSocket transport. Use transport: "ws" for real-time updates.'
+        );
         return {
-          namespaces: ["default"],
-          types: schemas,
-          schemas
-        };
-      },
-      async get(params) {
-        const result = await rpcCall("schemas.get", [params.type]);
-        return result;
-      }
-    },
-    /**
-     * Thing operations (maps to REST endpoints)
-     */
-    Thing: {
-      async types(params) {
-        try {
-          const schemas = await rpcCall("schemas.list", []);
-          let validEndpoints = endpointCache.get(rpcUrl);
-          if (!validEndpoints) {
-            validEndpoints = /* @__PURE__ */ new Set();
-            const probeResults = await Promise.all(
-              schemas.map(async (type) => {
-                const endpoint = getEndpointForType(type);
-                try {
-                  const response = await fetch(`${rpcUrl}${endpoint}`, { method: "HEAD" });
-                  return { type, exists: response.ok };
-                } catch {
-                  try {
-                    const response = await fetch(`${rpcUrl}${endpoint}?limit=0`);
-                    return { type, exists: response.ok };
-                  } catch {
-                    return { type, exists: false };
-                  }
-                }
-              })
-            );
-            for (const { type, exists } of probeResults) {
-              if (exists) {
-                validEndpoints.add(type);
-              }
-            }
-            endpointCache.set(rpcUrl, validEndpoints);
+          unsubscribe: () => {
           }
-          return Array.from(validEndpoints).map((name) => ({
-            name,
-            ns: params.ns || "default"
-          }));
-        } catch {
-          return ["Noun", "Verb", "Action", "Function"].map((name) => ({
-            name,
-            ns: params.ns || "default"
-          }));
-        }
-      },
-      async list(params) {
-        const endpoint = getEndpointForType(params.type || "Thing");
-        const response = await restCall(endpoint);
-        const items = response.data || response.items || response.result || [];
-        return {
-          data: items,
-          total: response.count ?? items.length
         };
-      },
-      async get(params) {
-        const endpoint = getEndpointForType(params.type);
-        const response = await restCall(`${endpoint}/${params.id}`);
-        return response.data;
-      },
-      async create(params) {
-        const endpoint = getEndpointForType(params.type);
-        const response = await restCall(endpoint, {
-          method: "POST",
-          body: JSON.stringify(params.data)
-        });
-        return response.data;
-      },
-      async update(params) {
-        const endpoint = getEndpointForType(params.type);
-        const response = await restCall(`${endpoint}/${params.id}`, {
-          method: "PUT",
-          body: JSON.stringify(params.data)
-        });
-        return response.data;
-      },
-      async delete(params) {
-        const endpoint = getEndpointForType(params.type);
-        await restCall(`${endpoint}/${params.id}`, { method: "DELETE" });
-        return { success: true };
-      },
-      async versions(_params) {
-        return [];
-      },
-      async stats(_params) {
-        let validEndpoints = endpointCache.get(rpcUrl);
-        if (!validEndpoints) {
-          await this.types({ ns: _params.ns });
-          validEndpoints = endpointCache.get(rpcUrl) || /* @__PURE__ */ new Set();
-        }
-        const types = Array.from(validEndpoints);
-        const results = await Promise.all(
-          types.map(async (type) => {
-            const endpoint = getEndpointForType(type);
-            const response = await restCall(endpoint).catch(() => ({ count: 0 }));
-            return { type, count: response.count || 0 };
-          })
-        );
-        const byType = {};
-        let total = 0;
-        for (const { type, count } of results) {
-          byType[type] = count;
-          total += count;
-        }
-        return { total, byType };
       }
     },
     /**
@@ -325,66 +229,47 @@ function createJsonRpcClient(baseUrl, options = {}) {
      */
     SQL: {
       async execute(params) {
-        const startTime = Date.now();
         try {
-          const result = await rpcCall("sql.execute", [params.query, params.params || []]);
+          const result = await rpc.sql?.execute?.(params.query, params.params);
           return {
-            rows: result.rows ?? [],
-            columns: result.columns ?? [],
-            rowsAffected: result.rowsAffected,
-            executionTimeMs: result.executionTimeMs ?? Date.now() - startTime
+            rows: result?.rows ?? [],
+            columns: result?.columns ?? [],
+            rowsAffected: result?.rowsAffected,
+            executionTimeMs: result?.executionTimeMs
           };
-        } catch (rpcError) {
-          const errorMessage = rpcError instanceof Error ? rpcError.message : String(rpcError);
-          const isNotSupported = errorMessage.includes("not found") || errorMessage.includes("not supported") || errorMessage.includes("unknown method");
-          try {
-            const response = await restCall("/sql", {
-              method: "POST",
-              body: JSON.stringify({ query: params.query, params: params.params })
-            });
-            return {
-              rows: response.rows ?? [],
-              columns: response.columns ?? [],
-              rowsAffected: response.rowsAffected,
-              executionTimeMs: Date.now() - startTime
-            };
-          } catch (restError) {
-            if (isNotSupported) {
-              throw new Error(
-                "SQL execution is not supported by this server. The server does not expose sql.execute RPC method or /sql REST endpoint."
-              );
-            }
-            throw restError;
-          }
+        } catch {
+          throw new Error("SQL execution is not supported by this server");
         }
       }
     },
-    // Required for interface compatibility
-    dup: () => createJsonRpcClient(baseUrl, options),
+    /**
+     * Create a duplicate client instance
+     */
+    dup: () => createDOClient(baseUrl, options),
+    /**
+     * Register callback for RPC connection errors
+     */
     onRpcBroken: (_callback) => {
     },
+    /**
+     * Cleanup/dispose the client
+     */
     [Symbol.dispose]: () => {
-    }
-  };
-}
-function getEndpointForType(type) {
-  const typeMap = {
-    Noun: "/nouns",
-    Verb: "/verbs",
-    Action: "/actions",
-    Function: "/functions",
-    Event: "/events",
-    Relationship: "/relationships",
-    Thing: "/things",
-    Workflow: "/workflows"
+      if (rpc.close && typeof rpc.close === "function") {
+        rpc.close();
+      }
+    },
+    /**
+     * Raw SDK access for advanced usage
+     */
+    $rpc: rpc
   };
-  return typeMap[type] || `/${type}`;
 }
-function $JsonRpcContext(url, options) {
-  return createJsonRpcClient(url, options);
+function $DOContext(url, options) {
+  return createDOClient(url, options);
 }
 
-// src/lib/mock-data.ts
+// src/client/mock-data.ts
 var idCounter = 0;
 function generateId(prefix = "mock") {
   return `${prefix}_${Date.now().toString(36)}_${(++idCounter).toString(36)}`;
@@ -682,7 +567,7 @@ function generateInitialMockData() {
   ];
 }
 
-// src/lib/mock-client.ts
+// src/client/mock-client.ts
 function thingKey(ns, type, id) {
   return `${ns}:${type}:${id}`;
 }
@@ -956,15 +841,7 @@ function $MockContext(options) {
   return createMockClient(options);
 }
 
-// src/lib/url-utils.ts
-function deriveRpcUrl(url) {
-  let rpcUrl = url.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
-  rpcUrl = rpcUrl.replace(/\/(sync|rpc)$/, "");
-  rpcUrl = rpcUrl.replace(/\/$/, "");
-  return `${rpcUrl}/rpc`;
-}
-
-// src/lib/fetch-with-timeout.ts
+// src/client/fetch.ts
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
 async function fetchWithTimeout(url, options = {}) {
   const { timeout = DEFAULT_REQUEST_TIMEOUT, signal: existingSignal, ...fetchOptions } = options;
@@ -995,77 +872,7 @@ async function fetchWithTimeout(url, options = {}) {
 function createFetchWithTimeout(defaultTimeout) {
   return (url, options = {}) => fetchWithTimeout(url, { timeout: defaultTimeout, ...options });
 }
-function useHealthCheck(config) {
-  const [isConnected, setIsConnected] = useState(false);
-  const [connectionError, setConnectionError] = useState();
-  const [isChecking, setIsChecking] = useState(true);
-  const { apiEndpoint, authToken, requestTimeout, healthCheckRetries = 3 } = config;
-  const abortControllerRef = useRef(null);
-  const performHealthCheck = useCallback(async () => {
-    const response = await fetchWithTimeout(apiEndpoint, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
-      },
-      timeout: requestTimeout ?? DEFAULT_REQUEST_TIMEOUT
-    });
-    if (!response.ok) {
-      throw new Error(`Health check failed: ${response.status}`);
-    }
-  }, [apiEndpoint, authToken, requestTimeout]);
-  const checkConnection = useCallback(async () => {
-    setIsChecking(true);
-    try {
-      await retryWithBackoff(performHealthCheck, {
-        maxRetries: healthCheckRetries,
-        backoffMultiplier: 1e3
-      });
-      setIsConnected(true);
-      setConnectionError(void 0);
-    } catch (error) {
-      setIsConnected(false);
-      setConnectionError(error instanceof Error ? error : new Error("Connection failed"));
-    } finally {
-      setIsChecking(false);
-    }
-  }, [performHealthCheck, healthCheckRetries]);
-  useEffect(() => {
-    abortControllerRef.current = new AbortController();
-    const { signal } = abortControllerRef.current;
-    async function runCheck() {
-      try {
-        await retryWithBackoff(performHealthCheck, {
-          maxRetries: healthCheckRetries,
-          backoffMultiplier: 1e3,
-          signal
-        });
-        if (!signal.aborted) {
-          setIsConnected(true);
-          setConnectionError(void 0);
-          setIsChecking(false);
-        }
-      } catch (error) {
-        if (!signal.aborted) {
-          setIsConnected(false);
-          setConnectionError(error instanceof Error ? error : new Error("Connection failed"));
-          setIsChecking(false);
-        }
-      }
-    }
-    runCheck();
-    return () => {
-      abortControllerRef.current?.abort();
-    };
-  }, [performHealthCheck, healthCheckRetries]);
-  return {
-    isConnected,
-    connectionError,
-    checkConnection,
-    isChecking
-  };
-}
 
-export { $CapnwebContext, $JsonRpcContext, $MockContext, DEFAULT_REQUEST_TIMEOUT, MOCK_TYPES, createCapnwebClient, createFetchWithTimeout, createJsonRpcClient, createMockClient, deriveRpcUrl, fetchWithTimeout, generateInitialMockData, generateMockSchema, generateMockThing, generateMockThings, useHealthCheck };
-//# sourceMappingURL=chunk-OVLO7UOH.js.map
-//# sourceMappingURL=chunk-OVLO7UOH.js.map
+export { $DOContext, $MockContext, DEFAULT_REQUEST_TIMEOUT, MOCK_TYPES, createDOClient, createFetchWithTimeout, createMockClient, fetchWithTimeout, generateInitialMockData, generateMockSchema, generateMockThing, generateMockThings };
+//# sourceMappingURL=chunk-KLN5OTQH.js.map
+//# sourceMappingURL=chunk-KLN5OTQH.js.map