@codemation/core-nodes 1.0.2 → 1.1.0

package/src/nodes/collections/collectionDeleteNode.types.ts

@@ -0,0 +1,23 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionDeleteNode = defineNode({
+  key: "collection-delete",
+  title: "Collection: Delete",
+  description: "Delete a row by id from a collection.",
+  icon: "lucide:braces",
+  configSchema: z.object({
+    collectionName: z.string(),
+    id: z.string(),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const result = await store.delete(config.id);
+    return { deleted: result.deleted, id: config.id };
+  },
+});

package/src/nodes/collections/collectionFindOneNode.types.ts

@@ -0,0 +1,26 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionFindOneNode = defineNode({
+  key: "collection-find-one",
+  title: "Collection: Find One",
+  description: "Find a single row matching a filter in a collection.",
+  icon: "lucide:filter",
+  configSchema: z.object({
+    collectionName: z.string(),
+    where: z.record(z.string(), z.unknown()),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const row = await store.findOne(config.where);
+    if (row === null) {
+      return [];
+    }
+    return row;
+  },
+});

package/src/nodes/collections/collectionGetNode.types.ts

@@ -0,0 +1,26 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionGetNode = defineNode({
+  key: "collection-get",
+  title: "Collection: Get",
+  description: "Get a single row by id from a collection.",
+  icon: "lucide:layers",
+  configSchema: z.object({
+    collectionName: z.string(),
+    id: z.string(),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const row = await store.get(config.id);
+    if (row === null) {
+      return [];
+    }
+    return row;
+  },
+});

package/src/nodes/collections/collectionInsertNode.types.ts

@@ -0,0 +1,22 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionInsertNode = defineNode({
+  key: "collection-insert",
+  title: "Collection: Insert",
+  description: "Insert a new row into a collection.",
+  icon: "lucide:boxes",
+  configSchema: z.object({
+    collectionName: z.string(),
+    data: z.record(z.string(), z.unknown()),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    return await store.insert(config.data);
+  },
+});

package/src/nodes/collections/collectionListNode.types.ts

@@ -0,0 +1,30 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionListNode = defineNode({
+  key: "collection-list",
+  title: "Collection: List",
+  description: "List rows from a collection with optional pagination and filtering.",
+  icon: "lucide:split",
+  configSchema: z.object({
+    collectionName: z.string(),
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().nonnegative().optional(),
+    where: z.record(z.string(), z.unknown()).optional(),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const { rows } = await store.list({
+      limit: config.limit,
+      offset: config.offset,
+      where: config.where,
+    });
+    // Emit one item per row per AGENTS.md engine/node contract.
+    return [...rows];
+  },
+});

package/src/nodes/collections/collectionUpdateNode.types.ts

@@ -0,0 +1,23 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionUpdateNode = defineNode({
+  key: "collection-update",
+  title: "Collection: Update",
+  description: "Update a row by id in a collection.",
+  icon: "lucide:square-pen",
+  configSchema: z.object({
+    collectionName: z.string(),
+    id: z.string(),
+    patch: z.record(z.string(), z.unknown()),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    return await store.update(config.id, config.patch);
+  },
+});

package/src/nodes/collections/index.ts

@@ -0,0 +1,6 @@
+export { collectionInsertNode } from "./collectionInsertNode.types";
+export { collectionGetNode } from "./collectionGetNode.types";
+export { collectionFindOneNode } from "./collectionFindOneNode.types";
+export { collectionListNode } from "./collectionListNode.types";
+export { collectionUpdateNode } from "./collectionUpdateNode.types";
+export { collectionDeleteNode } from "./collectionDeleteNode.types";

package/src/nodes/httpRequest.ts

@@ -1,5 +1,18 @@
-import { RetryPolicy, type RetryPolicySpec, type RunnableNodeConfig, type TypeToken } from "@codemation/core";
+import {
+  RetryPolicy,
+  type CredentialRequirement,
+  type RetryPolicySpec,
+  type RunnableNodeConfig,
+  type TypeToken,
+} from "@codemation/core";
 
+import type { HttpBodySpec } from "../http/httpRequest.types";
+import {
+  apiKeyCredentialType,
+  basicAuthCredentialType,
+  bearerTokenCredentialType,
+  oauth2ClientCredentialsType,
+} from "../credentials/index";
 import { HttpRequestNode } from "./HttpRequestNodeFactory";
 
 export type HttpRequestDownloadMode = "auto" | "always" | "never";
@@ -13,9 +26,22 @@ export type HttpRequestOutputJson = Readonly<{
   statusText: string;
   mimeType: string;
   headers: Readonly<Record<string, string>>;
+  json?: unknown;
+  text?: string;
   bodyBinaryName?: string;
 }>;
 
+/**
+ * The built-in HTTP request credential type IDs accepted by the `HttpRequest` node.
+ * These match the four generic credential types shipped with `@codemation/core-nodes`.
+ */
+export const HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES: ReadonlyArray<string> = [
+  bearerTokenCredentialType.definition.typeId,
+  apiKeyCredentialType.definition.typeId,
+  basicAuthCredentialType.definition.typeId,
+  oauth2ClientCredentialsType.definition.typeId,
+] as const;
+
 export class HttpRequest<
   TInputJson = Readonly<{ url?: string }>,
   TOutputJson = HttpRequestOutputJson,
@@ -28,8 +54,27 @@ export class HttpRequest<
   constructor(
     public readonly name: string,
     public readonly args: Readonly<{
+      /** HTTP method (default: GET). */
       method?: string;
+      /**
+       * Legacy: field name on item.json to read the URL from.
+       * Use `url` for a literal/templated URL instead.
+       */
       urlField?: string;
+      /** Literal or templated URL. When present, takes precedence over `urlField`. */
+      url?: string;
+      /** Extra headers to add to every request. */
+      headers?: Readonly<Record<string, string>>;
+      /** Query parameters to append to the URL. */
+      query?: Readonly<Record<string, string>>;
+      /** Request body specification. For canvas use, pass a JSON string in `body.data`. */
+      body?: HttpBodySpec;
+      /**
+       * Credential slot key. When set, the node resolves a credential via
+       * `ctx.getCredential(credentialSlot)` and applies it to the request.
+       * The slot must be declared in `getCredentialRequirements()`.
+       */
+      credentialSlot?: string;
       binaryName?: string;
       downloadMode?: HttpRequestDownloadMode;
       id?: string;
@@ -56,6 +101,21 @@ export class HttpRequest<
   get downloadMode(): HttpRequestDownloadMode {
     return this.args.downloadMode ?? "auto";
   }
+
+  getCredentialRequirements(): ReadonlyArray<CredentialRequirement> {
+    if (!this.args.credentialSlot) {
+      return [];
+    }
+    return [
+      {
+        slotKey: this.args.credentialSlot,
+        label: "Authentication",
+        acceptedTypes: HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES,
+        optional: true,
+        helpText: "Optional credential for authenticating the HTTP request.",
+      },
+    ];
+  }
 }
 
 export { HttpRequestNode } from "./HttpRequestNodeFactory";

package/src/nodes/isTestRun.ts

@@ -0,0 +1,24 @@
+import type { RunnableNodeConfig, TypeToken } from "@codemation/core";
+
+import { IsTestRunNode } from "./IsTestRunNode";
+
+/**
+ * Branches per-item on whether the current run is a test run. Output ports: `true`, `false`.
+ * The wire payload is unchanged — this is a router, not a transform.
+ */
+export class IsTestRun<TInputJson = unknown> implements RunnableNodeConfig<TInputJson, TInputJson> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = IsTestRunNode;
+  readonly execution = { hint: "local" } as const;
+  readonly icon = "lucide:flask-conical" as const;
+  readonly declaredOutputPorts = ["true", "false"] as const;
+  readonly name: string;
+  readonly id?: string;
+
+  constructor(name: string = "Is test run?", id?: string) {
+    this.name = name;
+    this.id = id;
+  }
+}
+
+export { IsTestRunNode } from "./IsTestRunNode";

package/src/nodes/testTrigger.ts

@@ -0,0 +1,72 @@
+import type {
+  CredentialRequirement,
+  Item,
+  TestTriggerNodeConfig,
+  TestTriggerSetupContext,
+  TypeToken,
+} from "@codemation/core";
+
+import { TestTriggerNode } from "./TestTriggerNode";
+
+export interface TestTriggerOptions<TOutputJson> {
+  readonly name?: string;
+  readonly id?: string;
+  readonly icon?: string;
+  /** Cap on simultaneous in-flight test cases for one suite run. Default: 4 (orchestrator). */
+  readonly concurrency?: number;
+  readonly credentialRequirements?: ReadonlyArray<CredentialRequirement>;
+  /**
+   * Free-form description of where the test cases come from. Shown in the node properties
+   * panel and the Tests-tab suite-detail header so authors revisiting the workflow six months
+   * later remember which mailbox / folder / fixture file the cases originate from.
+   */
+  readonly description?: string;
+  /**
+   * Author callback that yields one item per test case. Items are dispatched as separate
+   * workflow runs by the TestSuiteOrchestrator, with `executionOptions.testContext` set.
+   * The provided context exposes credential resolution and an AbortSignal for cancellation.
+   */
+  generateItems(ctx: TestTriggerSetupContext<TestTrigger<TOutputJson>>): AsyncIterable<Item<TOutputJson>>;
+  /**
+   * Optional resolver: extract a human-readable label from a yielded item. The orchestrator
+   * persists this on the run, so the Tests-tab tree-table shows e.g. "RFQ for batch 14"
+   * instead of an opaque runId. Typical use: `(item) => item.json.subject` for mailbox tests.
+   */
+  caseLabel?(item: Item<TOutputJson>): string | undefined;
+}
+
+/**
+ * Trigger config for a test fixture source. Drop one (or more) of these on the canvas alongside
+ * a workflow's live triggers; clicking "Run tests" on the Tests tab invokes
+ * {@link TestTriggerOptions.generateItems} via the TestSuiteOrchestrator.
+ */
+export class TestTrigger<TOutputJson = unknown> implements TestTriggerNodeConfig<TOutputJson> {
+  readonly kind = "trigger" as const;
+  readonly triggerKind = "test" as const;
+  readonly type: TypeToken<unknown> = TestTriggerNode;
+  readonly icon: string;
+  readonly name: string;
+  readonly id?: string;
+  readonly concurrency?: number;
+  readonly description?: string;
+  readonly generateItems: TestTriggerOptions<TOutputJson>["generateItems"];
+  readonly caseLabel?: TestTriggerOptions<TOutputJson>["caseLabel"];
+  private readonly credentialRequirements: ReadonlyArray<CredentialRequirement>;
+
+  constructor(options: TestTriggerOptions<TOutputJson>) {
+    this.name = options.name ?? "Test trigger";
+    this.id = options.id;
+    this.icon = options.icon ?? "lucide:flask-conical";
+    this.concurrency = options.concurrency;
+    this.description = options.description;
+    this.credentialRequirements = options.credentialRequirements ?? [];
+    this.generateItems = options.generateItems;
+    this.caseLabel = options.caseLabel;
+  }
+
+  getCredentialRequirements(): ReadonlyArray<CredentialRequirement> {
+    return this.credentialRequirements;
+  }
+}
+
+export { TestTriggerNode } from "./TestTriggerNode";