c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/QueriesUtil.mjs

@@ -0,0 +1,225 @@
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/QueriesUtil.js
+var QueriesUtil = class {
+	constructor() {
+		this.operatorFns = {
+			__not: (operand) => {
+				return `not(${this.buildQueryFilter(operand, null)})`;
+			},
+			__and: (operand) => {
+				return this.buildQueryFilter(operand, null, "and");
+			},
+			__or: (operand) => {
+				return this.buildQueryFilter(operand, null, "or");
+			},
+			__eq: (operand, contextKey) => {
+				if (typeof operand === "object" && operand !== null) return this.buildQueryFilter(operand, contextKey);
+				return `${contextKey} eq ${this.quoteString(operand)}`;
+			},
+			__gt: (operand, contextKey) => {
+				return `${contextKey} gt ${this.useAsFloat(operand)}`;
+			},
+			__ge: (operand, contextKey) => {
+				return `${contextKey} ge ${this.useAsFloat(operand)}`;
+			},
+			__lt: (operand, contextKey) => {
+				return `${contextKey} lt ${this.useAsFloat(operand)}`;
+			},
+			__le: (operand, contextKey) => {
+				return `${contextKey} le ${this.useAsFloat(operand)}`;
+			},
+			__in: (operand, contextKey) => {
+				const statements = operand.filter((op) => !!op).map((op) => {
+					return `${contextKey} eq ${this.quoteString(op)}`;
+				});
+				return this.glue(statements, "or");
+			},
+			__bygroupid: (operand) => {
+				return `bygroupid(${operand})`;
+			},
+			__has: (operand) => {
+				return `has(${operand})`;
+			},
+			__isinhierarchyof: (operand) => {
+				return `isinhierarchyof(${operand})`;
+			},
+			__hasany: (operand) => {
+				return `hasany(${operand})`;
+			},
+			__useFilterQueryString: (queryString) => {
+				var _a;
+				const query = (_a = queryString.match(/\(.*\)/)) === null || _a === void 0 ? void 0 : _a[0];
+				return query === null || query === void 0 ? void 0 : query.substring(1, query.length - 1);
+			}
+		};
+	}
+	/**
+	* Builds query string from provided query object.
+	*
+	* @param query Object containing filters and sort order for querying managed objects. Supported filters are:
+	* - **__and** - Specifies conditions, e.g. `{__and: [{__has: 'c8y_IsDevice'}, {'count': {__gt: 0}}]}`.
+	* - **__or** - Specifies alternative conditions, e.g. `{__or: [{__bygroupid: 10300}, {__bygroupid: 10400}]}`.
+	* - **__eq** - Specified fragment must be equal to given value, e.g. `{'status': 'AVAILABLE'}` (no nested object required).
+	* - **__lt** - Specified fragment must be less then given value, e.g. `{'count': {__lt: 10}}`.
+	* - **__gt** - Specified fragment must be greater then given value, e.g. `{'count': {__gt: 0}}`.
+	* - **__in** - Specified fragment must be equal to one of values in the list, e.g. `{'status': {__in: ['AVAILABLE', 'UNAVAILABLE']}}`.
+	* - **__not** - Negates condition, e.g. `{__not: {'status': 'AVAILABLE'}}`.
+	* - **__bygroupid** - True if filtered managed object is assigned to given group, e.g. `{__bygroupid: 10300}`.
+	* - **__has** - Specified fragment must have a value defined, e.g. `{__has: 'c8y_IsDevice'}`.
+	* - **__hasany** - Matches objects having at least one of the fragments defined, e.g. `{__has: ['c8y_IsDevice', 'c8y_Dashboard']}`.
+	* - **__isinhierarchyof** - Matches objects that are in hierarchy of given managed object, e.g. `{__isinhierarchyof: '12345'}`.
+	* - **__useFilterQueryString** - Gets rid of the `$filter=()… $orderby=…` parts of a query and keeps only what's between the most
+	*                                exterior parentheses of the $filter.
+	*                                EXAMPLE: takes a query of the form
+	*                                `$filter=(name eq 'RaspPi*') $orderby=name asc`
+	*                                and turns it into
+	*                                `name eq 'RaspPi*'`
+	*                                This is necessary for searching for smart groups, which are identified by their own query
+	*                                that needs to be passed through.
+	*
+	* Note: if you want to specify the order, you need to wrap your filters within `__filter` property and then add `__orderby` with the array of field paths and sort directions (1 for ascending, -1 for descending), for example:
+	* - `{ __filter: { ... }, __orderby: [{ 'creationTime': -1 }, { 'name': 1 }] }`
+	*
+	* @returns {string} Returns a query string ready to be sent in request params to backend.
+	*
+	* **Example**
+	* ```typescript
+	*   const query = {
+	*     __filter: {
+	*       'name': 'My Device*',
+	*       'c8y_Availability.status': {
+	*         __in: ['AVAILABLE', 'UNAVAILABLE']
+	*       },
+	*       'creationTime': {
+	*         __lt: '2015-11-30T13:28:123Z'
+	*       },
+	*       'c8y_ActiveAlarmsStatus.critical': {
+	*         __gt: 0
+	*       },
+	*       __or: [
+	*         {__not: {__has: 'c8y_ActiveAlarmsStatus.major'}},
+	*         {
+	*           __or: [
+	*             {__bygroupid: 10300},
+	*             {__bygroupid: 10400}
+	*           ]
+	*         }
+	*       ]
+	*     },
+	*     __orderby: [
+	*       {'name': 1},
+	*       {'creationTime': -1},
+	*       {'c8y_ActiveAlarmsStatus.critical': -1}
+	*     ]
+	*   };
+	*
+	*   const params = {
+	*     query: queriesUtil.buildQuery(query)
+	*   };
+	* ```
+	*/
+	buildQuery(query) {
+		const q = [];
+		const queryObjectRoot = query.__filter || query;
+		const filter = this.buildQueryFilter(queryObjectRoot);
+		const orderBy = this.buildQueryOrderby(query.__orderby);
+		if (filter) q.push(`$filter=(${filter})`);
+		if (orderBy) q.push(`$orderby=${orderBy}`);
+		return q.join(" ");
+	}
+	buildQueryFilter(queryFilter, _queryKey, _glueType) {
+		const queryKey = _queryKey || null;
+		const glueType = _glueType || "and";
+		const q = new Array();
+		if (Array.isArray(queryFilter)) for (const qFilter of queryFilter) {
+			const _q = this.buildQueryFilter(qFilter, null, glueType);
+			if (_q) q.push(_q);
+		}
+		else for (const k of Object.keys(queryFilter)) if (this.operatorFns[k] !== void 0) {
+			const _q = this.operatorFns[k](queryFilter[k], queryKey);
+			if (_q) q.push(_q);
+		} else {
+			const _q = this.operatorFns.__eq(queryFilter[k], k);
+			if (_q) q.push(_q);
+		}
+		return this.glue(q, glueType);
+	}
+	buildQueryOrderby(queryOrderbys) {
+		const o = [];
+		if (queryOrderbys) {
+			for (const q of queryOrderbys) for (const k of Object.keys(q)) if (q[k] !== 0) o.push(`${k} ${q[k] > 0 ? "asc" : "desc"}`);
+		}
+		return o.join(",");
+	}
+	addAndFilter(query, filter) {
+		return this.addFilter(query, filter, "and");
+	}
+	addOrFilter(query, filter) {
+		return this.addFilter(query, filter, "or");
+	}
+	addFilter(query, filter, operator) {
+		const oldFilter = query.__orderby ? query.__filter || {} : query.__filter || query;
+		const newFilter = { [`__${operator}`]: this.skipEmptyObjects([oldFilter, filter]) };
+		if (!query.__filter && !query.__orderby) return newFilter;
+		query.__filter = newFilter;
+		return query;
+	}
+	prependOrderbys(query, orderbys) {
+		return this.addOrderbys(query, orderbys, "prepend");
+	}
+	appendOrderbys(query, orderbys) {
+		return this.addOrderbys(query, orderbys, "append");
+	}
+	addOrderbys(query, orderbys, how) {
+		const oldFilter = query.__orderby ? query.__filter || {} : query.__filter || query;
+		const oldOrderbys = query.__orderby || [];
+		const newOrderbys = how === "prepend" ? [...orderbys, ...oldOrderbys] : [...oldOrderbys, ...orderbys];
+		const newQuery = { __orderby: this.skipEmptyObjects(newOrderbys) };
+		if (!this.isEmptyObject(oldFilter)) newQuery.__filter = oldFilter;
+		return newQuery;
+	}
+	extractAndMergeOrderBys(queries) {
+		if ((queries === null || queries === void 0 ? void 0 : queries.length) > 0) {
+			const orderByQuery = queries.map((query) => {
+				const tokenIndex = query.lastIndexOf("$orderby=");
+				return tokenIndex !== -1 ? query.substring(tokenIndex + 9) : null;
+			}).filter((orderBy) => orderBy !== null).join(",");
+			return orderByQuery ? `$orderby=${orderByQuery}` : "";
+		}
+	}
+	glue(statements, type) {
+		return statements.length > 1 ? `(${statements.join(`) ${type} (`)})` : statements[0];
+	}
+	useAsFloat(operand) {
+		operand = this.quoteString(operand);
+		if (typeof operand === "number") return `${operand}f`;
+		return operand;
+	}
+	quoteString(s) {
+		if (typeof s === "string") return `'${this.escapeString(s)}'`;
+		return s;
+	}
+	skipEmptyObjects(objs) {
+		return objs.filter((obj) => !this.isEmptyObject(obj));
+	}
+	isEmptyObject(obj) {
+		return Object.keys(obj).length === 0;
+	}
+	/**
+	* Escapes a string to be used in OData query.
+	*
+	* - OData does not support single quotes in the query. We need to replace all single quotes with double quotes.
+	* - OData uses parentheses for grouping expressions and functions. We need to escape any parentheses in the string.
+	* - OData uses backslash as an escape character. We need to escape any backslashes in the string.
+	*
+	* Spec: http://docs.oasis-open.org/odata/odata/v4.01/cs01/part2-url-conventions/odata-v4.01-cs01-part2-url-conventions.html#sec_URLComponents
+	*
+	* @param s String to be escaped.
+	* @returns Escaped string.
+	*/
+	escapeString(s) {
+		return s.replace(/'/g, "''").replace(/\\/g, "\\\\").replace(/(\[|\{|\(|\]|\}|\))/g, "\\$1");
+	}
+};
+
+//#endregion
+export { QueriesUtil };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/Service.mjs

@@ -0,0 +1,186 @@
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { Paging } from "./Paging.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/Service.js
+var Service = class {
+	constructor(client, realtime) {
+		this.client = client;
+		this.realtime = realtime;
+		this.cache = /* @__PURE__ */ new Map();
+		const methodsToHide = [
+			"list",
+			"create",
+			"update",
+			"detail",
+			"delete"
+		];
+		const prototype = Object.getPrototypeOf(this);
+		methodsToHide.forEach((method) => {
+			if (!prototype.hasOwnProperty(method)) Object.defineProperty(this, method, { get() {} });
+		});
+	}
+	list() {
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			const headers = { accept: "application/json" };
+			const url = this.listUrl;
+			const res = yield this.fetch(url, this.changeFetchOptions({
+				headers,
+				params: filter
+			}, url));
+			const json = yield res.json();
+			return {
+				res,
+				data: this.propertyName ? json[this.propertyName] : json,
+				paging: this.getPaging(json, filter)
+			};
+		});
+	}
+	detail(entityOrId_1) {
+		return __awaiter(this, arguments, void 0, function* (entityOrId, filter = {}) {
+			const headers = { accept: "application/json" };
+			const url = this.getDetailUrl(entityOrId);
+			const res = yield this.fetch(url, this.changeFetchOptions({
+				headers,
+				params: Object.assign({}, filter)
+			}, url));
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	create(entity) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const url = this.listUrl;
+			const method = "POST";
+			const body = JSON.stringify(this.onBeforeCreate(entity));
+			const res = yield this.fetch(url, this.changeFetchOptions({
+				method,
+				body,
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json"
+				}
+			}, url));
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	update(entity) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const url = this.getDetailUrl(entity);
+			const method = "PUT";
+			const body = JSON.stringify(this.onBeforeUpdate(entity));
+			const res = yield this.fetch(url, this.changeFetchOptions({
+				method,
+				body,
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json"
+				}
+			}, url));
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+	delete(entityOrId, params) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const method = "DELETE";
+			const url = this.getDetailUrl(entityOrId);
+			return {
+				res: yield this.fetch(url, this.changeFetchOptions({
+					method,
+					params
+				}, url)),
+				data: null
+			};
+		});
+	}
+	onBeforeCreate(obj) {
+		delete obj.id;
+		return obj;
+	}
+	onBeforeUpdate(objWithId) {
+		return objWithId;
+	}
+	changeFetchOptions(options, _url = "") {
+		return options;
+	}
+	getUrl(url = "") {
+		return `${this.baseUrl.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}`;
+	}
+	getEntityId(entityOrId) {
+		if (entityOrId === void 0 || entityOrId === null) return "";
+		if (typeof entityOrId === "object") return this.getEntityId(entityOrId.id);
+		return `${entityOrId}`;
+	}
+	getDetailUrl(entityOrId) {
+		const id = this.getEntityId(entityOrId);
+		return `${this.listUrl}/${id}`;
+	}
+	fetch(url, init) {
+		return __awaiter(this, void 0, void 0, function* () {
+			const fullUrl = this.getUrl(url);
+			const res = yield this.client.fetch(fullUrl, init);
+			return yield this.handleErrorStatusCodes(res);
+		});
+	}
+	/**
+	* Checks the response for errors and throws exceptions, otherwise returns the response as is.
+	*
+	* @param response The response from server.
+	*
+	* @returns If no errors are detected, it returns the same response.
+	*
+	* @throws If an error is detected, it throws `{ res, data }`, where `data` contains error details from server.
+	*/
+	handleErrorStatusCodes(response) {
+		return __awaiter(this, void 0, void 0, function* () {
+			if (response.status >= 400) {
+				let data = null;
+				try {
+					data = yield response.json();
+				} catch (ex) {
+					try {
+						data = yield response.text();
+					} catch (ex) {}
+				}
+				throw {
+					res: response,
+					data
+				};
+			}
+			return response;
+		});
+	}
+	mimeType(type) {
+		return `application/vnd.com.nsn.cumulocity.${type}+json`;
+	}
+	getIdString(reference) {
+		let id;
+		if (typeof reference === "object") id = reference.id;
+		else id = reference;
+		return String(id);
+	}
+	getPaging(json, filter) {
+		if (json.statistics) {
+			const statistics = Object.assign(Object.assign({}, json.statistics), {
+				nextPage: this.getCurrentPageFromLink(json.next),
+				prevPage: this.getCurrentPageFromLink(json.prev)
+			});
+			return new Paging(this, statistics, filter);
+		}
+		return null;
+	}
+	getCurrentPageFromLink(link = "") {
+		const matches = link.match(/currentPage=(-{0,1}\d+)/);
+		return matches && parseInt(matches[1], 10);
+	}
+};
+
+//#endregion
+export { Service };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/Severity.mjs

@@ -0,0 +1,18 @@
+import { gettext } from "../gettext-typed.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/Severity.js
+const Severity = {
+	CRITICAL: "CRITICAL",
+	MAJOR: "MAJOR",
+	MINOR: "MINOR",
+	WARNING: "WARNING"
+};
+const SEVERITY_LABELS = {
+	CRITICAL: gettext("Critical`alarm`"),
+	MAJOR: gettext("Major`alarm`"),
+	MINOR: gettext("Minor`alarm`"),
+	WARNING: gettext("Warning`alarm`")
+};
+
+//#endregion
+export { SEVERITY_LABELS, Severity };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/index.mjs

@@ -0,0 +1,13 @@
+import { Paging } from "./Paging.mjs";
+import { Service } from "./Service.mjs";
+import { FetchClient } from "./FetchClient.mjs";
+import { BasicAuth } from "./BasicAuth.mjs";
+import { BearerAuth } from "./BearerAuth.mjs";
+import { BearerAuthFromSessionStorage } from "./BearerAuthFromSessionStorage.mjs";
+import { CookieAuth } from "./CookieAuth.mjs";
+import { MicroserviceClientRequestAuth } from "./MicroserviceClientRequestAuth.mjs";
+import { NodeJSCookieAuth } from "./NodeJSCookieAuth.mjs";
+import { SEVERITY_LABELS, Severity } from "./Severity.mjs";
+import { QueriesUtil } from "./QueriesUtil.mjs";
+
+export {  };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/device-registration/DeviceRegistrationBulkService.mjs

@@ -0,0 +1,67 @@
+import { __toESM } from "../../../../../../../../../../_virtual/rolldown_runtime.mjs";
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { require_form_data } from "../../../../../../../../form-data@4.0.4/node_modules/form-data/lib/form_data.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/device-registration/DeviceRegistrationBulkService.js
+var import_form_data = /* @__PURE__ */ __toESM(require_form_data());
+/**
+* This class allows for bulk registering devices.
+*/
+var DeviceRegistrationBulkService = class {
+	/**
+	* Instantiate class and assign client
+	* @param {IFetchClient} client
+	*/
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* A new device registration as bulk.
+	*
+	* @param {Stream | Buffer} csv
+	*
+	* @returns Response wrapped in [[IResult]]
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const csvString = `
+	*  ID,CREDENTIALS,TENANT,TYPE,NAME,ICCID,IDTYPE,PATH,SHELL
+	*  e2eDeviceRegistrationId,e2epassword123!,e2edocker,c8y_e2eDevice,e2eDevice,123456789,89456,e2eDeviceGroup,1
+	*  900001,e2epassword123!,e2edocker,c8y_e2eDevice1,e2eDevice1,123456789,89456,e2eDeviceGroup,1
+	*  900002,e2epassword123!,e2edocker,c8y_e2eDevice2,e2eDevice2,123456789,89456,e2eDeviceGroup,1`.trim();
+	*
+	*  const csvBuffer = Buffer.from(csvString):
+	*
+	*  (async () => {
+	*    const {data, res} = await deviceRegistrationBulkService.create(csvBuffer);
+	*  })();
+	* ```
+	*/
+	create(inputFile) {
+		return __awaiter(this, void 0, void 0, function* () {
+			let csv = inputFile;
+			const url = "/devicecontrol/bulkNewDeviceRequests";
+			const method = "POST";
+			const body = new import_form_data.default();
+			let fileName = "bulk-registration.csv";
+			if (typeof File !== "undefined" && csv instanceof File) {
+				fileName = csv.name;
+				if (csv.name.match(/\.csv$/)) csv = new File([csv], csv.name, { type: "text/csv" });
+			}
+			body.append("file", csv, fileName);
+			const res = yield this.client.fetch(url, {
+				method,
+				body,
+				headers: { accept: "application/json" }
+			});
+			return {
+				res,
+				data: yield res.json()
+			};
+		});
+	}
+};
+
+//#endregion
+export { DeviceRegistrationBulkService };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/device-registration/DeviceRegistrationSecurityMode.mjs

@@ -0,0 +1,13 @@
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/device-registration/DeviceRegistrationSecurityMode.js
+/**
+* Device registration can have one of the following security modes.
+*/
+var DeviceRegistrationSecurityMode;
+(function(DeviceRegistrationSecurityMode) {
+	DeviceRegistrationSecurityMode["REQUIRED"] = "REQUIRED";
+	DeviceRegistrationSecurityMode["OPTIONAL"] = "OPTIONAL";
+	DeviceRegistrationSecurityMode["IGNORED"] = "IGNORED";
+})(DeviceRegistrationSecurityMode || (DeviceRegistrationSecurityMode = {}));
+
+//#endregion
+export { DeviceRegistrationSecurityMode };