@rolealpha/n8n-nodes-rolealpha 0.8.1 → 0.9.0

package/dist/lib/workflows.d.ts

@@ -11,11 +11,14 @@
  */
 import { type EntityChange } from './changes';
 import { type GraphSource } from './graph';
+import { type RunnerInfo } from './templates';
 export declare const MANAGED_TAG = "rolealpha-managed";
 export declare const DRAFT_TAG = "rolealpha-draft";
 export declare const MARKER_NAME = "roleALPHA binding";
 export declare const DRAFT_PREFIX = "Draft: ";
 export declare const DEFAULT_NODE_TYPES: string[];
+/** Allowed only with Allow Code Nodes, and then only through the code check. */
+export declare const CODE_NODE = "n8n-nodes-base.code";
 export interface N8nNode {
     id?: string;
     name: string;
@@ -61,6 +64,8 @@ export interface DraftInfo {
     reason: string;
     /** false when the entity is only a neighbour of the target: Apply then leaves the binding as it is. */
     bindEntity?: boolean;
+    /** When the draft was made; a later change of the entity replaces it. */
+    madeAt?: string;
 }
 export interface Binding {
     managed: true;
@@ -78,7 +83,13 @@ export interface ManagedWorkflow {
     active: boolean;
     entities: string[];
     isDraft: boolean;
+    /** For a draft: the entity it was made for, and when. */
+    draftFor?: {
+        entityUuid: string;
+        madeAt: string | null;
+    };
     versionId: string | null;
+    webhookPaths: string[];
     nodes: Array<{
         name: string;
         type: string;
@@ -87,6 +98,18 @@ export interface ManagedWorkflow {
     }>;
     connections: string[];
 }
+/** A workflow the builder must not touch, but must know about so it does not build it again. */
+export interface OtherWorkflow {
+    id: string;
+    name: string;
+    active: boolean;
+    triggers: string[];
+    webhookPaths: string[];
+    /** Inputs it declares as a sub-workflow; null when there are none to go by. */
+    inputs: string[] | null;
+    /** Whether it names the custom ID of the step at hand. */
+    namesStep?: boolean;
+}
 export declare function readBinding(wf: Pick<N8nWorkflow, 'nodes'>): Binding | null;
 export declare function markerNode(binding: Binding, position?: [number, number]): N8nNode;
 /** Hash of exactly what runs: names, types, versions, parameters, credentials and connections. */
@@ -95,6 +118,10 @@ export declare function summarizeWorkflows(raw: unknown[]): {
     workflows: ManagedWorkflow[];
     credentials: KnownCredential[];
 };
+/** All workflows that are not managed: what they start on, and whether they name the step already. */
+export declare function summarizeOthers(raw: unknown[], customId?: string | null): OtherWorkflow[];
+/** Finds the runner by ID or exact name among all workflows. */
+export declare function findRunner(raw: unknown[], nameOrId: string): RunnerInfo | null;
 /** A managed workflow a change touches: bound to the entity, or to a neighbouring step. */
 export interface AffectedWorkflow {
     workflowId: string;
@@ -110,6 +137,15 @@ export interface PlanContext {
     credentials: KnownCredential[];
     nodeTypes: string[];
     extraRules?: string[];
+    /** All workflows that are not managed; without them the checks against them are skipped. */
+    others?: OtherWorkflow[];
+    runner?: RunnerInfo | null;
+    endpointUrl?: string;
+    organisation?: string;
+    /** Whether Code nodes may be proposed at all. */
+    allowCode?: boolean;
+    /** Whether n8n blocks environment access; a Code node needs that. */
+    envBlocked?: boolean;
 }
 export interface PlanInput {
     systemMessage: string;
@@ -135,9 +171,42 @@ export interface PlanCheck {
     notes: string[];
     workflow: N8nWorkflow | null;
     contentHash: string | null;
+    /** The template the workflow comes from, if any. */
+    template?: string;
+    /** Code nodes that are new or changed, with the number of tests they passed. */
+    code?: Array<{
+        node: string;
+        tests: number;
+    }>;
 }
 export declare function checkPlan(ctx: PlanContext, answerRaw: unknown, existing?: N8nWorkflow | null): PlanCheck;
-export declare function draftWorkflow(plan: PlanCheck, change: EntityChange, target?: N8nWorkflow | null): N8nWorkflow;
+export interface TriageOptions {
+    /** Custom ID prefixes of the steps the builder runs itself. */
+    ownPrefixes?: string[];
+    /** Whether a generic scheduler starts every step with a frequency, so such a step needs no workflow. */
+    schedulerCoversFrequency?: boolean;
+}
+export interface TriageResult {
+    rule: 'own_step' | 'draft_waiting' | 'decision' | 'grouping' | 'scheduled' | 'retired';
+    reason: string;
+}
+/** Changes whose answer is known without asking: same result every time, and no model call. */
+export declare function triage(ctx: PlanContext, opts?: TriageOptions): TriageResult | null;
+/** The answer of a rule, in the shape of a checked proposal. */
+export declare function decidedPlan(change: EntityChange, reason: string): PlanCheck;
+/** What a draft changes, one line each: a new workflow as a list of its nodes. */
+export declare function diffWorkflows(before: Pick<N8nWorkflow, 'nodes' | 'connections'> | null | undefined, after: Pick<N8nWorkflow, 'nodes' | 'connections'>): string[];
+/** The Code nodes a draft adds or changes against its target. */
+export declare function changedCode(after: Pick<N8nWorkflow, 'nodes'>, before?: Pick<N8nWorkflow, 'nodes'> | null): Array<{
+    node: string;
+    jsCode: string;
+}>;
+/** The change and any code, escaped for the approval e-mail: all of it comes from a model. */
+export declare function reviewHtml(diff: string[], code: Array<{
+    node: string;
+    jsCode: string;
+}>): string;
+export declare function draftWorkflow(plan: PlanCheck, change: EntityChange, target?: N8nWorkflow | null, now?: Date): N8nWorkflow;
 /** The hash a draft stands for: its content, or for a deactivation the target and its version. */
 export declare function draftHash(draft: N8nWorkflow): {
     info: DraftInfo;
@@ -147,7 +216,8 @@ export type N8nRequest = (method: 'GET' | 'POST' | 'PUT' | 'DELETE', path: strin
 export declare class N8nApi {
     private readonly request;
     constructor(request: N8nRequest);
-    listWorkflows(tag: string): Promise<N8nWorkflow[]>;
+    /** The workflows with a tag; without one, all of them. */
+    listWorkflows(tag?: string): Promise<N8nWorkflow[]>;
     get(id: string): Promise<N8nWorkflow>;
     create(wf: N8nWorkflow): Promise<N8nWorkflow>;
     update(id: string, wf: N8nWorkflow): Promise<N8nWorkflow>;
@@ -171,6 +241,7 @@ export interface ApplyResult {
  */
 export declare function applyDraft(api: N8nApi, draftId: string, approvedHash: string, opts?: {
     activate?: boolean;
+    codeApproved?: boolean;
 }): Promise<ApplyResult>;
 /** Deletes a rejected draft. Refuses anything that is not a draft. */
 export declare function discardDraft(api: N8nApi, draftId: string): Promise<{