@centia-io/sdk 0.0.27 → 0.0.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MapCentia ApS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/centia-io-sdk.cjs

@@ -0,0 +1,588 @@
+
+//#region src/util/jwt-decode.ts
+var InvalidTokenError = class extends Error {};
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+	return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+		let code = p.charCodeAt(0).toString(16).toUpperCase();
+		if (code.length < 2) code = "0" + code;
+		return "%" + code;
+	}));
+}
+function base64UrlDecode(str) {
+	let output = str.replace(/-/g, "+").replace(/_/g, "/");
+	switch (output.length % 4) {
+		case 0: break;
+		case 2:
+			output += "==";
+			break;
+		case 3:
+			output += "=";
+			break;
+		default: throw new Error("base64 string is not of the correct length");
+	}
+	try {
+		return b64DecodeUnicode(output);
+	} catch (err) {
+		return atob(output);
+	}
+}
+function jwtDecode(token, options) {
+	if (typeof token !== "string") throw new InvalidTokenError("Invalid token specified: must be a string");
+	options ||= {};
+	const pos = options.header === true ? 0 : 1;
+	const part = token.split(".")[pos];
+	if (typeof part !== "string") throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+	let decoded;
+	try {
+		decoded = base64UrlDecode(part);
+	} catch (e) {
+		throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+	}
+	try {
+		return JSON.parse(decoded);
+	} catch (e) {
+		throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+	}
+}
+
+//#endregion
+//#region src/util/storage.ts
+var MemoryStorage = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map();
+	}
+	getItem(key) {
+		return this.store.has(key) ? this.store.get(key) : null;
+	}
+	setItem(key, value) {
+		this.store.set(key, String(value));
+	}
+	removeItem(key) {
+		this.store.delete(key);
+	}
+};
+let cached = null;
+function getStorage() {
+	if (cached) return cached;
+	try {
+		const g$1 = typeof globalThis !== "undefined" ? globalThis : window;
+		if (g$1 && g$1.localStorage && typeof g$1.localStorage.getItem === "function") {
+			cached = g$1.localStorage;
+			return cached;
+		}
+	} catch (e) {}
+	const g = typeof globalThis !== "undefined" ? globalThis : {};
+	if (!g.__gc2_memory_storage) g.__gc2_memory_storage = new MemoryStorage();
+	cached = g.__gc2_memory_storage;
+	return cached;
+}
+
+//#endregion
+//#region src/util/utils.ts
+const generatePkceChallenge = async () => {
+	const generateRandomString = () => {
+		const array = new Uint32Array(28);
+		crypto.getRandomValues(array);
+		return Array.from(array, (dec) => ("0" + dec.toString(16)).substr(-2)).join("");
+	};
+	const sha256 = (plain) => {
+		const data = new TextEncoder().encode(plain);
+		return crypto.subtle.digest("SHA-256", data);
+	};
+	const base64urlEncode = (str) => {
+		return btoa(String.fromCharCode.apply(null, [...new Uint8Array(str)])).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	};
+	async function pkceChallengeFromVerifier(v) {
+		return base64urlEncode(await sha256(v));
+	}
+	const { state, codeVerifier } = {
+		state: generateRandomString(),
+		codeVerifier: generateRandomString()
+	};
+	return {
+		state,
+		codeVerifier,
+		codeChallenge: await pkceChallengeFromVerifier(codeVerifier)
+	};
+};
+const isTokenExpired = (token) => {
+	let isJwtExpired = false;
+	const { exp } = jwtDecode(token);
+	const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+	if (exp) {
+		if (currentTime > exp) isJwtExpired = true;
+	}
+	return isJwtExpired;
+};
+const claims = (token) => {
+	return jwtDecode(token);
+};
+const isLogin = async (gc2) => {
+	const { accessToken, refreshToken } = getTokens();
+	if (!accessToken && !refreshToken) return false;
+	if (!accessToken || accessToken && isTokenExpired(accessToken)) {
+		if (refreshToken && isTokenExpired(refreshToken)) {
+			clearTokens();
+			clearOptions();
+			throw new Error("Refresh token has expired. Please login again.");
+		}
+		if (refreshToken) try {
+			const data = await gc2.getRefreshToken(refreshToken);
+			setTokens({
+				accessToken: data.access_token,
+				refreshToken,
+				idToken: data?.id_token
+			});
+			console.log("Access token refreshed");
+		} catch (e) {
+			throw new Error("Could not get refresh token.");
+		}
+	}
+	return true;
+};
+const setTokens = (tokens) => {
+	getStorage().setItem("gc2_tokens", JSON.stringify({
+		"accessToken": tokens.accessToken,
+		"refreshToken": tokens.refreshToken,
+		"idToken": tokens?.idToken || ""
+	}));
+};
+const getTokens = () => {
+	const str = getStorage().getItem("gc2_tokens");
+	const tokens = str ? JSON.parse(str) : {};
+	return {
+		accessToken: tokens?.accessToken || "",
+		refreshToken: tokens?.refreshToken || "",
+		idToken: tokens?.idToken || ""
+	};
+};
+const setOptions = (options) => {
+	getStorage().setItem("gc2_options", JSON.stringify({
+		"clientId": options.clientId,
+		"host": options.host,
+		"redirectUri": options.redirectUri
+	}));
+};
+const getOptions = () => {
+	const str = getStorage().getItem("gc2_options");
+	const options = str ? JSON.parse(str) : {};
+	return {
+		clientId: options?.clientId || "",
+		host: options?.host || "",
+		redirectUri: options?.redirectUri || ""
+	};
+};
+const clearTokens = () => {
+	getStorage().removeItem("gc2_tokens");
+};
+const clearOptions = () => {
+	getStorage().removeItem("gc2_options");
+};
+const getNonce = () => {
+	return getStorage().getItem("gc2_nonce");
+};
+const clearNonce = () => {
+	getStorage().removeItem("gc2_nonce");
+};
+
+//#endregion
+//#region src/services/gc2.services.ts
+var Gc2Service = class {
+	constructor(options) {
+		this.options = options;
+		this.host = options.host;
+	}
+	isCodeFlowOptions(options) {
+		return "redirectUri" in options;
+	}
+	isPasswordFlowOptions(options) {
+		return "username" in options;
+	}
+	buildUrl(path) {
+		if (path.startsWith("http://") || path.startsWith("https://")) return path;
+		return `${this.host}${path}`;
+	}
+	async request(url, method, body, contentType = "application/json") {
+		const headers = { "Content-Type": contentType };
+		let payload;
+		if (contentType === "application/json") payload = JSON.stringify(body);
+		else payload = new URLSearchParams(body).toString();
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: payload
+		});
+		if (!response.ok) {
+			const errText = await response.text();
+			throw new Error(`HTTP error ${response.status}: ${errText}`);
+		}
+		return response.json();
+	}
+	async getDeviceCode() {
+		const path = this.options.deviceUri ?? `${this.host}/api/v4/oauth/device`;
+		return this.request(this.buildUrl(path), "POST", { client_id: this.options.clientId });
+	}
+	async pollToken(deviceCode, interval) {
+		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+		const getToken = async () => {
+			try {
+				return await this.request(this.buildUrl(path), "POST", {
+					client_id: this.options.clientId,
+					device_code: deviceCode,
+					grant_type: "device_code"
+				});
+			} catch (e) {
+				const err = JSON.parse(e.message.split(": ")[1]);
+				if (err.error === "authorization_pending") return null;
+				return err.error_description;
+			}
+		};
+		let response = await getToken();
+		while (response === null) {
+			await new Promise((resolve) => setTimeout(resolve, interval * 1100));
+			response = await getToken();
+		}
+		if (typeof response === "string") throw new Error(response);
+		return response;
+	}
+	getAuthorizationCodeURL(codeChallenge, state) {
+		let redirectUri;
+		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+		else throw new Error("CodeFlow options required for this operation");
+		const base = this.options.authUri ?? `${this.host}/auth/`;
+		const params = new URLSearchParams();
+		const nonce = getNonce();
+		params.set("response_type", "code");
+		params.set("client_id", this.options.clientId);
+		params.set("redirect_uri", redirectUri);
+		params.set("state", state);
+		params.set("code_challenge", codeChallenge);
+		params.set("code_challenge_method", "S256");
+		if (nonce) params.set("nonce", nonce);
+		if (this.options.scope) params.set("scope", this.options.scope);
+		return `${base}?${params.toString()}`;
+	}
+	async getAuthorizationCodeToken(code, codeVerifier) {
+		let redirectUri;
+		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+		else throw new Error("CodeFlow options required for this operation");
+		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+		return this.request(this.buildUrl(path), "POST", {
+			client_id: this.options.clientId,
+			redirect_uri: redirectUri,
+			grant_type: "authorization_code",
+			code,
+			code_verifier: codeVerifier
+		}, "application/x-www-form-urlencoded");
+	}
+	async getPasswordToken() {
+		let username, password, database;
+		if (this.isPasswordFlowOptions(this.options)) {
+			username = this.options.username;
+			password = this.options.password;
+			database = this.options.database;
+		} else throw new Error("PasswordFlow options required for this operation");
+		const path = `${this.host}/api/v4/oauth`;
+		return this.request(this.buildUrl(path), "POST", {
+			client_id: this.options.clientId,
+			grant_type: "password",
+			username,
+			password,
+			database
+		});
+	}
+	async getRefreshToken(token) {
+		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+		return this.request(this.buildUrl(path), "POST", {
+			client_id: this.options.clientId,
+			grant_type: "refresh_token",
+			refresh_token: token
+		});
+	}
+	getSignOutURL() {
+		let redirectUri;
+		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+		else throw new Error("CodeFlow options required for this operation");
+		const params = new URLSearchParams({ redirect_uri: redirectUri });
+		return this.options.logoutUri ?? `${this.host}/signout?${params.toString()}`;
+	}
+};
+
+//#endregion
+//#region src/CodeFlow.ts
+var CodeFlow = class {
+	constructor(options) {
+		this.options = options;
+		this.service = new Gc2Service(options);
+	}
+	async redirectHandle() {
+		const url = window.location.search;
+		const queryParams = new URLSearchParams(url);
+		if (queryParams.get("error")) throw new Error(`Failed to redirect: ${url}`);
+		const code = queryParams.get("code");
+		if (code) {
+			if (queryParams.get("state") !== getStorage().getItem("state")) throw new Error("Possible CSRF attack. Aborting login!");
+			try {
+				const { access_token, refresh_token, id_token } = await this.service.getAuthorizationCodeToken(code, getStorage().getItem("codeVerifier"));
+				setTokens({
+					accessToken: access_token,
+					refreshToken: refresh_token,
+					idToken: id_token
+				});
+				setOptions({
+					clientId: this.options.clientId,
+					host: this.options.host,
+					redirectUri: this.options.redirectUri
+				});
+				getStorage().removeItem("state");
+				getStorage().removeItem("codeVerifier");
+				const params = new URLSearchParams(window.location.search);
+				params.delete("code");
+				params.delete("state");
+				const loc = window.location;
+				const newUrl = loc.origin + loc.pathname + (params.size > 0 ? "?" + params.toString() : "");
+				history.pushState(null, "", newUrl);
+				return Promise.resolve(true);
+			} catch (e) {
+				throw new Error(e.message);
+			}
+		}
+		return await isLogin(this.service);
+	}
+	async signIn() {
+		const { state, codeVerifier, codeChallenge } = await generatePkceChallenge();
+		getStorage().setItem("state", state);
+		getStorage().setItem("codeVerifier", codeVerifier);
+		window.location = this.service.getAuthorizationCodeURL(codeChallenge, state);
+	}
+	signOut() {
+		this.clear();
+		window.location = this.service.getSignOutURL();
+	}
+	clear() {
+		clearTokens();
+		clearOptions();
+		clearNonce();
+	}
+};
+
+//#endregion
+//#region src/PasswordFlow.ts
+var PasswordFlow = class {
+	constructor(options) {
+		this.options = options;
+		this.service = new Gc2Service(options);
+	}
+	async signIn() {
+		const { access_token, refresh_token } = await this.service.getPasswordToken();
+		setTokens({
+			accessToken: access_token,
+			refreshToken: refresh_token
+		});
+		setOptions({
+			clientId: this.options.clientId,
+			host: this.options.host,
+			redirectUri: ""
+		});
+	}
+	signOut() {
+		this.clear();
+	}
+	clear() {
+		clearTokens();
+		clearOptions();
+		clearNonce();
+	}
+};
+
+//#endregion
+//#region src/util/request-headers.ts
+const getHeaders = async (contentType = "application/json") => {
+	if (!await isLogin(new Gc2Service(getOptions()))) return Promise.reject("Is not logged in");
+	const { accessToken } = getTokens();
+	const headers = {
+		Accept: "application/json",
+		Cookie: "XDEBUG_SESSION=XDEBUG_ECLIPSE",
+		Authorization: accessToken ? "Bearer " + accessToken : null
+	};
+	if (contentType) headers["Content-Type"] = contentType;
+	return headers;
+};
+var request_headers_default = getHeaders;
+
+//#endregion
+//#region src/util/make-request.ts
+const make = async (version, resource, method, payload, contentType = "application/json") => {
+	const options = getOptions();
+	let request = {
+		method,
+		headers: await request_headers_default(contentType),
+		redirect: "manual"
+	};
+	if (payload) request.body = contentType === "application/json" ? JSON.stringify(payload) : payload;
+	return await fetch(options.host + `/api/v${version}/${resource}`, request);
+};
+var make_request_default = make;
+
+//#endregion
+//#region src/util/get-response.ts
+const get = async (response, expectedCode) => {
+	let res = null;
+	let bodyText = "";
+	try {
+		bodyText = await response.text();
+	} catch (e) {}
+	if (bodyText) try {
+		res = JSON.parse(bodyText);
+	} catch (e) {}
+	if (response.status !== expectedCode) {
+		const msg = res && (res.message || res.error) || bodyText || `Unexpected status ${response.status}`;
+		throw new Error(msg);
+	}
+	return res;
+};
+var get_response_default = get;
+
+//#endregion
+//#region src/Sql.ts
+var Sql = class {
+	async exec(request) {
+		return await get_response_default(await make_request_default("4", `sql`, "POST", request), 200);
+	}
+};
+
+//#endregion
+//#region src/Rpc.ts
+var Rpc = class {
+	async call(request) {
+		return await get_response_default(await make_request_default("4", `call`, "POST", request), 200);
+	}
+};
+
+//#endregion
+//#region src/Meta.ts
+var Meta = class {
+	async query(rel) {
+		return await get_response_default(await make_request_default("3", `meta/${rel}`, "GET", null), 200);
+	}
+};
+
+//#endregion
+//#region src/Status.ts
+var Status = class {
+	isAuth() {
+		const tokens = getTokens();
+		return !(!tokens.accessToken && !tokens.refreshToken);
+	}
+	getTokens() {
+		return getTokens();
+	}
+};
+
+//#endregion
+//#region src/Claims.ts
+var Claims = class {
+	get() {
+		const tokens = getTokens().accessToken;
+		return claims(tokens);
+	}
+};
+
+//#endregion
+//#region src/Users.ts
+var Users = class {
+	async get(user) {
+		return await get_response_default(await make_request_default("4", `users/${user}`, "GET", null), 200);
+	}
+};
+
+//#endregion
+//#region src/Ws.ts
+var Ws = class {
+	constructor(options) {
+		this.options = options;
+	}
+	connect() {
+		const me = this;
+		const { accessToken } = getTokens();
+		const connect = () => {
+			const ws = new WebSocket(this.options.host + `/?token=` + accessToken);
+			ws.onopen = function() {
+				console.log("WebSocket connected!");
+			};
+			ws.onmessage = function(event) {
+				me.options?.callBack(event.data);
+			};
+			ws.onclose = function(event) {
+				if (accessToken !== "") {
+					console.log("WebSocket closed, reconnecting in 3 seconds...", event.reason);
+					setTimeout(connect, 3e3);
+				}
+			};
+			ws.onerror = function(err) {
+				console.error("WebSocket error observed:", err);
+				ws.close();
+			};
+		};
+		if (accessToken !== "") connect();
+	}
+};
+
+//#endregion
+//#region src/Stats.ts
+var Stats = class {
+	async get() {
+		return await get_response_default(await make_request_default("4", `stats`, "GET", null), 200);
+	}
+};
+
+//#endregion
+//#region src/Tables.ts
+var Tables = class {
+	async get(schema, table) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "GET", null), 200);
+	}
+	async create(schema, table, payload) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "POST", payload), 200);
+	}
+	async patch(schema, table, payload) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "PATCH", payload), 200);
+	}
+	async delete(schema, table) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "DELETE", null), 204);
+	}
+};
+
+//#endregion
+//#region src/Api.ts
+async function dispatch(name, args) {
+	const rpc = new Rpc();
+	const request = {
+		jsonrpc: "2.0",
+		method: name,
+		id: 1,
+		params: args
+	};
+	return (await rpc.call(request)).result.data;
+}
+function createApi() {
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return void 0;
+		return (...args) => dispatch(prop, ...args);
+	} });
+}
+
+//#endregion
+exports.Claims = Claims;
+exports.CodeFlow = CodeFlow;
+exports.Meta = Meta;
+exports.PasswordFlow = PasswordFlow;
+exports.Rpc = Rpc;
+exports.Sql = Sql;
+exports.Stats = Stats;
+exports.Status = Status;
+exports.Tables = Tables;
+exports.Users = Users;
+exports.Ws = Ws;
+exports.createApi = createApi;