@automate.ax/catalog 0.75.0 → 0.77.0

package/dist/triggers/core-dashboard.js

@@ -0,0 +1,202 @@
+import { sentenceCase } from "./name.js";
+import * as z from "zod/mini";
+const EMAIL_SCHEMA = z.email();
+const URL_SCHEMA = z.url();
+const FIELD_NAME_SCHEMA = z
+    .string()
+    .check(z.trim(), z.minLength(1), z.maxLength(100));
+const FIELD_LABEL_SCHEMA = z
+    .string()
+    .check(z.trim(), z.minLength(1), z.maxLength(255));
+const FIELD_DESCRIPTION_SCHEMA = z.string().check(z.maxLength(2_000));
+const FIELD_LENGTH_SCHEMA = z.int().check(z.nonnegative());
+const DASHBOARD_RUN_FIELD_BASE_SCHEMA = {
+    description: z.optional(FIELD_DESCRIPTION_SCHEMA),
+    label: z.optional(FIELD_LABEL_SCHEMA),
+    name: FIELD_NAME_SCHEMA,
+};
+const DASHBOARD_RUN_TEXT_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.optional(z.string()),
+    maxLength: z.optional(FIELD_LENGTH_SCHEMA),
+    minLength: z.optional(FIELD_LENGTH_SCHEMA),
+    placeholder: z.optional(z.string()),
+    required: z.prefault(z.boolean(), true),
+    type: z.enum(["email", "phone", "text", "textarea", "url"]),
+});
+const DASHBOARD_RUN_NUMBER_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.optional(z.number()),
+    max: z.optional(z.number()),
+    min: z.optional(z.number()),
+    placeholder: z.optional(z.string()),
+    required: z.prefault(z.boolean(), true),
+    step: z.prefault(z.number().check(z.positive()), 1),
+    type: z.literal("number"),
+});
+const DASHBOARD_RUN_DATE_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.optional(z.iso.date()),
+    max: z.optional(z.iso.date()),
+    min: z.optional(z.iso.date()),
+    required: z.prefault(z.boolean(), true),
+    step: z.prefault(z.int().check(z.positive()), 1),
+    type: z.literal("date"),
+});
+const DASHBOARD_RUN_DATETIME_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.optional(z.iso.datetime({ local: true })),
+    max: z.optional(z.iso.datetime({ local: true })),
+    min: z.optional(z.iso.datetime({ local: true })),
+    required: z.prefault(z.boolean(), true),
+    step: z.prefault(z.number().check(z.positive()), 60),
+    type: z.literal("datetime"),
+});
+const DASHBOARD_RUN_CHOICE_FIELD_SCHEMA = {
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.optional(FIELD_NAME_SCHEMA),
+    options: z
+        .array(z.object({
+        label: FIELD_LABEL_SCHEMA,
+        value: FIELD_NAME_SCHEMA,
+    }))
+        .check(z.minLength(1)),
+    placeholder: z.optional(z.string()),
+    required: z.prefault(z.boolean(), true),
+};
+const DASHBOARD_RUN_SELECT_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_CHOICE_FIELD_SCHEMA,
+    type: z.literal("select"),
+});
+const DASHBOARD_RUN_RADIO_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_CHOICE_FIELD_SCHEMA,
+    type: z.literal("radio"),
+});
+const DASHBOARD_RUN_MULTI_SELECT_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.optional(z.array(FIELD_NAME_SCHEMA)),
+    options: z
+        .array(z.object({
+        label: FIELD_LABEL_SCHEMA,
+        value: FIELD_NAME_SCHEMA,
+    }))
+        .check(z.minLength(1)),
+    placeholder: z.optional(z.string()),
+    required: z.prefault(z.boolean(), true),
+    type: z.literal("multi-select"),
+});
+const DASHBOARD_RUN_CHECKBOX_FIELD_SCHEMA = z.object({
+    ...DASHBOARD_RUN_FIELD_BASE_SCHEMA,
+    defaultValue: z.prefault(z.boolean(), false),
+    required: z.prefault(z.boolean(), false),
+    type: z.literal("checkbox"),
+});
+const DASHBOARD_RUN_FIELD_SCHEMA = z.pipe(z.discriminatedUnion("type", [
+    DASHBOARD_RUN_TEXT_FIELD_SCHEMA,
+    DASHBOARD_RUN_NUMBER_FIELD_SCHEMA,
+    DASHBOARD_RUN_DATE_FIELD_SCHEMA,
+    DASHBOARD_RUN_DATETIME_FIELD_SCHEMA,
+    DASHBOARD_RUN_SELECT_FIELD_SCHEMA,
+    DASHBOARD_RUN_RADIO_FIELD_SCHEMA,
+    DASHBOARD_RUN_MULTI_SELECT_FIELD_SCHEMA,
+    DASHBOARD_RUN_CHECKBOX_FIELD_SCHEMA,
+]), z.transform((field) => ({
+    ...field,
+    label: field.label ??
+        `${sentenceCase(field.name)}${field.type === "checkbox" ? "?" : ""}`,
+})));
+const DASHBOARD_RUN_FIELDS_SCHEMA = z.array(DASHBOARD_RUN_FIELD_SCHEMA).check(z.refine((fields) => new Set(fields.map((field) => field.name)).size === fields.length, "Dashboard run field names must be unique."), z.refine((fields) => fields.every(isDashboardRunFieldDefaultValid), "Dashboard run field defaults must satisfy their field constraints."));
+export const DASHBOARD_RUN_CONFIG_SCHEMA = z.object({
+    description: z.optional(FIELD_DESCRIPTION_SCHEMA),
+    fields: z.prefault(DASHBOARD_RUN_FIELDS_SCHEMA, []),
+    submitLabel: z.prefault(z.string().check(z.trim(), z.minLength(1), z.maxLength(100)), "Run"),
+    title: z.string().check(z.trim(), z.minLength(1), z.maxLength(255)),
+});
+export const dashboardRunTriggerDefinition = {
+    getDetails: ({ config }) => [
+        {
+            label: "Run form",
+            value: DASHBOARD_RUN_CONFIG_SCHEMA.parse(config).title,
+        },
+    ],
+    icon: "automation",
+    name: "Dashboard run",
+    type: "dashboard.run",
+};
+/**
+ * Returns the organization-authenticated submission endpoint for one dashboard
+ * run.
+ *
+ * @param options - Public origin and trigger identity.
+ */
+export function getDashboardRunEndpoint(options) {
+    return new URL(`/api/dashboard-runs/${getDashboardRunEndpointKey(options)}`, options.appOrigin).toString();
+}
+/**
+ * Returns the durable endpoint identity for one dashboard run trigger.
+ *
+ * @param options - Trigger and owning automation identity.
+ */
+export function getDashboardRunEndpointKey(options) {
+    return `${options.automationId}:${[
+        ...(options.scopePath ?? []),
+        options.hookSlot,
+    ].join(".")}`;
+}
+/**
+ * Checks a configured default against the same constraints as submitted data.
+ *
+ * @param field - Field definition to validate.
+ */
+function isDashboardRunFieldDefaultValid(field) {
+    if (field.type === "checkbox" || field.defaultValue === undefined)
+        return true;
+    if (field.type === "multi-select") {
+        if (field.required !== false && field.defaultValue.length === 0)
+            return false;
+        return field.defaultValue.every((value) => field.options.some((option) => option.value === value));
+    }
+    if (field.type === "radio" || field.type === "select") {
+        return field.options.some((option) => option.value === field.defaultValue);
+    }
+    if (field.type === "number") {
+        return ((field.min === undefined || field.defaultValue >= field.min) &&
+            (field.max === undefined || field.defaultValue <= field.max) &&
+            !isDashboardRunStepMismatch(field.defaultValue, field.min ?? field.defaultValue, field.step ?? 1));
+    }
+    if (field.type === "date" || field.type === "datetime") {
+        const defaultValue = parseDashboardRunDateValue(field.type, field.defaultValue);
+        return ((field.min === undefined ||
+            defaultValue >= parseDashboardRunDateValue(field.type, field.min)) &&
+            (field.max === undefined ||
+                defaultValue <= parseDashboardRunDateValue(field.type, field.max)) &&
+            !isDashboardRunStepMismatch(defaultValue, parseDashboardRunDateValue(field.type, field.min ?? field.defaultValue), (field.step ?? (field.type === "date" ? 1 : 60)) *
+                (field.type === "date" ? 86_400_000 : 1_000)));
+    }
+    const defaultValue = field.defaultValue.trim();
+    return ((defaultValue.length > 0 || field.required === false) &&
+        (field.minLength === undefined || defaultValue.length >= field.minLength) &&
+        (field.maxLength === undefined || defaultValue.length <= field.maxLength) &&
+        (field.type !== "email" || EMAIL_SCHEMA.safeParse(defaultValue).success) &&
+        (field.type !== "url" || URL_SCHEMA.safeParse(defaultValue).success));
+}
+/**
+ * Checks whether a value falls outside an allowed step interval.
+ *
+ * @param value - Configured default value.
+ * @param base - Value from which step intervals begin.
+ * @param step - Allowed interval size.
+ */
+function isDashboardRunStepMismatch(value, base, step) {
+    const intervals = (value - base) / step;
+    return Math.abs(intervals - Math.round(intervals)) > 1e-9;
+}
+/**
+ * Converts a validated local date or date-time string to a UTC number.
+ *
+ * @param type - Temporal field type.
+ * @param value - Local ISO value to convert.
+ */
+function parseDashboardRunDateValue(type, value) {
+    return Date.parse(type === "date" ? `${value}T00:00:00Z` : `${value}Z`);
+}

package/dist/triggers/core-http.d.ts

@@ -0,0 +1,30 @@
+export declare const httpRequestTriggerDefinition: {
+    readonly getPrimary: ({ appOrigin, automationId, config, hookSlot, projectId, scopePath, }: import("..").TriggerPresentationContext) => {
+        copyable: true;
+        value: string;
+    };
+    readonly icon: "webhook";
+    readonly name: "HTTP request";
+    readonly type: "http.request";
+};
+export type HttpTriggerScope = "trigger" | "automation" | "project";
+export interface HttpTriggerEndpointOptions {
+    appOrigin: string;
+    automationId: string;
+    hookSlot: number;
+    projectId: string;
+    scope: HttpTriggerScope;
+    scopePath?: readonly number[];
+}
+/**
+ * Returns the public URL for one deployed HTTP trigger.
+ *
+ * @param options - Public origin and trigger identity.
+ */
+export declare function getHttpTriggerEndpoint(options: HttpTriggerEndpointOptions): string;
+/**
+ * Returns the durable endpoint identity for one configured HTTP scope.
+ *
+ * @param options - Trigger and owning resource identity.
+ */
+export declare function getHttpTriggerEndpointKey(options: Omit<HttpTriggerEndpointOptions, "appOrigin">): string;

package/dist/triggers/core-http.js

@@ -0,0 +1,43 @@
+import * as z from "zod/mini";
+const HTTP_PRESENTATION_CONFIG_SCHEMA = z.object({
+    scope: z.prefault(z.enum(["trigger", "automation", "project"]), "trigger"),
+});
+export const httpRequestTriggerDefinition = {
+    getPrimary: ({ appOrigin, automationId, config, hookSlot, projectId, scopePath, }) => ({
+        copyable: true,
+        value: getHttpTriggerEndpoint({
+            appOrigin,
+            automationId,
+            hookSlot,
+            projectId,
+            scope: HTTP_PRESENTATION_CONFIG_SCHEMA.parse(config).scope,
+            scopePath,
+        }),
+    }),
+    icon: "webhook",
+    name: "HTTP request",
+    type: "http.request",
+};
+/**
+ * Returns the public URL for one deployed HTTP trigger.
+ *
+ * @param options - Public origin and trigger identity.
+ */
+export function getHttpTriggerEndpoint(options) {
+    return new URL(`/x/${getHttpTriggerEndpointKey(options)}/`, options.appOrigin).toString();
+}
+/**
+ * Returns the durable endpoint identity for one configured HTTP scope.
+ *
+ * @param options - Trigger and owning resource identity.
+ */
+export function getHttpTriggerEndpointKey(options) {
+    if (options.scope === "project")
+        return options.projectId;
+    if (options.scope === "automation")
+        return options.automationId;
+    return `${options.automationId}:${[
+        ...(options.scopePath ?? []),
+        options.hookSlot,
+    ].join(".")}`;
+}

package/dist/triggers/core-invocation.d.ts

@@ -0,0 +1,9 @@
+export declare const automationInvokedTriggerDefinition: {
+    readonly getDetails: ({ config }: import("..").TriggerPresentationContext) => {
+        label: string;
+        value: string;
+    }[];
+    readonly icon: "automation";
+    readonly name: "Invocation";
+    readonly type: "automation.invoked";
+};

package/dist/triggers/core-invocation.js

@@ -0,0 +1,15 @@
+import * as z from "zod/mini";
+const INVOCATION_PRESENTATION_CONFIG_SCHEMA = z.object({
+    entrypoint: z.string(),
+});
+export const automationInvokedTriggerDefinition = {
+    getDetails: ({ config }) => [
+        {
+            label: "Entrypoint",
+            value: INVOCATION_PRESENTATION_CONFIG_SCHEMA.parse(config).entrypoint,
+        },
+    ],
+    icon: "automation",
+    name: "Invocation",
+    type: "automation.invoked",
+};

package/dist/triggers/core-mailhook.d.ts

@@ -0,0 +1,35 @@
+import type { HttpTriggerScope } from "./core-http.js";
+export declare const PLATFORM_EMAIL_DOMAIN = "automations.automate.ax";
+export declare const mailhookEmailReceivedTriggerDefinition: {
+    readonly getPrimary: ({ automationId, config, hookSlot, projectId, scopePath }: import("..").TriggerPresentationContext) => {
+        copyable: true;
+        value: string;
+    };
+    readonly icon: "webhook";
+    readonly name: "Mailhook";
+    readonly type: "mailhook.email.received";
+};
+export type MailhookScope = HttpTriggerScope;
+export interface MailhookAddressOptions {
+    automationId: string;
+    hookSlot: number;
+    plusPath?: string;
+    projectId: string;
+    scope: MailhookScope;
+    scopePath?: readonly number[];
+}
+/**
+ * Returns the unique inbound address for one deployed mailhook.
+ *
+ * Add `+suffix` before the `@` to carry a routing value into the event.
+ *
+ * @param options - Mailhook identity and sharing scope.
+ * @throws When the generated local part exceeds the email size limit.
+ */
+export declare function getMailhookAddress(options: MailhookAddressOptions): string;
+/**
+ * Returns the local-part router key for one configured mailhook scope.
+ *
+ * @param options - Mailhook identity and sharing scope.
+ */
+export declare function getMailhookAddressKey(options: MailhookAddressOptions): string;

package/dist/triggers/core-mailhook.js

@@ -0,0 +1,63 @@
+import * as z from "zod/mini";
+const MAX_EMAIL_LOCAL_PART_BYTES = 64;
+const EMAIL_SCHEMA = z.email();
+const MAILHOOK_PRESENTATION_CONFIG_SCHEMA = z.object({
+    scope: z.prefault(z.enum(["trigger", "automation", "project"]), "trigger"),
+});
+export const PLATFORM_EMAIL_DOMAIN = "automations.automate.ax";
+export const mailhookEmailReceivedTriggerDefinition = {
+    getPrimary: ({ automationId, config, hookSlot, projectId, scopePath }) => ({
+        copyable: true,
+        value: getMailhookAddress({
+            automationId,
+            hookSlot,
+            projectId,
+            scope: MAILHOOK_PRESENTATION_CONFIG_SCHEMA.parse(config).scope,
+            scopePath,
+        }),
+    }),
+    icon: "webhook",
+    name: "Mailhook",
+    type: "mailhook.email.received",
+};
+/**
+ * Returns the unique inbound address for one deployed mailhook.
+ *
+ * Add `+suffix` before the `@` to carry a routing value into the event.
+ *
+ * @param options - Mailhook identity and sharing scope.
+ * @throws When the generated local part exceeds the email size limit.
+ */
+export function getMailhookAddress(options) {
+    const localPart = `${getMailhookAddressKey(options)}${options.plusPath ? `+${options.plusPath}` : ""}`;
+    if (new TextEncoder().encode(localPart).length > MAX_EMAIL_LOCAL_PART_BYTES) {
+        throw new RangeError("Mailhook address local part exceeds 64 bytes.");
+    }
+    return EMAIL_SCHEMA.parse(`${localPart}@${PLATFORM_EMAIL_DOMAIN}`);
+}
+/**
+ * Returns the local-part router key for one configured mailhook scope.
+ *
+ * @param options - Mailhook identity and sharing scope.
+ */
+export function getMailhookAddressKey(options) {
+    if (options.scope === "project")
+        return `p${typeIdSuffix(options.projectId)}`;
+    if (options.scope === "automation") {
+        return `a${typeIdSuffix(options.automationId)}`;
+    }
+    return `a${typeIdSuffix(options.automationId)}.${[
+        ...(options.scopePath ?? []),
+        options.hookSlot,
+    ]
+        .map((segment) => segment.toString(36))
+        .join(".")}`;
+}
+/**
+ * Removes the redundant TypeID prefix from an address router.
+ *
+ * @param id - Project or automation TypeID.
+ */
+function typeIdSuffix(id) {
+    return id.includes("_") ? id.slice(id.indexOf("_") + 1) : id;
+}

package/dist/triggers/core-schedule.d.ts

@@ -0,0 +1,9 @@
+export declare const cronTickTriggerDefinition: {
+    readonly getDetails: ({ config }: import("..").TriggerPresentationContext) => {
+        label: string;
+        value: string;
+    }[];
+    readonly icon: "schedule";
+    readonly name: "Cron schedule";
+    readonly type: "cron.tick";
+};

package/dist/triggers/core-schedule.js

@@ -0,0 +1,17 @@
+import * as z from "zod/mini";
+const CRON_PRESENTATION_CONFIG_SCHEMA = z.object({
+    schedule: z.string(),
+    timeZone: z.prefault(z.string(), "UTC"),
+});
+export const cronTickTriggerDefinition = {
+    getDetails: ({ config }) => {
+        const parsedConfig = CRON_PRESENTATION_CONFIG_SCHEMA.parse(config);
+        return [
+            { label: "Schedule", value: parsedConfig.schedule },
+            { label: "Time zone", value: parsedConfig.timeZone },
+        ];
+    },
+    icon: "schedule",
+    name: "Cron schedule",
+    type: "cron.tick",
+};