n8n-nodes-geomelon 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# n8n-nodes-geomelon
+
+[n8n](https://n8n.io) community node for the **[Geomelon](https://geomelon.dev) geographic API** — search cities, look up countries and regions, compute distances, and resolve coordinates, all with multilingual name support.
+
+Looking for other ways to integrate? See all official libraries at [geomelon.dev/libraries](https://geomelon.dev/libraries/).
+
+## Installation
+
+In your n8n instance: **Settings → Community Nodes → Install** → enter `n8n-nodes-geomelon`.
+
+Requires n8n v1.0+ and Node.js 18+.
+
+## Credentials
+
+The node uses a **Geomelon API (RapidAPI)** credential. You need a RapidAPI key subscribed to the [Geomelon API](https://rapidapi.com/hom3chuk/api/geomelon).
+
+1. Create a credential of type **Geomelon API (RapidAPI)**
+2. Paste your RapidAPI key into the **RapidAPI Key** field
+
+## Resources and Operations
+
+### City
+
+| Operation | Description |
+|---|---|
+| **Search** | Search cities by name prefix, country code, region, population range, with sort and pagination |
+| **Get** | Get full details for a city by UUID |
+| **Get Translations** | Get all available name translations for a city |
+| **Get Settlement Types** | Get settlement-type classifications (city, town, village, …) |
+| **Distance** | Calculate the distance in kilometres between two cities |
+| **By Coordinates (Closest)** | Find cities nearest to a lat/lon point, ordered by distance |
+| **By Coordinates (Largest)** | Find the largest cities near a lat/lon point, ordered by population |
+
+### Country
+
+| Operation | Description |
+|---|---|
+| **List** | List countries with optional name, telephone code, and language filters |
+| **Get** | Get full details (including regions and translations) for a country by UUID |
+| **Get Translations** | Get name translations for a country |
+| **Get Regions** | Get all administrative regions belonging to a country |
+
+### Region
+
+| Operation | Description |
+|---|---|
+| **List** | List regions, optionally filtered by country UUID |
+| **Get** | Get full details for a region by UUID |
+| **Get Translations** | Get name translations for a region |
+
+### Language
+
+| Operation | Description |
+|---|---|
+| **List** | List languages available in the Geomelon database |
+| **Get** | Get details for a language by UUID |
+
+## Output
+
+- **List / Search** operations output one item per result, so downstream nodes can iterate naturally.
+- **Get** and single-result operations output one item.
+- The **Distance** operation outputs `{ distanceKm: number }`.
+
+## Example Workflows
+
+**Find the 10 largest cities in France with French names**
+1. Geomelon → City: Search → `countryCode = FR`, `preferredLanguages = fr`, `sort = population_desc`, `limit = 10`
+
+**Look up a city by coordinates**
+1. Geomelon → City: By Coordinates (Closest) → `lat = 48.8566`, `lon = 2.3522`
+
+**Get all regions of Germany**
+1. Geomelon → Country: List → `name = Germany`, `limit = 1`
+2. Geomelon → Country: Get Regions → `countryId = {{ $json.id }}`
+
+## License
+
+MIT

package/dist/credentials/GeomelonApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import type { ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class GeomelonApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    test: ICredentialTestRequest;
+}

package/dist/credentials/GeomelonApi.credentials.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeomelonApi = void 0;
+class GeomelonApi {
+    constructor() {
+        this.name = 'geomelonApi';
+        this.displayName = 'Geomelon API (RapidAPI)';
+        this.documentationUrl = 'https://rapidapi.com/hom3chuk/api/geomelon';
+        this.properties = [
+            {
+                displayName: 'RapidAPI Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Your RapidAPI key for the Geomelon API',
+            },
+        ];
+        this.test = {
+            request: {
+                baseURL: 'https://geomelon.p.rapidapi.com',
+                url: '/countries',
+                qs: { limit: 1 },
+                headers: {
+                    'x-rapidapi-key': '={{$credentials.apiKey}}',
+                    'x-rapidapi-host': 'geomelon.p.rapidapi.com',
+                },
+            },
+        };
+    }
+}
+exports.GeomelonApi = GeomelonApi;

package/dist/nodes/Geomelon/Geomelon.node.d.ts

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

package/dist/nodes/Geomelon/Geomelon.node.js

@@ -0,0 +1,624 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Geomelon = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const geomelon_1 = require("geomelon");
+class Geomelon {
+    constructor() {
+        this.description = {
+            displayName: 'Geomelon',
+            name: 'geomelon',
+            icon: 'file:geomelon.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Geographic data — cities, countries, regions, and languages via the Geomelon API',
+            defaults: { name: 'Geomelon' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'geomelonApi', required: true }],
+            properties: [
+                // ── Resource ──────────────────────────────────────────────────────────
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'City', value: 'city' },
+                        { name: 'Country', value: 'country' },
+                        { name: 'Language', value: 'language' },
+                        { name: 'Region', value: 'region' },
+                    ],
+                    default: 'city',
+                },
+                // ── City operations ───────────────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['city'] } },
+                    options: [
+                        {
+                            name: 'Search',
+                            value: 'search',
+                            description: 'Search cities by name, country, population range, and more',
+                            action: 'Search cities',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get full details for a city by UUID',
+                            action: 'Get a city',
+                        },
+                        {
+                            name: 'Get Translations',
+                            value: 'getTranslations',
+                            description: 'Get all name translations for a city',
+                            action: 'Get city translations',
+                        },
+                        {
+                            name: 'Get Settlement Types',
+                            value: 'getSettlementTypes',
+                            description: 'Get settlement-type classifications for a city',
+                            action: 'Get city settlement types',
+                        },
+                        {
+                            name: 'Distance',
+                            value: 'distance',
+                            description: 'Calculate the distance in kilometres between two cities',
+                            action: 'Get distance between two cities',
+                        },
+                        {
+                            name: 'By Coordinates (Closest)',
+                            value: 'byCoordinatesClosest',
+                            description: 'Find cities nearest to given coordinates, ordered by distance',
+                            action: 'Find closest cities by coordinates',
+                        },
+                        {
+                            name: 'By Coordinates (Largest)',
+                            value: 'byCoordinatesLargest',
+                            description: 'Find the largest cities near given coordinates, ordered by population',
+                            action: 'Find largest cities by coordinates',
+                        },
+                    ],
+                    default: 'search',
+                },
+                // ── Country operations ────────────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['country'] } },
+                    options: [
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List countries with optional filtering',
+                            action: 'List countries',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get full details for a country by UUID',
+                            action: 'Get a country',
+                        },
+                        {
+                            name: 'Get Translations',
+                            value: 'getTranslations',
+                            description: 'Get name translations for a country',
+                            action: 'Get country translations',
+                        },
+                        {
+                            name: 'Get Regions',
+                            value: 'getRegions',
+                            description: 'Get all administrative regions belonging to a country',
+                            action: 'Get country regions',
+                        },
+                    ],
+                    default: 'list',
+                },
+                // ── Region operations ─────────────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['region'] } },
+                    options: [
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List administrative regions, optionally filtered by country',
+                            action: 'List regions',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get full details for a region by UUID',
+                            action: 'Get a region',
+                        },
+                        {
+                            name: 'Get Translations',
+                            value: 'getTranslations',
+                            description: 'Get name translations for a region',
+                            action: 'Get region translations',
+                        },
+                    ],
+                    default: 'list',
+                },
+                // ── Language operations ───────────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['language'] } },
+                    options: [
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List languages available in Geomelon',
+                            action: 'List languages',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get details for a language by UUID',
+                            action: 'Get a language',
+                        },
+                    ],
+                    default: 'list',
+                },
+                // ══════════════════════════════════════════════════════════════════════
+                // Fields — City
+                // ══════════════════════════════════════════════════════════════════════
+                // City: Search
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    description: 'City name prefix to search for',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Country Code',
+                    name: 'countryCode',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'US',
+                    description: 'ISO 3166-1 alpha-2 country code',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Region ID',
+                    name: 'regionId',
+                    type: 'string',
+                    default: '',
+                    description: 'Filter by region UUID',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Min Population',
+                    name: 'minPopulation',
+                    type: 'number',
+                    default: 0,
+                    description: 'Minimum population filter (leave 0 to skip)',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Max Population',
+                    name: 'maxPopulation',
+                    type: 'number',
+                    default: 0,
+                    description: 'Maximum population filter (leave 0 to skip)',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Sort',
+                    name: 'sort',
+                    type: 'options',
+                    options: [
+                        { name: 'Population Descending', value: 'population_desc' },
+                        { name: 'Population Ascending', value: 'population_asc' },
+                        { name: 'Name A → Z', value: 'name_asc' },
+                        { name: 'Name Z → A', value: 'name_desc' },
+                    ],
+                    default: 'population_desc',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Preferred Languages',
+                    name: 'preferredLanguages',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'fr,en',
+                    description: 'Comma-separated BCP 47 language tags for localized names',
+                    displayOptions: {
+                        show: {
+                            resource: ['city'],
+                            operation: ['search', 'byCoordinatesClosest', 'byCoordinatesLargest'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 100 },
+                    default: 20,
+                    description: 'Max number of results to return',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                {
+                    displayName: 'Offset',
+                    name: 'offset',
+                    type: 'number',
+                    typeOptions: { minValue: 0 },
+                    default: 0,
+                    description: 'Pagination offset',
+                    displayOptions: { show: { resource: ['city'], operation: ['search'] } },
+                },
+                // City: Get / Get Translations / Get Settlement Types
+                {
+                    displayName: 'City ID',
+                    name: 'cityId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'UUID of the city',
+                    displayOptions: {
+                        show: {
+                            resource: ['city'],
+                            operation: ['get', 'getTranslations', 'getSettlementTypes'],
+                        },
+                    },
+                },
+                // City: Distance
+                {
+                    displayName: 'City 1 ID',
+                    name: 'city1',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'UUID of the first city',
+                    displayOptions: { show: { resource: ['city'], operation: ['distance'] } },
+                },
+                {
+                    displayName: 'City 2 ID',
+                    name: 'city2',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'UUID of the second city',
+                    displayOptions: { show: { resource: ['city'], operation: ['distance'] } },
+                },
+                // City: By Coordinates
+                {
+                    displayName: 'Latitude',
+                    name: 'lat',
+                    type: 'number',
+                    default: 0,
+                    required: true,
+                    description: 'Latitude of the reference point',
+                    displayOptions: {
+                        show: {
+                            resource: ['city'],
+                            operation: ['byCoordinatesClosest', 'byCoordinatesLargest'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Longitude',
+                    name: 'lon',
+                    type: 'number',
+                    default: 0,
+                    required: true,
+                    description: 'Longitude of the reference point',
+                    displayOptions: {
+                        show: {
+                            resource: ['city'],
+                            operation: ['byCoordinatesClosest', 'byCoordinatesLargest'],
+                        },
+                    },
+                },
+                // ══════════════════════════════════════════════════════════════════════
+                // Fields — Country
+                // ══════════════════════════════════════════════════════════════════════
+                // Country: List
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    description: 'Country name prefix to filter by',
+                    displayOptions: { show: { resource: ['country'], operation: ['list'] } },
+                },
+                {
+                    displayName: 'Telephone Code',
+                    name: 'telephoneCode',
+                    type: 'string',
+                    default: '',
+                    placeholder: '+1',
+                    description: 'Filter by dialing code',
+                    displayOptions: { show: { resource: ['country'], operation: ['list'] } },
+                },
+                {
+                    displayName: 'Preferred Languages',
+                    name: 'preferredLanguages',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'fr,es,en',
+                    description: 'Comma-separated BCP 47 language tags for localized names',
+                    displayOptions: {
+                        show: {
+                            resource: ['country'],
+                            operation: ['list', 'getTranslations'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 500 },
+                    default: 50,
+                    description: 'Max number of results to return',
+                    displayOptions: { show: { resource: ['country'], operation: ['list'] } },
+                },
+                {
+                    displayName: 'Offset',
+                    name: 'offset',
+                    type: 'number',
+                    typeOptions: { minValue: 0 },
+                    default: 0,
+                    description: 'Pagination offset',
+                    displayOptions: { show: { resource: ['country'], operation: ['list'] } },
+                },
+                // Country: Get / Get Translations / Get Regions
+                {
+                    displayName: 'Country ID',
+                    name: 'countryId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'UUID of the country',
+                    displayOptions: {
+                        show: {
+                            resource: ['country'],
+                            operation: ['get', 'getTranslations', 'getRegions'],
+                        },
+                    },
+                },
+                // ══════════════════════════════════════════════════════════════════════
+                // Fields — Region
+                // ══════════════════════════════════════════════════════════════════════
+                // Region: List
+                {
+                    displayName: 'Country ID',
+                    name: 'countryId',
+                    type: 'string',
+                    default: '',
+                    description: 'Filter regions by country UUID',
+                    displayOptions: { show: { resource: ['region'], operation: ['list'] } },
+                },
+                // Region: Get / Get Translations
+                {
+                    displayName: 'Region ID',
+                    name: 'regionId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'UUID of the region',
+                    displayOptions: {
+                        show: {
+                            resource: ['region'],
+                            operation: ['get', 'getTranslations'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Preferred Languages',
+                    name: 'preferredLanguages',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'fr,es,en',
+                    description: 'Comma-separated BCP 47 language tags',
+                    displayOptions: {
+                        show: {
+                            resource: ['region'],
+                            operation: ['getTranslations'],
+                        },
+                    },
+                },
+                // ══════════════════════════════════════════════════════════════════════
+                // Fields — Language
+                // ══════════════════════════════════════════════════════════════════════
+                // Language: List
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 500 },
+                    default: 50,
+                    description: 'Max number of results to return',
+                    displayOptions: { show: { resource: ['language'], operation: ['list'] } },
+                },
+                {
+                    displayName: 'Offset',
+                    name: 'offset',
+                    type: 'number',
+                    typeOptions: { minValue: 0 },
+                    default: 0,
+                    description: 'Pagination offset',
+                    displayOptions: { show: { resource: ['language'], operation: ['list'] } },
+                },
+                // Language: Get
+                {
+                    displayName: 'Language ID',
+                    name: 'languageId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'UUID of the language',
+                    displayOptions: { show: { resource: ['language'], operation: ['get'] } },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const credentials = await this.getCredentials('geomelonApi');
+        const client = new geomelon_1.GeomelonClient({ apiKey: credentials.apiKey });
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            const resource = this.getNodeParameter('resource', i);
+            const operation = this.getNodeParameter('operation', i);
+            try {
+                let result;
+                if (resource === 'city') {
+                    if (operation === 'search') {
+                        const params = {};
+                        const name = this.getNodeParameter('name', i, '');
+                        const countryCode = this.getNodeParameter('countryCode', i, '');
+                        const regionId = this.getNodeParameter('regionId', i, '');
+                        const minPopulation = this.getNodeParameter('minPopulation', i, 0);
+                        const maxPopulation = this.getNodeParameter('maxPopulation', i, 0);
+                        const sort = this.getNodeParameter('sort', i);
+                        const preferredLanguages = this.getNodeParameter('preferredLanguages', i, '');
+                        const limit = this.getNodeParameter('limit', i);
+                        const offset = this.getNodeParameter('offset', i);
+                        if (name)
+                            params.name = name;
+                        if (countryCode)
+                            params.countryCode = countryCode;
+                        if (regionId)
+                            params.regionId = regionId;
+                        if (minPopulation > 0)
+                            params.minPopulation = minPopulation;
+                        if (maxPopulation > 0)
+                            params.maxPopulation = maxPopulation;
+                        if (sort)
+                            params.sort = sort;
+                        if (preferredLanguages)
+                            params.preferredLanguages = preferredLanguages;
+                        params.limit = limit;
+                        params.offset = offset;
+                        result = await client.cities.search(params);
+                    }
+                    else if (operation === 'get') {
+                        const id = this.getNodeParameter('cityId', i);
+                        result = await client.cities.get(id);
+                    }
+                    else if (operation === 'getTranslations') {
+                        const id = this.getNodeParameter('cityId', i);
+                        result = await client.cities.translations(id);
+                    }
+                    else if (operation === 'getSettlementTypes') {
+                        const id = this.getNodeParameter('cityId', i);
+                        result = await client.cities.settlementTypes(id);
+                    }
+                    else if (operation === 'distance') {
+                        const city1 = this.getNodeParameter('city1', i);
+                        const city2 = this.getNodeParameter('city2', i);
+                        result = await client.cities.distance(city1, city2);
+                    }
+                    else if (operation === 'byCoordinatesClosest') {
+                        const lat = this.getNodeParameter('lat', i);
+                        const lon = this.getNodeParameter('lon', i);
+                        const preferredLanguages = this.getNodeParameter('preferredLanguages', i, '');
+                        const params = { lat, lon, ...(preferredLanguages ? { preferredLanguages } : {}) };
+                        result = await client.cities.byCoordinatesClosest(params);
+                    }
+                    else if (operation === 'byCoordinatesLargest') {
+                        const lat = this.getNodeParameter('lat', i);
+                        const lon = this.getNodeParameter('lon', i);
+                        const preferredLanguages = this.getNodeParameter('preferredLanguages', i, '');
+                        const params = { lat, lon, ...(preferredLanguages ? { preferredLanguages } : {}) };
+                        result = await client.cities.byCoordinatesLargest(params);
+                    }
+                }
+                else if (resource === 'country') {
+                    if (operation === 'list') {
+                        const params = {};
+                        const name = this.getNodeParameter('name', i, '');
+                        const telephoneCode = this.getNodeParameter('telephoneCode', i, '');
+                        const preferredLanguages = this.getNodeParameter('preferredLanguages', i, '');
+                        const limit = this.getNodeParameter('limit', i);
+                        const offset = this.getNodeParameter('offset', i);
+                        if (name)
+                            params.name = name;
+                        if (telephoneCode)
+                            params.telephoneCode = telephoneCode;
+                        if (preferredLanguages)
+                            params.preferredLanguages = preferredLanguages;
+                        params.limit = limit;
+                        params.offset = offset;
+                        result = await client.countries.list(params);
+                    }
+                    else if (operation === 'get') {
+                        const id = this.getNodeParameter('countryId', i);
+                        result = await client.countries.get(id);
+                    }
+                    else if (operation === 'getTranslations') {
+                        const id = this.getNodeParameter('countryId', i);
+                        const preferredLanguages = this.getNodeParameter('preferredLanguages', i, '');
+                        result = await client.countries.translations(id, preferredLanguages ? { preferredLanguages } : undefined);
+                    }
+                    else if (operation === 'getRegions') {
+                        const id = this.getNodeParameter('countryId', i);
+                        result = await client.countries.regions(id);
+                    }
+                }
+                else if (resource === 'region') {
+                    if (operation === 'list') {
+                        const countryId = this.getNodeParameter('countryId', i, '');
+                        result = await client.regions.list(countryId ? { countryId } : undefined);
+                    }
+                    else if (operation === 'get') {
+                        const id = this.getNodeParameter('regionId', i);
+                        result = await client.regions.get(id);
+                    }
+                    else if (operation === 'getTranslations') {
+                        const id = this.getNodeParameter('regionId', i);
+                        const preferredLanguages = this.getNodeParameter('preferredLanguages', i, '');
+                        result = await client.regions.translations(id, preferredLanguages ? { preferredLanguages } : undefined);
+                    }
+                }
+                else if (resource === 'language') {
+                    if (operation === 'list') {
+                        const limit = this.getNodeParameter('limit', i);
+                        const offset = this.getNodeParameter('offset', i);
+                        result = await client.languages.list({ limit, offset });
+                    }
+                    else if (operation === 'get') {
+                        const id = this.getNodeParameter('languageId', i);
+                        result = await client.languages.get(id);
+                    }
+                }
+                if (result === undefined) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation "${operation}" for resource "${resource}"`, { itemIndex: i });
+                }
+                const items = Array.isArray(result) ? result : [result];
+                for (const item of items) {
+                    returnData.push({ json: item, pairedItem: { item: i } });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Geomelon = Geomelon;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "n8n-nodes-geomelon",
+  "version": "1.0.0",
+  "description": "n8n community node for the Geomelon geographic API — cities, countries, regions, and languages with multilingual support",
+  "keywords": [
+    "n8n-community-node-package",
+    "geomelon",
+    "geography",
+    "cities",
+    "countries",
+    "geocoding"
+  ],
+  "license": "MIT",
+  "homepage": "https://geomelon.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/930m310n/n8n-nodes-geomelon.git"
+  },
+  "bugs": {
+    "url": "https://github.com/930m310n/n8n-nodes-geomelon/issues"
+  },
+  "author": {
+    "name": "Geomelon"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/GeomelonApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Geomelon/Geomelon.node.js"
+    ]
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "geomelon": "^1.0.7"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "n8n-workflow": "^1.120.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}