@xentom/integration-framework 0.0.0

package/dist/pins/index.d.ts

@@ -0,0 +1,97 @@
+import { type DataPin, type DataPinBuilder } from './data';
+import { type ExecPin, type ExecPinBuilder } from './exec';
+export * from './base';
+export * from './data';
+export * from './exec';
+export * from './utils';
+export type Pin = DataPin | ExecPin;
+export type PinRecord<P extends Pin = Pin> = Record<string, P>;
+export declare enum PinType {
+    /**
+     * Represents a data pin, used for inputs and outputs of an node.
+     */
+    Data = "data",
+    /**
+     * Represents an exec pin, used for executable outputs of an node.
+     * Only applicable within triggers and callable nodes.
+     */
+    Exec = "exec"
+}
+/**
+ * Utilities for defining pins used in nodes.
+ *
+ * Includes:
+ * - `data`: Defines a data pin, used for passing inputs and outputs.
+ * - `exec`: Defines an exec pin, used to control execution flow in triggers and callable nodes.
+ */
+export declare const pins: {
+    /**
+     * Creates a data pin, used for passing input or output values in an node.
+     * The pin can include a custom schema, control, and example values to guide users.
+     *
+     * @example
+     * Basic usage:
+     * ```ts
+     * i.pins.data()
+     * ```
+     *
+     * @example
+     * Customizing the pin with additional properties:
+     * ```ts
+     * i.pins.data({
+     *   displayName: 'Message',
+     *   description: 'A message to send',
+     *   control: i.controls.text({
+     *     placeholder: 'Hello, world!',
+     *   }),
+     * });
+     * ```
+     *
+     * @example
+     * Using inside a node:
+     * ```ts
+     * i.nodes.pure({
+     *   outputs: {
+     *     value: i.pins.data({
+     *       control: i.controls.text(),
+     *     }),
+     *   },
+     * });
+     */
+    data: DataPinBuilder;
+    /**
+     * Creates an exec pin, used to define an executable output from an node.
+     * Exec pins are only supported within triggers and callable nodes.
+     * They can optionally include scoped data outputs, separate from global node outputs.
+     *
+     * @example
+     * Basic usage:
+     * ```ts
+     * i.pins.exec()
+     * ```
+     *
+     * @example
+     * Customizing the exec pin with additional properties:
+     * ```ts
+     * i.pins.exec({
+     *  displayName: 'Process Item',
+     * });
+     * ```
+     *
+     * @example
+     * Using exec pin with scoped outputs:
+     * ```ts
+     * i.nodes.callable({
+     *   outputs: {
+     *     completed: i.pins.exec(),
+     *     iteration: i.pins.exec({
+     *       outputs: {
+     *         element: i.pins.data(),
+     *         index: i.pins.data(),
+     *       },
+     *     }),
+     *   },
+     * });
+     */
+    exec: ExecPinBuilder;
+};

package/dist/pins/index.js

@@ -0,0 +1,47 @@
+export * from './base';
+export * from './data';
+export * from './exec';
+export * from './utils';
+export var PinType;
+(function (PinType) {
+    /**
+     * Represents a data pin, used for inputs and outputs of an node.
+     */
+    PinType["Data"] = "data";
+    /**
+     * Represents an exec pin, used for executable outputs of an node.
+     * Only applicable within triggers and callable nodes.
+     */
+    PinType["Exec"] = "exec";
+})(PinType || (PinType = {}));
+/**
+ * Utilities for defining pins used in nodes.
+ *
+ * Includes:
+ * - `data`: Defines a data pin, used for passing inputs and outputs.
+ * - `exec`: Defines an exec pin, used to control execution flow in triggers and callable nodes.
+ */
+export const pins = {
+    data: (definition) => ({
+        ...definition,
+        type: PinType.Data,
+        // @ts-expect-error -- -
+        with(definition) {
+            return {
+                ...this,
+                ...definition,
+            };
+        },
+    }),
+    exec: (definition) => ({
+        ...definition,
+        type: PinType.Exec,
+        // @ts-expect-error -- -
+        with(definition) {
+            return {
+                ...this,
+                ...definition,
+            };
+        },
+    }),
+};

package/dist/pins/utils.d.ts

@@ -0,0 +1,25 @@
+import { type Pin, type PinRecord } from '.';
+import { type DataPin } from './data';
+import { type ExecPin } from './exec';
+export type InferPinRecordOutput<R extends PinRecord> = {
+    [K in keyof R as R[K] extends DataPin ? K : never]: InferPinOutput<R[K]>;
+} & {
+    [K in FlattenExecPinOutputs<R>]: GetExecPinOutputType<R, K>;
+};
+export type FlattenExecPinOutputs<R extends PinRecord> = {
+    [K in keyof R]: R[K] extends ExecPin<infer O> ? `${K & string}.${keyof O & string}` : never;
+}[keyof R];
+export type GetExecPinOutputType<R extends PinRecord, FlatKey extends string> = FlatKey extends `${infer ExecKey}.${infer OutputKey}` ? ExecKey extends keyof R ? R[ExecKey] extends ExecPin<infer O> ? OutputKey extends keyof O ? InferPinOutput<O[OutputKey]> : never : never : never : never;
+export type InferPinOutput<P extends Pin> = P extends DataPin<infer I, infer O> ? (0 extends 1 & O ? I : O) : never;
+export type InferPinRecordInput<R extends PinRecord> = {
+    [K in keyof R as R[K] extends DataPin ? undefined extends InferPinInput<R[K]> ? never : K : never]: InferPinInput<R[K]>;
+} & {
+    [K in keyof R as R[K] extends DataPin ? undefined extends InferPinInput<R[K]> ? K : never : never]?: InferPinInput<R[K]>;
+};
+export type InferPinInput<P extends Pin> = P extends DataPin<infer I, infer _> ? I : never;
+export type ExtractPinsOfType<R extends PinRecord, P extends Pin> = {
+    [K in keyof R as R[K] extends P ? K : never]: R[K] extends P ? R[K] : never;
+};
+export type PinRecordHasPinType<R extends PinRecord, P extends DataPin | ExecPin> = {
+    [K in keyof R]: R[K] extends P ? K : never;
+}[keyof R] extends never ? false : true;

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+export type HasRequiredKeys<T> = keyof T extends never ? false : {
+    [K in keyof T]-?: undefined extends T[K] ? false : true;
+}[keyof T] extends true ? true : false;
+export type ContainsFunction<T> = [Extract<T, Function>] extends [never] ? false : true;
+export type Serialize<T> = ContainsFunction<T> extends true ? SerializeFunction<T> : T extends object ? SerializeObject<T> : T;
+export type SerializeFunction<T> = ContainsFunction<T> extends true ? true | Exclude<T, Function> : T;
+export type SerializeObject<T extends object> = {
+    [K in keyof T]: Serialize<T[K]>;
+};
+export type ConditionalOptional<C extends boolean, V> = C extends true ? V | undefined : Exclude<V, undefined>;

package/dist/utils.js

@@ -0,0 +1 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */

package/dist/webhook.d.ts

@@ -0,0 +1,33 @@
+export interface Webhook {
+    /**
+     * The external URL that an external service can call to trigger the webhook handler.
+     */
+    url: string;
+    /**
+     * Registers a handler for incoming webhook requests to the URL.
+     * The handler is invoked when the external service sends an HTTP request.
+     * Returns an unsubscribe function to clean up the handler.
+     *
+     * @example
+     * ```ts
+     * subscribe(opts) {
+     *   const unsubscribe = opts.webhook.subscribe((req) => {
+     *     // Handle incoming webhook request
+     *     return new Response('OK');
+     *   });
+     *
+     *   return () => {
+     *     unsubscribe();
+     *   };
+     * },
+     * ```
+     */
+    subscribe: (handler: WebhookHandler) => () => void;
+}
+export type WebhookHandler = (request: Request) => Promise<void | Response> | (void | Response);
+export interface WebhookRequestData {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: ArrayBuffer;
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@xentom/integration-framework",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "format": "prettier --check . --ignore-path ../../.gitignore",
+    "typecheck": "tsc --noEmit",
+    "clean": "git clean -xdf .cache .turbo node_modules dist",
+    "build": "tsc"
+  },
+  "files": [
+    "dist",
+    "CLAUDE.md"
+  ],
+  "imports": {
+    "#src/*": "./src/*.ts"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0"
+  },
+  "devDependencies": {
+    "@xentom/style-guide": "0.0.0",
+    "eslint": "^9.31.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.8.3"
+  },
+  "prettier": "@xentom/style-guide/prettier"
+}