Edition & Plan Limits

┌─────────────────────────────────────────────────────┐
│                     Frontend                         │
│  usePlanLimits() / usePlanLimitsFromData()           │
│  PlanLimitBanner, disabled buttons, tooltips         │
│  Edition from: import.meta.env.VITE_SAYR_EDITION    │
└──────────────────────┬──────────────────────────────┘
                       │ fetch (POST/PATCH)
┌──────────────────────▼──────────────────────────────┐
│                     Backend                          │
│  enforceLimit()  — instance-level (self-hosted)      │
│  canCreateResource() — plan-level (per-org)          │
│  Edition from: process.env / SAYR_EDITION_BAKED      │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│               @repo/edition                          │
│  Types, constants, pure functions, server wrappers   │
└─────────────────────────────────────────────────────┘

type Edition = "cloud" | "community" | "enterprise";

interface PlanLimits {
   members: number | null;       // null = unlimited
   savedViews: number | null;
   issueTemplates: number | null;
   teams: number | null;
   releases: number | null;
}

type CloudPlan = "free" | "pro";
type SelfHostedPlan = "self-hosted";
type PlanId = CloudPlan | SelfHostedPlan;

// Cloud free plan limits
const FREE_LIMITS: PlanLimits = {
   members: 5, savedViews: 3, issueTemplates: 3, teams: 1, releases: 0,
};

// Cloud pro plan -- effectively unlimited
const CLOUD_PLAN_LIMITS = {
   free: FREE_LIMITS,
   pro: { members: 1000, savedViews: null, issueTemplates: null, teams: null, releases: null },
};

// Self-hosted editions -- unlimited everything
const SELF_HOSTED_LIMITS: PlanLimits = {
   members: 1000, savedViews: null, issueTemplates: null, teams: null, releases: null,
};

// Backend (server-side) -- can use anything
import { canCreateResource, getLimitReachedMessage, isCloud } from "@repo/edition";

// Frontend (browser) -- ONLY pure functions and types
import { canCreate, isOverLimit, getLimitsForEdition, getResourceLimitMessage } from "@repo/edition";
import type { Edition, PlanLimits } from "@repo/edition";

import { usePlanLimits } from "@/hooks/usePlanLimits";

function MyComponent() {
   const { canCreateResource, isOverLimit, getLimitMessage, limits, counts, isCloud } = usePlanLimits();

   if (!canCreateResource("savedViews")) {
      // Show lock icon or disable button
   }

   if (isOverLimit("savedViews")) {
      // Block editing too (user must delete to get back under)
   }

   const message = getLimitMessage("savedViews");
   // "You've reached the maximum of 3 saved views on the free plan..."
}

import { usePlanLimitsFromData } from "@/hooks/usePlanLimits";

function SettingsPage() {
   const { organization, views, issueTemplates, releases } = useLayoutOrganizationSettings();

   const planLimits = usePlanLimitsFromData({
      plan: organization.plan,
      memberCount: organization.members.length,
      viewCount: views.length,
      issueTemplateCount: issueTemplates.length,
      releaseCount: releases.length,
   });

   // Same API as usePlanLimits()
}

import { PlanLimitBanner } from "@/components/generic/PlanLimitBanner";

<PlanLimitBanner
   title="Saved view limit reached"
   description={getLimitMessage("savedViews")}
/>

import { enforceLimit } from "@/util";

const limitRes = await enforceLimit({
   c,
   limitKey: "savedViews",
   table: schema.savedView,
   traceName: "saved_view.count_all",
   entityName: "saved view",
   traceAsync,
   recordWideError,
});
if (limitRes) return limitRes;

import { canCreateResource, getLimitReachedMessage } from "@repo/edition";

// Count org-specific resources
const orgViews = await db.query.savedView.findMany({
   where: eq(schema.savedView.organizationId, orgId),
});

if (!canCreateResource("savedViews", orgViews.length, org.plan)) {
   return c.json({
      success: false,
      error: getLimitReachedMessage("savedViews", org.plan),
   }, 403);
}

import { getEffectiveLimits } from "@repo/edition";

const limits = getEffectiveLimits(org.plan);
if (limits.savedViews !== null) {
   const orgViews = await db.query.savedView.findMany({
      where: eq(schema.savedView.organizationId, orgId),
   });
   if (orgViews.length > limits.savedViews) {
      return c.json({
         success: false,
         error: "You are over the saved view limit. Please delete some views before editing.",
      }, 403);
   }
}

{canCreateResource("savedViews") ? (
   <CreateButton />
) : (
   <Tooltip content={getLimitMessage("savedViews")}>
      <Button variant="ghost" disabled>
         <IconLock className="size-4" />
      </Button>
   </Tooltip>
)}

<Button
   disabled={isOverLimit("savedViews")}
   onClick={handleSave}
>
   Save
</Button>
{isOverLimit("savedViews") && (
   <p className="text-destructive text-xs">
      You are over the saved view limit. Delete some views before editing.
   </p>
)}

// packages/edition/src/types.ts
export interface PlanLimits {
   // ...existing fields
   myNewResource: number | null;
}

// packages/edition/src/capabilities.ts
export const CLOUD_PLAN_LIMITS = {
   free: { ...existing, myNewResource: 3 },
   pro: { ...existing, myNewResource: null },
};

export const SELF_HOSTED_LIMITS = { ...existing, myNewResource: null };
export const FREE_LIMITS = { ...existing, myNewResource: 3 };

case "myNewResource":
   return "My new resources";

const counts: Record<keyof PlanLimits, number> = {
   // ...existing
   myNewResource: data.myNewResourceCount,
};

// Tier 1: instance-level (self-hosted)
const limitRes = await enforceLimit({
   c, limitKey: "myNewResource", table: schema.myNewResource,
   traceName: "my_new_resource.count_all", entityName: "resource",
   traceAsync, recordWideError,
});
if (limitRes) return limitRes;

// Tier 2: plan-level (per-org)
const orgResources = await db.query.myNewResource.findMany({
   where: eq(schema.myNewResource.organizationId, orgId),
});
if (!canCreateResource("myNewResource", orgResources.length, org.plan)) {
   return c.json({
      success: false,
      error: getLimitReachedMessage("myNewResource", org.plan),
   }, 403);
}