WorkOS Integration

1
import { SchematicClient } from "@schematichq/schematic-typescript-node";
2
3
const client = new SchematicClient({ apiKey: process.env.SCHEMATIC_API_KEY });
4
5
// An organization signs up
6
await client.companies.upsertCompany({
7
  keys: { workos_organization_id: "org_EXAMPLE0123456789" },
8
  name: "Acme Inc.",
9
  traits: {
10
    // Optional: carry over WorkOS context you want to target on
11
    workosExternalId: "EXAMPLE_EXTERNAL_ID",
12
  },
13
});
14
15
// A user signs up and joins that organization
16
await client.companies.upsertUser({
17
  keys: {
18
    workos_user_id: "user_EXAMPLE0123456789",
19
    email: "marcelina.davis@example.com",
20
  },
21
  name: "Marcelina Davis",
22
  // `company` accepts the parent company's keys, so the user is
23
  // associated with the right Schematic company
24
  company: { workos_organization_id: "org_EXAMPLE0123456789" },
25
});

1
const isOn = await client.checkFlag(
2
  {
3
    company: { workos_organization_id: "org_EXAMPLE0123456789" },
4
    user: { workos_user_id: "user_EXAMPLE0123456789" },
5
  },
6
  "your-feature-flag",
7
);

1
await client.track({
2
  event: "api-request",
3
  company: { workos_organization_id: "org_EXAMPLE0123456789" },
4
  user: { workos_user_id: "user_EXAMPLE0123456789" },
5
});

1
import { WorkOS } from "@workos-inc/node";
2
import { SchematicClient } from "@schematichq/schematic-typescript-node";
3
4
const workos = new WorkOS(process.env.WORKOS_API_KEY);
5
const client = new SchematicClient({ apiKey: process.env.SCHEMATIC_API_KEY });
6
7
// 1. Backfill organizations -> Schematic companies
8
const organizationIds: string[] = [];
9
let after: string | undefined;
10
do {
11
  const page = await workos.organizations.listOrganizations({ limit: 100, after });
12
  for (const org of page.data) {
13
    organizationIds.push(org.id);
14
    await client.companies.upsertCompany({
15
      keys: { workos_organization_id: org.id },
16
      name: org.name,
17
    });
18
  }
19
  after = page.listMetadata.after ?? undefined;
20
} while (after);
21
22
// 2. Backfill users -> Schematic users
23
after = undefined;
24
do {
25
  const page = await workos.userManagement.listUsers({ limit: 100, after });
26
  for (const user of page.data) {
27
    await client.companies.upsertUser({
28
      keys: { workos_user_id: user.id, email: user.email },
29
      name: `${user.firstName ?? ""} ${user.lastName ?? ""}`.trim(),
30
    });
31
  }
32
  after = page.listMetadata.after ?? undefined;
33
} while (after);
34
35
// 3. Backfill memberships so each user is tied to the right company.
36
//    Page through every organization collected in step 1. Because `company`
37
//    adds the user to that company without removing others, a user who belongs
38
//    to multiple organizations accumulates all of them across the loop.
39
for (const organizationId of organizationIds) {
40
  after = undefined;
41
  do {
42
    const page = await workos.userManagement.listOrganizationMemberships({
43
      organizationId,
44
      limit: 100,
45
      after,
46
    });
47
    for (const membership of page.data) {
48
      await client.companies.upsertUser({
49
        keys: { workos_user_id: membership.userId },
50
        company: { workos_organization_id: membership.organizationId },
51
      });
52
    }
53
    after = page.listMetadata.after ?? undefined;
54
  } while (after);
55
}

1
import { WorkOS } from "@workos-inc/node";
2
import { SchematicClient } from "@schematichq/schematic-typescript-node";
3
import express from "express";
4
5
const app = express();
6
const workos = new WorkOS(process.env.WORKOS_API_KEY);
7
const schematic = new SchematicClient({ apiKey: process.env.SCHEMATIC_API_KEY });
8
9
// Use express.raw, not express.json. constructEvent verifies the signature
10
// against the exact bytes WorkOS sent, so it needs the raw body. Handing it a
11
// parsed-then-re-serialized object can fail verification if the JSON differs.
12
app.post("/webhooks/workos", express.raw({ type: "application/json" }), async (req, res) => {
13
  let event;
14
  try {
15
    event = await workos.webhooks.constructEvent({
16
      payload: req.body,
17
      sigHeader: req.headers["workos-signature"],
18
      secret: process.env.WORKOS_WEBHOOK_SECRET,
19
    });
20
  } catch {
21
    return res.status(400).send("Invalid signature");
22
  }
23
24
  // The event type is on `event.event`, not `event.type`.
25
  const { event: type, data } = event;
26
  try {
27
    switch (type) {
28
      case "organization.created":
29
      case "organization.updated":
30
        await schematic.companies.upsertCompany({
31
          keys: { workos_organization_id: data.id },
32
          name: data.name,
33
        });
34
        break;
35
36
      case "organization.deleted":
37
        await schematic.companies.deleteCompanyByKeys({
38
          keys: { workos_organization_id: data.id },
39
        });
40
        break;
41
42
      case "user.created":
43
      case "user.updated":
44
        await schematic.companies.upsertUser({
45
          keys: { workos_user_id: data.id, email: data.email },
46
          name: `${data.firstName ?? ""} ${data.lastName ?? ""}`.trim(),
47
        });
48
        break;
49
50
      case "user.deleted":
51
        await schematic.companies.deleteUserByKeys({
52
          keys: { workos_user_id: data.id },
53
        });
54
        break;
55
56
      case "organization_membership.created":
57
      case "organization_membership.updated":
58
      case "organization_membership.deleted": {
59
        // Re-derive the user's current organizations and write them as the
60
        // exhaustive `companies` list. This reflects both additions and
61
        // removals: a deleted membership drops that company, and a user left
62
        // with none is cleared (companies: []).
63
        const memberships = await workos.userManagement.listOrganizationMemberships({
64
          userId: data.userId,
65
          limit: 100,
66
        });
67
        await schematic.companies.upsertUser({
68
          keys: { workos_user_id: data.userId },
69
          companies: memberships.data.map((m) => ({
70
            workos_organization_id: m.organizationId,
71
          })),
72
        });
73
        break;
74
      }
75
    }
76
  } catch (err) {
77
    // Return a non-2xx so WorkOS retries the delivery.
78
    console.error("Schematic sync failed", err);
79
    return res.status(500).send("Sync failed");
80
  }
81
82
  res.status(200).send("OK");
83
});