@webstudio-is/plans 0.260.2

package/src/plan-client.server.ts

@@ -0,0 +1,218 @@
+import type { Client } from "@webstudio-is/postgrest/index.server";
+import {
+  type PlanFeatures,
+  PlanFeaturesSchema,
+  defaultPlanFeatures,
+  parsePlansEnv,
+  type Purchase,
+} from "./plan-features";
+
+export { parsePlansEnv } from "./plan-features";
+
+type PostgrestContext = { client: Client };
+
+type AuthorizationContext =
+  | { type: "token"; ownerId: string }
+  | { type: "user"; userId: string }
+  | { type: "service" }
+  | { type: "anonymous" };
+
+type PlanInfo = {
+  planFeatures: PlanFeatures;
+  purchases: Array<Purchase>;
+};
+
+export const parseProductMeta = (meta: unknown): Partial<PlanFeatures> => {
+  const result = PlanFeaturesSchema.partial().safeParse(meta);
+  return result.success ? result.data : {};
+};
+
+export const mergeProductMetas = (
+  productMetas: Array<PlanFeatures>
+): PlanFeatures => {
+  if (productMetas.length === 0) {
+    return defaultPlanFeatures;
+  }
+
+  return Object.fromEntries(
+    (Object.keys(defaultPlanFeatures) as Array<keyof PlanFeatures>).map(
+      (key) => {
+        const vals = productMetas.map((item) => item[key]);
+        const merged =
+          typeof defaultPlanFeatures[key] === "boolean"
+            ? (vals as Array<boolean>).some(Boolean)
+            : Math.max(...(vals as Array<number>));
+        return [key, merged];
+      }
+    )
+  ) as PlanFeatures;
+};
+
+export const buildPurchases = (
+  userProducts: Array<{
+    productId: string | null | undefined;
+    subscriptionId: string | null | undefined;
+  }>,
+  productIdToName: Map<string, string>
+): Array<Purchase> => {
+  const purchases: Array<Purchase> = [];
+  for (const userProduct of userProducts) {
+    if (userProduct.productId === null || userProduct.productId === undefined) {
+      continue;
+    }
+    purchases.push({
+      planName: productIdToName.get(userProduct.productId) ?? "",
+      subscriptionId: userProduct.subscriptionId ?? undefined,
+    });
+  }
+  return purchases;
+};
+
+type Product = { id: string; name: string; meta: unknown };
+
+// Products are admin-created and rarely change. Cache them for the lifetime of the
+// server instance to avoid a repeated DB round-trip on every request.
+// The promise itself is cached to deduplicate concurrent cold-start requests.
+let productCachePromise: Promise<Map<string, Product>> | undefined;
+
+const getProductCache = (
+  postgrest: PostgrestContext
+): Promise<Map<string, Product>> => {
+  if (productCachePromise !== undefined) {
+    return productCachePromise;
+  }
+  const promise: Promise<Map<string, Product>> = Promise.resolve(
+    postgrest.client.from("Product").select("id, name, meta")
+  ).then((result) => {
+    if (result.error) {
+      productCachePromise = undefined;
+      console.error(result.error);
+      throw new Error("Failed to fetch products");
+    }
+    return new Map(result.data.map((p) => [p.id, p as Product]));
+  });
+  productCachePromise = promise;
+  return promise;
+};
+
+export const getPlanInfo = async (
+  userIds: string[],
+  context: { postgrest: PostgrestContext }
+): Promise<Map<string, PlanInfo>> => {
+  const { postgrest } = context;
+
+  if (userIds.length === 0) {
+    return new Map();
+  }
+
+  const userProductsResult = await postgrest.client
+    .from("UserProduct")
+    .select("userId, subscriptionId, productId")
+    .in("userId", userIds);
+
+  if (userProductsResult.error) {
+    console.error(userProductsResult.error);
+    throw new Error("Failed to fetch user products");
+  }
+
+  const userProductsByUserId = new Map<
+    string,
+    Array<{
+      productId: string | null;
+      subscriptionId: string | null;
+    }>
+  >();
+
+  for (const row of userProductsResult.data) {
+    if (row.userId === null) {
+      continue;
+    }
+    const rows = userProductsByUserId.get(row.userId) ?? [];
+    rows.push({
+      productId: row.productId,
+      subscriptionId: row.subscriptionId,
+    });
+    userProductsByUserId.set(row.userId, rows);
+  }
+
+  const productIds = [
+    ...new Set(
+      userProductsResult.data.flatMap(({ productId }) =>
+        productId === null || productId === undefined ? [] : [productId]
+      )
+    ),
+  ];
+
+  if (productIds.length === 0) {
+    return new Map(
+      userIds.map((userId) => [
+        userId,
+        { planFeatures: defaultPlanFeatures, purchases: [] },
+      ])
+    );
+  }
+
+  const allProducts = await getProductCache(postgrest);
+  const productById = new Map(
+    productIds.flatMap((id) => {
+      const product = allProducts.get(id);
+      return product !== undefined ? [[id, product] as const] : [];
+    })
+  );
+  const productIdToName = new Map(
+    [...productById.values()].map((product) => [product.id, product.name])
+  );
+  const plansByName = parsePlansEnv(process.env.PLANS ?? "[]");
+
+  return new Map(
+    userIds.map((userId) => {
+      const userProducts = userProductsByUserId.get(userId) ?? [];
+      const productMetas = userProducts.flatMap(({ productId }) => {
+        if (productId === null || productId === undefined) {
+          return [];
+        }
+        const product = productById.get(productId);
+        if (product === undefined) {
+          return [];
+        }
+        return [
+          {
+            ...(plansByName.get(product.name) ?? defaultPlanFeatures),
+            ...parseProductMeta(product.meta),
+          },
+        ];
+      });
+
+      return [
+        userId,
+        {
+          planFeatures: mergeProductMetas(productMetas),
+          purchases: buildPurchases(userProducts, productIdToName),
+        },
+      ];
+    })
+  );
+};
+
+/** Resets the module-level product cache. Only for use in tests. */
+const resetProductCache = () => {
+  productCachePromise = undefined;
+};
+
+export const __testing__ = {
+  parseProductMeta,
+  mergeProductMetas,
+  resetProductCache,
+};
+
+export const getAuthorizationOwnerId = (
+  authorization: AuthorizationContext
+): string | undefined => {
+  if (authorization.type === "token") {
+    return authorization.ownerId;
+  }
+  if (authorization.type === "user") {
+    return authorization.userId;
+  }
+  return undefined;
+};

package/src/plan-features.test.ts

@@ -0,0 +1,132 @@
+import { describe, test, expect } from "vitest";
+import {
+  type PlanFeatures,
+  defaultPlanFeatures,
+  parsePlansEnv,
+} from "./plan-features";
+
+/** 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("parsePlansEnv", () => {
+  const validEntry = JSON.stringify({ name: "Pro", features: fullFeatures });
+  const twoEntries = JSON.stringify([
+    { name: "Pro", features: fullFeatures },
+    { name: "Workspaces", features: { ...fullFeatures, maxWorkspaces: 10 } },
+  ]);
+
+  test("returns empty map for empty JSON array", () => {
+    expect(parsePlansEnv("[]").size).toBe(0);
+  });
+
+  test("returns empty map for invalid JSON", () => {
+    expect(parsePlansEnv("not json").size).toBe(0);
+  });
+
+  test("returns empty map for non-array JSON", () => {
+    expect(parsePlansEnv(validEntry).size).toBe(0);
+  });
+
+  test("extends-only entry (no features key) inherits parent features", () => {
+    const result = parsePlansEnv(
+      JSON.stringify([
+        { name: "Pro", features: fullFeatures },
+        { name: "LTD T2", extends: "Pro" },
+      ])
+    );
+    expect(result.size).toBe(2);
+    expect(result.get("LTD T2")).toEqual(result.get("Pro"));
+  });
+
+  test("entry with no features key and no extends resolves to defaultPlanFeatures", () => {
+    const result = parsePlansEnv(JSON.stringify([{ name: "Free" }]));
+    expect(result.size).toBe(1);
+    expect(result.get("Free")).toEqual(defaultPlanFeatures);
+  });
+
+  test("extends: child inherits parent features and overrides specific fields", () => {
+    const result = parsePlansEnv(
+      JSON.stringify([
+        { name: "Pro", features: fullFeatures },
+        { name: "Team", extends: "Pro", features: { maxWorkspaces: 50 } },
+      ])
+    );
+    expect(result.size).toBe(2);
+    expect(result.get("Team")!.canDownloadAssets).toBe(true);
+    expect(result.get("Team")!.maxWorkspaces).toBe(50);
+    expect(result.get("Pro")!.maxWorkspaces).toBe(fullFeatures.maxWorkspaces);
+  });
+
+  test("extends: throws when extending an unknown plan", () => {
+    expect(() =>
+      parsePlansEnv(
+        JSON.stringify([
+          {
+            name: "Team",
+            extends: "NonExistent",
+            features: { maxWorkspaces: 5 },
+          },
+        ])
+      )
+    ).toThrow('PLANS entry "Team" extends unknown plan "NonExistent"');
+  });
+
+  test("parses a single valid entry", () => {
+    const result = parsePlansEnv(`[${validEntry}]`);
+    expect(result.size).toBe(1);
+    expect(result.get("Pro")).toEqual(fullFeatures);
+  });
+
+  test("parses multiple valid entries", () => {
+    const result = parsePlansEnv(twoEntries);
+    expect(result.size).toBe(2);
+    expect(result.get("Workspaces")!.maxWorkspaces).toBe(10);
+  });
+
+  test("skips entries with invalid features (wrong type), keeps valid ones", () => {
+    const result = parsePlansEnv(
+      JSON.stringify([
+        { name: "Bad", features: { canDownloadAssets: "not-a-bool" } },
+        { name: "Pro", features: fullFeatures },
+      ])
+    );
+    expect(result.size).toBe(1);
+    expect(result.get("Pro")).toEqual(fullFeatures);
+  });
+
+  test("partial features without extends fills in from defaultPlanFeatures", () => {
+    const result = parsePlansEnv(
+      JSON.stringify([{ name: "Pro", features: { canDownloadAssets: true } }])
+    );
+    expect(result.size).toBe(1);
+    expect(result.get("Pro")).toEqual({
+      ...defaultPlanFeatures,
+      canDownloadAssets: true,
+    });
+  });
+
+  test("strips unknown keys from features", () => {
+    const result = parsePlansEnv(
+      JSON.stringify([
+        { name: "Pro", features: { ...fullFeatures, admin: true } },
+      ])
+    );
+    expect(result.size).toBe(1);
+    expect(
+      (result.get("Pro") as Record<string, unknown>)["admin"]
+    ).toBeUndefined();
+  });
+});

package/src/plan-features.ts

@@ -0,0 +1,150 @@
+import { z } from "zod";
+
+/**
+ * Zod schema for validating partial plan features from external sources
+ * (e.g. product.meta JSON blobs). Only known keys of the correct type
+ * are kept — anything else is silently stripped.
+ */
+export const PlanFeaturesSchema = z.object({
+  canDownloadAssets: z.boolean(),
+  canRestoreBackups: z.boolean(),
+  allowAdditionalPermissions: z.boolean(),
+  allowDynamicData: z.boolean(),
+  allowContentMode: z.boolean(),
+  allowStagingPublish: z.boolean(),
+  maxContactEmailsPerProject: z.number().nonnegative(),
+  maxDomainsAllowedPerUser: z.number().nonnegative(),
+  maxDailyPublishesPerUser: z.number().nonnegative(),
+  maxWorkspaces: z.number().nonnegative(),
+  maxProjectsAllowedPerUser: z.number().nonnegative(),
+  maxAssetsPerProject: z.number().nonnegative(),
+  minSeats: z.number().nonnegative(),
+  maxSeatsPerWorkspace: z.number().nonnegative(),
+});
+
+export type PlanFeatures = z.infer<typeof PlanFeaturesSchema>;
+
+// Compile-time guard: all PlanFeatures values must be boolean or number.
+// If a new field with a different type is added to PlanFeaturesSchema, this line will error.
+type _AssertBooleanOrNumber =
+  PlanFeatures extends Record<string, boolean | number> ? true : never;
+const _checkPlanFeaturesValueTypes: _AssertBooleanOrNumber = true;
+void _checkPlanFeaturesValueTypes;
+
+/** Default (free) plan — the baseline, all features disabled / at minimum limits */
+export const defaultPlanFeatures: PlanFeatures = {
+  canDownloadAssets: false,
+  canRestoreBackups: false,
+  allowAdditionalPermissions: false,
+  allowDynamicData: false,
+  allowContentMode: false,
+  allowStagingPublish: false,
+  maxContactEmailsPerProject: 0,
+  maxDomainsAllowedPerUser: 0,
+  maxDailyPublishesPerUser: 10,
+  maxWorkspaces: 1,
+  maxProjectsAllowedPerUser: 100,
+  maxAssetsPerProject: 50,
+  minSeats: 0,
+  maxSeatsPerWorkspace: 0,
+};
+
+/** All user purchases (subscriptions and LTDs). subscriptionId present only for recurring subscriptions */
+export type Purchase = {
+  planName: string;
+  subscriptionId?: string;
+};
+
+/**
+ * Parse the PLANS env variable (JSON array of {name, extends?, features}).
+ * - features is partial when extends is used; the parent plan fills in the rest.
+ * - The final merged features are validated against the full PlanFeaturesSchema.
+ * - Invalid entries are skipped with a console.error.
+ * - An extends reference to an unknown plan name throws an error.
+ * Returns a Map of plan name → resolved PlanFeatures.
+ */
+export const parsePlansEnv = (raw: string): Map<string, PlanFeatures> => {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return new Map();
+    }
+
+    type PlanEntry = {
+      name: string;
+      extends?: string;
+      features: Partial<PlanFeatures>;
+    };
+
+    // First pass: validate entry structure and collect partial features.
+    const entries: PlanEntry[] = parsed.flatMap((item) => {
+      if (
+        typeof item !== "object" ||
+        item === null ||
+        typeof item.name !== "string"
+      ) {
+        console.error("Invalid PLANS entry (missing name):", item);
+        return [];
+      }
+      if ("extends" in item && typeof item.extends !== "string") {
+        console.error("Invalid PLANS entry (extends must be a string):", item);
+        return [];
+      }
+      const result = PlanFeaturesSchema.partial().safeParse(
+        "features" in item ? item.features : {}
+      );
+      if (!result.success) {
+        console.error(
+          `Invalid PLANS entry "${item.name}" features:`,
+          result.error.flatten()
+        );
+        return [];
+      }
+      return [
+        {
+          name: item.name,
+          extends: "extends" in item ? (item.extends as string) : undefined,
+          features: result.data,
+        } satisfies PlanEntry,
+      ];
+    });
+
+    // Build name → partial features map for resolving extends.
+    const byName = new Map<string, Partial<PlanFeatures>>(
+      entries.map((e) => [e.name, e.features])
+    );
+
+    // Second pass: resolve extends and validate the full feature set.
+    // Every entry implicitly extends defaultPlanFeatures; "extends" picks a named plan on top of that.
+    const resolved = new Map<string, PlanFeatures>();
+    for (const entry of entries) {
+      if (entry.extends !== undefined && !byName.has(entry.extends)) {
+        throw new Error(
+          `PLANS entry "${entry.name}" extends unknown plan "${entry.extends}"`
+        );
+      }
+      const parentFeatures: PlanFeatures =
+        entry.extends === undefined
+          ? defaultPlanFeatures
+          : { ...defaultPlanFeatures, ...byName.get(entry.extends)! };
+      const result = PlanFeaturesSchema.safeParse({
+        ...parentFeatures,
+        ...entry.features,
+      });
+      if (!result.success) {
+        console.error(
+          `Invalid PLANS entry "${entry.name}" features after resolving extends:`,
+          result.error.flatten()
+        );
+        continue;
+      }
+      resolved.set(entry.name, result.data);
+    }
+    return resolved;
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("PLANS entry")) {
+      throw error;
+    }
+    return new Map();
+  }
+};

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@webstudio-is/tsconfig/base.json"
+}