@centia-io/sdk 0.1.2 → 0.2.0

package/dist/centia-io-sdk-node.cjs

@@ -0,0 +1,174 @@
+
+//#region \0@oxc-project+runtime@0.101.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/auth/configstoreTokenStore.ts
+const LOCK_RETRIES = 5;
+const LOCK_RETRY_MIN_MS = 100;
+const LOCK_RETRY_MAX_MS = 500;
+const LOCK_STALE_MS = 1e4;
+/**
+* Build a Node-only file-backed {@link TokenStore} that persists OAuth
+* credentials at `~/.config/configstore/<name>.json` (or
+* `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process
+* and cross-process write safety.
+*
+* **Shared-state intent.** The `name` is the file name on disk. Two processes
+* (e.g. `gc2-cli` and a local MCP server) that pass the same name share the
+* same on-disk credentials and therefore the same login session. The default
+* `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time
+* `gc2 login` is observable to every process that calls
+* `createConfigstoreTokenStore()` with no argument. Pass a different name
+* to isolate.
+*
+* **In-process correctness.** A serial promise chain on `set()` ensures
+* concurrent same-process calls do not race on the shared configstore cache.
+*
+* **Cross-process correctness.** `proper-lockfile` serializes the
+* read-merge-write critical section across processes so two simultaneous
+* `set()` calls from different processes cannot corrupt the file.
+*
+* **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`
+* out of browser bundles even when this module is imported through the SDK
+* barrel. Calling this function in a browser environment will fail at
+* runtime when the deferred `await import('configstore')` cannot resolve.
+*
+* @param name - configstore file name (without `.json`). Default `'gc2-env'`
+*               matches `gc2-cli`'s configstore so credentials are shared.
+* @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.
+*/
+function createConfigstoreTokenStore(name = "gc2-env") {
+	let configstoreInstance = null;
+	let setChain = Promise.resolve();
+	async function getConfigstore() {
+		var _default;
+		if (configstoreInstance) return configstoreInstance;
+		const mod = await import("configstore");
+		const Configstore = (_default = mod.default) !== null && _default !== void 0 ? _default : mod;
+		const { homedir } = await import("node:os");
+		const { join } = await import("node:path");
+		configstoreInstance = new Configstore(name, void 0, { configPath: join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "configstore", `${name}.json`) });
+		return configstoreInstance;
+	}
+	async function getLockfile() {
+		var _default2;
+		const mod = await import("proper-lockfile");
+		return (_default2 = mod.default) !== null && _default2 !== void 0 ? _default2 : mod;
+	}
+	function readAll(cs) {
+		const result = {};
+		const token = cs.get("token");
+		const refresh_token = cs.get("refresh_token");
+		const host = cs.get("host");
+		if (token !== void 0) result.token = token;
+		if (refresh_token !== void 0) result.refresh_token = refresh_token;
+		if (host !== void 0) result.host = host;
+		return result;
+	}
+	async function doLockedSet(patch) {
+		const cs = await getConfigstore();
+		const lockfile = await getLockfile();
+		const filePath = cs.path;
+		const { mkdirSync, writeFileSync } = await import("node:fs");
+		const { dirname } = await import("node:path");
+		try {
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, "{}", { flag: "wx" });
+		} catch (e) {
+			if ((e === null || e === void 0 ? void 0 : e.code) !== "EEXIST") throw e;
+		}
+		const release = await lockfile.lock(filePath, {
+			retries: {
+				retries: LOCK_RETRIES,
+				minTimeout: LOCK_RETRY_MIN_MS,
+				maxTimeout: LOCK_RETRY_MAX_MS,
+				factor: 2
+			},
+			stale: LOCK_STALE_MS,
+			realpath: false
+		});
+		try {
+			configstoreInstance = null;
+			const fresh = await getConfigstore();
+			fresh.all = _objectSpread2(_objectSpread2({}, readAll(fresh)), patch);
+		} finally {
+			await release();
+		}
+	}
+	return {
+		async get() {
+			return readAll(await getConfigstore());
+		},
+		async set(patch) {
+			const next = setChain.then(() => doLockedSet(patch));
+			setChain = next.catch(() => {});
+			return next;
+		}
+	};
+}
+
+//#endregion
+exports.createConfigstoreTokenStore = createConfigstoreTokenStore;

package/dist/centia-io-sdk-node.d.cts

@@ -0,0 +1,50 @@
+//#region src/auth/types.d.ts
+
+interface StoredCredentials {
+  token?: string;
+  refresh_token?: string;
+  host?: string;
+  user?: string;
+  database?: string;
+  superUser?: boolean;
+}
+interface TokenStore {
+  get(): Promise<StoredCredentials>;
+  set(patch: Partial<StoredCredentials>): Promise<void>;
+}
+//#endregion
+//#region src/auth/configstoreTokenStore.d.ts
+/**
+ * Build a Node-only file-backed {@link TokenStore} that persists OAuth
+ * credentials at `~/.config/configstore/<name>.json` (or
+ * `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process
+ * and cross-process write safety.
+ *
+ * **Shared-state intent.** The `name` is the file name on disk. Two processes
+ * (e.g. `gc2-cli` and a local MCP server) that pass the same name share the
+ * same on-disk credentials and therefore the same login session. The default
+ * `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time
+ * `gc2 login` is observable to every process that calls
+ * `createConfigstoreTokenStore()` with no argument. Pass a different name
+ * to isolate.
+ *
+ * **In-process correctness.** A serial promise chain on `set()` ensures
+ * concurrent same-process calls do not race on the shared configstore cache.
+ *
+ * **Cross-process correctness.** `proper-lockfile` serializes the
+ * read-merge-write critical section across processes so two simultaneous
+ * `set()` calls from different processes cannot corrupt the file.
+ *
+ * **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`
+ * out of browser bundles even when this module is imported through the SDK
+ * barrel. Calling this function in a browser environment will fail at
+ * runtime when the deferred `await import('configstore')` cannot resolve.
+ *
+ * @param name - configstore file name (without `.json`). Default `'gc2-env'`
+ *               matches `gc2-cli`'s configstore so credentials are shared.
+ * @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.
+ */
+declare function createConfigstoreTokenStore(name?: string): TokenStore;
+//#endregion
+export { createConfigstoreTokenStore };
+//# sourceMappingURL=centia-io-sdk-node.d.cts.map

package/dist/centia-io-sdk-node.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"centia-io-sdk-node.d.cts","names":[],"sources":["../src/auth/types.ts","../src/auth/configstoreTokenStore.ts"],"sourcesContent":[],"mappings":";;AAoB4C,UAX3B,iBAAA,CAW2B;EAAO,KAAA,CAAA,EAAA,MAAA;;;;;;;UAFlC,UAAA;SACN,QAAQ;aACJ,QAAQ,qBAAqB;ACwB5C;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;iBAAgB,2BAAA,iBAA+C"}

package/dist/centia-io-sdk-node.d.ts

@@ -0,0 +1,50 @@
+//#region src/auth/types.d.ts
+
+interface StoredCredentials {
+  token?: string;
+  refresh_token?: string;
+  host?: string;
+  user?: string;
+  database?: string;
+  superUser?: boolean;
+}
+interface TokenStore {
+  get(): Promise<StoredCredentials>;
+  set(patch: Partial<StoredCredentials>): Promise<void>;
+}
+//#endregion
+//#region src/auth/configstoreTokenStore.d.ts
+/**
+ * Build a Node-only file-backed {@link TokenStore} that persists OAuth
+ * credentials at `~/.config/configstore/<name>.json` (or
+ * `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process
+ * and cross-process write safety.
+ *
+ * **Shared-state intent.** The `name` is the file name on disk. Two processes
+ * (e.g. `gc2-cli` and a local MCP server) that pass the same name share the
+ * same on-disk credentials and therefore the same login session. The default
+ * `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time
+ * `gc2 login` is observable to every process that calls
+ * `createConfigstoreTokenStore()` with no argument. Pass a different name
+ * to isolate.
+ *
+ * **In-process correctness.** A serial promise chain on `set()` ensures
+ * concurrent same-process calls do not race on the shared configstore cache.
+ *
+ * **Cross-process correctness.** `proper-lockfile` serializes the
+ * read-merge-write critical section across processes so two simultaneous
+ * `set()` calls from different processes cannot corrupt the file.
+ *
+ * **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`
+ * out of browser bundles even when this module is imported through the SDK
+ * barrel. Calling this function in a browser environment will fail at
+ * runtime when the deferred `await import('configstore')` cannot resolve.
+ *
+ * @param name - configstore file name (without `.json`). Default `'gc2-env'`
+ *               matches `gc2-cli`'s configstore so credentials are shared.
+ * @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.
+ */
+declare function createConfigstoreTokenStore(name?: string): TokenStore;
+//#endregion
+export { createConfigstoreTokenStore };
+//# sourceMappingURL=centia-io-sdk-node.d.ts.map

package/dist/centia-io-sdk-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"centia-io-sdk-node.d.ts","names":[],"sources":["../src/auth/types.ts","../src/auth/configstoreTokenStore.ts"],"sourcesContent":[],"mappings":";;AAoB4C,UAX3B,iBAAA,CAW2B;EAAO,KAAA,CAAA,EAAA,MAAA;;;;;;;UAFlC,UAAA;SACN,QAAQ;aACJ,QAAQ,qBAAqB;ACwB5C;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;iBAAgB,2BAAA,iBAA+C"}

package/dist/centia-io-sdk-node.js

@@ -0,0 +1,174 @@
+//#region \0@oxc-project+runtime@0.101.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/auth/configstoreTokenStore.ts
+const LOCK_RETRIES = 5;
+const LOCK_RETRY_MIN_MS = 100;
+const LOCK_RETRY_MAX_MS = 500;
+const LOCK_STALE_MS = 1e4;
+/**
+* Build a Node-only file-backed {@link TokenStore} that persists OAuth
+* credentials at `~/.config/configstore/<name>.json` (or
+* `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process
+* and cross-process write safety.
+*
+* **Shared-state intent.** The `name` is the file name on disk. Two processes
+* (e.g. `gc2-cli` and a local MCP server) that pass the same name share the
+* same on-disk credentials and therefore the same login session. The default
+* `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time
+* `gc2 login` is observable to every process that calls
+* `createConfigstoreTokenStore()` with no argument. Pass a different name
+* to isolate.
+*
+* **In-process correctness.** A serial promise chain on `set()` ensures
+* concurrent same-process calls do not race on the shared configstore cache.
+*
+* **Cross-process correctness.** `proper-lockfile` serializes the
+* read-merge-write critical section across processes so two simultaneous
+* `set()` calls from different processes cannot corrupt the file.
+*
+* **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`
+* out of browser bundles even when this module is imported through the SDK
+* barrel. Calling this function in a browser environment will fail at
+* runtime when the deferred `await import('configstore')` cannot resolve.
+*
+* @param name - configstore file name (without `.json`). Default `'gc2-env'`
+*               matches `gc2-cli`'s configstore so credentials are shared.
+* @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.
+*/
+function createConfigstoreTokenStore(name = "gc2-env") {
+	let configstoreInstance = null;
+	let setChain = Promise.resolve();
+	async function getConfigstore() {
+		var _default;
+		if (configstoreInstance) return configstoreInstance;
+		const mod = await import("configstore");
+		const Configstore = (_default = mod.default) !== null && _default !== void 0 ? _default : mod;
+		const { homedir } = await import("node:os");
+		const { join } = await import("node:path");
+		configstoreInstance = new Configstore(name, void 0, { configPath: join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "configstore", `${name}.json`) });
+		return configstoreInstance;
+	}
+	async function getLockfile() {
+		var _default2;
+		const mod = await import("proper-lockfile");
+		return (_default2 = mod.default) !== null && _default2 !== void 0 ? _default2 : mod;
+	}
+	function readAll(cs) {
+		const result = {};
+		const token = cs.get("token");
+		const refresh_token = cs.get("refresh_token");
+		const host = cs.get("host");
+		if (token !== void 0) result.token = token;
+		if (refresh_token !== void 0) result.refresh_token = refresh_token;
+		if (host !== void 0) result.host = host;
+		return result;
+	}
+	async function doLockedSet(patch) {
+		const cs = await getConfigstore();
+		const lockfile = await getLockfile();
+		const filePath = cs.path;
+		const { mkdirSync, writeFileSync } = await import("node:fs");
+		const { dirname } = await import("node:path");
+		try {
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, "{}", { flag: "wx" });
+		} catch (e) {
+			if ((e === null || e === void 0 ? void 0 : e.code) !== "EEXIST") throw e;
+		}
+		const release = await lockfile.lock(filePath, {
+			retries: {
+				retries: LOCK_RETRIES,
+				minTimeout: LOCK_RETRY_MIN_MS,
+				maxTimeout: LOCK_RETRY_MAX_MS,
+				factor: 2
+			},
+			stale: LOCK_STALE_MS,
+			realpath: false
+		});
+		try {
+			configstoreInstance = null;
+			const fresh = await getConfigstore();
+			fresh.all = _objectSpread2(_objectSpread2({}, readAll(fresh)), patch);
+		} finally {
+			await release();
+		}
+	}
+	return {
+		async get() {
+			return readAll(await getConfigstore());
+		},
+		async set(patch) {
+			const next = setChain.then(() => doLockedSet(patch));
+			setChain = next.catch(() => {});
+			return next;
+		}
+	};
+}
+
+//#endregion
+export { createConfigstoreTokenStore };
+//# sourceMappingURL=centia-io-sdk-node.js.map

package/dist/centia-io-sdk-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"centia-io-sdk-node.js","names":["configstoreInstance: any | null","setChain: Promise<void>","Configstore: any","result: StoredCredentials","filePath: string","e: any"],"sources":["../src/auth/configstoreTokenStore.ts"],"sourcesContent":["/**\n * @author     Martin Høgh <mh@mapcentia.com>\n * @copyright  2013-2026 MapCentia ApS\n * @license    https://opensource.org/license/mit  The MIT License\n *\n */\n\nimport type { StoredCredentials, TokenStore } from './types'\n\nconst LOCK_RETRIES = 5\nconst LOCK_RETRY_MIN_MS = 100\nconst LOCK_RETRY_MAX_MS = 500\nconst LOCK_STALE_MS = 10_000\n\n/**\n * Build a Node-only file-backed {@link TokenStore} that persists OAuth\n * credentials at `~/.config/configstore/<name>.json` (or\n * `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process\n * and cross-process write safety.\n *\n * **Shared-state intent.** The `name` is the file name on disk. Two processes\n * (e.g. `gc2-cli` and a local MCP server) that pass the same name share the\n * same on-disk credentials and therefore the same login session. The default\n * `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time\n * `gc2 login` is observable to every process that calls\n * `createConfigstoreTokenStore()` with no argument. Pass a different name\n * to isolate.\n *\n * **In-process correctness.** A serial promise chain on `set()` ensures\n * concurrent same-process calls do not race on the shared configstore cache.\n *\n * **Cross-process correctness.** `proper-lockfile` serializes the\n * read-merge-write critical section across processes so two simultaneous\n * `set()` calls from different processes cannot corrupt the file.\n *\n * **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`\n * out of browser bundles even when this module is imported through the SDK\n * barrel. Calling this function in a browser environment will fail at\n * runtime when the deferred `await import('configstore')` cannot resolve.\n *\n * @param name - configstore file name (without `.json`). Default `'gc2-env'`\n *               matches `gc2-cli`'s configstore so credentials are shared.\n * @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.\n */\nexport function createConfigstoreTokenStore(name = 'gc2-env'): TokenStore {\n    let configstoreInstance: any | null = null\n    let setChain: Promise<void> = Promise.resolve()\n\n    async function getConfigstore(): Promise<any> {\n        if (configstoreInstance) return configstoreInstance\n        const mod = await import('configstore')\n        const Configstore: any = (mod as any).default ?? mod\n        const { homedir } = await import('node:os')\n        const { join } = await import('node:path')\n        // Resolve XDG_CONFIG_HOME at call time (not at module-load time):\n        // configstore@7's transitive xdg-basedir snapshots the env var when\n        // first imported, which would ignore per-test mutations and (more\n        // importantly) couple our path to xdg-basedir's caching across\n        // process lifetimes. Computing configPath ourselves keeps the\n        // SDK's storage location stable regardless of dep version churn.\n        const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), '.config')\n        const configPath = join(xdgConfig, 'configstore', `${name}.json`)\n        configstoreInstance = new Configstore(name, undefined, { configPath })\n        return configstoreInstance\n    }\n\n    async function getLockfile(): Promise<typeof import('proper-lockfile')> {\n        const mod = await import('proper-lockfile')\n        return ((mod as any).default ?? mod) as typeof import('proper-lockfile')\n    }\n\n    function readAll(cs: any): StoredCredentials {\n        const result: StoredCredentials = {}\n        const token = cs.get('token')\n        const refresh_token = cs.get('refresh_token')\n        const host = cs.get('host')\n        if (token !== undefined) result.token = token\n        if (refresh_token !== undefined) result.refresh_token = refresh_token\n        if (host !== undefined) result.host = host\n        return result\n    }\n\n    async function doLockedSet(patch: Partial<StoredCredentials>): Promise<void> {\n        const cs = await getConfigstore()\n        const lockfile = await getLockfile()\n        const filePath: string = cs.path\n\n        // Ensure the file (and its directory) exist so proper-lockfile has\n        // something to anchor on. `wx` is atomic create-if-not-exists, so this\n        // is safe even if another process is racing to create the same file.\n        const { mkdirSync, writeFileSync } = await import('node:fs')\n        const { dirname } = await import('node:path')\n        try {\n            mkdirSync(dirname(filePath), { recursive: true })\n            writeFileSync(filePath, '{}', { flag: 'wx' })\n        } catch (e: any) {\n            if (e?.code !== 'EEXIST') throw e\n        }\n\n        // realpath:false skips symlink resolution. configstore returns an\n        // already-absolute path, and resolving symlinks would force an extra\n        // stat (and breaks on macOS test tmpdirs which are symlinks).\n        const release = await lockfile.lock(filePath, {\n            retries: {\n                retries: LOCK_RETRIES,\n                minTimeout: LOCK_RETRY_MIN_MS,\n                maxTimeout: LOCK_RETRY_MAX_MS,\n                factor: 2,\n            },\n            stale: LOCK_STALE_MS,\n            realpath: false,\n        })\n\n        try {\n            // Force configstore to re-read the on-disk state so we merge\n            // against the latest cross-process value, not a stale cache.\n            configstoreInstance = null\n            const fresh = await getConfigstore()\n            const merged: StoredCredentials = { ...readAll(fresh), ...patch }\n            ;(fresh as any).all = merged\n        } finally {\n            await release()\n        }\n    }\n\n    return {\n        async get(): Promise<StoredCredentials> {\n            const cs = await getConfigstore()\n            return readAll(cs)\n        },\n\n        async set(patch: Partial<StoredCredentials>): Promise<void> {\n            const next = setChain.then(() => doLockedSet(patch))\n            // Don't poison the chain on a rejection; the original error still\n            // propagates via `next` to the caller.\n            setChain = next.catch(() => {})\n            return next\n        },\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,MAAM,eAAe;AACrB,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAC1B,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,SAAgB,4BAA4B,OAAO,WAAuB;CACtE,IAAIA,sBAAkC;CACtC,IAAIC,WAA0B,QAAQ,SAAS;CAE/C,eAAe,iBAA+B;;AAC1C,MAAI,oBAAqB,QAAO;EAChC,MAAM,MAAM,MAAM,OAAO;EACzB,MAAMC,0BAAoB,IAAY,sDAAW;EACjD,MAAM,EAAE,YAAY,MAAM,OAAO;EACjC,MAAM,EAAE,SAAS,MAAM,OAAO;AAS9B,wBAAsB,IAAI,YAAY,MAAM,QAAW,EAAE,YADtC,KADD,QAAQ,IAAI,mBAAmB,KAAK,SAAS,EAAE,UAAU,EACxC,eAAe,GAAG,KAAK,OAAO,EACI,CAAC;AACtE,SAAO;;CAGX,eAAe,cAAyD;;EACpE,MAAM,MAAM,MAAM,OAAO;AACzB,sBAAS,IAAY,wDAAW;;CAGpC,SAAS,QAAQ,IAA4B;EACzC,MAAMC,SAA4B,EAAE;EACpC,MAAM,QAAQ,GAAG,IAAI,QAAQ;EAC7B,MAAM,gBAAgB,GAAG,IAAI,gBAAgB;EAC7C,MAAM,OAAO,GAAG,IAAI,OAAO;AAC3B,MAAI,UAAU,OAAW,QAAO,QAAQ;AACxC,MAAI,kBAAkB,OAAW,QAAO,gBAAgB;AACxD,MAAI,SAAS,OAAW,QAAO,OAAO;AACtC,SAAO;;CAGX,eAAe,YAAY,OAAkD;EACzE,MAAM,KAAK,MAAM,gBAAgB;EACjC,MAAM,WAAW,MAAM,aAAa;EACpC,MAAMC,WAAmB,GAAG;EAK5B,MAAM,EAAE,WAAW,kBAAkB,MAAM,OAAO;EAClD,MAAM,EAAE,YAAY,MAAM,OAAO;AACjC,MAAI;AACA,aAAU,QAAQ,SAAS,EAAE,EAAE,WAAW,MAAM,CAAC;AACjD,iBAAc,UAAU,MAAM,EAAE,MAAM,MAAM,CAAC;WACxCC,GAAQ;AACb,8CAAI,EAAG,UAAS,SAAU,OAAM;;EAMpC,MAAM,UAAU,MAAM,SAAS,KAAK,UAAU;GAC1C,SAAS;IACL,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,QAAQ;IACX;GACD,OAAO;GACP,UAAU;GACb,CAAC;AAEF,MAAI;AAGA,yBAAsB;GACtB,MAAM,QAAQ,MAAM,gBAAgB;AAEnC,GAAC,MAAc,wCADuB,QAAQ,MAAM,GAAK;YAEpD;AACN,SAAM,SAAS;;;AAIvB,QAAO;EACH,MAAM,MAAkC;AAEpC,UAAO,QADI,MAAM,gBAAgB,CACf;;EAGtB,MAAM,IAAI,OAAkD;GACxD,MAAM,OAAO,SAAS,WAAW,YAAY,MAAM,CAAC;AAGpD,cAAW,KAAK,YAAY,GAAG;AAC/B,UAAO;;EAEd"}

package/dist/centia-io-sdk.cjs

@@ -2681,112 +2681,6 @@ function isExpired(jwt, skewSeconds) {
 	return Math.floor(Date.now() / 1e3) + skewSeconds >= exp;
 }
 
-//#endregion
-//#region src/auth/configstoreTokenStore.ts
-const LOCK_RETRIES = 5;
-const LOCK_RETRY_MIN_MS = 100;
-const LOCK_RETRY_MAX_MS = 500;
-const LOCK_STALE_MS = 1e4;
-/**
-* Build a Node-only file-backed {@link TokenStore} that persists OAuth
-* credentials at `~/.config/configstore/<name>.json` (or
-* `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process
-* and cross-process write safety.
-*
-* **Shared-state intent.** The `name` is the file name on disk. Two processes
-* (e.g. `gc2-cli` and a local MCP server) that pass the same name share the
-* same on-disk credentials and therefore the same login session. The default
-* `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time
-* `gc2 login` is observable to every process that calls
-* `createConfigstoreTokenStore()` with no argument. Pass a different name
-* to isolate.
-*
-* **In-process correctness.** A serial promise chain on `set()` ensures
-* concurrent same-process calls do not race on the shared configstore cache.
-*
-* **Cross-process correctness.** `proper-lockfile` serializes the
-* read-merge-write critical section across processes so two simultaneous
-* `set()` calls from different processes cannot corrupt the file.
-*
-* **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`
-* out of browser bundles even when this module is imported through the SDK
-* barrel. Calling this function in a browser environment will fail at
-* runtime when the deferred `await import('configstore')` cannot resolve.
-*
-* @param name - configstore file name (without `.json`). Default `'gc2-env'`
-*               matches `gc2-cli`'s configstore so credentials are shared.
-* @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.
-*/
-function createConfigstoreTokenStore(name = "gc2-env") {
-	let configstoreInstance = null;
-	let setChain = Promise.resolve();
-	async function getConfigstore() {
-		var _default;
-		if (configstoreInstance) return configstoreInstance;
-		const mod = await import("configstore");
-		const Configstore = (_default = mod.default) !== null && _default !== void 0 ? _default : mod;
-		const { homedir } = await import("node:os");
-		const { join } = await import("node:path");
-		configstoreInstance = new Configstore(name, void 0, { configPath: join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "configstore", `${name}.json`) });
-		return configstoreInstance;
-	}
-	async function getLockfile() {
-		var _default2;
-		const mod = await import("proper-lockfile");
-		return (_default2 = mod.default) !== null && _default2 !== void 0 ? _default2 : mod;
-	}
-	function readAll(cs) {
-		const result = {};
-		const token = cs.get("token");
-		const refresh_token = cs.get("refresh_token");
-		const host = cs.get("host");
-		if (token !== void 0) result.token = token;
-		if (refresh_token !== void 0) result.refresh_token = refresh_token;
-		if (host !== void 0) result.host = host;
-		return result;
-	}
-	async function doLockedSet(patch) {
-		const cs = await getConfigstore();
-		const lockfile = await getLockfile();
-		const filePath = cs.path;
-		const { mkdirSync, writeFileSync } = await import("node:fs");
-		const { dirname } = await import("node:path");
-		try {
-			mkdirSync(dirname(filePath), { recursive: true });
-			writeFileSync(filePath, "{}", { flag: "wx" });
-		} catch (e) {
-			if ((e === null || e === void 0 ? void 0 : e.code) !== "EEXIST") throw e;
-		}
-		const release = await lockfile.lock(filePath, {
-			retries: {
-				retries: LOCK_RETRIES,
-				minTimeout: LOCK_RETRY_MIN_MS,
-				maxTimeout: LOCK_RETRY_MAX_MS,
-				factor: 2
-			},
-			stale: LOCK_STALE_MS,
-			realpath: false
-		});
-		try {
-			configstoreInstance = null;
-			const fresh = await getConfigstore();
-			fresh.all = _objectSpread2(_objectSpread2({}, readAll(fresh)), patch);
-		} finally {
-			await release();
-		}
-	}
-	return {
-		async get() {
-			return readAll(await getConfigstore());
-		},
-		async set(patch) {
-			const next = setChain.then(() => doLockedSet(patch));
-			setChain = next.catch(() => {});
-			return next;
-		}
-	};
-}
-
 //#endregion
 //#region src/index.ts
 /**
@@ -2817,7 +2711,6 @@ exports.Ws = Ws;
 exports.createApi = createApi;
 exports.createCentiaAdminClient = createCentiaAdminClient;
 exports.createCentiaClient = createCentiaClient;
-exports.createConfigstoreTokenStore = createConfigstoreTokenStore;
 exports.createSqlBuilder = createSqlBuilder;
 exports.createTokenProvider = createTokenProvider;
 exports.isCentiaApiError = isCentiaApiError;

package/dist/centia-io-sdk.d.cts

@@ -961,17 +961,17 @@ interface RpcMethodInfo {
   type_hints?: Record<string, unknown>;
 }
 interface MetadataFieldInfo {
-  alias?: string;
+  alias?: string | null;
   queryable?: boolean;
-  sort_id?: number;
+  sort_id?: number | null;
 }
 interface MetadataRelationInfo {
-  title?: string;
-  abstract?: string;
-  group?: string;
-  sort_id?: number;
-  tags?: string[];
-  properties?: Record<string, unknown>;
+  title?: string | null;
+  abstract?: string | null;
+  group?: string | null;
+  sort_id?: number | null;
+  tags?: string[] | null;
+  properties?: Record<string, unknown> | null;
   fields?: Record<string, MetadataFieldInfo>;
 }
 interface PatchMetadataRequest {
@@ -1288,39 +1288,6 @@ interface CreateTokenProviderOptions {
  */
 declare function createTokenProvider(opts: CreateTokenProviderOptions): TokenProvider;
 //#endregion
-//#region src/auth/configstoreTokenStore.d.ts
-/**
- * Build a Node-only file-backed {@link TokenStore} that persists OAuth
- * credentials at `~/.config/configstore/<name>.json` (or
- * `$XDG_CONFIG_HOME/configstore/<name>.json` if set), with both in-process
- * and cross-process write safety.
- *
- * **Shared-state intent.** The `name` is the file name on disk. Two processes
- * (e.g. `gc2-cli` and a local MCP server) that pass the same name share the
- * same on-disk credentials and therefore the same login session. The default
- * `'gc2-env'` matches the name `gc2-cli` already uses, so a one-time
- * `gc2 login` is observable to every process that calls
- * `createConfigstoreTokenStore()` with no argument. Pass a different name
- * to isolate.
- *
- * **In-process correctness.** A serial promise chain on `set()` ensures
- * concurrent same-process calls do not race on the shared configstore cache.
- *
- * **Cross-process correctness.** `proper-lockfile` serializes the
- * read-merge-write critical section across processes so two simultaneous
- * `set()` calls from different processes cannot corrupt the file.
- *
- * **Node-only.** The dynamic imports keep `configstore` and `proper-lockfile`
- * out of browser bundles even when this module is imported through the SDK
- * barrel. Calling this function in a browser environment will fail at
- * runtime when the deferred `await import('configstore')` cannot resolve.
- *
- * @param name - configstore file name (without `.json`). Default `'gc2-env'`
- *               matches `gc2-cli`'s configstore so credentials are shared.
- * @returns A {@link TokenStore} suitable for passing to {@link createTokenProvider}.
- */
-declare function createConfigstoreTokenStore(name?: string): TokenStore;
-//#endregion
 //#region src/auth/errors.d.ts
 /**
  * @author     Martin Høgh <mh@mapcentia.com>
@@ -1357,5 +1324,5 @@ declare class SessionExpiredError extends Error {
 */
 
 //#endregion
-export { type AuthService, type BatchMessage, type CentiaAdminClient, CentiaApiError, type CentiaApiErrorOptions, type CentiaAuth, type CentiaClientConfig, type CentiaHttpClient, Claims, type ClientInfo, CodeFlow, type CodeFlowOptions, type ColumnDef, type ColumnInfo, type CommitRequest, type CommitResult, type ConstraintInfo, type CreateClientRequest, type CreateClientResponse, type CreateColumnRequest, type CreateConstraintRequest, type CreateIndexRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type FileProcessRequest, type FileProcessResponse, type FileUploadOptions, type FullResponse, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, type LocationResponse, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, type Options, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchMetadataRequest, type PatchPrivilegeRequest, type PatchRpcMethodRequest, type PatchRuleRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PrivilegeInfo, type PrivilegeLevel, type RenameSchemaRequest, type RequestOptions, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcMethodInfo, type RpcRequest, type RpcResponse, type RuleAccess, type RuleInfo, type RuleRequest, type RuleService, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, Sql, SqlNoToken, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type StoredCredentials, type SubscriptionAckMessage, type SubscriptionRequest, type TableBatch, type TableDef, type TableInfo, Tables, type TokenProvider, type TokenStore, type UserInfo, Users, Ws, type WsErrorMessage, type WsMessage, type WsOptions, createApi, createCentiaAdminClient, createCentiaClient, createConfigstoreTokenStore, createSqlBuilder, createTokenProvider, isCentiaApiError };
+export { type AuthService, type BatchMessage, type CentiaAdminClient, CentiaApiError, type CentiaApiErrorOptions, type CentiaAuth, type CentiaClientConfig, type CentiaHttpClient, Claims, type ClientInfo, CodeFlow, type CodeFlowOptions, type ColumnDef, type ColumnInfo, type CommitRequest, type CommitResult, type ConstraintInfo, type CreateClientRequest, type CreateClientResponse, type CreateColumnRequest, type CreateConstraintRequest, type CreateIndexRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type FileProcessRequest, type FileProcessResponse, type FileUploadOptions, type FullResponse, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, type IndexInfo, type LocationResponse, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, type Options, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchMetadataRequest, type PatchPrivilegeRequest, type PatchRpcMethodRequest, type PatchRuleRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PrivilegeInfo, type PrivilegeLevel, type RenameSchemaRequest, type RequestOptions, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcMethodInfo, type RpcRequest, type RpcResponse, type RuleAccess, type RuleInfo, type RuleRequest, type RuleService, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, Sql, SqlNoToken, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type StoredCredentials, type SubscriptionAckMessage, type SubscriptionRequest, type TableBatch, type TableDef, type TableInfo, Tables, type TokenProvider, type TokenStore, type UserInfo, Users, Ws, type WsErrorMessage, type WsMessage, type WsOptions, createApi, createCentiaAdminClient, createCentiaClient, createSqlBuilder, createTokenProvider, isCentiaApiError };
 //# sourceMappingURL=centia-io-sdk.d.cts.map