feat: setting to disable taxable tiers

Author: Benjamin Piouffle

codecov.yml

@@ -8,6 +8,8 @@ coverage:
 ignore:
   - reports
   - migrations
+  - eslint-rules
+  - config
 
 comment:
   behavior: once # update, if exists. Otherwise post new. Skip if deleted.

package-lock.json

@@ -45,7 +45,7 @@
     "@node-oauth/oauth2-server": "5.2.1",
     "@octokit/auth-oauth-app": "9.0.3",
     "@octokit/rest": "22.0.1",
-    "@opencollective/taxes": "5.3.0",
+    "@opencollective/taxes": "5.4.0",
     "@opensearch-project/opensearch": "^3.4.0",
     "@opentelemetry/context-async-hooks": "2.3.0",
     "@opentelemetry/instrumentation": "0.209.0",

package.json

@@ -28,6 +28,7 @@ import queries from '../../lib/queries';
 import { canSeeLegalName } from '../../lib/user-permissions';
 import models, { Op } from '../../models';
 import { PayoutMethodTypes } from '../../models/PayoutMethod';
+import Tier, { AllTierTypes } from '../../models/Tier';
 import { hostResolver } from '../common/collective';
 import { GraphQLCollectiveFeatures } from '../common/CollectiveFeatures';
 import { getContextPermission, PERMISSION_TYPE } from '../common/context-permissions';
@@ -511,6 +512,12 @@ export const CollectiveInterfaceType = new GraphQLInterfaceType({
           id: { type: GraphQLInt },
           slug: { type: GraphQLString },
           slugs: { type: new GraphQLList(GraphQLString) },
+          onlyValid: {
+            type: GraphQLBoolean,
+            defaultValue: true,
+            description:
+              'When true (default), exclude tiers with types that are no longer supported. Use false for edit pages to show all tiers.',
+          },
         },
       },
       orders: {
@@ -1333,8 +1340,14 @@ const CollectiveFields = () => {
         id: { type: GraphQLInt },
         slug: { type: GraphQLString },
         slugs: { type: new GraphQLList(GraphQLString) },
+        onlyValid: {
+          type: GraphQLBoolean,
+          defaultValue: true,
+          description:
+            'When true (default), exclude tiers with types that are no longer supported. Use false for edit pages to show all tiers.',
+        },
       },
-      resolve(collective, args) {
+      async resolve(collective, args, req) {
         const where = {};
 
         if (args.id) {
@@ -1345,6 +1358,18 @@ const CollectiveFields = () => {
           where.slug = { [Op.in]: args.slugs };
         }
 
+        if (args.onlyValid !== false) {
+          const host = await req.loaders.Collective.host.load(collective);
+          if (Tier.hostHasDisabledTaxableTiers(host)) {
+            const validTypes = AllTierTypes.filter(
+              type => !models.Tier.isForbiddenTaxableTierType(collective, host, type),
+            );
+            if (validTypes.length !== AllTierTypes.length) {
+              where.type = validTypes;
+            }
+          }
+        }
+
         return collective.getTiers({
           where,
           order: [['amount', 'ASC']],

server/graphql/v1/CollectiveInterface.js

@@ -11,16 +11,17 @@ import {
 } from 'graphql';
 import { GraphQLDateTime } from 'graphql-scalars';
 import { isNil, omit } from 'lodash';
-import { OrderItem, QueryTypes } from 'sequelize';
+import { OrderItem, QueryTypes, WhereOptions } from 'sequelize';
 
 import PlatformConstants from '../../../constants/platform';
 import { filterContributors } from '../../../lib/contributors';
 import models, { Collective, sequelize } from '../../../models';
+import Tier, { AllTierTypes, TierType } from '../../../models/Tier';
 import { checkReceiveFinancialContributions } from '../../common/features';
 import { GraphQLAccountCollection } from '../collection/AccountCollection';
 import { GraphQLContributorCollection } from '../collection/ContributorCollection';
 import { GraphQLTierCollection } from '../collection/TierCollection';
-import { GraphQLAccountType, GraphQLMemberRole } from '../enum';
+import { GraphQLAccountType, GraphQLMemberRole, GraphQLTierType } from '../enum';
 
 import { CollectionArgs } from './Collection';
 
@@ -58,22 +59,56 @@ export const AccountWithContributionsFields = {
         description: 'The number of results to fetch',
         defaultValue: 100,
       },
+      onlyValid: {
+        type: GraphQLBoolean,
+        description:
+          'When true (default), exclude tiers with types that are no longer supported (e.g. taxable tiers when disabled by host). Use false for edit pages to show all tiers.',
+        defaultValue: true,
+      },
     },
-    async resolve(account: Collective, args: Record<string, unknown>): Promise<Record<string, unknown>> {
+    async resolve(
+      account: Collective,
+      args: Record<string, unknown>,
+      req: express.Request,
+    ): Promise<Record<string, unknown>> {
       if (!account.hasBudget()) {
         return { nodes: [], totalCount: 0 };
       }
 
-      const query = {
-        where: { CollectiveId: account.id },
+      const where: WhereOptions<Tier> = { CollectiveId: account.id };
+      if (args.onlyValid !== false) {
+        const host = await req.loaders.Collective.host.load(account);
+        if (Tier.hostHasDisabledTaxableTiers(host)) {
+          const validTypes = AllTierTypes.filter(type => !models.Tier.isForbiddenTaxableTierType(account, host, type));
+          if (validTypes.length !== AllTierTypes.length) {
+            where.type = validTypes;
+          }
+        }
+      }
+
+      const result = await models.Tier.findAndCountAll({
+        where,
         order: [['amount', 'ASC']] as OrderItem[],
         limit: <number>args.limit,
         offset: <number>args.offset,
-      };
-      const result = await models.Tier.findAndCountAll(query);
+      });
+
       return { nodes: result.rows, totalCount: result.count, limit: args.limit, offset: args.offset };
     },
   },
+  supportedTierTypes: {
+    type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLTierType))),
+    description:
+      'Tier types that can be created for this account. Uses host tax settings and account overrides via Tier.isForbiddenTaxableTierType.',
+    async resolve(account: Collective, _, req: express.Request): Promise<readonly TierType[]> {
+      const host = await req.loaders.Collective.host.load(account);
+      if (Tier.hostHasDisabledTaxableTiers(host)) {
+        return AllTierTypes.filter(tierType => !models.Tier.isForbiddenTaxableTierType(account, host, tierType));
+      } else {
+        return AllTierTypes;
+      }
+    },
+  },
   contributors: {
     type: new GraphQLNonNull(GraphQLContributorCollection),
     description: 'All the persons and entities that contribute to this account',

server/graphql/v2/interface/AccountWithContributions.ts

@@ -7,7 +7,7 @@ import { EntityShortIdPrefix, isEntityPublicId } from '../../../lib/permalink/en
 import twoFactorAuthLib from '../../../lib/two-factor-authentication';
 import models, { Tier as TierModel } from '../../../models';
 import { checkRemoteUserCanUseAccount } from '../../common/scope-check';
-import { NotFound, Unauthorized } from '../../errors';
+import { NotFound, Unauthorized, ValidationFailed } from '../../errors';
 import { getIntervalFromTierFrequency } from '../enum/TierFrequency';
 import { idDecode, IDENTIFIER_TYPES } from '../identifiers';
 import { fetchAccountWithReference, GraphQLAccountReferenceInput } from '../input/AccountReferenceInput';
@@ -102,6 +102,14 @@ const tierMutations = {
       // Check 2FA
       await twoFactorAuthLib.enforceForAccount(req, collective, { onlyAskOnLogin: true });
 
+      // Validate taxable tier restriction when changing type
+      const host = await req.loaders.Collective.host.load(collective);
+      if (args.tier.type && models.Tier.isForbiddenTaxableTierType(collective, host, args.tier.type)) {
+        throw new ValidationFailed(
+          'This tier type is not allowed by your fiscal host, because it is subject to taxes in your country. Reach out to them for more information.',
+        );
+      }
+
       // Update tier
       const updatedTier = await tier.update(transformTierInputToAttributes(args.tier));
 
@@ -135,6 +143,14 @@ const tierMutations = {
       // Check 2FA
       await twoFactorAuthLib.enforceForAccount(req, account, { onlyAskOnLogin: true });
 
+      // Validate taxable tier restriction
+      const host = await req.loaders.Collective.host.load(account);
+      if (models.Tier.isForbiddenTaxableTierType(account, host, args.tier.type)) {
+        throw new ValidationFailed(
+          'This tier type is not allowed by your fiscal host, because it is subject to taxes in your country. Reach out to them for more information.',
+        );
+      }
+
       // Create tier
       const tier = await TierModel.create({
         ...transformTierInputToAttributes(args.tier),

server/graphql/v2/mutation/TierMutations.ts

@@ -177,6 +177,7 @@ export const COLLECTIVE_SETTINGS_KEYS_LIST = [
   'showSetupGuide',
   'showInitialOverviewSubscriptionCard',
   'kyc',
+  'disableTaxableTiers',
 ];
 
 /**
@@ -198,6 +199,10 @@ export function filterCollectiveSettings(settings: Record<string, unknown> | nul
     preparedSettings.GST = pick(preparedSettings.GST, ['number', 'disabled']);
   }
 
+  if (preparedSettings.disableTaxableTiers !== undefined) {
+    preparedSettings.disableTaxableTiers = Boolean(preparedSettings.disableTaxableTiers);
+  }
+
   // Generate warnings for invalid settings
   Object.keys(settings).forEach(key => {
     if (!COLLECTIVE_SETTINGS_KEYS_LIST.includes(key)) {

server/lib/collectivelib.ts

@@ -192,6 +192,7 @@ type Settings = {
   applyMessage?: string;
   tos?: string;
   expenseTypes?: Partial<Record<ExpenseType, boolean>>;
+  disableTaxableTiers?: boolean;
 } & TaxSettings;
 
 type Data = Partial<{

server/models/Collective.ts

@@ -1,6 +1,12 @@
+import {
+  accountHasGST,
+  isMemberOfTheEuropeanUnion,
+  isTierTypeSubjectToGST,
+  isTierTypeSubjectToVAT,
+} from '@opencollective/taxes';
 import debugLib from 'debug';
 import slugify from 'limax';
-import { defaults, isNil, min, uniq } from 'lodash';
+import { defaults, get, isNil, min, uniq } from 'lodash';
 import pMap from 'p-map';
 import { CreationOptional, InferAttributes, InferCreationAttributes, NonAttribute } from 'sequelize';
 import Temporal from 'sequelize-temporal';
@@ -30,7 +36,8 @@ const longDescriptionSanitizerOpts = buildSanitizerOptions({
   videoIframes: true,
 });
 
-export type TierType = 'TIER' | 'MEMBERSHIP' | 'DONATION' | 'TICKET' | 'PRODUCT' | 'SERVICE';
+export const AllTierTypes = ['TIER', 'MEMBERSHIP', 'DONATION', 'TICKET', 'PRODUCT', 'SERVICE'] as const;
+export type TierType = (typeof AllTierTypes)[number];
 
 class Tier extends ModelWithPublicId<EntityShortIdPrefix.Tier, InferAttributes<Tier>, InferCreationAttributes<Tier>> {
   public static readonly nanoIdPrefix = EntityShortIdPrefix.Tier;
@@ -181,6 +188,32 @@ class Tier extends ModelWithPublicId<EntityShortIdPrefix.Tier, InferAttributes<T
     });
   };
 
+  static hostHasDisabledTaxableTiers = (host: Collective): boolean => {
+    return Boolean(host?.settings?.disableTaxableTiers);
+  };
+
+  static isForbiddenTaxableTierType = (account: Collective, host: Collective, tierType: TierType): boolean => {
+    // Check if taxable tiers are disabled at the host level
+    if (!Tier.hostHasDisabledTaxableTiers(host)) {
+      return false;
+    }
+
+    // Check if taxable tiers are allowed at the account level (override)
+    const allowTaxableTiers = get(account, 'data.allowTaxableTiers');
+    if (allowTaxableTiers === true || (Array.isArray(allowTaxableTiers) && allowTaxableTiers.includes(tierType))) {
+      return false;
+    }
+
+    // Check if the tier type is subject to VAT or GST
+    if (isMemberOfTheEuropeanUnion(host.countryISO)) {
+      return isTierTypeSubjectToVAT(tierType);
+    } else if (host.countryISO === 'NZ' || accountHasGST(account)) {
+      return isTierTypeSubjectToGST(tierType);
+    }
+
+    return false;
+  };
+
   /**
    * Getters
    */
@@ -289,7 +322,12 @@ Tier.init(
       type: DataTypes.STRING, // TIER, TICKET, DONATION, SERVICE, PRODUCT, MEMBERSHIP
       defaultValue: 'TIER',
       allowNull: false,
-      // TODO validate value
+      validate: {
+        isIn: {
+          args: [AllTierTypes],
+          msg: 'Invalid tier type',
+        },
+      },
     },
 
     description: {