@centia-io/sdk 0.2.0 → 0.2.2

package/README.md

@@ -363,6 +363,75 @@ Notes:
 - `createApi<T>()` relies on naming conventions: the property name is the JSON‑RPC `method` name.
 - Each call returns `result.data` from the RPC response (array of rows).
 
+## Layer styling (admin client)
+
+Layer configuration (properties, classes, styles and labels — MapServer-backed cartography) is managed through the admin client:
+
+```ts
+import { createCentiaAdminClient } from '@centia-io/sdk'
+
+const client = createCentiaAdminClient({
+  baseUrl: 'https://example.centia.io',
+  auth: { getAccessToken: async () => token },
+})
+
+const layers = client.provisioning.layers
+
+// List layer keys
+const names = await layers.getLayer(undefined, { namesOnly: true })
+
+// Read a full layer definition (properties + classes with styles/labels)
+const layer = await layers.getLayer('my_schema.my_table.the_geom')
+
+// Update layer properties (key-merge)
+await layers.patchLayer('my_schema.my_table.the_geom', {
+  name: 'my_schema.my_table.the_geom',
+  properties: { opacity: '80', geotype: 'POLYGON' },
+})
+
+// Classes, styles and labels have their own CRUD methods
+const { location } = await layers.postLayerClass('my_schema.my_table.the_geom', {
+  name: 'Roads',
+  expression: "[type]='road'",
+})
+await layers.postStyle('my_schema.my_table.the_geom', 'a1b2c3d4', { color: '#008000', width: '2' })
+await layers.postLabel('my_schema.my_table.the_geom', 'a1b2c3d4', { text: '[name]', on: true })
+```
+
+## OGC services (OWS / WFS)
+
+`Ows` and `Wfs` wrap the OGC endpoints and take a `CentiaHttpClient`:
+
+```ts
+import { createCentiaClient, Ows, Wfs } from '@centia-io/sdk'
+
+const http = createCentiaClient({
+  baseUrl: 'https://example.centia.io',
+  auth: { getAccessToken: async () => token },
+})
+
+// Token-authenticated WFS
+const wfs = new Wfs(http)
+const capabilities = await wfs.getWfs('my_schema', { REQUEST: 'GetCapabilities' })
+const gml = await wfs.getWfs(
+  'my_schema',
+  { REQUEST: 'GetFeature', TYPENAME: 'my_table', MAXFEATURES: 100 },
+  { srs: 25832 }, // optional output SRID (and optional timeSlice for versioned layers)
+)
+
+// WFS-T transactions are posted as XML
+await wfs.postWfs('my_schema', '<wfs:Transaction>…</wfs:Transaction>')
+
+// Generic OWS (WMS/WFS/UTFGRID)
+const ows = new Ows(http)
+const wmsCaps = await ows.getOws('my_schema', { SERVICE: 'WMS', REQUEST: 'GetCapabilities' })
+
+// Anonymous / HTTP-Basic access uses the ...NoToken variants with the database in the path
+const anonCaps = await wfs.getWfsNoToken('my_schema', 'my_database', { REQUEST: 'GetCapabilities' })
+```
+
+Responses are returned as XML text (or parsed JSON for JSON formats such as UTFGRID). Binary responses like WMS `GetMap` images are not supported by these wrappers.
+
 ## Error handling
 
 - Network/HTTP errors: thrown as `Error` with the status/body text when available.

package/dist/centia-io-sdk.cjs

@@ -2352,6 +2352,169 @@ var Rules = class {
 	}
 };
 
+//#endregion
+//#region src/provisioning/Layers.ts
+var Layers = class {
+	constructor(client) {
+		this.client = client;
+	}
+	layerPath(layer) {
+		return `api/v4/layers/${encodeURIComponent(layer)}`;
+	}
+	classPath(layer, classId) {
+		return `${this.layerPath(layer)}/classes/${encodeURIComponent(classId)}`;
+	}
+	async getLayer(layer, opts) {
+		var _this = this;
+		const path = layer ? _this.layerPath(layer) : "api/v4/layers";
+		const query = {};
+		if (opts === null || opts === void 0 ? void 0 : opts.namesOnly) query.namesOnly = "true";
+		return _this.client.request({
+			path,
+			method: "GET",
+			query: Object.keys(query).length > 0 ? query : void 0
+		});
+	}
+	/** Configure existing layer(s): set properties and replace classes. */
+	async postLayer(body) {
+		var _this2 = this;
+		var _res$getHeader;
+		return { location: (_res$getHeader = (await _this2.client.requestFull({
+			path: "api/v4/layers",
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader !== void 0 ? _res$getHeader : "" };
+	}
+	/** Update layer properties (key-merge on the def JSON). */
+	async patchLayer(layer, body) {
+		var _this3 = this;
+		var _res$getHeader2;
+		return { location: (_res$getHeader2 = (await _this3.client.requestFull({
+			path: _this3.layerPath(layer),
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader2 !== void 0 ? _res$getHeader2 : "" };
+	}
+	async getLayerClass(layer, classId) {
+		var _this4 = this;
+		const path = classId != null ? _this4.classPath(layer, classId) : `${_this4.layerPath(layer)}/classes`;
+		return _this4.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	async postLayerClass(layer, body) {
+		var _this5 = this;
+		var _res$getHeader3;
+		return { location: (_res$getHeader3 = (await _this5.client.requestFull({
+			path: `${_this5.layerPath(layer)}/classes`,
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader3 !== void 0 ? _res$getHeader3 : "" };
+	}
+	/** Update a class (key-merge). Styles/labels are managed via their own methods. */
+	async patchLayerClass(layer, classId, body) {
+		var _this6 = this;
+		var _res$getHeader4;
+		return { location: (_res$getHeader4 = (await _this6.client.requestFull({
+			path: _this6.classPath(layer, classId),
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader4 !== void 0 ? _res$getHeader4 : "" };
+	}
+	/** Delete class(es). `classId` may be a comma-separated list of ids. */
+	async deleteLayerClass(layer, classId) {
+		var _this7 = this;
+		await _this7.client.request({
+			path: _this7.classPath(layer, classId),
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+	async getStyle(layer, classId, styleId) {
+		var _this8 = this;
+		const base = `${_this8.classPath(layer, classId)}/styles`;
+		const path = styleId != null ? `${base}/${encodeURIComponent(styleId)}` : base;
+		return _this8.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	async postStyle(layer, classId, body) {
+		var _this9 = this;
+		var _res$getHeader5;
+		return { location: (_res$getHeader5 = (await _this9.client.requestFull({
+			path: `${_this9.classPath(layer, classId)}/styles`,
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader5 !== void 0 ? _res$getHeader5 : "" };
+	}
+	/** Update a style (key-merge). */
+	async patchStyle(layer, classId, styleId, body) {
+		var _this10 = this;
+		var _res$getHeader6;
+		return { location: (_res$getHeader6 = (await _this10.client.requestFull({
+			path: `${_this10.classPath(layer, classId)}/styles/${encodeURIComponent(styleId)}`,
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader6 !== void 0 ? _res$getHeader6 : "" };
+	}
+	/** Delete style(s). `styleId` may be a comma-separated list of ids. */
+	async deleteStyle(layer, classId, styleId) {
+		var _this11 = this;
+		await _this11.client.request({
+			path: `${_this11.classPath(layer, classId)}/styles/${encodeURIComponent(styleId)}`,
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+	async getLabel(layer, classId, labelId) {
+		var _this12 = this;
+		const base = `${_this12.classPath(layer, classId)}/labels`;
+		const path = labelId != null ? `${base}/${encodeURIComponent(labelId)}` : base;
+		return _this12.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	async postLabel(layer, classId, body) {
+		var _this13 = this;
+		var _res$getHeader7;
+		return { location: (_res$getHeader7 = (await _this13.client.requestFull({
+			path: `${_this13.classPath(layer, classId)}/labels`,
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader7 !== void 0 ? _res$getHeader7 : "" };
+	}
+	/** Update a label (key-merge). */
+	async patchLabel(layer, classId, labelId, body) {
+		var _this14 = this;
+		var _res$getHeader8;
+		return { location: (_res$getHeader8 = (await _this14.client.requestFull({
+			path: `${_this14.classPath(layer, classId)}/labels/${encodeURIComponent(labelId)}`,
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader8 !== void 0 ? _res$getHeader8 : "" };
+	}
+	/** Delete label(s). `labelId` may be a comma-separated list of ids. */
+	async deleteLabel(layer, classId, labelId) {
+		var _this15 = this;
+		await _this15.client.request({
+			path: `${_this15.classPath(layer, classId)}/labels/${encodeURIComponent(labelId)}`,
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+};
+
 //#endregion
 //#region src/provisioning/Privileges.ts
 var Privileges = class {
@@ -2426,6 +2589,98 @@ var RpcMethods = class {
 	}
 };
 
+//#endregion
+//#region src/provisioning/Functions.ts
+/**
+* Lambda-like functions: manage (CRUD), invoke (sync/async/dry-run) and read
+* the generated TypeScript interface.
+*/
+var Functions = class {
+	constructor(client) {
+		this.client = client;
+	}
+	async getFunctions(name) {
+		var _this = this;
+		const path = name ? `api/v4/functions/${encodeURIComponent(name)}` : "api/v4/functions";
+		return _this.client.request({
+			path,
+			method: "GET"
+		});
+	}
+	/** Create one or more functions. Returns the Location of the created resource. */
+	async postFunction(body) {
+		var _this2 = this;
+		var _res$getHeader;
+		return { location: (_res$getHeader = (await _this2.client.requestFull({
+			path: "api/v4/functions",
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader !== void 0 ? _res$getHeader : "" };
+	}
+	/** Update a function. Changing the code bumps its version. */
+	async patchFunction(name, body) {
+		var _this3 = this;
+		var _res$getHeader2;
+		return { location: (_res$getHeader2 = (await _this3.client.requestFull({
+			path: `api/v4/functions/${encodeURIComponent(name)}`,
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader2 !== void 0 ? _res$getHeader2 : "" };
+	}
+	/** Delete a function. */
+	async deleteFunction(name) {
+		await this.client.request({
+			path: `api/v4/functions/${encodeURIComponent(name)}`,
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+	/** Invoke a function synchronously and return its result. */
+	async invoke(name, event = {}) {
+		return this.client.request({
+			path: `api/v4/functions/${encodeURIComponent(name)}/invocations`,
+			method: "POST",
+			body: event
+		});
+	}
+	/** Queue a function invocation; returns immediately with 202 and an id to poll. */
+	async invokeAsync(name, event = {}) {
+		return this.client.request({
+			path: `api/v4/functions/${encodeURIComponent(name)}/invocations`,
+			method: "POST",
+			body: event,
+			query: { async: "true" },
+			expectedStatus: 202
+		});
+	}
+	/** Run once to infer and store input/output type schemas (for TypeScript generation). */
+	async dryRun(name, event = {}) {
+		return this.client.request({
+			path: `api/v4/functions/${encodeURIComponent(name)}/invocations`,
+			method: "POST",
+			body: event,
+			query: { dry: "true" }
+		});
+	}
+	/** Get a stored invocation record (e.g. to poll an async invocation). */
+	async getInvocation(name, id) {
+		return this.client.request({
+			path: `api/v4/functions/${encodeURIComponent(name)}/invocations/${encodeURIComponent(id)}`,
+			method: "GET"
+		});
+	}
+	/** Get the generated TypeScript `Functions` interface (from dry-run schemas). */
+	async getInterfaces() {
+		return this.client.request({
+			path: "api/v4/function-interfaces",
+			method: "GET",
+			accept: "text/plain"
+		});
+	}
+};
+
 //#endregion
 //#region src/provisioning/MetadataWrite.ts
 var MetadataWrite = class {
@@ -2559,8 +2814,10 @@ function createCentiaAdminClient(config) {
 			users: new ProvisioningUsers(http),
 			clients: new ProvisioningClients(http),
 			rules: new Rules(http),
+			layers: new Layers(http),
 			privileges: new Privileges(http),
 			rpcMethods: new RpcMethods(http),
+			functions: new Functions(http),
 			metadata: new MetadataWrite(http),
 			typeScript: new TypeScriptInterfaces(http),
 			fileImport: new FileImport(http),
@@ -2569,6 +2826,140 @@ function createCentiaAdminClient(config) {
 	};
 }
 
+//#endregion
+//#region src/ogc/Ows.ts
+function toQuery$1(params) {
+	if (!params) return void 0;
+	const query = {};
+	for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) query[key] = String(value);
+	return Object.keys(query).length > 0 ? query : void 0;
+}
+/**
+* OWS (WMS/WFS/UTFGRID) endpoint wrapper.
+*
+* Token-authenticated clients use `getOws`/`postOws`; anonymous and HTTP-Basic
+* clients use the `...NoToken` variants, which include the database in the path.
+*
+* Responses are streamed from the backend and returned as text (XML) or, for
+* JSON responses such as UTFGRID, as parsed JSON. Binary responses (e.g. WMS
+* GetMap images) are not supported by this wrapper — request those directly.
+*/
+var Ows = class {
+	constructor(client) {
+		this.client = client;
+	}
+	/** Token-authenticated OWS GET (WMS/WFS/UTFGRID). */
+	async getOws(schema, params) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}`,
+			method: "GET",
+			query: toQuery$1(params),
+			accept: "*/*"
+		});
+	}
+	/** Token-authenticated OWS POST (WFS XML). */
+	async postOws(schema, xml) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}`,
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "*/*"
+		});
+	}
+	/** Anonymous/HTTP-Basic OWS GET (WMS/WFS/UTFGRID). */
+	async getOwsNoToken(schema, database, params) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`,
+			method: "GET",
+			query: toQuery$1(params),
+			accept: "*/*"
+		});
+	}
+	/** Anonymous/HTTP-Basic OWS POST (WFS XML). */
+	async postOwsNoToken(schema, database, xml) {
+		return this.client.request({
+			path: `api/v4/ows/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`,
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "*/*"
+		});
+	}
+};
+
+//#endregion
+//#region src/ogc/Wfs.ts
+function wfsPath(base, options) {
+	let path = base;
+	if ((options === null || options === void 0 ? void 0 : options.timeSlice) != null && options.srs == null) throw new Error("timeSlice requires srs to be set");
+	if ((options === null || options === void 0 ? void 0 : options.srs) != null) {
+		path += `/srs/${encodeURIComponent(options.srs)}`;
+		if (options.timeSlice != null) path += `/${encodeURIComponent(options.timeSlice)}`;
+	}
+	return path;
+}
+function toQuery(params) {
+	const query = { SERVICE: "WFS" };
+	for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) query[key] = String(value);
+	return query;
+}
+/**
+* WFS endpoint wrapper (GetCapabilities, DescribeFeatureType, GetFeature and
+* WFS-T transactions).
+*
+* Token-authenticated clients use `getWfs`/`postWfs`; anonymous and HTTP-Basic
+* clients (e.g. QGIS) use the `...NoToken` variants, which include the
+* database in the path. Responses are returned as XML text.
+*/
+var Wfs = class {
+	constructor(client) {
+		this.client = client;
+	}
+	/** Token-authenticated WFS GET. */
+	async getWfs(schema, params, options) {
+		return this.client.request({
+			path: wfsPath(`api/v4/wfs/schema/${encodeURIComponent(schema)}`, options),
+			method: "GET",
+			query: toQuery(params),
+			accept: "text/xml"
+		});
+	}
+	/** Token-authenticated WFS POST (XML-encoded GetFeature or Transaction). */
+	async postWfs(schema, xml, options) {
+		return this.client.request({
+			path: wfsPath(`api/v4/wfs/schema/${encodeURIComponent(schema)}`, options),
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "text/xml"
+		});
+	}
+	/** Anonymous/HTTP-Basic WFS GET. */
+	async getWfsNoToken(schema, database, params, options) {
+		var _this3 = this;
+		const base = `api/v4/wfs/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`;
+		return _this3.client.request({
+			path: wfsPath(base, options),
+			method: "GET",
+			query: toQuery(params),
+			accept: "text/xml"
+		});
+	}
+	/** Anonymous/HTTP-Basic WFS POST (XML-encoded GetFeature or Transaction). */
+	async postWfsNoToken(schema, database, xml, options) {
+		var _this4 = this;
+		const base = `api/v4/wfs/schema/${encodeURIComponent(schema)}/database/${encodeURIComponent(database)}`;
+		return _this4.client.request({
+			path: wfsPath(base, options),
+			method: "POST",
+			body: xml,
+			contentType: "text/xml",
+			accept: "text/xml"
+		});
+	}
+};
+
 //#endregion
 //#region src/auth/errors.ts
 /**
@@ -2697,6 +3088,7 @@ exports.CodeFlow = CodeFlow;
 exports.Gql = Gql;
 exports.Meta = Meta;
 exports.NotLoggedInError = NotLoggedInError;
+exports.Ows = Ows;
 exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;
 exports.SessionExpiredError = SessionExpiredError;
@@ -2707,6 +3099,7 @@ exports.Stats = Stats;
 exports.Status = Status;
 exports.Tables = Tables;
 exports.Users = Users;
+exports.Wfs = Wfs;
 exports.Ws = Ws;
 exports.createApi = createApi;
 exports.createCentiaAdminClient = createCentiaAdminClient;