@ridesafety/sdk 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# RideSafety JS/TS SDK
+
+## Install
+
+```bash
+pnpm add @ridesafety/sdk
+```
+
+## Build & publish
+
+```bash
+cd sdk/js
+npm install
+npm run build
+npm login
+npm publish --access public
+```
+
+## Usage
+
+```ts
+import { RideSafetyClient } from "@ridesafety/sdk"
+
+const client = new RideSafetyClient({
+  apiKey: process.env.RIDESAFETY_API_KEY!,
+  baseUrl: "https://ridesafety.app",
+})
+
+const recalls = await client.getRecalls({ vin: "1HGBH41JXMN109186" })
+const diagnostics = await client.runDiagnostics({
+  vin: "1HGBH41JXMN109186",
+  symptoms: "Rough idle and engine misfire",
+  dtc_codes: ["P0300"],
+})
+const safety = await client.getSafetyRatings({ make: "Honda", model: "Civic", year: 2020 })
+```
+
+## Auth modes
+
+By default the SDK uses `Authorization: Bearer <key>`. To use `x-api-key` instead:
+
+```ts
+const client = new RideSafetyClient({ apiKey, authMode: "x-api-key" })
+```

package/dist/index.d.ts

@@ -0,0 +1,141 @@
+export type RecallsQuery = {
+    vin?: string;
+    make?: string;
+    model?: string;
+    year?: string | number;
+    limit?: number;
+    offset?: number;
+};
+export type DiagnosticsRequest = {
+    vin: string;
+    symptoms?: string;
+    dtc_codes?: string[];
+};
+export type SafetyRatingsQuery = {
+    make: string;
+    model: string;
+    year: string | number;
+};
+export type RecallsResponse = {
+    vehicle: {
+        vin: string | null;
+        make: string | null;
+        model: string | null;
+        year: number | null;
+    };
+    recalls: Array<{
+        id: string | null;
+        title: string;
+        description: string;
+        severity: "Low" | "Medium" | "High";
+        date_issued: string | null;
+        status: string;
+        component: string | null;
+        remedy: string | null;
+        consequence: string | null;
+        summary: string | null;
+    }>;
+    total_recalls: number;
+    pagination: {
+        limit: number;
+        offset: number;
+        total: number;
+        hasMore: boolean;
+    };
+    meta: {
+        timestamp: string;
+        version: string;
+        source: string;
+    };
+};
+export type DiagnosticsResponse = {
+    data: {
+        vin: string;
+        diagnosis: {
+            primary_issue: string;
+            confidence: number;
+            severity: string;
+            estimated_cost: {
+                min: number;
+                max: number;
+                currency: string;
+            };
+            recommended_actions: string[];
+        };
+        related_recalls: Array<{
+            recall_id: string;
+            title: string;
+            severity: string;
+            affected_components: string[];
+        }>;
+        dtc_analysis: Array<{
+            code: string;
+            description: string;
+            severity: string;
+        }>;
+        timestamp: string;
+    };
+    meta: {
+        timestamp: string;
+        version: string;
+        processing_time_ms: number;
+    };
+};
+export type SafetyRatingsResponse = {
+    data: {
+        vehicle: {
+            make: string;
+            model: string;
+            year: number;
+        };
+        nhtsa_rating: {
+            overall: number;
+            frontal_crash: number;
+            side_crash: number;
+            rollover: number;
+            last_updated: string;
+        };
+        iihs_rating: {
+            top_safety_pick: boolean;
+            top_safety_pick_plus: boolean;
+            awards: string[];
+            tests: Record<string, string>;
+        };
+        safety_features: string[];
+        recalls_summary: {
+            total_recalls: number;
+            open_recalls: number;
+            last_recall_date: string;
+        };
+    };
+    meta: {
+        timestamp: string;
+        version: string;
+        data_sources: string[];
+    };
+};
+export declare class RideSafetyError extends Error {
+    status: number;
+    details?: unknown;
+    constructor(status: number, message: string, details?: unknown);
+}
+export type RideSafetyClientOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    authMode?: "bearer" | "x-api-key";
+    fetchImpl?: typeof fetch;
+};
+export declare class RideSafetyClient {
+    private apiKey;
+    private baseUrl;
+    private timeoutMs;
+    private authMode;
+    private fetchImpl;
+    constructor(options: RideSafetyClientOptions);
+    getRecalls(params: RecallsQuery): Promise<RecallsResponse>;
+    runDiagnostics(body: DiagnosticsRequest): Promise<DiagnosticsResponse>;
+    getSafetyRatings(params: SafetyRatingsQuery): Promise<SafetyRatingsResponse>;
+    private buildHeaders;
+    private request;
+}

package/dist/index.js

@@ -0,0 +1,91 @@
+export class RideSafetyError extends Error {
+    constructor(status, message, details) {
+        super(message);
+        this.name = "RideSafetyError";
+        this.status = status;
+        this.details = details;
+    }
+}
+export class RideSafetyClient {
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl || "https://ridesafety.app").replace(/\/$/, "");
+        this.timeoutMs = options.timeoutMs ?? 20000;
+        this.authMode = options.authMode ?? "bearer";
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async getRecalls(params) {
+        return this.request("/api/v1/recalls", {
+            method: "GET",
+            query: params,
+        });
+    }
+    async runDiagnostics(body) {
+        return this.request("/api/v1/diagnostics", {
+            method: "POST",
+            body,
+        });
+    }
+    async getSafetyRatings(params) {
+        return this.request("/api/v1/safety-ratings", {
+            method: "GET",
+            query: params,
+        });
+    }
+    buildHeaders() {
+        const headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+        if (this.authMode === "x-api-key") {
+            headers["x-api-key"] = this.apiKey;
+        }
+        else {
+            headers.Authorization = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+    async request(path, options) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (options.query) {
+            Object.entries(options.query).forEach(([key, value]) => {
+                if (value === undefined || value === null || value === "")
+                    return;
+                url.searchParams.set(key, String(value));
+            });
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            response = await this.fetchImpl(url.toString(), {
+                method: options.method,
+                headers: this.buildHeaders(),
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        const text = await response.text();
+        const data = text ? tryParseJson(text) : null;
+        if (!response.ok) {
+            const message = data?.error || response.statusText || "Request failed";
+            throw new RideSafetyError(response.status, message, data);
+        }
+        return (data ?? {});
+    }
+}
+function tryParseJson(payload) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch {
+        return payload;
+    }
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@ridesafety/sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4"
+  }
+}