@loopstack/github-oauth-example 0.3.1 → 0.4.0

package/src/workflows/github-repos-overview.workflow.ts

@@ -1,18 +1,16 @@
+import { Inject } from '@nestjs/common';
 import { z } from 'zod';
 import {
   BaseWorkflow,
   CallbackSchema,
-  Final,
   Guard,
-  Initial,
-  InjectTool,
-  InjectWorkflow,
   LinkDocument,
   MarkdownDocument,
-  ToolResult,
+  TEMPLATE_RENDERER,
   Transition,
   Workflow,
 } from '@loopstack/common';
+import type { LoopstackContext, TemplateRenderFn } from '@loopstack/common';
 import {
   GitHubGetAuthenticatedUserTool,
   GitHubGetRepoTool,
@@ -26,17 +24,13 @@ import {
 } from '@loopstack/github-module';
 import { OAuthWorkflow } from '@loopstack/oauth-module';
 
-interface GitHubUserResult {
-  error?: string;
+interface GitHubReposOverviewState {
+  owner: string;
+  repo: string;
+  requiresAuthentication?: boolean;
   user?: { login: string; name: string | null; htmlUrl: string; publicRepos: number };
-}
-
-interface GitHubOrgsResult {
-  orgs: Array<{ login: string; description: string | null }>;
-}
-
-interface GitHubRepoResult {
-  repo: {
+  orgs?: Array<{ login: string; description: string | null }>;
+  repoDetails?: {
     fullName: string;
     description: string | null;
     language: string | null;
@@ -46,18 +40,9 @@ interface GitHubRepoResult {
     defaultBranch: string;
     htmlUrl: string;
   };
-}
-
-interface GitHubBranchesResult {
-  branches: Array<{ name: string; protected: boolean }>;
-}
-
-interface GitHubIssuesResult {
-  issues: Array<{ number: number; title: string; state: string; user: string; htmlUrl: string }>;
-}
-
-interface GitHubPullRequestsResult {
-  pullRequests: Array<{
+  branches?: Array<{ name: string; protected: boolean }>;
+  issues?: Array<{ number: number; title: string; state: string; user: string; htmlUrl: string }>;
+  pullRequests?: Array<{
     number: number;
     title: string;
     state: string;
@@ -65,30 +50,22 @@ interface GitHubPullRequestsResult {
     draft: boolean;
     htmlUrl: string;
   }>;
-}
-
-interface GitHubDirectoryResult {
-  entries: Array<{ name: string; type: string; path: string }>;
-}
-
-interface GitHubWorkflowRunsResult {
-  totalCount: number;
-  runs: Array<{
+  directoryEntries?: Array<{ name: string; type: string; path: string }>;
+  workflowRuns?: Array<{
     id: number;
     name: string;
     status: string;
     conclusion: string | null;
     htmlUrl: string;
   }>;
-}
-
-interface GitHubSearchCodeResult {
-  totalCount: number;
-  results: Array<{ name: string; path: string; repository: string }>;
+  searchResults?: Array<{ name: string; path: string; repository: string }>;
 }
 
 @Workflow({
-  uiConfig: __dirname + '/github-repos-overview.ui.yaml',
+  title: 'GitHub Repository Overview',
+  description:
+    'Comprehensive GitHub example that exercises every GitHub tool.\nFetches user info, repository details, issues, pull requests, branches,\ndirectory contents, workflow runs, and search results for a given repository.\nIf not authenticated, launches the OAuth sub-workflow and retries.',
+  name: 'github_repos_overview',
   schema: z
     .object({
       owner: z.string().default('octocat'),
@@ -96,75 +73,51 @@ interface GitHubSearchCodeResult {
     })
     .strict(),
 })
-export class GitHubReposOverviewWorkflow extends BaseWorkflow<{ owner: string; repo: string }> {
-  // GitHub tools
-  @InjectTool() private gitHubGetAuthenticatedUser: GitHubGetAuthenticatedUserTool;
-  @InjectTool() private gitHubListUserOrgs: GitHubListUserOrgsTool;
-  @InjectTool() private gitHubGetRepo: GitHubGetRepoTool;
-  @InjectTool() private gitHubListBranches: GitHubListBranchesTool;
-  @InjectTool() private gitHubListIssues: GitHubListIssuesTool;
-  @InjectTool() private gitHubListPullRequests: GitHubListPullRequestsTool;
-  @InjectTool() private gitHubListDirectory: GitHubListDirectoryTool;
-  @InjectTool() private gitHubListWorkflowRuns: GitHubListWorkflowRunsTool;
-  @InjectTool() private gitHubSearchCode: GitHubSearchCodeTool;
-
-  @InjectWorkflow() oAuth: OAuthWorkflow;
+export class GitHubReposOverviewWorkflow extends BaseWorkflow<
+  { owner: string; repo: string },
+  GitHubReposOverviewState
+> {
+  constructor(
+    private readonly gitHubGetAuthenticatedUser: GitHubGetAuthenticatedUserTool,
+    private readonly gitHubListUserOrgs: GitHubListUserOrgsTool,
+    private readonly gitHubGetRepo: GitHubGetRepoTool,
+    private readonly gitHubListBranches: GitHubListBranchesTool,
+    private readonly gitHubListIssues: GitHubListIssuesTool,
+    private readonly gitHubListPullRequests: GitHubListPullRequestsTool,
+    private readonly gitHubListDirectory: GitHubListDirectoryTool,
+    private readonly gitHubListWorkflowRuns: GitHubListWorkflowRunsTool,
+    private readonly gitHubSearchCode: GitHubSearchCodeTool,
+    private readonly oAuthWorkflow: OAuthWorkflow,
+    @Inject(TEMPLATE_RENDERER) private readonly render: TemplateRenderFn,
+  ) {
+    super();
+  }
 
-  owner!: string;
-  repo!: string;
-  requiresAuthentication?: boolean;
-  user?: { login: string; name: string | null; htmlUrl: string; publicRepos: number };
-  orgs?: Array<{ login: string; description: string | null }>;
-  repoDetails?: {
-    fullName: string;
-    description: string | null;
-    language: string | null;
-    stars: number;
-    forks: number;
-    openIssues: number;
-    defaultBranch: string;
-    htmlUrl: string;
-  };
-  branches?: Array<{ name: string; protected: boolean }>;
-  issues?: Array<{ number: number; title: string; state: string; user: string; htmlUrl: string }>;
-  pullRequests?: Array<{
-    number: number;
-    title: string;
-    state: string;
-    user: string;
-    draft: boolean;
-    htmlUrl: string;
-  }>;
-  directoryEntries?: Array<{ name: string; type: string; path: string }>;
-  workflowRuns?: Array<{
-    id: number;
-    name: string;
-    status: string;
-    conclusion: string | null;
-    htmlUrl: string;
-  }>;
-  searchResults?: Array<{ name: string; path: string; repository: string }>;
   // --- Step 1: Fetch authenticated user ---
 
-  @Initial({ to: 'user_fetched' })
-  async fetchUser(args: { owner: string; repo: string }) {
-    this.owner = args.owner;
-    this.repo = args.repo;
-    const result: ToolResult<GitHubUserResult> = await this.gitHubGetAuthenticatedUser.call();
-    this.requiresAuthentication = result.data!.error === 'unauthorized';
-    this.user = result.data!.user;
+  @Transition({ to: 'user_fetched' })
+  async fetchUser(state: GitHubReposOverviewState, ctx: LoopstackContext): Promise<GitHubReposOverviewState> {
+    const args = ctx.args as { owner: string; repo: string };
+    const result = await this.gitHubGetAuthenticatedUser.call();
+    return {
+      ...state,
+      owner: args.owner,
+      repo: args.repo,
+      requiresAuthentication: result.data!.error === 'unauthorized',
+      user: result.data!.user,
+    };
   }
 
   // If unauthorized -> launch OAuth
   @Transition({ from: 'user_fetched', to: 'awaiting_auth', priority: 10 })
   @Guard('needsAuth')
-  async authRequired() {
-    const result = await this.oAuth.run(
+  async authRequired(state: GitHubReposOverviewState): Promise<GitHubReposOverviewState> {
+    const result = await this.oAuthWorkflow.run(
       { provider: 'github', scopes: ['repo', 'read:org', 'workflow'] },
-      { alias: 'oAuth', callback: { transition: 'authCompleted' } },
+      { callback: { transition: 'authCompleted' } },
     );
 
-    await this.repository.save(
+    await this.documentStore.save(
       LinkDocument,
       {
         label: 'GitHub authentication required',
@@ -174,10 +127,11 @@ export class GitHubReposOverviewWorkflow extends BaseWorkflow<{ owner: string; r
       },
       { id: `link_${result.workflowId}` },
     );
+    return state;
   }
 
-  needsAuth(): boolean {
-    return !!this.requiresAuthentication;
+  needsAuth(state: GitHubReposOverviewState): boolean {
+    return !!state.requiresAuthentication;
   }
 
   // Auth completed -> retry from start
@@ -187,8 +141,11 @@ export class GitHubReposOverviewWorkflow extends BaseWorkflow<{ owner: string; r
     wait: true,
     schema: CallbackSchema,
   })
-  async authCompleted(payload: { workflowId: string }) {
-    await this.repository.save(
+  async authCompleted(
+    state: GitHubReposOverviewState,
+    payload: { workflowId: string },
+  ): Promise<GitHubReposOverviewState> {
+    await this.documentStore.save(
       LinkDocument,
       {
         status: 'success',
@@ -199,99 +156,98 @@ export class GitHubReposOverviewWorkflow extends BaseWorkflow<{ owner: string; r
       },
       { id: `link_${payload.workflowId}` },
     );
+    return state;
   }
 
   // --- Step 2: Fetch user orgs ---
 
   @Transition({ from: 'user_fetched', to: 'orgs_fetched' })
-  async fetchOrgs() {
-    const result: ToolResult<GitHubOrgsResult> = await this.gitHubListUserOrgs.call({ perPage: 10 });
-    this.orgs = result.data!.orgs;
+  async fetchOrgs(state: GitHubReposOverviewState): Promise<GitHubReposOverviewState> {
+    const result = await this.gitHubListUserOrgs.call({ perPage: 10 });
+    return { ...state, orgs: result.data!.orgs };
   }
 
   // --- Step 3: Fetch repo details and branches ---
 
   @Transition({ from: 'orgs_fetched', to: 'repo_fetched' })
-  async fetchRepoDetails() {
-    const repoResult: ToolResult<GitHubRepoResult> = await this.gitHubGetRepo.call({
-      owner: this.owner,
-      repo: this.repo,
+  async fetchRepoDetails(state: GitHubReposOverviewState): Promise<GitHubReposOverviewState> {
+    const repoResult = await this.gitHubGetRepo.call({
+      owner: state.owner,
+      repo: state.repo,
     });
-    this.repoDetails = repoResult.data!.repo;
 
-    const branchesResult: ToolResult<GitHubBranchesResult> = await this.gitHubListBranches.call({
-      owner: this.owner,
-      repo: this.repo,
+    const branchesResult = await this.gitHubListBranches.call({
+      owner: state.owner,
+      repo: state.repo,
     });
-    this.branches = branchesResult.data!.branches;
+    return { ...state, repoDetails: repoResult.data!.repo, branches: branchesResult.data!.branches };
   }
 
   // --- Step 4: Fetch issues and PRs ---
 
   @Transition({ from: 'repo_fetched', to: 'issues_prs_fetched' })
-  async fetchIssuesPrs() {
-    const issuesResult: ToolResult<GitHubIssuesResult> = await this.gitHubListIssues.call({
-      owner: this.owner,
-      repo: this.repo,
+  async fetchIssuesPrs(state: GitHubReposOverviewState): Promise<GitHubReposOverviewState> {
+    const issuesResult = await this.gitHubListIssues.call({
+      owner: state.owner,
+      repo: state.repo,
       state: 'open',
       perPage: 10,
     });
-    this.issues = issuesResult.data!.issues;
 
-    const prsResult: ToolResult<GitHubPullRequestsResult> = await this.gitHubListPullRequests.call({
-      owner: this.owner,
-      repo: this.repo,
+    const prsResult = await this.gitHubListPullRequests.call({
+      owner: state.owner,
+      repo: state.repo,
       state: 'open',
       perPage: 10,
     });
-    this.pullRequests = prsResult.data!.pullRequests;
+    return { ...state, issues: issuesResult.data!.issues, pullRequests: prsResult.data!.pullRequests };
   }
 
   // --- Step 5: Fetch directory listing and workflow runs ---
 
   @Transition({ from: 'issues_prs_fetched', to: 'content_actions_fetched' })
-  async fetchContentActions() {
-    const dirResult: ToolResult<GitHubDirectoryResult> = await this.gitHubListDirectory.call({
-      owner: this.owner,
-      repo: this.repo,
+  async fetchContentActions(state: GitHubReposOverviewState): Promise<GitHubReposOverviewState> {
+    const dirResult = await this.gitHubListDirectory.call({
+      owner: state.owner,
+      repo: state.repo,
     });
-    this.directoryEntries = dirResult.data!.entries;
 
-    const runsResult: ToolResult<GitHubWorkflowRunsResult> = await this.gitHubListWorkflowRuns.call({
-      owner: this.owner,
-      repo: this.repo,
+    const runsResult = await this.gitHubListWorkflowRuns.call({
+      owner: state.owner,
+      repo: state.repo,
       perPage: 5,
     });
-    this.workflowRuns = runsResult.data!.runs;
+    return { ...state, directoryEntries: dirResult.data!.entries, workflowRuns: runsResult.data!.runs };
   }
 
   // --- Step 6: Search code in the repo ---
 
   @Transition({ from: 'content_actions_fetched', to: 'search_done' })
-  async fetchSearch() {
-    const result: ToolResult<GitHubSearchCodeResult> = await this.gitHubSearchCode.call({
-      query: `repo:${this.owner}/${this.repo}`,
+  async fetchSearch(state: GitHubReposOverviewState): Promise<GitHubReposOverviewState> {
+    const result = await this.gitHubSearchCode.call({
+      query: `repo:${state.owner}/${state.repo}`,
       perPage: 5,
     });
-    this.searchResults = result.data!.results;
+    return { ...state, searchResults: result.data!.results };
   }
 
   // --- Display all results ---
 
-  @Final({ from: 'search_done' })
-  async displayResults() {
-    await this.repository.save(MarkdownDocument, {
+  @Transition({ from: 'search_done', to: 'end' })
+  async displayResults(state: GitHubReposOverviewState): Promise<unknown> {
+    await this.documentStore.save(MarkdownDocument, {
       markdown: this.render(__dirname + '/templates/repoOverview.md', {
-        user: this.user,
-        orgs: this.orgs,
-        repo: this.repoDetails,
-        branches: this.branches,
-        issues: this.issues,
-        pullRequests: this.pullRequests,
-        directoryEntries: this.directoryEntries,
-        workflowRuns: this.workflowRuns,
-        searchResults: this.searchResults,
+        user: state.user,
+        orgs: state.orgs,
+        repo: state.repoDetails,
+        branches: state.branches,
+        issues: state.issues,
+        pullRequests: state.pullRequests,
+        directoryEntries: state.directoryEntries,
+        workflowRuns: state.workflowRuns,
+        searchResults: state.searchResults,
       }),
     });
+    return {};
   }
 }

package/dist/workflows/github-repos-overview.ui.yaml

@@ -1,17 +0,0 @@
-title: 'GitHub Repository Overview'
-
-description: |
-  Comprehensive GitHub example that exercises every GitHub tool.
-  Fetches user info, repository details, issues, pull requests, branches,
-  directory contents, workflow runs, and search results for a given repository.
-  If not authenticated, launches the OAuth sub-workflow and retries.
-
-ui:
-  form:
-    properties:
-      owner:
-        title: 'Repository Owner'
-        placeholder: 'octocat'
-      repo:
-        title: 'Repository Name'
-        placeholder: 'Hello-World'

package/src/workflows/github-repos-overview.ui.yaml

@@ -1,17 +0,0 @@
-title: 'GitHub Repository Overview'
-
-description: |
-  Comprehensive GitHub example that exercises every GitHub tool.
-  Fetches user info, repository details, issues, pull requests, branches,
-  directory contents, workflow runs, and search results for a given repository.
-  If not authenticated, launches the OAuth sub-workflow and retries.
-
-ui:
-  form:
-    properties:
-      owner:
-        title: 'Repository Owner'
-        placeholder: 'octocat'
-      repo:
-        title: 'Repository Name'
-        placeholder: 'Hello-World'