@atomoz/workflows-nodes 0.1.13 → 0.1.15

package/src/nodes/inputs/http/post/function.js

@@ -1,36 +0,0 @@
-// "use server";
-export const HttpPostInputNodeFunction = (params) => {
-    const { request, fieldValues } = params;
-    const { queryParams: configQueryParams, headers: configHeaders, body: configBody } = fieldValues || {};
-    if (request.method !== 'POST') {
-        throw new Error('Método HTTP inválido');
-    }
-    const actualData = {
-        queryParams: request?.query || {},
-        headers: request?.headers || {},
-        body: request?.body || {},
-        ip: request?.ip || '127.0.0.1',
-    };
-    if (configQueryParams) {
-        const requiredParams = configQueryParams.filter((p) => p.required);
-        const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
-        if (missingParams.length > 0) {
-            throw new Error(`Parâmetros obrigatórios ausentes: ${missingParams.map((p) => p.key).join(', ')}`);
-        }
-    }
-    if (configHeaders) {
-        const requiredHeaders = configHeaders.filter((h) => h.required);
-        const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
-        if (missingHeaders.length > 0) {
-            throw new Error(`Headers obrigatórios ausentes: ${missingHeaders.map((h) => h.key).join(', ')}`);
-        }
-    }
-    if (configBody) {
-        const requiredBodyFields = configBody.filter((f) => f.required);
-        const missingBodyFields = requiredBodyFields.filter((f) => !actualData.body[f.key]);
-        if (missingBodyFields.length > 0) {
-            throw new Error(`Campos obrigatórios do body ausentes: ${missingBodyFields.map((f) => f.key).join(', ')}`);
-        }
-    }
-    return actualData;
-};

package/src/nodes/inputs/http/post/index.d.ts

@@ -1,4 +0,0 @@
-export * from './data';
-export * from './function';
-export * from './schema';
-//# sourceMappingURL=index.d.ts.map

package/src/nodes/inputs/http/post/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/post/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC"}

package/src/nodes/inputs/http/post/index.js

@@ -1,3 +0,0 @@
-export * from './data';
-export * from './function';
-export * from './schema';

package/src/nodes/inputs/http/post/schema.d.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-export declare const HttpPostInputNodeSchema: z.ZodObject<{
-    route: z.ZodString;
-    queryParams: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    body: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodAny>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type HttpPostInputNodeType = z.infer<typeof HttpPostInputNodeSchema>;
-//# sourceMappingURL=schema.d.ts.map

package/src/nodes/inputs/http/post/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/post/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAKlC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/src/nodes/inputs/http/post/schema.js

@@ -1,8 +0,0 @@
-import { z } from "zod";
-import { RouteSchema, QueryParamSchema, HeaderSchema, BodyFieldSchema } from "../schemas";
-export const HttpPostInputNodeSchema = z.object({
-    route: RouteSchema,
-    queryParams: z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-    headers: z.array(HeaderSchema).optional().describe("Headers configuration"),
-    body: z.array(BodyFieldSchema).optional().describe("Body fields configuration"),
-});

package/src/nodes/inputs/http/put/data.d.ts

@@ -1,3 +0,0 @@
-import { NodeData } from "../../../types/base-node";
-export declare const HttpPutInputNode: NodeData;
-//# sourceMappingURL=data.d.ts.map

package/src/nodes/inputs/http/put/data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/put/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,eAAO,MAAM,gBAAgB,EAAE,QAqE9B,CAAC"}

package/src/nodes/inputs/http/put/data.js

@@ -1,70 +0,0 @@
-export const HttpPutInputNode = {
-    label: 'Http PUT Input',
-    type: 'HttpPutInput',
-    category: 'input',
-    icon: '📝',
-    description: 'Node que representa uma rota PUT HTTP para atualização completa de recursos',
-    tags: {
-        execution: 'sync',
-        group: 'HTTP'
-    },
-    fields: [
-        {
-            id: 'route',
-            label: 'Route',
-            type: 'route',
-            required: true,
-            placeholder: '/produtos/{id}',
-        },
-        {
-            id: 'queryParams',
-            label: 'Query Params',
-            type: 'keyValue',
-            required: false,
-            handle: {
-                type: 'output',
-                label: 'Query Params',
-                name: 'queryParams',
-                fieldType: 'keyValue',
-            }
-        },
-        {
-            id: 'headers',
-            label: 'Headers',
-            type: 'keyValue',
-            required: false,
-            handle: {
-                type: 'output',
-                label: 'Headers',
-                name: 'headers',
-                fieldType: 'keyValue',
-            }
-        },
-        {
-            id: 'body',
-            label: 'Body',
-            type: 'object',
-            required: false,
-            handle: {
-                type: 'output',
-                label: 'Body',
-                name: 'body',
-                fieldType: 'object',
-                required: false
-            }
-        },
-        {
-            id: 'ip',
-            label: 'Request IP',
-            type: 'string',
-            required: false,
-            typeable: false,
-            handle: {
-                type: 'output',
-                label: 'IP',
-                name: 'ip',
-                fieldType: 'string',
-            }
-        }
-    ]
-};

package/src/nodes/inputs/http/put/function.d.ts

@@ -1,2 +0,0 @@
-export declare const HttpPutInputNodeFunction: (params: any) => any;
-//# sourceMappingURL=function.d.ts.map

package/src/nodes/inputs/http/put/function.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/put/function.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,GAAI,QAAQ,GAAG,KAAG,GAwCtD,CAAC"}

package/src/nodes/inputs/http/put/function.js

@@ -1,36 +0,0 @@
-// "use server";
-export const HttpPutInputNodeFunction = (params) => {
-    const { request, fieldValues } = params;
-    const { queryParams: configQueryParams, headers: configHeaders, body: configBody } = fieldValues || {};
-    if (request.method !== 'PUT') {
-        throw new Error('Método HTTP inválido');
-    }
-    const actualData = {
-        queryParams: request?.query || {},
-        headers: request?.headers || {},
-        body: request?.body || {},
-        ip: request?.ip || '127.0.0.1',
-    };
-    if (configQueryParams) {
-        const requiredParams = configQueryParams.filter((p) => p.required);
-        const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
-        if (missingParams.length > 0) {
-            throw new Error(`Parâmetros obrigatórios ausentes: ${missingParams.map((p) => p.key).join(', ')}`);
-        }
-    }
-    if (configHeaders) {
-        const requiredHeaders = configHeaders.filter((h) => h.required);
-        const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
-        if (missingHeaders.length > 0) {
-            throw new Error(`Headers obrigatórios ausentes: ${missingHeaders.map((h) => h.key).join(', ')}`);
-        }
-    }
-    if (configBody) {
-        const requiredBodyFields = configBody.filter((f) => f.required);
-        const missingBodyFields = requiredBodyFields.filter((f) => !actualData.body[f.key]);
-        if (missingBodyFields.length > 0) {
-            throw new Error(`Campos obrigatórios do body ausentes: ${missingBodyFields.map((f) => f.key).join(', ')}`);
-        }
-    }
-    return actualData;
-};

package/src/nodes/inputs/http/put/index.d.ts

@@ -1,4 +0,0 @@
-export * from './data';
-export * from './function';
-export * from './schema';
-//# sourceMappingURL=index.d.ts.map

package/src/nodes/inputs/http/put/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/put/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC"}

package/src/nodes/inputs/http/put/index.js

@@ -1,3 +0,0 @@
-export * from './data';
-export * from './function';
-export * from './schema';

package/src/nodes/inputs/http/put/schema.d.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-export declare const HttpPutInputNodeSchema: z.ZodObject<{
-    route: z.ZodString;
-    queryParams: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    body: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodAny>;
-        required: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type HttpPutInputNodeType = z.infer<typeof HttpPutInputNodeSchema>;
-//# sourceMappingURL=schema.d.ts.map

package/src/nodes/inputs/http/put/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/put/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;iBAKjC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/src/nodes/inputs/http/put/schema.js

@@ -1,8 +0,0 @@
-import { z } from "zod";
-import { RouteSchema, QueryParamSchema, HeaderSchema, BodyFieldSchema } from "../schemas";
-export const HttpPutInputNodeSchema = z.object({
-    route: RouteSchema,
-    queryParams: z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-    headers: z.array(HeaderSchema).optional().describe("Headers configuration"),
-    body: z.array(BodyFieldSchema).optional().describe("Body fields configuration"),
-});

package/src/nodes/inputs/http/schemas.d.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-export declare const QueryParamSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const HeaderSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const BodyFieldSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodOptional<z.ZodAny>;
-    required: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const RouteSchema: z.ZodString;
-//# sourceMappingURL=schemas.d.ts.map

package/src/nodes/inputs/http/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/inputs/http/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;iBAI3B,CAAC;AAEH,eAAO,MAAM,YAAY;;;;iBAIvB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;iBAI1B,CAAC;AAEH,eAAO,MAAM,WAAW,aAAyC,CAAC"}

package/src/nodes/inputs/http/schemas.js

@@ -1,17 +0,0 @@
-import { z } from "zod";
-export const QueryParamSchema = z.object({
-    key: z.string(),
-    value: z.string().optional(),
-    required: z.boolean().optional()
-});
-export const HeaderSchema = z.object({
-    key: z.string(),
-    value: z.string().optional(),
-    required: z.boolean().optional()
-});
-export const BodyFieldSchema = z.object({
-    key: z.string(),
-    value: z.any().optional(),
-    required: z.boolean().optional()
-});
-export const RouteSchema = z.string().describe("HTTP route path");

package/src/nodes/inputs/http/utils.d.ts

@@ -1,21 +0,0 @@
-export declare const HTTP_NODE_TYPES: {
-    readonly GET: "HttpGetInput";
-    readonly POST: "HttpPostInput";
-    readonly PUT: "HttpPutInput";
-    readonly DELETE: "HttpDeleteInput";
-    readonly PATCH: "HttpPatchInput";
-};
-export declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH"];
-export type HttpMethod = typeof HTTP_METHODS[number];
-export type HttpNodeType = typeof HTTP_NODE_TYPES[keyof typeof HTTP_NODE_TYPES];
-export declare const getHttpNodesTypes: () => string[];
-export declare const getHttpNodeTypesArray: () => HttpNodeType[];
-export declare const isHttpInputNode: (nodeType: string) => boolean;
-export declare const isHttpMethodNode: (nodeType: string, method: HttpMethod) => boolean;
-export declare const extractHttpMethodFromNodeType: (nodeType: string) => HttpMethod;
-export declare const getHttpMethodFromNodeType: (nodeType: string) => HttpMethod;
-export declare const isAnyHttpInputNode: (nodeType: string) => boolean;
-export declare const getHttpNodeTypeStrings: () => string[];
-export declare const isHttpInputFriendlyId: (friendlyId: string) => boolean;
-export declare const getHttpMethodFromFriendlyId: (friendlyId: string) => HttpMethod;
-//# sourceMappingURL=utils.d.ts.map

package/src/nodes/inputs/http/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/inputs/http/utils.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAEX,eAAO,MAAM,YAAY,oDAAqD,CAAC;AAE/E,MAAM,MAAM,UAAU,GAAG,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,YAAY,GAAG,OAAO,eAAe,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAGhF,eAAO,MAAM,iBAAiB,QAAO,MAAM,EAQ1C,CAAC;AAGF,eAAO,MAAM,qBAAqB,QAAO,YAAY,EAEpD,CAAC;AAGF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,OAElD,CAAC;AAGF,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,EAAE,QAAQ,UAAU,KAAG,OAEvE,CAAC;AAGF,eAAO,MAAM,6BAA6B,GAAI,UAAU,MAAM,KAAG,UAOhE,CAAC;AAGF,eAAO,MAAM,yBAAyB,aAVkB,MAAM,KAAG,UAUK,CAAC;AAGvE,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OAErD,CAAC;AAGF,eAAO,MAAM,sBAAsB,QAAO,MAAM,EAE/C,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAAI,YAAY,MAAM,KAAG,OAE1D,CAAC;AAGF,eAAO,MAAM,2BAA2B,GAAI,YAAY,MAAM,KAAG,UAEhE,CAAC"}

package/src/nodes/inputs/http/utils.js

@@ -1,63 +0,0 @@
-import { HttpGetInputNode } from "./get/data";
-import { HttpPatchInputNode } from "./patch/data";
-import { HttpDeleteInputNode } from './delete/data';
-import { HttpPostInputNode } from './post/data';
-import { HttpPutInputNode } from './put/data';
-// HTTP Node Types
-export const HTTP_NODE_TYPES = {
-    GET: 'HttpGetInput',
-    POST: 'HttpPostInput',
-    PUT: 'HttpPutInput',
-    DELETE: 'HttpDeleteInput',
-    PATCH: 'HttpPatchInput',
-};
-export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
-// Get all HTTP node types
-export const getHttpNodesTypes = () => {
-    return [
-        HttpGetInputNode,
-        HttpPostInputNode,
-        HttpPutInputNode,
-        HttpDeleteInputNode,
-        HttpPatchInputNode,
-    ].map(node => node.type);
-};
-// Get HTTP node types as array
-export const getHttpNodeTypesArray = () => {
-    return Object.values(HTTP_NODE_TYPES);
-};
-// Check if a node type is an HTTP input node
-export const isHttpInputNode = (nodeType) => {
-    return getHttpNodeTypesArray().some(httpType => nodeType.includes(httpType));
-};
-// Check if a node type is a specific HTTP method
-export const isHttpMethodNode = (nodeType, method) => {
-    return nodeType.includes(HTTP_NODE_TYPES[method]);
-};
-// Extract HTTP method from node type
-export const extractHttpMethodFromNodeType = (nodeType) => {
-    for (const [method, nodeTypeValue] of Object.entries(HTTP_NODE_TYPES)) {
-        if (nodeType.includes(nodeTypeValue)) {
-            return method;
-        }
-    }
-    return 'GET'; // Default fallback
-};
-// Get HTTP method from node type (alias for consistency)
-export const getHttpMethodFromNodeType = extractHttpMethodFromNodeType;
-// Check if a node type is any HTTP input node
-export const isAnyHttpInputNode = (nodeType) => {
-    return nodeType.includes('Http') && nodeType.includes('Input');
-};
-// Get all HTTP node type strings for filtering
-export const getHttpNodeTypeStrings = () => {
-    return Object.values(HTTP_NODE_TYPES);
-};
-// Check if a friendlyId is an HTTP input
-export const isHttpInputFriendlyId = (friendlyId) => {
-    return friendlyId.includes('Http') && friendlyId.includes('Input');
-};
-// Get HTTP method from friendlyId
-export const getHttpMethodFromFriendlyId = (friendlyId) => {
-    return extractHttpMethodFromNodeType(friendlyId);
-};

package/src/nodes/inputs/index.d.ts

@@ -1,5 +0,0 @@
-export * from './http/get';
-export * from './http/post';
-export * from './chat/chat';
-export * from './manual/trigger';
-//# sourceMappingURL=index.d.ts.map

package/src/nodes/inputs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../libs/nodes/src/nodes/inputs/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC"}

package/src/nodes/inputs/index.js

@@ -1,4 +0,0 @@
-export * from './http/get';
-export * from './http/post';
-export * from './chat/chat';
-export * from './manual/trigger';

package/src/nodes/inputs/manual/trigger.d.ts

@@ -1,4 +0,0 @@
-import { NodeData } from "../../types/base-node";
-export declare const ManualTriggerNodeFunction: (params: any) => any;
-export declare const ManualTriggerNode: NodeData;
-//# sourceMappingURL=trigger.d.ts.map

package/src/nodes/inputs/manual/trigger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/inputs/manual/trigger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,yBAAyB,GAAI,QAAQ,GAAG,KAAG,GAIvD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,QAgC/B,CAAC"}

package/src/nodes/inputs/manual/trigger.js

@@ -1,39 +0,0 @@
-// Função do node ManualTrigger: apenas retorna os valores configurados
-export const ManualTriggerNodeFunction = (params) => {
-    const { fieldValues } = params || {};
-    // Normaliza: para keyValue manter array; para simples retornar literal
-    return fieldValues || {};
-};
-export const ManualTriggerNode = {
-    label: 'Manual Trigger',
-    type: 'ManualTrigger',
-    category: 'input',
-    icon: '🖐️',
-    description: 'Dispara fluxo manualmente e envia campos dinâmicos',
-    tags: {
-        execution: 'sync',
-        group: 'Custom'
-    },
-    fields: [
-        {
-            id: 'stringExample',
-            label: 'String Example',
-            type: 'string',
-            handle: { type: 'output', label: 'String', name: 'stringExample', fieldType: 'string' },
-            placeholder: 'Ex.: valor literal',
-        },
-        {
-            id: 'numberExample',
-            label: 'Number Example',
-            type: 'number',
-            handle: { type: 'output', label: 'Number', name: 'numberExample', fieldType: 'number' },
-            placeholder: 'Ex.: 123',
-        },
-        {
-            id: 'keyValue1',
-            label: 'Key/Value 1',
-            type: 'keyValue',
-            handle: { type: 'output', label: 'Key/Value', name: 'keyValue1', fieldType: 'keyValue' },
-        }
-    ]
-};

package/src/nodes/output-node/index.d.ts

@@ -1,4 +0,0 @@
-import { NodeData } from "../types/base-node";
-export declare const HttpOutputNodeFunction: (params: any) => any;
-export declare const OutputNode: NodeData;
-//# sourceMappingURL=index.d.ts.map

package/src/nodes/output-node/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../libs/nodes/src/nodes/output-node/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C,eAAO,MAAM,sBAAsB,GAAI,QAAQ,GAAG,KAAG,GAwClD,CAAC;AAwBJ,eAAO,MAAM,UAAU,EAAE,QAiExB,CAAC"}

package/src/nodes/output-node/index.js

@@ -1,123 +0,0 @@
-export const HttpOutputNodeFunction = (params) => {
-    const { fieldValues, results } = params;
-    // Usar fieldValues.data como dados de resposta (contém os placeholders configurados)
-    let responseData = fieldValues?.data || {};
-    // Se responseData é um objeto com placeholders, processar
-    if (typeof responseData === 'object' && responseData !== null) {
-        // Processar placeholders usando os inputs resolvidos
-        const processedData = {};
-        for (const [key, value] of Object.entries(responseData)) {
-            if (typeof value === 'string' && value.includes('{{')) {
-                // Processar placeholders usando os results
-                processedData[key] = processPlaceholders(value, results);
-            }
-            else {
-                processedData[key] = value;
-            }
-        }
-        responseData = processedData;
-    }
-    else if (typeof responseData === 'string') {
-        // Se é uma string simples, criar um objeto com a string
-        responseData = { value: responseData };
-    }
-    // Configurações padrão
-    const status = fieldValues?.status || 200;
-    const headers = fieldValues?.headers || {};
-    // Validações
-    if (status && (status < 100 || status > 599)) {
-        throw new Error(`Status HTTP inválido: ${status}`);
-    }
-    return {
-        status,
-        headers,
-        data: responseData,
-        isHttpResponse: true
-    };
-};
-function processPlaceholders(value, results) {
-    // Substituir placeholders por valores dos results
-    return value.replace(/\{\{(.*?)\}\}/g, (match, placeholder) => {
-        // Extrair friendlyId e campo do placeholder
-        const parts = placeholder.split('-');
-        const friendlyId = parts[0];
-        const fieldName = parts[1];
-        const keyName = parts.length > 2 ? parts[2] : undefined;
-        const sourceResult = results[friendlyId];
-        if (sourceResult) {
-            if (keyName) {
-                return sourceResult[fieldName]?.[keyName] || keyName;
-            }
-            else {
-                return sourceResult[fieldName] || '';
-            }
-        }
-        return match; // Manter placeholder se não encontrar
-    });
-}
-export const OutputNode = {
-    label: 'Http Output Node',
-    type: 'HttpOutput',
-    category: 'output',
-    icon: '📤',
-    description: 'Node de saída do workflow que aceita qualquer entrada e retorna ela diretamente',
-    group: 'HTTP',
-    tags: {
-        execution: 'sync',
-        group: 'HTTP'
-    },
-    fields: [
-        {
-            id: 'status',
-            label: 'Status Code',
-            type: 'select',
-            required: true,
-            defaultValue: 200,
-            options: [
-                { label: '200 - OK', value: 200 },
-                { label: '201 - Created', value: 201 },
-                { label: '204 - No Content', value: 204 },
-                { label: '400 - Bad Request', value: 400 },
-                { label: '401 - Unauthorized', value: 401 },
-                { label: '403 - Forbidden', value: 403 },
-                { label: '404 - Not Found', value: 404 },
-                { label: '422 - Unprocessable Entity', value: 422 },
-                { label: '500 - Internal Server Error', value: 500 }
-            ],
-            handle: {
-                type: 'output',
-                label: 'Status',
-                name: 'status',
-                fieldType: 'number',
-                required: true
-            }
-        },
-        {
-            id: 'headers',
-            label: 'Response Headers',
-            type: 'keyValue',
-            required: false,
-            defaultValue: {},
-            handle: {
-                type: 'output',
-                label: 'Headers',
-                name: 'headers',
-                fieldType: 'object',
-                required: false
-            }
-        },
-        {
-            id: 'data',
-            label: 'Response Data',
-            type: 'json',
-            required: true,
-            handle: {
-                type: 'input',
-                label: 'Data',
-                name: 'data',
-                fieldType: 'json',
-                required: true
-            }
-        }
-    ]
-};

package/src/nodes/outputs/chat/output.d.ts

@@ -1,4 +0,0 @@
-import { NodeData } from "../../types/base-node";
-export declare const ChatOutputNodeFunction: (params: any) => Promise<any>;
-export declare const ChatOutputNode: NodeData;
-//# sourceMappingURL=output.d.ts.map

package/src/nodes/outputs/chat/output.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/outputs/chat/output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,sBAAsB,GAAU,QAAQ,GAAG,KAAG,OAAO,CAAC,GAAG,CAiBrE,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,QAyB5B,CAAC"}