@webstudio-is/plans 0.260.2

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@webstudio-is/plans",
+  "version": "0.260.2",
+  "description": "Plan features and billing logic for Webstudio",
+  "author": "Webstudio <github@webstudio.is>",
+  "homepage": "https://webstudio.is",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "dependencies": {
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "vitest": "^3.1.2",
+    "@webstudio-is/postgrest": "0.260.2",
+    "@webstudio-is/tsconfig": "1.0.7"
+  },
+  "exports": {
+    ".": {
+      "webstudio": "./src/index.ts",
+      "import": "./src/index.ts"
+    },
+    "./index.server": {
+      "webstudio": "./src/index.server.ts",
+      "import": "./src/index.server.ts"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/dev-plan.server.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect } from "vitest";
+import {
+  createTestServer,
+  db,
+  testContext,
+  json,
+  empty,
+} from "@webstudio-is/postgrest/testing";
+import { applyDevPlan } from "./dev-plan.server";
+
+const server = createTestServer();
+
+// ─── applyDevPlan ─────────────────────────────────────────────
+
+describe("applyDevPlan (msw)", () => {
+  test("does nothing when user is not found", async () => {
+    server.use(
+      db.get("User", () =>
+        json(
+          { code: "PGRST116", message: "Row not found", details: "", hint: "" },
+          { status: 406 }
+        )
+      )
+    );
+
+    // Should resolve without throwing even when user is missing
+    await expect(
+      applyDevPlan("ghost@example.com", "Pro", testContext)
+    ).resolves.toBeUndefined();
+  });
+
+  test("upserts Product and TransactionLog when plan is set", async () => {
+    let productUpserted = false;
+    let txUpserted = false;
+
+    server.use(
+      db.get("User", () => json({ id: "user-1" })),
+      db.post("Product", () => {
+        productUpserted = true;
+        return empty({ status: 201 });
+      }),
+      db.post("TransactionLog", () => {
+        txUpserted = true;
+        return empty({ status: 201 });
+      })
+    );
+
+    await applyDevPlan("dev@example.com", "Pro", testContext);
+    expect(productUpserted).toBe(true);
+    expect(txUpserted).toBe(true);
+  });
+
+  test("deletes TransactionLog when plan is null (free tier)", async () => {
+    let txDeleted = false;
+
+    server.use(
+      db.get("User", () => json({ id: "user-1" })),
+      db.delete("TransactionLog", () => {
+        txDeleted = true;
+        return empty({ status: 204 });
+      })
+    );
+
+    await applyDevPlan("dev@example.com", null, testContext);
+    expect(txDeleted).toBe(true);
+  });
+
+  test("does nothing when Product upsert fails", async () => {
+    server.use(
+      db.get("User", () => json({ id: "user-1" })),
+      db.post("Product", () =>
+        json(
+          { code: "PGRST000", message: "DB error", details: "", hint: "" },
+          { status: 500 }
+        )
+      )
+    );
+
+    // Should resolve (logs error but doesn't throw)
+    await expect(
+      applyDevPlan("dev@example.com", "Pro", testContext)
+    ).resolves.toBeUndefined();
+  });
+});

package/src/dev-plan.server.ts

@@ -0,0 +1,85 @@
+import type { Client } from "@webstudio-is/postgrest/index.server";
+
+type PostgrestContext = { client: Client };
+
+/**
+ * Upsert or delete dev plan rows in the DB for the given user email.
+ * This lets getPlanInfo work naturally (same as production) for all callers,
+ * including getOwnerPlanFeatures for shared-workspace suspension checks.
+ *
+ * - Plan selected: upsert a Product row (id = "dev-product-{planName}") and a
+ *   TransactionLog row (eventId = "dev-{userId}") that satisfies the UserProduct view.
+ * - No plan selected: delete the TransactionLog row so the user has no active purchase.
+ */
+export const applyDevPlan = async (
+  email: string,
+  planName: string | null,
+  context: { postgrest: PostgrestContext }
+) => {
+  const { postgrest } = context;
+  // Resolve userId from email (user was already created by the authenticator).
+  const userResult = await postgrest.client
+    .from("User")
+    .select("id")
+    .eq("email", email)
+    .single();
+
+  if (userResult.error) {
+    console.error("[applyDevPlan] Failed to find user:", userResult.error);
+    return;
+  }
+
+  const userId = userResult.data?.id as string | undefined;
+  if (!userId) {
+    console.error("[applyDevPlan] No user found for email:", email);
+    return;
+  }
+
+  if (planName !== null) {
+    const productId = `dev-product-${planName}`;
+
+    const productResult = await postgrest.client.from("Product").upsert({
+      id: productId,
+      name: planName,
+      meta: {},
+      features: [],
+      images: [],
+    });
+    if (productResult.error) {
+      console.error(
+        "[applyDevPlan] Failed to upsert Product:",
+        productResult.error
+      );
+      return;
+    }
+
+    const txResult = await postgrest.client.from("TransactionLog").upsert({
+      eventId: `dev-${userId}`,
+      userId,
+      productId,
+      eventData: {
+        type: "checkout.session.completed",
+        created: Math.floor(Date.now() / 1000),
+        data: { object: { status: "complete" } },
+      },
+    });
+    if (txResult.error) {
+      console.error(
+        "[applyDevPlan] Failed to upsert TransactionLog:",
+        txResult.error
+      );
+    }
+  } else {
+    // Remove any existing dev plan row — the user becomes free tier.
+    const deleteResult = await postgrest.client
+      .from("TransactionLog")
+      .delete()
+      .eq("eventId", `dev-${userId}`);
+    if (deleteResult.error) {
+      console.error(
+        "[applyDevPlan] Failed to delete TransactionLog:",
+        deleteResult.error
+      );
+    }
+  }
+};

package/src/index.server.ts

@@ -0,0 +1,11 @@
+export * from "./index";
+export {
+  getPlanInfo,
+  getAuthorizationOwnerId,
+  parsePlansEnv,
+  parseProductMeta,
+  mergeProductMetas,
+  buildPurchases,
+  __testing__,
+} from "./plan-client.server";
+export { applyDevPlan } from "./dev-plan.server";

package/src/index.ts

@@ -0,0 +1,6 @@
+export {
+  PlanFeaturesSchema,
+  defaultPlanFeatures,
+  parsePlansEnv,
+} from "./plan-features";
+export type { PlanFeatures, Purchase } from "./plan-features";

package/src/plan-client.server.test.ts

@@ -0,0 +1,272 @@
+import { describe, test, expect, beforeEach, vi } from "vitest";
+import {
+  createTestServer,
+  db,
+  json,
+  testContext,
+} from "@webstudio-is/postgrest/testing";
+import { type PlanFeatures, defaultPlanFeatures } from "./plan-features";
+import { getPlanInfo, __testing__ } from "./plan-client.server";
+
+const { parseProductMeta, mergeProductMetas, resetProductCache } = __testing__;
+
+// ---------------------------------------------------------------------------
+// Unit tests for private helpers
+// ---------------------------------------------------------------------------
+
+const server = createTestServer();
+
+beforeEach(() => {
+  resetProductCache();
+  vi.unstubAllEnvs();
+});
+
+const proProduct = {
+  id: "prod-pro",
+  name: "Pro",
+  meta: { maxDomainsAllowedPerUser: 10 },
+};
+
+const proUserProduct = {
+  userId: "user-1",
+  productId: "prod-pro",
+  subscriptionId: "sub-abc",
+};
+
+describe("getPlanInfo (msw)", () => {
+  test("empty userIds returns empty map without hitting DB", async () => {
+    const result = await getPlanInfo([], testContext);
+    expect(result.size).toBe(0);
+  });
+
+  test("user with no products returns defaultPlanFeatures", async () => {
+    server.use(db.get("UserProduct", () => json([])));
+
+    const result = await getPlanInfo(["user-1"], testContext);
+    expect(result.get("user-1")).toEqual({
+      planFeatures: defaultPlanFeatures,
+      purchases: [],
+    });
+  });
+
+  test("user with one product resolves plan features from PLANS env + meta merge", async () => {
+    vi.stubEnv(
+      "PLANS",
+      JSON.stringify([{ name: "Pro", maxDomainsAllowedPerUser: 5 }])
+    );
+    server.use(
+      db.get("UserProduct", () => json([proUserProduct])),
+      db.get("Product", () => json([proProduct]))
+    );
+
+    const result = await getPlanInfo(["user-1"], testContext);
+    const info = result.get("user-1");
+    // meta overrides env plan: maxDomainsAllowedPerUser should be 10 (from meta)
+    expect(info?.planFeatures.maxDomainsAllowedPerUser).toBe(10);
+    expect(info?.purchases).toEqual([
+      { planName: "Pro", subscriptionId: "sub-abc" },
+    ]);
+  });
+
+  test("product not in PLANS falls back to defaultPlanFeatures for that product", async () => {
+    vi.stubEnv("PLANS", JSON.stringify([]));
+    server.use(
+      db.get("UserProduct", () => json([proUserProduct])),
+      db.get("Product", () => json([proProduct]))
+    );
+
+    const result = await getPlanInfo(["user-1"], testContext);
+    const info = result.get("user-1");
+    // meta provides maxDomainsAllowedPerUser: 10, rest from defaultPlanFeatures
+    expect(info?.planFeatures.maxDomainsAllowedPerUser).toBe(10);
+    expect(info?.planFeatures.canDownloadAssets).toBe(
+      defaultPlanFeatures.canDownloadAssets
+    );
+  });
+
+  test("multiple users batched in one UserProduct query", async () => {
+    vi.stubEnv("PLANS", JSON.stringify([]));
+    server.use(
+      db.get("UserProduct", ({ request }) => {
+        const url = new URL(request.url);
+        // PostgREST IN filter: userId=in.(user-1,user-2)
+        expect(url.searchParams.get("userId")).toMatch(/user-1/);
+        expect(url.searchParams.get("userId")).toMatch(/user-2/);
+        return json([
+          proUserProduct,
+          { userId: "user-2", productId: "prod-pro", subscriptionId: null },
+        ]);
+      }),
+      db.get("Product", () => json([proProduct]))
+    );
+
+    const result = await getPlanInfo(["user-1", "user-2"], testContext);
+    expect(result.size).toBe(2);
+    expect(result.get("user-1")?.purchases[0].planName).toBe("Pro");
+    expect(result.get("user-2")?.purchases[0].subscriptionId).toBeUndefined();
+  });
+
+  test("UserProduct DB error throws", async () => {
+    server.use(
+      db.get("UserProduct", () =>
+        json({ message: "db error" }, { status: 500 })
+      )
+    );
+
+    await expect(getPlanInfo(["user-1"], testContext)).rejects.toThrow(
+      "Failed to fetch user products"
+    );
+  });
+
+  test("Product DB error throws and cache is cleared for retry", async () => {
+    server.use(
+      db.get("UserProduct", () => json([proUserProduct])),
+      db.get("Product", () => json({ message: "db error" }, { status: 500 }))
+    );
+
+    await expect(getPlanInfo(["user-1"], testContext)).rejects.toThrow(
+      "Failed to fetch products"
+    );
+
+    // After error the cache is cleared — next call should hit DB again
+    server.use(
+      db.get("UserProduct", () => json([proUserProduct])),
+      db.get("Product", () => json([proProduct]))
+    );
+    vi.stubEnv("PLANS", JSON.stringify([]));
+    const result = await getPlanInfo(["user-1"], testContext);
+    expect(result.get("user-1")?.purchases[0].planName).toBe("Pro");
+  });
+
+  test("Product table is queried only once across two calls (cache hit)", async () => {
+    vi.stubEnv("PLANS", JSON.stringify([]));
+    let productFetchCount = 0;
+    server.use(
+      db.get("UserProduct", () => json([proUserProduct])),
+      db.get("Product", () => {
+        productFetchCount += 1;
+        return json([proProduct]);
+      })
+    );
+
+    await getPlanInfo(["user-1"], testContext);
+    await getPlanInfo(["user-1"], testContext);
+
+    expect(productFetchCount).toBe(1);
+  });
+});
+
+/** Full-featured plan for use in tests — all booleans true, numeric limits at max */
+const fullFeatures: PlanFeatures = {
+  ...defaultPlanFeatures,
+  canDownloadAssets: true,
+  canRestoreBackups: true,
+  allowAdditionalPermissions: true,
+  allowDynamicData: true,
+  allowContentMode: true,
+  allowStagingPublish: true,
+  maxContactEmailsPerProject: 5,
+  maxDomainsAllowedPerUser: 100,
+  maxDailyPublishesPerUser: 100,
+  maxWorkspaces: 1,
+  maxProjectsAllowedPerUser: 100,
+};
+
+describe("parseProductMeta", () => {
+  test("extracts known keys from a valid object", () => {
+    const result = parseProductMeta({
+      maxContactEmailsPerProject: 10,
+      canDownloadAssets: true,
+    });
+    expect(result).toEqual({
+      maxContactEmailsPerProject: 10,
+      canDownloadAssets: true,
+    });
+  });
+
+  test("strips unknown keys", () => {
+    const result = parseProductMeta({
+      admin: true,
+      maxContactEmailsPerProject: 3,
+    });
+    expect(result).toEqual({ maxContactEmailsPerProject: 3 });
+  });
+
+  test("returns empty object for non-object input", () => {
+    expect(parseProductMeta("not an object")).toEqual({});
+    expect(parseProductMeta(42)).toEqual({});
+    expect(parseProductMeta(undefined)).toEqual({});
+  });
+
+  test("returns empty object for null input", () => {
+    expect(parseProductMeta(null)).toEqual({});
+  });
+
+  test("rejects negative numbers", () => {
+    const result = parseProductMeta({ maxContactEmailsPerProject: -1 });
+    expect(result).toEqual({});
+  });
+
+  test("accepts zero for numeric fields", () => {
+    const result = parseProductMeta({ maxWorkspaces: 0 });
+    expect(result).toEqual({ maxWorkspaces: 0 });
+  });
+
+  test("rejects wrong types for fields", () => {
+    const result = parseProductMeta({
+      canDownloadAssets: "yes",
+      maxContactEmailsPerProject: "five",
+    });
+    expect(result).toEqual({});
+  });
+});
+
+describe("mergeProductMetas", () => {
+  test("booleans: true if ANY product grants the feature", () => {
+    const result = mergeProductMetas([
+      { ...fullFeatures, canDownloadAssets: false, canRestoreBackups: true },
+      { ...fullFeatures, canDownloadAssets: true, canRestoreBackups: false },
+    ]);
+    expect(result.canDownloadAssets).toBe(true);
+    expect(result.canRestoreBackups).toBe(true);
+  });
+
+  test("booleans: false when NO product grants the feature", () => {
+    const result = mergeProductMetas([
+      { ...fullFeatures, canDownloadAssets: false },
+      { ...fullFeatures, canDownloadAssets: false },
+    ]);
+    expect(result.canDownloadAssets).toBe(false);
+  });
+
+  test("numbers: takes the highest value across products", () => {
+    const result = mergeProductMetas([
+      { ...fullFeatures, maxContactEmailsPerProject: 3, maxWorkspaces: 2 },
+      { ...fullFeatures, maxContactEmailsPerProject: 10, maxWorkspaces: 5 },
+    ]);
+    expect(result.maxContactEmailsPerProject).toBe(10);
+    expect(result.maxWorkspaces).toBe(5);
+  });
+
+  test("single product returns its values unchanged", () => {
+    const plan = { ...fullFeatures, maxWorkspaces: 7 };
+    const result = mergeProductMetas([plan]);
+    expect(result).toEqual(plan);
+  });
+
+  test("empty array returns defaultPlanFeatures", () => {
+    const result = mergeProductMetas([]);
+    expect(result).toEqual(defaultPlanFeatures);
+  });
+});
+
+describe("workspaces plan", () => {
+  test("merging pro + workspaces product picks highest maxWorkspaces", () => {
+    const proProduct = { ...fullFeatures, maxWorkspaces: 1 };
+    const workspacesProduct = { ...defaultPlanFeatures, maxWorkspaces: 20 };
+
+    const result = mergeProductMetas([proProduct, workspacesProduct]);
+    expect(result.maxWorkspaces).toBe(20);
+    expect(result.canDownloadAssets).toBe(true);
+  });
+});