@obniz/obniz-now-sdk 0.1.0 → 0.1.10

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 obniz
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -3,6 +3,190 @@
 TypeScript/JavaScript SDK for Obniz Now API
 
 ## Installation
+```bash
+npm install @obniz/obniz-now-sdk-js
+```
+
+## Authentication
+
+The SDK supports authentication using an API token (Bearer token). You can obtain your API token from your [Obniz account settings](https://obniz.com/).
+
+### Using API Token
+```typescript
+import { ObnizNow } from '@obniz/sdk';
+
+const client = new ObnizNow({ 
+  token: 'your-api-token-here'
+});
+```
+
+### Using Environment Variables (Recommended)
+```typescript
+const client = new ObnizNow({ 
+  token: process.env.OBNIZ_NOW_TOKEN
+});
+```
+
+## Basic Usage
+
+### List Machines
+
+```typescript
+import { ObnizNow } from '@obniz/obniz-now-sdk-js';
+
+const client = new ObnizNow({ token: process.env.OBNIZ_TOKEN });
+
+// Get list of machines
+const response = await client.machines.listMachines({ 
+  limit: 10,
+  offset: 0 
+});
+
+console.log(`Found ${response.count} machines`);
+response.items.forEach((item) => {
+  console.log(`- ${item.machine.name} (${item.machine.id})`);
+});
+```
+
+### Get Machine Details
+```typescript
+// Get specific machine
+const machine = await client.machine.getMachine({ 
+  machineId: 'machine-id' 
+});
+
+console.log(`Name: ${machine.name}`);
+console.log(`Created: ${machine.createdAt}`);
+```
+
+### Get Events
+```typescript
+// Get recent events
+const events = await client.events.listEvents({
+  from: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+  to: new Date().toISOString(),
+  limit: 20
+});
+
+console.log(`Found ${events.count} events`);
+```
+
+## Error Handling
+
+All API errors are automatically converted to `ObnizNowApiError` with parsed response data.
+
+```typescript
+import { ObnizNow, ObnizNowApiError } from '@obniz/obniz-now-sdk-js';
+
+try {
+  const machine = await client.machine.getMachine({ machineId: 'invalid-id' });
+} catch (error) {
+  if (error instanceof ObnizNowApiError) {
+    console.error(`Error ${error.status}: ${error.message}`);
+    console.error('Details:', error.data);
+    
+    // Access response headers
+    const headers = error.getResponseHeaders();
+    const rateLimit = headers.get('x-ratelimit-remaining');
+    
+    // Get request URL for debugging
+    console.error('Failed request:', error.getRequestUrl());
+  }
+}
+```
+
+## Browser Usage (Svelte)
 
+### ⚠️ Security Warning
+**Never expose your API token in client-side code!** Use one of these safe approaches:
+
+### Option 1: Cookie-based Authentication (Recommended)
+```typescript
+// In your Svelte component
+import { ObnizNow } from '@obniz/obniz-now-sdk-js';
+
+const client = new ObnizNow({
+  cookies: {
+    token: getCookie('token'),
+    accountId: getCookie('account_id'),
+  },
+});
+
+function getCookie(name: string): string {
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) return parts.pop()?.split(';').shift() || '';
+  return '';
+}
+```
+
+Your backend should set httpOnly cookies after user authentication.
+
+### Option 2: Backend Proxy
+```typescript
+// Frontend - call your backend API
+const machines = await fetch('/api/obniz/machines').then(r => r.json());
+
+// Backend (Node.js) - proxy to Obniz API
+app.get('/api/obniz/machines', async (req, res) => {
+  const client = new ObnizNow({ token: process.env.OBNIZ_TOKEN });
+  const data = await client.machines.listMachines({ limit: 20 });
+  res.json(data);
+});
+```
+
+### SvelteKit Server-Side Example
+```typescript
+// src/routes/+page.server.ts
+import { ObnizNow } from '@obniz/sdk';
+
+export async function load() {
+  const client = new ObnizNow({ token: process.env.OBNIZ_TOKEN });
+  const machines = await client.machines.listMachines({ limit: 20 });
+  
+  return { machines: machines.items };
+}
+```
+
+```svelte
+<!-- src/routes/+page.svelte -->
+<script lang="ts">
+  export let data;
+</script>
+
+<h1>Machines</h1>
+<ul>
+  {#each data.machines as item}
+    <li>{item.machine.name}</li>
+  {/each}
+</ul>
+```
+
+## Examples
+See the examples/ directory for more detailed examples:
+
+`basic-usage.ts` - SDK initialization and basic operations
+
+`analytics.ts` - Working with analytics
+
+`events.ts` - Retrieving and filtering events
+
+`machine-management.ts` - CRUD operations
+
+`custom-config.ts` - Advanced configuration (retry, logging)
+
+`advanced-error-handling.ts` - Error inspection and debugging
+
+### Run any example:
 ```bash
-npm install @obniz/obniz-now-sdk
+npx tsx examples/basic-usage.ts
+```
+
+# Requirements
+Node.js >= 18.0.0
+
+# Links
+Website: 
+https://iot.obniz.com
+
+API documentation: https://now.obniz.com/api/1/docs/

package/dist/ObnizNowApiError.d.ts

@@ -1,16 +1,13 @@
 import { ResponseError } from "./sdk-core/runtime";
 /**
- * Enhanced API error with automatically parsed response data
- *
- * All API methods automatically convert ResponseError to ObnizApiError,
- * so you get parsed error information without manual handling.
+ * All API methods automatically convert ResponseError to ObnizApiError
  *
  * @example
  * ```typescript
  * try {
  *   await client.machines.getMachine({ id: 'invalid-id' });
  * } catch (error) {
- *   if (error instanceof ObnizApiError) {
+ *   if (error instanceof ObnizNowApiError) {
  *     console.error(`API Error [${error.status}]: ${error.message}`);
  *     console.error('Error data:', error.data);
  *   }
@@ -28,7 +25,7 @@ export declare class ObnizNowApiError extends Error {
     readonly originalError: ResponseError;
     constructor(responseError: ResponseError, status: number, statusText: string, data: any);
     /**
-     * Create ObnizApiError from ResponseError by parsing the response
+     * Create ObnizNowApiError from ResponseError by parsing the response
      */
     static fromResponseError(error: ResponseError): Promise<ObnizNowApiError>;
     /**
@@ -57,6 +54,6 @@ export declare class ObnizNowApiError extends Error {
     };
 }
 /**
- * Wraps an API object to automatically convert ResponseError to ObnizApiError
+ * Wraps an API object to automatically convert ResponseError to ObnizNowApiError
  */
 export declare function wrapApiWithErrorHandling<T extends object>(api: T): T;

package/dist/index.d.ts

@@ -1,2 +1 @@
 export * from "./ObnizNow";
-export { ObnizNowApiError } from "./ObnizNowApiError";

package/dist/index.js

@@ -2267,6 +2267,38 @@ class NotificationsApi extends BaseAPI {
     async deleteNotification(requestParameters, initOverrides) {
         await this.deleteNotificationRaw(requestParameters, initOverrides);
     }
+    /**
+     * Retrieves the send history for a specific notification destination with pagination  **Authorization** - API token is required in the `Authorization` header  **Permissions** - `notifications:read` permission is required
+     * Get notification history
+     */
+    async listNotificationHistoryRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new RequiredError('id', 'Required parameter "id" was null or undefined when calling listNotificationHistory().');
+        }
+        const queryParameters = {};
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+        const headerParameters = {};
+        const response = await this.request({
+            path: `/api/1/notifications/{id}/history`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new JSONApiResponse(response);
+    }
+    /**
+     * Retrieves the send history for a specific notification destination with pagination  **Authorization** - API token is required in the `Authorization` header  **Permissions** - `notifications:read` permission is required
+     * Get notification history
+     */
+    async listNotificationHistory(requestParameters, initOverrides) {
+        const response = await this.listNotificationHistoryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Retrieves notification destinations within the account with pagination  **Authorization** - API token is required in the `Authorization` header  **Permissions** - `notifications:read` permission is required
      * Get notifications list
@@ -2312,6 +2344,7 @@ class NotificationsApi extends BaseAPI {
         }
         const queryParameters = {};
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiToken authentication
         }
@@ -2320,6 +2353,7 @@ class NotificationsApi extends BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: requestParameters['testNotificationRequest'],
         }, initOverrides);
         return new JSONApiResponse(response);
     }
@@ -2331,6 +2365,39 @@ class NotificationsApi extends BaseAPI {
         const response = await this.testNotificationRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Updates the title/body templates for a notification destination. Templates support {:key} placeholders that are dynamically replaced when sending notifications. Set to null to clear the template and use the controller-generated values as-is.  **Authorization** - API token is required in the `Authorization` header  **Permissions** - `notifications:write` permission is required
+     * Update notification template
+     */
+    async updateNotificationTemplateRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new RequiredError('id', 'Required parameter "id" was null or undefined when calling updateNotificationTemplate().');
+        }
+        if (requestParameters['updateNotificationTemplateRequest'] == null) {
+            throw new RequiredError('updateNotificationTemplateRequest', 'Required parameter "updateNotificationTemplateRequest" was null or undefined when calling updateNotificationTemplate().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiToken authentication
+        }
+        const response = await this.request({
+            path: `/api/1/notifications/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters['updateNotificationTemplateRequest'],
+        }, initOverrides);
+        return new VoidApiResponse(response);
+    }
+    /**
+     * Updates the title/body templates for a notification destination. Templates support {:key} placeholders that are dynamically replaced when sending notifications. Set to null to clear the template and use the controller-generated values as-is.  **Authorization** - API token is required in the `Authorization` header  **Permissions** - `notifications:write` permission is required
+     * Update notification template
+     */
+    async updateNotificationTemplate(requestParameters, initOverrides) {
+        await this.updateNotificationTemplateRaw(requestParameters, initOverrides);
+    }
 }
 
 /* tslint:disable */
@@ -3152,128 +3219,6 @@ class UnitsApi extends BaseAPI {
     }
 }
 
-/**
- * Enhanced API error with automatically parsed response data
- *
- * All API methods automatically convert ResponseError to ObnizApiError,
- * so you get parsed error information without manual handling.
- *
- * @example
- * ```typescript
- * try {
- *   await client.machines.getMachine({ id: 'invalid-id' });
- * } catch (error) {
- *   if (error instanceof ObnizApiError) {
- *     console.error(`API Error [${error.status}]: ${error.message}`);
- *     console.error('Error data:', error.data);
- *   }
- * }
- * ```
- */
-class ObnizNowApiError extends Error {
-    constructor(responseError, status, statusText, data) {
-        const message = data?.error || data?.message || statusText || `HTTP ${status}`;
-        super(message);
-        this.name = "ObnizApiError";
-        this.status = status;
-        this.statusText = statusText;
-        this.data = data;
-        // Store originalError as non-enumerable property to keep it out of console.log
-        // but still accessible for advanced use cases
-        Object.defineProperty(this, 'originalError', {
-            value: responseError,
-            writable: false,
-            enumerable: false, // Не будет засирать console.log!
-            configurable: false
-        });
-        // Maintain proper stack trace (ES2015+)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, ObnizNowApiError);
-        }
-    }
-    /**
-     * Create ObnizApiError from ResponseError by parsing the response
-     */
-    static async fromResponseError(error) {
-        const status = error.response.status;
-        const statusText = error.response.statusText;
-        let data;
-        try {
-            // Try to parse as JSON
-            const text = await error.response.text();
-            data = JSON.parse(text);
-        }
-        catch {
-            // If not JSON, wrap as error object
-            try {
-                data = { error: await error.response.text() };
-            }
-            catch {
-                data = { error: statusText };
-            }
-        }
-        return new ObnizNowApiError(error, status, statusText, data);
-    }
-    /**
-     * Get response headers (useful for rate limiting, caching, etc.)
-     *
-     * @example
-     * ```typescript
-     * const rateLimit = error.getResponseHeaders().get('x-ratelimit-remaining');
-     * ```
-     */
-    getResponseHeaders() {
-        return this.originalError.response.headers;
-    }
-    /**
-     * Get full request URL
-     */
-    getRequestUrl() {
-        return this.originalError.response.url;
-    }
-    /**
-     * Control JSON serialization - don't include originalError
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            status: this.status,
-            statusText: this.statusText,
-            data: this.data,
-            stack: this.stack,
-        };
-    }
-}
-/**
- * Wraps an API object to automatically convert ResponseError to ObnizApiError
- */
-function wrapApiWithErrorHandling(api) {
-    return new Proxy(api, {
-        get(target, prop) {
-            const original = target[prop];
-            // Only wrap functions
-            if (typeof original !== 'function') {
-                return original;
-            }
-            // Return wrapped function that auto-converts errors
-            return async function (...args) {
-                try {
-                    return await original.apply(this, args);
-                }
-                catch (error) {
-                    // Convert ResponseError to ObnizApiError
-                    if (error instanceof ResponseError) {
-                        throw await ObnizNowApiError.fromResponseError(error);
-                    }
-                    // Re-throw other errors as-is
-                    throw error;
-                }
-            };
-        }
-    });
-}
-
 /**
  * ObnizNow SDK main class
  *
@@ -3354,26 +3299,24 @@ class ObnizNow {
             fetchApi: customFetch || fetchApi,
             credentials: cookies ? "include" : undefined,
         });
-        // Wrap all APIs with automatic error handling
-        this.analytics = wrapApiWithErrorHandling(new AnalyticsApi(config));
-        this.connectionModels = wrapApiWithErrorHandling(new ConnectionModelsApi(config));
-        this.connections = wrapApiWithErrorHandling(new ConnectionsApi(config));
-        this.events = wrapApiWithErrorHandling(new EventsApi(config));
-        this.groups = wrapApiWithErrorHandling(new GroupsApi(config));
-        this.inboundConnections = wrapApiWithErrorHandling(new InboundConnectionsApi(config));
-        this.inboundSources = wrapApiWithErrorHandling(new InboundSourcesApi(config));
-        this.integrations = wrapApiWithErrorHandling(new IntegrationsApi(config));
-        this.intelligences = wrapApiWithErrorHandling(new IntelligencesApi(config));
-        this.issues = wrapApiWithErrorHandling(new IssuesApi(config));
-        this.machine = wrapApiWithErrorHandling(new MachineApi(config));
-        this.machines = wrapApiWithErrorHandling(new MachinesApi(config));
-        this.notifications = wrapApiWithErrorHandling(new NotificationsApi(config));
-        this.reports = wrapApiWithErrorHandling(new ReportsApi(config));
-        this.threads = wrapApiWithErrorHandling(new ThreadsApi(config));
-        this.units = wrapApiWithErrorHandling(new UnitsApi(config));
+        this.analytics = new AnalyticsApi(config);
+        this.connectionModels = new ConnectionModelsApi(config);
+        this.connections = new ConnectionsApi(config);
+        this.events = new EventsApi(config);
+        this.groups = new GroupsApi(config);
+        this.inboundConnections = new InboundConnectionsApi(config);
+        this.inboundSources = new InboundSourcesApi(config);
+        this.integrations = new IntegrationsApi(config);
+        this.intelligences = new IntelligencesApi(config);
+        this.issues = new IssuesApi(config);
+        this.machine = new MachineApi(config);
+        this.machines = new MachinesApi(config);
+        this.notifications = new NotificationsApi(config);
+        this.reports = new ReportsApi(config);
+        this.threads = new ThreadsApi(config);
+        this.units = new UnitsApi(config);
     }
 }
 
 exports.ObnizNow = ObnizNow;
-exports.ObnizNowApiError = ObnizNowApiError;
 //# sourceMappingURL=index.js.map