tRPC Endpoints

export const appRouter = createTRPCRouter({
  admin: adminRouter,
  agent: agentRouter,
  apiKey: apiKeyRouter,
  analytics: analyticsRouter,
  chat: chatRouter,
  device: deviceRouter,
  integration: integrationRouter,
  organization: organizationRouter,
  project: projectRouter,
  task: taskRouter,
  user: userRouter,
  workspace: workspaceRouter,
});

export type AppRouter = typeof appRouter;

export const publicProcedure = t.procedure;

export const protectedProcedure = t.procedure.use(async ({ ctx, next }) => {
  if (!ctx.session) {
    throw new TRPCError({
      code: "UNAUTHORIZED",
      message: "Not authenticated. Please sign in.",
    });
  }
  return next({ ctx: { session: ctx.session } });
});

export const adminProcedure = protectedProcedure.use(async ({ ctx, next }) => {
  if (!ctx.session.user.email.endsWith(COMPANY.EMAIL_DOMAIN)) {
    throw new TRPCError({
      code: "FORBIDDEN",
      message: `Admin access requires ${COMPANY.EMAIL_DOMAIN} email.`,
    });
  }
  return next({ ctx });
});

const { data: user } = api.user.get.useQuery();

const result = await api.workspace.ensure.mutate({
  organizationId: 'org-123',
  project: {
    name: 'My Project',
    slug: 'my-project',
    repoOwner: 'acme',
    repoName: 'app',
    repoUrl: 'https://github.com/acme/app',
    defaultBranch: 'main'
  },
  workspace: {
    id: 'ws-123',
    name: 'feature-auth',
    type: 'worktree',
    config: { branchName: 'feature/auth' }
  }
});

await api.analytics.track.mutate({
  event: 'workspace_created',
  properties: {
    workspaceId: 'ws-123',
    projectId: 'proj-456'
  }
});

import { createTRPCReact } from '@trpc/react-query';
import type { AppRouter } from '@superset/trpc';

export const api = createTRPCReact<AppRouter>();

export function TRPCProvider({ children }: { children: React.ReactNode }) {
  const [queryClient] = useState(() => new QueryClient());
  const [trpcClient] = useState(() =>
    api.createClient({
      links: [
        httpBatchLink({
          url: '/api/trpc',
        }),
      ],
    })
  );

  return (
    <api.Provider client={trpcClient} queryClient={queryClient}>
      <QueryClientProvider client={queryClient}>
        {children}
      </QueryClientProvider>
    </api.Provider>
  );
}

import { createCaller } from '@superset/trpc';
import { auth } from '@superset/auth/server';

export const api = async () => {
  const session = await auth();
  
  return createCaller({
    session,
    auth,
    headers: new Headers(),
  });
};

import { api } from '@/trpc/react';

function WorkspaceList() {
  const { data: workspaces, isLoading } = api.workspace.list.useQuery({
    organizationId: 'org-123'
  });
  
  const createWorkspace = api.workspace.create.useMutation({
    onSuccess: () => {
      console.log('Workspace created!');
    }
  });
  
  return (
    <div>
      {workspaces?.map(ws => <div key={ws.id}>{ws.name}</div>)}
      <button onClick={() => createWorkspace.mutate({
        organizationId: 'org-123',
        projectId: 'proj-123',
        name: 'New Workspace',
        type: 'worktree',
        config: {}
      })}>
        Create Workspace
      </button>
    </div>
  );
}

import { api } from '@/trpc/server';

export default async function Page() {
  const caller = await api();
  const workspaces = await caller.workspace.list({
    organizationId: 'org-123'
  });
  
  return (
    <ul>
      {workspaces.map(ws => <li key={ws.id}>{ws.name}</li>)}
    </ul>
  );
}

import type { AppRouter } from '@superset/trpc';
import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';

type RouterInputs = inferRouterInputs<AppRouter>;
type RouterOutputs = inferRouterOutputs<AppRouter>;

// Input type for workspace.create
type CreateWorkspaceInput = RouterInputs['workspace']['create'];

// Output type for workspace.list
type WorkspaceList = RouterOutputs['workspace']['list'];

import { TRPCError } from '@trpc/server';

try {
  await api.workspace.create.mutate({ /* ... */ });
} catch (error) {
  if (error instanceof TRPCError) {
    switch (error.code) {
      case 'UNAUTHORIZED':
        // Redirect to login
        break;
      case 'FORBIDDEN':
        // Show permission error
        break;
      case 'BAD_REQUEST':
        // Validate input
        break;
    }
  }
}