thinkwork-cli 0.13.1 → 1.0.0

package/dist/plugins/twenty/scripts/lambda-handler.ts

@@ -0,0 +1,49 @@
+/**
+ * AWS Lambda entry point for the nightly LastMile → Twenty sync.
+ *
+ * Invoked by n8n (Schedule → AWS Lambda) in TEI's account, where the function
+ * can reach both the LastMile RDS and crm.tei.thinkwork.ai. Reads the same
+ * three env vars as the CLI and runs an APPLY (delta re-sync) by default; pass
+ * `{"mode":"dry-run"}` to read + report without writing. Returns the parity
+ * report so n8n can log it or branch on failures.
+ *
+ * The sync is idempotent (upsert by sourceId + deletion mirror), reads LastMile
+ * read-only, never provisions members, and needs no AWS credentials. Runtime is
+ * ~90s against TEI's current data — set the Lambda timeout to 300s for headroom.
+ *
+ * Build the deployment zip with scripts/build-lambda.sh; deploy per
+ * scripts/LAMBDA_DEPLOY.md. Handler string: `index.handler`.
+ */
+import { executeMigration } from "./migrate-lastmile";
+
+interface SyncEvent {
+  mode?: "apply" | "dry-run";
+}
+
+interface EntityFailures {
+  failed?: number;
+}
+
+function totalFailed(report: Record<string, unknown>): number {
+  let failed = 0;
+  for (const value of Object.values(report)) {
+    if (value && typeof value === "object" && "failed" in value) {
+      const n = (value as EntityFailures).failed;
+      if (typeof n === "number") failed += n;
+    }
+  }
+  return failed;
+}
+
+export async function handler(
+  event: SyncEvent | null,
+): Promise<{ ok: boolean; failed: number; report: Record<string, unknown> }> {
+  // Default to apply — the whole point of the scheduled invocation. A hard
+  // failure (DB unreachable, sourceId abort) throws and fails the invocation;
+  // per-record soft failures surface via `failed` so n8n can alert without the
+  // run being considered a crash.
+  const apply = event?.mode !== "dry-run";
+  const report = await executeMigration({ apply });
+  const failed = totalFailed(report);
+  return { ok: failed === 0, failed, report };
+}

package/dist/plugins/twenty/scripts/lib/__tests__/load-attachments.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+
+import { isUploadUnsupported } from "../load-attachments";
+import { TwentyGraphqlError } from "../twenty-client";
+
+describe("isUploadUnsupported", () => {
+  it("recognizes the missing Upload scalar and uploadFile mutation", () => {
+    expect(
+      isUploadUnsupported(
+        new TwentyGraphqlError("x", {
+          errors: [{ message: 'Unknown type "Upload". Did you mean "Float"?' }],
+        }),
+      ),
+    ).toBe(true);
+    expect(
+      isUploadUnsupported(
+        new TwentyGraphqlError("x", {
+          errors: [
+            { message: 'Cannot query field "uploadFile" on type "Mutation".' },
+          ],
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it("does not swallow a genuine upload failure", () => {
+    // A real 500 or a missing binary must still count as a failure, so the run
+    // exits non-zero and someone looks at it.
+    expect(
+      isUploadUnsupported(
+        new TwentyGraphqlError("x", {
+          errors: [{ message: "Internal server error" }],
+        }),
+      ),
+    ).toBe(false);
+    expect(isUploadUnsupported(new Error("connect ETIMEDOUT"))).toBe(false);
+  });
+});

package/dist/plugins/twenty/scripts/lib/__tests__/load-records.test.ts

@@ -3,12 +3,14 @@ import { describe, expect, it, vi } from "vitest";
 import {
   COMPANY,
   emptyCounters,
+  isMissingSourceIdFieldError,
   mirrorDeletions,
+  upsertNotes,
   upsertRecords,
 } from "../load-records";
 import { contentHash } from "../mappers";
-import type { MappedRecord } from "../mappers";
-import type { TwentyClient } from "../twenty-client";
+import type { MappedNote, MappedRecord } from "../mappers";
+import { TwentyGraphqlError, type TwentyClient } from "../twenty-client";
 
 function mapped(
   sourceId: string,
@@ -230,3 +232,144 @@ describe("mirrorDeletions (AE2 / KTD7)", () => {
     ]);
   });
 });
+
+describe("isMissingSourceIdFieldError", () => {
+  const gqlError = (message: string) =>
+    new TwentyGraphqlError("wrapped", { errors: [{ message }] });
+
+  it("recognizes a not-yet-created sourceId field", () => {
+    expect(
+      isMissingSourceIdFieldError(
+        gqlError('Object company doesn\'t have any "sourceId" field.'),
+      ),
+    ).toBe(true);
+  });
+
+  it("recognizes a not-yet-created custom object", () => {
+    expect(
+      isMissingSourceIdFieldError(
+        gqlError('Unknown type "OrganizationFilterInput".'),
+      ),
+    ).toBe(true);
+    expect(
+      isMissingSourceIdFieldError(
+        gqlError('Cannot query field "organizations" on type "Query".'),
+      ),
+    ).toBe(true);
+  });
+
+  it("does not swallow unrelated errors", () => {
+    expect(isMissingSourceIdFieldError(gqlError("Rate limit reached"))).toBe(
+      false,
+    );
+    expect(isMissingSourceIdFieldError(new Error("boom"))).toBe(false);
+  });
+});
+
+describe("upsertNotes batches the NoteTarget existence check (perf)", () => {
+  function note(sourceId: string): MappedNote {
+    return {
+      sourceId,
+      title: sourceId,
+      bodyMarkdown: sourceId,
+      targetSourceId: "opportunity:o1",
+      targetKind: "opportunity",
+      isDeleted: false,
+      createdAt: null,
+      authorName: null,
+    };
+  }
+
+  // A note whose id appears here already has a NoteTarget in Twenty.
+  function noteClient(pairedNoteIds: string[]): {
+    client: TwentyClient;
+    lookups: number;
+    createdTargets: Array<Record<string, unknown>>;
+  } {
+    const state = {
+      lookups: 0,
+      createdTargets: [] as Record<string, unknown>[],
+    };
+    const client = {
+      requestWithRetry: vi.fn(
+        async (
+          _path: string,
+          query: string,
+          variables: { filter?: { noteId?: { in?: string[] } } },
+        ) => {
+          if (query.includes("MigrationNoteTargets")) {
+            state.lookups += 1;
+            const ids = variables.filter?.noteId?.in ?? [];
+            return {
+              noteTargets: {
+                edges: ids
+                  .filter((id) => pairedNoteIds.includes(id))
+                  .map((id) => ({ node: { noteId: id } })),
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            };
+          }
+          // Note sourceId existence lookups → nothing exists yet (force create).
+          return { notes: { edges: [] } };
+        },
+      ),
+      requestOnce: vi.fn(
+        async (
+          _path: string,
+          query: string,
+          variables: { data: Array<Record<string, unknown>> },
+        ) => {
+          if (query.includes("createNotes")) {
+            return {
+              createNotes: variables.data.map((row) => ({
+                id: `note-${row.sourceId as string}`,
+                sourceId: row.sourceId,
+              })),
+            };
+          }
+          if (query.includes("createNoteTargets")) {
+            state.createdTargets.push(...variables.data);
+            return {
+              createNoteTargets: variables.data.map((_, i) => ({
+                id: `nt-${i}`,
+              })),
+            };
+          }
+          return { ok: true };
+        },
+      ),
+    } as unknown as TwentyClient;
+    return { client, ...state };
+  }
+
+  it("issues one lookup for many notes and only creates the missing targets", async () => {
+    const notes = [note("task_comment:c1"), note("task_comment:c2")];
+    // c1 already has its target; c2 does not.
+    const harness = noteClient(["note-task_comment:c1"]);
+    const counters = emptyCounters();
+
+    await upsertNotes({
+      client: harness.client,
+      notes,
+      targetIdBySourceId: new Map([["opportunity:o1", "opp1"]]),
+      dryRun: false,
+      counters,
+    });
+
+    // Batched: a single noteTargets query covers both notes (was one per note).
+    const lookupCalls = (
+      harness.client.requestWithRetry as unknown as {
+        mock: { calls: unknown[] };
+      }
+    ).mock.calls.filter((c) =>
+      String((c as unknown[])[1]).includes("MigrationNoteTargets"),
+    ).length;
+    expect(lookupCalls).toBe(1);
+
+    // Only the unpaired note gets a target, and it carries the opportunity FK.
+    expect(harness.createdTargets).toEqual([
+      { noteId: "note-task_comment:c2", targetOpportunityId: "opp1" },
+    ]);
+    expect(counters.failed).toBe(0);
+  });
+});