thinkwork-cli 0.12.15 → 0.12.17

package/dist/plugins/twenty/scripts/lib/__tests__/provision-members-db.test.ts

@@ -0,0 +1,43 @@
+import bcrypt from "bcryptjs";
+import { describe, expect, it } from "vitest";
+
+import { hashPassword, quoteIdent } from "../provision-members-db";
+
+describe("hashPassword", () => {
+  it("emits the $2b$ prefix Twenty's own signup writes", () => {
+    const hash = hashPassword("TestPassword1!", 4);
+    expect(hash.startsWith("$2b$")).toBe(true);
+    expect(hash).toHaveLength(60);
+  });
+
+  it("produces a hash the password verifies against, and nothing else does", () => {
+    const hash = hashPassword("TestPassword1!", 4);
+    expect(bcrypt.compareSync("TestPassword1!", hash)).toBe(true);
+    expect(bcrypt.compareSync("TestPassword1", hash)).toBe(false);
+  });
+
+  it("handles the shell-hostile characters in the shared rep password", () => {
+    const hash = hashPassword("Abc123$$", 4);
+    expect(bcrypt.compareSync("Abc123$$", hash)).toBe(true);
+  });
+
+  it("refuses passwords past bcrypt's silent 72-byte truncation point", () => {
+    expect(() => hashPassword("x".repeat(73), 4)).toThrow(/72-byte/);
+  });
+});
+
+describe("quoteIdent", () => {
+  it("accepts a Twenty workspace data schema", () => {
+    expect(quoteIdent("workspace_brl3ypdat40udm5gtn95sozcg")).toBe(
+      '"workspace_brl3ypdat40udm5gtn95sozcg"',
+    );
+  });
+
+  it("refuses anything that is not a workspace schema", () => {
+    expect(() => quoteIdent("core")).toThrow(/Refusing/);
+    expect(() =>
+      quoteIdent('workspace_x"; drop table core."user"; --'),
+    ).toThrow(/Refusing/);
+    expect(() => quoteIdent("public")).toThrow(/Refusing/);
+  });
+});

package/dist/plugins/twenty/scripts/lib/__tests__/schema-ensure.test.ts

@@ -0,0 +1,230 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  applySchemaEnsure,
+  FIELD_SPECS,
+  PENDING_OBJECT_ID,
+  planSchemaEnsure,
+} from "../schema-ensure";
+import { MIGRATION_STAGE_OPTIONS } from "../mappers";
+import type { TwentyClient } from "../twenty-client";
+
+const EXISTING_STAGE_OPTIONS = [
+  { id: "id-new", label: "New", value: "NEW", color: "red", position: 0 },
+  {
+    id: "id-cust",
+    label: "Customer",
+    value: "CUSTOMER",
+    color: "yellow",
+    position: 1,
+  },
+];
+
+interface FieldFixture {
+  id: string;
+  name: string;
+  type: string;
+  options: typeof EXISTING_STAGE_OPTIONS | null;
+}
+
+function objectsFixture(
+  fieldsByObject: Record<string, FieldFixture[]>,
+): Map<
+  string,
+  { id: string; nameSingular: string; fields: Map<string, FieldFixture> }
+> {
+  const map = new Map<
+    string,
+    { id: string; nameSingular: string; fields: Map<string, FieldFixture> }
+  >();
+  for (const [name, fields] of Object.entries(fieldsByObject)) {
+    map.set(name, {
+      id: `obj-${name}`,
+      nameSingular: name,
+      fields: new Map(fields.map((field) => [field.name, field])),
+    });
+  }
+  return map;
+}
+
+const stageField: FieldFixture = {
+  id: "field-stage",
+  name: "stage",
+  type: "SELECT",
+  options: EXISTING_STAGE_OPTIONS,
+};
+
+function bareObjects() {
+  return objectsFixture({
+    company: [],
+    person: [],
+    opportunity: [stageField],
+    note: [],
+    attachment: [],
+    // The product-line object exists (ensureOpportunityProductObject ran) but
+    // has none of its fields yet.
+    opportunityProduct: [],
+  });
+}
+
+/** A workspace that has never seen the product-line object at all. */
+function objectsWithoutProductObject() {
+  return objectsFixture({
+    company: [],
+    person: [],
+    opportunity: [stageField],
+    note: [],
+    attachment: [],
+  });
+}
+
+function provisionedObjects() {
+  const withAll = (object: string): FieldFixture[] =>
+    FIELD_SPECS.filter((spec) => spec.object === object).map((spec, index) => ({
+      id: `f-${object}-${index}`,
+      name: spec.name,
+      type: spec.type,
+      options: null,
+    }));
+  const opportunityFields = [
+    ...withAll("opportunity"),
+    {
+      ...stageField,
+      options: [
+        ...EXISTING_STAGE_OPTIONS,
+        ...MIGRATION_STAGE_OPTIONS.map((option, index) => ({
+          id: `id-${option.value}`,
+          ...option,
+          position: EXISTING_STAGE_OPTIONS.length + index,
+        })),
+      ],
+    },
+  ];
+  return objectsFixture({
+    company: withAll("company"),
+    person: withAll("person"),
+    opportunity: opportunityFields,
+    note: withAll("note"),
+    attachment: withAll("attachment"),
+    opportunityProduct: [
+      ...withAll("opportunityProduct"),
+      {
+        id: "f-op-rel",
+        name: "opportunity",
+        type: "RELATION",
+        options: null,
+      },
+    ],
+  });
+}
+
+describe("planSchemaEnsure", () => {
+  it("plans every missing field and all stage options on an empty workspace", () => {
+    const plan = planSchemaEnsure(bareObjects());
+    expect(plan.createFields).toHaveLength(FIELD_SPECS.length);
+    expect(plan.stageOptionsToAdd).toEqual(
+      MIGRATION_STAGE_OPTIONS.map((option) => option.value),
+    );
+    // Full-replace semantics (U1): the merged array keeps existing options first.
+    expect(
+      plan.mergedStageOptions?.slice(0, 2).map((option) => option.value),
+    ).toEqual(["NEW", "CUSTOMER"]);
+    expect(plan.mergedStageOptions).toHaveLength(
+      EXISTING_STAGE_OPTIONS.length + MIGRATION_STAGE_OPTIONS.length,
+    );
+  });
+
+  it("is a no-op against already-provisioned metadata (idempotent)", () => {
+    const plan = planSchemaEnsure(provisionedObjects());
+    expect(plan.createFields).toHaveLength(0);
+    expect(plan.stageOptionsToAdd).toEqual([]);
+    expect(plan.mergedStageOptions).toBeNull();
+  });
+
+  it("creates only the gap on partial presence", () => {
+    const objects = bareObjects();
+    objects.get("opportunity")!.fields.set("product", {
+      id: "f-product",
+      name: "product",
+      type: "TEXT",
+      options: null,
+    });
+    const plan = planSchemaEnsure(objects);
+    const names = plan.createFields.map(
+      (field) => `${field.object}.${field.name}`,
+    );
+    expect(names).not.toContain("opportunity.product");
+    expect(names).toContain("opportunity.quantity");
+  });
+
+  it("aborts when the stage field is missing", () => {
+    const objects = objectsFixture({
+      company: [],
+      person: [],
+      opportunity: [],
+      note: [],
+      attachment: [],
+      opportunityProduct: [],
+    });
+    expect(() => planSchemaEnsure(objects)).toThrow(/stage field/);
+  });
+
+  it("plans product-line fields against a pending object id when it does not exist yet", () => {
+    const plan = planSchemaEnsure(objectsWithoutProductObject());
+    const productFields = plan.createFields.filter(
+      (field) => field.object === "opportunityProduct",
+    );
+    expect(productFields.length).toBeGreaterThan(0);
+    expect(
+      productFields.every(
+        (field) => field.objectMetadataId === PENDING_OBJECT_ID,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("applySchemaEnsure", () => {
+  it("issues createOneField per missing field and one full-replace options write", async () => {
+    const requestOnce = vi.fn(async () => ({}));
+    const client = { requestOnce } as unknown as TwentyClient;
+    const plan = planSchemaEnsure(bareObjects());
+    const result = await applySchemaEnsure(client, plan);
+    expect(result.createdFields).toHaveLength(FIELD_SPECS.length);
+    // one createOneField call per field + one updateOneField for stage options
+    expect(requestOnce).toHaveBeenCalledTimes(FIELD_SPECS.length + 1);
+    const lastCall = requestOnce.mock.calls.at(-1) as unknown as [
+      string,
+      string,
+      { input: { update: { options: Array<{ value: string }> } } },
+    ];
+    expect(
+      lastCall[2].input.update.options.map((option) => option.value),
+    ).toContain("CUSTOMER");
+    expect(
+      lastCall[2].input.update.options.map((option) => option.value),
+    ).toContain("LEAD");
+  });
+
+  it("refuses to create a field against a pending object id", async () => {
+    // Guards the ordering bug: fields must be planned only after
+    // ensureOpportunityProductObject has created the object.
+    const requestOnce = vi.fn(async () => ({}));
+    const client = { requestOnce } as unknown as TwentyClient;
+    const plan = planSchemaEnsure(objectsWithoutProductObject());
+    await expect(applySchemaEnsure(client, plan)).rejects.toThrow(
+      /planned against an uncreated object/,
+    );
+  });
+
+  it("aborts on the first metadata mutation error", async () => {
+    const requestOnce = vi.fn(async () => {
+      throw new Error("metadata boom");
+    });
+    const client = { requestOnce } as unknown as TwentyClient;
+    const plan = planSchemaEnsure(bareObjects());
+    await expect(applySchemaEnsure(client, plan)).rejects.toThrow(
+      /metadata boom/,
+    );
+    expect(requestOnce).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,207 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  BATCH_LIMIT,
+  chunk,
+  normalizeBaseUrl,
+  TwentyClient,
+  TwentyGraphqlError,
+} from "../twenty-client";
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("normalizeBaseUrl", () => {
+  it("resolves the endpoint from TWENTY_PUBLIC_URL plus path", () => {
+    const client = new TwentyClient({
+      baseUrl: "https://crm.tei.thinkwork.ai/",
+      authToken: "key",
+    });
+    expect(client.endpoint("/graphql")).toBe(
+      "https://crm.tei.thinkwork.ai/graphql",
+    );
+    expect(client.endpoint("/metadata")).toBe(
+      "https://crm.tei.thinkwork.ai/metadata",
+    );
+  });
+
+  it("rejects non-HTTPS URLs", () => {
+    expect(() => normalizeBaseUrl("http://crm.tei.thinkwork.ai")).toThrow(
+      /HTTPS/,
+    );
+  });
+});
+
+describe("chunk", () => {
+  it("splits 130 records into 3 chunks at the batch limit", () => {
+    const chunks = chunk(
+      Array.from({ length: 130 }, (_, index) => index),
+      BATCH_LIMIT,
+    );
+    expect(chunks.map((c) => c.length)).toEqual([60, 60, 10]);
+  });
+
+  it("rejects a chunk size below 1", () => {
+    expect(() => chunk([1], 0)).toThrow(/>= 1/);
+  });
+});
+
+describe("TwentyClient.requestOnce", () => {
+  it("throws with the message when GraphQL returns errors[]", async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({ errors: [{ message: "Field boom is required" }] }),
+    );
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    await expect(client.requestOnce("/graphql", "query { x }")).rejects.toThrow(
+      /Field boom is required/,
+    );
+  });
+
+  it("sends the Bearer auth header", async () => {
+    const fetchImpl = vi.fn(async () => jsonResponse({ data: { ok: true } }));
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "secret-key",
+      fetchImpl,
+      minRequestIntervalMs: 0,
+    });
+    await client.requestOnce("/graphql", "query { x }");
+    const [, init] = fetchImpl.mock.calls[0] as unknown as [
+      string,
+      RequestInit,
+    ];
+    expect((init.headers as Record<string, string>).authorization).toBe(
+      "Bearer secret-key",
+    );
+  });
+
+  it("flags duplicate-key errors", async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({
+        errors: [
+          { message: 'duplicate key value violates unique constraint "x"' },
+        ],
+      }),
+    );
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    const error = await client
+      .requestOnce("/graphql", "mutation { y }")
+      .catch((e) => e);
+    expect(error).toBeInstanceOf(TwentyGraphqlError);
+    expect((error as TwentyGraphqlError).isDuplicateError).toBe(true);
+  });
+});
+
+describe("TwentyClient.requestWithRetry", () => {
+  it("retries on 429 with backoff then succeeds", async () => {
+    const fetchImpl = vi
+      .fn()
+      .mockResolvedValueOnce(new Response("rate limited", { status: 429 }))
+      .mockResolvedValueOnce(jsonResponse({ data: { ok: true } }));
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      backoffMs: 1,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    const data = await client.requestWithRetry<{ ok: boolean }>(
+      "/graphql",
+      "query { x }",
+    );
+    expect(data.ok).toBe(true);
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not retry GraphQL validation errors", async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({ errors: [{ message: "bad query" }] }),
+    );
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      backoffMs: 1,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    await expect(
+      client.requestWithRetry("/graphql", "query { x }"),
+    ).rejects.toThrow(/bad query/);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it("gives up after maxRetries on persistent 5xx", async () => {
+    const fetchImpl = vi.fn(async () => new Response("boom", { status: 502 }));
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      backoffMs: 1,
+      maxRetries: 2,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    await expect(
+      client.requestWithRetry("/graphql", "query { x }"),
+    ).rejects.toThrow(/502/);
+    expect(fetchImpl).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe("network errors", () => {
+  it("retries socket-level failures on reads", async () => {
+    const fetchImpl = vi
+      .fn()
+      .mockRejectedValueOnce(new TypeError("fetch failed"))
+      .mockResolvedValueOnce(jsonResponse({ data: { ok: true } }));
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      backoffMs: 1,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    const data = await client.requestWithRetry<{ ok: boolean }>(
+      "/graphql",
+      "query { x }",
+    );
+    expect(data.ok).toBe(true);
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+  });
+
+  it("wraps network failures with context on requestOnce", async () => {
+    const fetchImpl = vi.fn().mockRejectedValue(new TypeError("fetch failed"));
+    const client = new TwentyClient({
+      baseUrl: "https://crm.example.com",
+      authToken: "key",
+      fetchImpl,
+      minRequestIntervalMs: 0,
+      rateLimitWaitMs: 1,
+    });
+    const error = await client
+      .requestOnce("/graphql", "mutation { y }")
+      .catch((e) => e);
+    expect(error).toBeInstanceOf(TwentyGraphqlError);
+    expect((error as TwentyGraphqlError).isNetworkError).toBe(true);
+    expect((error as TwentyGraphqlError).message).toMatch(/network error/);
+  });
+});