feed-common 1.10.5 → 1.11.0

package/src/utils/profile.ts

@@ -1,180 +1,172 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import {
-  OptionType,
-  OptionTypeItem,
-  OptionTypeGroup,
-  ProductUploadProfile,
-  ProductUploadMapping,
-  ProductUploadRuleFilterType,
-  RuleOperatorsType,
-  ProductUploadRuleItem,
-  ProductUploadRuleSection,
-  ProductUploadRules,
+    OptionType,
+    OptionTypeItem,
+    OptionTypeGroup,
+    ProductUploadProfile,
+    ProductUploadMapping,
+    ProductUploadRuleFilterType,
+    RuleOperatorsType,
+    ProductUploadRuleItem,
+    ProductUploadRuleSection,
+    ProductUploadRules,
 } from '../types/profile.types.js';
 import { ProductUploadMappings } from '../constants/profile.constants.js';
 import { code } from './utils.js';
 
-export function checkRuleDuplication (rules: ProductUploadRuleItem[]): string[] {
-  return rules
-    .map((r) => {
-      for (const rule of rules) {
-        if (
-          r.id !== rule.id &&
-          r.attribute === rule.attribute &&
-          r.operator === rule.operator &&
-          r.value === rule.value
-        ) {
-          return r.id;
-        }
-      }
-      return null;
-    })
-    .filter(Boolean) as string[];
+/**
+ * Check for rules duplication
+ * @param rules
+ * @returns
+ */
+export function checkRuleDuplication(rules: ProductUploadRuleItem[]): string[] {
+    return rules
+        .map(r => {
+            for (const rule of rules) {
+                if (
+                    r.id !== rule.id &&
+                    r.attribute === rule.attribute &&
+                    r.operator === rule.operator &&
+                    r.value === rule.value
+                ) {
+                    return r.id;
+                }
+            }
+            return null;
+        })
+        .filter(Boolean) as string[];
 }
 
-export function checkRuleAlwaysness (rules: ProductUploadRuleItem[]): string[] {
-  return rules
-    .map((r) => {
-      for (const rule of rules) {
-        if (isExlusive(r, rule)) {
-          return r.id;
-        }
-      }
-      return null;
-    })
-    .filter(Boolean) as string[];
+/**
+ * Check if rules mutually exclusive
+ * @param rules
+ * @returns
+ */
+export function checkRuleAlwaysness(rules: ProductUploadRuleItem[]): string[] {
+    return rules
+        .map(r => {
+            for (const rule of rules) {
+                if (isExclusive(r, rule)) {
+                    return r.id;
+                }
+            }
+            return null;
+        })
+        .filter(Boolean) as string[];
 }
 
-export function checkRuleDeadlocks (
-  sections: ProductUploadRuleSection[]
-): string[] {
-  let totalList = [] as string[];
-
-  for (let i = 0; i < sections.length; i++) {
-    const currentSection = sections[i];
-    const currentList = [] as string[];
-
-    for (let y = 0; y < sections.length; y++) {
-      if (i === y) {
-        continue;
-      }
-
-      from_start: for (const ruleA of currentSection.ruleItems) {
-        for (const ruleB of sections[y].ruleItems) {
-          if (isExlusive(ruleA, ruleB)) {
-            currentList.push(ruleA.id);
-            continue from_start;
-          }
+/**
+ * Checks for contradictions in rules, e.g A == 1 and A != 1
+ * @param sections
+ * @returns
+ */
+export function checkRuleDeadlocks(input: ProductUploadRuleSection[]): string[] {
+    const totalList = [] as string[][];
+    const sections = structuredClone(input);
+
+    for (let i = 0; i < sections.length - 1; i++) {
+        const currentSection = sections[i];
+
+        for (let y = i + 1; y < sections.length; y++) {
+            from_start: for (let x = 0; x < currentSection.ruleItems.length; x++) {
+                const ruleA = currentSection.ruleItems[x];
+                for (let z = 0; z < sections[y].ruleItems.length; z++) {
+                    const ruleB = sections[y].ruleItems[z];
+                    if (isExclusive(ruleA, ruleB)) {
+                        totalList.push([ruleA.id, ruleB.id]);
+                        currentSection.ruleItems.splice(x, 1);
+                        sections[y].ruleItems.splice(z, 1);
+                        continue from_start;
+                    }
+                }
+            }
         }
-      }
     }
 
-    if (currentList.length === currentSection.ruleItems.length) {
-      totalList = [...totalList, ...currentList];
-    }
-  }
-
-  return totalList;
+    return sections.some(s => s.ruleItems.length === 0) ? totalList.flat() : [];
 }
 
-function isExlusive (
-  rule1: ProductUploadRuleItem,
-  rule2: ProductUploadRuleItem
-): boolean {
-  return (
-    rule1.id !== rule2.id &&
-    rule1.attribute === rule2.attribute &&
-    rule1.operator ===
-      getOperatorCounterpart(rule2.operator as keyof RuleOperatorsType) &&
-    rule1.value === rule2.value
-  );
+function isExclusive(rule1: ProductUploadRuleItem, rule2: ProductUploadRuleItem): boolean {
+    return (
+        rule1.id !== rule2.id &&
+        rule1.attribute === rule2.attribute &&
+        rule1.operator === getOperatorCounterpart(rule2.operator as keyof RuleOperatorsType) &&
+        rule1.value === rule2.value
+    );
 }
 
-function getOperatorCounterpart (
-  operator: keyof RuleOperatorsType
-): keyof RuleOperatorsType {
-  switch (operator) {
-    case 'equals':
-      return 'notEquals';
-    case 'notEquals':
-      return 'equals';
-    case 'contains':
-      return 'notContains';
-    case 'notContains':
-      return 'contains';
-    case 'startsWith':
-      return 'notStartsWith';
-    case 'notStartsWith':
-      return 'startsWith';
-    case 'endsWith':
-      return 'notEndsWith';
-    case 'notEndsWith':
-      return 'endsWith';
-    case 'in':
-      return 'notIn';
-    case 'notIn':
-      return 'in';
-    case 'greater':
-      return 'less';
-    case 'less':
-      return 'greater';
-    case 'greaterOrEqual':
-      return 'lessOrEqual';
-    case 'lessOrEqual':
-      return 'greaterOrEqual';
-    default:
-      throw new Error(`Unknown operator ${String(operator)}`);
-  }
+export function getOperatorCounterpart(operator: keyof RuleOperatorsType): keyof RuleOperatorsType {
+    switch (operator) {
+        case 'equals':
+            return 'notEquals';
+        case 'notEquals':
+            return 'equals';
+        case 'contains':
+            return 'notContains';
+        case 'notContains':
+            return 'contains';
+        case 'startsWith':
+            return 'notStartsWith';
+        case 'notStartsWith':
+            return 'startsWith';
+        case 'endsWith':
+            return 'notEndsWith';
+        case 'notEndsWith':
+            return 'endsWith';
+        case 'in':
+            return 'notIn';
+        case 'notIn':
+            return 'in';
+        case 'greater':
+            return 'less';
+        case 'less':
+            return 'greater';
+        case 'greaterOrEqual':
+            return 'lessOrEqual';
+        case 'lessOrEqual':
+            return 'greaterOrEqual';
+        default:
+            throw new Error(`Unknown operator ${String(operator)}`);
+    }
 }
 
-export function getEmptyRuleItem (
-  attribute: ProductUploadRuleFilterType['value'] = ''
-): ProductUploadRuleItem {
-  return { attribute, operator: '', value: '', id: code() };
+export function getEmptyRuleItem(attribute: ProductUploadRuleFilterType['value'] = ''): ProductUploadRuleItem {
+    return { attribute, operator: '', value: '', id: code() };
 }
 
-export function sortMappings (
-  a: ProductUploadMapping,
-  b: ProductUploadMapping
-): number {
-  if (!a.attribute) {
-    return 1;
-  }
-
-  if (!b.attribute) {
-    return -1;
-  }
-
-  const sourceA = ProductUploadMappings.find(
-    (m) => m.attribute === a.attribute
-  );
-  const sourceB = ProductUploadMappings.find(
-    (m) => m.attribute === b.attribute
-  );
-
-  if (sourceA?.required && !sourceB?.required) {
-    return -1;
-  }
-
-  if (sourceB?.required && !sourceA?.required) {
-    return 1;
-  }
-
-  if (a.attribute < b.attribute) {
-    return -1;
-  }
-
-  if (a.attribute > b.attribute) {
-    return 1;
-  }
-
-  return 0;
+export function sortMappings(a: ProductUploadMapping, b: ProductUploadMapping): number {
+    if (!a.attribute) {
+        return 1;
+    }
+
+    if (!b.attribute) {
+        return -1;
+    }
+
+    const sourceA = ProductUploadMappings.find(m => m.attribute === a.attribute);
+    const sourceB = ProductUploadMappings.find(m => m.attribute === b.attribute);
+
+    if (sourceA?.required && !sourceB?.required) {
+        return -1;
+    }
+
+    if (sourceB?.required && !sourceA?.required) {
+        return 1;
+    }
+
+    if (a.attribute < b.attribute) {
+        return -1;
+    }
+
+    if (a.attribute > b.attribute) {
+        return 1;
+    }
+
+    return 0;
 }
 
-export function hasRules (rules: ProductUploadRules): boolean {
-  return (
-    Array.isArray(rules?.sections) &&
-    rules.sections.some((section) => section.ruleItems.length > 0)
-  );
+export function hasRules(rules: ProductUploadRules): boolean {
+    return Array.isArray(rules?.sections) && rules.sections.some(section => section.ruleItems.length > 0);
 }
 
 /**
@@ -183,170 +175,148 @@ export function hasRules (rules: ProductUploadRules): boolean {
  * @param b
  * @returns
  */
-export function compareRules (
-  a: ProductUploadRules = { sections: [] },
-  b: ProductUploadRules = { sections: [] }
+export function compareRules(
+    a: ProductUploadRules = { sections: [] },
+    b: ProductUploadRules = { sections: [] }
 ): boolean {
-  const matchedSections = [] as number[];
-  const sameRule = (
-    rA: ProductUploadRuleItem,
-    rB: ProductUploadRuleItem
-  ): boolean => {
-    return (
-      rA.attribute === rB.attribute &&
-      rA.operator === rB.operator &&
-      compareValues(rA.value, rB.value)
-    );
-  };
+    const matchedSections = [] as number[];
+    const sameRule = (rA: ProductUploadRuleItem, rB: ProductUploadRuleItem): boolean => {
+        return rA.attribute === rB.attribute && rA.operator === rB.operator && compareValues(rA.value, rB.value);
+    };
 
-  a.sections = a.sections.filter((s) => s.ruleItems.length > 0);
-  b.sections = b.sections.filter((s) => s.ruleItems.length > 0);
+    a.sections = a.sections.filter(s => s.ruleItems.length > 0);
+    b.sections = b.sections.filter(s => s.ruleItems.length > 0);
 
-  if (a.sections.length !== b.sections.length) {
-    return false;
-  }
+    if (a.sections.length !== b.sections.length) {
+        return false;
+    }
 
-  for (let i = 0; i < a.sections.length; i++) {
-    const rulesA = a.sections[i].ruleItems;
+    for (let i = 0; i < a.sections.length; i++) {
+        const rulesA = a.sections[i].ruleItems;
 
-    for (let j = 0; j < b.sections.length; j++) {
-      if (matchedSections.includes(j)) {
-        continue;
-      }
+        for (let j = 0; j < b.sections.length; j++) {
+            if (matchedSections.includes(j)) {
+                continue;
+            }
 
-      const rulesB = b.sections[j].ruleItems;
+            const rulesB = b.sections[j].ruleItems;
 
-      if (rulesA.length !== rulesB.length) {
-        continue;
-      }
+            if (rulesA.length !== rulesB.length) {
+                continue;
+            }
 
-      if (
-        rulesA.every((ruleA) => rulesB.some((ruleB) => sameRule(ruleA, ruleB)))
-      ) {
-        matchedSections.push(j);
-        break;
-      }
+            if (rulesA.every(ruleA => rulesB.some(ruleB => sameRule(ruleA, ruleB)))) {
+                matchedSections.push(j);
+                break;
+            }
+        }
     }
-  }
 
-  return matchedSections.length === a.sections.length;
+    return matchedSections.length === a.sections.length;
 }
 
-function compareValues (a: any, b: any): boolean {
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((i) => b.includes(i));
-  }
+function compareValues(a: any, b: any): boolean {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every(i => b.includes(i));
+    }
 
-  return a === b;
+    return a === b;
 }
 
-export function compareMappings (
-  a: ProductUploadMapping[],
-  b: ProductUploadMapping[]
-): boolean {
-  const matchedMappings = [] as number[];
-
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  for (let i = 0; i < a.length; i++) {
-    const mappingA = a[i];
-
-    for (let j = 0; j < b.length; j++) {
-      if (matchedMappings.includes(j)) {
-        continue;
-      }
-
-      const mappingB = b[j];
-
-      if (
-        mappingA.attribute === mappingB.attribute &&
-        compareValues(mappingA.value, mappingB.value) &&
-        compareRules(mappingA.rules, mappingB.rules)
-      ) {
-        matchedMappings.push(j);
-        break;
-      }
+export function compareMappings(a: ProductUploadMapping[], b: ProductUploadMapping[]): boolean {
+    const matchedMappings = [] as number[];
+
+    if (a.length !== b.length) {
+        return false;
+    }
+
+    for (let i = 0; i < a.length; i++) {
+        const mappingA = a[i];
+
+        for (let j = 0; j < b.length; j++) {
+            if (matchedMappings.includes(j)) {
+                continue;
+            }
+
+            const mappingB = b[j];
+
+            if (
+                mappingA.attribute === mappingB.attribute &&
+                compareValues(mappingA.value, mappingB.value) &&
+                compareRules(mappingA.rules, mappingB.rules)
+            ) {
+                matchedMappings.push(j);
+                break;
+            }
+        }
     }
-  }
 
-  return matchedMappings.length === a.length;
+    return matchedMappings.length === a.length;
 }
-export function optionIsString (option: OptionType): option is string {
-  return typeof option === 'string';
+
+export function optionIsString(option: OptionType): option is string {
+    return typeof option === 'string';
 }
 
-export function optionIsItem (option: OptionType): option is OptionTypeItem {
-  return typeof option !== 'string' && 'value' in option;
+export function optionIsItem(option: OptionType): option is OptionTypeItem {
+    return typeof option !== 'string' && 'value' in option;
 }
 
-export function optionIsGroup (option: OptionType): option is OptionTypeGroup {
-  return typeof option !== 'string' && 'options' in option;
+export function optionIsGroup(option: OptionType): option is OptionTypeGroup {
+    return typeof option !== 'string' && 'options' in option;
 }
-export function detectProfileChange (
-  a: ProductUploadProfile,
-  b: ProductUploadProfile
+
+export function detectProfileChange(
+    a: ProductUploadProfile,
+    b: ProductUploadProfile
 ): { name: boolean; rules: boolean; mappings: boolean; id: boolean } {
-  const changes = {
-    name: false,
-    rules: false,
-    mappings: false,
-    id: false,
-  };
-
-  if (a.name !== b.name) {
-    changes.name = true;
-  }
-
-  if (a.mappings !== b.mappings) {
-    const mappingsA = a.mappings?.filter(
-      (m) =>
-        m.attribute !== 'targetCountry' && m.attribute !== 'contentLanguage'
-    );
-    const mappingsB = b.mappings?.filter(
-      (m) =>
-        m.attribute !== 'targetCountry' && m.attribute !== 'contentLanguage'
-    );
-    changes.mappings = !compareMappings(mappingsA, mappingsB);
-  }
+    const changes = {
+        name: false,
+        rules: false,
+        mappings: false,
+        id: false,
+    };
+
+    if (a.name !== b.name) {
+        changes.name = true;
+    }
 
-  if (
-    ['targetCountry', 'contentLanguage'].some((key) => {
-      const mappingA = a.mappings?.filter((m) => m.attribute === key) ?? [];
-      const mappingB = b.mappings?.filter((m) => m.attribute === key) ?? [];
+    if (
+        ProductUploadMappings.filter(m => m.required)
+            .map(m => m.attribute)
+            .some(key => {
+                const mappingA = a.mappings?.filter(m => m.attribute === key) ?? [];
+                const mappingB = b.mappings?.filter(m => m.attribute === key) ?? [];
+                return !compareMappings(mappingA, mappingB);
+            })
+    ) {
+        changes.id = true;
+    }
 
-      return !compareMappings(mappingA, mappingB);
-    })
-  ) {
-    changes.id = true;
-  }
+    const requiredAttrs = ProductUploadMappings.filter(m => m.required).map(m => m.attribute);
+    const mappingsA = a.mappings?.filter(m => !requiredAttrs.includes(m.attribute));
+    const mappingsB = b.mappings?.filter(m => !requiredAttrs.includes(m.attribute));
+    changes.mappings = !compareMappings(mappingsA, mappingsB);
 
-  if (!compareRules(a.rules, b.rules)) {
-    changes.rules = true;
-  }
+    if (!compareRules(a.rules, b.rules)) {
+        changes.rules = true;
+    }
 
-  return changes;
+    return changes;
 }
 
-export function sanitizeUploadProfile (
-  profile: ProductUploadProfile
-): ProductUploadProfile {
-  if (profile.rules?.sections) {
-    profile.rules.sections = profile.rules.sections.filter(
-      (section) => section.ruleItems.length > 0
-    );
-  }
-
-  profile.mappings = profile.mappings?.map((mapping) => {
-    if (mapping.rules?.sections) {
-      mapping.rules.sections = mapping.rules.sections.filter(
-        (section) => section.ruleItems.length > 0
-      );
+export function sanitizeUploadProfile(profile: ProductUploadProfile): ProductUploadProfile {
+    if (profile.rules?.sections) {
+        profile.rules.sections = profile.rules.sections.filter(section => section.ruleItems.length > 0);
     }
 
-    return mapping;
-  });
+    profile.mappings = profile.mappings?.map(mapping => {
+        if (mapping.rules?.sections) {
+            mapping.rules.sections = mapping.rules.sections.filter(section => section.ruleItems.length > 0);
+        }
+
+        return mapping;
+    });
 
-  return profile;
+    return profile;
 }

package/tests/company.spec.ts

@@ -0,0 +1,49 @@
+import { describe, test, expect } from 'vitest';
+import {
+  extractSubscriptionCode,
+  makeSubscriptionCode,
+  makeSubscriptionName,
+  parseSubscriptionName,
+} from '../src/utils/company.js';
+import { ShopifyRecurringCharge } from '../src/types/shopify.types.js';
+
+describe('Company', () => {
+  test('Make subscription code', () => {
+    expect(
+      makeSubscriptionCode({
+        code: 'G',
+        level: 20,
+        products: 100,
+        profiles: 100,
+        price: 100,
+      })
+    ).toBe('G20');
+  });
+
+  test('Make subscription name', () => {
+    expect(
+      makeSubscriptionName({
+        code: 'G',
+        level: 10,
+        products: 100,
+        profiles: 100,
+        price: 100,
+      })
+    ).toBe('G10');
+  });
+
+  test('Extract subscription code', () => {
+    expect(
+      extractSubscriptionCode({
+        name: 'G50 subscription',
+        price: 100,
+        status: 'active',
+        trial_ends_at: '2022-01-01',
+      } as unknown as ShopifyRecurringCharge)
+    ).toBe('G50');
+  });
+
+  test('Parse subscription name', () => {
+    expect(parseSubscriptionName('G50')).toEqual({ code: 'G', level: '50' });
+  });
+});