@erxes/api-shared 0.0.0-stage → 3.2.19-2

package/src/core-modules/segments/plan.test.ts

@@ -0,0 +1,172 @@
+import { segmentRelationRef } from './nodeRefs';
+import { SegmentOperator } from './operators';
+
+import { SegmentNode, SegmentRelationNode } from './nodes';
+import { buildSegmentEvaluationPlan, planValueRefs } from './plan';
+
+const field = (
+  contentType: string,
+  fieldKey: string,
+  value?: string,
+): SegmentNode => ({
+  kind: 'field',
+  contentType,
+  fieldKey,
+  operator: SegmentOperator.Equals,
+  value,
+});
+
+const group = (children: SegmentNode[]): SegmentNode => ({
+  kind: 'group',
+  conjunction: 'and',
+  children,
+});
+
+const plan = (segments: SegmentNode[], relationOwners?: Map<string, string>) =>
+  buildSegmentEvaluationPlan({
+    subjectType: 'core:customer',
+    subjectIds: ['c-1', 'c-2'],
+    segments: segments.map((root, index) => ({ _id: `seg-${index}`, root })),
+    relationOwners,
+  });
+
+describe('buildSegmentEvaluationPlan', () => {
+  it('asks each plugin once for the union of what every segment needs', () => {
+    const result = plan([
+      group([
+        field('core:customer', 'state', 'customer'),
+        field('sales:deal', 'stageId', 'a'),
+      ]),
+      group([
+        field('core:customer', 'state', 'lead'),
+        field('sales:deal', 'status', 'won'),
+      ]),
+    ]);
+
+    expect([...result.requestsByPlugin.keys()]).toEqual(['core', 'sales']);
+    expect(result.requestsByPlugin.get('core')).toEqual([
+      {
+        kind: 'field',
+        ref: 'core:customer.state',
+        contentType: 'core:customer',
+        fieldKey: 'state',
+      },
+    ]);
+    expect(
+      result.requestsByPlugin.get('sales')?.map((request) => request.ref),
+    ).toEqual(['sales:deal.stageId', 'sales:deal.status']);
+  });
+
+  it('collapses the same field asked for by many segments into one request', () => {
+    const stage = field('sales:deal', 'stageId', 'a');
+    const result = plan(
+      Array.from({ length: 53 }, (_, index) =>
+        group([stage, field('sales:deal', 'status', `s-${index % 2}`)]),
+      ),
+    );
+
+    expect(result.requestsByPlugin.get('sales')).toHaveLength(2);
+  });
+
+  it('walks nested groups', () => {
+    const result = plan([
+      group([
+        field('core:customer', 'state'),
+        group([field('core:company', 'primaryName')]),
+      ]),
+    ]);
+
+    expect(result.requestsByPlugin.get('core')?.map((r) => r.ref)).toEqual([
+      'core:company.primaryName',
+      'core:customer.state',
+    ]);
+  });
+
+  it('carries the subject batch through untouched', () => {
+    const result = plan([group([field('core:customer', 'state')])]);
+
+    expect(result.subjectType).toBe('core:customer');
+    expect(result.subjectIds).toEqual(['c-1', 'c-2']);
+  });
+});
+
+describe('buildSegmentEvaluationPlan · relations', () => {
+  const relation = (relationKey: string, child: SegmentNode): SegmentNode => ({
+    kind: 'relation',
+    relationKey,
+    measure: { op: 'exists' },
+    child,
+  });
+
+  it('routes a relation to the plugin that owns it', () => {
+    const node = relation(
+      'customer.deals',
+      field('sales:deal', 'status', 'won'),
+    );
+
+    const result = plan(
+      [group([node])],
+      new Map([['customer.deals', 'sales']]),
+    );
+
+    expect(result.requestsByPlugin.get('sales')).toContainEqual({
+      kind: 'relation',
+      ref: segmentRelationRef(node as SegmentRelationNode),
+      relationKey: 'customer.deals',
+      measure: { op: 'exists' },
+      child: node.child,
+    });
+    expect(result.unresolvable).toEqual([]);
+  });
+
+  it('keeps two predicates on one relation apart', () => {
+    const won = relation(
+      'customer.deals',
+      field('sales:deal', 'status', 'won'),
+    );
+    const big = relation(
+      'customer.deals',
+      field('sales:deal', 'amount', '1000'),
+    );
+
+    const result = plan(
+      [group([won, big])],
+      new Map([['customer.deals', 'sales']]),
+    );
+
+    expect(result.requestsByPlugin.get('sales')).toHaveLength(2);
+    expect(segmentRelationRef(won as SegmentRelationNode)).not.toBe(
+      segmentRelationRef(big as SegmentRelationNode),
+    );
+  });
+
+  it('reports a relation nothing owns instead of dropping it', () => {
+    const node = relation(
+      'customer.tickets',
+      field('tickets:ticket', 'status'),
+    );
+    const result = plan([group([node])]);
+
+    expect(result.requestsByPlugin.size).toBe(0);
+    expect(result.unresolvable).toEqual([
+      segmentRelationRef(node as SegmentRelationNode),
+    ]);
+  });
+
+  it('reports a field whose contentType has no plugin', () => {
+    const result = plan([group([field('', 'state')])]);
+
+    expect(result.unresolvable).toEqual(['.state']);
+  });
+
+  it('lists every ref the resolvers owe back', () => {
+    const result = plan([
+      group([field('core:customer', 'state'), field('sales:deal', 'status')]),
+    ]);
+
+    expect(planValueRefs(result)).toEqual([
+      'core:customer.state',
+      'sales:deal.status',
+    ]);
+  });
+});

package/src/core-modules/segments/plan.ts

@@ -0,0 +1,155 @@
+import {
+  segmentFieldRef,
+  segmentReferenceRef,
+  segmentRelationRef,
+} from './nodeRefs';
+import { walkSegmentNodes } from './walkNodes';
+import { SEGMENT_MEMBERSHIP_FIELD, SegmentMeasure, SegmentNode } from './nodes';
+
+export type SegmentPlannedSegment = {
+  _id: string;
+  root: SegmentNode;
+};
+
+export type SegmentFieldRequest = {
+  kind: 'field';
+  ref: string;
+  contentType: string;
+  fieldKey: string;
+};
+
+export type SegmentRelationRequest = {
+  kind: 'relation';
+  ref: string;
+  relationKey: string;
+  measure: SegmentMeasure;
+  child?: SegmentNode;
+  edges?: Record<string, string[]>;
+};
+
+export type SegmentValueRequest = SegmentFieldRequest | SegmentRelationRequest;
+
+export type SegmentEvaluationPlan = {
+  subjectType: string;
+  subjectIds: string[];
+  requestsByPlugin: Map<string, SegmentValueRequest[]>;
+  unresolvable: string[];
+};
+
+export type SegmentPlanInput = {
+  subjectType: string;
+  subjectIds: string[];
+  segments: SegmentPlannedSegment[];
+  relationOwners?: ReadonlyMap<string, string>;
+};
+
+const pluginOf = (contentType: string): string | undefined =>
+  contentType.split(':')[0] || undefined;
+
+export const buildSegmentEvaluationPlan = ({
+  subjectType,
+  subjectIds,
+  segments,
+  relationOwners,
+}: SegmentPlanInput): SegmentEvaluationPlan => {
+  const byPlugin = new Map<string, Map<string, SegmentValueRequest>>();
+  const unresolvable = new Set<string>();
+
+  const add = (plugin: string, request: SegmentValueRequest) => {
+    const existing = byPlugin.get(plugin);
+
+    if (existing) {
+      existing.set(request.ref, request);
+      return;
+    }
+
+    byPlugin.set(plugin, new Map([[request.ref, request]]));
+  };
+
+  for (const segment of segments) {
+    for (const node of walkSegmentNodes(segment.root)) {
+      if (node.kind === 'field') {
+        const plugin = pluginOf(node.contentType);
+        const ref = segmentFieldRef(node);
+
+        if (!plugin) {
+          unresolvable.add(ref);
+          continue;
+        }
+
+        add(plugin, {
+          kind: 'field',
+          ref,
+          contentType: node.contentType,
+          fieldKey: node.fieldKey,
+        });
+
+        continue;
+      }
+
+      if (node.kind === 'segment') {
+        const plugin = pluginOf(subjectType);
+        const ref = segmentReferenceRef(subjectType);
+
+        if (!plugin) {
+          unresolvable.add(ref);
+          continue;
+        }
+
+        add(plugin, {
+          kind: 'field',
+          ref,
+          contentType: subjectType,
+          fieldKey: SEGMENT_MEMBERSHIP_FIELD,
+        });
+
+        continue;
+      }
+
+      if (node.kind === 'relation') {
+        const ref = segmentRelationRef(node);
+        const plugin = relationOwners?.get(node.relationKey);
+
+        if (!plugin) {
+          unresolvable.add(ref);
+          continue;
+        }
+
+        add(plugin, {
+          kind: 'relation',
+          ref,
+          relationKey: node.relationKey,
+          measure: node.measure,
+          child: node.child,
+        });
+      }
+    }
+  }
+
+  const requestsByPlugin = new Map<string, SegmentValueRequest[]>();
+
+  for (const plugin of [...byPlugin.keys()].sort()) {
+    const requests = [
+      ...(byPlugin.get(plugin) as Map<string, SegmentValueRequest>).values(),
+    ];
+
+    requestsByPlugin.set(
+      plugin,
+      requests.sort((left, right) => left.ref.localeCompare(right.ref)),
+    );
+  }
+
+  return {
+    subjectType,
+    subjectIds,
+    requestsByPlugin,
+    unresolvable: [...unresolvable].sort(),
+  };
+};
+
+export const planValueRefs = (plan: SegmentEvaluationPlan): string[] => [
+  ...[...plan.requestsByPlugin.values()].flatMap((requests) =>
+    requests.map((request) => request.ref),
+  ),
+  ...plan.unresolvable,
+];

package/src/core-modules/segments/relationRegistry.test.ts

@@ -0,0 +1,64 @@
+import { SegmentRelationMeta } from './relationRegistry';
+
+const plugins: Record<string, SegmentRelationMeta[]> = {
+  sales: [
+    {
+      key: 'customer.deals',
+      label: 'Deals',
+      subjectType: 'core:contacts.customers',
+      relatedType: 'sales:sales.deals',
+      join: {
+        via: 'relation',
+        subjectRecordType: 'core:customer',
+        relatedRecordType: 'sales:deal',
+      },
+    },
+    {
+      key: 'company.deals',
+      label: 'Deals',
+      subjectType: 'core:contacts.companies',
+      relatedType: 'sales:sales.deals',
+      join: {
+        via: 'relation',
+        subjectRecordType: 'core:company',
+        relatedRecordType: 'sales:deal',
+      },
+    },
+    {
+      key: 'deal.products',
+      label: 'Products',
+      subjectType: 'sales:sales.deals',
+      relatedType: 'core:products.products',
+      join: { via: 'field', path: 'productsData.productId' },
+    },
+  ],
+};
+
+jest.mock('../../utils', () => ({
+  getPlugins: async () => Object.keys(plugins),
+  getPlugin: async (name: string) => ({
+    config: { meta: { segments: { segmentRelations: plugins[name] } } },
+  }),
+}));
+
+import { gatherSegmentRecordTypes } from './relationRegistry';
+
+describe('gatherSegmentRecordTypes', () => {
+  it('maps both ends of a relation back to the types segments use', async () => {
+    const map = await gatherSegmentRecordTypes();
+
+    expect(map.get('core:customer')).toEqual(['core:contacts.customers']);
+    expect(map.get('core:company')).toEqual(['core:contacts.companies']);
+    expect(map.get('sales:deal')).toEqual(['sales:sales.deals']);
+  });
+
+  it('ignores a relation joined by a field, which stores no row', async () => {
+    const map = await gatherSegmentRecordTypes();
+
+    expect([...map.keys()].sort()).toEqual([
+      'core:company',
+      'core:customer',
+      'sales:deal',
+    ]);
+  });
+});

package/src/core-modules/segments/relationRegistry.ts

@@ -0,0 +1,198 @@
+import { getPlugin, getPlugins } from '../../utils';
+import { resolveSegmentFieldDependencies, SegmentFieldMeta } from './fieldMeta';
+import { ISegmentContentType } from './types';
+
+export type SegmentRelationMeta = {
+  key: string;
+  label: string;
+  subjectType: string;
+  relatedType: string;
+  join:
+    | {
+        via: 'relation';
+        subjectRecordType: string;
+        relatedRecordType: string;
+      }
+    | { via: 'field'; on: 'subject' | 'related'; path: string };
+};
+
+export type SegmentRelationDirectory = {
+  owners: Map<string, string>;
+  relations: Map<string, SegmentRelationMeta>;
+};
+
+export const gatherSegmentRelations = async (
+  subjectType: string,
+): Promise<SegmentRelationDirectory> => {
+  const owners = new Map<string, string>();
+  const relations = new Map<string, SegmentRelationMeta>();
+
+  for (const pluginName of await getPlugins()) {
+    const plugin = await getPlugin(pluginName);
+    const declared: SegmentRelationMeta[] =
+      plugin.config?.meta?.segments?.segmentRelations || [];
+
+    for (const relation of declared) {
+      if (relation.subjectType === subjectType) {
+        owners.set(relation.key, pluginName);
+        relations.set(relation.key, relation);
+      }
+    }
+  }
+
+  return { owners, relations };
+};
+
+export const gatherSegmentEventTypes = async (): Promise<
+  Map<string, string[]>
+> => {
+  const byEventType = new Map<string, string[]>();
+
+  for (const pluginName of await getPlugins()) {
+    const plugin = await getPlugin(pluginName);
+    const declared: ISegmentContentType[] =
+      plugin.config?.meta?.segments?.contentTypes || [];
+
+    for (const entry of declared) {
+      if (!entry.contentType) {
+        continue;
+      }
+
+      for (const eventType of entry.eventTypes || [entry.contentType]) {
+        byEventType.set(eventType, [
+          ...(byEventType.get(eventType) || []),
+          entry.contentType,
+        ]);
+      }
+    }
+  }
+
+  return byEventType;
+};
+
+export const gatherSegmentRecordTypes = async (): Promise<
+  Map<string, string[]>
+> => {
+  const bySegmentType = new Map<string, Set<string>>();
+
+  const add = (recordType?: string, segmentType?: string) => {
+    if (!recordType || !segmentType) {
+      return;
+    }
+
+    bySegmentType.set(
+      recordType,
+      (bySegmentType.get(recordType) || new Set<string>()).add(segmentType),
+    );
+  };
+
+  for (const pluginName of await getPlugins()) {
+    const plugin = await getPlugin(pluginName);
+    const declared: SegmentRelationMeta[] =
+      plugin.config?.meta?.segments?.segmentRelations || [];
+
+    for (const relation of declared) {
+      if (relation.join.via !== 'relation') {
+        continue;
+      }
+
+      add(relation.join.subjectRecordType, relation.subjectType);
+      add(relation.join.relatedRecordType, relation.relatedType);
+    }
+  }
+
+  return new Map(
+    [...bySegmentType].map(([recordType, types]) => [recordType, [...types]]),
+  );
+};
+
+export type SegmentFieldSourceLink = {
+  subjectType: string;
+  via: string;
+};
+
+export type SegmentFieldSourceDirectory = {
+  byField: Map<string, string[]>;
+  bySource: Map<string, SegmentFieldSourceLink[]>;
+};
+
+export const gatherSegmentFieldSources =
+  async (): Promise<SegmentFieldSourceDirectory> => {
+    const byField = new Map<string, string[]>();
+    const bySource = new Map<string, SegmentFieldSourceLink[]>();
+
+    for (const pluginName of await getPlugins()) {
+      const plugin = await getPlugin(pluginName);
+      const declared: Record<string, SegmentFieldMeta[]> =
+        plugin.config?.meta?.segments?.segmentFields || {};
+
+      for (const [contentType, fields] of Object.entries(declared)) {
+        for (const field of fields) {
+          for (const dependency of resolveSegmentFieldDependencies(field)) {
+            if (!dependency.contentType) {
+              continue;
+            }
+
+            const key = `${contentType}:${field.key}`;
+
+            byField.set(key, [
+              ...(byField.get(key) || []),
+              dependency.contentType,
+            ]);
+
+            if (!dependency.via) {
+              continue;
+            }
+
+            const reached = bySource.get(dependency.contentType) || [];
+
+            const already = reached.some(
+              (link) =>
+                link.subjectType === contentType && link.via === dependency.via,
+            );
+
+            if (!already) {
+              bySource.set(dependency.contentType, [
+                ...reached,
+                { subjectType: contentType, via: dependency.via },
+              ]);
+            }
+          }
+        }
+      }
+    }
+
+    return { byField, bySource };
+  };
+
+export const gatherSegmentJoinPaths = async (): Promise<
+  Map<string, string[]>
+> => {
+  const byContentType = new Map<string, Set<string>>();
+
+  for (const pluginName of await getPlugins()) {
+    const plugin = await getPlugin(pluginName);
+    const declared: SegmentRelationMeta[] =
+      plugin.config?.meta?.segments?.segmentRelations || [];
+
+    for (const relation of declared) {
+      if (relation.join.via !== 'field') {
+        continue;
+      }
+
+      const owner =
+        relation.join.on === 'related'
+          ? relation.relatedType
+          : relation.subjectType;
+
+      byContentType.set(
+        owner,
+        (byContentType.get(owner) || new Set<string>()).add(relation.join.path),
+      );
+    }
+  }
+
+  return new Map(
+    [...byContentType].map(([contentType, paths]) => [contentType, [...paths]]),
+  );
+};