weave-typescript 0.10.12 → 0.10.14

package/README.md

@@ -0,0 +1,102 @@
+# weave-typescript
+
+TypeScript bindings for the Weave platform. The package ships generated protobuf message types, gRPC service clients,
+and Postgres query helpers so applications can talk to Weave services and databases from Node.js and modern TypeScript
+runtimes.
+
+- gRPC-ready service clients produced from Buf-managed protobuf definitions.
+- Strongly-typed SQL helpers generated with `sqlc` for the WeaveSQL datasets.
+
+## Installation
+
+```bash
+pnpm add weave-typescript
+# or
+npm install weave-typescript
+# or
+yarn add weave-typescript
+```
+
+The package includes runtime dependencies on `@grpc/grpc-js`, `@bufbuild/protobuf`, and `pg`; no extra installs are
+required when using the default export.
+
+## Quick start
+
+```ts
+import { credentials } from "@grpc/grpc-js";
+import { auth } from "weave-typescript";
+
+const client = new auth.AuthClient(
+  "api.weave.com:443",
+  credentials.createSsl()
+);
+
+client.initiateOAuth(
+  {
+    provider: "github",
+    redirectUri: "https://example.com/oauth/callback",
+    state: "csrf-token",
+    scope: "openid profile email",
+    providerParams: {},
+  },
+  (err, response) => {
+    if (err) throw err;
+    console.log(response.authUrl);
+  }
+);
+```
+
+Every protobuf module under `src/weaveapi/**` is re-exported from the root package. Service namespaces expose message
+types, client constructors, and server implementations that the `@grpc/grpc-js` ecosystem expects.
+
+## Query helpers for WeaveSQL
+
+```ts
+import { Client } from "pg";
+import { getModel } from "weave-typescript/weavesql/llmxdb/models_sql";
+
+const client = new Client({ connectionString: process.env.DATABASE_URL });
+await client.connect();
+
+const row = await getModel(client, { slug: "weave/sonnet-3" });
+if (!row) {
+  console.log("model not found");
+} else {
+  console.log(row.name, row.capabilities);
+}
+```
+
+Each helper follows the `sqlc` convention: the exported SQL text constants match the query names while the functions
+perform typed marshalling to and from `pg` array results. When you regenerate SQL code, the TypeScript bindings stay in
+sync with new database migrations.
+
+## Development
+
+```bash
+pnpm install           # install dependencies
+pnpm build             # emit dist/ with JS and type declarations
+pnpm test              # run sqlc generator unit tests (tools/sqlcgen.test.js)
+pnpm generate          # rebuild src/index.ts barrel exports
+pnpm generate:sqlc-config --schema ../schema/weavesql
+                       # regenerate sqlc.yaml for local schemas
+```
+
+### Regenerating protobuf clients
+
+1. Sync the `schema/` directory (or point Buf at the shared schema checkout).
+2. Run `buf generate` (Buf picks up `buf.gen.yaml` and writes into `src/`).
+3. Execute `pnpm generate` to rebuild the barrel exports.
+4. Re-run `pnpm build` so `dist/` reflects the new artifacts.
+
+### SQL code generation
+
+The `tools/sqlcgen.js` utility scans `schema/weavesql/**` (or the directory passed via `--schema`) and writes an
+`sqlc.yaml` that targets the TypeScript `sqlc` plugin. Regenerate it before running `sqlc generate` so new databases or
+query directories are included.
+
+## Contributing
+
+Follow the project coding guidelines in `CODE_STYLE.md`, prefer small focused commits, and keep generated artifacts out
+of Git history unless they are part of a release. Pull requests should include regenerated protobufs/SQL bindings when
+schemas change and cover the relevant tooling scripts with tests where practical.
+

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "weave-typescript",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist/**/*"
   ],
   "author": "weave-labs",
-  "license": "ISC",
+  "license": "FCL-1.0-ALv2",
   "dependencies": {
     "@bufbuild/protobuf": "^2.4.0",
     "@grpc/grpc-js": "^1.13.4",