createCheck

Стабильный · с 0.1.0

Строит хелпер check, который обработчики получают через ctx.check. Рантайм собирает его за тебя на каждом запуске — createCheck экспортируется только для редких случаев, когда нужно использовать тот же предикатный DSL вне контекста обработчика (кастомные middleware, тестирование по условиям, панели devtools).

is, all и any принимают предикаты над NonNullable<C[K]>. Когда значение условия равно undefined или null, предикат не вызывается, а результат по этому ключу — false.

Импорт

import { createCheck } from '@triggery/core';

Сигнатура

function createCheck<C extends Record<string, unknown>>(
  conditions: C,
): CheckCtx<C>;

Параметры

Параметр	Тип	Описание
`conditions`	`Record<string, unknown>`	Карта-снепшот значений условий. Передавай ту же форму, которую рантайм даёт обработчикам.

Возвращает

Объект CheckCtx:

Метод	Сигнатура	Результат
`is(key, predicate)`	`(key, value => boolean) => boolean`	`true`, когда условие существует (не null) и предикат вернул truthy.
`all(map)`	`({ key: predicate, … }) => boolean`	Каждое перечисленное условие должно существовать и проходить свой предикат.
`any(map)`	`({ key: predicate, … }) => boolean`	Хотя бы одно перечисленное условие должно существовать и проходить свой предикат.

Примеры

Внутри обработчика (обычный случай)

Обычно ты используешь ctx.check вместо ручной сборки:

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';

createTriggercreateTrigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            active: boolean;
        } | null;
        tenant: string | null;
    };
}>(config: CreateTriggerConfig<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            active: boolean;
        } | null;
        tenant: string | null;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            active: boolean;
        } | null;
        tenant: string | null;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
  eventsevents: {
    ping: void;
}: { pingping: void: void };
  conditionsconditions: {
    user: {
        active: boolean;
    } | null;
    tenant: string | null;
}: { useruser: {
    active: boolean;
} | null: { activeactive: boolean: boolean } | null; tenanttenant: string | null: string | null };
}>({
  idid: string: 'demo',
  eventsevents: readonly "ping"[]: ['ping'],
  handlerhandler: TriggerHandler<{
    events: {
        ping: void;
    };
    conditions: {
        user: {
            active: boolean;
        } | null;
        tenant: string | null;
    };
}, never>({ checkcheck: CheckCtx<{
    user: {
        active: boolean;
    } | null;
    tenant: string | null;
}> }) {
    if (checkcheck: CheckCtx<{
    user: {
        active: boolean;
    } | null;
    tenant: string | null;
}>.allall<{
    user: (u: {
        active: boolean;
    }) => boolean;
    tenant: (t: string) => boolean;
}>(map: {
    user: (u: {
        active: boolean;
    }) => boolean;
    tenant: (t: string) => boolean;
}): boolean({ useruser: (u: {
    active: boolean;
}) => boolean: uu: {
    active: boolean;
} => uu: {
    active: boolean;
}.activeactive: boolean, tenanttenant: (t: string) => boolean: tt: string => tt: string.lengthString.length: numberReturns the length of a String object. > 0 })) {
      consolevar console: Console.logConsole.log(...data: any[]): voidThe **`console.log()`** static method outputs a message to the console.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)('go');
    }
  },
});

Standalone (продвинутый — вне обработчика)

import { createCheckfunction createCheck<C extends Record<string, unknown>>(conditions: C): CheckCtx<C>Builds the `check` helper bound to a specific conditions snapshot.

`is`, `all` and `any` accept predicates over `NonNullable<C[K]>`: if a condition is
absent (`undefined` or `null`), the predicate is not invoked and the result is `false`
for that key. } from '@triggery/core';

const checkconst check: CheckCtx<{
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}> = createCheckcreateCheck<{
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}>(conditions: {
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}): CheckCtx<{
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}>Builds the `check` helper bound to a specific conditions snapshot.

`is`, `all` and `any` accept predicates over `NonNullable<C[K]>`: if a condition is
absent (`undefined` or `null`), the predicate is not invoked and the result is `false`
for that key.({
  useruser: {
    active: boolean;
    name: string;
} | null:   { activeactive: boolean: true,  namename: string: 'Alice' } as { activeactive: boolean: boolean; namename: string: string } | null,
  tenanttenant: string | null: 'acme-corp'                       as string | null,
});

checkconst check: CheckCtx<{
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}>.isis<"user">(key: "user", predicate: (value: {
    active: boolean;
    name: string;
}) => boolean): boolean('user', uu: {
    active: boolean;
    name: string;
} => uu: {
    active: boolean;
    name: string;
}.activeactive: boolean);                 // true
checkconst check: CheckCtx<{
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}>.allall<{
    user: (u: {
        active: boolean;
        name: string;
    }) => boolean;
    tenant: (t: string) => boolean;
}>(map: {
    user: (u: {
        active: boolean;
        name: string;
    }) => boolean;
    tenant: (t: string) => boolean;
}): boolean({ useruser: (u: {
    active: boolean;
    name: string;
}) => boolean: uu: {
    active: boolean;
    name: string;
} => uu: {
    active: boolean;
    name: string;
}.activeactive: boolean, tenanttenant: (t: string) => boolean: tt: string => tt: string.lengthString.length: numberReturns the length of a String object. > 0 }); // true
checkconst check: CheckCtx<{
    user: {
        active: boolean;
        name: string;
    } | null;
    tenant: string | null;
}>.anyany<{
    user: (u: {
        active: boolean;
        name: string;
    }) => boolean;
}>(map: {
    user: (u: {
        active: boolean;
        name: string;
    }) => boolean;
}): boolean({ useruser: (u: {
    active: boolean;
    name: string;
}) => boolean: uu: {
    active: boolean;
    name: string;
} => !uu: {
    active: boolean;
    name: string;
}.activeactive: boolean });             // false

Null-safety

import { createCheckfunction createCheck<C extends Record<string, unknown>>(conditions: C): CheckCtx<C>Builds the `check` helper bound to a specific conditions snapshot.

`is`, `all` and `any` accept predicates over `NonNullable<C[K]>`: if a condition is
absent (`undefined` or `null`), the predicate is not invoked and the result is `false`
for that key. } from '@triggery/core';

const checkconst check: CheckCtx<{
    user: {
        active: boolean;
    } | null;
}> = createCheckcreateCheck<{
    user: {
        active: boolean;
    } | null;
}>(conditions: {
    user: {
        active: boolean;
    } | null;
}): CheckCtx<{
    user: {
        active: boolean;
    } | null;
}>Builds the `check` helper bound to a specific conditions snapshot.

`is`, `all` and `any` accept predicates over `NonNullable<C[K]>`: if a condition is
absent (`undefined` or `null`), the predicate is not invoked and the result is `false`
for that key.({ useruser: {
    active: boolean;
} | null: null as { activeactive: boolean: boolean } | null });

// Predicate is never invoked when the value is null — no NPE risk.
checkconst check: CheckCtx<{
    user: {
        active: boolean;
    } | null;
}>.isis<"user">(key: "user", predicate: (value: {
    active: boolean;
}) => boolean): boolean('user', uu: {
    active: boolean;
} => uu: {
    active: boolean;
}.activeactive: boolean); // false

Замечания

См. также

createTrigger Обработчик получает экземпляр `check` автоматически.

TriggerCtx Полный тип контекста обработчика, включая `check`.

Руководство по условиям Когда читать условия напрямую, а когда через `check`.

Ограничение required Зачем вообще существует `check` — заметки по сужению типов в V1.