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

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

@@ -0,0 +1,130 @@
+import { SegmentOperator } from './operators';
+import { z } from 'zod';
+
+import { SegmentNode } from './nodes';
+import { TSegmentProducers } from './types';
+
+export const SegmentNodeSchema: z.ZodType<SegmentNode> = z.lazy(() =>
+  z.union([
+    z.object({
+      kind: z.literal('group'),
+      conjunction: z.enum(['and', 'or']),
+      children: z.array(SegmentNodeSchema),
+    }),
+    z.object({
+      kind: z.literal('field'),
+      contentType: z.string(),
+      fieldKey: z.string(),
+      operator: z.nativeEnum(SegmentOperator),
+      value: z.any().optional(),
+      meta: z.record(z.string(), z.string()).optional(),
+    }),
+    z.object({
+      kind: z.literal('relation'),
+      relationKey: z.string(),
+      measure: z.union([
+        z.object({ op: z.enum(['exists', 'none', 'count']) }),
+        z.object({
+          op: z.enum(['sum', 'avg', 'min', 'max']),
+          fieldKey: z.string(),
+        }),
+      ]),
+      child: SegmentNodeSchema.optional(),
+      operator: z.nativeEnum(SegmentOperator).optional(),
+      value: z.any().optional(),
+    }),
+    z.object({
+      kind: z.literal('segment'),
+      segmentId: z.string(),
+      exclude: z.boolean().optional(),
+    }),
+  ]),
+);
+
+export const SegmentBaseInput = z.object({
+  subdomain: z.string(),
+  data: z.any().optional(),
+});
+
+const EvaluateFieldsInputData = z.object({
+  subjectType: z.string(),
+  subjectIds: z.array(z.string()),
+  timeZone: z.string().optional(),
+  requests: z.array(
+    z.union([
+      z.object({
+        kind: z.literal('field'),
+        ref: z.string(),
+        contentType: z.string(),
+        fieldKey: z.string(),
+      }),
+      z.object({
+        kind: z.literal('relation'),
+        ref: z.string(),
+        relationKey: z.string(),
+        measure: z.union([
+          z.object({ op: z.enum(['exists', 'none', 'count']) }),
+          z.object({
+            op: z.enum(['sum', 'avg', 'min', 'max']),
+            fieldKey: z.string(),
+          }),
+        ]),
+        child: SegmentNodeSchema.optional(),
+        edges: z.record(z.string(), z.array(z.string())).optional(),
+      }),
+    ]),
+  ),
+});
+
+export const EvaluateFieldsInput = SegmentBaseInput.extend({
+  data: EvaluateFieldsInputData,
+});
+
+const SegmentMemberQueryInputData = z.object({
+  contentType: z.string(),
+  node: SegmentNodeSchema,
+  ids: z.array(z.string()).optional(),
+  timeZone: z.string().optional(),
+});
+
+const ListSegmentMembersInputData = SegmentMemberQueryInputData.extend({
+  cursor: z.string().optional(),
+  limit: z.number().int().positive().max(10000).optional(),
+});
+
+export const ListSegmentMembersInput = SegmentBaseInput.extend({
+  data: ListSegmentMembersInputData,
+});
+
+export const CountSegmentMembersInput = SegmentBaseInput.extend({
+  data: SegmentMemberQueryInputData,
+});
+
+const ApplyMembershipInputData = z.object({
+  contentType: z.string(),
+  updates: z.array(
+    z.object({
+      segmentId: z.string(),
+      matched: z.array(z.string()),
+      notMatched: z.array(z.string()),
+    }),
+  ),
+  forget: z.array(z.string()).optional(),
+  countFor: z.array(z.string()).optional(),
+  transitions: z.boolean().optional(),
+});
+
+export const ApplyMembershipInput = SegmentBaseInput.extend({
+  data: ApplyMembershipInputData,
+});
+
+export type TSegmentProducersInput = {
+  [TSegmentProducers.EVALUATE_FIELDS]: z.infer<typeof EvaluateFieldsInputData>;
+  [TSegmentProducers.LIST_MEMBERS]: z.infer<typeof ListSegmentMembersInputData>;
+  [TSegmentProducers.COUNT_MEMBERS]: z.infer<
+    typeof SegmentMemberQueryInputData
+  >;
+  [TSegmentProducers.APPLY_MEMBERSHIP]: z.infer<
+    typeof ApplyMembershipInputData
+  >;
+};

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

@@ -0,0 +1,163 @@
+import {
+  anniversaryRanges,
+  isAnniversary,
+  shiftZonedDays,
+  zonedDate,
+  zonedDayStart,
+  zonedPeriodRange,
+} from './zonedTime';
+
+const UB = 'Asia/Ulaanbaatar';
+
+describe('zonedDate', () => {
+  it('reads the day the organization is on, not the UTC one', () => {
+    expect(zonedDate(new Date('2026-08-31T16:30:00Z'), UB)).toEqual({
+      year: 2026,
+      month: 9,
+      day: 1,
+    });
+
+    expect(zonedDate(new Date('2026-08-31T16:30:00Z'), 'UTC')).toEqual({
+      year: 2026,
+      month: 8,
+      day: 31,
+    });
+  });
+});
+
+describe('zonedDayStart', () => {
+  it('returns the instant the local day begins', () => {
+    expect(
+      zonedDayStart({ year: 2026, month: 9, day: 1 }, UB).toISOString(),
+    ).toBe('2026-08-31T16:00:00.000Z');
+  });
+
+  it('handles a zone whose clocks move', () => {
+    expect(
+      zonedDayStart(
+        { year: 2026, month: 9, day: 1 },
+        'America/New_York',
+      ).toISOString(),
+    ).toBe('2026-09-01T04:00:00.000Z');
+
+    expect(
+      zonedDayStart(
+        { year: 2026, month: 12, day: 1 },
+        'America/New_York',
+      ).toISOString(),
+    ).toBe('2026-12-01T05:00:00.000Z');
+  });
+});
+
+describe('shiftZonedDays', () => {
+  it('crosses months and years', () => {
+    expect(shiftZonedDays({ year: 2026, month: 8, day: 31 }, 1)).toEqual({
+      year: 2026,
+      month: 9,
+      day: 1,
+    });
+
+    expect(shiftZonedDays({ year: 2026, month: 1, day: 1 }, -1)).toEqual({
+      year: 2025,
+      month: 12,
+      day: 31,
+    });
+  });
+});
+
+describe('anniversaryRanges', () => {
+  const covers = (
+    ranges: { gte: Date; lt: Date }[],
+    instant: string,
+  ): boolean =>
+    ranges.some(
+      (range) => new Date(instant) >= range.gte && new Date(instant) < range.lt,
+    );
+
+  it('matches the same day in every year', () => {
+    const ranges = anniversaryRanges({ year: 2026, month: 9, day: 7 }, UB);
+
+    expect(covers(ranges, '1980-09-06T16:00:00Z')).toBe(true);
+    expect(covers(ranges, '2001-09-07T03:00:00Z')).toBe(true);
+    expect(covers(ranges, '1980-09-07T16:00:00Z')).toBe(false);
+  });
+
+  it('never rolls February 29th onto March 1st', () => {
+    const ranges = anniversaryRanges({ year: 2028, month: 2, day: 29 }, UB);
+
+    expect(covers(ranges, '1996-02-28T16:00:00Z')).toBe(true); // Feb 29 1996
+    expect(covers(ranges, '1997-02-28T16:00:00Z')).toBe(false); // Mar 1 1997
+    expect(covers(ranges, '1997-02-27T16:00:00Z')).toBe(false); // Feb 28 1997
+  });
+
+  it('celebrates a February 29th birthday on the 28th in a common year', () => {
+    const ranges = anniversaryRanges({ year: 2027, month: 2, day: 28 }, UB);
+
+    expect(covers(ranges, '1997-02-27T16:00:00Z')).toBe(true); // Feb 28 1997
+    expect(covers(ranges, '1996-02-28T16:00:00Z')).toBe(true); // Feb 29 1996
+  });
+
+  it('leaves it on its own day in a leap year', () => {
+    const ranges = anniversaryRanges({ year: 2028, month: 2, day: 28 }, UB);
+
+    expect(covers(ranges, '1997-02-27T16:00:00Z')).toBe(true); // Feb 28 1997
+    expect(covers(ranges, '1996-02-28T16:00:00Z')).toBe(false); // Feb 29 1996
+  });
+});
+
+describe('isAnniversary', () => {
+  it('agrees with the ranges on the February 29th fold', () => {
+    const born = new Date('1996-02-28T16:00:00Z'); // Feb 29 1996, UB
+
+    expect(isAnniversary(born, { year: 2027, month: 2, day: 28 }, UB)).toBe(
+      true,
+    );
+    expect(isAnniversary(born, { year: 2028, month: 2, day: 28 }, UB)).toBe(
+      false,
+    );
+    expect(isAnniversary(born, { year: 2028, month: 2, day: 29 }, UB)).toBe(
+      true,
+    );
+  });
+});
+
+describe('zonedPeriodRange', () => {
+  const at = (iso: string, period: 'month' | 'quarter' | 'year', zone = UB) => {
+    const { gte, lt } = zonedPeriodRange(new Date(iso), zone, period);
+
+    return [gte.toISOString(), lt.toISOString()];
+  };
+
+  it('holds the whole local month, quarter or year around now', () => {
+    expect(at('2026-10-08T03:00:00Z', 'month')).toEqual([
+      '2026-09-30T16:00:00.000Z',
+      '2026-10-31T16:00:00.000Z',
+    ]);
+    expect(at('2026-10-08T03:00:00Z', 'quarter')).toEqual([
+      '2026-09-30T16:00:00.000Z',
+      '2026-12-31T16:00:00.000Z',
+    ]);
+    expect(at('2026-10-08T03:00:00Z', 'year')).toEqual([
+      '2025-12-31T16:00:00.000Z',
+      '2026-12-31T16:00:00.000Z',
+    ]);
+  });
+
+  it('rolls over into the next year at the end of December', () => {
+    expect(at('2026-12-15T00:00:00Z', 'month', 'UTC')).toEqual([
+      '2026-12-01T00:00:00.000Z',
+      '2027-01-01T00:00:00.000Z',
+    ]);
+    expect(at('2026-12-15T00:00:00Z', 'quarter', 'UTC')).toEqual([
+      '2026-10-01T00:00:00.000Z',
+      '2027-01-01T00:00:00.000Z',
+    ]);
+  });
+
+  it("takes the period of the organization's day, not the UTC one", () => {
+    expect(at('2026-08-31T17:00:00Z', 'month')).toEqual([
+      '2026-08-31T16:00:00.000Z',
+      '2026-09-30T16:00:00.000Z',
+    ]);
+  });
+});

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

@@ -0,0 +1,198 @@
+export type ZonedDate = { year: number; month: number; day: number };
+
+export const DEFAULT_SEGMENT_TIME_ZONE = 'UTC';
+
+const formatters = new Map<string, Intl.DateTimeFormat>();
+
+const formatterFor = (timeZone: string): Intl.DateTimeFormat => {
+  const cached = formatters.get(timeZone);
+
+  if (cached) {
+    return cached;
+  }
+
+  const created = new Intl.DateTimeFormat('en-US', {
+    timeZone,
+    hour12: false,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+
+  formatters.set(timeZone, created);
+
+  return created;
+};
+
+const partsOf = (instant: Date, timeZone: string) =>
+  Object.fromEntries(
+    formatterFor(timeZone)
+      .formatToParts(instant)
+      .map((part) => [part.type, part.value]),
+  ) as Record<string, string>;
+
+export const zonedDate = (instant: Date, timeZone: string): ZonedDate => {
+  const parts = partsOf(instant, timeZone);
+
+  return {
+    year: Number(parts.year),
+    month: Number(parts.month),
+    day: Number(parts.day),
+  };
+};
+
+const utcAt = (
+  year: number,
+  month: number,
+  day: number,
+  hour = 0,
+  minute = 0,
+  second = 0,
+): number => {
+  const at = new Date(0);
+
+  at.setUTCFullYear(year, month - 1, day);
+  at.setUTCHours(hour, minute, second, 0);
+
+  return at.getTime();
+};
+
+export const zonedDayStart = (date: ZonedDate, timeZone: string): Date => {
+  const wanted = utcAt(date.year, date.month, date.day);
+
+  let instant = wanted;
+
+  for (let round = 0; round < 3; round++) {
+    const parts = partsOf(new Date(instant), timeZone);
+
+    const seen = utcAt(
+      Number(parts.year),
+      Number(parts.month),
+      Number(parts.day),
+      Number(parts.hour) % 24,
+      Number(parts.minute),
+      Number(parts.second),
+    );
+
+    instant = wanted - (seen - instant);
+  }
+
+  return new Date(instant);
+};
+
+export type ZonedPeriod = 'month' | 'quarter' | 'year';
+
+const PERIOD_MONTHS: Record<ZonedPeriod, number> = {
+  month: 1,
+  quarter: 3,
+  year: 12,
+};
+
+/**
+ * The calendar month, quarter or year holding `now` in the zone, as
+ * [start, next start): "this month" on 10/08 is 10/01 up to 11/01.
+ */
+export const zonedPeriodRange = (
+  now: Date,
+  timeZone: string,
+  period: ZonedPeriod,
+): { gte: Date; lt: Date } => {
+  const { year, month } = zonedDate(now, timeZone);
+  const span = PERIOD_MONTHS[period];
+  const startMonth = Math.floor((month - 1) / span) * span + 1;
+  const nextIndex = startMonth - 1 + span;
+
+  return {
+    gte: zonedDayStart({ year, month: startMonth, day: 1 }, timeZone),
+    lt: zonedDayStart(
+      {
+        year: year + Math.floor(nextIndex / 12),
+        month: (nextIndex % 12) + 1,
+        day: 1,
+      },
+      timeZone,
+    ),
+  };
+};
+
+export const shiftZonedDays = (date: ZonedDate, days: number): ZonedDate => {
+  const at = new Date(0);
+
+  at.setUTCFullYear(date.year, date.month - 1, date.day + days);
+
+  return {
+    year: at.getUTCFullYear(),
+    month: at.getUTCMonth() + 1,
+    day: at.getUTCDate(),
+  };
+};
+
+export const isLeapYear = (year: number): boolean =>
+  (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+
+const daysInMonth = (year: number, month: number): number =>
+  month === 2
+    ? isLeapYear(year)
+      ? 29
+      : 28
+    : [4, 6, 9, 11].includes(month)
+    ? 30
+    : 31;
+
+const WINDOW_BACK = 150;
+const WINDOW_FORWARD = 20;
+
+export const anniversaryRanges = (
+  target: ZonedDate,
+  timeZone: string,
+): { gte: Date; lt: Date }[] => {
+  const days = [{ month: target.month, day: target.day }];
+
+  if (target.month === 2 && target.day === 28 && !isLeapYear(target.year)) {
+    days.push({ month: 2, day: 29 });
+  }
+
+  const ranges: { gte: Date; lt: Date }[] = [];
+
+  for (
+    let year = target.year - WINDOW_BACK;
+    year <= target.year + WINDOW_FORWARD;
+    year++
+  ) {
+    for (const { month, day } of days) {
+      if (day > daysInMonth(year, month)) {
+        continue;
+      }
+
+      ranges.push({
+        gte: zonedDayStart({ year, month, day }, timeZone),
+        lt: zonedDayStart(shiftZonedDays({ year, month, day }, 1), timeZone),
+      });
+    }
+  }
+
+  return ranges;
+};
+
+export const isAnniversary = (
+  instant: Date,
+  target: ZonedDate,
+  timeZone: string,
+): boolean => {
+  const on = zonedDate(instant, timeZone);
+
+  if (on.month === target.month && on.day === target.day) {
+    return true;
+  }
+
+  return (
+    target.month === 2 &&
+    target.day === 28 &&
+    !isLeapYear(target.year) &&
+    on.month === 2 &&
+    on.day === 29
+  );
+};

package/src/core-modules/templates/index.ts

@@ -0,0 +1 @@
+export * from './utils';

package/src/core-modules/templates/utils.ts

@@ -0,0 +1,91 @@
+import * as crypto from 'crypto';
+import { Document, ObjectId } from 'mongoose';
+import { nanoid } from 'nanoid';
+
+export class TemplateManager<T extends Document> {
+  private EXCLUDE_FIELDS: (keyof T)[];
+  private INCLUDE_FEILDS?: Record<string, unknown>;
+
+  constructor(EXCLUDE_FIELDS: (keyof T)[] = [], INCLUDE_FEILDS?: Record<string, unknown>) {
+    this.EXCLUDE_FIELDS = EXCLUDE_FIELDS;
+    this.INCLUDE_FEILDS = INCLUDE_FEILDS
+  }
+
+  public generateIdentity(): string {
+    return nanoid()
+  }
+
+  private generateHash(doc: T): string {
+    return crypto
+      .createHash('sha256')
+      .update(JSON.stringify(doc))
+      .digest('hex')
+      .slice(0, 8);
+  }
+
+  public getContent(documents: T[]): Record<string, T> {
+    const hashMap: Record<string, string> = {};
+
+    if (!documents?.length) return {};
+
+    for (const document of documents) {
+      hashMap[String(document._id)] = this.generateHash(document);
+    }
+
+    const content: Record<string, T> = {};
+
+    for (const document of documents) {
+      const hash = hashMap[String(document._id)];
+
+      for (const key of Object.keys(document) as (keyof T)[]) {
+        const value = document[key];
+
+        if (this.EXCLUDE_FIELDS.includes(key)) {
+          delete document[key];
+          
+          continue;
+        }
+
+        if (!hashMap[String(value)]) continue;
+
+        document[key] = hashMap[String(value)] as T[keyof T];
+      }
+
+      content[hash] = document;
+    }
+
+    return content;
+  }
+
+  public setContent(content: Record<string, T>) {
+    const identityMap: Record<string, string | ObjectId> = {};
+
+    const documents: Array<T> = []
+    
+    for (const [hash, fields] of Object.entries(content)) {
+      identityMap[String(hash)] = this.generateIdentity();
+
+      const document: T = { ...fields, _id: identityMap[hash] }
+
+      if (Object.keys(this.INCLUDE_FEILDS || {}).length) {
+        Object.assign(document, this.INCLUDE_FEILDS)
+      }
+
+      for (const key of Object.keys(document) as (keyof T)[]) {
+        const value = document[key];
+
+        if (key === 'code') {
+          document[key] = this.generateIdentity() as T[keyof T];
+        }
+
+        if (!identityMap[String(value)]) continue;
+
+        document[key] = identityMap[String(value)] as T[keyof T];
+      }
+
+      documents.push(document)
+    }
+
+    return documents
+  }
+}