n8n-nodes-pronote 0.2.0 → 0.2.2

package/dist/nodes/Pronote/PronoteTool.node.d.ts

@@ -1,5 +1,5 @@
-import { type INodeType, type INodeTypeDescription, type ISupplyDataFunctions, type SupplyData } from "n8n-workflow";
+import { type INodeType, type INodeTypeDescription, type IExecuteFunctions, type INodeExecutionData } from "n8n-workflow";
 export declare class PronoteTool implements INodeType {
     description: INodeTypeDescription;
-    supplyData(this: ISupplyDataFunctions): Promise<SupplyData>;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

package/dist/nodes/Pronote/PronoteTool.node.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PronoteTool = void 0;
-const tools_1 = require("@langchain/core/tools");
-const zod_1 = require("zod");
 const n8n_workflow_1 = require("n8n-workflow");
 const pawnoteClient_1 = require("../../shared/pawnoteClient");
 const GenericFunctions_1 = require("./GenericFunctions");
@@ -15,14 +13,14 @@ class PronoteTool {
             group: ["transform"],
             version: 1,
             description: "Expose PRONOTE timetable, tasks, and grades to AI Agents",
-            subtitle: "={{ \"Tool\" }}",
+            subtitle: "={{ $parameter[\"action\"] || \"PRONOTE\" }}",
             defaults: {
                 name: "PRONOTE Tool",
             },
             usableAsTool: true,
-            inputs: [],
-            outputs: [n8n_workflow_1.NodeConnectionTypes.AiTool],
-            outputNames: ["Tool"],
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputNames: ["Result"],
             credentials: [
                 {
                     name: "pronoteApi",
@@ -31,97 +29,138 @@ class PronoteTool {
             ],
             properties: [
                 {
-                    displayName: "Tool Description",
-                    name: "toolDescription",
-                    type: "hidden",
-                    default: "Use this tool to read timetable, homework/tasks, or grade information from PRONOTE. Provide an action (timetable, tasks, grades, gradePeriods) and an optional referenceDate (ISO string).",
+                    displayName: "Action",
+                    name: "action",
+                    type: "options",
+                    default: "timetable",
+                    options: [
+                        { name: "Timetable", value: "timetable" },
+                        { name: "Tasks", value: "tasks" },
+                        { name: "Grades", value: "grades" },
+                        { name: "Grade Periods", value: "gradePeriods" },
+                    ],
+                    description: "What to retrieve from PRONOTE",
+                },
+                {
+                    displayName: "Reference Date",
+                    name: "referenceDate",
+                    type: "string",
+                    default: "",
+                    placeholder: "2024-09-01",
+                    description: "ISO date used to pick the PRONOTE week for timetable/tasks. Defaults to today.",
+                    displayOptions: {
+                        show: {
+                            action: ["timetable", "tasks"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Only Pending Tasks",
+                    name: "onlyPendingTasks",
+                    type: "boolean",
+                    default: false,
+                    description: "Filter out tasks already marked done",
+                    displayOptions: {
+                        show: {
+                            action: ["tasks"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Period Name or ID",
+                    name: "periodName",
+                    type: "string",
+                    default: "",
+                    description: "Grade period to fetch (name or ID). Leave empty to use the first available period.",
+                    displayOptions: {
+                        show: {
+                            action: ["grades"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Include Individual Grades",
+                    name: "includeGrades",
+                    type: "boolean",
+                    default: true,
+                    description: "If false, only averages and subjects are returned",
+                    displayOptions: {
+                        show: {
+                            action: ["grades"],
+                        },
+                    },
                 },
             ],
         };
     }
-    async supplyData() {
-        try {
-            const { session } = await (0, GenericFunctions_1.getPronoteAuth)(this);
-            const tool = new tools_1.DynamicStructuredTool({
-                name: "pronote",
-                description: "Fetch timetable, homework/tasks, or grade information from PRONOTE. " +
-                    "Actions: timetable, tasks, grades, gradePeriods. " +
-                    "Use referenceDate (ISO date) to target a week for timetable/tasks. " +
-                    "When action=grades, provide periodName (ID or label).",
-                schema: zod_1.z.object({
-                    action: zod_1.z
-                        .enum(["timetable", "tasks", "grades", "gradePeriods"])
-                        .describe("What to retrieve from PRONOTE."),
-                    referenceDate: zod_1.z
-                        .string()
-                        .optional()
-                        .describe("ISO date (e.g. 2024-09-01). Used for timetable and tasks to select the week; defaults to today."),
-                    periodName: zod_1.z
-                        .string()
-                        .optional()
-                        .describe("Grade period name or ID. Used when action=grades."),
-                    onlyPendingTasks: zod_1.z
-                        .boolean()
-                        .optional()
-                        .describe("When action=tasks, if true only return undone tasks."),
-                    includeGrades: zod_1.z
-                        .boolean()
-                        .optional()
-                        .describe("When action=grades, if false only averages are returned."),
-                }),
-                func: async (input) => {
-                    const safeStringify = (data) => JSON.stringify(data, null, 2);
-                    switch (input.action) {
-                        case "timetable": {
-                            const referenceDate = (0, GenericFunctions_1.resolveReferenceDate)(input.referenceDate);
-                            const timetable = await (0, pawnoteClient_1.fetchTimetable)(session, referenceDate);
-                            return safeStringify(timetable);
-                        }
-                        case "tasks": {
-                            const referenceDate = (0, GenericFunctions_1.resolveReferenceDate)(input.referenceDate);
-                            const assignments = await (0, pawnoteClient_1.fetchAssignments)(session, referenceDate);
-                            const filtered = input.onlyPendingTasks
-                                ? assignments.filter((a) => !a.isDone)
-                                : assignments;
-                            return safeStringify(filtered);
-                        }
-                        case "gradePeriods": {
-                            const periods = await (0, pawnoteClient_1.fetchGradePeriods)(session);
-                            return safeStringify(periods);
-                        }
-                        case "grades": {
-                            const includeGrades = input.includeGrades !== false;
-                            const overview = await (0, pawnoteClient_1.fetchGrades)(session, input.periodName);
-                            if (!includeGrades) {
-                                return safeStringify({
-                                    period: overview.period,
-                                    studentOverall: overview.studentOverall,
-                                    classAverage: overview.classAverage,
-                                    subjects: overview.subjects.map((subject) => ({
-                                        id: subject.id,
-                                        name: subject.name,
-                                        studentAverage: subject.studentAverage,
-                                        classAverage: subject.classAverage,
-                                        maximum: subject.maximum,
-                                        minimum: subject.minimum,
-                                        outOf: subject.outOf,
-                                    })),
-                                });
-                            }
-                            return safeStringify(overview);
-                        }
-                        default:
-                            throw new Error(`Unsupported action: ${input["action"]}`);
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const auth = await (0, GenericFunctions_1.getPronoteAuth)(this);
+        const action = this.getNodeParameter("action", 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (action === "timetable") {
+                    const referenceDate = (0, GenericFunctions_1.resolveReferenceDate)(this.getNodeParameter("referenceDate", i));
+                    const timetable = await (0, pawnoteClient_1.fetchTimetable)(auth.session, referenceDate);
+                    for (const day of timetable) {
+                        returnData.push({ json: day, pairedItem: { item: i } });
                     }
-                },
-            });
-            return {
-                response: tool,
-            };
-        }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message);
+                    continue;
+                }
+                if (action === "tasks") {
+                    const referenceDate = (0, GenericFunctions_1.resolveReferenceDate)(this.getNodeParameter("referenceDate", i));
+                    const onlyPending = this.getNodeParameter("onlyPendingTasks", i);
+                    const assignments = await (0, pawnoteClient_1.fetchAssignments)(auth.session, referenceDate);
+                    for (const assignment of assignments) {
+                        if (onlyPending && assignment.isDone)
+                            continue;
+                        returnData.push({ json: assignment, pairedItem: { item: i } });
+                    }
+                    continue;
+                }
+                if (action === "gradePeriods") {
+                    const periods = await (0, pawnoteClient_1.fetchGradePeriods)(auth.session);
+                    for (const period of periods) {
+                        returnData.push({ json: period, pairedItem: { item: i } });
+                    }
+                    continue;
+                }
+                if (action === "grades") {
+                    const periodName = this.getNodeParameter("periodName", i).trim() || undefined;
+                    const includeGrades = this.getNodeParameter("includeGrades", i);
+                    const overview = await (0, pawnoteClient_1.fetchGrades)(auth.session, periodName);
+                    if (!includeGrades) {
+                        returnData.push({
+                            json: {
+                                period: overview.period,
+                                studentOverall: overview.studentOverall,
+                                classAverage: overview.classAverage,
+                                subjects: overview.subjects.map((subject) => ({
+                                    id: subject.id,
+                                    name: subject.name,
+                                    studentAverage: subject.studentAverage,
+                                    classAverage: subject.classAverage,
+                                    maximum: subject.maximum,
+                                    minimum: subject.minimum,
+                                    outOf: subject.outOf,
+                                })),
+                            },
+                            pairedItem: { item: i },
+                        });
+                    }
+                    else {
+                        returnData.push({ json: overview, pairedItem: { item: i } });
+                    }
+                    continue;
+                }
+                throw new Error(`Unsupported action ${action}`);
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, { itemIndex: i });
+            }
         }
+        return [returnData];
     }
 }
 exports.PronoteTool = PronoteTool;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "n8n-nodes-pronote",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "n8n custom nodes and agent utilities to talk to PRONOTE via the Pawnote library.",
   "license": "MIT",
   "main": "dist/nodes/Pronote/Pronote.node.js",
   "types": "dist/nodes/Pronote/Pronote.node.d.ts",
+  "keywords": ["n8n-community-node-package", "n8n", "n8n-nodes", "pronote", "pawnote", "langchain"],
   "scripts": {
     "build": "tsc -p .",
     "clean": "rimraf dist"
@@ -13,9 +14,7 @@
     "dist"
   ],
   "dependencies": {
-    "@langchain/core": "^0.2.29",
-    "pawnote": "^1.6.2",
-    "zod": "^3.23.8"
+    "pawnote": "^1.6.2"
   },
   "peerDependencies": {
     "n8n-core": "^1.0.0",