createCheck

Stable · since 0.1.0

Builds the check helper that handlers receive via ctx.check. The runtime wires this for you on every run — createCheck is exported only for the rare cases where you need the same predicate DSL outside the handler context (custom middleware, condition-based testing, devtools panels).

is, all and any accept predicates over NonNullable<C[K]>. When a condition value is undefined or null, the predicate is never called and the result is false for that key.

Import

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

Signature

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

Parameters

Param	Type	Description
`conditions`	`Record<string, unknown>`	Snapshot map of condition values. Pass the same shape the runtime gives to handlers.

Returns

A CheckCtx object:

Method	Signature	Result
`is(key, predicate)`	`(key, value => boolean) => boolean`	`true` when the condition exists (non-null) and the predicate returns truthy.
`all(map)`	`({ key: predicate, … }) => boolean`	Every listed condition must exist and pass its predicate.
`any(map)`	`({ key: predicate, … }) => boolean`	At least one listed condition must exist and pass its predicate.

Examples

Inside a handler (the common case)

You normally use ctx.check instead of constructing your own:

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 (advanced — outside a handler)

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

Notes

createTrigger The handler receives a `check` instance automatically.

TriggerCtx Full handler context type, including `check`.

Conditions guide When to read conditions directly vs through `check`.

Required limitation Why `check` exists at all — V1 narrowing notes.