335 lines
13 KiB
Plaintext
335 lines
13 KiB
Plaintext
import type {
|
|
INodeType,
|
|
INodeTypeDescription,
|
|
IExecuteFunctions,
|
|
ILoadOptionsFunctions,
|
|
INodePropertyOptions,
|
|
} from "n8n-workflow";
|
|
import axios from "axios";
|
|
|
|
interface OpenAPISpec {
|
|
paths: Record<string, any>;
|
|
components?: Record<string, any>;
|
|
servers?: Array<{ url: string }>;
|
|
}
|
|
|
|
const openApiCache: Map<string, OpenAPISpec> = new Map();
|
|
|
|
async function loadOpenAPISpecCached(url: string): Promise<OpenAPISpec> {
|
|
if (openApiCache.has(url)) return openApiCache.get(url)!;
|
|
const res = await axios.get(url, { timeout: 20000 });
|
|
const spec: OpenAPISpec = res.data;
|
|
openApiCache.set(url, spec);
|
|
return spec;
|
|
}
|
|
|
|
function getDefaultValue(type: string | undefined, schema?: any): any {
|
|
if (schema?.example !== undefined) return schema.example;
|
|
if (schema?.default !== undefined) return schema.default;
|
|
switch (type) {
|
|
case "string": return "";
|
|
case "number":
|
|
case "integer": return 0;
|
|
case "boolean": return false;
|
|
case "array": return [];
|
|
case "object": return {};
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
function resolveRef(obj: any, spec: OpenAPISpec): any {
|
|
if (!obj || typeof obj !== "object") return obj;
|
|
if (obj.$ref && typeof obj.$ref === "string" && obj.$ref.startsWith("#/")) {
|
|
const refPath = obj.$ref.replace(/^#\//, "").split("/");
|
|
let cur: any = spec;
|
|
for (const seg of refPath) cur = cur?.[seg];
|
|
return cur || obj;
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
export class OpenApiNode implements INodeType {
|
|
description: INodeTypeDescription = {
|
|
displayName: "OpenApiNode - Dynamic OpenAPI",
|
|
name: "openApiNode",
|
|
icon: "file:icon.svg",
|
|
group: ["transform"],
|
|
version: 1,
|
|
subtitle: "={{$parameter['operation'] || 'select operation'}}",
|
|
description: "Dynamic UI n8n node generated from OpenAPI",
|
|
defaults: { name: "OpenApiNode" },
|
|
inputs: ["main"],
|
|
outputs: ["main"],
|
|
credentials: [
|
|
{ name: "openApiNodeApi", required: false },
|
|
],
|
|
properties: [
|
|
{
|
|
displayName: "OpenAPI JSON URL",
|
|
name: "openapiUrl",
|
|
type: "string",
|
|
default: "",
|
|
required: true,
|
|
},
|
|
{
|
|
displayName: "Operation",
|
|
name: "operation",
|
|
type: "options",
|
|
typeOptions: {
|
|
loadOptionsMethod: "loadOperations",
|
|
loadOptionsDependsOn: ["openapiUrl"],
|
|
},
|
|
default: "",
|
|
required: true,
|
|
},
|
|
{
|
|
displayName: "Parameters (Form)",
|
|
name: "parametersForm",
|
|
type: "fixedCollection",
|
|
placeholder: "Add Parameter",
|
|
typeOptions: { multipleValues: true },
|
|
default: {},
|
|
options: [
|
|
{
|
|
name: "parameter",
|
|
displayName: "Parameter",
|
|
values: [
|
|
{
|
|
displayName: "Name",
|
|
name: "name",
|
|
type: "options",
|
|
typeOptions: {
|
|
loadOptionsMethod: "loadParameterNames",
|
|
loadOptionsDependsOn: ["openapiUrl", "operation"],
|
|
},
|
|
default: "",
|
|
},
|
|
{
|
|
displayName: "In",
|
|
name: "in",
|
|
type: "options",
|
|
options: [
|
|
{ name: "query", value: "query" },
|
|
{ name: "path", value: "path" },
|
|
{ name: "header", value: "header" },
|
|
{ name: "body", value: "body" },
|
|
],
|
|
default: "query",
|
|
},
|
|
{
|
|
displayName: "Value",
|
|
name: "value",
|
|
type: "string",
|
|
default: "",
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
methods = {
|
|
loadOptions: {
|
|
async loadOperations(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
|
|
const url = (this.getNodeParameter("openapiUrl", "") as string).trim();
|
|
if (!url) return [{ name: "Provide openapiUrl first", value: "" }];
|
|
try {
|
|
const spec = await loadOpenAPISpecCached(url);
|
|
const ops: INodePropertyOptions[] = [];
|
|
|
|
for (const path of Object.keys(spec.paths || {})) {
|
|
const pathObj = spec.paths[path];
|
|
for (const method of Object.keys(pathObj || {})) {
|
|
const op = pathObj[method];
|
|
const opId =
|
|
op.operationId ||
|
|
`${method}_${path.replace(/[{}]/g, "").replace(/\//g, "_")}`;
|
|
const title = (op.summary || opId).toString();
|
|
ops.push({
|
|
name: `${title} — ${method.toUpperCase()} ${path}`,
|
|
value: opId,
|
|
});
|
|
}
|
|
}
|
|
return ops;
|
|
} catch (err: any) {
|
|
return [{ name: `Error: ${err.message}`, value: "" }];
|
|
}
|
|
},
|
|
|
|
async loadParameterNames(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
|
|
const url = (this.getNodeParameter("openapiUrl", "") as string).trim();
|
|
const opId = (this.getNodeParameter("operation", "") as string).trim();
|
|
if (!url || !opId) return [{ name: "Select operation first", value: "" }];
|
|
|
|
try {
|
|
const spec = await loadOpenAPISpecCached(url);
|
|
const out: INodePropertyOptions[] = [];
|
|
|
|
outer: for (const path of Object.keys(spec.paths || {})) {
|
|
const pathObj = spec.paths[path];
|
|
for (const method of Object.keys(pathObj || {})) {
|
|
const op = pathObj[method];
|
|
const id =
|
|
op.operationId ||
|
|
`${method}_${path.replace(/[{}]/g, "").replace(/\//g, "_")}`;
|
|
if (id !== opId) continue;
|
|
|
|
const params = [
|
|
...(pathObj.parameters || []),
|
|
...(op.parameters || []),
|
|
];
|
|
|
|
const seen = new Set<string>();
|
|
|
|
for (const p of params) {
|
|
if (!seen.has(p.name)) {
|
|
seen.add(p.name);
|
|
out.push({
|
|
name: `${p.name} (in=${p.in})`,
|
|
value: p.name,
|
|
});
|
|
}
|
|
}
|
|
|
|
const bodySchema =
|
|
op.requestBody?.content?.["application/json"]?.schema;
|
|
if (bodySchema) {
|
|
const resolved = resolveRef(bodySchema, spec);
|
|
const props = resolved.properties || {};
|
|
for (const propName of Object.keys(props)) {
|
|
if (!seen.has(propName)) {
|
|
seen.add(propName);
|
|
out.push({
|
|
name: `${propName} (body)`,
|
|
value: propName,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
break outer;
|
|
}
|
|
}
|
|
|
|
return out;
|
|
} catch (err: any) {
|
|
return [{ name: `Error: ${err.message}`, value: "" }];
|
|
}
|
|
},
|
|
},
|
|
};
|
|
|
|
async execute(this: IExecuteFunctions) {
|
|
const items = this.getInputData();
|
|
const returnData: any[] = [];
|
|
|
|
const creds = (await this.getCredentials?.("openApiNodeApi")) as
|
|
| { baseUrl?: string; token?: string; apiKey?: string }
|
|
| undefined;
|
|
|
|
for (let i = 0; i < items.length; i++) {
|
|
try {
|
|
const openapiUrl = this.getNodeParameter("openapiUrl", i, "") as string;
|
|
const operationId = this.getNodeParameter("operation", i, "") as string;
|
|
const spec = await loadOpenAPISpecCached(openapiUrl);
|
|
|
|
let foundOp: any = null;
|
|
let foundPath = "";
|
|
let foundMethod = "";
|
|
|
|
outer: for (const path of Object.keys(spec.paths || {})) {
|
|
const pathObj = spec.paths[path];
|
|
for (const method of Object.keys(pathObj || {})) {
|
|
const op = pathObj[method];
|
|
const id =
|
|
op.operationId ||
|
|
`${method}_${path.replace(/[{}]/g, "").replace(/\//g, "_")}`;
|
|
if (id === operationId) {
|
|
foundOp = op;
|
|
foundPath = path;
|
|
foundMethod = method.toLowerCase();
|
|
break outer;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!foundOp) throw new Error("Operation not found");
|
|
|
|
const paramsForm = this.getNodeParameter("parametersForm", i, {}) as any;
|
|
let queryParams: Record<string, any> = {};
|
|
let bodyParams: Record<string, any> = {};
|
|
|
|
const pathParams = [
|
|
...(spec.paths[foundPath].parameters || []),
|
|
...(foundOp.parameters || []),
|
|
];
|
|
|
|
if (paramsForm && Array.isArray(paramsForm.parameter)) {
|
|
for (const p of paramsForm.parameter) {
|
|
if (p.in === "query") queryParams[p.name] = p.value;
|
|
else if (p.in === "body") bodyParams[p.name] = p.value;
|
|
else if (p.in === "header") queryParams[p.name] = p.value;
|
|
}
|
|
}
|
|
|
|
let baseUrl =
|
|
creds?.baseUrl ||
|
|
spec.servers?.[0]?.url ||
|
|
"";
|
|
baseUrl = baseUrl.replace(/\/+$/, "");
|
|
|
|
let url = baseUrl + foundPath;
|
|
|
|
for (const p of pathParams) {
|
|
if (p.in === "path") {
|
|
const item = paramsForm.parameter.find((x: any) => x.name === p.name);
|
|
const val = item?.value;
|
|
if (!val) throw new Error(`Missing path param ${p.name}`);
|
|
url = url.replace(`{${p.name}}`, encodeURIComponent(val));
|
|
}
|
|
}
|
|
|
|
const headers: Record<string, any> = {
|
|
"Content-Type": "application/json",
|
|
};
|
|
|
|
if (creds?.token) headers["Authorization"] = `Bearer ${creds.token}`;
|
|
if (creds?.apiKey) headers["X-API-Key"] = creds.apiKey;
|
|
|
|
const axiosConfig: any = {
|
|
method: foundMethod,
|
|
url,
|
|
headers,
|
|
params: queryParams,
|
|
timeout: 30000,
|
|
};
|
|
|
|
// === FIX: GET & HEAD tidak boleh punya body ===
|
|
if (!(foundMethod === "get" || foundMethod === "head")) {
|
|
axiosConfig.data = Object.keys(bodyParams).length ? bodyParams : undefined;
|
|
}
|
|
|
|
const resp = await axios(axiosConfig);
|
|
returnData.push({ json: resp.data });
|
|
|
|
} catch (err: any) {
|
|
if (this.continueOnFail && this.continueOnFail()) {
|
|
returnData.push({
|
|
json: {
|
|
error: true,
|
|
message: err.message,
|
|
response: err.response?.data,
|
|
},
|
|
});
|
|
continue;
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
return [returnData];
|
|
}
|
|
}
|