@convex-dev/workos-authkit 0.1.1

package/src/component/_generated/server.ts

@@ -0,0 +1,161 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/convex.config.ts

@@ -0,0 +1,8 @@
+import { defineComponent } from "convex/server";
+import workpool from "@convex-dev/workpool/convex.config";
+
+const component = defineComponent("workOSAuthKit");
+
+component.use(workpool, { name: "eventWorkpool" });
+
+export default component;

package/src/component/lib.ts

@@ -0,0 +1,189 @@
+import { v } from "convex/values";
+import {
+  internalAction,
+  internalMutation,
+  internalQuery,
+  mutation,
+  query,
+} from "./_generated/server.js";
+import { components, internal } from "./_generated/api.js";
+import { omit, withoutSystemFields } from "convex-helpers";
+import { WorkOS, type Event as WorkOSEvent } from "@workos-inc/node";
+import type { FunctionHandle } from "convex/server";
+import { Workpool } from "@convex-dev/workpool";
+import schema from "./schema.js";
+
+const eventWorkpool = new Workpool(components.eventWorkpool, {
+  maxParallelism: 1,
+});
+
+export const enqueueWebhookEvent = mutation({
+  args: {
+    apiKey: v.string(),
+    eventId: v.string(),
+    event: v.string(),
+    updatedAt: v.optional(v.string()),
+    onEventHandle: v.optional(v.string()),
+    eventTypes: v.optional(v.array(v.string())),
+    logLevel: v.optional(v.literal("DEBUG")),
+  },
+  handler: async (ctx, args) => {
+    await eventWorkpool.cancelAll(ctx);
+    await eventWorkpool.enqueueAction(ctx, internal.lib.updateEvents, {
+      apiKey: args.apiKey,
+      onEventHandle: args.onEventHandle,
+      eventTypes: args.eventTypes,
+      logLevel: args.logLevel,
+    });
+  },
+});
+
+export const getCursor = internalQuery({
+  args: {},
+  returns: v.union(v.string(), v.null()),
+  handler: async (ctx) => {
+    const lastProcessedEvent = await ctx.db
+      .query("events")
+      .order("desc")
+      .first();
+    return lastProcessedEvent?.eventId;
+  },
+});
+
+export const updateEvents = internalAction({
+  args: {
+    apiKey: v.string(),
+    onEventHandle: v.optional(v.string()),
+    eventTypes: v.optional(v.array(v.string())),
+    logLevel: v.optional(v.literal("DEBUG")),
+  },
+  handler: async (ctx, args) => {
+    const workos = new WorkOS(args.apiKey);
+    const cursor = await ctx.runQuery(internal.lib.getCursor);
+    let nextCursor = cursor ?? undefined;
+    const eventTypes = [
+      "user.created" as const,
+      "user.updated" as const,
+      "user.deleted" as const,
+      ...((args.eventTypes as WorkOSEvent["event"][]) ?? []),
+    ];
+    // No cursor should mean we haven't handled any events - set
+    // a start time of 5 minutes ago
+    let rangeStart = nextCursor
+      ? undefined
+      : new Date(Date.now() - 1000 * 60 * 5).toISOString();
+    do {
+      const { data, listMetadata } = await workos.events.listEvents({
+        events: eventTypes,
+        after: nextCursor,
+        rangeStart,
+      });
+      for (const event of data) {
+        await ctx.runMutation(internal.lib.processEvent, {
+          event,
+          logLevel: args.logLevel,
+          onEventHandle: args.onEventHandle,
+        });
+      }
+      nextCursor = listMetadata.after;
+      rangeStart = undefined;
+    } while (nextCursor);
+  },
+});
+
+export const processEvent = internalMutation({
+  args: {
+    event: v.object({
+      id: v.string(),
+      createdAt: v.string(),
+      event: v.string(),
+      data: v.record(v.string(), v.any()),
+    }),
+    logLevel: v.optional(v.literal("DEBUG")),
+    onEventHandle: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.logLevel === "DEBUG") {
+      console.log("processing event", args.event);
+    }
+    const dbEvent = await ctx.db
+      .query("events")
+      .withIndex("eventId", (q) => q.eq("eventId", args.event.id))
+      .unique();
+    if (dbEvent) {
+      console.log("event already processed", args.event.id);
+      return;
+    }
+    await ctx.db.insert("events", {
+      eventId: args.event.id,
+      event: args.event.event,
+      updatedAt: args.event.data.updatedAt,
+    });
+    const event = args.event as WorkOSEvent;
+    switch (event.event) {
+      case "user.created": {
+        const data = omit(event.data, ["object"]);
+        const existingUser = await ctx.db
+          .query("users")
+          .withIndex("id", (q) => q.eq("id", data.id))
+          .unique();
+        if (existingUser) {
+          console.warn("user already exists", data.id);
+          break;
+        }
+        await ctx.db.insert("users", data);
+        break;
+      }
+      case "user.updated": {
+        const data = omit(event.data, ["object"]);
+        const user = await ctx.db
+          .query("users")
+          .withIndex("id", (q) => q.eq("id", data.id))
+          .unique();
+        if (!user) {
+          console.error("user not found", data.id);
+          break;
+        }
+        if (user.updatedAt >= data.updatedAt) {
+          console.warn(`user already updated for event ${event.id}, skipping`);
+          break;
+        }
+        await ctx.db.patch(user._id, data);
+        break;
+      }
+      case "user.deleted": {
+        const data = omit(event.data, ["object"]);
+        const user = await ctx.db
+          .query("users")
+          .withIndex("id", (q) => q.eq("id", data.id))
+          .unique();
+        if (!user) {
+          console.warn("user not found", data.id);
+          break;
+        }
+        await ctx.db.delete(user._id);
+        break;
+      }
+    }
+    if (args.onEventHandle) {
+      await ctx.runMutation(args.onEventHandle as FunctionHandle<"mutation">, {
+        event: args.event.event,
+        data: args.event.data,
+      });
+    }
+  },
+});
+
+export const getAuthUser = query({
+  args: {
+    id: v.string(),
+  },
+  returns: v.union(schema.tables.users.validator, v.null()),
+  handler: async (ctx, args) => {
+    const user = await ctx.db
+      .query("users")
+      .withIndex("id", (q) => q.eq("id", args.id))
+      .unique();
+    return user ? withoutSystemFields(user) : null;
+  },
+});

package/src/component/schema.ts

@@ -0,0 +1,24 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  events: defineTable({
+    eventId: v.string(),
+    event: v.string(),
+    updatedAt: v.optional(v.string()),
+  }).index("eventId", ["eventId"]),
+  users: defineTable({
+    id: v.string(),
+    email: v.string(),
+    firstName: v.optional(v.union(v.null(), v.string())),
+    lastName: v.optional(v.union(v.null(), v.string())),
+    emailVerified: v.boolean(),
+    profilePictureUrl: v.optional(v.union(v.null(), v.string())),
+    lastSignInAt: v.optional(v.union(v.null(), v.string())),
+    externalId: v.optional(v.union(v.null(), v.string())),
+    metadata: v.record(v.string(), v.any()),
+    locale: v.optional(v.union(v.null(), v.string())),
+    createdAt: v.string(),
+    updatedAt: v.string(),
+  }).index("id", ["id"]),
+});

package/src/component/setup.test.ts

@@ -0,0 +1,5 @@
+/// <reference types="vite/client" />
+import { test } from "vitest";
+export const modules = import.meta.glob("./**/*.*s");
+
+test("setup", () => {});

package/src/react/index.ts

@@ -0,0 +1,7 @@
+"use client";
+
+// This is where React components / hooks go.
+
+export const useMyComponent = () => {
+  return {};
+};

package/src/test.ts

@@ -0,0 +1,17 @@
+import type { TestConvex } from "convex-test";
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import schema from "./component/schema.js";
+const modules = import.meta.glob("./component/**/*.ts");
+
+/**
+ * Register the component with the test convex instance.
+ * @param t - The test convex instance, e.g. from calling `convexTest`.
+ * @param name - The name of the component, as registered in convex.config.ts.
+ */
+function register(
+  t: TestConvex<SchemaDefinition<GenericSchema, boolean>>,
+  name: string = "workOSAuthKit"
+) {
+  t.registerComponent(name, schema, modules);
+}
+export default { register, schema, modules };