@checkstack/theme-backend 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# @checkstack/theme-backend
+
+## 0.0.2
+
+### Patch Changes
+
+- d20d274: Initial release of all @checkstack packages. Rebranded from Checkmate to Checkstack with new npm organization @checkstack and domain checkstack.dev.
+- Updated dependencies [d20d274]
+  - @checkstack/auth-backend@0.0.2
+  - @checkstack/backend-api@0.0.2
+  - @checkstack/common@0.0.2
+  - @checkstack/theme-common@0.0.2
+
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies [b4eb432]
+- Updated dependencies [a65e002]
+- Updated dependencies [a65e002]
+  - @checkstack/backend-api@1.1.0
+  - @checkstack/common@0.2.0
+  - @checkstack/auth-backend@1.1.0
+  - @checkstack/theme-common@0.0.3
+
+## 0.0.3
+
+### Patch Changes
+
+- @checkstack/auth-backend@1.0.1
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [ffc28f6]
+- Updated dependencies [71275dd]
+- Updated dependencies [ae19ff6]
+- Updated dependencies [32f2535]
+- Updated dependencies [b55fae6]
+- Updated dependencies [b354ab3]
+- Updated dependencies [8e889b4]
+- Updated dependencies [81f3f85]
+  - @checkstack/common@0.1.0
+  - @checkstack/backend-api@1.0.0
+  - @checkstack/auth-backend@1.0.0
+  - @checkstack/theme-common@0.0.2

package/drizzle/0000_milky_paladin.sql

@@ -0,0 +1,5 @@
+CREATE TABLE "user_theme_preference" (
+	"user_id" text PRIMARY KEY NOT NULL,
+	"theme" text DEFAULT 'system' NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL
+);

package/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,52 @@
+{
+  "id": "b76ea33f-6e1b-477e-847e-009c75b0fd5a",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.user_theme_preference": {
+      "name": "user_theme_preference",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "theme": {
+          "name": "theme",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'system'"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1767319107725,
+      "tag": "0000_milky_paladin",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.config.ts

@@ -0,0 +1,8 @@
+export default {
+  dialect: "postgresql",
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  dbCredentials: {
+    url: process.env.DATABASE_URL || "",
+  },
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@checkstack/theme-backend",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "src/index.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "generate": "drizzle-kit generate",
+    "lint": "bun run lint:code",
+    "lint:code": "eslint . --max-warnings 0",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@checkstack/theme-common": "workspace:*",
+    "@checkstack/backend-api": "workspace:*",
+    "@checkstack/auth-backend": "workspace:*",
+    "drizzle-orm": "^0.45.1",
+    "zod": "^4.2.1",
+    "@checkstack/common": "workspace:*"
+  },
+  "devDependencies": {
+    "@checkstack/drizzle-helper": "workspace:*",
+    "@checkstack/scripts": "workspace:*",
+    "@checkstack/tsconfig": "workspace:*",
+    "@checkstack/test-utils-backend": "workspace:*",
+    "@orpc/server": "^1.13.2",
+    "@types/node": "^20.0.0",
+    "drizzle-kit": "^0.31.8",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+import {
+  createBackendPlugin,
+  coreServices,
+} from "@checkstack/backend-api";
+import { pluginMetadata, themeContract } from "@checkstack/theme-common";
+import { eq } from "drizzle-orm";
+import * as schema from "./schema";
+import { createThemeRouter } from "./router";
+import { authHooks } from "@checkstack/auth-backend";
+
+export default createBackendPlugin({
+  metadata: pluginMetadata,
+
+  register(env) {
+    // Register initialization logic with schema
+    env.registerInit({
+      schema,
+      deps: {
+        database: coreServices.database,
+        rpc: coreServices.rpc,
+        logger: coreServices.logger,
+      },
+      init: async ({ database, rpc }) => {
+        // Create and register the theme router
+        const router = createThemeRouter(database);
+        rpc.registerRouter(router, themeContract);
+      },
+      afterPluginsReady: async ({ database, logger, onHook }) => {
+        const db = database;
+
+        // Subscribe to user deletion to clean up theme preferences
+        onHook(
+          authHooks.userDeleted,
+          async ({ userId }) => {
+            logger.debug(
+              `Cleaning up theme preference for deleted user: ${userId}`
+            );
+            await db
+              .delete(schema.userThemePreference)
+              .where(eq(schema.userThemePreference.userId, userId));
+            logger.debug(`Cleaned up theme preference for user: ${userId}`);
+          },
+          { mode: "work-queue", workerGroup: "user-cleanup" }
+        );
+
+        logger.debug("✅ Theme Backend afterPluginsReady complete.");
+      },
+    });
+  },
+});

package/src/router.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, mock } from "bun:test";
+import { createThemeRouter } from "./router";
+import { createMockRpcContext } from "@checkstack/backend-api";
+import { createMockDb } from "@checkstack/test-utils-backend";
+import { call } from "@orpc/server";
+
+describe("Theme Router", () => {
+  const mockUser = {
+    type: "user" as const,
+    id: "test-user-123",
+    permissions: [],
+    roles: [],
+  } as any;
+
+  const mockDb = createMockDb();
+  const router = createThemeRouter(mockDb as any);
+
+  describe("getTheme", () => {
+    it("returns user theme preference when it exists", async () => {
+      const context = createMockRpcContext({ user: mockUser });
+
+      // Mock the full query chain: select().from().where().limit()
+      const mockWhereChain = Object.assign(
+        Promise.resolve([{ theme: "dark" }]),
+        {
+          limit: mock(() => Promise.resolve([{ theme: "dark" }])),
+        }
+      );
+      const mockFromChain = Object.assign(
+        Promise.resolve([{ theme: "dark" }]),
+        {
+          where: mock(() => mockWhereChain),
+        }
+      );
+      mockDb.select.mockReturnValueOnce({
+        from: mock(() => mockFromChain),
+      } as any);
+
+      const result = await call(router.getTheme, undefined, { context });
+      expect(result.theme).toBe("dark");
+    });
+
+    it("returns 'system' as default when no preference exists", async () => {
+      const context = createMockRpcContext({ user: mockUser });
+
+      // Mock the full query chain returning empty array
+      const mockWhereChain = Object.assign(Promise.resolve([]), {
+        limit: mock(() => Promise.resolve([])),
+      });
+      const mockFromChain = Object.assign(Promise.resolve([]), {
+        where: mock(() => mockWhereChain),
+      });
+      mockDb.select.mockReturnValueOnce({
+        from: mock(() => mockFromChain),
+      } as any);
+
+      const result = await call(router.getTheme, undefined, { context });
+      expect(result.theme).toBe("system");
+    });
+
+    it("throws error when user is not authenticated", async () => {
+      const context = createMockRpcContext({ user: undefined });
+
+      await expect(
+        call(router.getTheme, undefined, { context })
+      ).rejects.toThrow("Authentication required");
+    });
+  });
+
+  describe("setTheme", () => {
+    it("saves theme preference successfully", async () => {
+      const context = createMockRpcContext({ user: mockUser });
+
+      const result = await call(
+        router.setTheme,
+        { theme: "dark" },
+        { context }
+      );
+
+      expect(result).toBeUndefined(); // setTheme returns void
+      expect(mockDb.insert).toHaveBeenCalled();
+    });
+
+    it("upserts theme preference with conflict handling", async () => {
+      const context = createMockRpcContext({ user: mockUser });
+
+      await call(router.setTheme, { theme: "light" }, { context });
+
+      // Verify insert was called (the mock from test-utils handles onConflictDoUpdate)
+      expect(mockDb.insert).toHaveBeenCalled();
+    });
+
+    it("accepts 'system' theme value", async () => {
+      const context = createMockRpcContext({ user: mockUser });
+
+      const result = await call(
+        router.setTheme,
+        { theme: "system" },
+        { context }
+      );
+
+      expect(result).toBeUndefined();
+      expect(mockDb.insert).toHaveBeenCalled();
+    });
+
+    it("throws error when user is not authenticated", async () => {
+      const context = createMockRpcContext({ user: undefined });
+
+      await expect(
+        call(router.setTheme, { theme: "dark" }, { context })
+      ).rejects.toThrow("Authentication required");
+    });
+
+    it("validates theme enum values", async () => {
+      const context = createMockRpcContext({ user: mockUser });
+
+      // This should be caught by Zod validation at the contract level
+      // but we can verify the router accepts valid values
+      const validThemes = ["light", "dark", "system"];
+
+      for (const theme of validThemes) {
+        await call(router.setTheme, { theme: theme as any }, { context });
+        expect(mockDb.insert).toHaveBeenCalled();
+      }
+    });
+  });
+});

package/src/router.ts

@@ -0,0 +1,67 @@
+import { implement } from "@orpc/server";
+import {
+  autoAuthMiddleware,
+  type RpcContext,
+  type RealUser,
+} from "@checkstack/backend-api";
+import { themeContract } from "@checkstack/theme-common";
+import * as schema from "./schema";
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+/**
+ * Creates the theme router using contract-based implementation.
+ *
+ * Auth is automatically enforced via autoAuthMiddleware based on
+ * the contract's meta.userType (both endpoints are userType: "user").
+ */
+export const createThemeRouter = (db: NodePgDatabase<typeof schema>) => {
+  // Create contract implementer with context type AND auto auth middleware
+  const os = implement(themeContract)
+    .$context<RpcContext>()
+    .use(autoAuthMiddleware);
+
+  return os.router({
+    getTheme: os.getTheme.handler(async ({ context }) => {
+      // context.user is guaranteed to be RealUser by contract meta
+      const userId = (context.user as RealUser).id;
+
+      // Query user theme preference
+      const preferences = await db
+        .select({ theme: schema.userThemePreference.theme })
+        .from(schema.userThemePreference)
+        .where(eq(schema.userThemePreference.userId, userId))
+        .limit(1);
+
+      // Return preference or default to 'system'
+      const theme = preferences[0]?.theme || "system";
+      return { theme: theme as "light" | "dark" | "system" };
+    }),
+
+    setTheme: os.setTheme.handler(async ({ input, context }) => {
+      // context.user is guaranteed to be RealUser by contract meta
+      const userId = (context.user as RealUser).id;
+      const { theme } = input;
+
+      // Upsert theme preference
+      await db
+        .insert(schema.userThemePreference)
+        .values([
+          {
+            userId,
+            theme,
+            updatedAt: new Date(),
+          },
+        ])
+        .onConflictDoUpdate({
+          target: [schema.userThemePreference.userId],
+          set: {
+            theme,
+            updatedAt: new Date(),
+          },
+        });
+    }),
+  });
+};
+
+export type ThemeRouter = ReturnType<typeof createThemeRouter>;

package/src/schema.ts

@@ -0,0 +1,8 @@
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+
+// User theme preference table
+export const userThemePreference = pgTable("user_theme_preference", {
+  userId: text("user_id").primaryKey(), // References user from auth system
+  theme: text("theme").notNull().default("system"), // 'light', 'dark', or 'system'
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@checkstack/tsconfig/backend.json",
+  "include": [
+    "src"
+  ]
+}