decouple logic from taxes

Author: Benjamin Piouffle

server/graphql/v1/CollectiveInterface.js

@@ -1358,15 +1358,12 @@ const CollectiveFields = () => {
           where.slug = { [Op.in]: args.slugs };
         }
 
+        // Filter out forbidden tier types
         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;
-            }
+          const allowedTierTypes = Tier.getAllowedTierTypes(collective, host);
+          if (allowedTierTypes.length !== AllTierTypes.length) {
+            where.type = allowedTierTypes;
           }
         }
 

server/graphql/v2/interface/AccountWithContributions.ts

@@ -62,7 +62,7 @@ export const AccountWithContributionsFields = {
       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.',
+          'When true (default), exclude tiers with types that are no longer supported (e.g. types in host.disabledTierTypes). Use false for edit pages to show all tiers.',
         defaultValue: true,
       },
     },
@@ -78,11 +78,9 @@ export const AccountWithContributionsFields = {
       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 allowedTierTypes = Tier.getAllowedTierTypes(account, host);
+        if (allowedTierTypes.length !== AllTierTypes.length) {
+          where.type = allowedTierTypes;
         }
       }
 
@@ -99,14 +97,10 @@ export const AccountWithContributionsFields = {
   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.',
+      'Tier types that can be created for this account. Uses host disabledTierTypes and account overrides via Tier.isForbiddenTierType.',
     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;
-      }
+      return Tier.getAllowedTierTypes(account, host).toSorted();
     },
   },
   contributors: {

server/graphql/v2/mutation/TierMutations.ts

@@ -5,7 +5,7 @@ import { purgeCacheForCollective } from '../../../lib/cache';
 import { purgeCacheForPage } from '../../../lib/cloudflare';
 import { EntityShortIdPrefix, isEntityPublicId } from '../../../lib/permalink/entity-map';
 import twoFactorAuthLib from '../../../lib/two-factor-authentication';
-import models, { Tier as TierModel } from '../../../models';
+import models, { Tier, Tier as TierModel } from '../../../models';
 import { checkRemoteUserCanUseAccount } from '../../common/scope-check';
 import { NotFound, Unauthorized, ValidationFailed } from '../../errors';
 import { getIntervalFromTierFrequency } from '../enum/TierFrequency';
@@ -102,11 +102,11 @@ const tierMutations = {
       // Check 2FA
       await twoFactorAuthLib.enforceForAccount(req, collective, { onlyAskOnLogin: true });
 
-      // Validate taxable tier restriction when changing type
+      // Validate tier type 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)) {
+      if (args.tier.type && !Tier.getAllowedTierTypes(collective, host).includes(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.',
+          'This tier type is not allowed by your fiscal host. Reach out to them for more information.',
         );
       }
 
@@ -143,11 +143,11 @@ const tierMutations = {
       // Check 2FA
       await twoFactorAuthLib.enforceForAccount(req, account, { onlyAskOnLogin: true });
 
-      // Validate taxable tier restriction
+      // Validate tier type restriction
       const host = await req.loaders.Collective.host.load(account);
-      if (models.Tier.isForbiddenTaxableTierType(account, host, args.tier.type)) {
+      if (args.tier.type && !Tier.getAllowedTierTypes(account, host).includes(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.',
+          'This tier type is not allowed by your fiscal host. Reach out to them for more information.',
         );
       }
 

server/lib/collectivelib.ts

@@ -9,6 +9,7 @@ import { MODERATION_CATEGORIES } from '../constants/moderation-categories';
 import PlatformConstants from '../constants/platform';
 import { VAT_OPTIONS } from '../constants/vat';
 import models, { Collective, Member, Op, sequelize, User } from '../models';
+import { AllTierTypes } from '../models/Tier';
 
 import logger from './logger';
 import { stripHTML } from './sanitize-html';
@@ -177,7 +178,7 @@ export const COLLECTIVE_SETTINGS_KEYS_LIST = [
   'showSetupGuide',
   'showInitialOverviewSubscriptionCard',
   'kyc',
-  'disableTaxableTiers',
+  'disabledTierTypes',
 ];
 
 /**
@@ -199,8 +200,12 @@ export function filterCollectiveSettings(settings: Record<string, unknown> | nul
     preparedSettings.GST = pick(preparedSettings.GST, ['number', 'disabled']);
   }
 
-  if (preparedSettings.disableTaxableTiers !== undefined) {
-    preparedSettings.disableTaxableTiers = Boolean(preparedSettings.disableTaxableTiers);
+  if (preparedSettings.disabledTierTypes !== undefined) {
+    preparedSettings.disabledTierTypes = Array.isArray(preparedSettings.disabledTierTypes)
+      ? preparedSettings.disabledTierTypes.filter(
+          (t: unknown) => typeof t === 'string' && (AllTierTypes as readonly string[]).includes(t),
+        )
+      : [];
   }
 
   // Generate warnings for invalid settings

server/models/Collective.ts

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

server/models/Tier.ts

@@ -1,9 +1,3 @@
-import {
-  accountHasGST,
-  isMemberOfTheEuropeanUnion,
-  isTierTypeSubjectToGST,
-  isTierTypeSubjectToVAT,
-} from '@opencollective/taxes';
 import debugLib from 'debug';
 import slugify from 'limax';
 import { defaults, get, isNil, min, uniq } from 'lodash';
@@ -188,30 +182,19 @@ 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;
+  static getAllowedTierTypes = (account: Collective, host: Collective): readonly TierType[] => {
+    const disabledTypes = host?.settings?.disabledTierTypes;
+    if (!Array.isArray(disabledTypes) || !disabledTypes?.length) {
+      return AllTierTypes;
     }
 
-    // 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);
+    const overrideAllowedTierTypesSettings = get(account, 'data.allowedTierTypes');
+    let overrideAllowedTierTypes: string[] = [];
+    if (overrideAllowedTierTypesSettings && Array.isArray(overrideAllowedTierTypesSettings)) {
+      overrideAllowedTierTypes = overrideAllowedTierTypesSettings;
     }
 
-    return false;
+    return AllTierTypes.filter(type => !disabledTypes.includes(type) || overrideAllowedTierTypes.includes(type));
   };
 
   /**

test/server/graphql/v2/mutation/TierMutations.test.ts

@@ -134,15 +134,14 @@ describe('server/graphql/v2/mutation/TierMutations', () => {
       expect(createdTier.currency).to.eql('EUR');
     });
 
-    it('rejects taxable tier types when host has disableTaxableTiers', async () => {
-      const host = await fakeCollective({ admin: adminUser, countryISO: 'FR' });
+    it('rejects tier types when host has disabledTierTypes', async () => {
+      const host = await fakeCollective({ admin: adminUser });
       const hostedCollective = await fakeCollective({
         admin: adminUser,
         HostCollectiveId: host.id,
         settings: {},
       });
-      await host.update({ settings: { ...host.settings, disableTaxableTiers: true } });
-      await fakeMember({ CollectiveId: adminUser.id, MemberCollectiveId: hostedCollective.id, role: roles.ADMIN });
+      await host.update({ settings: { ...host.settings, disabledTierTypes: ['PRODUCT', 'SERVICE', 'TICKET'] } });
 
       const result = await graphqlQueryV2(
         CREATE_TIER_MUTATION,
@@ -162,15 +161,14 @@ describe('server/graphql/v2/mutation/TierMutations', () => {
       expect(result.errors[0].message).to.include('not allowed');
     });
 
-    it('allows taxable tier types when collective has allowTaxableTiers override in data', async () => {
-      const host = await fakeCollective({ admin: adminUser, countryISO: 'FR' });
+    it('allows tier types when collective has allowedTierTypes override in data', async () => {
+      const host = await fakeCollective({ admin: adminUser });
       const hostedCollective = await fakeCollective({
         admin: adminUser,
         HostCollectiveId: host.id,
       });
-      await hostedCollective.update({ data: { ...hostedCollective.data, allowTaxableTiers: true } });
-      await host.update({ settings: { ...host.settings, disableTaxableTiers: true } });
-      await fakeMember({ CollectiveId: adminUser.id, MemberCollectiveId: hostedCollective.id, role: roles.ADMIN });
+      await hostedCollective.update({ data: { ...hostedCollective.data, allowedTierTypes: ['PRODUCT'] } });
+      await host.update({ settings: { ...host.settings, disabledTierTypes: ['PRODUCT', 'SERVICE', 'TICKET'] } });
 
       const result = await graphqlQueryV2(
         CREATE_TIER_MUTATION,
@@ -186,6 +184,7 @@ describe('server/graphql/v2/mutation/TierMutations', () => {
         },
         adminUser,
       );
+      result.errors && console.error(result.errors);
       expect(result.errors).to.not.exist;
       expect(result.data.createTier.legacyId).to.exist;
     });
@@ -295,14 +294,13 @@ describe('server/graphql/v2/mutation/TierMutations', () => {
       expect(editedTier.interval).to.equal(existingTier.interval);
     });
 
-    it('rejects changing tier type to taxable when host has disableTaxableTiers', async () => {
-      const host = await fakeCollective({ admin: adminUser, countryISO: 'FR' });
+    it('rejects changing tier type when host has disabledTierTypes', async () => {
+      const host = await fakeCollective({ admin: adminUser });
       const hostedCollective = await fakeCollective({
         admin: adminUser,
         HostCollectiveId: host.id,
       });
-      await host.update({ settings: { ...host.settings, disableTaxableTiers: true } });
-      await fakeMember({ CollectiveId: adminUser.id, MemberCollectiveId: hostedCollective.id, role: roles.ADMIN });
+      await host.update({ settings: { ...host.settings, disabledTierTypes: ['PRODUCT', 'SERVICE', 'TICKET'] } });
 
       const tier = await fakeTier({
         CollectiveId: hostedCollective.id,