feed-common 1.0.0 → 1.0.1

package/src/utils/profile.ts

@@ -0,0 +1,348 @@
+import {
+  OptionType,
+  OptionTypeItem,
+  OptionTypeGroup,
+  ProductUploadProfile,
+} from '../types/profile.types.js';
+import { ProductUploadMappings } from '../constants/profile.constants.js';
+import { ProductUploadMapping } from '../types/profile.types.js';
+import {
+  ProductUploadRuleFilterType,
+  RuleOperatorsType,
+} from '../types/profile.types.js';
+import {
+  ProductUploadRuleItem,
+  ProductUploadRuleSection,
+  ProductUploadRules,
+} from '../types/profile.types.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[];
+}
+
+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[];
+}
+
+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;
+          }
+        }
+      }
+    }
+    
+    if (currentList.length === currentSection.ruleItems.length) {
+      totalList = [...totalList, ...currentList];
+    }
+  }
+
+  return totalList;
+}
+
+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 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';
+    default:
+      throw new Error(`Unknown operator ${String(operator)}`);
+  }
+}
+
+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 hasRules (rules: ProductUploadRules): boolean {
+  return (
+    Array.isArray(rules?.sections) &&
+    rules.sections.some((section) => section.ruleItems.length > 0)
+  );
+}
+
+/**
+ * Checks if two rules are the same
+ * @param a
+ * @param b
+ * @returns
+ */
+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)
+    );
+  };
+
+  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;
+  }
+
+  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;
+      }
+
+      const rulesB = b.sections[j].ruleItems;
+
+      if (rulesA.length !== rulesB.length) {
+        continue;
+      }
+
+      if (
+        rulesA.every((ruleA) => rulesB.some((ruleB) => sameRule(ruleA, ruleB)))
+      ) {
+        matchedSections.push(j);
+        break;
+      }
+    }
+  }
+
+  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));
+  }
+
+  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;
+      }
+    }
+  }
+
+  return matchedMappings.length === a.length;
+}
+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 optionIsGroup (option: OptionType): option is OptionTypeGroup {
+  return typeof option !== 'string' && 'options' in option;
+}
+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);
+  }
+
+  if (
+    ['targetCountry', 'contentLanguage'].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;
+  }
+
+  if (!compareRules(a.rules, b.rules)) {
+    changes.rules = true;
+  }
+
+  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
+      );
+    }
+
+    return mapping;
+  });
+
+  return profile;
+}

package/src/utils/utils.ts

@@ -0,0 +1,3 @@
+export function code () {
+  return (Math.random() * 1000000).toFixed(0);
+}

package/.github/workflows/release.yml

@@ -1,38 +0,0 @@
-name: Release
-
-permissions:
-  contents: write
-  issues: write
-  pull-requests: write
-
-on:
-  push:
-    branches:
-      - master
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build
-        run: npm run build
-
-      - name: Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
-        run: npx semantic-release