cargo run -p cratestack-cli -- generate-typescript \
  --schema crates/cratestack-pg/tests/fixtures/blog.cstack \
  --out packages/blog-client \
  --package-name @example/blog-client \
  --base-path /cstack

use cratestack_client_typescript::{TypeScriptGeneratorConfig, generate_package};

let schema = cratestack_parser::parse_schema_file("schema.cstack")?;
let package = generate_package(&schema, &TypeScriptGeneratorConfig {
    package_name: "@example/blog-client".to_owned(),
    base_path: "/cstack".to_owned(),
    swr: true, // omit (or `false`) for the default layout only
    ..Default::default()
})?;

for file in package.files {
    let path = out_dir.join(&file.file_name);
    std::fs::create_dir_all(path.parent().unwrap())?;
    std::fs::write(path, &file.contents)?;
}

transport rpc

datasource db {
  provider = "postgresql"
  url = env("DATABASE_URL")
}

auth Operator {
  id Int
}

model Widget {
  id Int @id
  name String
  weight Int?

  @@allow("read", auth() != null)
  @@allow("create", auth() != null)
  @@allow("update", auth() != null)
  @@allow("delete", auth() != null)
}

procedure echoName(name: String): String
  @allow(auth() != null)

cargo run -p cratestack-cli -- generate-typescript \
  --schema schemas/widget_rpc.cstack \
  --out packages/widget-client \
  --package-name @example/widget-client \
  --base-path /api

cargo run -p cratestack-cli -- generate-typescript \
  --schema examples/react-vite-swr/schema.cstack \
  --out packages/board-client \
  --package-name @example/board-client \
  --base-path /api \
  --swr

// Note the `/swr` subpath — these are the SWR layout's plain functions,
// and its own `CratestackRuntime`. See the warning below on why the root
// package's runtime is not interchangeable with this one.
import { CratestackRuntime, listWidgets, createWidget } from "@example/board-client/swr";

const runtime = new CratestackRuntime("https://api.example.com", { basePath: "/api" });

const widgets = await listWidgets(runtime, { query: { limit: 20, sort: ["-id"] } });
const created = await createWidget(runtime, { id: 3, name: "New Widget" });

import { useWidgets, useCreateWidget } from "@example/board-client/swr/models/widget.hooks";

function WidgetList({ runtime }: { runtime: CratestackRuntime }) {
  const { data: widgets } = useWidgets(runtime);
  const { trigger: createWidget } = useCreateWidget(runtime);
  // ...
}

TS2308: Module "./models/post.js" has already exported a member named 'listPosts'

cd packages/blog-client
npm install
npm run build   # runs `tsc -p tsconfig.json`, emits dist/

export interface Widget {
  id?: number;
  name?: string;
  weight?: number | null;
}

cargo run -p cratestack-cli -- generate-typescript \
  --schema crates/cratestack-pg/tests/fixtures/blog.cstack \
  --out packages/blog-client \
  --package-name @example/blog-client \
  --base-path /cstack \
  --full-selection

export interface Widget {
  id: number;
  name: string;
  weight?: number | null;
}

import { ExampleBlogClientClient } from "@example/blog-client";

const client = new ExampleBlogClientClient("https://api.example.com", {
  basePath: "/cstack",
  headers: async () => ({
    authorization: `Bearer ${await tokenStore.getAccessToken()}`,
    "x-request-id": crypto.randomUUID(),
  }),
});

await client.posts.create(input, {
  headers: { "idempotency-key": idempotencyKey },
});

const posts = await client.posts.list({
  query: { fields: ["id", "title"], sort: ["-id"], limit: 20 },
});

const post = await client.posts.get(1, {
  query: { fields: ["id", "title"], include: ["author"] },
});

const created = await client.posts.create({
  id: 3,
  title: "Created Post",
  subtitle: "created",
  published: true,
  authorId: 1,
});

const updated = await client.posts.update(1, {
  title: "Updated Post",
  published: false,
});

await client.posts.delete(1);

const feed = await client.procedures.getFeed({ limit: 10 });

const published = await client.procedures.publishPost({
  args: { postId: 1 },
});

import {
  ExampleBlogClientClient,
  usePostListQuery,
  useCreatePostMutation,
} from "@example/blog-client";

function PostList({ client }: { client: ExampleBlogClientClient }) {
  const list = usePostListQuery(client, {
    query: { fields: ["id", "title"], limit: 20 },
    queryOptions: { staleTime: 30_000 },
  });
  const create = useCreatePostMutation(client);

  if (list.isPending) return null;
  if (list.isError) return <ErrorState error={list.error} />;

  return <PostListView data={list.data} onCreate={(input) => create.mutate(input)} />;
}

import { ExampleWidgetClientClient } from "@example/widget-client";

const client = new ExampleWidgetClientClient("https://api.example.com", {
  basePath: "/api",
});

const widgets = await client.widgets.list();
const widget = await client.widgets.get(1);
const created = await client.widgets.create({ id: 3, name: "New Widget" });
const updated = await client.widgets.update(1, { name: "Renamed" });
await client.widgets.delete(1);

const echoed = await client.procedures.echoName({ name: "hello" });

const results = await client.runtime.batch([
  { id: 1, op: "model.Widget.get", input: { id: 1 } },
  { id: 2, op: "procedure.echoName", input: { name: "hi" } },
]);

await client.widgets.create(input, { idempotencyKey: crypto.randomUUID() });

for await (const ping of client.runtime.stream<Ping>("procedure.manyPings", {})) {
  render(ping);
}

import { createBatchLink, createLoggerLink } from "@cratestack/api";
import { ExampleWidgetClientClient } from "@example/widget-client";

const client = new ExampleWidgetClientClient("https://api.example.com", {
  links: [createLoggerLink(), createBatchLink()],
});

// Issued inside the same tick — collapses into a single POST /rpc/batch:
const [a, b, c] = await Promise.all([
  client.widgets.get(1),
  client.widgets.get(2),
  client.widgets.get(3),
]);

import { createZodValidatorLink } from "@cratestack/api/validator-zod";
import { rpcQueryOptions } from "@cratestack/api/adapter-tanstack-query";

cargo run -p cratestack-cli -- generate-typescript \
  --schema schema.cstack \
  --out packages/widget-client \
  --package-name @example/widget-client \
  --no-native-cbor

import { jsonRpcCodec } from "@example/widget-client";
import { ExampleWidgetClientClient } from "@example/widget-client";

const client = new ExampleWidgetClientClient("https://api.example.com", {
  codec: jsonRpcCodec,
});

// TypeScript
import { ExampleBlogClientClient } from "@example/blog-client";

const client = new ExampleBlogClientClient("https://api.example.com", {
  basePath: "/cstack",
});

// Dart
final blogClient = BlogClientCratestackClient(
  CratestackDioAdapter(dio: myDio),
  basePath: '/cstack',
);

// Rust
use cratestack_client_rust::{ClientConfig, CratestackClient, CborCodec};

let runtime = CratestackClient::new(ClientConfig::new(base_url), CborCodec);
let client = cratestack_schema::client::Client::new(runtime);

// TypeScript
const posts = await client.posts.list({ query: { limit: 2 } });

// Dart
final posts = await blogClient.posts.list(
  query: (PostSelection()..id()).toListQuery(limit: 2),
);

// Rust
let posts = client.posts().list(&[("limit", "2")], &[]).await?;

// TypeScript
const created = await client.posts.create({
  id: 3,
  title: "Created Post",
  subtitle: "created",
  published: true,
  authorId: 1,
});

// Dart
final created = await blogClient.posts.create(
  const CreatePostInput(
    id: 3,
    title: 'Created Post',
    subtitle: 'created',
    published: true,
    authorId: 1,
  ),
);

// Rust
let created = client
    .posts()
    .create(
        &cratestack_schema::CreatePostInput {
            id: 3,
            title: "Created Post".to_owned(),
            subtitle: Some("created".to_owned()),
            published: true,
            authorId: 1,
        },
        &[],
    )
    .await?;

// TypeScript
const feed = await client.procedures.getFeed({ limit: 10 });

// Dart
final feed = await blogClient.procedures.getFeed(
  const GetFeedArgs(limit: 10),
);

// Rust
let feed = client
    .procedures()
    .get_feed(&cratestack_schema::procedures::get_feed::Args { limit: Some(10) }, &[])
    .await?;

// TypeScript
const published = await client.procedures.publishPost({
  args: { postId: 1 },
});

// Dart
final publishedPost = await blogClient.procedures.publishPost(
  const PublishPostArgs(args: PublishPostInput(postId: 1)),
);

// Rust
let published = client
    .procedures()
    .publish_post(
        &cratestack_schema::procedures::publish_post::Args {
            args: cratestack_schema::PublishPostInput { postId: 1 },
        },
        &[],
    )
    .await?;

const image = await client.images.get(7, {
  computedParams: { proxyUrl: { width: 800 } },
});

const image = await client.images.get(7, {
  fields: ["id", "proxyUrl"],
  computedParams: { proxyUrl: { width: 800 } },
});