@nativesquare/upwork 0.1.0 → 0.2.0

package/src/component/public.ts

@@ -2,6 +2,19 @@ import { query, action } from "./_generated/server.js";
 import { api } from "./_generated/api.js";
 import { v } from "convex/values";
 
+const BASE_URL = "https://upwork-mock-server.onrender.com";
+
+function getCredentials(): { clientId: string; clientSecret: string } {
+  const clientId = process.env.UPWORK_CLIENT_ID;
+  const clientSecret = process.env.UPWORK_CLIENT_SECRET;
+  if (!clientId || !clientSecret) {
+    throw new Error(
+      "Missing UPWORK_CLIENT_ID or UPWORK_CLIENT_SECRET environment variables.",
+    );
+  }
+  return { clientId, clientSecret };
+}
+
 function buildJobPostingsQuery(opts: {
   searchQuery?: string;
   sortField?: string;
@@ -78,18 +91,15 @@ type SearchResult = {
 };
 
 export const refreshAccessToken = action({
-  args: {
-    clientId: v.string(),
-    clientSecret: v.string(),
-    baseUrl: v.string(),
-  },
-  handler: async (ctx, args) => {
+  args: {},
+  handler: async (ctx) => {
+    const { clientId, clientSecret } = getCredentials();
     const tokens = await ctx.runQuery(api.private.getTokens, {});
     if (!tokens) {
       throw new Error("No stored tokens found. Complete OAuth authorization first.");
     }
 
-    const tokenUrl = `${args.baseUrl}/api/v3/oauth2/token`;
+    const tokenUrl = `${BASE_URL}/api/v3/oauth2/token`;
 
     const response = await fetch(tokenUrl, {
       method: "POST",
@@ -99,8 +109,8 @@ export const refreshAccessToken = action({
       },
       body: new URLSearchParams({
         grant_type: "refresh_token",
-        client_id: args.clientId,
-        client_secret: args.clientSecret,
+        client_id: clientId,
+        client_secret: clientSecret,
         refresh_token: tokens.refreshToken,
       }).toString(),
     });
@@ -124,26 +134,24 @@ export const refreshAccessToken = action({
 
 export const exchangeAuthCode = action({
   args: {
-    clientId: v.string(),
-    clientSecret: v.string(),
     code: v.string(),
     redirectUri: v.string(),
-    baseUrl: v.string(),
   },
   handler: async (ctx, args): Promise<void> => {
-    const tokenUrl = `${args.baseUrl}/api/v3/oauth2/token`;
+    const { clientId, clientSecret } = getCredentials();
+    const tokenUrl = `${BASE_URL}/api/v3/oauth2/token`;
 
     const body = new URLSearchParams({
       grant_type: "authorization_code",
-      client_id: args.clientId,
-      client_secret: args.clientSecret,
+      client_id: clientId,
+      client_secret: clientSecret,
       code: args.code,
       redirect_uri: args.redirectUri,
     }).toString();
 
     console.log("[exchangeAuthCode] POST", tokenUrl);
     console.log("[exchangeAuthCode] redirect_uri:", args.redirectUri);
-    console.log("[exchangeAuthCode] client_id:", args.clientId);
+    console.log("[exchangeAuthCode] client_id:", clientId);
     console.log("[exchangeAuthCode] code:", args.code);
 
     const response = await fetch(tokenUrl, {
@@ -174,9 +182,6 @@ export const exchangeAuthCode = action({
 
 export const searchJobPostings = action({
   args: {
-    clientId: v.string(),
-    clientSecret: v.string(),
-    baseUrl: v.string(),
     searchQuery: v.optional(v.string()),
     sortField: v.optional(v.string()),
   },
@@ -187,18 +192,14 @@ export const searchJobPostings = action({
     }
 
     if (tokens.expiresAt < Date.now()) {
-      await ctx.runAction(api.public.refreshAccessToken, {
-        clientId: args.clientId,
-        clientSecret: args.clientSecret,
-        baseUrl: args.baseUrl,
-      });
+      await ctx.runAction(api.public.refreshAccessToken, {});
       tokens = await ctx.runQuery(api.private.getTokens, {});
       if (!tokens) {
         throw new Error("Failed to refresh token.");
       }
     }
 
-    const graphqlUrl = `${args.baseUrl}/graphql`;
+    const graphqlUrl = `${BASE_URL}/graphql`;
 
     const { query, variables } = buildJobPostingsQuery({
       searchQuery: args.searchQuery,
@@ -282,6 +283,124 @@ export const searchJobPostings = action({
   },
 });
 
+export const getJobPosting = query({
+  args: { upworkId: v.string() },
+  handler: async (ctx, args) => {
+    return (
+      (await ctx.db
+        .query("jobPostings")
+        .withIndex("byUpworkId", (q) => q.eq("upworkId", args.upworkId))
+        .first()) ?? null
+    );
+  },
+});
+
+function buildJobPostingQuery(upworkId: string): {
+  query: string;
+  variables: Record<string, unknown>;
+} {
+  const query = `
+query($id: ID!) {
+  marketplaceJobPosting(id: $id) {
+    id
+    title
+    description
+    category { id name }
+    subcategory { id name }
+    skills { name }
+    experienceLevel
+    duration
+    budget { amount currency }
+    createdDateTime
+    publishedDateTime
+    client { totalHires companyName }
+  }
+}`;
+  return { query, variables: { id: upworkId } };
+}
+
+export const fetchJobPosting = action({
+  args: {
+    upworkId: v.string(),
+  },
+  handler: async (ctx, args): Promise<JobPostingRow | null> => {
+    let tokens = await ctx.runQuery(api.private.getTokens, {});
+    if (!tokens) {
+      throw new Error("Not connected to Upwork. Complete OAuth authorization first.");
+    }
+
+    if (tokens.expiresAt < Date.now()) {
+      await ctx.runAction(api.public.refreshAccessToken, {});
+      tokens = await ctx.runQuery(api.private.getTokens, {});
+      if (!tokens) {
+        throw new Error("Failed to refresh token.");
+      }
+    }
+
+    const graphqlUrl = `${BASE_URL}/graphql`;
+
+    const { query, variables } = buildJobPostingQuery(args.upworkId);
+
+    const response = await fetch(graphqlUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${tokens.accessToken}`,
+      },
+      body: JSON.stringify({ query, variables }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Upwork GraphQL request failed (${response.status}): ${text}`);
+    }
+
+    const result: {
+      data?: { marketplaceJobPosting?: Record<string, unknown> };
+      errors?: Array<{ message: string }>;
+    } = await response.json();
+
+    if (result.errors?.length) {
+      throw new Error(
+        `Upwork GraphQL errors: ${result.errors.map((e) => e.message).join(", ")}`,
+      );
+    }
+
+    const node = result.data?.marketplaceJobPosting;
+    if (!node) return null;
+
+    const budget = node.budget as { amount?: string; currency?: string } | null;
+    const client = node.client as {
+      totalHires?: number;
+      companyName?: string;
+    } | null;
+    const category = node.category as { name?: string } | null;
+    const subcategory = node.subcategory as { name?: string } | null;
+    const skills = (node.skills as Array<{ name: string }>) ?? [];
+
+    const posting: JobPostingRow = {
+      upworkId: String(node.id),
+      title: String(node.title ?? ""),
+      description: String(node.description ?? ""),
+      category: category?.name ?? undefined,
+      subcategory: subcategory?.name ?? undefined,
+      skills: skills.map((s) => ({ name: s.name })),
+      experienceLevel: String(node.experienceLevel ?? ""),
+      duration: node.duration != null ? String(node.duration) : undefined,
+      budgetAmount: budget?.amount != null ? String(budget.amount) : undefined,
+      budgetCurrency: budget?.currency != null ? String(budget.currency) : undefined,
+      createdDateTime: String(node.createdDateTime ?? ""),
+      publishedDateTime: String(node.publishedDateTime ?? ""),
+      clientTotalHires: client?.totalHires ?? undefined,
+      clientCompanyName: client?.companyName ?? undefined,
+    };
+
+    await ctx.runMutation(api.private.upsertJobPostings, { postings: [posting] });
+
+    return posting;
+  },
+});
+
 const TWENTY_THREE_HOURS_MS = 23 * 60 * 60 * 1000;
 
 export const listJobPostings = query({