@bitavu/n8n-nodes-bitavu 0.1.2 → 0.1.4

package/dist/nodes/Bitavu/BitavuAction.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitavuListSearch = exports.versionPicker = exports.templatePicker = exports.bitavuNodeDefaults = void 0;
+exports.executeBitavu = executeBitavu;
+const node_crypto_1 = require("node:crypto");
+const n8n_workflow_1 = require("n8n-workflow");
+const BitavuApi_1 = require("./BitavuApi");
+exports.bitavuNodeDefaults = {
+    group: ['transform'],
+    version: 1,
+    inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+    outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+    credentials: [{ name: 'bitavuApi', required: true }],
+};
+exports.templatePicker = {
+    displayName: 'Template',
+    name: 'templateId',
+    type: 'resourceLocator',
+    required: true,
+    default: { mode: 'id', value: '' },
+    modes: [
+        {
+            displayName: 'From List',
+            name: 'list',
+            type: 'list',
+            typeOptions: { searchListMethod: 'searchTemplates', searchable: true },
+        },
+        {
+            displayName: 'By ID',
+            name: 'id',
+            type: 'string',
+            placeholder: 'invoice',
+        },
+    ],
+    description: 'Choose an accessible template with Read templates permission, or enter a template ID or expression',
+};
+exports.versionPicker = {
+    type: 'resourceLocator',
+    default: { mode: 'number', value: '' },
+    typeOptions: { loadOptionsDependsOn: ['templateId'] },
+    modes: [
+        {
+            displayName: 'From List',
+            name: 'list',
+            type: 'list',
+            typeOptions: { searchListMethod: 'searchVersions' },
+        },
+        {
+            displayName: 'By Number',
+            name: 'number',
+            type: 'string',
+            placeholder: '1',
+        },
+    ],
+};
+const templateNameOrder = new Intl.Collator('en', { numeric: true, sensitivity: 'base' });
+exports.bitavuListSearch = {
+    async searchVersions(_filter, paginationToken) {
+        const templateId = locatorValue(this.getCurrentNodeParameter('templateId'));
+        if (typeof templateId !== 'string' || !validTemplateId.test(templateId.trim())) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Select a template to list its saved versions.');
+        }
+        const page = paginationToken === undefined ? 1 : Number(paginationToken);
+        if (!Number.isSafeInteger(page) || page < 1 || page > 10000) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid template version page.');
+        }
+        const response = await (0, BitavuApi_1.requestBitavu)(this, undefined, {
+            path: `/v1/templates/${templateId.trim()}/versions?summary=true&page=${page}&pageSize=50`,
+            permission: 'Read templates',
+        });
+        const value = (0, BitavuApi_1.hasMediaType)(response, 'application/json') ? (0, BitavuApi_1.parseJson)(response.body) : undefined;
+        if (!(0, BitavuApi_1.isVersionPage)(value)) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Bitavu returned an unexpected version list.');
+        }
+        return {
+            results: [...value.versions]
+                .sort((a, b) => b.revision - a.revision)
+                .map(({ revision, title }) => {
+                const publication = revision === value.publishedRevision ? ' (Published)' : '';
+                return {
+                    name: `Version ${revision}${publication}${title ? ` - ${title}` : ''}`,
+                    value: String(revision),
+                };
+            }),
+            ...(value.page < value.pages ? { paginationToken: String(value.page + 1) } : {}),
+        };
+    },
+    async searchTemplates(filter = '') {
+        const response = await (0, BitavuApi_1.requestBitavu)(this, undefined, {
+            path: '/v1/templates',
+            permission: 'Read templates',
+        });
+        const value = (0, BitavuApi_1.hasMediaType)(response, 'application/json') ? (0, BitavuApi_1.parseJson)(response.body) : undefined;
+        if (!(0, BitavuApi_1.isCatalog)(value)) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Bitavu returned an unexpected template list.');
+        }
+        const search = filter.trim().toLowerCase();
+        return {
+            results: value.templates
+                .filter((entry) => [entry.id, entry.name, ...entry.path].some((label) => label.toLowerCase().includes(search)))
+                .map((entry) => ({
+                name: entry.path.join(' / ') || entry.name,
+                value: entry.id,
+            }))
+                .sort((a, b) => templateNameOrder.compare(a.name, b.name) || a.value.localeCompare(b.value, 'en')),
+        };
+    },
+};
+async function executeBitavu(operation) {
+    var _a, _b;
+    const items = this.getInputData();
+    const output = [];
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+        try {
+            const invalid = (message) => {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), message, { itemIndex });
+            };
+            const result = operation === 'generate'
+                ? await generatePdf(this, itemIndex, invalid)
+                : { bitavu: await runTemplateOperation(this, itemIndex, operation, invalid) };
+            const item = items[itemIndex];
+            const binary = result.binary ? { ...item.binary, ...result.binary } : item.binary;
+            output.push({
+                json: { ...item.json, bitavu: result.bitavu },
+                ...(binary ? { binary } : {}),
+                pairedItem: { item: itemIndex },
+            });
+        }
+        catch (error) {
+            const knownError = error instanceof n8n_workflow_1.NodeApiError || error instanceof n8n_workflow_1.NodeOperationError;
+            const message = knownError
+                ? error.message
+                : 'The Bitavu operation failed. Check the node configuration.';
+            if (!this.continueOnFail()) {
+                if (error instanceof n8n_workflow_1.NodeApiError) {
+                    const apiError = new n8n_workflow_1.NodeApiError(this.getNode(), { message }, {
+                        message,
+                        description: (_a = error.description) !== null && _a !== void 0 ? _a : undefined,
+                        httpCode: (_b = error.httpCode) !== null && _b !== void 0 ? _b : undefined,
+                        itemIndex,
+                    });
+                    apiError.context.bitavu = error.context.bitavu;
+                    throw apiError;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), message, { itemIndex });
+            }
+            output.push({
+                json: {
+                    error: message,
+                    ...(error instanceof n8n_workflow_1.NodeApiError ? { bitavu: error.context.bitavu } : {}),
+                },
+                pairedItem: { item: itemIndex },
+            });
+        }
+    }
+    return [output];
+}
+const validTemplateId = /^[A-Za-z0-9_-]{1,80}$/;
+function locatorValue(parameter) {
+    return (0, BitavuApi_1.isRecord)(parameter) && parameter.__rl === true ? parameter.value : parameter;
+}
+function versionValue(parameter) {
+    const raw = locatorValue(parameter);
+    if (typeof raw !== 'string')
+        return raw;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    return /^\d+$/.test(value) ? Number(value) : value;
+}
+function templateIdParameter(context, itemIndex, invalid) {
+    const value = locatorValue(context.getNodeParameter('templateId', itemIndex));
+    const id = typeof value === 'string' ? value.trim() : '';
+    if (!validTemplateId.test(id))
+        invalid('Enter a valid Template ID from Bitavu Integrations.');
+    return id;
+}
+function integer(value, name, invalid, maximum = Number.MAX_SAFE_INTEGER) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > maximum) {
+        return invalid(maximum === Number.MAX_SAFE_INTEGER
+            ? `${name} must be a positive integer.`
+            : `${name} must be an integer from 1 to ${maximum}.`);
+    }
+    return value;
+}
+function jsonObject(raw, name, invalid) {
+    const value = typeof raw === 'string' ? (0, BitavuApi_1.parseJson)(raw) : raw;
+    if (!(0, BitavuApi_1.isRecord)(value))
+        invalid(`${name} must be a valid JSON object.`);
+    let serialized;
+    try {
+        serialized = (0, BitavuApi_1.parseJson)(JSON.stringify(value));
+    }
+    catch {
+    }
+    if (!(0, BitavuApi_1.isRecord)(serialized))
+        return invalid(`${name} must be serializable as a JSON object.`);
+    return serialized;
+}
+async function generatePdf(context, itemIndex, invalid) {
+    var _a;
+    const templateId = templateIdParameter(context, itemIndex, invalid);
+    const selection = context.getNodeParameter('versionSelection', itemIndex, 'pinned');
+    if (selection !== 'pinned' && selection !== 'latest-published')
+        invalid('Choose Pinned or Latest Published for Version Selection.');
+    const options = context.getNodeParameter('options', itemIndex, {});
+    const selectedVersion = versionValue(context.getNodeParameter('revision', itemIndex, null));
+    const revision = selection === 'latest-published'
+        ? selection
+        : integer(selectedVersion !== null && selectedVersion !== void 0 ? selectedVersion : 1, 'Pinned Version', invalid);
+    const data = jsonObject(context.getNodeParameter('data', itemIndex), 'Document Data', invalid);
+    const body = { templateId, revision, data };
+    const baseVersion = selectedVersion !== null && selectedVersion !== void 0 ? selectedVersion : options.baseRevision;
+    if (selection === 'latest-published' && baseVersion != null) {
+        body.baseRevision = integer(baseVersion, 'Base Version', invalid);
+    }
+    if (options.mappingId !== undefined && options.mappingId !== '') {
+        const mappingId = options.mappingId;
+        if (typeof mappingId !== 'string' || !mappingId.trim())
+            return invalid('Mapping ID must be a non-empty string.');
+        body.mappingId = mappingId.trim();
+    }
+    const outputField = String(options.outputField || 'pdf');
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(outputField) ||
+        ['__proto__', 'constructor', 'prototype'].includes(outputField))
+        invalid('Output Binary Field must be a simple field name, such as pdf.');
+    const fileName = String(options.fileName || `${templateId}.pdf`).trim();
+    if (!fileName ||
+        /[/\\]/.test(fileName) ||
+        [...fileName].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127) ||
+        !fileName.toLowerCase().endsWith('.pdf'))
+        invalid('File Name must end in .pdf and contain no path separators or control characters.');
+    const operationId = String(options.operationId ||
+        `bitavu-${(0, node_crypto_1.createHash)('sha256')
+            .update(JSON.stringify([
+            context.getExecutionId(),
+            context.getNode().id,
+            context.evaluateExpression('{{ $runIndex }}', itemIndex),
+            itemIndex,
+        ]))
+            .digest('hex')}`);
+    if (!/^[a-zA-Z0-9_-]{16,128}$/.test(operationId))
+        invalid('Operation ID must contain 16–128 letters, digits, underscores or hyphens.');
+    const response = await (0, BitavuApi_1.requestBitavu)(context, itemIndex, {
+        path: '/v1/render',
+        permission: 'Generate PDFs',
+        body,
+        idempotencyKey: operationId,
+    });
+    if (response.statusCode !== 200 ||
+        !(0, BitavuApi_1.hasMediaType)(response, 'application/pdf') ||
+        !response.body.subarray(0, 5).equals(Buffer.from('%PDF-')))
+        invalid('Bitavu returned an unexpected response instead of a PDF.');
+    const binary = await context.helpers.prepareBinaryData(response.body, fileName, 'application/pdf');
+    return {
+        bitavu: {
+            templateId,
+            revision: (_a = (0, BitavuApi_1.readPositiveHeader)(response, 'x-bitavu-revision')) !== null && _a !== void 0 ? _a : (typeof revision === 'number' ? revision : null),
+            requestedRevision: revision,
+            pageCount: (0, BitavuApi_1.readPositiveHeader)(response, 'x-bitavu-pages'),
+            requestId: (0, BitavuApi_1.readRequestId)(response),
+            operationId,
+            fileName,
+            outputField,
+        },
+        binary: { [outputField]: binary },
+    };
+}
+async function runTemplateOperation(context, itemIndex, operation, invalid) {
+    var _a, _b;
+    let path = '/v1/templates';
+    let body;
+    let validate = BitavuApi_1.isCatalog;
+    if (operation !== 'listTemplates') {
+        path += '/' + templateIdParameter(context, itemIndex, invalid);
+        switch (operation) {
+            case 'getTemplate': {
+                const revision = integer(versionValue(context.getNodeParameter('templateRevision', itemIndex)), 'Version to Read', invalid);
+                path += '?revision=' + revision;
+                validate = BitavuApi_1.isTemplateRevision;
+                break;
+            }
+            case 'listVersions': {
+                const options = context.getNodeParameter('versionOptions', itemIndex, {});
+                const page = integer((_a = options.page) !== null && _a !== void 0 ? _a : 1, 'Page', invalid, 10000);
+                const pageSize = integer((_b = options.pageSize) !== null && _b !== void 0 ? _b : 10, 'Page Size', invalid, 50);
+                const query = new URLSearchParams({
+                    summary: 'true',
+                    page: String(page),
+                    pageSize: String(pageSize),
+                });
+                if (options.selectedRevision !== undefined) {
+                    query.set('revision', String(integer(options.selectedRevision, 'Selected Version', invalid)));
+                }
+                path += '/versions?' + query;
+                break;
+            }
+            case 'saveExample':
+                path += '/example';
+                body = {
+                    expectedRevision: integer(context.getNodeParameter('expectedRevision', itemIndex), 'Expected Version', invalid, Number.MAX_SAFE_INTEGER - 1),
+                    exampleJson: jsonObject(context.getNodeParameter('exampleJson', itemIndex), 'Example JSON', invalid),
+                };
+                validate = BitavuApi_1.isTemplateRevision;
+                break;
+        }
+    }
+    const response = await (0, BitavuApi_1.requestBitavu)(context, itemIndex, {
+        path,
+        permission: body === undefined ? 'Read templates' : 'Save template examples',
+        body,
+    });
+    const value = (0, BitavuApi_1.hasMediaType)(response, 'application/json') ? (0, BitavuApi_1.parseJson)(response.body) : undefined;
+    if (operation === 'listVersions') {
+        if (!(0, BitavuApi_1.isVersionPage)(value))
+            invalid('Bitavu returned an unexpected template response.');
+        if (value.publishedRevision === undefined)
+            return value;
+        return {
+            ...value,
+            versions: value.versions.map((version) => ({
+                ...version,
+                published: version.revision === value.publishedRevision,
+            })),
+        };
+    }
+    if (!validate(value))
+        invalid('Bitavu returned an unexpected template response.');
+    return value;
+}
+//# sourceMappingURL=BitavuAction.js.map

package/dist/nodes/Bitavu/BitavuApi.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestBitavu = requestBitavu;
+exports.hasMediaType = hasMediaType;
+exports.readPositiveHeader = readPositiveHeader;
+exports.readRequestId = readRequestId;
+exports.parseJson = parseJson;
+exports.isRecord = isRecord;
+exports.isCatalog = isCatalog;
+exports.isVersionPage = isVersionPage;
+exports.isTemplateRevision = isTemplateRevision;
+const n8n_workflow_1 = require("n8n-workflow");
+const origin = 'https://api.bitavu.com';
+const messages = {
+    INVALID_API_KEY: 'Your API key is invalid, expired or revoked. Check your Bitavu credential.',
+    KEY_REPORT: 'This key cannot access the template. Grant it access in Bitavu Integrations.',
+    NOT_PUBLISHED: 'Publish a saved version in Bitavu Studio before using Latest Published.',
+    JSON_COMPATIBILITY: 'The published version is incompatible with your base version or saved mapping. Review the JSON contract in Studio or pin a tested version.',
+    TEMPLATE_REVISION_CONFLICT: 'The template changed. Get the latest saved version and check its bindings before saving the example again.',
+    IDEMPOTENCY_CONFLICT: 'This operation ID was already used with different input. Use a new ID for a new document.',
+    API_VERSION_LIMIT: 'This template reached its rolling saved-version limit. Use a previously rendered version or wait for the limit to reset.',
+};
+async function requestBitavu(context, itemIndex, { path, permission, body, idempotencyKey }) {
+    var _a, _b;
+    const headers = {
+        Accept: permission === 'Generate PDFs' ? 'application/pdf' : 'application/json',
+    };
+    const request = {
+        method: body === undefined ? 'GET' : 'POST',
+        url: origin + path,
+        headers,
+        encoding: 'arraybuffer',
+        returnFullResponse: true,
+        ignoreHttpStatusErrors: true,
+        disableFollowRedirect: true,
+        timeout: 120000,
+    };
+    if (body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        request.body = JSON.stringify(body);
+    }
+    if (idempotencyKey !== undefined)
+        headers['Idempotency-Key'] = idempotencyKey;
+    let response;
+    try {
+        response = await context.helpers.httpRequestWithAuthentication.call(context, 'bitavuApi', request);
+    }
+    catch {
+        const guidance = {
+            'Generate PDFs': ' Retry with the same operation ID if the result is uncertain.',
+            'Read templates': '',
+            'Save template examples': ' Check the latest saved version before retrying the save.',
+        }[permission];
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Could not complete the Bitavu request. Check your credential and network connection.' +
+            guidance, { itemIndex });
+    }
+    const result = {
+        body: Buffer.isBuffer(response.body) ? response.body : Buffer.from((_a = response.body) !== null && _a !== void 0 ? _a : ''),
+        headers: (_b = response.headers) !== null && _b !== void 0 ? _b : {},
+        statusCode: response.statusCode,
+    };
+    if (result.statusCode < 200 || result.statusCode >= 300) {
+        throw apiError(context, itemIndex, result, permission);
+    }
+    return result;
+}
+function apiError(context, itemIndex, response, permission) {
+    const status = response.statusCode;
+    const payload = response.body.length <= 65536 && hasMediaType(response, 'application/json')
+        ? parseJson(response.body)
+        : undefined;
+    const value = isRecord(payload) ? payload.code : undefined;
+    const code = typeof value === 'string' &&
+        (value === 'KEY_SCOPE' || Object.prototype.hasOwnProperty.call(messages, value))
+        ? value
+        : null;
+    const fallback = {
+        400: 'Check your Bitavu node settings and input against the template.',
+        401: messages.INVALID_API_KEY,
+        402: 'The workspace cannot complete this request. Check your Bitavu subscription.',
+        403: `Check the key’s ${permission} permission and template access in Bitavu Integrations.`,
+        404: 'Check the Template ID, version and saved mapping in Bitavu Studio.',
+        409: 'Bitavu reported a conflict. Check the template version and input before retrying.',
+        422: 'Check the JSON fields and saved mapping against the Bitavu template.',
+        429: 'Bitavu is limiting requests or your render allowance is exhausted.',
+    };
+    const message = code === 'KEY_SCOPE'
+        ? `Enable ${permission} permission for this key in Bitavu Integrations.`
+        : (code && messages[code]) || fallback[status] || 'Bitavu could not complete the request.';
+    const requestId = readRequestId(response);
+    const retryAfter = readHeader(response, 'retry-after');
+    const delay = /^\d+$/.test(retryAfter)
+        ? Number(retryAfter) * 1000
+        : Math.max(0, Date.parse(retryAfter) - Date.now());
+    const retryAfterMs = Number.isSafeInteger(delay) ? delay : null;
+    const description = [
+        `Bitavu returned HTTP ${status}${code ? ` (${code})` : ''}.`,
+        ...(requestId === null ? [] : [`Request ID ${requestId}.`]),
+        ...(retryAfterMs === null
+            ? []
+            : [`Wait at least ${Math.ceil(retryAfterMs / 1000)} seconds before retrying.`]),
+    ].join(' ');
+    const error = new n8n_workflow_1.NodeApiError(context.getNode(), { message }, { message, description, httpCode: String(status), itemIndex });
+    error.context.bitavu = { status, code, requestId, retryAfterMs };
+    return error;
+}
+function readHeader(response, name) {
+    const entry = Object.entries(response.headers).find(([key]) => key.toLowerCase() === name);
+    return typeof (entry === null || entry === void 0 ? void 0 : entry[1]) === 'string' ? entry[1].trim() : '';
+}
+function hasMediaType(response, type) {
+    return readHeader(response, 'content-type').split(';', 1)[0].trim().toLowerCase() === type;
+}
+function readPositiveHeader(response, name) {
+    const value = readHeader(response, name);
+    const number = Number(value);
+    return /^\d+$/.test(value) && isInteger(number, 1) ? number : null;
+}
+function readRequestId(response) {
+    const id = readHeader(response, 'x-bitavu-request-id');
+    return /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i.test(id) ? id : null;
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value.toString());
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isInteger(value, minimum) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= minimum;
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+function isRevisionSummary(value) {
+    return (isRecord(value) &&
+        typeof value.id === 'string' &&
+        typeof value.name === 'string' &&
+        typeof value.studioUrl === 'string' &&
+        isInteger(value.revision, 1) &&
+        (value.createdAt === null || isInteger(value.createdAt, 0)) &&
+        (value.updatedAt === null || isInteger(value.updatedAt, 0)));
+}
+function isInputPath(value) {
+    return isRecord(value) && typeof value.path === 'string' && typeof value.required === 'boolean';
+}
+function isCatalog(value) {
+    return (isRecord(value) &&
+        Array.isArray(value.templates) &&
+        value.templates.every((entry) => isRecord(entry) &&
+            typeof entry.id === 'string' &&
+            typeof entry.name === 'string' &&
+            typeof entry.studioUrl === 'string' &&
+            isStringList(entry.path) &&
+            isInteger(entry.latestRevision, 1)));
+}
+function isVersionPage(value) {
+    return (isRecord(value) &&
+        Array.isArray(value.versions) &&
+        value.versions.every((entry) => isRevisionSummary(entry) && (entry.title === null || typeof entry.title === 'string')) &&
+        isRevisionSummary(value.latest) &&
+        (value.publishedRevision == null || isInteger(value.publishedRevision, 1)) &&
+        (value.selected === null || isRevisionSummary(value.selected)) &&
+        isInteger(value.page, 1) &&
+        isInteger(value.pageSize, 1) &&
+        isInteger(value.total, 0) &&
+        isInteger(value.pages, 0));
+}
+function isTemplateRevision(value) {
+    if (!isRevisionSummary(value))
+        return false;
+    const review = value.inputReview;
+    return (Array.isArray(value.bindings) &&
+        value.bindings.every((entry) => isInputPath(entry) && typeof entry.type === 'string') &&
+        (value.exampleJson === null || isRecord(value.exampleJson)) &&
+        (review === null ||
+            (isRecord(review) &&
+                Array.isArray(review.missing) &&
+                review.missing.every(isInputPath) &&
+                isStringList(review.unused))));
+}
+//# sourceMappingURL=BitavuApi.js.map

package/dist/nodes/BitavuGetTemplateVersion/BitavuGetTemplateVersion.node.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitavuGetTemplateVersion = void 0;
+const BitavuAction_1 = require("../Bitavu/BitavuAction");
+class BitavuGetTemplateVersion {
+    constructor() {
+        this.description = {
+            ...BitavuAction_1.bitavuNodeDefaults,
+            displayName: 'Get Template Version',
+            icon: { light: 'file:../Bitavu/bitavu.svg', dark: 'file:../Bitavu/bitavu.svg' },
+            usableAsTool: undefined,
+            subtitle: '',
+            name: 'bitavuGetTemplateVersion',
+            description: 'Read a saved Bitavu template version, its bindings, and example JSON',
+            defaults: { name: 'Get Template Version' },
+            properties: [
+                BitavuAction_1.templatePicker,
+                {
+                    ...BitavuAction_1.versionPicker,
+                    displayName: 'Version to Read',
+                    name: 'templateRevision',
+                    default: { mode: 'number', value: '1' },
+                    required: true,
+                    description: 'The saved version to read',
+                },
+            ],
+        };
+        this.methods = { listSearch: BitavuAction_1.bitavuListSearch };
+    }
+    async execute() {
+        return await BitavuAction_1.executeBitavu.call(this, 'getTemplate');
+    }
+}
+exports.BitavuGetTemplateVersion = BitavuGetTemplateVersion;
+//# sourceMappingURL=BitavuGetTemplateVersion.node.js.map

package/dist/nodes/BitavuGetTemplateVersion/BitavuGetTemplateVersion.node.json

@@ -0,0 +1,17 @@
+{
+    "node": "@bitavu/n8n-nodes-bitavu.bitavuGetTemplateVersion",
+    "nodeVersion": "1.0",
+    "codexVersion": "1.0",
+    "alias": ["Bitavu"],
+    "categories": [
+        "Productivity",
+        "Utility"
+    ],
+    "resources": {
+        "primaryDocumentation": [
+            {
+                "url": "https://bitavu.com/support/n8n"
+            }
+        ]
+    }
+}

package/dist/nodes/BitavuListTemplateVersions/BitavuListTemplateVersions.node.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitavuListTemplateVersions = void 0;
+const BitavuAction_1 = require("../Bitavu/BitavuAction");
+class BitavuListTemplateVersions {
+    constructor() {
+        this.description = {
+            ...BitavuAction_1.bitavuNodeDefaults,
+            displayName: 'List Template Versions',
+            icon: { light: 'file:../Bitavu/bitavu.svg', dark: 'file:../Bitavu/bitavu.svg' },
+            usableAsTool: undefined,
+            subtitle: '',
+            name: 'bitavuListTemplateVersions',
+            description: 'List saved versions of a Bitavu template and identify the current publication',
+            defaults: { name: 'List Template Versions' },
+            properties: [
+                BitavuAction_1.templatePicker,
+                {
+                    displayName: 'Options',
+                    name: 'versionOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Page',
+                            name: 'page',
+                            type: 'number',
+                            default: 1,
+                            typeOptions: { minValue: 1, maxValue: 10000, numberPrecision: 0 },
+                            description: 'The page of saved versions, starting at 1',
+                        },
+                        {
+                            displayName: 'Page Size',
+                            name: 'pageSize',
+                            type: 'number',
+                            default: 10,
+                            typeOptions: { minValue: 1, maxValue: 50, numberPrecision: 0 },
+                            description: 'How many versions to return per page',
+                        },
+                        {
+                            displayName: 'Selected Version',
+                            name: 'selectedRevision',
+                            type: 'number',
+                            default: 1,
+                            typeOptions: { minValue: 1, numberPrecision: 0 },
+                            description: 'Include this version’s summary even if it is on a different page',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = { listSearch: { searchTemplates: BitavuAction_1.bitavuListSearch.searchTemplates } };
+    }
+    async execute() {
+        return await BitavuAction_1.executeBitavu.call(this, 'listVersions');
+    }
+}
+exports.BitavuListTemplateVersions = BitavuListTemplateVersions;
+//# sourceMappingURL=BitavuListTemplateVersions.node.js.map

package/dist/nodes/BitavuListTemplateVersions/BitavuListTemplateVersions.node.json

@@ -0,0 +1,17 @@
+{
+    "node": "@bitavu/n8n-nodes-bitavu.bitavuListTemplateVersions",
+    "nodeVersion": "1.0",
+    "codexVersion": "1.0",
+    "alias": ["Bitavu"],
+    "categories": [
+        "Productivity",
+        "Utility"
+    ],
+    "resources": {
+        "primaryDocumentation": [
+            {
+                "url": "https://bitavu.com/support/n8n"
+            }
+        ]
+    }
+}

package/dist/nodes/BitavuListTemplates/BitavuListTemplates.node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitavuListTemplates = void 0;
+const BitavuAction_1 = require("../Bitavu/BitavuAction");
+class BitavuListTemplates {
+    constructor() {
+        this.description = {
+            ...BitavuAction_1.bitavuNodeDefaults,
+            displayName: 'List Templates',
+            icon: { light: 'file:../Bitavu/bitavu.svg', dark: 'file:../Bitavu/bitavu.svg' },
+            usableAsTool: undefined,
+            subtitle: '',
+            name: 'bitavuListTemplates',
+            description: 'List the Bitavu templates accessible to your API key',
+            defaults: { name: 'List Templates' },
+            properties: [],
+        };
+    }
+    async execute() {
+        return await BitavuAction_1.executeBitavu.call(this, 'listTemplates');
+    }
+}
+exports.BitavuListTemplates = BitavuListTemplates;
+//# sourceMappingURL=BitavuListTemplates.node.js.map