@pyrpc/client 0.3.3 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @pyrpc/client
 
-Universal TypeScript client for [pyRPC](https://pyrpc.dev). Type-safe RPC calls to your Python backend — install, import, call.
+Universal TypeScript client for [pyRPC](https://pyrpc.com). Type-safe RPC calls to your Python backend - install, import, call.
 
 ## Installation
 
@@ -12,13 +12,12 @@ pnpm add @pyrpc/client
 bun add @pyrpc/client
 ```
 
-The postinstall script in `@pyrpc/types` will prompt for your server URL and generate typed contracts automatically.
+On install, `@pyrpc/types` runs a `postinstall` script that prompts you to choose a **distribution mode**:
 
-For CI, set the `PYRPC_URL` environment variable:
+- **Workspace** — types are written by the server-side `pyrpc dev` / `pyrpc codegen` commands.
+- **Server** — types are fetched from a running server at `npx pyrpc sync` time.
 
-```bash
-PYRPC_URL=https://api.example.com npm install @pyrpc/client
-```
+CI / non-TTY environments skip the prompt silently.
 
 ## Usage
 
@@ -31,7 +30,7 @@ const client = createClient<Types>({
 });
 
 const user = await client.get_user(1);
-console.log(user.name);
+console.log(user.name); // Fully typed - no manual type definitions needed
 ```
 
 The proxy-based API lets you call any remote procedure as a local method. Parameters are passed positionally or as a single object for named arguments.
@@ -50,14 +49,31 @@ try {
 }
 ```
 
+## CLI — `npx pyrpc sync`
+
+After install, you can sync types from a server distribution:
+
+```bash
+npx pyrpc sync
+```
+
+Reads `pyrpc-client.json` and behaves according to the configured distribution:
+
+- **workspace** — prints "Nothing to sync — server writes types directly."
+- **server** — fetches schema from the configured `server_url` and regenerates `@pyrpc/types/src/index.ts`.
+
+Run `npx pyrpc --help` for options.
+
 ## API
 
-### `createClient<TTypes>(options?)`
+### `createClient<T>(options?)`
+
+Creates a proxy client that forwards method calls to the server. The generic parameter `T` is your `Types` interface for full type safety.
 
-Creates a proxy client that forwards method calls to the server.
+- `baseUrl` - Server root URL (defaults to `window.location.origin` in browsers)
+- `headers` - Static or async `HeadersInit`
 
-- `baseUrl` — Server root URL (defaults to `window.location.origin` in browsers)
-- `headers` — Static or async `HeadersInit`
+**Note:** There is no `.rpc` property. Call methods directly on the client object.
 
 ## Keywords
 

package/cli.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+var fs = require('fs');
+var path = require('path');
+var http = require('http');
+var https = require('https');
+
+var TYPES_OUTPUT;
+try {
+  var typesDir = path.dirname(require.resolve('@pyrpc/types/package.json'));
+  TYPES_OUTPUT = path.join(typesDir, 'src', 'index.ts');
+} catch (e) {
+  TYPES_OUTPUT = path.join(__dirname, 'node_modules', '@pyrpc', 'types', 'src', 'index.ts');
+}
+
+function findConfig() {
+  var dir = process.cwd();
+  while (true) {
+    var cfgPath = path.join(dir, 'pyrpc-client.json');
+    if (fs.existsSync(cfgPath)) {
+      return cfgPath;
+    }
+    var parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+var TYPE_MAP = {
+  int: 'number',
+  float: 'number',
+  str: 'string',
+  bool: 'boolean',
+  None: 'null',
+  NoneType: 'null',
+  Any: 'any',
+};
+
+function toTs(t) {
+  if (!t || t === 'None') return 'void';
+  var m = t.match(/^<class\s+'([^'>]+)'>$/);
+  if (m) {
+    var n = m[1];
+    if (TYPE_MAP[n]) return TYPE_MAP[n];
+    if (n[0] >= 'A' && n[0] <= 'Z') return n;
+    return 'any';
+  }
+  var s = t.replace(/^typing\./, '');
+  var o = s.match(/^Optional\[(.+)\]$/);
+  if (o) return toTs(o[1]) + ' | null';
+  var l = s.match(/^(?:List|list)\[(.+)\]$/);
+  if (l) return toTs(l[1]) + '[]';
+  var d = s.match(/^(?:Dict|dict)\[([^,]+),\s*(.+)\]$/);
+  if (d) return 'Record<' + toTs(d[1]) + ', ' + toTs(d[2]) + '>';
+  var u = s.match(/^Union\[(.+)\]$/);
+  if (u) return u[1].split(',').map(function(p) { return toTs(p.trim()); }).join(' | ');
+  var tup = s.match(/^(?:Tuple|tuple)\[([^\]]+)\]$/);
+  if (tup) return '[' + tup[1].split(',').map(function(p) { return toTs(p.trim()); }).join(', ') + ']';
+  return 'any';
+}
+
+function generate(schemas) {
+  var lines = [];
+  lines.push('// Auto-generated by @pyrpc/types');
+  lines.push('// Schema fetched from: ' + (process.env.PYRPC_URL || 'http://localhost:8000'));
+  lines.push('');
+  var names = Object.keys(schemas);
+  for (var i = 0; i < names.length; i++) {
+    var name = names[i];
+    var schema = schemas[name];
+    lines.push('export interface ' + name + 'Params {');
+    var params = schema.parameters || [];
+    for (var j = 0; j < params.length; j++) {
+      var p = params[j];
+      lines.push('  ' + p.name + ': ' + toTs(p.type) + ';');
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push('export interface ' + name + 'Result {');
+    lines.push('  data: ' + toTs(schema.return_type) + ';');
+    lines.push('}');
+    lines.push('');
+  }
+  lines.push('export interface Types {');
+  for (var k = 0; k < names.length; k++) {
+    lines.push('  ' + names[k] + ': { params: ' + names[k] + 'Params; result: ' + names[k] + 'Result };');
+  }
+  lines.push('}');
+  lines.push('');
+  return lines.join('\n');
+}
+
+function fetchSchema(url) {
+  var endpoint = url.replace(/\/+$/, '');
+  if (endpoint.indexOf('/rpc') !== endpoint.length - 4) {
+    endpoint += '/rpc';
+  }
+  var mod = endpoint.indexOf('https') === 0 ? https : http;
+  return new Promise(function(resolve, reject) {
+    mod.get(endpoint, function(res) {
+      var data = '';
+      res.on('data', function(c) { data += c; });
+      res.on('end', function() {
+        if (res.statusCode !== 200) return reject(new Error('HTTP ' + res.statusCode));
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(e); }
+      });
+    }).on('error', reject);
+  });
+}
+
+function printHelp() {
+  console.log('');
+  console.log('  pyRPC client CLI');
+  console.log('');
+  console.log('  Usage:');
+  console.log('    npx pyrpc              Sync types from server (default)');
+  console.log('    npx pyrpc sync         Same as above');
+  console.log('    npx pyrpc --help       Show this help');
+  console.log('');
+  console.log('  The sync command reads pyrpc-client.json from your project');
+  console.log('  root and fetches the latest RPC schema from the server.');
+  console.log('');
+  console.log('  In workspace mode, the server writes types directly to your');
+  console.log('  project — no sync needed.');
+  console.log('');
+}
+
+function main() {
+  var args = process.argv.slice(2);
+
+  if (args[0] === '--help' || args[0] === '-h') {
+    printHelp();
+    return Promise.resolve();
+  }
+
+  if (args[0] && args[0] !== 'sync') {
+    console.log('Unknown command: ' + args[0]);
+    console.log('Usage: npx pyrpc sync');
+    return Promise.resolve();
+  }
+
+  var cfgPath = findConfig();
+  if (!cfgPath) {
+    console.log('');
+    console.log('  No pyrpc-client.json found.');
+    console.log('  Run npm install @pyrpc/client to set up,');
+    console.log('  or create pyrpc-client.json manually.');
+    console.log('');
+    return Promise.resolve();
+  }
+
+  var config;
+  try {
+    config = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+  } catch (e) {
+    console.log('  \u2717 Error reading ' + cfgPath);
+    return Promise.resolve();
+  }
+
+  if (config.distribution === 'workspace') {
+    console.log('');
+    console.log('  Nothing to sync \u2014 server writes types directly to your project.');
+    console.log('  Run pyrpc dev on your backend to regenerate types on change.');
+    console.log('');
+    return Promise.resolve();
+  }
+
+  if (config.distribution === 'server') {
+    var url = config.server_url;
+    if (!url) {
+      console.log('  \u2717 pyrpc-client.json is missing server_url');
+      return Promise.resolve();
+    }
+
+    return fetchSchema(url).then(function(schemas) {
+      var code = generate(schemas);
+      fs.mkdirSync(path.dirname(TYPES_OUTPUT), { recursive: true });
+      fs.writeFileSync(TYPES_OUTPUT, code, 'utf-8');
+      console.log('  \u2713 Types synced: ' + Object.keys(schemas).length + ' procedures');
+      console.log('  Import: import type { Types } from "@pyrpc/types"');
+    }).catch(function(err) {
+      console.log('  \u2717 Could not fetch schema from ' + url + ' (' + err.message + ')');
+    });
+  }
+
+  console.log('  \u2717 Unknown distribution: ' + config.distribution);
+  return Promise.resolve();
+}
+
+if (require.main === module) {
+  main().catch(function(e) {});
+}
+
+module.exports = { main, toTs, generate, fetchSchema, findConfig, printHelp };

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@pyrpc/client",
-  "version": "0.3.3",
+  "version": "0.6.0",
   "description": "Universal TypeScript client for pyRPC",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "pyrpc": "./cli.js"
+  },
   "files": [
-    "dist"
+    "dist",
+    "cli.js"
   ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",