@zerodot/node-sdk 1.0.0 → 1.1.0

package/dist/index.d.mts

@@ -1,4 +1,17 @@
 import { z } from "zod";
+/**
+ * Binary data in a node output. zerodot has no separate binary store, so the bytes are base64
+ * text under `binary.<property>` in the JSON output. The size limit of a node output applies.
+ */
+type BinaryData = {
+  data: string;
+  mimeType: string;
+  fileName?: string;
+};
+export declare function mimeTypeOf(fileName: string): string;
+export declare function toBinary(bytes: Uint8Array, fileName: string, mimeType?: string): BinaryData;
+/** The binary data that an earlier node put under `input.binary[property]`. */
+export declare function readBinary(input: unknown, property: string): BinaryData;
 declare const sandboxRequestSchema: z.ZodObject<{
   code: z.ZodString;
   scope: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -419,11 +432,6 @@ type NodeDefinition<Schema extends z.ZodType = z.ZodType> = {
   listen?(ctx: ListenContext<z.output<Schema>>): Promise<ListenHandle>;
   /** Output ports that depend on the config (a switch has one port for each case). */
   outPorts?(config: Record<string, unknown>): string[];
-  /**
-   * Data form of `outPorts`, for a node whose code the browser does not have (an adapted n8n
-   * node). The catalog carries it, so the editor can draw the ports.
-   */
-  outPortsKind?: "n8n-switch";
   run(ctx: NodeRunContext<z.output<Schema>>): Promise<NodeResult> | NodeResult;
 };
 export declare function defineNode<Schema extends z.ZodType>(definition: NodeDefinition<Schema>): NodeDefinition<Schema>;
@@ -465,6 +473,43 @@ type CredentialTypeDefinition = {
 };
 /** A string with one `` and nothing else keeps the value type. Otherwise the result is text. */
 export declare function resolveTemplate(input: string, scope: Record<string, unknown>): unknown;
+/** Resolve every string inside a config value. Errors carry the path to the bad value. */
+export declare function resolveConfig(value: unknown, scope: Record<string, unknown>, path?: string): unknown;
+/**
+ * The shape of a nested field (a collection or a fixed collection), as plain data. A node writes
+ * it into the JSON Schema of its config. The editor draws a form from it.
+ * A key of a condition that starts with "/" reads from the top level of the config.
+ */
+type FieldSpec = {
+  name: string;
+  label: string;
+  kind: "string" | "number" | "boolean" | "options" | "filter" | "collection" | "fixed";
+  description?: string;
+  placeholder?: string;
+  default?: unknown;
+  multiline?: boolean;
+  options?: {
+    value: string | number | boolean;
+    label: string;
+    hint?: string;
+  }[];
+  show?: FieldCondition | FieldCondition[];
+  hide?: FieldCondition;
+  /** `collection`: the fields that the user can add. */
+  fields?: FieldSpec[];
+  /** `fixed`: the groups. A group holds a list when `multiple` is set, or one object. */
+  groups?: {
+    name: string;
+    label: string;
+    fields: FieldSpec[];
+  }[];
+  multiple?: boolean;
+};
+/** One item of a node run: a plain object. */
+type Item = Record<string, unknown>;
+export declare const isRecord: (value: unknown) => value is Item;
+/** The items of a node run. A list is the items. One object is one item. Null is one empty item. */
+export declare function toItems(input: unknown): Item[];
 /**
  * Reads an icon file of a package and returns it as a data URL, for `iconUrl` of a node or a
  * credential type. `from` is `import.meta.url` of the file that calls it, and `path` is relative
@@ -476,11 +521,11 @@ export declare function fileIcon(from: string, path: string): string;
  * Version of the node contract (the shape of `NodeDefinition` and what a node can use).
  * A minor version only adds. A major version can break a node package.
  */
-export declare const SDK_VERSION = "1.0.0";
+export declare const SDK_VERSION = "1.1.0";
 /**
  * True when `version` fits `range`. A range is a caret range (`^1.4`, `^1.4.2`) or one exact
  * version (`1.4.2`). A caret range allows the same major version, from the given version up.
  * For major 0 it allows the same minor version only, as npm does.
  */
 export declare function satisfiesSdk(range: string, version?: string): boolean;
-export type { CredentialTypeDefinition, ListenContext, ListenHandle, NodeCategory, NodeDefinition, NodeResult, NodeRunContext, NodeWebhook, OAuth2Config, PollContext, PollItem, PollResult, ResolvedCredential, ShowRules, WaitForm, WaitFormField, WebhookContext, WebhookRequest, WebhookVerdict };
+export type { BinaryData, CredentialTypeDefinition, FieldSpec, Item, ListenContext, ListenHandle, NodeCategory, NodeDefinition, NodeResult, NodeRunContext, NodeWebhook, OAuth2Config, PollContext, PollItem, PollResult, ResolvedCredential, ShowRules, WaitForm, WaitFormField, WebhookContext, WebhookRequest, WebhookVerdict };

package/dist/index.mjs

@@ -2,6 +2,46 @@ import { z } from "zod";
 import { readFileSync } from "node:fs";
 import { extname } from "node:path";
 import { fileURLToPath } from "node:url";
+// ../engine/src/binary.ts
+const MIME = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	mp4: "video/mp4",
+	mov: "video/quicktime",
+	mp3: "audio/mpeg",
+	ogg: "audio/ogg",
+	oga: "audio/ogg",
+	wav: "audio/wav",
+	pdf: "application/pdf",
+	txt: "text/plain",
+	json: "application/json",
+	csv: "text/csv",
+	zip: "application/zip",
+	tgs: "application/x-tgsticker"
+};
+function mimeTypeOf(fileName) {
+	return MIME[fileName.split(".").pop()?.toLowerCase() ?? ""] ?? "application/octet-stream";
+}
+function toBinary(bytes, fileName, mimeType) {
+	return {
+		data: Buffer.from(bytes).toString("base64"),
+		mimeType: mimeType ?? mimeTypeOf(fileName),
+		fileName
+	};
+}
+/** The binary data that an earlier node put under `input.binary[property]`. */
+function readBinary(input, property) {
+	const found = (input?.binary)?.[property];
+	if (!found || typeof found.data !== "string") throw new Error(`The input has no binary data in the property "${property}"`);
+	return {
+		data: found.data,
+		mimeType: found.mimeType ?? "application/octet-stream",
+		fileName: found.fileName
+	};
+}
 // ../engine/src/expression.ts
 /**
 * Small safe expression evaluator. No eval, no new Function, no function calls.
@@ -389,6 +429,21 @@ function resolveTemplate(input, scope) {
 	if (only && "expression" in only) return evaluateExpression(only.expression, scope);
 	return segments.map((s) => "text" in s ? s.text : stringify(evaluateExpression(s.expression, scope))).join("");
 }
+/** Resolve every string inside a config value. Errors carry the path to the bad value. */
+function resolveConfig(value, scope, path = "config") {
+	if (typeof value === "string") try {
+		return resolveTemplate(value, scope);
+	} catch (error) {
+		if (error instanceof ExpressionError) {
+			const inner = error.path ? ` [${error.path}]` : "";
+			throw new ExpressionError(`${error.detail}${inner}`, path);
+		}
+		throw error;
+	}
+	if (Array.isArray(value)) return value.map((item, index) => resolveConfig(item, scope, `${path}[${index}]`));
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, resolveConfig(item, scope, `${path}.${key}`)]));
+	return value;
+}
 // ../engine/src/graph.ts
 const retrySchema = z.object({
 	max: z.number().int().min(1).max(10),
@@ -460,6 +515,15 @@ graphSchema.extend({
 	name: z.string().trim().min(1).max(120).optional(),
 	variables: z.array(z.string()).optional()
 });
+// ../engine/src/items.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** The items of a node run. A list is the items. One object is one item. Null is one empty item. */
+function toItems(input) {
+	if (Array.isArray(input)) return input.map((item) => isRecord(item) ? item : { value: item });
+	if (isRecord(input)) return [input];
+	if (input === null || input === void 0) return [{}];
+	return [{ value: input }];
+}
 z.object({
 	code: z.string().min(1).max(2e5),
 	/** Names the code can read, for example `$input` and `$vars`. Plain JSON values only. */
@@ -661,7 +725,7 @@ function fileIcon(from, path) {
 * Version of the node contract (the shape of `NodeDefinition` and what a node can use).
 * A minor version only adds. A major version can break a node package.
 */
-const SDK_VERSION = "1.0.0";
+const SDK_VERSION = "1.1.0";
 function parse(text) {
 	const match = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?$/.exec(text.trim());
 	if (!match) return null;
@@ -691,4 +755,4 @@ function satisfiesSdk(range, version = SDK_VERSION) {
 	const exact = parse(text);
 	return exact !== null && compare(actual, exact) === 0;
 }
-export { FORM_FIELD_TYPES, POLL_MAX_ITEMS, SDK_VERSION, defineNode, fileIcon, resolveTemplate, satisfiesSdk };
+export { FORM_FIELD_TYPES, POLL_MAX_ITEMS, SDK_VERSION, defineNode, fileIcon, isRecord, mimeTypeOf, readBinary, resolveConfig, resolveTemplate, satisfiesSdk, toBinary, toItems };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerodot/node-sdk",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Contract for zerodot node packages: node types, helpers and the SDK version.",
   "license": "AGPL-3.0-only",
   "repository": {