@eidos.space/client 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mayneyao
+
+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/README.md

@@ -0,0 +1,121 @@
+# @eidos.space/client
+
+Eidos RPC client for Node.js and browser environments. Connect to a headless Eidos server via HTTP and interact with your data using a Prisma-style API.
+
+## Installation
+
+```bash
+npm install @eidos.space/client @eidos.space/core
+```
+
+## Basic Usage
+
+```typescript
+import { createEidosClient } from "@eidos.space/client"
+
+const client = createEidosClient({
+  endpoint: "http://localhost:3000/rpc",
+})
+
+// Query table data
+const posts = await client.currentSpace.table("posts").findMany({
+  where: { published: true },
+  take: 10,
+})
+
+// Get graft sync status
+const status = await client.currentSpace.graft.status()
+```
+
+## Integration with React
+
+To use the client in a React application, we recommend using `@eidos.space/react` which provides hooks and state management for the Eidos SDK.
+
+### 1. Installation
+
+```bash
+npm install @eidos.space/client @eidos.space/react
+```
+
+### 2. Setup
+
+Initialize the client and set it to the Eidos store. You can do this at the root of your application.
+
+```tsx
+import { useEffect } from "react"
+import { createEidosClient } from "@eidos.space/client"
+import { createEidos, useEidosStore } from "@eidos.space/react"
+
+function App() {
+  const { setEidos } = useEidosStore()
+
+  useEffect(() => {
+    // 1. Create the RPC client
+    const client = createEidosClient({
+      endpoint: "http://localhost:3000/rpc",
+    })
+
+    // 2. Wrap it with Eidos SDK interface
+    // createEidos adds helper methods like AI and utils
+    const eidos = createEidos(client.currentSpace)
+
+    // 3. Set to global store
+    setEidos(eidos)
+  }, [setEidos])
+
+  return (
+    <div className="App">
+      <BlogPostList />
+    </div>
+  )
+}
+```
+
+### 3. Usage in Components
+
+Now you can use the `useEidos` hook in any component to access your data.
+
+```tsx
+import { useEidos } from "@eidos.space/react"
+import { useQuery } from "@tanstack/react-query"
+
+export function BlogPostList() {
+  const eidos = useEidos()
+
+  // Example with TanStack Query
+  const { data: posts, isLoading } = useQuery({
+    queryKey: ["posts"],
+    queryFn: () =>
+      eidos.currentSpace.table("posts").findMany({
+        orderBy: { created_at: "desc" },
+      }),
+  })
+
+  if (isLoading) return <div>Loading...</div>
+
+  return (
+    <ul>
+      {posts?.map((post) => (
+        <li key={post._id}>{post.name}</li>
+      ))}
+    </ul>
+  )
+}
+```
+
+## Configuration
+
+The `createEidosClient` function accepts a configuration object:
+
+| Option     | Type           | Description                                              |
+| ---------- | -------------- | -------------------------------------------------------- |
+| `endpoint` | `string`       | The RPC endpoint URL (e.g., `http://localhost:3000/rpc`) |
+| `timeout`  | `number`       | Request timeout in milliseconds (default: 30000)         |
+| `fetch`    | `typeof fetch` | Custom fetch implementation (optional)                   |
+
+## Features
+
+- **Prisma-style API**: Type-safe (when used with generated types) and intuitive CRUD operations.
+- **Isomorphic**: Works in Node.js, browsers, and Edge functions.
+- **Minimal Footprint**: Lightweight proxy-based implementation.
+- **Deep Integration**: First-class support for Eidos features like Graft sync, Files, and KV storage.

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { DataSpace, DataSpace as DataSpace$1 } from "@eidos.space/core";
+
+//#region src/types.d.ts
+
+/**
+ * Eidos client interface
+ */
+interface EidosClient {
+  /**
+   * The current data space
+   */
+  currentSpace: DataSpace$1;
+  /**
+   * Alias for currentSpace
+   */
+  space: DataSpace$1;
+}
+/**
+ * Client configuration
+ */
+interface EidosClientConfig {
+  /** RPC endpoint URL */
+  endpoint: string;
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+  /** Custom fetch function */
+  fetch?: typeof fetch;
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/transport.d.ts
+/**
+ * HTTP Transport for Eidos RPC client
+ * Extracted and adapted from packages/sandbox/src/sdk-inject-script.html
+ */
+interface TransportConfig {
+  endpoint: string;
+  timeout?: number;
+  fetch?: typeof fetch;
+}
+interface TransportPort {
+  onmessage: ((event: {
+    data: any;
+  }) => void) | null;
+  close: () => void;
+}
+/**
+ * Create HTTP transport for RPC calls
+ */
+declare function createHttpTransport(config: TransportConfig): {
+  send: (requestData: any) => Promise<TransportPort>;
+  close: () => void;
+};
+/**
+ * Wait for callback from transport port
+ */
+declare function onCallBack(port: TransportPort): Promise<any>;
+//# sourceMappingURL=transport.d.ts.map
+//#endregion
+//#region src/space-proxy.d.ts
+/**
+ * Create space proxy with Prisma-style API
+ */
+declare function createSpaceProxy(config: TransportConfig): {};
+//# sourceMappingURL=space-proxy.d.ts.map
+
+//#endregion
+//#region src/index.d.ts
+/**
+ * Create an Eidos client for connecting to headless server
+ */
+declare function createEidosClient(config: EidosClientConfig): EidosClient;
+//#endregion
+export { DataSpace, EidosClient, EidosClientConfig, TransportConfig, TransportPort, createEidosClient, createHttpTransport, createSpaceProxy, onCallBack };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/transport.ts","../src/space-proxy.ts","../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAA4B,UAAX,WAAA,CAAW;EAAA;;AAQV;EAMD,YAAA,EAVD,WAUkB;;;;ECdjB,KAAA,EDQR,WCRQ;AAMjB;AAQA;;;AAK4C,UDL3B,iBAAA,CCK2B;EAAa;EAAd,QAAA,EAAA,MAAA;EAwD3B;EAAU,OAAA,CAAA,EAAA,MAAA;EAAA;EAAoB,KAAG,CAAA,EAAA,ODvDhC,KCuDgC;AAAO;;;;;;;AD3ExD;AAA4B,UCAX,eAAA,CDAW;EAAA,QAIZ,EAAA,MAAA;EAAS,OAIhB,CAAA,EAAA,MAAA;EAAS,KAAA,CAAA,EAAA,OCLD,KDKC;AAMlB;UCRiB,aAAA;;;EANA,CAAA,EAAA,GAAA,IAAA,CAAA,GAAA,IAAe;EAMf,KAAA,EAAA,GAAA,GAAA,IAAa;AAQ9B;;;;AAKoC,iBALpB,mBAAA,CAKoB,MAAA,EALQ,eAKR,CAAA,EAAA;EAAO,IAAA,EAAA,CAAA,WAAA,EAAA,GAAA,EAAA,GAAP,OAAO,CAAC,aAAD,CAAA;EAwD3B,KAAA,EAAA,GAAA,GAAU,IAAA;CAAA;;;AAA8B;iBAAxC,UAAA,OAAiB,gBAAgB;;;;;ADnE/B;AAMlB;iBERgB,gBAAA,SAAyB;;;;;;;;AAAzB,iBCqBA,iBAAA,CDrByB,MAAe,ECqBd,iBDrBc,CAAA,ECqBM,WDrBN"}

package/dist/index.js

@@ -0,0 +1,145 @@
+//#region src/transport.ts
+/**
+* Create HTTP transport for RPC calls
+*/
+function createHttpTransport(config) {
+	const { endpoint, timeout = 3e4 } = config;
+	const fetchFn = config.fetch || globalThis.fetch;
+	return {
+		send: async (requestData) => {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeout);
+			try {
+				const response = await fetchFn(endpoint, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify(requestData),
+					signal: controller.signal
+				});
+				clearTimeout(timeoutId);
+				if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
+				const jsonData = await response.json();
+				if (!jsonData.success) throw new Error(jsonData.error || "RPC call failed");
+				const responseData = jsonData.data;
+				const simulatedPort = {
+					onmessage: null,
+					close: () => {}
+				};
+				setTimeout(() => {
+					if (simulatedPort.onmessage) simulatedPort.onmessage({ data: {
+						type: "rpcCallResp",
+						data: responseData
+					} });
+				}, 0);
+				return simulatedPort;
+			} catch (error) {
+				clearTimeout(timeoutId);
+				throw error;
+			}
+		},
+		close: () => {}
+	};
+}
+/**
+* Wait for callback from transport port
+*/
+function onCallBack(port) {
+	return new Promise((resolve, reject) => {
+		port.onmessage = (event) => {
+			port.close();
+			const { type, data } = event.data;
+			if (type === "rpcCallResp") resolve(data);
+			else reject(/* @__PURE__ */ new Error("RPC call failed"));
+		};
+	});
+}
+
+//#endregion
+//#region src/space-proxy.ts
+/**
+* Create space proxy with Prisma-style API
+*/
+function createSpaceProxy(config) {
+	const transport = createHttpTransport(config);
+	return new Proxy({}, { get: (target, method) => {
+		if (method === "table") return function(tableId) {
+			const tableMethods = [
+				"create",
+				"createMany",
+				"findUnique",
+				"findFirst",
+				"findMany",
+				"count",
+				"update",
+				"updateMany",
+				"delete",
+				"deleteMany"
+			];
+			return new Proxy({}, { get(target$1, tableMethod) {
+				if (tableMethods.includes(tableMethod)) return async function(args) {
+					const port = await transport.send({
+						method: `table(${tableId}).${tableMethod}`,
+						params: [args]
+					});
+					return onCallBack(port);
+				};
+				return void 0;
+			} });
+		};
+		const namespaces = [
+			"doc",
+			"action",
+			"graft",
+			"script",
+			"extension",
+			"tree",
+			"view",
+			"column",
+			"embedding",
+			"file",
+			"extNode",
+			"theme",
+			"dataView",
+			"kv",
+			"fs"
+		];
+		if (namespaces.includes(method)) return new Proxy({}, { get(target$1, subMethod) {
+			return async function(...params) {
+				const port = await transport.send({
+					method: `${method}.${subMethod}`,
+					params
+				});
+				return onCallBack(port);
+			};
+		} });
+		return async (...params) => {
+			const port = await transport.send({
+				method,
+				params
+			});
+			return onCallBack(port);
+		};
+	} });
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Create an Eidos client for connecting to headless server
+*/
+function createEidosClient(config) {
+	const { endpoint, timeout, fetch: fetchFn } = config;
+	const spaceProxy = createSpaceProxy({
+		endpoint,
+		timeout,
+		fetch: fetchFn
+	});
+	return {
+		currentSpace: spaceProxy,
+		space: spaceProxy
+	};
+}
+
+//#endregion
+export { createEidosClient, createHttpTransport, createSpaceProxy, onCallBack };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["config: TransportConfig","requestData: any","simulatedPort: TransportPort","port: TransportPort","config: TransportConfig","method: string","tableId: string","target","tableMethod: string","args?: any","subMethod: string","config: EidosClientConfig"],"sources":["../src/transport.ts","../src/space-proxy.ts","../src/index.ts"],"sourcesContent":["/**\n * HTTP Transport for Eidos RPC client\n * Extracted and adapted from packages/sandbox/src/sdk-inject-script.html\n */\n\nexport interface TransportConfig {\n  endpoint: string\n  timeout?: number\n  fetch?: typeof fetch\n}\n\nexport interface TransportPort {\n  onmessage: ((event: { data: any }) => void) | null\n  close: () => void\n}\n\n/**\n * Create HTTP transport for RPC calls\n */\nexport function createHttpTransport(config: TransportConfig) {\n  const { endpoint, timeout = 30000 } = config\n  const fetchFn = config.fetch || globalThis.fetch\n  \n  return {\n    send: async (requestData: any): Promise<TransportPort> => {\n      const controller = new AbortController()\n      const timeoutId = setTimeout(() => controller.abort(), timeout)\n      \n      try {\n        const response = await fetchFn(endpoint, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n          },\n          body: JSON.stringify(requestData),\n          signal: controller.signal,\n        })\n        \n        clearTimeout(timeoutId)\n        \n        if (!response.ok) {\n          throw new Error(`HTTP error: ${response.status}`)\n        }\n        \n        const jsonData = await response.json()\n        \n        if (!jsonData.success) {\n          throw new Error(jsonData.error || 'RPC call failed')\n        }\n        \n        const responseData = jsonData.data\n        \n        // Create simulated port for callback compatibility\n        const simulatedPort: TransportPort = {\n          onmessage: null,\n          close: () => {},\n        }\n        \n        // Async callback\n        setTimeout(() => {\n          if (simulatedPort.onmessage) {\n            simulatedPort.onmessage({\n              data: { type: 'rpcCallResp', data: responseData },\n            })\n          }\n        }, 0)\n        \n        return simulatedPort\n      } catch (error) {\n        clearTimeout(timeoutId)\n        throw error\n      }\n    },\n    close: () => {},\n  }\n}\n\n/**\n * Wait for callback from transport port\n */\nexport function onCallBack(port: TransportPort): Promise<any> {\n  return new Promise((resolve, reject) => {\n    port.onmessage = (event) => {\n      port.close()\n      const { type, data } = event.data\n      if (type === 'rpcCallResp') {\n        resolve(data)\n      } else {\n        reject(new Error('RPC call failed'))\n      }\n    }\n  })\n}\n","/**\n * Space Proxy for Eidos RPC client\n * Creates a Proxy-based interface for calling RPC methods\n * Extracted and adapted from packages/sandbox/src/sdk-inject-script.html\n */\n\nimport { createHttpTransport, onCallBack, TransportConfig } from './transport'\n\n/**\n * Create space proxy with Prisma-style API\n */\nexport function createSpaceProxy(config: TransportConfig) {\n  const transport = createHttpTransport(config)\n  \n  return new Proxy({}, {\n    get: (target, method: string) => {\n      // Prisma-style table() API\n      if (method === 'table') {\n        return function(tableId: string) {\n          const tableMethods = [\n            'create',\n            'createMany', \n            'findUnique',\n            'findFirst',\n            'findMany',\n            'count',\n            'update',\n            'updateMany',\n            'delete',\n            'deleteMany',\n          ]\n          \n          return new Proxy({}, {\n            get(target, tableMethod: string) {\n              if (tableMethods.includes(tableMethod)) {\n                return async function(args?: any) {\n                  const port = await transport.send({\n                    method: `table(${tableId}).${tableMethod}`,\n                    params: [args],\n                  })\n                  return onCallBack(port)\n                }\n              }\n              return undefined\n            },\n          })\n        }\n      }\n      \n      // Namespace APIs: doc, tree, file, kv, fs, etc.\n      const namespaces = [\n        'doc',\n        'action', \n        'graft',\n        'script',\n        'extension',\n        'tree',\n        'view',\n        'column',\n        'embedding',\n        'file',\n        'extNode',\n        'theme',\n        'dataView',\n        'kv',\n        'fs',\n      ]\n      \n      if (namespaces.includes(method)) {\n        return new Proxy({}, {\n          get(target, subMethod: string) {\n            return async function(...params: any[]) {\n              const port = await transport.send({\n                method: `${method}.${subMethod}`,\n                params,\n              })\n              return onCallBack(port)\n            }\n          },\n        })\n      }\n      \n      // Direct method call\n      return async (...params: any[]) => {\n        const port = await transport.send({\n          method,\n          params,\n        })\n        return onCallBack(port)\n      }\n    },\n  })\n}\n","/**\n * @eidos.space/client\n * \n * Eidos RPC client for Node.js and browser environments.\n * Connect to a headless Eidos server via HTTP.\n * \n * @example\n * ```typescript\n * import { createEidosClient } from '@eidos.space/client'\n * \n * const eidos = createEidosClient({\n *   endpoint: 'http://localhost:3000/rpc'\n * })\n * \n * // Query table data\n * const posts = await eidos.currentSpace.table('posts').findMany({\n *   where: { published: true },\n *   orderBy: { created_at: 'desc' }\n * })\n * \n * // Get document\n * const doc = await eidos.currentSpace.doc.get('doc-id')\n * ```\n */\n\nimport { createSpaceProxy } from './space-proxy'\nimport type { EidosClient, EidosClientConfig } from './types'\nimport type { DataSpace } from '@eidos.space/core'\n\n/**\n * Create an Eidos client for connecting to headless server\n */\nexport function createEidosClient(config: EidosClientConfig): EidosClient {\n  const { endpoint, timeout, fetch: fetchFn } = config\n  \n  const spaceProxy = createSpaceProxy({\n    endpoint,\n    timeout,\n    fetch: fetchFn,\n  }) as unknown as DataSpace\n  \n  return {\n    currentSpace: spaceProxy,\n    space: spaceProxy,\n  }\n}\n\n// Re-export types\nexport type {\n  EidosClient,\n  EidosClientConfig,\n} from './types'\n\n// Re-export DataSpace for convenience\nexport type { DataSpace } from '@eidos.space/core'\n\n// Re-export low-level APIs for advanced usage\nexport { createSpaceProxy } from './space-proxy'\nexport { createHttpTransport, onCallBack } from './transport'\nexport type { TransportConfig, TransportPort } from './transport'\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@eidos.space/client",
+  "version": "0.1.0",
+  "description": "Eidos RPC client for Node.js and browser",
+  "keywords": [
+    "eidos",
+    "eidos.space",
+    "rpc",
+    "client",
+    "sdk",
+    "prisma-style"
+  ],
+  "author": "mayneyao",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mayneyao/eidos.git",
+    "directory": "packages/client"
+  },
+  "bugs": {
+    "url": "https://github.com/mayneyao/eidos/issues"
+  },
+  "homepage": "https://github.com/mayneyao/eidos/tree/main/packages/client#readme",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@eidos.space/core": "^0.28.0"
+  },
+  "devDependencies": {
+    "tsdown": "0.20.0-beta.3",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}