feat(table): make plan table limits configurable via env vars

Author: waleedlatif1

apps/sim/lib/core/config/env.ts

@@ -60,6 +60,16 @@ export const env = createEnv({
     ENTERPRISE_STORAGE_LIMIT_GB:           z.number().optional().default(500),     // Default storage limit in GB for enterprise tier (can be overridden per org)
     BILLING_ENABLED:                       z.boolean().optional(),                 // Enable billing enforcement and usage tracking
 
+    // Table feature limits (per plan). Apply when billing is disabled (free tier defaults) or for billed plans.
+    FREE_TABLES_LIMIT:                     z.number().optional(),                  // Max user tables per workspace on free tier (default: 3)
+    FREE_TABLE_ROWS_LIMIT:                 z.number().optional(),                  // Max rows per table on free tier (default: 1000)
+    PRO_TABLES_LIMIT:                      z.number().optional(),                  // Max user tables per workspace on pro tier (default: 25)
+    PRO_TABLE_ROWS_LIMIT:                  z.number().optional(),                  // Max rows per table on pro tier (default: 5000)
+    TEAM_TABLES_LIMIT:                     z.number().optional(),                  // Max user tables per workspace on team tier (default: 100)
+    TEAM_TABLE_ROWS_LIMIT:                 z.number().optional(),                  // Max rows per table on team tier (default: 10000)
+    ENTERPRISE_TABLES_LIMIT:               z.number().optional(),                  // Max user tables per workspace on enterprise tier (default: 10000)
+    ENTERPRISE_TABLE_ROWS_LIMIT:           z.number().optional(),                  // Max rows per table on enterprise tier (default: 1000000)
+
     // Credit-tier Stripe prices (monthly)
     STRIPE_PRICE_TIER_25_MO:               z.string().min(1).optional(),           // Pro: $25/mo (6,000 credits)
     STRIPE_PRICE_TIER_100_MO:              z.string().min(1).optional(),           // Max: $100/mo (25,000 credits)

apps/sim/lib/table/billing.ts

@@ -8,7 +8,7 @@ import { createLogger } from '@sim/logger'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
 import { getPlanTypeForLimits } from '@/lib/billing/plan-helpers'
 import { getWorkspaceBilledAccountUserId } from '@/lib/workspaces/utils'
-import { type PlanName, TABLE_PLAN_LIMITS, type TablePlanLimits } from './constants'
+import { getTablePlanLimits, type PlanName, type TablePlanLimits } from './constants'
 
 const logger = createLogger('TableBilling')
 
@@ -22,18 +22,20 @@ const logger = createLogger('TableBilling')
  * @returns Table limits based on the workspace's billing plan
  */
 export async function getWorkspaceTableLimits(workspaceId: string): Promise<TablePlanLimits> {
+  const planLimits = getTablePlanLimits()
+
   try {
     const billedAccountUserId = await getWorkspaceBilledAccountUserId(workspaceId)
 
     if (!billedAccountUserId) {
       logger.warn('No billed account found for workspace, using free tier limits', { workspaceId })
-      return TABLE_PLAN_LIMITS.free
+      return planLimits.free
     }
 
     const subscription = await getHighestPrioritySubscription(billedAccountUserId)
     const planName = getPlanTypeForLimits(subscription?.plan) as PlanName
 
-    const limits = TABLE_PLAN_LIMITS[planName] ?? TABLE_PLAN_LIMITS.free
+    const limits = planLimits[planName] ?? planLimits.free
 
     logger.info('Retrieved workspace table limits', {
       workspaceId,
@@ -48,7 +50,7 @@ export async function getWorkspaceTableLimits(workspaceId: string): Promise<Tabl
       workspaceId,
       error,
     })
-    return TABLE_PLAN_LIMITS.free
+    return planLimits.free
   }
 }
 

apps/sim/lib/table/constants.ts

@@ -2,6 +2,8 @@
  * Limits and constants for user-defined tables.
  */
 
+import { env } from '@/lib/core/config/env'
+
 export const TABLE_LIMITS = {
   MAX_TABLES_PER_WORKSPACE: 100,
   MAX_ROWS_PER_TABLE: 10000,
@@ -24,9 +26,11 @@ export const TABLE_LIMITS = {
 } as const
 
 /**
- * Plan-based table limits.
+ * Default plan-based table limits. Each value can be overridden via env vars
+ * (see `getTablePlanLimits`) so self-hosted deployments can raise the free-tier
+ * caps that apply when billing is disabled.
  */
-export const TABLE_PLAN_LIMITS = {
+export const DEFAULT_TABLE_PLAN_LIMITS = {
   free: {
     maxTables: 3,
     maxRowsPerTable: 1000,
@@ -45,13 +49,42 @@ export const TABLE_PLAN_LIMITS = {
   },
 } as const
 
-export type PlanName = keyof typeof TABLE_PLAN_LIMITS
+export type PlanName = keyof typeof DEFAULT_TABLE_PLAN_LIMITS
 
 export interface TablePlanLimits {
   maxTables: number
   maxRowsPerTable: number
 }
 
+export type TablePlanLimitsByPlan = Record<PlanName, TablePlanLimits>
+
+/**
+ * Returns plan-based table limits, applying env var overrides on top of the
+ * defaults. When no override is set the value falls back to the hosted-default
+ * constant so behavior is unchanged for the hosted product.
+ */
+export function getTablePlanLimits(): TablePlanLimitsByPlan {
+  return {
+    free: {
+      maxTables: env.FREE_TABLES_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.free.maxTables,
+      maxRowsPerTable: env.FREE_TABLE_ROWS_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.free.maxRowsPerTable,
+    },
+    pro: {
+      maxTables: env.PRO_TABLES_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.pro.maxTables,
+      maxRowsPerTable: env.PRO_TABLE_ROWS_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.pro.maxRowsPerTable,
+    },
+    team: {
+      maxTables: env.TEAM_TABLES_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.team.maxTables,
+      maxRowsPerTable: env.TEAM_TABLE_ROWS_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.team.maxRowsPerTable,
+    },
+    enterprise: {
+      maxTables: env.ENTERPRISE_TABLES_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.enterprise.maxTables,
+      maxRowsPerTable:
+        env.ENTERPRISE_TABLE_ROWS_LIMIT ?? DEFAULT_TABLE_PLAN_LIMITS.enterprise.maxRowsPerTable,
+    },
+  }
+}
+
 export const COLUMN_TYPES = ['string', 'number', 'boolean', 'date', 'json'] as const
 
 export const NAME_PATTERN = /^[a-z_][a-z0-9_]*$/i

helm/sim/values.yaml

@@ -166,6 +166,17 @@ app:
     EXECUTION_TIMEOUT_ASYNC_TEAM: "5400"                  # Team tier async timeout (90 minutes)
     EXECUTION_TIMEOUT_ASYNC_ENTERPRISE: "5400"            # Enterprise tier async timeout (90 minutes)
 
+    # Table Feature Limits (per workspace, per plan)
+    # Apply when billing is disabled (free tier defaults) or for billed plans
+    FREE_TABLES_LIMIT: "3"                                # Max user tables per workspace on free tier
+    FREE_TABLE_ROWS_LIMIT: "1000"                         # Max rows per table on free tier
+    PRO_TABLES_LIMIT: "25"                                # Max user tables per workspace on pro tier
+    PRO_TABLE_ROWS_LIMIT: "5000"                          # Max rows per table on pro tier
+    TEAM_TABLES_LIMIT: "100"                              # Max user tables per workspace on team tier
+    TEAM_TABLE_ROWS_LIMIT: "10000"                        # Max rows per table on team tier
+    ENTERPRISE_TABLES_LIMIT: "10000"                      # Max user tables per workspace on enterprise tier
+    ENTERPRISE_TABLE_ROWS_LIMIT: "1000000"                # Max rows per table on enterprise tier
+
     # Isolated-VM Worker Pool Configuration
     IVM_POOL_SIZE: "4"                                    # Max worker processes in pool
     IVM_MAX_CONCURRENT: "10000"                           # Max concurrent executions globally