@hiai-gg/docsmint 0.4.2 → 0.4.4

package/dist/backend/index.js

@@ -198633,6 +198633,13 @@ var JOB_IDS = {
 init_names();
 var ACTIVE_STATUSES = ["pending", "processing", "retrying"];
 var postgresRunStore = {
+  async isCancelled(input) {
+    return withTenant({ userId: input.ownerId, role: "user", workspaceId: input.workspaceId }, async (tx) => {
+      const boundary = input.workspaceId ? eq(documentPipelineRuns.workspaceId, input.workspaceId) : and(isNull(documentPipelineRuns.workspaceId), eq(documentPipelineRuns.ownerId, input.ownerId));
+      const [run] = await tx.select({ status: documentPipelineRuns.status }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.generationId, input.generationId), boundary)).limit(1);
+      return run?.status === "cancelled";
+    });
+  },
   async findOrCreate(input) {
     const ownerBoundary = input.workspaceId ? eq(documents.workspaceId, input.workspaceId) : and(isNull(documents.workspaceId), eq(documents.ownerId, input.ownerId));
     const runBoundary = input.workspaceId ? eq(documentPipelineRuns.workspaceId, input.workspaceId) : and(isNull(documentPipelineRuns.workspaceId), eq(documentPipelineRuns.ownerId, input.ownerId));
@@ -198691,11 +198698,24 @@ async function enqueueDocumentPipeline(input, dependencies) {
       requestedAt: requestedAt.toISOString(),
       source: parsed.source
     };
-    await deps.prepareQueue.add("prepare", job2, {
+    const queued = await deps.prepareQueue.add("prepare", job2, {
       ...DEFAULT_JOB_OPTIONS,
       jobId: JOB_IDS.prepare(parsed.documentId, run.generationId, parsed.workspaceId),
       priority: SOURCE_PRIORITY[parsed.source]
     });
+    if (await deps.runs.isCancelled({
+      ownerId: parsed.ownerId,
+      generationId: run.generationId,
+      workspaceId: parsed.workspaceId
+    })) {
+      try {
+        await queued.remove();
+      } catch (error53) {
+        const message2 = error53 instanceof Error ? error53.message.toLowerCase() : "";
+        if (!message2.includes("locked") && !message2.includes("active") && !message2.includes("not found"))
+          throw error53;
+      }
+    }
   }
   return { generationId: run.generationId, deduplicated: !created };
 }
@@ -212786,6 +212806,9 @@ function profileId(profile) {
 }
 async function activateEmbeddingGeneration(documentId, generationId, expectedChunks, profile) {
   await withTenant(WORKER_TENANT, async (tx) => {
+    const run = await tx.select({ status: documentPipelineRuns.status }).from(documentPipelineRuns).where(eq(documentPipelineRuns.generationId, generationId)).limit(1).for("update");
+    if (run[0]?.status === "cancelled")
+      throw new Error("pipeline_cancelled");
     const documentRows = await tx.select({ pending: documents.pendingEmbeddingGeneration }).from(documents).where(eq(documents.id, documentId)).limit(1);
     if (documentRows[0]?.pending !== generationId) {
       throw new Error("generation_not_pending");
@@ -212823,6 +212846,18 @@ async function activateEmbeddingGeneration(documentId, generationId, expectedChu
 // ../../backend/src/queue/adapters.ts
 init_config();
 
+// ../../backend/src/lib/graph/delete-document-state.ts
+async function deleteDocumentGraphState(documentId) {
+  const sql6 = await getGraphDb();
+  if (!sql6)
+    return;
+  const literal2 = JSON.stringify(documentId);
+  await sql6.begin(async (tx) => {
+    await tx.unsafe("SET LOCAL search_path = ag_catalog, public");
+    await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ MATCH (d:Document {id: ${literal2}}) DETACH DELETE d RETURN 1 $$) AS (deleted agtype)`);
+  });
+}
+
 // ../../backend/src/lib/graph/extract-entities.ts
 init_zod();
 init_config();
@@ -213297,7 +213332,7 @@ async function setStageStatus(generationId, stage, status2, errorCode) {
     ...stagePatch(stage, status2),
     ...errorCode ? { errorCode } : {},
     updatedAt: new Date
-  }).where(eq(documentPipelineRuns.generationId, generationId)));
+  }).where(and(eq(documentPipelineRuns.generationId, generationId), ne(documentPipelineRuns.status, "cancelled"))));
 }
 async function markRunStale(generationId, stage, errorCode) {
   await withTenant(admin, (tx) => tx.update(documentPipelineRuns).set({
@@ -213305,12 +213340,15 @@ async function markRunStale(generationId, stage, errorCode) {
     status: "failed",
     errorCode,
     updatedAt: new Date
-  }).where(eq(documentPipelineRuns.generationId, generationId)));
+  }).where(and(eq(documentPipelineRuns.generationId, generationId), ne(documentPipelineRuns.status, "cancelled"))));
 }
 async function claimPendingBatches(job2, limit) {
   return withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => {
-    const [run] = await tx.select({ totalBatches: documentPipelineRuns.totalBatches }).from(documentPipelineRuns).where(eq(documentPipelineRuns.generationId, job2.generationId)).limit(1);
-    if (!run || limit < 1)
+    const [run] = await tx.select({
+      totalBatches: documentPipelineRuns.totalBatches,
+      status: documentPipelineRuns.status
+    }).from(documentPipelineRuns).where(eq(documentPipelineRuns.generationId, job2.generationId)).limit(1);
+    if (!run || run.status === "cancelled" || limit < 1)
       return [];
     const candidates = await tx.select({
       batchIndex: documentPipelineBatches.batchIndex,
@@ -213340,8 +213378,24 @@ async function claimPendingBatches(job2, limit) {
 }
 function createPipelineStageDependencies(redisUrl) {
   const queue2 = (stage) => getPipelineQueue(stage, redisUrl);
+  const enqueueIfActive = async (stage, name, data, options) => {
+    if ((await getRun(data.generationId))?.status === "cancelled")
+      return null;
+    const queued = await queue2(stage).add(name, data, options);
+    if ((await getRun(data.generationId))?.status !== "cancelled")
+      return queued;
+    try {
+      await queued.remove();
+    } catch (error53) {
+      const message2 = error53 instanceof Error ? error53.message.toLowerCase() : "";
+      if (!message2.includes("locked") && !message2.includes("active") && !message2.includes("not found"))
+        throw error53;
+    }
+    return null;
+  };
   return {
     prepare: {
+      isCancelled: async (job2) => (await getRun(job2.generationId))?.status === "cancelled",
       claimPendingBatches,
       markStale: (job2, errorCode) => markRunStale(job2.generationId, "prepare", errorCode),
       async loadDocument({ documentId, ownerId, workspaceId }) {
@@ -213365,11 +213419,13 @@ function createPipelineStageDependencies(redisUrl) {
           if ((batches.at(-1)?.chunkEnd ?? 0) !== totalChunks) {
             return "stale";
           }
-          const [run] = await tx.select({ status: documentPipelineRuns.prepareStatus }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.generationId, job2.generationId), tenantOwnerCondition(documentPipelineRuns.ownerId, documentPipelineRuns.workspaceId, jobTenant(job2)), eq(documentPipelineRuns.revision, job2.revision))).limit(1);
+          const [run] = await tx.select({ status: documentPipelineRuns.prepareStatus }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.generationId, job2.generationId), tenantOwnerCondition(documentPipelineRuns.ownerId, documentPipelineRuns.workspaceId, jobTenant(job2)), eq(documentPipelineRuns.revision, job2.revision))).limit(1).for("update");
           if (!run)
             return "stale";
           if (run.status === "ready")
             return "duplicate";
+          if (run.status === "cancelled")
+            return "stale";
           await tx.update(documents).set({
             pendingEmbeddingGeneration: job2.generationId,
             embeddingStatus: "processing",
@@ -213391,12 +213447,15 @@ function createPipelineStageDependencies(redisUrl) {
             status: "processing",
             totalBatches: batches.length,
             updatedAt: new Date
-          }).where(eq(documentPipelineRuns.generationId, job2.generationId));
+          }).where(and(eq(documentPipelineRuns.generationId, job2.generationId), ne(documentPipelineRuns.status, "cancelled")));
           return "prepared";
         });
       },
       async completeEmpty(job2) {
         await withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => {
+          const [run] = await tx.select({ status: documentPipelineRuns.status }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.generationId, job2.generationId), eq(documentPipelineRuns.ownerId, job2.ownerId))).limit(1).for("update");
+          if (!run || run.status === "cancelled")
+            return;
           const activated = await tx.update(documents).set({
             activeEmbeddingGeneration: job2.generationId,
             pendingEmbeddingGeneration: null,
@@ -213416,16 +213475,17 @@ function createPipelineStageDependencies(redisUrl) {
         });
       },
       enqueueEmbed(data, options) {
-        return queue2("embed").add("embed", data, options);
+        return enqueueIfActive("embed", "embed", data, options);
       },
       enqueueGraph(data, options) {
-        return queue2("graph").add("graph", data, options);
+        return enqueueIfActive("graph", "graph", data, options);
       }
     },
     embed: {
+      isCancelled: async (job2) => (await getRun(job2.generationId))?.status === "cancelled",
       claimPendingBatches,
       enqueueEmbed(data, options) {
-        return queue2("embed").add("embed", data, options);
+        return enqueueIfActive("embed", "embed", data, options);
       },
       markStale: (job2, errorCode) => markRunStale(job2.generationId, "embed", errorCode),
       async loadDocument({ documentId, ownerId, generationId, workspaceId }) {
@@ -213449,8 +213509,9 @@ function createPipelineStageDependencies(redisUrl) {
       getEmbedding: (text4) => withProviderPermit(providerProfile(`embedding:${config3.EMBEDDING_MODEL ?? "default"}`), "embed", () => getEmbedding(text4)),
       async storeBatch({ job: job2, rows }) {
         return withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => {
+          const [run] = await tx.select({ status: documentPipelineRuns.status }).from(documentPipelineRuns).where(eq(documentPipelineRuns.generationId, job2.generationId)).limit(1).for("update");
           const [batch] = await tx.select({ status: documentPipelineBatches.status }).from(documentPipelineBatches).where(and(eq(documentPipelineBatches.generationId, job2.generationId), eq(documentPipelineBatches.batchIndex, job2.batchIndex))).limit(1);
-          if (!batch)
+          if (!batch || run?.status === "cancelled")
             return "stale";
           if (batch.status === "ready")
             return "duplicate";
@@ -213474,6 +213535,9 @@ function createPipelineStageDependencies(redisUrl) {
       },
       async completeBatch({ job: job2, profile }) {
         return withTenant(admin, async (tx) => {
+          const [run] = await tx.select({ status: documentPipelineRuns.status }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.generationId, job2.generationId), eq(documentPipelineRuns.ownerId, job2.ownerId))).limit(1).for("update");
+          if (!run || run.status === "cancelled")
+            return { allBatchesComplete: false, totalChunks: 0 };
           await tx.update(documentPipelineBatches).set({
             status: "ready",
             embeddingProfile: profile.profile,
@@ -213489,7 +213553,7 @@ function createPipelineStageDependencies(redisUrl) {
             completedBatches: counts?.ready ?? 0,
             embedStatus: (counts?.ready ?? 0) === (counts?.total ?? -1) ? "ready" : "processing",
             updatedAt: new Date
-          }).where(eq(documentPipelineRuns.generationId, job2.generationId));
+          }).where(and(eq(documentPipelineRuns.generationId, job2.generationId), ne(documentPipelineRuns.status, "cancelled")));
           return {
             allBatchesComplete: (counts?.total ?? 0) > 0 && counts?.ready === counts?.total,
             totalChunks: chunks?.total ?? 0
@@ -213501,10 +213565,11 @@ function createPipelineStageDependencies(redisUrl) {
         await setStageStatus(input.generationId, "embed", "ready");
       },
       enqueueGraph(data, options) {
-        return queue2("graph").add("graph", data, options);
+        return enqueueIfActive("graph", "graph", data, options);
       }
     },
     graph: {
+      isCancelled: async (job2) => (await getRun(job2.generationId))?.status === "cancelled",
       async getRun(job2) {
         const run = await getRun(job2.generationId);
         return run ? {
@@ -213524,10 +213589,15 @@ function createPipelineStageDependencies(redisUrl) {
           throw new Error("Pipeline document not found");
         await withProviderPermit(providerProfile(`graph:${config3.GRAPH_EXTRACT_MODEL ?? "default"}`), "graph", () => extractEntities(doc3.content ?? "", job2.documentId));
       },
+      async compensateExtract(job2) {
+        const owned = await withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => tx.select({ id: documents.id }).from(documents).where(and(eq(documents.id, job2.documentId), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1));
+        if (owned.length === 1)
+          await deleteDocumentGraphState(job2.documentId);
+      },
       setGraphStatus: (generationId, status2, errorCode) => setStageStatus(generationId, "graph", status2, errorCode),
       async enqueueSummarize(job2) {
         const data = { ...job2, stage: "summarize" };
-        await queue2("summarize").add("summarize", data, {
+        await enqueueIfActive("summarize", "summarize", data, {
           ...DEFAULT_JOB_OPTIONS,
           jobId: JOB_IDS.summarize(job2.generationId, job2.workspaceId),
           priority: SOURCE_PRIORITY[job2.source]
@@ -213535,6 +213605,7 @@ function createPipelineStageDependencies(redisUrl) {
       }
     },
     summarize: {
+      isCancelled: async (job2) => (await getRun(job2.generationId))?.status === "cancelled",
       async getRun(job2) {
         const run = await getRun(job2.generationId);
         return run ? {
@@ -213550,7 +213621,7 @@ function createPipelineStageDependencies(redisUrl) {
       setSummaryStatus: (generationId, status2, errorCode) => setStageStatus(generationId, "summarize", status2, errorCode),
       async enqueueFinalize(job2) {
         const data = { ...job2, stage: "finalize" };
-        await queue2("finalize").add("finalize", data, {
+        await enqueueIfActive("finalize", "finalize", data, {
           ...DEFAULT_JOB_OPTIONS,
           jobId: JOB_IDS.finalize(job2.generationId, job2.workspaceId),
           priority: SOURCE_PRIORITY[job2.source]
@@ -213578,7 +213649,7 @@ function createPipelineStageDependencies(redisUrl) {
           ...errorCode ? { errorCode } : {},
           completedAt: new Date,
           updatedAt: new Date
-        }).where(eq(documentPipelineRuns.generationId, generationId)));
+        }).where(and(eq(documentPipelineRuns.generationId, generationId), ne(documentPipelineRuns.status, "cancelled"))));
       }
     }
   };
@@ -213837,6 +213908,8 @@ init_esm();
 init_names();
 async function processEmbedJob(rawJob, deps) {
   const job2 = embedBatchJobSchema.parse(rawJob.data);
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", activated: false };
   const document2 = await deps.loadDocument(job2);
   if (!document2 || document2.revision !== job2.revision || document2.pendingGenerationId !== job2.generationId) {
     await deps.markStale(job2, "stale_revision");
@@ -213866,6 +213939,8 @@ ${document2.content}`);
     throw new Error("empty_batch");
   if (results.some(({ result }) => result.model !== first.model || result.profile !== first.profile || result.dimensions !== first.dimensions))
     throw new Error("mixed_embedding_profile");
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", activated: false };
   const stored = await deps.storeBatch({
     job: job2,
     rows: results.map(({ index: index2, chunk, result }) => ({
@@ -213889,9 +213964,13 @@ ${document2.content}`);
     profile: first.profile,
     dimensions: first.dimensions
   };
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", activated: false };
   const completion = await deps.completeBatch({ job: job2, profile });
   if (!completion.allBatchesComplete) {
     const next = await deps.claimPendingBatches(job2, 1);
+    if (await deps.isCancelled?.(job2))
+      return { status: "cancelled", activated: false };
     await Promise.all(next.map((data) => deps.enqueueEmbed(data, {
       ...DEFAULT_JOB_OPTIONS,
       jobId: JOB_IDS.embed(job2.generationId, data.batchIndex, job2.workspaceId),
@@ -213899,12 +213978,16 @@ ${document2.content}`);
     })));
     return { status: "stored", activated: false };
   }
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", activated: false };
   await deps.activateGeneration({
     documentId: job2.documentId,
     generationId: job2.generationId,
     totalChunks: completion.totalChunks,
     profile
   });
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", activated: false };
   await deps.enqueueGraph({ ...job2, stage: "graph" }, {
     ...DEFAULT_JOB_OPTIONS,
     jobId: JOB_IDS.graph(job2.generationId, job2.workspaceId),
@@ -213958,6 +214041,8 @@ function createFinalizeWorker(deps) {
 function createGraphWorker(deps) {
   return async function processGraphJob(input) {
     const job2 = graphJobSchema.parse(input);
+    if (await deps.isCancelled?.(job2))
+      return;
     const run = await deps.getRun(job2);
     if (!run)
       throw new Error("Pipeline run not found");
@@ -213969,18 +214054,33 @@ function createGraphWorker(deps) {
       return;
     }
     if (run.embedStatus !== "ready") {
+      if (await deps.isCancelled?.(job2))
+        return;
       await deps.setGraphStatus(job2.generationId, "skipped", "embedding_not_ready");
-      await deps.enqueueSummarize(job2);
+      if (!await deps.isCancelled?.(job2))
+        await deps.enqueueSummarize(job2);
       return;
     }
+    if (await deps.isCancelled?.(job2))
+      return;
     await deps.setGraphStatus(job2.generationId, "processing");
     try {
+      if (await deps.isCancelled?.(job2))
+        return;
       await deps.extract(job2);
+      if (await deps.isCancelled?.(job2)) {
+        await deps.compensateExtract?.(job2);
+        return;
+      }
       await deps.setGraphStatus(job2.generationId, "ready");
-      await deps.enqueueSummarize(job2);
+      if (!await deps.isCancelled?.(job2))
+        await deps.enqueueSummarize(job2);
     } catch (error53) {
+      if (await deps.isCancelled?.(job2))
+        throw error53;
       await deps.setGraphStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "graph_failed");
-      await deps.enqueueSummarize(job2);
+      if (!await deps.isCancelled?.(job2))
+        await deps.enqueueSummarize(job2);
       throw error53;
     }
   };
@@ -213991,6 +214091,8 @@ init_esm();
 init_names();
 async function processPrepareJob(rawJob, deps, batchSize = DEFAULT_EMBED_CHUNKS_PER_JOB, maxActiveBatches = 2) {
   const job2 = prepareJobSchema.parse(rawJob.data);
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", batches: 0 };
   const document2 = await deps.loadDocument(job2);
   if (!document2 || document2.revision !== job2.revision) {
     await deps.markStale(job2, "stale_revision");
@@ -214004,6 +214106,8 @@ ${document2.content}`);
     chunkStart: batchIndex * batchSize,
     chunkEnd: Math.min(chunks.length, (batchIndex + 1) * batchSize)
   }));
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", batches: 0 };
   const state = await deps.prepareRun({
     job: job2,
     totalChunks: chunks.length,
@@ -214015,7 +214119,11 @@ ${document2.content}`);
     return { status: state, batches: batches.length };
   }
   if (batches.length === 0) {
+    if (await deps.isCancelled?.(job2))
+      return { status: "cancelled", batches: 0 };
     await deps.completeEmpty(job2);
+    if (await deps.isCancelled?.(job2))
+      return { status: "cancelled", batches: 0 };
     await deps.enqueueGraph({ ...job2, stage: "graph" }, {
       ...DEFAULT_JOB_OPTIONS,
       jobId: JOB_IDS.graph(job2.generationId, job2.workspaceId),
@@ -214024,6 +214132,8 @@ ${document2.content}`);
     return { status: "prepared", batches: 0 };
   }
   const initial = await deps.claimPendingBatches(job2, maxActiveBatches);
+  if (await deps.isCancelled?.(job2))
+    return { status: "cancelled", batches: batches.length };
   await Promise.all(initial.map((data) => deps.enqueueEmbed(data, {
     ...DEFAULT_JOB_OPTIONS,
     jobId: JOB_IDS.embed(job2.generationId, data.batchIndex, data.workspaceId),
@@ -214042,6 +214152,8 @@ function createPrepareWorker(redisUrl, deps, options = {}) {
 function createSummarizeWorker(deps) {
   return async function processSummarizeJob(input) {
     const job2 = summarizeJobSchema.parse(input);
+    if (await deps.isCancelled?.(job2))
+      return;
     const run = await deps.getRun(job2);
     if (!run)
       throw new Error("Pipeline run not found");
@@ -214053,19 +214165,31 @@ function createSummarizeWorker(deps) {
       return;
     }
     if (!deps.enabled()) {
+      if (await deps.isCancelled?.(job2))
+        return;
       await deps.setSummaryStatus(job2.generationId, "skipped");
-      await deps.enqueueFinalize(job2);
+      if (!await deps.isCancelled?.(job2))
+        await deps.enqueueFinalize(job2);
       return;
     }
+    if (await deps.isCancelled?.(job2))
+      return;
     await deps.setSummaryStatus(job2.generationId, "processing");
     try {
+      if (await deps.isCancelled?.(job2))
+        return;
       await deps.summarize(job2);
+      if (await deps.isCancelled?.(job2))
+        return;
       await deps.setSummaryStatus(job2.generationId, "ready");
     } catch (error53) {
+      if (await deps.isCancelled?.(job2))
+        return;
       await deps.setSummaryStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "summary_failed");
       throw error53;
     }
-    await deps.enqueueFinalize(job2);
+    if (!await deps.isCancelled?.(job2))
+      await deps.enqueueFinalize(job2);
   };
 }
 
@@ -214237,7 +214361,7 @@ var swaggerConfig = {
   documentation: {
     info: {
       title: "DocsMint API",
-      version: "0.4.2",
+      version: "0.4.4",
       description: "Self-hosted AI-first documentation platform. Full-text + semantic search, version history, sharing, and folder organization.",
       contact: { name: "HiAi-gg", url: "https://github.com/HiAi-gg/docsmint" },
       license: {

package/dist/backend-pipeline-cancellation.d.ts

@@ -0,0 +1,11 @@
+export type AccountPipelineCancellation = Readonly<{
+    cancelActorPipeline(actorUserId: string, signal?: AbortSignal): Promise<{
+        runs: number;
+        jobs: number;
+    }>;
+    close(): Promise<void>;
+}>;
+export declare function createAccountPipelineCancellation(options: {
+    redisUrl: string;
+    databaseUrl: string;
+}): AccountPipelineCancellation;