@hello.nrfcloud.com/nrfcloud-api-helpers 6.0.466 → 6.0.468

package/npm/api/DeviceShadow.js

@@ -0,0 +1,32 @@
+import { Type } from '@sinclair/typebox';
+/**
+ * @link https://api.nrfcloud.com/v1/#tag/All-Devices/operation/ListDevices
+ */ export const DeviceShadow = Type.Object({
+    id: Type.String(),
+    $meta: Type.Object({
+        createdAt: Type.String({
+            minLength: 1,
+            examples: [
+                '2019-08-24T14:15:22Z'
+            ]
+        }),
+        updatedAt: Type.Optional(Type.String({
+            minLength: 1,
+            examples: [
+                '2019-08-24T14:15:22Z'
+            ]
+        }))
+    }),
+    state: Type.Optional(Type.Object({
+        reported: Type.Optional(Type.Record(Type.String({
+            minLength: 1
+        }), Type.Any())),
+        desired: Type.Optional(Type.Record(Type.String({
+            minLength: 1
+        }), Type.Any())),
+        version: Type.Number(),
+        metadata: Type.Record(Type.String({
+            minLength: 1
+        }), Type.Any())
+    }))
+});

package/npm/api/FetchError.js

@@ -0,0 +1,9 @@
+export class FetchError extends Error {
+    statusCode;
+    constructor(statusCode, message){
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'FetchError';
+    }
+}
+export const toFetchError = async (response)=>new FetchError(response.status, parseInt(response.headers.get('content-length') ?? '0', 10) > 0 ? await response.text() : 'No content returned from server');

package/npm/{src/api → api}/bulkOps.d.ts

@@ -1,4 +1,3 @@
-import { type Static } from '@sinclair/typebox';
 import type { FetchError } from './FetchError.ts';
 import { type ValidationError } from './validatedFetch.ts';
 /**
@@ -11,8 +10,11 @@ export declare const BulkOpsRequestType: import("@sinclair/typebox").TObject<{
 export declare const bulkOpsRequests: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => (bulkOpsId: string) => Promise<{
+}, fetchImplementation?: typeof fetch | undefined) => (bulkOpsId: string) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: Static<typeof BulkOpsRequestType>;
+    result: {
+        bulkOpsRequestId: string;
+        status: "FAILED" | "IN_PROGRESS" | "PENDING" | "SUCCEEDED";
+    };
 }>;

package/npm/api/bulkOps.js

@@ -0,0 +1,22 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+/**
+ * @link https://api.nrfcloud.com/v1/#tag/Bulk-Ops-Requests/operation/FetchBulkOpsRequest
+ */ export const BulkOpsRequestType = Type.Object({
+    bulkOpsRequestId: Type.String(),
+    status: Type.Union([
+        Type.Literal('PENDING'),
+        Type.Literal('IN_PROGRESS'),
+        Type.Literal('FAILED'),
+        Type.Literal('SUCCEEDED')
+    ])
+});
+export const bulkOpsRequests = ({ apiKey, endpoint }, fetchImplementation)=>async (bulkOpsId)=>{
+        const vf = validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation);
+        return vf({
+            resource: `bulk-ops-requests/${encodeURIComponent(bulkOpsId)}`
+        }, BulkOpsRequestType);
+    };

package/npm/{src/api → api}/cancelFOTAJob.d.ts

@@ -3,7 +3,7 @@ import type { ValidationError } from './validatedFetch.ts';
 export declare const cancelFOTAJob: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => (jobId: string) => Promise<{
+}, fetchImplementation?: typeof fetch | undefined) => (jobId: string) => Promise<{
     error: FetchError | ValidationError;
 } | {
     success: true;

package/npm/api/cancelFOTAJob.js

@@ -0,0 +1,15 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+export const cancelFOTAJob = ({ apiKey, endpoint }, fetchImplementation)=>async (jobId)=>{
+        const maybeSuccess = await validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation)({
+            resource: `fota-jobs/${jobId}/cancel`,
+            method: 'PUT'
+        }, Type.Any());
+        if ('error' in maybeSuccess) return maybeSuccess;
+        return {
+            success: true
+        };
+    };

package/npm/api/createAccountDevice.d.ts

@@ -0,0 +1,7 @@
+export declare const createAccountDevice: ({ apiKey, endpoint, }: {
+    apiKey: string;
+    endpoint: URL;
+}) => Promise<{
+    clientCert: string;
+    privateKey: string;
+}>;

package/npm/api/createAccountDevice.js

@@ -0,0 +1,25 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+/**
+ * @link https://api.nrfcloud.com/v1/#tag/Account-Devices/operation/CreateAccountDevice
+ */ const CertificateCredentials = Type.Object({
+    clientCert: Type.String(),
+    privateKey: Type.String()
+});
+export const createAccountDevice = async ({ apiKey, endpoint })=>{
+    const vf = validatedFetch({
+        endpoint,
+        apiKey
+    });
+    const maybeResult = await vf({
+        resource: 'devices/account',
+        method: 'POST'
+    }, CertificateCredentials);
+    if ('error' in maybeResult) {
+        throw maybeResult.error;
+    }
+    return {
+        clientCert: maybeResult.result.clientCert,
+        privateKey: maybeResult.result.privateKey
+    };
+};

package/npm/{src/api → api}/createFOTAJob.d.ts

@@ -1,4 +1,3 @@
-import { type Static } from '@sinclair/typebox';
 import type { FetchError } from './FetchError.ts';
 import type { ValidationError } from './validatedFetch.ts';
 export declare const CreateFOTAJobType: import("@sinclair/typebox").TObject<{
@@ -7,11 +6,13 @@ export declare const CreateFOTAJobType: import("@sinclair/typebox").TObject<{
 export declare const createFOTAJob: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => ({ deviceId, bundleId, }: {
+}, fetchImplementation?: typeof fetch | undefined) => ({ deviceId, bundleId, }: {
     deviceId: string;
     bundleId: string;
 }) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: Static<typeof CreateFOTAJobType>;
+    result: {
+        jobId: string;
+    };
 }>;

package/npm/api/createFOTAJob.js

@@ -0,0 +1,32 @@
+import { Type } from '@sinclair/typebox';
+import { JSONPayload, validatedFetch } from './validatedFetch.js';
+export const CreateFOTAJobType = Type.Object({
+    jobId: Type.String({
+        minLength: 1,
+        title: 'ID',
+        description: 'Universally unique identifier',
+        examples: [
+            'bc631093-7f7c-4c1b-aa63-a68c759bcd5c'
+        ]
+    })
+}, {
+    title: 'FOTA Job',
+    description: 'See https://api.nrfcloud.com/#tag/FOTA-Jobs/operation/CreateFOTAJob'
+});
+export const createFOTAJob = ({ apiKey, endpoint }, fetchImplementation)=>async ({ deviceId, bundleId })=>{
+        const maybeJob = await validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation)({
+            resource: 'fota-jobs',
+            payload: JSONPayload({
+                bundleId,
+                autoApply: true,
+                deviceIdentifiers: [
+                    deviceId
+                ]
+            })
+        }, CreateFOTAJobType);
+        if ('error' in maybeJob) return maybeJob;
+        return maybeJob;
+    };

package/npm/api/deleteAccountDevice.js

@@ -0,0 +1,9 @@
+import { slashless } from './slashless.js';
+export const deleteAccountDevice = async ({ apiKey, endpoint })=>{
+    await fetch(`${slashless(endpoint)}/v1/devices/account`, {
+        method: 'DELETE',
+        headers: {
+            Authorization: `Bearer ${apiKey}`
+        }
+    });
+};

package/npm/api/devices.d.ts

@@ -0,0 +1,98 @@
+import type { FetchError } from './FetchError.ts';
+import { type ValidationError } from './validatedFetch.ts';
+/**
+ * firmware types supported by a device for FOTA
+ */
+export declare enum FwType {
+    APP = "APP",
+    MODEM = "MODEM",
+    BOOT = "BOOT",
+    SOFTDEVICE = "SOFTDEVICE",
+    BOOTLOADER = "BOOTLOADER",
+    MDM_FULL = "MDM_FULL"
+}
+export declare const devices: ({ endpoint, apiKey, }: {
+    endpoint: URL;
+    apiKey: string;
+}, fetchImplementation?: typeof fetch | undefined) => {
+    list: () => Promise<{
+        error: FetchError | ValidationError;
+    } | {
+        result: {
+            total: number;
+            items: {
+                id: string;
+                $meta: {
+                    createdAt: string;
+                    updatedAt?: string | undefined;
+                };
+                state?: {
+                    reported?: {
+                        [x: string]: any;
+                    } | undefined;
+                    desired?: {
+                        [x: string]: any;
+                    } | undefined;
+                    version: number;
+                    metadata: {
+                        [x: string]: any;
+                    };
+                } | undefined;
+            }[];
+        };
+    }>;
+    get: (id: string) => Promise<{
+        error: FetchError | ValidationError;
+    } | {
+        result: {
+            id: string;
+            $meta: {
+                createdAt: string;
+                updatedAt?: string | undefined;
+            };
+            state?: {
+                reported?: {
+                    [x: string]: any;
+                } | undefined;
+                desired?: {
+                    [x: string]: any;
+                } | undefined;
+                version: number;
+                metadata: {
+                    [x: string]: any;
+                };
+            } | undefined;
+        };
+    }>;
+    updateState: (id: string, state: {
+        desired?: Record<string, any> | undefined;
+        reported?: Record<string, any> | undefined;
+    }) => Promise<{
+        error: FetchError | ValidationError;
+    } | {
+        success: boolean;
+    }>;
+    register: (devices: {
+        deviceId: string;
+        certPem: string;
+        subType?: string | undefined;
+        tags?: string[] | undefined;
+        /**
+         * A list of pipe-delimited firmware types that each device supports for FOTA (e.g., APP|MODEM)
+         *
+         * Defaults to all supported (APP|MODEM|BOOT|SOFTDEVICE|BOOTLOADER|MDM_FULL)
+         *
+         * @default 'APP|MODEM|BOOT|SOFTDEVICE|BOOTLOADER|MDM_FULL'
+         */
+        fwTypes?: FwType[] | undefined;
+    }[]) => Promise<{
+        error: FetchError | ValidationError;
+    } | {
+        bulkOpsRequestId: string;
+    }>;
+    remove: (deviceId: string) => Promise<{
+        error: FetchError | ValidationError;
+    } | {
+        success: boolean;
+    }>;
+};

package/npm/api/devices.js

@@ -0,0 +1,98 @@
+import { Type } from '@sinclair/typebox';
+import { DeviceShadow } from './DeviceShadow.js';
+import { toFetchError } from './FetchError.js';
+import { slashless } from './slashless.js';
+import { validatedFetch } from './validatedFetch.js';
+const Page = (Item)=>Type.Object({
+        total: Type.Integer(),
+        items: Type.Array(Item)
+    });
+const Devices = Page(DeviceShadow);
+/**
+ * @link https://api.nrfcloud.com/v1/#tag/IP-Devices/operation/ProvisionDevices
+ */ const ProvisionDevice = Type.Object({
+    bulkOpsRequestId: Type.String()
+});
+/**
+ * firmware types supported by a device for FOTA
+ */ export var FwType = /*#__PURE__*/ function(FwType) {
+    FwType["APP"] = "APP";
+    FwType["MODEM"] = "MODEM";
+    FwType["BOOT"] = "BOOT";
+    FwType["SOFTDEVICE"] = "SOFTDEVICE";
+    FwType["BOOTLOADER"] = "BOOTLOADER";
+    FwType["MDM_FULL"] = "MDM_FULL";
+    return FwType;
+}({});
+export const devices = ({ endpoint, apiKey }, fetchImplementation)=>{
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: 'application/json; charset=utf-8'
+    };
+    const vf = validatedFetch({
+        endpoint,
+        apiKey
+    }, fetchImplementation);
+    return {
+        // FIXME: implement pagination
+        list: async ()=>vf({
+                resource: `devices?${new URLSearchParams({
+                    pageLimit: '100',
+                    deviceNameFuzzy: 'oob-'
+                }).toString()}`
+            }, Devices),
+        get: async (id)=>vf({
+                resource: `devices/${encodeURIComponent(id)}`
+            }, DeviceShadow),
+        updateState: async (id, state)=>fetch(`${slashless(endpoint)}/v1/devices/${encodeURIComponent(id)}/state`, {
+                headers: {
+                    ...headers,
+                    'Content-Type': 'application/json'
+                },
+                method: 'PATCH',
+                body: JSON.stringify(state)
+            }).then(async (res)=>{
+                if (res.status >= 400) return {
+                    error: await toFetchError(res)
+                };
+                return {
+                    success: true
+                };
+            }),
+        register: async (devices)=>{
+            const bulkRegistrationPayload = devices.map(({ deviceId, subType, tags, fwTypes, certPem })=>{
+                const deviceFwTypes = fwTypes ?? Object.values(FwType);
+                return [
+                    [
+                        deviceId,
+                        subType ?? '',
+                        (tags ?? []).join('|'),
+                        deviceFwTypes.join('|'),
+                        `"${certPem}"`
+                    ]
+                ];
+            }).map((cols)=>cols.join(',')).join('\n');
+            const maybeResult = await vf({
+                resource: 'devices',
+                payload: {
+                    body: bulkRegistrationPayload,
+                    type: 'application/octet-stream'
+                }
+            }, ProvisionDevice);
+            if ('error' in maybeResult) return maybeResult;
+            return {
+                bulkOpsRequestId: maybeResult.result.bulkOpsRequestId
+            };
+        },
+        remove: async (deviceId)=>{
+            const maybeResult = await vf({
+                method: 'DELETE',
+                resource: `devices/${deviceId}`
+            }, Type.Any());
+            if ('error' in maybeResult) return maybeResult;
+            return {
+                success: true
+            };
+        }
+    };
+};

package/npm/api/export.js

@@ -0,0 +1,18 @@
+export * from './bulkOps.js';
+export * from './cancelFOTAJob.js';
+export * from './createAccountDevice.js';
+export * from './createFOTAJob.js';
+export * from './deleteAccountDevice.js';
+export * from './devices.js';
+export * from './DeviceShadow.js';
+export * from './FetchError.js';
+export * from './getAccountInfo.js';
+export * from './getCurrentMonthlyCosts.js';
+export * from './getDeviceShadow.js';
+export * from './getFOTABundles.js';
+export * from './getFOTAJob.js';
+export * from './getLocationHistory.js';
+export * from './groundFix.js';
+export * from './serviceToken.js';
+export * from './slashless.js';
+export * from './validatedFetch.js';

package/npm/{src/api → api}/getAccountInfo.d.ts

@@ -13,9 +13,16 @@ export type AccountInfo = Static<typeof AccountInfoType>;
 export declare const getAccountInfo: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => Promise<{
+}, fetchImplementation?: typeof fetch | undefined) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: AccountInfo;
+    result: {
+        mqttEndpoint: string;
+        mqttTopicPrefix: string;
+        team: {
+            tenantId: string;
+            name: string;
+        };
+    };
 }>;
 export {};

package/npm/api/getAccountInfo.js

@@ -0,0 +1,20 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+const AccountInfoType = Type.Object({
+    mqttEndpoint: Type.String(),
+    mqttTopicPrefix: Type.String(),
+    team: Type.Object({
+        tenantId: Type.String(),
+        name: Type.String()
+    })
+});
+export const getAccountInfo = async ({ apiKey, endpoint }, fetchImplementation)=>{
+    const maybeAccount = await validatedFetch({
+        endpoint,
+        apiKey
+    }, fetchImplementation)({
+        resource: 'account'
+    }, AccountInfoType);
+    if ('error' in maybeAccount) return maybeAccount;
+    return maybeAccount;
+};

package/npm/{src/api → api}/getCurrentMonthlyCosts.d.ts

@@ -3,7 +3,7 @@ import type { ValidationError } from './validatedFetch.ts';
 export declare const getCurrentMonthlyCosts: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => () => Promise<{
+}, fetchImplementation?: typeof fetch | undefined) => () => Promise<{
     error: FetchError | ValidationError;
 } | {
     currentMonthTotalCost: number;

package/npm/api/getCurrentMonthlyCosts.js

@@ -0,0 +1,22 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+export const getCurrentMonthlyCosts = ({ apiKey, endpoint }, fetchImplementation)=>async ()=>{
+        const vf = validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation);
+        const maybeResult = await vf({
+            resource: 'account'
+        }, Type.Object({
+            plan: Type.Object({
+                currentMonthTotalCost: Type.Number()
+            })
+        }));
+        if ('error' in maybeResult) {
+            return maybeResult;
+        }
+        const currentMonthTotalCost = maybeResult.result.plan.currentMonthTotalCost;
+        return {
+            currentMonthTotalCost
+        };
+    };

package/npm/api/getDeviceShadow.d.ts

@@ -0,0 +1,28 @@
+import type { FetchError } from './FetchError.ts';
+import type { ValidationError } from './validatedFetch.ts';
+export declare const getDeviceShadow: ({ endpoint, apiKey, }: {
+    endpoint: URL;
+    apiKey: string;
+}, fetchImplementation?: typeof fetch | undefined) => (devices: string[]) => Promise<{
+    shadows: {
+        id: string;
+        $meta: {
+            createdAt: string;
+            updatedAt?: string | undefined;
+        };
+        state?: {
+            reported?: {
+                [x: string]: any;
+            } | undefined;
+            desired?: {
+                [x: string]: any;
+            } | undefined;
+            version: number;
+            metadata: {
+                [x: string]: any;
+            };
+        } | undefined;
+    }[];
+} | {
+    error: FetchError | ValidationError;
+}>;

package/npm/api/getDeviceShadow.js

@@ -0,0 +1,42 @@
+import { Type } from '@sinclair/typebox';
+import { DeviceShadow } from './DeviceShadow.js';
+import { validatedFetch } from './validatedFetch.js';
+const DeviceShadows = Type.Array(DeviceShadow);
+/**
+ * @see https://api.nrfcloud.com/v1#tag/All-Devices/operation/ListDevices
+ */ const ListDevices = Type.Object({
+    items: DeviceShadows,
+    total: Type.Optional(Type.Number({
+        minimum: 0
+    })),
+    pageNextToken: Type.Optional(Type.String({
+        minLength: 1
+    }))
+});
+export const getDeviceShadow = ({ endpoint, apiKey }, fetchImplementation)=>{
+    const vf = validatedFetch({
+        endpoint,
+        apiKey
+    }, fetchImplementation);
+    return async (devices)=>{
+        const params = {
+            includeState: true,
+            includeStateMeta: true,
+            pageLimit: 100,
+            deviceIds: devices.join(',')
+        };
+        const queryString = Object.entries(params).sort((a, b)=>a[0].localeCompare(b[0])).map((kv)=>kv.map(encodeURIComponent).join('=')).join('&');
+        const url = `devices?${queryString}`;
+        const maybeResult = await vf({
+            resource: url
+        }, ListDevices);
+        if ('error' in maybeResult) {
+            return {
+                error: maybeResult.error
+            };
+        }
+        return {
+            shadows: maybeResult.result.items
+        };
+    };
+};

package/npm/{src/api → api}/getFOTABundles.d.ts

@@ -1,4 +1,3 @@
-import { type Static } from '@sinclair/typebox';
 import { FwType } from './devices.ts';
 import type { FetchError } from './FetchError.ts';
 import type { ValidationError } from './validatedFetch.ts';
@@ -15,8 +14,17 @@ export declare const FOTABundle: import("@sinclair/typebox").TObject<{
 export declare const getFOTABundles: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => () => Promise<{
+}, fetchImplementation?: typeof fetch | undefined) => () => Promise<{
     error: FetchError | ValidationError;
 } | {
-    bundles: Array<Static<typeof FOTABundle>>;
+    bundles: {
+        bundleId: string;
+        lastModified?: string | undefined;
+        size: number;
+        version: string;
+        type: FwType;
+        filenames: string[];
+        name?: string | undefined;
+        description?: string | undefined;
+    }[];
 }>;