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

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

@@ -0,0 +1,170 @@
+import {
+  SegmentApplyMembershipResult,
+  SegmentMembershipTransition,
+} from './types';
+
+export type SegmentMembershipCollection = {
+  bulkWrite: (operations: Record<string, unknown>[]) => Promise<unknown>;
+  countDocuments: (filter: Record<string, unknown>) => Promise<number>;
+  find: (
+    filter: Record<string, unknown>,
+    projection?: Record<string, 1>,
+  ) => { lean: () => Promise<{ _id: string; segmentIds?: string[] }[]> };
+};
+
+export type SegmentMembershipUpdate = {
+  segmentId: string;
+  matched: string[];
+  notMatched: string[];
+};
+
+const membershipBefore = async (
+  collection: SegmentMembershipCollection,
+  updates: SegmentMembershipUpdate[],
+): Promise<Map<string, Set<string>>> => {
+  const touched = [
+    ...new Set(updates.flatMap((u) => [...u.matched, ...u.notMatched])),
+  ];
+
+  const segmentIds = updates.map((update) => update.segmentId);
+
+  if (!touched.length || !segmentIds.length) {
+    return new Map();
+  }
+
+  const records = await collection
+    .find(
+      { _id: { $in: touched }, segmentIds: { $in: segmentIds } },
+      { _id: 1, segmentIds: 1 },
+    )
+    .lean();
+
+  return new Map(
+    records.map((record) => [
+      String(record._id),
+      new Set(record.segmentIds || []),
+    ]),
+  );
+};
+
+const transitionsFrom = (
+  updates: SegmentMembershipUpdate[],
+  before: Map<string, Set<string>>,
+): SegmentMembershipTransition[] =>
+  updates
+    .map(({ segmentId, matched, notMatched }) => ({
+      segmentId,
+      joined: matched.filter((id) => !before.get(id)?.has(segmentId)),
+      left: notMatched.filter((id) => before.get(id)?.has(segmentId)),
+    }))
+    .filter(({ joined, left }) => joined.length || left.length);
+
+export const applySegmentMembership = async (
+  collections: Record<string, SegmentMembershipCollection>,
+  {
+    contentType,
+    updates,
+    forget,
+    countFor,
+    transitions,
+  }: {
+    contentType: string;
+    updates: SegmentMembershipUpdate[];
+    forget?: string[];
+    countFor?: string[];
+    transitions?: boolean;
+  },
+): Promise<SegmentApplyMembershipResult> => {
+  const collection = collections[contentType];
+
+  if (!collection) {
+    return { counts: {}, unsupported: [contentType] };
+  }
+
+  const wantsTransitions = transitions !== false;
+
+  const before = wantsTransitions
+    ? await membershipBefore(collection, updates)
+    : new Map<string, Set<string>>();
+
+  const operations: Record<string, unknown>[] = (forget || []).map(
+    (segmentId) => ({
+      updateMany: {
+        filter: { segmentIds: segmentId },
+        update: { $pull: { segmentIds: segmentId } },
+      },
+    }),
+  );
+
+  for (const update of updates) {
+    if (update.matched.length) {
+      operations.push({
+        updateMany: {
+          filter: { _id: { $in: update.matched } },
+          update: { $addToSet: { segmentIds: update.segmentId } },
+        },
+      });
+    }
+
+    if (update.notMatched.length) {
+      operations.push({
+        updateMany: {
+          filter: {
+            _id: { $in: update.notMatched },
+            segmentIds: update.segmentId,
+          },
+          update: { $pull: { segmentIds: update.segmentId } },
+        },
+      });
+    }
+  }
+
+  const counting = countFor ?? updates.map((update) => update.segmentId);
+
+  let countedAt: string | undefined;
+
+  const countMembers = async (): Promise<Record<string, number>> => {
+    const counts: Record<string, number> = {};
+
+    await Promise.all(
+      counting.map(async (segmentId) => {
+        counts[segmentId] = await collection.countDocuments({
+          segmentIds: segmentId,
+        });
+      }),
+    );
+
+    countedAt = new Date().toISOString();
+
+    return counts;
+  };
+
+  if (!operations.length) {
+    const counts = counting.length ? await countMembers() : {};
+
+    return { counts, countedAt };
+  }
+
+  const cleared = [...new Set(updates.flatMap((update) => update.notMatched))];
+
+  if (cleared.length) {
+    operations.push({
+      updateMany: {
+        filter: { _id: { $in: cleared }, segmentIds: { $size: 0 } },
+        update: { $unset: { segmentIds: '' } },
+      },
+    });
+  }
+
+  await collection.bulkWrite(operations);
+
+  const counts = counting.length ? await countMembers() : {};
+
+  return {
+    counts,
+    countedAt,
+    ...(wantsTransitions
+      ? { transitions: transitionsFrom(updates, before) }
+      : {}),
+  };
+};

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

@@ -0,0 +1,326 @@
+import { SegmentOperator } from './operators';
+import { SegmentFieldMeta, SegmentFieldNamespace } from './fieldMeta';
+import { compileSegmentMongoFilter } from './mongoFilter';
+import { SegmentNode } from './nodes';
+
+const NOW = new Date('2026-08-23T10:30:00.000Z');
+
+const fields: SegmentFieldMeta[] = [
+  {
+    key: 'status',
+    label: 'Status',
+    operators: [SegmentOperator.Equals],
+    kind: 'projected',
+    path: 'status',
+    input: 'text',
+  },
+  {
+    key: 'name',
+    label: 'Name',
+    operators: [SegmentOperator.Contains],
+    kind: 'projected',
+    path: 'name',
+    input: 'text',
+  },
+  {
+    key: 'amount',
+    label: 'Amount',
+    operators: [SegmentOperator.NumberGt],
+    kind: 'projected',
+    path: 'totalAmount',
+    input: 'number',
+  },
+  {
+    key: 'closeDate',
+    label: 'Close date',
+    operators: [SegmentOperator.DateGte],
+    kind: 'projected',
+    path: 'closeDate',
+    input: 'date',
+  },
+  {
+    key: 'tagIds',
+    label: 'Tags',
+    operators: [SegmentOperator.Equals],
+    kind: 'projected',
+    path: 'tagIds',
+    input: 'text',
+  },
+  {
+    key: 'pipelineId',
+    label: 'Pipeline',
+    operators: [SegmentOperator.Equals],
+    kind: 'derived',
+    dependsOn: [{ fields: ['stageId'] }],
+    input: 'text',
+  },
+];
+
+const namespaces: SegmentFieldNamespace[] = [
+  {
+    prefix: 'propertiesData',
+    label: 'Custom properties',
+    path: 'propertiesData',
+  },
+];
+
+const field = (
+  fieldKey: string,
+  operator: SegmentOperator,
+  value?: string | number | Date | string[],
+): SegmentNode => ({
+  kind: 'field',
+  contentType: 'sales:deal',
+  fieldKey,
+  operator,
+  value,
+});
+
+const compile = (node: SegmentNode, extra: { timeZone?: string } = {}) =>
+  compileSegmentMongoFilter(node, { fields, namespaces, now: NOW, ...extra });
+
+describe('compileSegmentMongoFilter · operators', () => {
+  it('compiles onto the declared path, not the field key', () => {
+    expect(
+      compile(field('amount', SegmentOperator.NumberGt, 100)).filter,
+    ).toEqual({ totalAmount: { $gte: 100 } });
+  });
+
+  it('escapes a contains value so it cannot inject a pattern', () => {
+    expect(
+      compile(field('name', SegmentOperator.Contains, 'a.b*c')).filter,
+    ).toEqual({ name: { $regex: 'a\\.b\\*c', $options: 'i' } });
+  });
+
+  it('treats null and an empty array as unset, matching the evaluator', () => {
+    expect(compile(field('tagIds', SegmentOperator.IsSet)).filter).toEqual({
+      tagIds: { $nin: [null, []], $exists: true },
+    });
+    expect(compile(field('tagIds', SegmentOperator.IsNotSet)).filter).toEqual({
+      tagIds: { $in: [null, []] },
+    });
+  });
+
+  it('matches an id list, and matches nothing when the list is empty', () => {
+    expect(
+      compile(field('status', SegmentOperator.In, ['won', 'lost'])).filter,
+    ).toEqual({ status: { $in: ['won', 'lost'] } });
+
+    expect(compile(field('status', SegmentOperator.In, [])).filter).toEqual({
+      status: { $in: [] },
+    });
+  });
+
+  it('turns a relative-day operator into one whole day', () => {
+    const { filter } = compile(field('closeDate', SegmentOperator.DaysAgo, 3));
+    const range = filter.closeDate as Record<string, Date>;
+
+    expect(range.$gte).toEqual(new Date('2026-08-20T00:00:00.000Z'));
+    expect(range.$lt).toEqual(new Date('2026-08-21T00:00:00.000Z'));
+  });
+
+  it("reads a day in the organization's zone, not in UTC", () => {
+    const { filter } = compile(field('closeDate', SegmentOperator.DaysAgo, 0), {
+      timeZone: 'Asia/Ulaanbaatar',
+    });
+    const range = filter.closeDate as Record<string, Date>;
+
+    expect(range.$gte).toEqual(new Date('2026-08-22T16:00:00.000Z'));
+    expect(range.$lt).toEqual(new Date('2026-08-23T16:00:00.000Z'));
+  });
+
+  it('turns "this month" into the calendar month in the zone', () => {
+    const { filter } = compile(
+      field('closeDate', SegmentOperator.DateThisMonth),
+      {
+        timeZone: 'Asia/Ulaanbaatar',
+      },
+    );
+    const range = filter.closeDate as Record<string, Date>;
+
+    expect(range.$gte).toEqual(new Date('2026-07-31T16:00:00.000Z'));
+    expect(range.$lt).toEqual(new Date('2026-08-31T16:00:00.000Z'));
+  });
+
+  it('normalizes a deprecated operator before compiling', () => {
+    expect(
+      compile(field('closeDate', SegmentOperator.DateRelativeGt, '2026-01-01'))
+        .filter,
+    ).toEqual({ closeDate: { $gte: new Date('2026-01-01T00:00:00.000Z') } });
+  });
+});
+
+describe('compileSegmentMongoFilter · namespaces', () => {
+  it('compiles a namespaced field to the path it reads as', () => {
+    const { filter } = compile(
+      field('propertiesData.plan', SegmentOperator.Equals, 'enterprise'),
+    );
+
+    expect(filter).toEqual({
+      'propertiesData.plan': { $eq: 'enterprise' },
+    });
+  });
+
+  it('matches one row of a repeating group', () => {
+    const { filter } = compile(
+      field(
+        'propertiesData.g:edu/school',
+        SegmentOperator.Equals,
+        'enterprise',
+      ),
+    );
+
+    expect(filter).toEqual({
+      'propertiesData.g:edu': { $elemMatch: { school: { $eq: 'enterprise' } } },
+    });
+  });
+
+  it('makes both conditions hold for one shared row', () => {
+    const { filter } = compile({
+      kind: 'group',
+      conjunction: 'and',
+      children: [
+        field('propertiesData.g:edu/school', SegmentOperator.Equals, 'MUIS'),
+        field('propertiesData.g:edu/year', SegmentOperator.Equals, '2020'),
+      ],
+    });
+
+    expect(filter).toEqual({
+      'propertiesData.g:edu': {
+        $elemMatch: { school: { $eq: 'MUIS' }, year: { $eq: '2020' } },
+      },
+    });
+  });
+
+  it('keeps or branches apart', () => {
+    const { filter } = compile({
+      kind: 'group',
+      conjunction: 'or',
+      children: [
+        field('propertiesData.g:edu/school', SegmentOperator.Equals, 'MUIS'),
+        field('propertiesData.g:edu/school', SegmentOperator.Equals, 'SUIS'),
+      ],
+    });
+
+    expect(filter).toEqual({
+      $or: [
+        { 'propertiesData.g:edu': { $elemMatch: { school: { $eq: 'MUIS' } } } },
+        { 'propertiesData.g:edu': { $elemMatch: { school: { $eq: 'SUIS' } } } },
+      ],
+    });
+  });
+
+  it('narrows one leaf with two operators instead of two rows', () => {
+    const { filter } = compile({
+      kind: 'group',
+      conjunction: 'and',
+      children: [
+        field('propertiesData.g:edu/year', SegmentOperator.NumberGt, '2018'),
+        field('propertiesData.g:edu/year', SegmentOperator.NumberLt, '2022'),
+      ],
+    });
+
+    expect(filter).toEqual({
+      'propertiesData.g:edu': {
+        $elemMatch: { year: { $gte: 2018, $lte: 2022 } },
+      },
+    });
+  });
+
+  it('leaves a plain field beside a folded row', () => {
+    const { filter } = compile({
+      kind: 'group',
+      conjunction: 'and',
+      children: [
+        field('propertiesData.plan', SegmentOperator.Equals, 'pro'),
+        field('propertiesData.g:edu/school', SegmentOperator.Equals, 'MUIS'),
+      ],
+    });
+
+    expect(filter).toEqual({
+      $and: [
+        { 'propertiesData.plan': { $eq: 'pro' } },
+        { 'propertiesData.g:edu': { $elemMatch: { school: { $eq: 'MUIS' } } } },
+      ],
+    });
+  });
+});
+
+describe('compileSegmentMongoFilter · trees', () => {
+  const group = (
+    conjunction: 'and' | 'or',
+    children: SegmentNode[],
+  ): SegmentNode => ({ kind: 'group', conjunction, children });
+
+  it('collapses a single-child group instead of nesting $and', () => {
+    expect(
+      compile(group('and', [field('status', SegmentOperator.Equals, 'won')]))
+        .filter,
+    ).toEqual({ status: { $eq: 'won' } });
+  });
+
+  it('compiles and / or', () => {
+    const won = field('status', SegmentOperator.Equals, 'won');
+    const big = field('amount', SegmentOperator.NumberGt, 100);
+
+    expect(compile(group('and', [won, big])).filter).toEqual({
+      $and: [{ status: { $eq: 'won' } }, { totalAmount: { $gte: 100 } }],
+    });
+    expect(compile(group('or', [won, big])).filter).toEqual({
+      $or: [{ status: { $eq: 'won' } }, { totalAmount: { $gte: 100 } }],
+    });
+  });
+
+  it('keeps two conditions on one path apart under $and', () => {
+    const { filter } = compile(
+      group('and', [
+        field('amount', SegmentOperator.NumberGt, 10),
+        field('amount', SegmentOperator.NumberLt, 100),
+      ]),
+    );
+
+    expect(filter).toEqual({
+      $and: [{ totalAmount: { $gte: 10 } }, { totalAmount: { $lte: 100 } }],
+    });
+  });
+});
+
+describe('compileSegmentMongoFilter · what it cannot express', () => {
+  it('reports a derived field rather than dropping it', () => {
+    const result = compile(field('pipelineId', SegmentOperator.Equals, 'p-1'));
+
+    expect(result.unsupported).toEqual(['sales:deal.pipelineId']);
+    expect(result.filter).toEqual({});
+  });
+
+  it('reports an undeclared field', () => {
+    expect(
+      compile(field('removed', SegmentOperator.Equals, 'x')).unsupported,
+    ).toEqual(['sales:deal.removed']);
+  });
+
+  it('reports a relation', () => {
+    const result = compile({
+      kind: 'relation',
+      relationKey: 'customer.deals',
+      measure: { op: 'exists' },
+      child: field('status', SegmentOperator.Equals, 'won'),
+    });
+
+    expect(result.unsupported).toEqual(['customer.deals']);
+  });
+
+  it('still compiles the siblings it can express', () => {
+    const result = compile({
+      kind: 'group',
+      conjunction: 'and',
+      children: [
+        field('status', SegmentOperator.Equals, 'won'),
+        field('pipelineId', SegmentOperator.Equals, 'p-1'),
+      ],
+    });
+
+    expect(result.filter).toEqual({ status: { $eq: 'won' } });
+    expect(result.unsupported).toEqual(['sales:deal.pipelineId']);
+  });
+});