@nativesquare/upwork 0.1.0

package/src/component/public.ts

@@ -0,0 +1,315 @@
+import { query, action } from "./_generated/server.js";
+import { api } from "./_generated/api.js";
+import { v } from "convex/values";
+
+function buildJobPostingsQuery(opts: {
+  searchQuery?: string;
+  sortField?: string;
+}): { query: string; variables: Record<string, unknown> } {
+  const filterArg = opts.searchQuery
+    ? `marketPlaceJobFilter: $marketPlaceJobFilter,`
+    : "";
+
+  const sortField = opts.sortField ?? "RECENCY";
+
+  const variableDefs = opts.searchQuery
+    ? `($marketPlaceJobFilter: MarketplaceJobPostingsSearchFilter)`
+    : "";
+
+  const variables: Record<string, unknown> = {};
+  if (opts.searchQuery) {
+    variables.marketPlaceJobFilter = {
+      searchTerm_eq: { andTerms_all: opts.searchQuery },
+    };
+  }
+
+  const query = `
+query ${variableDefs} {
+  marketplaceJobPostingsSearch(
+    ${filterArg}
+    searchType: USER_JOBS_SEARCH
+    sortAttributes: { field: ${sortField} }
+  ) {
+    totalCount
+    edges {
+      node {
+        id
+        title
+        description
+        category { id name }
+        subcategory { id name }
+        skills { name }
+        experienceLevel
+        duration
+        budget { amount currency }
+        createdDateTime
+        publishedDateTime
+        client { totalHires companyName }
+      }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`;
+
+  return { query, variables };
+}
+
+type JobPostingRow = {
+  upworkId: string;
+  title: string;
+  description: string;
+  category?: string;
+  subcategory?: string;
+  skills: Array<{ name: string }>;
+  experienceLevel: string;
+  duration?: string;
+  budgetAmount?: string;
+  budgetCurrency?: string;
+  createdDateTime: string;
+  publishedDateTime: string;
+  clientTotalHires?: number;
+  clientCompanyName?: string;
+};
+
+type SearchResult = {
+  totalCount: number;
+  postings: JobPostingRow[];
+  hasNextPage: boolean;
+};
+
+export const refreshAccessToken = action({
+  args: {
+    clientId: v.string(),
+    clientSecret: v.string(),
+    baseUrl: v.string(),
+  },
+  handler: async (ctx, args) => {
+    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 response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+      },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: args.clientId,
+        client_secret: args.clientSecret,
+        refresh_token: tokens.refreshToken,
+      }).toString(),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Token refresh failed (${response.status}): ${text}`);
+    }
+
+    const data = await response.json();
+    const expiresAt = Date.now() + (data.expires_in ?? 86400) * 1000;
+
+    await ctx.runMutation(api.private.storeTokens, {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token ?? tokens.refreshToken,
+      expiresAt,
+      tokenType: data.token_type ?? "Bearer",
+    });
+  },
+});
+
+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 body = new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: args.clientId,
+      client_secret: args.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] code:", args.code);
+
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+      },
+      body,
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`OAuth token exchange failed (${response.status}): ${text}`);
+    }
+
+    const data = await response.json();
+    const expiresAt = Date.now() + (data.expires_in ?? 86400) * 1000;
+
+    await ctx.runMutation(api.private.storeTokens, {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresAt,
+      tokenType: data.token_type ?? "Bearer",
+    });
+  },
+});
+
+export const searchJobPostings = action({
+  args: {
+    clientId: v.string(),
+    clientSecret: v.string(),
+    baseUrl: v.string(),
+    searchQuery: v.optional(v.string()),
+    sortField: v.optional(v.string()),
+  },
+  handler: async (ctx, args): Promise<SearchResult> => {
+    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, {
+        clientId: args.clientId,
+        clientSecret: args.clientSecret,
+        baseUrl: args.baseUrl,
+      });
+      tokens = await ctx.runQuery(api.private.getTokens, {});
+      if (!tokens) {
+        throw new Error("Failed to refresh token.");
+      }
+    }
+
+    const graphqlUrl = `${args.baseUrl}/graphql`;
+
+    const { query, variables } = buildJobPostingsQuery({
+      searchQuery: args.searchQuery,
+      sortField: args.sortField,
+    });
+
+    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?: { marketplaceJobPostingsSearch?: {
+        totalCount?: number;
+        edges?: Array<{ node: Record<string, unknown> }>;
+        pageInfo?: { hasNextPage?: boolean; endCursor?: string };
+      }};
+      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 connection = result.data?.marketplaceJobPostingsSearch;
+    if (!connection) {
+      return { totalCount: 0, postings: [], hasNextPage: false };
+    }
+
+    const postings: JobPostingRow[] = (connection.edges ?? []).map(
+      (edge) => {
+        const node = edge.node;
+        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 }>) ?? [];
+
+        return {
+          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,
+        };
+      },
+    );
+
+    if (postings.length > 0) {
+      await ctx.runMutation(api.private.upsertJobPostings, { postings });
+    }
+
+    return {
+      totalCount: connection.totalCount ?? 0,
+      postings,
+      hasNextPage: connection.pageInfo?.hasNextPage ?? false,
+    };
+  },
+});
+
+const TWENTY_THREE_HOURS_MS = 23 * 60 * 60 * 1000;
+
+export const listJobPostings = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 50;
+    const cutoff = Date.now() - TWENTY_THREE_HOURS_MS;
+    const postings = await ctx.db
+      .query("jobPostings")
+      .withIndex("byCachedAt", (q) => q.gte("cachedAt", cutoff))
+      .order("desc")
+      .take(limit);
+    return postings;
+  },
+});
+
+export const getAuthStatus = query({
+  args: {},
+  handler: async (ctx) => {
+    const tokens = await ctx.db.query("oauthTokens").first();
+    if (!tokens) {
+      return "disconnected" as const;
+    }
+    if (tokens.expiresAt < Date.now()) {
+      return "expired" as const;
+    }
+    return "connected" as const;
+  },
+});

package/src/component/schema.ts

@@ -0,0 +1,31 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  oauthTokens: defineTable({
+    accessToken: v.string(),
+    refreshToken: v.string(),
+    expiresAt: v.number(),
+    tokenType: v.string(),
+  }),
+
+  jobPostings: defineTable({
+    upworkId: v.string(),
+    title: v.string(),
+    description: v.string(),
+    category: v.optional(v.string()),
+    subcategory: v.optional(v.string()),
+    skills: v.array(v.object({ name: v.string() })),
+    experienceLevel: v.string(),
+    duration: v.optional(v.string()),
+    budgetAmount: v.optional(v.string()),
+    budgetCurrency: v.optional(v.string()),
+    createdDateTime: v.string(),
+    publishedDateTime: v.string(),
+    clientTotalHires: v.optional(v.number()),
+    clientCompanyName: v.optional(v.string()),
+    cachedAt: v.number(),
+  })
+    .index("byUpworkId", ["upworkId"])
+    .index("byCachedAt", ["cachedAt"]),
+});

package/src/react/index.ts

@@ -0,0 +1,7 @@
+"use client";
+
+// This is where React components / hooks go.
+
+export const useMyComponent = () => {
+  return {};
+};

package/src/test.ts

@@ -0,0 +1,18 @@
+/// <reference types="vite/client" />
+import type { TestConvex } from "convex-test";
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import schema from "./component/schema.js";
+const modules = import.meta.glob("./component/**/*.ts");
+
+/**
+ * Register the component with the test convex instance.
+ * @param t - The test convex instance, e.g. from calling `convexTest`.
+ * @param name - The name of the component, as registered in convex.config.ts.
+ */
+export function register(
+  t: TestConvex<SchemaDefinition<GenericSchema, boolean>>,
+  name: string = "upwork",
+) {
+  t.registerComponent(name, schema, modules);
+}
+export default { register, schema, modules };