Skip to content

Job application tracker and AI-powered job search assistant. Helps job seekers manage their search journey with AI resume review, job matching, task logging, and application analytics, all while keeping your data private.

feat(stages): write a first current stage from every job creation path and load stages on the details page

Khuram Niaz211df3cbaacc
diff --git a/__tests__/ats-runner.spec.ts b/__tests__/ats-runner.spec.ts
index d68e167..d978672 100644
--- a/__tests__/ats-runner.spec.ts
+++ b/__tests__/ats-runner.spec.ts
@@ -17,7 +17,13 @@ vi.mock("@prisma/client", () => {
location: { findUnique: vi.fn(), create: vi.fn() },
company: { findUnique: vi.fn(), create: vi.fn() },
jobSource: { findUnique: vi.fn(), create: vi.fn() },
- jobStatus: { findFirst: vi.fn(), create: vi.fn() },
+ jobStatus: { findFirst: vi.fn(), findUnique: vi.fn(), create: vi.fn() },
+ jobStage: { create: vi.fn() },
+ jobStageType: {
+ findUnique: vi.fn(),
+ aggregate: vi.fn(),
+ create: vi.fn(),
+ },
};
return {
PrismaClient: vi.fn(function () {
@@ -118,6 +124,17 @@ describe("runAutomation (lever)", () => {
(prisma.company.findUnique as any).mockResolvedValue({ id: "co" });
(prisma.jobSource.findUnique as any).mockResolvedValue({ id: "src" });
(prisma.jobStatus.findFirst as any).mockResolvedValue({ id: "st" });
+ // Every saved job now gets its first current stage, which resolves the
+ // status-named stage type through the same Prisma mock.
+ (prisma.jobStatus.findUnique as any).mockResolvedValue({
+ id: "st",
+ label: "New",
+ });
+ (prisma.jobStageType.findUnique as any).mockResolvedValue({
+ id: "stage-type-new",
+ label: "New",
+ });
+ (prisma.jobStage.create as any).mockResolvedValue({ id: "stage-1" });
(generateText as any).mockResolvedValue({
text: "SCORES: match=90 recommendation=strong match\n\n## Summary\nGreat fit",
diff --git a/__tests__/createJobStage.spec.ts b/__tests__/createJobStage.spec.ts
new file mode 100644
index 0000000..af4f9ce
--- /dev/null
+++ b/__tests__/createJobStage.spec.ts
@@ -0,0 +1,55 @@
+import { createJobRecord, createFirstStage } from "@/lib/jobs/createJobRecord";
+import prisma from "@/lib/db";
+import { resolveStageTypeForStatusId } from "@/lib/jobs/resolve";
+
+vi.mock("@/lib/db", () => ({
+ default: {
+ job: { create: vi.fn() },
+ jobStage: { create: vi.fn() },
+ },
+}));
+vi.mock("@/lib/jobs/resolve", () => ({
+ resolveStageTypeForStatusId: vi.fn(),
+}));
+
+const db = prisma as any;
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ (resolveStageTypeForStatusId as any).mockResolvedValue("t-draft");
+ db.job.create.mockResolvedValue({ id: "j1", createdAt: new Date("2026-09-19T00:00:00Z") });
+});
+
+describe("createFirstStage", () => {
+ it("writes one current stage dated at the job's creation", async () => {
+ const created = new Date("2026-09-19T00:00:00Z");
+
+ await createFirstStage(db, "j1", "s-draft", "u1", created);
+
+ expect(resolveStageTypeForStatusId).toHaveBeenCalledWith("s-draft", "u1");
+ expect(db.jobStage.create).toHaveBeenCalledWith({
+ data: {
+ jobId: "j1",
+ stageTypeId: "t-draft",
+ occurredAt: created,
+ isCurrent: true,
+ },
+ });
+ });
+});
+
+describe("createJobRecord", () => {
+ it("gives every new job exactly one current stage", async () => {
+ await createJobRecord({
+ jobTitleId: "t1",
+ companyId: "c1",
+ statusId: "s-draft",
+ description: "<p>x</p>",
+ jobType: "full-time",
+ userId: "u1",
+ } as any);
+
+ expect(db.jobStage.create).toHaveBeenCalledTimes(1);
+ expect(db.jobStage.create.mock.calls[0][0].data.isCurrent).toBe(true);
+ });
+});
diff --git a/__tests__/persistDiscoveredJobStage.spec.ts b/__tests__/persistDiscoveredJobStage.spec.ts
new file mode 100644
index 0000000..6555914
--- /dev/null
+++ b/__tests__/persistDiscoveredJobStage.spec.ts
@@ -0,0 +1,60 @@
+import { persistDiscoveredJob } from "@/lib/scraper/automation-run/persist";
+import { mapScrapedJobToJobRecord } from "@/lib/scraper/mapper";
+import db from "@/lib/db";
+import { resolveStageTypeForStatusId } from "@/lib/jobs/resolve";
+
+vi.mock("@/lib/db", () => ({
+ default: { job: { create: vi.fn() }, jobStage: { create: vi.fn() } },
+}));
+vi.mock("@/lib/scraper/mapper", () => ({ mapScrapedJobToJobRecord: vi.fn() }));
+vi.mock("@/lib/jobs/resolve", () => ({
+ resolveStageTypeForStatusId: vi.fn(),
+}));
+
+const mockDb = db as any;
+const createdAt = new Date("2026-09-19T00:00:00Z");
+
+const automation = { id: "a1", userId: "u1", jobBoard: "greenhouse" } as any;
+const job = {
+ title: "Engineer",
+ company: "Acme",
+ location: "Remote",
+ description: "Build things",
+ url: "https://boards.greenhouse.io/acme/jobs/1",
+} as any;
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ (resolveStageTypeForStatusId as any).mockResolvedValue("t-new");
+ (mapScrapedJobToJobRecord as any).mockResolvedValue({
+ statusId: "s-new",
+ createdAt,
+ tags: { connect: [] },
+ });
+ mockDb.job.create.mockResolvedValue({ id: "j1", createdAt });
+});
+
+describe("persistDiscoveredJob", () => {
+ it("gives a discovered job its first current stage", async () => {
+ const res = await persistDiscoveredJob(automation, job, 50, {}, []);
+
+ expect(res.saved).toBe(true);
+ expect(resolveStageTypeForStatusId).toHaveBeenCalledWith("s-new", "u1");
+ expect(mockDb.jobStage.create.mock.calls[0][0].data).toEqual({
+ jobId: "j1",
+ stageTypeId: "t-new",
+ occurredAt: createdAt,
+ isCurrent: true,
+ });
+ });
+
+ // A concurrent run won the dedup race, so there is no job to stage.
+ it("writes no stage when the unique index refuses the job", async () => {
+ mockDb.job.create.mockRejectedValue({ code: "P2002" });
+
+ const res = await persistDiscoveredJob(automation, job, 50, {}, []);
+
+ expect(res.saved).toBe(false);
+ expect(mockDb.jobStage.create).not.toHaveBeenCalled();
+ });
+});
diff --git a/src/actions/job/queries.ts b/src/actions/job/queries.ts
index d0ada89..32d2c71 100644
--- a/src/actions/job/queries.ts
+++ b/src/actions/job/queries.ts
@@ -71,6 +71,33 @@ const JOB_DETAILS_INCLUDE = {
},
orderBy: { createdAt: "asc" as const },
},
+ // Duplicates STAGE_DETAIL_INCLUDE rather than importing it: this is a
+ // "use server" module and that const lives in another action directory.
+ stages: {
+ include: {
+ StageType: { include: { Status: true } },
+ interviewers: {
+ include: {
+ Contact: {
+ select: {
+ id: true,
+ name: true,
+ title: true,
+ email: true,
+ phone: true,
+ linkedinUrl: true,
+ Company: { select: { id: true, label: true } },
+ },
+ },
+ },
+ orderBy: { createdAt: "asc" as const },
+ },
+ prepQuestions: {
+ include: { Question: { select: { id: true, question: true, tags: true } } },
+ orderBy: { createdAt: "asc" as const },
+ },
+ },
+ },
};
type JobsListFilters = {
diff --git a/src/actions/mock.actions.ts b/src/actions/mock.actions.ts
index cd74816..62a76fa 100644
--- a/src/actions/mock.actions.ts
+++ b/src/actions/mock.actions.ts
@@ -2,6 +2,7 @@
import prisma from "@/lib/db";
import { handleError } from "@/lib/utils";
import { requireUser } from "./shared";
+import { createFirstStage } from "@/lib/jobs/createJobRecord";
import { generateMockActivities } from "@/lib/mock.utils";
import {
mockActivityTypes,
@@ -573,11 +574,18 @@ export const generateMockJobsAction = async (): Promise<any> => {
};
});
- const created = await prisma.job.createMany({ data: jobsData });
+ // A loop rather than createMany: createMany returns only a count, so it
+ // cannot feed createFirstStage the new ids. Dev-only, tens of rows.
+ let count = 0;
+ for (const data of jobsData) {
+ const job = await prisma.job.create({ data });
+ await createFirstStage(prisma, job.id, data.statusId, user.id, data.createdAt);
+ count += 1;
+ }
return {
success: true,
- message: `Generated ${created.count} mock jobs across the last 30 days.`,
+ message: `Generated ${count} mock jobs across the last 30 days.`,
};
} catch (error) {
return handleError(error, "Failed to generate mock jobs");
diff --git a/src/lib/jobs/createJobRecord.ts b/src/lib/jobs/createJobRecord.ts
index 04283ca..7d2f29c 100644
--- a/src/lib/jobs/createJobRecord.ts
+++ b/src/lib/jobs/createJobRecord.ts
@@ -1,4 +1,25 @@
import prisma from "@/lib/db";
+import { resolveStageTypeForStatusId } from "@/lib/jobs/resolve";
+
+type StageClient = {
+ jobStage: { create: (args: any) => Promise<any> };
+};
+
+// There is no single choke point for job creation: the scraper and the mock
+// generator write jobs directly. Each calls this so a job added after the
+// backfill is never left without the timeline a backfilled job has.
+export async function createFirstStage(
+ client: StageClient,
+ jobId: string,
+ statusId: string,
+ userId: string,
+ occurredAt: Date,
+): Promise<void> {
+ const stageTypeId = await resolveStageTypeForStatusId(statusId, userId);
+ await client.jobStage.create({
+ data: { jobId, stageTypeId, occurredAt, isCurrent: true },
+ });
+}
export async function createJobRecord(fields: {
jobTitleId: string;
@@ -22,11 +43,14 @@ export async function createJobRecord(fields: {
descriptionCompleteness?: string | null;
}) {
const { tagIds = [], ...rest } = fields;
- return prisma.job.create({
+ const createdAt = new Date();
+ const job = await prisma.job.create({
data: {
...rest,
- createdAt: new Date(),
+ createdAt,
...(tagIds.length > 0 ? { tags: { connect: tagIds.map((id) => ({ id })) } } : {}),
},
});
+ await createFirstStage(prisma, job.id, fields.statusId, fields.userId, createdAt);
+ return job;
}
diff --git a/src/lib/scraper/automation-run/persist.ts b/src/lib/scraper/automation-run/persist.ts
index 70a80ee..7fa93f6 100644
--- a/src/lib/scraper/automation-run/persist.ts
+++ b/src/lib/scraper/automation-run/persist.ts
@@ -3,6 +3,7 @@ import { APP_CONSTANTS } from "@/lib/constants";
import type { Automation, ScrapedJobData } from "@/models/automation.model";
import type { JobDetails } from "../types";
import { mapScrapedJobToJobRecord } from "../mapper";
+import { createFirstStage } from "@/lib/jobs/createJobRecord";
import { normalizeJobUrl } from "../utils";
import type { SkillTerm } from "./skillTags";
@@ -52,7 +53,14 @@ export async function persistDiscoveredJob(
});
try {
- await db.job.create({ data: jobRecord });
+ const created = await db.job.create({ data: jobRecord });
+ await createFirstStage(
+ db,
+ created.id,
+ jobRecord.statusId,
+ automation.userId,
+ jobRecord.createdAt,
+ );
return { saved: true, tagsApplied: jobRecord.tags?.connect.length ?? 0 };
} catch (err: any) {
if (err?.code === "P2002") return { saved: false, tagsApplied: 0 };
diff --git a/src/models/job.model.ts b/src/models/job.model.ts
index 4f06f28..8704112 100644
--- a/src/models/job.model.ts
+++ b/src/models/job.model.ts
@@ -1,6 +1,9 @@
import type { JobBoard, LeverHost } from "@/models/automation.model";
import { CoverLetter, Resume } from "./profile.model";
import type { JobContactLink } from "./contact.model";
+// Type-only: jobStage.model.ts imports Tag from here and has a runtime export,
+// so a value import back would make a real module cycle.
+import type { JobStage } from "./jobStage.model";
export interface JobForm {
id?: string;
@@ -57,6 +60,7 @@ export interface JobResponse {
matchData?: string | null;
tags?: Tag[];
contactLinks?: JobContactLink[];
+ stages?: JobStage[];
createdVia?: string | null;
discoveryStatus?: string | null;
descriptionCompleteness?: DescriptionCompleteness | null;