@synap-core/client 0.1.0

package/dist/index.js

@@ -0,0 +1,18 @@
+// src/index.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+function createSynapClient(config) {
+  return createTRPCClient({
+    links: [
+      httpBatchLink({
+        url: `${config.url}/trpc`,
+        headers: config.headers,
+        fetch: config.fetch
+      })
+    ]
+  });
+}
+var index_default = createSynapClient;
+export {
+  createSynapClient,
+  index_default as default
+};

package/dist/react/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @synap/client React Hooks
+ *
+ * Reusable React hooks for any frontend using Synap Data Pod
+ */
+export { useEntities, useEntity, useEntitySearch, useCreateEntity, useUpdateEntity, useDeleteEntity } from './useEntities.js';
+export { useThreads, useThread, useBranches, useSendMessage, useCreateBranch } from './useThreads.js';
+export { useEvents, useAggregateEvents } from './useEvents.js';
+export { SynapProvider, useSynapClient, useSynap } from './provider.js';

package/dist/react/provider.cjs

@@ -0,0 +1,94 @@
+"use strict";
+"use client";
+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/react/provider.tsx
+var provider_exports = {};
+__export(provider_exports, {
+  SynapProvider: () => SynapProvider,
+  trpc: () => trpc,
+  useSynap: () => useSynap,
+  useSynapClient: () => useSynapClient
+});
+module.exports = __toCommonJS(provider_exports);
+var import_react = require("react");
+var import_react_query = require("@tanstack/react-query");
+var import_react_query2 = require("@trpc/react-query");
+var import_jsx_runtime = require("react/jsx-runtime");
+var trpc = (0, import_react_query2.createTRPCReact)();
+var SynapContext = (0, import_react.createContext)(null);
+function SynapProvider({ url = "http://localhost:3000", getToken, headers, children }) {
+  const queryClient = (0, import_react.useMemo)(() => new import_react_query.QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 5 * 60 * 1e3,
+        // 5 minutes
+        retry: 1
+      }
+    }
+  }), []);
+  const trpcClient = (0, import_react.useMemo)(() => trpc.createClient({
+    links: [
+      (0, import_react_query2.httpBatchLink)({
+        url: `${url}/trpc`,
+        async headers() {
+          const baseHeaders = {
+            ...headers
+          };
+          if (getToken) {
+            const token = await getToken();
+            if (token) {
+              baseHeaders["Authorization"] = `Bearer ${token}`;
+            }
+          }
+          return baseHeaders;
+        },
+        fetch(url2, options) {
+          return fetch(url2, {
+            ...options,
+            credentials: "include"
+            // Send cookies
+          });
+        }
+      })
+    ]
+  }), [url, getToken, headers]);
+  const contextValue = (0, import_react.useMemo)(() => ({
+    api: trpc,
+    url
+  }), [url]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SynapContext.Provider, { value: contextValue, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(trpc.Provider, { client: trpcClient, queryClient, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_query.QueryClientProvider, { client: queryClient, children }) }) });
+}
+function useSynap() {
+  const context = (0, import_react.useContext)(SynapContext);
+  if (!context) {
+    throw new Error("useSynap must be used within a SynapProvider");
+  }
+  return context;
+}
+function useSynapClient() {
+  return useSynap().api;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SynapProvider,
+  trpc,
+  useSynap,
+  useSynapClient
+});

package/dist/react/provider.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Synap Provider
+ *
+ * React context provider for Synap Client SDK
+ * Wraps tRPC and QueryClient, provides hooks access
+ */
+import { type ReactNode } from 'react';
+import type { AppRouter } from '../types.js';
+import { type CreateTRPCReact } from '@trpc/react-query';
+declare const trpc: CreateTRPCReact<AppRouter, unknown>;
+export interface SynapProviderConfig {
+    /**
+     * Data Pod URL
+     * @default 'http://localhost:3000'
+     */
+    url?: string;
+    /**
+     * Token getter for authentication
+     */
+    getToken?: () => Promise<string | null> | string | null;
+    /**
+     * Additional headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Children to wrap
+     */
+    children: ReactNode;
+}
+interface SynapContextValue {
+    api: typeof trpc;
+    url: string;
+}
+/**
+ * Synap Provider Component
+ *
+ * Wraps your app with tRPC and React Query providers
+ *
+ * @example
+ * ```tsx
+ * <SynapProvider url="http://localhost:3000">
+ *   <App />
+ * </SynapProvider>
+ * ```
+ */
+export declare function SynapProvider({ url, getToken, headers, children }: SynapProviderConfig): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access Synap context
+ * Must be used within SynapProvider
+ */
+export declare function useSynap(): SynapContextValue;
+/**
+ * Hook to access the Synap tRPC client
+ * Must be used within SynapProvider
+ */
+export declare function useSynapClient(): any;
+export { trpc };

package/dist/react/provider.js

@@ -0,0 +1,67 @@
+"use client";
+
+// src/react/provider.tsx
+import { createContext, useContext, useMemo } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createTRPCReact, httpBatchLink } from "@trpc/react-query";
+import { jsx } from "react/jsx-runtime";
+var trpc = createTRPCReact();
+var SynapContext = createContext(null);
+function SynapProvider({ url = "http://localhost:3000", getToken, headers, children }) {
+  const queryClient = useMemo(() => new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 5 * 60 * 1e3,
+        // 5 minutes
+        retry: 1
+      }
+    }
+  }), []);
+  const trpcClient = useMemo(() => trpc.createClient({
+    links: [
+      httpBatchLink({
+        url: `${url}/trpc`,
+        async headers() {
+          const baseHeaders = {
+            ...headers
+          };
+          if (getToken) {
+            const token = await getToken();
+            if (token) {
+              baseHeaders["Authorization"] = `Bearer ${token}`;
+            }
+          }
+          return baseHeaders;
+        },
+        fetch(url2, options) {
+          return fetch(url2, {
+            ...options,
+            credentials: "include"
+            // Send cookies
+          });
+        }
+      })
+    ]
+  }), [url, getToken, headers]);
+  const contextValue = useMemo(() => ({
+    api: trpc,
+    url
+  }), [url]);
+  return /* @__PURE__ */ jsx(SynapContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(trpc.Provider, { client: trpcClient, queryClient, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children }) }) });
+}
+function useSynap() {
+  const context = useContext(SynapContext);
+  if (!context) {
+    throw new Error("useSynap must be used within a SynapProvider");
+  }
+  return context;
+}
+function useSynapClient() {
+  return useSynap().api;
+}
+export {
+  SynapProvider,
+  trpc,
+  useSynap,
+  useSynapClient
+};

package/dist/react/useEntities.d.ts

@@ -0,0 +1,34 @@
+/**
+ * useEntities Hook
+ *
+ * Fetches entities from Data Pod via tRPC
+ */
+export interface UseEntitiesOptions {
+    type?: 'task' | 'contact' | 'meeting' | 'idea' | 'note' | 'project';
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Fetch user's entities
+ */
+export declare function useEntities(options?: UseEntitiesOptions): any;
+/**
+ * Fetch single entity by ID
+ */
+export declare function useEntity(id: string): any;
+/**
+ * Search entities by text
+ */
+export declare function useEntitySearch(query: string, options?: Omit<UseEntitiesOptions, 'offset'>): any;
+/**
+ * Create entity mutation
+ */
+export declare function useCreateEntity(): any;
+/**
+ * Update entity mutation
+ */
+export declare function useUpdateEntity(): any;
+/**
+ * Delete entity mutation
+ */
+export declare function useDeleteEntity(): any;

package/dist/react/useEvents.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useEvents Hook
+ *
+ * Fetches events from Data Pod via tRPC
+ */
+export interface UseEventsOptions {
+    days?: number;
+    limit?: number;
+    eventTypes?: string[];
+}
+/**
+ * Fetch user's event stream
+ */
+export declare function useEvents(options?: UseEventsOptions): any;
+/**
+ * Fetch events for specific aggregate
+ */
+export declare function useAggregateEvents(_aggregateId: string, _options?: {
+    fromVersion?: number;
+    toVersion?: number;
+}): any;

package/dist/react/useThreads.d.ts

@@ -0,0 +1,27 @@
+/**
+ * useThreads Hook
+ *
+ * Fetches chat threads from Data Pod via tRPC
+ *
+ * DISABLED - chat router not implemented in @synap/api yet
+ */
+/**
+ * Fetch user's chat threads
+ */
+export declare function useThreads(_limit?: number): any;
+/**
+ * Fetch single thread with messages
+ */
+export declare function useThread(_threadId: string, _limit?: number): any;
+/**
+ * Get branches from a message
+ */
+export declare function useBranches(_parentId: string): any;
+/**
+ * Send chat message mutation
+ */
+export declare function useSendMessage(): any;
+/**
+ * Create branch mutation
+ */
+export declare function useCreateBranch(): any;

package/dist/react.cjs

@@ -0,0 +1,38 @@
+"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/react.ts
+var react_exports = {};
+__export(react_exports, {
+  SynapQueryClientProvider: () => import_react_query2.QueryClientProvider,
+  createSynapReact: () => createSynapReact,
+  default: () => react_default
+});
+module.exports = __toCommonJS(react_exports);
+var import_react_query = require("@trpc/react-query");
+var import_react_query2 = require("@tanstack/react-query");
+function createSynapReact() {
+  return (0, import_react_query.createTRPCReact)();
+}
+var react_default = createSynapReact;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SynapQueryClientProvider,
+  createSynapReact
+});

package/dist/react.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @synap/client/react - React Query hooks for Synap
+ *
+ * Provides tRPC React Query hooks with full type safety.
+ * Auto-syncs with API changes via AppRouter type.
+ *
+ * @example
+ * ```typescript
+ * import { createSynapReact, SynapProvider } from '@synap/client/react';
+ *
+ * // Create hooks
+ * export const api = createSynapReact();
+ *
+ * // In your app
+ * function App() {
+ *   return (
+ *     <SynapProvider client={trpcClient} queryClient={queryClient}>
+ *       <MyComponent />
+ *     </SynapProvider>
+ *   );
+ * }
+ *
+ * // In components
+ * function MyComponent() {
+ *   const { data } = api.entities.list.useQuery({ limit: 20 });
+ *   const createTag = api.tags.create.useMutation();
+ *
+ *   return <div>{data?.entities.map(...)}</div>;
+ * }
+ * ```
+ */
+import { createTRPCReact } from '@trpc/react-query';
+import type { AppRouter } from '@synap/api';
+/**
+ * Create tRPC React hooks for Synap API
+ *
+ * This provides fully typed React Query hooks that auto-sync
+ * with the API's AppRouter type.
+ *
+ * @example
+ * ```typescript
+ * // Create once in your app
+ * export const api = createSynapReact();
+ *
+ * // Use in components
+ * function NotesScreen() {
+ *   const { data, isLoading } = api.entities.list.useQuery({
+ *     type: 'note',
+ *     limit: 50
+ *   });
+ *
+ *   const createEntity = api.entities.create.useMutation({
+ *     onSuccess: () => {
+ *       // Invalidate cache
+ *       api.useContext().entities.list.invalidate();
+ *     },
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {data?.entities.map(entity => (
+ *         <div key={entity.id}>{entity.title}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function createSynapReact(): ReturnType<typeof createTRPCReact<AppRouter>>;
+/**
+ * Type alias for the Synap tRPC React context
+ */
+export type SynapReactContext = ReturnType<typeof createSynapReact>;
+export { QueryClientProvider as SynapQueryClientProvider } from '@tanstack/react-query';
+export type { AppRouter } from '@synap/api';
+export default createSynapReact;

package/dist/react.js

@@ -0,0 +1,12 @@
+// src/react.ts
+import { createTRPCReact } from "@trpc/react-query";
+import { QueryClientProvider } from "@tanstack/react-query";
+function createSynapReact() {
+  return createTRPCReact();
+}
+var react_default = createSynapReact;
+export {
+  QueryClientProvider as SynapQueryClientProvider,
+  createSynapReact,
+  react_default as default
+};

package/dist/realtime.cjs

@@ -0,0 +1,117 @@
+"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/realtime.ts
+var realtime_exports = {};
+__export(realtime_exports, {
+  SynapRealtimeClient: () => SynapRealtimeClient
+});
+module.exports = __toCommonJS(realtime_exports);
+var SynapRealtimeClient = class {
+  ws = null;
+  config;
+  reconnectAttempts = 0;
+  maxReconnectAttempts;
+  reconnectDelay;
+  reconnectTimer = null;
+  isIntentionallyDisconnected = false;
+  constructor(config) {
+    this.config = config;
+    this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
+    this.reconnectDelay = config.reconnectDelay ?? 1e3;
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  connect() {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      return;
+    }
+    this.isIntentionallyDisconnected = false;
+    const wsUrl = this.config.url;
+    try {
+      this.ws = new WebSocket(wsUrl);
+      this.ws.onopen = () => {
+        this.reconnectAttempts = 0;
+        this.config.onConnect?.();
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.config.onMessage?.(message);
+        } catch (error) {
+          console.error("Failed to parse WebSocket message:", error);
+          this.config.onError?.(
+            new Error(`Failed to parse message: ${error instanceof Error ? error.message : String(error)}`)
+          );
+        }
+      };
+      this.ws.onerror = () => {
+        this.config.onError?.(new Error("WebSocket error"));
+      };
+      this.ws.onclose = () => {
+        this.config.onDisconnect?.();
+        if (!this.isIntentionallyDisconnected) {
+          this.attemptReconnect();
+        }
+      };
+    } catch (error) {
+      this.config.onError?.(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.isIntentionallyDisconnected = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Check if currently connected
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.config.onError?.(
+        new Error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`)
+      );
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * this.reconnectAttempts;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SynapRealtimeClient
+});

package/dist/realtime.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Real-time Client - WebSocket connection for live updates
+ *
+ * Connects to the Synap real-time notification system (Cloudflare Durable Objects)
+ * to receive live updates about async operations.
+ */
+/**
+ * NotificationMessage type definition
+ *
+ * Matches the type from @synap/realtime but defined here to avoid dependency.
+ */
+export interface NotificationMessage {
+    type: string;
+    data: Record<string, unknown>;
+    requestId?: string;
+    timestamp?: string;
+    status?: 'success' | 'error' | 'pending';
+}
+export interface RealtimeConfig {
+    /** WebSocket URL (e.g., 'wss://realtime.synap.app/rooms/user_123/subscribe') */
+    url: string;
+    /** User ID for the connection */
+    userId: string;
+    /** Callback when a message is received */
+    onMessage?: (message: NotificationMessage) => void;
+    /** Callback when an error occurs */
+    onError?: (error: Error) => void;
+    /** Callback when connection is established */
+    onConnect?: () => void;
+    /** Callback when connection is closed */
+    onDisconnect?: () => void;
+    /** Maximum number of reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Reconnection delay in milliseconds (default: 1000) */
+    reconnectDelay?: number;
+}
+/**
+ * Real-time WebSocket Client
+ *
+ * Connects to the Synap real-time notification system to receive live updates.
+ *
+ * @example
+ * ```typescript
+ * const realtime = new SynapRealtimeClient({
+ *   url: 'wss://realtime.synap.app/rooms/user_123/subscribe',
+ *   userId: 'user-123',
+ *   onMessage: (message) => {
+ *     console.log('Received:', message);
+ *     if (message.type === 'note.creation.completed') {
+ *       // Refresh notes list
+ *     }
+ *   },
+ * });
+ *
+ * realtime.connect();
+ * ```
+ */
+export declare class SynapRealtimeClient {
+    private ws;
+    private config;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private reconnectTimer;
+    private isIntentionallyDisconnected;
+    constructor(config: RealtimeConfig);
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): void;
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Check if currently connected
+     */
+    isConnected(): boolean;
+    private attemptReconnect;
+}