@vxil/cli 0.16.1 → 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. */

package/dist/config.d.ts

@@ -106,6 +106,21 @@ export interface CollectionDef {
      *  with a regression test on each — an attribute read by no enforcing path ships
      *  inert (the validation.unique / owner_field precedent). */
     public?: boolean;
+    /** What a VERIFIED end user (a thin-client key + a session) may do on this
+     *  collection (https://vxil.com/docs/guide/09-security-and-multitenancy):
+     *    'readwrite' (default) — read and write (owner-scoped when ownerField is set);
+     *    'read'      — read only (owner-scoped as above); every end-user write
+     *                  (create, update, $inc, delete, publish, transaction step,
+     *                  filtered delete, batch write — and a delete elsewhere
+     *                  whose on_delete cascade / set_null would change a row
+     *                  here) is `403 server_only`;
+     *    'none'      — no end-user reads or writes at all, even with ownerField.
+     *  Server keys (and platform writes such as a jobs status mirror) are never
+     *  affected. Stored on the collection (model data, not a config leaf) and
+     *  carried by BOTH push paths; widening ('read'/'none' → 'readwrite') needs
+     *  `vxil push --allow-destructive`. Any other value fails `vxil plan` /
+     *  `vxil push` (it never falls back to 'readwrite'). */
+    endUserAccess?: 'readwrite' | 'read' | 'none';
     /** Per-record action buttons (guide ch. 4): `[{ key, label, fn }]`, stored on
      *  the collection (model data, not a config leaf). The dashboard renders one
      *  button per action on each record row; `POST /v1/cms/items/:coll/:id/actions/