symone-sdk 1.0.0

package/README.md

@@ -0,0 +1,54 @@
+# symone-sdk
+
+JavaScript SDK for the [SYMONE](https://symone.fr) motorcycle transport API.
+
+SYMONE is Europe's first long-distance motorcycle highway transport service. This SDK lets you search available routes between French cities (Paris, Marseille, Lyon, Nice, etc.).
+
+**No authentication required.**
+
+## Install
+
+```bash
+npm install symone-sdk
+```
+
+## Usage
+
+```javascript
+const { searchRoutes, filterRoutes, getParisMarseilleCache } = require('symone-sdk');
+
+// Get all upcoming routes
+const routes = await searchRoutes();
+
+// Filter Paris → Marseille
+const results = filterRoutes(routes, { depart: 'Paris', arrival: 'Marseille' });
+console.log(results);
+
+// Fast cache for Paris–Marseille
+const cache = await getParisMarseilleCache();
+console.log(cache.trajetIds);
+```
+
+## API
+
+### `searchRoutes()`
+Returns all upcoming motorcycle transport routes in France as a JSON array.
+
+### `filterRoutes(routes, options)`
+Filter results client-side.
+- `options.depart` — departure city name (e.g. `"Paris"`)
+- `options.arrival` — arrival city name (e.g. `"Marseille"`)
+- `options.date` — date in `YYYYMMDD` format
+
+### `getParisMarseilleCache()`
+Fast cached endpoint returning available Paris–Marseille route IDs.
+
+### `getCitiesNear(location)`
+Find SYMONE-served cities near a location name.
+
+## Links
+
+- Website: https://symone.fr
+- API docs: https://symone.fr/api/index.md
+- OpenAPI spec: https://symone.fr/openapi.json
+- Pricing: https://symone.fr/pricing.md

package/index.d.ts

@@ -0,0 +1,34 @@
+export interface Route {
+  type: 'route' | 'event';
+  id: number;
+  depart: string;
+  arrival: string;
+  date: string;
+  price_min: number;
+  price_max: number;
+  places_moto_1: number;
+  places_passenger_1: number;
+  time0: string;
+  time4: string;
+  layover1?: string;
+  layover2?: string;
+  completed: number;
+  draft: number;
+}
+
+export interface ParisMarseilleCache {
+  trajetIds: number[];
+  cacheDate: string;
+  updatedAt: string;
+}
+
+export interface FilterOptions {
+  depart?: string;
+  arrival?: string;
+  date?: string;
+}
+
+export function searchRoutes(): Promise<Route[]>;
+export function getParisMarseilleCache(): Promise<ParisMarseilleCache>;
+export function getCitiesNear(location: string): Promise<any[]>;
+export function filterRoutes(routes: Route[], options?: FilterOptions): Route[];

package/index.js

@@ -0,0 +1,54 @@
+const BASE_URL = 'https://symone.fr/api-proxy';
+
+/**
+ * Search all upcoming motorcycle transport routes in France.
+ * Returns a full list — filter client-side by depart/arrival/date.
+ * @returns {Promise<Array>} Array of route objects
+ */
+async function searchRoutes() {
+  const res = await fetch(`${BASE_URL}/route/get/results`);
+  if (!res.ok) throw new Error(`SYMONE API error: ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Get cached Paris–Marseille route IDs (fast).
+ * @returns {Promise<Object>} { trajetIds, cacheDate }
+ */
+async function getParisMarseilleCache() {
+  const res = await fetch(`${BASE_URL}/route/paris-marseille-cache`);
+  if (!res.ok) throw new Error(`SYMONE API error: ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Find SYMONE-served cities near a location.
+ * @param {string} location - City name (e.g. "Paris")
+ * @returns {Promise<Array>}
+ */
+async function getCitiesNear(location) {
+  const res = await fetch(`${BASE_URL}/route/cities-near?location=${encodeURIComponent(location)}`);
+  if (!res.ok) throw new Error(`SYMONE API error: ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Filter routes by departure and/or arrival city.
+ * @param {Array} routes - Result from searchRoutes()
+ * @param {Object} options
+ * @param {string} [options.depart] - Departure city name
+ * @param {string} [options.arrival] - Arrival city name
+ * @param {string} [options.date] - Date in YYYYMMDD format
+ * @returns {Array}
+ */
+function filterRoutes(routes, { depart, arrival, date } = {}) {
+  return routes.filter(r => {
+    if (r.type !== 'route') return false;
+    if (depart && r.depart !== depart) return false;
+    if (arrival && r.arrival !== arrival) return false;
+    if (date && r.date !== date) return false;
+    return true;
+  });
+}
+
+module.exports = { searchRoutes, getParisMarseilleCache, getCitiesNear, filterRoutes };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "symone-sdk",
+  "version": "1.0.0",
+  "description": "JavaScript SDK for the SYMONE motorcycle transport API. Search available routes between French cities. No authentication required.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": [
+    "symone",
+    "motorcycle",
+    "transport",
+    "moto",
+    "france",
+    "api",
+    "sdk",
+    "paris",
+    "marseille",
+    "route",
+    "travel"
+  ],
+  "author": "SYMONE SAS <contact@symone.fr> (https://symone.fr)",
+  "license": "MIT",
+  "homepage": "https://symone.fr/api/index.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/silen4-zg/symone-skills.git"
+  },
+  "bugs": {
+    "email": "contact@symone.fr"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}