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/audit/AuditService.mjs

@@ -0,0 +1,95 @@
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { Service } from "../core/Service.mjs";
+import "../core/index.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/audit/AuditService.js
+var AuditService = class extends Service {
+	constructor() {
+		super(...arguments);
+		this.baseUrl = "audit";
+		this.listUrl = "auditRecords";
+		this.propertyName = "auditRecords";
+	}
+	/**
+	* Gets the details of selected audit record.
+	*
+	* @param {string|number|IAuditRecord} entityOrId Entity or Id of the entity.
+	*
+	* @returns Response wrapped in [[IResult]]
+	*
+	* **Example**
+	* ```typescript
+	*
+	*    const auditId: number = 1;
+	*
+	*    (async () => {
+	*      const {data, res} = await auditService.detail(auditId);
+	*   })();
+	* ```
+	*/
+	detail(entityOrId) {
+		const _super = Object.create(null, { detail: { get: () => super.detail } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.detail.call(this, entityOrId);
+		});
+	}
+	/**
+	* Creates a new audit record for a given source.
+	*
+	* @param {IAuditRecord} entity Audit record object with mandantory fragments.
+	* IAuditRecord implements the [[IEvent]] interface.
+	*
+	* @returns Response wrapped in [[IResult]]
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const mandantoryObject: IAuditRecord = {
+	*    type: AuditRecordType.ALARM,
+	*    time: '2018-05-02T10:08:00Z',
+	*    severity: Severity.MAJOR,
+	*    source: {id: 1}
+	*  };
+	*
+	*  (async () => {
+	*    const {data, res} = await auditService.create(mandantoryObject);
+	*  })();
+	* ```
+	*/
+	create(entity) {
+		const _super = Object.create(null, { create: { get: () => super.create } });
+		return __awaiter(this, void 0, void 0, function* () {
+			return _super.create.call(this, entity);
+		});
+	}
+	/**
+	* Gets the list of audit records filtered by parameters.
+	*
+	* @returns Response wrapped in [[IResultList]]
+	*
+	* @param {object} filter Object containing filters for querying audit records.
+	*
+	* **Example**
+	* ```typescript
+	*
+	*  const filter: object = {
+	*     severity: Severity.MAJOR,
+	*     pageSize: 100,
+	*     withTotalPages: true
+	*   };
+	*
+	*   (async () => {
+	*     const {data, res, paging} = await auditService.list(filter);
+	*   })();
+	* ```
+	*/
+	list() {
+		const _super = Object.create(null, { list: { get: () => super.list } });
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			return _super.list.call(this, filter);
+		});
+	}
+};
+
+//#endregion
+export { AuditService };

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

@@ -0,0 +1,15 @@
+import { gettext } from "../gettext.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/audit/ChangeType.js
+/**
+* An audit record can have one of the following change type
+*/
+var ChangeType;
+(function(ChangeType) {
+	ChangeType[ChangeType["ADDED"] = gettext("ADDED")] = "ADDED";
+	ChangeType[ChangeType["REPLACED"] = gettext("REPLACED")] = "REPLACED";
+	ChangeType[ChangeType["REMOVED"] = gettext("REMOVED")] = "REMOVED";
+})(ChangeType || (ChangeType = {}));
+
+//#endregion
+export { ChangeType };

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

@@ -0,0 +1,5 @@
+import { AuditService } from "./AuditService.mjs";
+import { AuditRecordType } from "./AuditRecordType.mjs";
+import { ChangeType } from "./ChangeType.mjs";
+
+export {  };

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

@@ -0,0 +1,69 @@
+import { require_lib } from "../../../../../../../../b2a@1.1.2/node_modules/b2a/lib/index.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/BasicAuth.js
+var import_lib = require_lib();
+var secrets = /* @__PURE__ */ new WeakMap();
+/**
+* Allows to use Basic-Auth for Authorization to the
+* Cumulocity API.
+*/
+var BasicAuth = class {
+	/**
+	* Authenticates the given user against the given tenant.
+	* @param name
+	* @param password
+	* @param tenant
+	*/
+	constructor(credentials) {
+		this.updateCredentials(credentials);
+	}
+	updateCredentials({ tenant, user, password, token, tfa } = {}) {
+		const secret = secrets.get(this) || {};
+		if (user && tenant) user = `${tenant}/${user}`;
+		user = user || this.user;
+		password = password || secret.password;
+		if (!token && user && password) token = (0, import_lib.btoa)(`${user}:${password}`);
+		if (user) this.user = user;
+		token = token || secret.token;
+		tfa = tfa || secret.tfa;
+		secrets.set(this, {
+			tfa,
+			token,
+			password
+		});
+		return token;
+	}
+	getFetchOptions(options) {
+		const { token, tfa } = secrets.get(this);
+		const xsrfToken = this.getCookieValue("XSRF-TOKEN");
+		const headers = Object.assign({ Authorization: `Basic ${token || ""}` }, xsrfToken ? { "X-XSRF-TOKEN": xsrfToken } : void 0);
+		if (tfa) headers.tfatoken = tfa;
+		options.headers = Object.assign(headers, options.headers);
+		return options;
+	}
+	getCometdHandshake(config = {}) {
+		const { token, tfa } = secrets.get(this);
+		const KEY = "com.cumulocity.authn";
+		const ext = config.ext = config.ext || {};
+		ext[KEY] = Object.assign(ext[KEY] || {}, {
+			token,
+			tfa
+		});
+		return config;
+	}
+	logout() {
+		delete this.user;
+		secrets.set(this, {});
+	}
+	getCookieValue(name) {
+		try {
+			const value = document.cookie.match("(^|;)\\s*" + name + "\\s*=\\s*([^;]+)");
+			return value ? value.pop() : void 0;
+		} catch (ex) {
+			return;
+		}
+	}
+};
+
+//#endregion
+export { BasicAuth };

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

@@ -0,0 +1,52 @@
+import { FetchClient } from "./FetchClient.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/BearerAuth.js
+const secrets = /* @__PURE__ */ new WeakMap();
+var BearerAuth = class {
+	constructor(token) {
+		this.logoutUrl = "user/logout";
+		secrets.set(this, { token });
+	}
+	getFetchOptions(options) {
+		const token = this.getToken();
+		options.headers = Object.assign({ Authorization: `Bearer ${token}` }, options.headers);
+		return options;
+	}
+	updateCredentials({ token }) {
+		secrets.set(this, { token });
+	}
+	getCometdHandshake(config = {}) {
+		const { tfa } = secrets.get(this);
+		const token = this.getToken();
+		const KEY = "com.cumulocity.authn";
+		const ext = config.ext = config.ext || {};
+		ext[KEY] = Object.assign(ext[KEY] || {}, {
+			token,
+			tfa
+		});
+		return config;
+	}
+	logout(options = {}) {
+		const client = new FetchClient();
+		client.setAuth(this);
+		const method = "POST";
+		const body = JSON.stringify({});
+		return client.fetch(this.logoutUrl, Object.assign({
+			headers: {
+				"content-type": "application/json",
+				accept: "application/json"
+			},
+			body,
+			method
+		}, options)).finally(() => {
+			secrets.set(this, {});
+		});
+	}
+	getToken() {
+		const { token } = secrets.get(this);
+		return token;
+	}
+};
+
+//#endregion
+export { BearerAuth };

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

@@ -0,0 +1,43 @@
+import { BearerAuth } from "./BearerAuth.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/BearerAuthFromSessionStorage.js
+var BearerAuthFromSessionStorage = class BearerAuthFromSessionStorage extends BearerAuth {
+	static removeEntriesFromSessionStorage() {
+		sessionStorage.removeItem(BearerAuthFromSessionStorage.sessionStorageKey);
+		sessionStorage.removeItem(BearerAuthFromSessionStorage.sessionStorageKeyToKeepToken);
+	}
+	constructor(throwIfNoTokenPresent = true) {
+		super();
+		if (!this.getToken() && throwIfNoTokenPresent) throw new Error("No token present in session storage");
+	}
+	updateCredentials({ token }) {
+		if (!token) return;
+		super.updateCredentials({ token });
+	}
+	logout() {
+		return super.logout().finally(() => {
+			BearerAuthFromSessionStorage.removeEntriesFromSessionStorage();
+		});
+	}
+	getToken() {
+		const token = sessionStorage.getItem(BearerAuthFromSessionStorage.sessionStorageKey);
+		if (token) {
+			if (!(sessionStorage.getItem(BearerAuthFromSessionStorage.sessionStorageKeyToKeepToken) === "true")) sessionStorage.removeItem(BearerAuthFromSessionStorage.sessionStorageKey);
+			this.updateCredentials({ token });
+			return token;
+		}
+		return super.getToken();
+	}
+};
+/**
+* Key for the session storage used to retrieve the bearer token from.
+*/
+BearerAuthFromSessionStorage.sessionStorageKey = "bearerAuthToken";
+/**
+* If the session storage key 'bearerAuthTokenKeep' is set to true, the token will be kept in session storage after it was found.
+* Allows you to still refresh the page.
+*/
+BearerAuthFromSessionStorage.sessionStorageKeyToKeepToken = `bearerAuthTokenKeep`;
+
+//#endregion
+export { BearerAuthFromSessionStorage };

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

@@ -0,0 +1,53 @@
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { FetchClient } from "./FetchClient.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/CookieAuth.js
+/**
+* Allows to use Cookies for Authorization to the
+* Cumulocity API.
+*/
+var CookieAuth = class {
+	constructor() {
+		this.logoutUrl = "user/logout";
+	}
+	updateCredentials({ user } = {}) {
+		this.user = user;
+	}
+	getFetchOptions(options) {
+		const xsrfToken = this.getCookieValue("XSRF-TOKEN");
+		const headers = { "X-XSRF-TOKEN": xsrfToken };
+		options.headers = Object.assign(headers, options.headers);
+		return options;
+	}
+	getCometdHandshake(config = {}) {
+		const KEY = "com.cumulocity.authn";
+		const xsrfToken = this.getCookieValue("XSRF-TOKEN");
+		const ext = config.ext = config.ext || {};
+		ext[KEY] = Object.assign(ext[KEY] || {}, { xsrfToken });
+		return config;
+	}
+	logout() {
+		return __awaiter(this, arguments, void 0, function* (options = {}) {
+			if (this.user) delete this.user;
+			const client = new FetchClient();
+			client.setAuth(this);
+			const method = "POST";
+			const body = JSON.stringify({});
+			return client.fetch(this.logoutUrl, Object.assign({
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json"
+				},
+				body,
+				method
+			}, options));
+		});
+	}
+	getCookieValue(name) {
+		const value = document.cookie.match("(^|;)\\s*" + name + "\\s*=\\s*([^;]+)");
+		return value ? value.pop() : "";
+	}
+};
+
+//#endregion
+export { CookieAuth };

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

@@ -0,0 +1,82 @@
+import { __toESM } from "../../../../../../../../../../_virtual/rolldown_runtime.mjs";
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+import { require_node_ponyfill } from "../../../../../../../../cross-fetch@4.1.0_encoding@0.1.13/node_modules/cross-fetch/dist/node-ponyfill.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/FetchClient.js
+var import_node_ponyfill = /* @__PURE__ */ __toESM(require_node_ponyfill());
+let auths = /* @__PURE__ */ new WeakMap();
+var FetchClient = class {
+	constructor(authOrBaseUrl, baseUrl) {
+		this.baseUrl = baseUrl;
+		this.tenant = "";
+		this.defaultHeaders = {};
+		this.defaultFetchOptions = {};
+		if (typeof authOrBaseUrl === "string") baseUrl = authOrBaseUrl;
+		else this.setAuth(authOrBaseUrl);
+		this.baseUrl = this.resolveServerUrl(baseUrl);
+	}
+	setAuth(auth) {
+		auths.set(this, auth);
+	}
+	performLogoutOnCurrentAuthStrategy() {
+		const auth = auths.get(this);
+		if (auth) return auth.logout();
+	}
+	authIsInstanceOf(authClass) {
+		const auth = auths.get(this);
+		return auth && auth instanceof authClass;
+	}
+	fetch(url, init) {
+		return __awaiter(this, void 0, void 0, function* () {
+			let fetchFn = import_node_ponyfill.default;
+			try {
+				fetchFn = window.fetch || fetchFn;
+			} catch (e) {}
+			const fullUrl = this.getUrl(url, init);
+			const options = this.getFetchOptions(init);
+			const optionsWithAdjustedBody = this.adjustOptionsForFormData(options);
+			return fetchFn(fullUrl, optionsWithAdjustedBody);
+		});
+	}
+	getUrl(url = "", options) {
+		const params = options && options.params;
+		let paramPart = "";
+		if (params && Object.keys(params).length) {
+			paramPart = Object.keys(params).map((k) => {
+				let vals = params[k];
+				const encodedKey = encodeURIComponent(k);
+				if (!Array.isArray(vals)) vals = [vals];
+				return vals.map((v) => `${encodedKey}=${encodeURIComponent(v)}`).join("&");
+			}).join("&");
+			paramPart = `?${paramPart}`;
+		}
+		return `${this.baseUrl.replace(/\/+$/, "").replace(/^\/+/, "")}/${url.replace(/\/+$/, "").replace(/^\/+/, "")}${paramPart}`;
+	}
+	getFetchOptions(options = {}) {
+		let clonedOptions = Object.assign(Object.assign({}, this.defaultFetchOptions), options);
+		const auth = auths.get(this);
+		clonedOptions.headers = Object.assign({}, this.defaultHeaders, clonedOptions.headers, { UseXBasic: true });
+		delete clonedOptions.params;
+		clonedOptions = auth ? auth.getFetchOptions(clonedOptions) : clonedOptions;
+		return clonedOptions;
+	}
+	getCometdHandshake(config = {}) {
+		const auth = auths.get(this);
+		return auth ? auth.getCometdHandshake(config) : config;
+	}
+	resolveServerUrl(baseUrl = "") {
+		if (baseUrl && baseUrl.startsWith("http")) return baseUrl.replace(/\/+$/, "");
+		try {
+			const location = window.location;
+			return `${location.protocol}//${location.host}/${baseUrl.replace(/\/+$/, "")}`;
+		} catch (ex) {
+			throw Error("Your environment does not support relative URLs. Please provide a base URL.");
+		}
+	}
+	adjustOptionsForFormData(options) {
+		return Object.assign(options, { body: options.body });
+	}
+};
+
+//#endregion
+export { FetchClient };

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

@@ -0,0 +1,50 @@
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/MicroserviceClientRequestAuth.js
+/**
+* Allows to use either Cookie-Auth or Basic-Auth
+* of a microservice client request header
+* for Authorization to the Cumulocity API.
+*/
+var MicroserviceClientRequestAuth = class {
+	/**
+	* Authenticates using the credentials which were
+	* provided within the request headers of the
+	* client call to the microservice.
+	* @param headers
+	*/
+	constructor(headers = {}) {
+		this.xsrfToken = this.getCookieValue(headers, "XSRF-TOKEN");
+		this.authTokenFromCookie = this.getCookieValue(headers, "authorization");
+		this.authTokenFromHeader = headers.authorization;
+	}
+	updateCredentials() {}
+	getFetchOptions(options) {
+		const headers = Object.assign({ Authorization: this.authTokenFromCookie ? `Bearer ${this.authTokenFromCookie}` : this.authTokenFromHeader }, this.xsrfToken ? { "X-XSRF-TOKEN": this.xsrfToken } : void 0);
+		options.headers = Object.assign(headers, options.headers);
+		return options;
+	}
+	getCometdHandshake(config = {}) {
+		const KEY = "com.cumulocity.authn";
+		const xsrfToken = this.xsrfToken;
+		let token = this.authTokenFromCookie;
+		if (!token && this.authTokenFromHeader) token = this.authTokenFromHeader.replace("Basic ", "").replace("Bearer ", "");
+		const ext = config.ext = config.ext || {};
+		ext[KEY] = Object.assign(ext[KEY] || {}, Object.assign({ token }, xsrfToken ? { xsrfToken } : void 0));
+		return config;
+	}
+	logout() {
+		if (this.authTokenFromCookie) delete this.authTokenFromCookie;
+		if (this.authTokenFromHeader) delete this.authTokenFromHeader;
+		if (this.xsrfToken) delete this.xsrfToken;
+	}
+	getCookieValue(headers, name) {
+		try {
+			const value = headers && headers.cookie && headers.cookie.match("(^|;)\\s*" + name + "\\s*=\\s*([^;]+)");
+			return value ? value.pop() : void 0;
+		} catch (ex) {
+			return;
+		}
+	}
+};
+
+//#endregion
+export { MicroserviceClientRequestAuth };

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

@@ -0,0 +1,19 @@
+import { MicroserviceClientRequestAuth } from "./MicroserviceClientRequestAuth.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/NodeJSCookieAuth.js
+/**
+* Extracts the `authorization` cookie from the `set-cookie` header of a response.
+*
+* Meant to be used in none browser environments like nodejs which don't deal with cookies.
+*/
+var NodeJSCookieAuth = class extends MicroserviceClientRequestAuth {
+	constructor(cookieResponse) {
+		super();
+		const setCookiesHeader = cookieResponse.headers.get("set-cookie");
+		if (!setCookiesHeader) throw Error("No Cookie set");
+		this.authTokenFromCookie = this.getCookieValue({ cookie: setCookiesHeader }, "authorization");
+	}
+};
+
+//#endregion
+export { NodeJSCookieAuth };

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

@@ -0,0 +1,68 @@
+import { __awaiter } from "../../../../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/esm2015/src/core/Paging.js
+/**
+* Paging allows you to query the next and previous data chunks
+* in a convenient way. You can also go to a specific page or just read
+* page information about the current data chunk.
+* Note that page numbers are generated by backend
+* and may be used as offset rather than a continuous range of positive numbers
+* (e.g. in case of users with restricted permissions).
+*/
+var Paging = class {
+	constructor(service, statistics, filter) {
+		this.filter = filter;
+		this.service = service;
+		this.currentPage = statistics.currentPage;
+		this.nextPage = statistics.nextPage;
+		this.prevPage = statistics.prevPage;
+		this.pageSize = statistics.pageSize;
+		this.totalPages = statistics.totalPages;
+		this.totalElements = statistics.totalElements;
+	}
+	/**
+	* Gets the next page of available data from the server.
+	* @param filter
+	*/
+	next() {
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			return this.list(this.getFilter(filter, this.nextPage));
+		});
+	}
+	/**
+	* Gets the previous page of available data from server.
+	* @param filter
+	*/
+	prev() {
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			return this.list(this.getFilter(filter, this.prevPage));
+		});
+	}
+	/**
+	* Method used by next(), prev() and goto() to call the service.list method.
+	* It is public so it can be overriden in special cases (like children objects
+	* in inventory).
+	* @param filter
+	*/
+	list() {
+		return __awaiter(this, arguments, void 0, function* (filter = {}) {
+			return this.service.list(filter);
+		});
+	}
+	/**
+	* Goes to the page that you define as page parameter.
+	* @param page
+	* @param filter
+	*/
+	goto(page_1) {
+		return __awaiter(this, arguments, void 0, function* (page, filter = {}) {
+			return this.list(this.getFilter(filter, page));
+		});
+	}
+	getFilter(filter, page) {
+		return Object.assign(filter, this.filter, { currentPage: page });
+	}
+};
+
+//#endregion
+export { Paging };