@vxil/cli 0.17.0 → 0.18.0

package/dist/_vxil-feature-configs-hooks.d.ts

@@ -64,6 +64,17 @@ export declare class HookEvalError extends Error {
 /** Thrown by a `validate` hook whose expression is falsy — maps to a clean 422. */
 export declare class HookRejection extends Error {
 }
+/** A WRITE `validate` hook whose expression could not be evaluated (null
+ *  arithmetic, a missing operand, a bad date …). Still a HookEvalError — the
+ *  write is refused, never let through — but it carries the hook's id and its
+ *  declared `message`, so the API can show the end user the tenant's own copy
+ *  while keeping the engine detail for the developer. `message` stays the
+ *  engine detail. */
+export declare class HookValidateFault extends HookEvalError {
+    readonly hookId: string;
+    readonly tenantMessage: string | undefined;
+    constructor(hookId: string, tenantMessage: string | undefined, detail: string);
+}
 /** Parse a hook expression into an AST. Throws HookParseError on any malformed input. */
 export declare function parseExpr(src: string): Node;
 /** Walk the AST and reject anything outside the allow-list, plus depth bounds.
@@ -157,6 +168,36 @@ export type InferredType = 'number' | 'string' | 'boolean' | 'null' | 'unknown';
 /** Best-effort static type of an expression's result (its output). 'unknown' for
  *  member access / coalesce / mixed ternaries — never a false-positive mismatch. */
 export declare function inferType(nd: Node): InferredType;
+/** One declared field, as the typing pass needs it (cms field type + required). */
+export interface HookFieldInfo {
+    type: string;
+    required?: boolean;
+}
+/** collection → field → declared info. */
+export type HookFieldTypes = Record<string, Record<string, HookFieldInfo>>;
+/** Type one parsed expression against one collection's declared fields.
+ *  `errors` are shapes that can never work (refuse); `warnings` are shapes
+ *  that work only for some stored values (json vs a scalar, `+` on a text
+ *  field) and arithmetic on an optional field with no coalesce() — it faults
+ *  the hook whenever the field is missing. `present` lists fields a derive sets first. */
+export declare function checkHookExprTypes(root: Node, fields: Record<string, HookFieldInfo> | undefined, opts: {
+    kind: HookDef['kind'];
+    event: HookDef['event'];
+    present?: ReadonlySet<string> | undefined;
+}): {
+    errors: string[];
+    warnings: string[];
+};
+/** Project declared collections (`{ <name>: { fields: { <f>: { type, required? } } } }`
+ *  — the vxil.config / apply-bundle shape) onto HookFieldTypes. Malformed
+ *  entries are skipped: no declared field means no verdict. */
+export declare function hookFieldTypesOf(collections: unknown): HookFieldTypes;
+/** Type every hook whose collection the caller declares (see checkHookExprTypes).
+ *  Unparseable expressions are skipped — validateHookDef already reports them. */
+export declare function checkHookTypes(hooks: Record<string, HookDef> | undefined, fieldTypes: HookFieldTypes): {
+    errors: string[];
+    warnings: string[];
+};
 export type HlKind = 'num' | 'str' | 'fn' | 'var' | 'kw' | 'op' | 'ident' | 'ws' | 'err';
 /** Token-level highlighter over the FULL source (whitespace + bad chars kept),
  *  so a dashboard editor can render a colored overlay behind a textarea. */

package/dist/_vxil-feature-configs.d.ts

@@ -78,9 +78,10 @@ export declare const NotificationsConfigSchema: import("@sinclair/typebox").TObj
         maxAttempts: import("@sinclair/typebox").TInteger;
         backoff: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"exponential">, import("@sinclair/typebox").TLiteral<"linear">]>;
     }>>;
-    suppression: import("@sinclair/typebox").TObject<{
+    suppression: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         softBounceThreshold: import("@sinclair/typebox").TInteger;
-    }>;
+        testRecipients: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    }>>;
     rateLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         perDay: import("@sinclair/typebox").TInteger;
         perTenantSec: import("@sinclair/typebox").TInteger;
@@ -832,6 +833,9 @@ export declare const TEST_RECIPIENT_EMAIL_RE: RegExp;
 export declare const TEST_RECIPIENT_GLOB_RE: RegExp;
 export declare const TEST_RECIPIENT_E164_RE: RegExp;
 export declare function isTestRecipientPattern(entry: string): boolean;
+/** The MAIL subset of the grammar (notifications suppression.testRecipients):
+ * an exact email or an `*@domain` glob. */
+export declare function isMailTestRecipientPattern(entry: string): boolean;
 /** True iff `identifier` (an email today) matches one configured entry:
  * exact (case-insensitive) or the `*@domain` glob. +E.164 entries never match
  * an email. */