Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import { parseCron } from '@core/util/cron';
import { TZDate } from '@date-fns/tz';
import type {
ActionTrigger,
EventFilter,
PayloadCondition,
PayloadScalar,
} from '@service-scheduled-action/generated/schemas';
import { match } from 'ts-pattern';
import {
type EventTriggerDraft,
newScheduleTrigger,
type PayloadTestDraft,
payloadTestValues,
type RoutineTriggerDraft,
} from '../core/routine-triggers';
/** Typed text as the JSON scalar it names; anything else stays text. */
function scalar(text: string): PayloadScalar {
const value = text.trim();
if (value === 'true') return true;
if (value === 'false') return false;
if (value === 'null') return null;
if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
return value;
}
function serializePayloadTest(test: PayloadTestDraft): PayloadCondition {
const path = test.path.split('.').map((segment) => segment.trim());
return match(test.op)
.with('equals', () => ({ path, equals: scalar(test.value) }))
.with('in', () => ({ path, in: payloadTestValues(test).map(scalar) }))
.with('notIn', () => ({
path,
notIn: payloadTestValues(test).map(scalar),
}))
.with('glob', () => ({ path, glob: test.value.trim() }))
.with('exists', () => ({ path, exists: true }))
.with('missing', () => ({ path, exists: false }))
.exhaustive(() => {
throw new Error('Choose how to test the payload field.');
});
}
function parsePayloadTest(condition: PayloadCondition): PayloadTestDraft {
const path = condition.path.join('.');
const list = (values: PayloadScalar[]) => values.map(String).join(', ');
if (condition.in != null)
return { path, op: 'in', value: list(condition.in) };
if (condition.notIn != null)
return { path, op: 'notIn', value: list(condition.notIn) };
if (condition.glob != null)
return { path, op: 'glob', value: condition.glob };
if (condition.exists != null)
return { path, op: condition.exists ? 'exists' : 'missing', value: '' };
return { path, op: 'equals', value: String(condition.equals ?? null) };
}
function serializeFilter(trigger: EventTriggerDraft): EventFilter {
const condition = trigger.condition?.trim();
return {
events: trigger.events,
...(trigger.ids === undefined ? {} : { ids: trigger.ids }),
...(trigger.github ? { github: trigger.github } : {}),
...(trigger.match?.length
? { match: trigger.match.map(serializePayloadTest) }
: {}),
...(trigger.property ? { property: trigger.property } : {}),
...(condition ? { condition } : {}),
};
}
export function serializeTrigger(trigger: RoutineTriggerDraft) {
if (trigger.kind === 'event')
return {
type: 'events' as const,
filters: [serializeFilter(trigger)],
};
const [hour, minute] = trigger.time.split(':').map(Number);
if (trigger.frequency === 'once') return onceTrigger(trigger.onceAt);
const schedule = match(trigger.frequency)
.with('hour', () => '0 0 * * * *')
.with('day', () => `0 ${minute} ${hour} * * *`)
.with(
'week',
() => `0 ${minute} ${hour} * * ${trigger.daysOfWeek.toSorted().join(',')}`
)
.with('month', () => `0 ${minute} ${hour} ${trigger.dayOfMonth} * *`)
.with('custom', () => trigger.cron.trim())
.exhaustive(() => {
throw new Error('Choose how often the routine runs.');
});
return { type: 'cron' as const, schedule, timezone: trigger.timezone };
}
export function serializeTriggers(
triggers: RoutineTriggerDraft[]
): ActionTrigger {
const schedules = triggers
.filter((trigger) => trigger.kind === 'schedule')
.map(serializeTrigger);
const filters = triggers.flatMap((trigger) =>
trigger.kind === 'event' ? [serializeFilter(trigger)] : []
);
const values = [
...schedules,
...(filters.length ? [{ type: 'events' as const, filters }] : []),
];
if (values.length === 1) return values[0];
return { type: 'multiple', triggers: values };
}
export function parseRoutineTriggers(
trigger: ActionTrigger
): RoutineTriggerDraft[] | undefined {
const values = trigger.type === 'multiple' ? trigger.triggers : [trigger];
if (
!values.every(
(value) =>
value.type === 'cron' ||
value.type === 'once' ||
value.type === 'events'
)
)
return undefined;
return values.flatMap((value): RoutineTriggerDraft[] => {
if (value.type === 'once')
return [
{
...newScheduleTrigger('once'),
onceAt: localDateTime(new Date(value.at)),
},
];
if (value.type === 'events')
return value.filters.map((filter) => ({
id: crypto.randomUUID(),
kind: 'event',
events: filter.events,
ids: filter.ids ?? undefined,
github: filter.github
? {
events: filter.github.events ?? [],
actions: filter.github.actions ?? [],
repositories: filter.github.repositories ?? [],
includeBots: filter.github.includeBots ?? false,
}
: undefined,
match: filter.match?.map(parsePayloadTest),
property: filter.property
? {
definitionId: filter.property.definitionId,
values: filter.property.values ?? [],
}
: undefined,
condition: filter.condition ?? undefined,
}));
const draft = {
...newScheduleTrigger('custom'),
timezone: value.timezone,
cron: value.schedule,
};
const once = onceFromCron(value.schedule, value.timezone);
if (once && value.schedule.split(/\s+/)[5] === '*')
return [{ ...draft, ...once }];
const parsed = parseCron(value.schedule);
// Only use a visual preset when serializing it produces the exact schedule.
// Arbitrary API-written expressions stay editable as cron without losing fields.
for (const frequency of ['hour', 'day', 'week', 'month'] as const) {
const candidate = { ...draft, ...parsed, frequency };
const serialized = serializeTrigger(candidate);
if (serialized.type === 'cron' && serialized.schedule === value.schedule)
return [candidate];
}
return [draft];
});
}
export function onceFromCron(
cron: string,
timezone = 'UTC'
): { frequency: 'once'; onceAt: string } | undefined {
const parts = cron.trim().split(/\s+/);
if (
parts.length !== 7 ||
!/^\d{4}$/.test(parts[6]) ||
!parts.slice(0, 5).every((part) => /^\d+$/.test(part))
)
return;
const [second, minute, hour, day, month, , year] = parts.map(Number);
const date = new TZDate(year, month - 1, day, hour, minute, second, timezone);
if (Number.isNaN(date.getTime())) return;
return { frequency: 'once', onceAt: localDateTime(new Date(date.getTime())) };
}
/** An instant as the `datetime-local` value the once picker edits. */
function localDateTime(instant: Date): string {
const local = new Date(
instant.getTime() - instant.getTimezoneOffset() * 60000
);
return local.toISOString().slice(0, 19);
}
/** A single run at the picked local date and time. */
export function onceTrigger(onceAt: string) {
const date = new Date(onceAt);
if (!Number.isFinite(date.getTime()))
throw new Error('Choose a date and time.');
return { type: 'once' as const, at: date.toISOString() };
}