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

package/npm/src/api/getFOTABundles.js

@@ -0,0 +1,101 @@
+import { Type } from '@sinclair/typebox';
+import { FwType } from './devices.js';
+import { validatedFetch } from './validatedFetch.js';
+export const FOTABundle = Type.Object({
+    bundleId: Type.String({
+        minLength: 1,
+        description: 'The ID of the bundle',
+        examples: [
+            'APP*20a4b75a*v1.1.1-debug'
+        ]
+    }),
+    lastModified: Type.Optional(Type.String({
+        title: 'Timestamp',
+        description: 'ISO-8601 date-time string',
+        examples: [
+            '2019-08-24T14:15:22Z'
+        ]
+    })),
+    size: Type.Number({
+        minimum: 0,
+        description: 'Size of the bundle in bytes',
+        examples: [
+            418565
+        ]
+    }),
+    version: Type.String({
+        minLength: 1,
+        examples: [
+            'v1.1.1-debug'
+        ]
+    }),
+    type: Type.Enum(FwType, {
+        title: 'Firmware Type'
+    }),
+    filenames: Type.Array(Type.String({
+        minLength: 1,
+        examples: [
+            'hello-nrfcloud-thingy91-debug-v1.1.1-fwupd.bin'
+        ]
+    }), {
+        description: 'The files in the bundle.'
+    }),
+    name: Type.Optional(Type.String({
+        minLength: 1,
+        title: 'Name',
+        description: 'The name of the bundle',
+        examples: [
+            'hello.nrfcloud.com v1.1.1-debug'
+        ]
+    })),
+    description: Type.Optional(Type.String({
+        minLength: 1,
+        title: 'Description',
+        description: 'The description of the bundle',
+        examples: [
+            'Firmware Update Image BIN file (thingy91, debug)'
+        ]
+    }))
+});
+const FirmwaresType = Type.Object({
+    items: Type.Array(FOTABundle),
+    total: Type.Integer({
+        minimum: 0,
+        description: 'Reflects the total results returned by the query, which may be less than the total number of items available. If the response contains a pageNextToken value, you can supply the pageNextToken in the next request to get more results. The maximum value of total is the page limit of the request, or ten pages if no page limit is provided.'
+    }),
+    pageNextToken: Type.Optional(Type.String({
+        minLength: 1,
+        description: 'Token used to retrieve the next page of items in the list. Present in a response only if the total available results exceeds the specified limit on a page. This token does not change between requests. When supplying as a request parameter, use URL-encoding.'
+    }))
+}, {
+    title: 'Firmware bundles',
+    description: 'Returns the list of firmware bundles. See https://api.nrfcloud.com/v1#tag/Firmware-Bundles/operation/ListFirmware'
+});
+export const getFOTABundles = ({ apiKey, endpoint }, fetchImplementation)=>async ()=>{
+        const vf = validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation);
+        return paginateFirmwares(vf);
+    };
+const paginateFirmwares = async (vf, bundles = [], pageNextToken = undefined)=>{
+    const query = new URLSearchParams({
+        pageLimit: '100'
+    });
+    if (pageNextToken !== undefined) query.set('pageNextToken', pageNextToken);
+    const maybeBundles = await vf({
+        resource: `firmwares`,
+        query
+    }, FirmwaresType);
+    if ('error' in maybeBundles) return maybeBundles;
+    if (maybeBundles.result.pageNextToken !== undefined) return paginateFirmwares(vf, [
+        ...bundles,
+        ...maybeBundles.result.items
+    ], maybeBundles.result.pageNextToken);
+    return {
+        bundles: [
+            ...bundles,
+            ...maybeBundles.result.items
+        ]
+    };
+};

package/npm/src/api/getFOTAJob.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';
@@ -40,10 +39,31 @@ export declare const FOTAJobType: import("@sinclair/typebox").TObject<{
 export declare const getFOTAJob: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => ({ jobId, }: {
+}, fetchImplementation?: typeof fetch | undefined) => ({ jobId, }: {
     jobId: string;
 }) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: Static<typeof FOTAJobType>;
+    result: {
+        jobId: string;
+        status: FOTAJobStatus;
+        statusDetail?: string | undefined;
+        name?: string | undefined;
+        description?: string | undefined;
+        createdAt: string;
+        lastUpdatedAt?: string | undefined;
+        completedAt?: string | undefined;
+        firmware?: {
+            bundleId: string;
+            fileSize: number;
+            firmwareType: FwType;
+            host: string;
+            uris: string[];
+            version: string;
+        } | undefined;
+        target?: {
+            deviceIds: string[];
+            tags: string[];
+        } | undefined;
+    };
 }>;

package/npm/src/api/getFOTAJob.js

@@ -0,0 +1,114 @@
+import { Type } from '@sinclair/typebox';
+import { FwType } from './devices.js';
+import { validatedFetch } from './validatedFetch.js';
+export var FOTAJobStatus = /*#__PURE__*/ function(FOTAJobStatus) {
+    FOTAJobStatus["CREATED"] = "CREATED";
+    FOTAJobStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    FOTAJobStatus["CANCELLED"] = "CANCELLED";
+    FOTAJobStatus["DELETION_IN_PROGRESS"] = "DELETION_IN_PROGRESS";
+    FOTAJobStatus["COMPLETED"] = "COMPLETED";
+    FOTAJobStatus["QUEUED"] = "QUEUED";
+    FOTAJobStatus["FAILED"] = "FAILED";
+    FOTAJobStatus["SUCCEEDED"] = "SUCCEEDED";
+    FOTAJobStatus["TIMED_OUT"] = "TIMED_OUT";
+    FOTAJobStatus["REJECTED"] = "REJECTED";
+    FOTAJobStatus["DOWNLOADING"] = "DOWNLOADING";
+    return FOTAJobStatus;
+}({});
+const ts = Type.String({
+    title: 'Timestamp',
+    description: 'ISO-8601 date-time string',
+    examples: [
+        '2019-08-24T14:15:22Z'
+    ]
+});
+export const FOTAJobType = Type.Object({
+    jobId: Type.String({
+        minLength: 1,
+        title: 'ID',
+        description: 'Universally unique identifier',
+        examples: [
+            'bc631093-7f7c-4c1b-aa63-a68c759bcd5c'
+        ]
+    }),
+    status: Type.Enum(FOTAJobStatus, {
+        title: 'Status',
+        description: 'Current status of the job'
+    }),
+    statusDetail: Type.Optional(Type.String({
+        minLength: 0
+    })),
+    name: Type.Optional(Type.String({
+        minLength: 1
+    })),
+    description: Type.Optional(Type.String({
+        minLength: 1
+    })),
+    createdAt: ts,
+    lastUpdatedAt: Type.Optional(ts),
+    completedAt: Type.Optional(ts),
+    firmware: Type.Optional(Type.Object({
+        bundleId: Type.String({
+            minLength: 1,
+            examples: [
+                'APP*439ddbc7*v2.0.0'
+            ]
+        }),
+        fileSize: Type.Number({
+            minimum: 1,
+            examples: [
+                385068
+            ]
+        }),
+        firmwareType: Type.Enum(FwType, {
+            title: 'Firmware Type'
+        }),
+        host: Type.String({
+            minLength: 1,
+            examples: [
+                'firmware.nrfcloud.com'
+            ]
+        }),
+        uris: Type.Array(Type.String({
+            minLength: 1,
+            examples: [
+                'bbfe6b73-a46a-43ad-94bd-8e4b4a7847ce/APP*439ddbc7*v2.0.0/hello-nrfcloud-thingy91-v2.0.0-fwupd.bin'
+            ]
+        })),
+        version: Type.String({
+            minLength: 1,
+            examples: [
+                'v2.0.0'
+            ]
+        })
+    })),
+    target: Type.Optional(Type.Object({
+        deviceIds: Type.Array(Type.String({
+            minLength: 1,
+            title: 'Device ID',
+            examples: [
+                'oob-358299840021360'
+            ]
+        })),
+        tags: Type.Array(Type.String({
+            minLength: 1,
+            title: 'Tag',
+            examples: [
+                'nrf9160'
+            ]
+        }))
+    }))
+}, {
+    title: 'FOTA Job',
+    description: 'See https://api.nrfcloud.com/#tag/FOTA-Jobs/operation/FetchFOTAJob'
+});
+export const getFOTAJob = ({ apiKey, endpoint }, fetchImplementation)=>async ({ jobId })=>{
+        const maybeJob = await validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation)({
+            resource: `fota-jobs/${jobId}`
+        }, FOTAJobType);
+        if ('error' in maybeJob) return maybeJob;
+        return maybeJob;
+    };

package/npm/src/api/getLocationHistory.d.ts

@@ -34,14 +34,33 @@ export type LocationHistory = Static<typeof LocationHistoryType>;
 export declare const getLocationHistory: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => ({ deviceId, pageNextToken, start, end, }: {
+}, fetchImplementation?: typeof fetch | undefined) => ({ deviceId, pageNextToken, start, end, }: {
     deviceId: string;
-    pageNextToken?: string;
-    start?: Date;
-    end?: Date;
+    pageNextToken?: string | undefined;
+    start?: Date | undefined;
+    end?: Date | undefined;
 }) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: Static<typeof LocationHistoryType>;
+    result: {
+        items: {
+            id: string;
+            deviceId: string;
+            serviceType: LocationHistoryServiceType;
+            insertedAt: string;
+            lat: string;
+            lon: string;
+            meta: {
+                [x: string]: any;
+            };
+            uncertainty: string;
+            anchors?: {
+                macAddress: string;
+                name?: string | undefined;
+            }[] | undefined;
+        }[];
+        total: number;
+        pageNextToken?: string | undefined;
+    };
 }>;
 export {};

package/npm/src/api/getLocationHistory.js

@@ -0,0 +1,118 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+export var LocationHistoryServiceType = /*#__PURE__*/ function(LocationHistoryServiceType) {
+    LocationHistoryServiceType["ANCHOR"] = "ANCHOR";
+    LocationHistoryServiceType["GNSS"] = "GNSS";
+    LocationHistoryServiceType["GPS"] = "GPS";
+    LocationHistoryServiceType["MCELL"] = "MCELL";
+    LocationHistoryServiceType["MCELL_EVAL"] = "MCELL_EVAL";
+    LocationHistoryServiceType["SCELL"] = "SCELL";
+    LocationHistoryServiceType["SCELL_EVAL"] = "SCELL_EVAL";
+    LocationHistoryServiceType["WIFI"] = "WIFI";
+    LocationHistoryServiceType["WIFI_EVAL"] = "WIFI_EVAL";
+    return LocationHistoryServiceType;
+}({});
+const LocationHistoryType = Type.Object({
+    items: Type.Array(Type.Object({
+        id: Type.String({
+            minLength: 1,
+            title: 'ID',
+            description: 'Universally unique identifier',
+            examples: [
+                'bc631093-7f7c-4c1b-aa63-a68c759bcd5c'
+            ]
+        }),
+        deviceId: Type.String({
+            minLength: 1,
+            title: 'This is the canonical device id used in the device certificate, and as the MQTT client id.',
+            examples: [
+                'nrf-1234567890123456789000'
+            ]
+        }),
+        serviceType: Type.Enum(LocationHistoryServiceType, {
+            title: 'Tracker Service Type',
+            description: 'This is the service used to obtain the location of a device. The "_EVAL" suffix means the location was obtained using an evaluation token. GNSS location is derived on the device and reported back to the cloud. "GPS" type has been deprecated, but will still return for older records.',
+            examples: [
+                'location'
+            ]
+        }),
+        insertedAt: Type.String({
+            title: 'Insertion Time',
+            description: 'HTML-encoded ISO-8601 date-time string denoting the start or end of a date range. If the string includes only a date, the time is the beginning of the day (00:00:00).',
+            examples: [
+                '2021-08-31T20:00:00Z'
+            ]
+        }),
+        lat: Type.String({
+            minLength: 1,
+            examples: [
+                '63.41999531'
+            ],
+            description: 'Latitude in degrees'
+        }),
+        lon: Type.String({
+            minLength: 1,
+            examples: [
+                '-122.688408'
+            ],
+            description: 'Longitude in degrees'
+        }),
+        meta: Type.Record(Type.String({
+            minLength: 1
+        }), Type.Any(), {
+            title: 'GNSS metatdata',
+            description: 'Metadata sent from device when reporting GNSS location in PVT format. Can include other non-gnss related key/value pairs for easy retrieval later. Only populated for GNSS PVT formatted fixes, empty object otherwise.'
+        }),
+        uncertainty: Type.RegExp(/^[0-9.]+$/, {
+            title: 'Uncertainty',
+            description: 'Radius of the uncertainty circle around the location in meters. Also known as Horizontal Positioning Error (HPE).',
+            examples: [
+                '2420',
+                '13.012'
+            ]
+        }),
+        anchors: Type.Optional(Type.Array(Type.Object({
+            macAddress: Type.RegExp(/^([0-9a-f]{2}:){5}[0-9a-f]{2}$/i, {
+                title: 'Mac Address',
+                description: 'String comprised of 6 hexadecimal pairs, separated by colons or dashes. When used in a positioning request, it must be universally assigned. See this help page for details.',
+                examples: [
+                    'FE:1E:41:2D:9E:53'
+                ]
+            }),
+            name: Type.Optional(Type.RegExp(/^[a-z0-9_ -]{1,32}$/i, {
+                title: 'Name',
+                description: 'Limit 32 characters. Only numbers, letters, underscores, dashes, and spaces allowed. All other characters will be removed.',
+                examples: [
+                    'anchor-1'
+                ]
+            }))
+        })))
+    })),
+    total: Type.Number({
+        minimum: 0
+    }),
+    pageNextToken: Type.Optional(Type.String({
+        minLength: 1
+    }))
+}, {
+    title: 'Location History',
+    description: 'See https://api.nrfcloud.com/v1#tag/Location-History/operation/GetLocationHistory'
+});
+export const getLocationHistory = ({ apiKey, endpoint }, fetchImplementation)=>async ({ deviceId, pageNextToken, start, end })=>{
+        const query = new URLSearchParams({
+            pageLimit: '100',
+            deviceId
+        });
+        if (start !== undefined) query.set('start', start.toISOString());
+        if (end !== undefined) query.set('end', end.toISOString());
+        if (pageNextToken !== undefined) query.set('pageNextToken', pageNextToken);
+        const maybeHistory = await validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation)({
+            resource: 'location/history',
+            query
+        }, LocationHistoryType);
+        if ('error' in maybeHistory) return maybeHistory;
+        return maybeHistory;
+    };

package/npm/src/api/groundFix.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 lat: import("@sinclair/typebox").TNumber;
@@ -16,14 +15,19 @@ export declare const GroundFixType: import("@sinclair/typebox").TObject<{
 export declare const groundFix: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => (cell: {
+}, fetchImplementation?: typeof fetch | undefined) => (cell: {
     mcc: number;
     mnc: string;
     eci: number;
     tac: number;
-    rsrp?: number;
+    rsrp?: number | undefined;
 }) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: Static<typeof GroundFixType>;
+    result: {
+        lat: number;
+        lon: number;
+        uncertainty: number;
+        fulfilledWith: "SCELL";
+    };
 }>;

package/npm/src/api/groundFix.js

@@ -0,0 +1,38 @@
+import { Type } from '@sinclair/typebox';
+import { JSONPayload, validatedFetch } from './validatedFetch.js';
+export const lat = Type.Number({
+    minimum: -90,
+    maximum: 90,
+    description: 'Latitude in degrees'
+});
+export const lng = Type.Number({
+    minimum: -180,
+    maximum: 180,
+    description: 'Longitude in degrees'
+});
+export const accuracy = Type.Number({
+    minimum: 0,
+    description: 'HPE (horizontal positioning error) in meters'
+});
+/**
+ * @link https://api.nrfcloud.com/v1/#tag/Ground-Fix
+ */ export const GroundFixType = Type.Object({
+    lat,
+    lon: lng,
+    uncertainty: accuracy,
+    fulfilledWith: Type.Literal('SCELL')
+});
+export const groundFix = ({ apiKey, endpoint }, fetchImplementation)=>async (cell)=>{
+        const vf = validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation);
+        return vf({
+            resource: 'location/ground-fix',
+            payload: JSONPayload({
+                lte: [
+                    cell
+                ]
+            })
+        }, GroundFixType);
+    };

package/npm/src/api/serviceToken.d.ts

@@ -9,8 +9,8 @@ export declare const ServiceToken: import("@sinclair/typebox").TObject<{
 export declare const serviceToken: ({ apiKey, endpoint, }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => (() => Promise<{
+}, fetchImplementation?: typeof fetch | undefined) => () => Promise<{
     error: FetchError | ValidationError;
 } | {
     token: string;
-}>);
+}>;

package/npm/src/api/serviceToken.js

@@ -0,0 +1,20 @@
+import { Type } from '@sinclair/typebox';
+import { validatedFetch } from './validatedFetch.js';
+/**
+ * @link https://api.nrfcloud.com/v1/#tag/Account/operation/GetServiceToken
+ */ export const ServiceToken = Type.Object({
+    token: Type.String()
+});
+export const serviceToken = ({ apiKey, endpoint }, fetchImplementation)=>async ()=>{
+        const vf = validatedFetch({
+            endpoint,
+            apiKey
+        }, fetchImplementation);
+        const maybeResult = await vf({
+            resource: 'account/service-token'
+        }, ServiceToken);
+        if ('error' in maybeResult) {
+            return maybeResult;
+        }
+        return maybeResult.result;
+    };

package/npm/src/api/slashless.js

@@ -0,0 +1 @@
+export const slashless = (url)=>url.toString().replace(/\/$/, '');

package/npm/src/api/validatedFetch.d.ts

@@ -1,4 +1,4 @@
-import { type Static, type TSchema } from '@sinclair/typebox';
+import { type TSchema } from '@sinclair/typebox';
 import type { ValueError } from '@sinclair/typebox/compiler';
 import type { FetchError } from './FetchError.ts';
 export declare class ValidationError extends Error {
@@ -9,7 +9,7 @@ export declare class ValidationError extends Error {
 export declare const validatedFetch: ({ endpoint, apiKey }: {
     apiKey: string;
     endpoint: URL;
-}, fetchImplementation?: typeof fetch) => <Schema extends TSchema>(params: ({
+}, fetchImplementation?: typeof fetch | undefined) => <Schema extends TSchema>(params: ({
     resource: string;
 } | {
     resource: string;
@@ -18,11 +18,13 @@ export declare const validatedFetch: ({ endpoint, apiKey }: {
     resource: string;
     method: string;
 }) & {
-    query?: URLSearchParams;
+    query?: URLSearchParams | undefined;
 }, schema: Schema) => Promise<{
     error: FetchError | ValidationError;
 } | {
-    result: Static<Schema>;
+    result: (Schema & {
+        params: [];
+    })["static"];
 }>;
 type Payload = {
     /** The content-type of body */

package/npm/src/api/validatedFetch.js

@@ -0,0 +1,58 @@
+import { validateWithTypeBox } from '@hello.nrfcloud.com/proto';
+import { toFetchError } from './FetchError.js';
+import { slashless } from './slashless.js';
+export class ValidationError extends Error {
+    errors;
+    isValidationError = true;
+    constructor(errors){
+        super(`Validation errors`);
+        this.name = 'ValidationError';
+        this.errors = errors;
+    }
+}
+const validate = (SchemaObject, data)=>{
+    const maybeData = validateWithTypeBox(SchemaObject)(data);
+    if ('errors' in maybeData) {
+        console.error('Validation failed', {
+            error: maybeData.errors
+        });
+        throw new ValidationError(maybeData.errors);
+    }
+    return maybeData.value;
+};
+const fetchData = (fetchImplementation)=>async (...args)=>{
+        const response = await (fetchImplementation ?? fetch)(...args);
+        if (!response.ok) throw await toFetchError(response);
+        if (response.headers?.get('content-length') === '0') return undefined;
+        return response.json();
+    };
+export const validatedFetch = ({ endpoint, apiKey }, fetchImplementation)=>async (params, schema)=>{
+        const { resource, query } = params;
+        const args = {
+            headers: headers(apiKey)
+        };
+        if ('payload' in params) {
+            const payload = params.payload;
+            args.method = 'POST';
+            args.body = payload.body;
+            args.headers = {
+                ...args.headers ?? {},
+                ['Content-Type']: payload.type
+            };
+        } else if ('method' in params) {
+            args.method = params.method;
+        }
+        return fetchData(fetchImplementation)(`${slashless(endpoint)}/v1/${resource}${query !== undefined ? `?${query.toString()}` : ''}`, args).then((res)=>({
+                result: validate(schema, res)
+            })).catch((error)=>({
+                error
+            }));
+    };
+const headers = (apiKey)=>({
+        Authorization: `Bearer ${apiKey}`,
+        Accept: 'application/json; charset=utf-8'
+    });
+export const JSONPayload = (payload)=>({
+        type: 'application/json',
+        body: JSON.stringify(payload)
+    });

package/npm/src/settings/export.js

@@ -0,0 +1,5 @@
+export * from './getAllAccounts.js';
+export * from './getAllAccountsSettings.js';
+export * from './groupByAccount.js';
+export * from './scope.js';
+export * from './settings.js';

package/npm/src/settings/getAllAccounts.js

@@ -0,0 +1,9 @@
+import { get } from '@bifravst/aws-ssm-settings-helpers';
+import { NRFCLOUD_ACCOUNT_SCOPE } from './scope.js';
+export const getAllAccounts = async ({ ssm, stackName })=>[
+        ...getAccountsFromAllSettings(await get(ssm)({
+            stackName,
+            scope: NRFCLOUD_ACCOUNT_SCOPE
+        })())
+    ];
+export const getAccountsFromAllSettings = (settings)=>new Set(Object.keys(settings).map((key)=>key.split('/')[0]));

package/npm/src/settings/getAllAccountsSettings.js

@@ -0,0 +1,13 @@
+import { get } from '@bifravst/aws-ssm-settings-helpers';
+import { groupByAccount } from './groupByAccount.js';
+import { NRFCLOUD_ACCOUNT_SCOPE } from './scope.js';
+import { validateSettings } from './settings.js';
+/**
+ * Returns settings for all accounts
+ */ export const getAllAccountsSettings = async ({ ssm, stackName })=>Object.entries(groupByAccount(await get(ssm)({
+        stackName,
+        scope: NRFCLOUD_ACCOUNT_SCOPE
+    })())).reduce((allSettings, [account, settings])=>({
+            ...allSettings,
+            [account]: validateSettings(settings)
+        }), {});

package/npm/src/settings/groupByAccount.js

@@ -0,0 +1,16 @@
+import { getAccountsFromAllSettings } from './getAllAccounts.js';
+export const groupByAccount = (allSettings)=>{
+    const accounts = getAccountsFromAllSettings(allSettings);
+    return [
+        ...accounts
+    ].reduce((allAccountSettings, account)=>({
+            ...allAccountSettings,
+            [account]: Object.entries(allSettings).filter(([k])=>k.startsWith(`${account}/`)).map(([k, v])=>[
+                    k.replace(new RegExp(`^${account}/`), ''),
+                    v
+                ]).reduce((s, [k, v])=>({
+                    ...s,
+                    [k]: v
+                }), {})
+        }), {});
+};

package/npm/src/settings/scope.js

@@ -0,0 +1,6 @@
+export const NRFCLOUD_ACCOUNT_SCOPE = 'thirdParty';
+const nameRx = /^[a-zA-Z0-9_.-]+$/;
+export const nrfCloudAccount = (account)=>{
+    if (!nameRx.test(account)) throw new Error(`Invalid account name: ${account}`);
+    return account;
+};