@centia-io/sdk 0.0.28 → 0.0.30

package/dist/centia-io-sdk.js

@@ -198,6 +198,9 @@ var Gc2Service = class {
 	isPasswordFlowOptions(options) {
 		return "username" in options;
 	}
+	isSignUpOptions(options) {
+		return "parentDb" in options;
+	}
 	buildUrl(path) {
 		if (path.startsWith("http://") || path.startsWith("https://")) return path;
 		return `${this.host}${path}`;
@@ -262,6 +265,15 @@ var Gc2Service = class {
 		if (this.options.scope) params.set("scope", this.options.scope);
 		return `${base}?${params.toString()}`;
 	}
+	getSignUpURL() {
+		if (!this.isSignUpOptions(this.options)) throw new Error("CodeFlow options required for this operation");
+		const base = this.options.authUri ?? `${this.host}/signup/`;
+		const params = new URLSearchParams();
+		params.set("client_id", this.options.clientId);
+		params.set("parentdb", this.options.parentDb);
+		params.set("redirect_uri", this.options.redirectUri);
+		return `${base}?${params.toString()}`;
+	}
 	async getAuthorizationCodeToken(code, codeVerifier) {
 		let redirectUri;
 		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
@@ -501,17 +513,21 @@ var Users = class {
 var Ws = class {
 	constructor(options) {
 		this.options = options;
+		this.options.wsClient = this.options?.wsClient ?? WebSocket;
 	}
 	connect() {
 		const me = this;
 		const { accessToken } = getTokens();
 		const connect = () => {
-			const ws = new WebSocket(this.options.host + `/?token=` + accessToken);
+			let queryString = `?token=` + accessToken;
+			if (this.options?.rel) queryString = queryString + `&rel=` + this.options.rel;
+			const WSClass = this.options.wsClient;
+			const ws = new WSClass(this.options.host + `/` + queryString);
 			ws.onopen = function() {
 				console.log("WebSocket connected!");
 			};
 			ws.onmessage = function(event) {
-				me.options?.callBack(event.data);
+				me.options.callBack(event.data);
 			};
 			ws.onclose = function(event) {
 				if (accessToken !== "") {
@@ -555,23 +571,835 @@ var Tables = class {
 
 //#endregion
 //#region src/Api.ts
-async function dispatch(name, args) {
+function isPlainObject$1(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateParamsForMethod(method, params) {
+	if (Array.isArray(params)) {
+		const badIndex = params.findIndex((p) => !isPlainObject$1(p));
+		if (badIndex !== -1) throw new TypeError(`createApi: Invalid argument at index ${badIndex} for RPC method "${method}". Expected a plain object.`);
+		return params;
+	}
+	if (params === void 0) return {};
+	if (!isPlainObject$1(params)) throw new TypeError(`createApi: Invalid argument for RPC method "${method}". Expected a plain object.`);
+	return params;
+}
+function extractDataFromResponse(method, res) {
+	if (!res || typeof res !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected an object.`);
+	if (res.jsonrpc !== "2.0") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing or invalid jsonrpc version.`);
+	const err = res.error;
+	if (err !== void 0) {
+		if (!err || typeof err !== "object") throw new TypeError(`createApi: Invalid RPC error for method "${method}". Expected 'error' to be an object.`);
+		const code = err.code;
+		const message = err.message;
+		const data$1 = err.data;
+		const codeIsNum = typeof code === "number" && Number.isFinite(code);
+		const details = typeof message === "string" && message.length > 0 ? message : "Unknown error";
+		const e = /* @__PURE__ */ new Error(`createApi: RPC error for method "${method}"${codeIsNum ? ` (${code})` : ""}: ${details}`);
+		e.code = code;
+		if (data$1 !== void 0) e.data = data$1;
+		e.method = method;
+		e.name = "JsonRpcError";
+		throw e;
+	}
+	const result = res.result;
+	if (!result || typeof result !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing result object.`);
+	const data = result.data;
+	if (!Array.isArray(data)) throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected result.data to be an array.`);
+	return data;
+}
+async function dispatch(name, paramsLike) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("createApi: RPC method name must be a non-empty string.");
+	const params = validateParamsForMethod(String(name), paramsLike);
 	const rpc = new Rpc();
 	const request = {
 		jsonrpc: "2.0",
 		method: name,
 		id: 1,
-		params: args
+		params
 	};
-	return (await rpc.call(request)).result.data;
+	const res = await rpc.call(request);
+	return extractDataFromResponse(String(name), res);
 }
 function createApi() {
 	return new Proxy({}, { get(_target, prop) {
 		if (typeof prop !== "string") return void 0;
-		return (...args) => dispatch(prop, ...args);
+		return (...args) => {
+			return dispatch(prop, args.length === 0 ? {} : args.length === 1 ? args[0] : args);
+		};
 	} });
 }
 
 //#endregion
-export { Claims, CodeFlow, Meta, PasswordFlow, Rpc, Sql, Stats, Status, Tables, Users, Ws, createApi };
+//#region src/SignUp.ts
+var SignUp = class {
+	constructor(options) {
+		this.options = options;
+		this.service = new Gc2Service(options);
+	}
+	async signUp() {
+		window.location = this.service.getSignUpURL();
+	}
+};
+
+//#endregion
+//#region src/SqlBuilder.ts
+function findTable(schema, name) {
+	const tbl = schema.tables.find((t) => t.name === name);
+	if (!tbl) throw new Error(`Table not found in schema: ${name}`);
+	return tbl;
+}
+function findColumn(table, name) {
+	const col = table.columns.find((c) => c.name === name);
+	if (!col) throw new Error(`Column not found in table ${table.name}: ${name}`);
+	return col;
+}
+function getPrimaryKeyColumns(table) {
+	const pk = (table.constraints || []).find((c) => c.constraint === "primary" && Array.isArray(c.columns) && c.columns.length > 0);
+	return pk ? pk.columns.map(String) : [];
+}
+function typeNameToHint(typname, isArray) {
+	if (!typname) return void 0;
+	const base = typname;
+	return isArray ? base + "[]" : base;
+}
+function addTypeHintForParam(typeHints, paramName, col, value) {
+	let isArr = col._is_array;
+	if (Array.isArray(value)) if (isArrayShapedGeomTypename(col._typname)) isArr = value.every(Array.isArray);
+	else isArr = true;
+	const hint = typeNameToHint(col._typname, isArr);
+	if (hint) typeHints[paramName] = hint;
+}
+function expectedScalarKind(typname) {
+	const t = typname.toLowerCase();
+	if (t === "int2" || t === "int4" || t === "int8" || t === "float4" || t === "float8") return "number";
+	if (t === "numeric" || t === "decimal") return "string";
+	if (t === "varchar" || t === "text" || t === "bpchar" || t === "char" || t === "date" || t === "time" || t === "timetz" || t === "timestamp" || t === "timestamptz") return "string";
+	if (t === "bool") return "boolean";
+	if (t === "json" || t === "jsonb") return "json";
+	if (t === "int4range" || t === "int8range" || t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "range";
+	if (t === "interval") return "interval";
+	if (t === "point" || t === "line" || t === "lseg" || t === "box" || t === "path" || t === "polygon" || t === "circle") return "geom";
+	return "unknown";
+}
+function isArrayShapedGeomTypename(typname) {
+	const t = typname.toLowerCase();
+	return t === "path" || t === "polygon";
+}
+function isArrayShapedGeomScalarValue(col, value) {
+	if (!Array.isArray(value)) return false;
+	if (!isArrayShapedGeomTypename(col._typname)) return false;
+	return !value.every(Array.isArray);
+}
+function expectedRangeInnerKind(typname) {
+	const t = typname.toLowerCase();
+	if (t === "int4range" || t === "int8range") return "number";
+	if (t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "string";
+	return "unknown";
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isFiniteNumber(n) {
+	return typeof n === "number" && Number.isFinite(n);
+}
+function isPointLike(v) {
+	if (!isPlainObject(v)) return false;
+	const x = v.x;
+	const y = v.y;
+	return isFiniteNumber(x) && isFiniteNumber(y);
+}
+function validateGeometryForColumn(col, value, context) {
+	const t = col._typname.toLowerCase();
+	if (t === "point") {
+		if (!isPointLike(value)) throw new Error(`Invalid value for ${context}. Expected Point { x: number, y: number }`);
+		return;
+	}
+	if (t === "line") {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Line { A: number, B: number, C: number }`);
+		const A = value.A, B = value.B, C = value.C;
+		if (!isFiniteNumber(A) || !isFiniteNumber(B) || !isFiniteNumber(C)) throw new Error(`Invalid Line for ${context}. A, B, C must be finite numbers`);
+		return;
+	}
+	if (t === "lseg" || t === "box") {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected ${t.toUpperCase()} { start: Point, end: Point }`);
+		const start = value.start;
+		const end = value.end;
+		if (!isPointLike(start) || !isPointLike(end)) throw new Error(`Invalid ${t} for ${context}. 'start' and 'end' must be Point { x, y }`);
+		return;
+	}
+	if (t === "path") {
+		if (!Array.isArray(value) || value.length < 1) throw new Error(`Invalid value for ${context}. Expected Path [isClosed: boolean, ...points: Point[]]`);
+		const [isClosed, ...points] = value;
+		if (typeof isClosed !== "boolean") throw new Error(`Invalid Path for ${context}. First element must be boolean (isClosed)`);
+		for (let i = 0; i < points.length; i++) if (!isPointLike(points[i])) throw new Error(`Invalid Path for ${context}. Element at index ${i + 1} must be Point { x, y }`);
+		return;
+	}
+	if (t === "polygon") {
+		if (!Array.isArray(value)) throw new Error(`Invalid value for ${context}. Expected Polygon as Point[]`);
+		for (let i = 0; i < value.length; i++) if (!isPointLike(value[i])) throw new Error(`Invalid Polygon for ${context}. Element at index ${i} must be Point { x, y }`);
+		return;
+	}
+	if (t === "circle") {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Circle { center: Point, radius: number }`);
+		const center = value.center;
+		const radius = value.radius;
+		if (!isPointLike(center) || !isFiniteNumber(radius)) throw new Error(`Invalid Circle for ${context}. 'center' must be Point and 'radius' must be finite number`);
+		return;
+	}
+}
+function validateRangeForColumn(col, value, context) {
+	if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected a range object for type ${col._typname}`);
+	const r = value;
+	const hasLower = Object.prototype.hasOwnProperty.call(r, "lower");
+	const hasUpper = Object.prototype.hasOwnProperty.call(r, "upper");
+	const hasLi = Object.prototype.hasOwnProperty.call(r, "lowerInclusive");
+	const hasUi = Object.prototype.hasOwnProperty.call(r, "upperInclusive");
+	if (!hasLower || !hasUpper || !hasLi || !hasUi) throw new Error(`Invalid range for ${context}. Required properties: lower, upper, lowerInclusive, upperInclusive`);
+	if (typeof r.lowerInclusive !== "boolean" || typeof r.upperInclusive !== "boolean") throw new Error(`Invalid range for ${context}. lowerInclusive and upperInclusive must be boolean`);
+	const inner = expectedRangeInnerKind(col._typname);
+	if (inner === "number") {
+		if (typeof r.lower !== "number" || !Number.isFinite(r.lower)) throw new Error(`Invalid range.lower for ${context}. Expected number for type ${col._typname}`);
+		if (typeof r.upper !== "number" || !Number.isFinite(r.upper)) throw new Error(`Invalid range.upper for ${context}. Expected number for type ${col._typname}`);
+	} else if (inner === "string") {
+		if (typeof r.lower !== "string") throw new Error(`Invalid range.lower for ${context}. Expected string for type ${col._typname}`);
+		if (typeof r.upper !== "string") throw new Error(`Invalid range.upper for ${context}. Expected string for type ${col._typname}`);
+	}
+}
+function validateIntervalForColumn(col, value, context) {
+	if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected an interval object for type ${col._typname}`);
+	const v = value;
+	for (const k of [
+		"y",
+		"m",
+		"d",
+		"h",
+		"i",
+		"s"
+	]) {
+		if (!Object.prototype.hasOwnProperty.call(v, k)) throw new Error(`Invalid interval for ${context}. Missing property '${k}'`);
+		const num = v[k];
+		if (typeof num !== "number" || !Number.isFinite(num)) throw new Error(`Invalid interval.${String(k)} for ${context}. Expected finite number`);
+	}
+}
+function isValidJsonLike(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "object" && value !== null;
+}
+function validateScalarForColumn(col, value, context) {
+	const kind = expectedScalarKind(col._typname);
+	if (kind === "unknown") return;
+	if (kind === "number") {
+		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid value for ${context}. Expected number for type ${col._typname}, got ${typeof value}`);
+		return;
+	}
+	if (kind === "string") {
+		if (typeof value !== "string") throw new Error(`Invalid value for ${context}. Expected string for type ${col._typname}, got ${typeof value}`);
+		return;
+	}
+	if (kind === "boolean") {
+		if (typeof value !== "boolean") throw new Error(`Invalid value for ${context}. Expected boolean for type ${col._typname}, got ${typeof value}`);
+		return;
+	}
+	if (kind === "json") {
+		if (!isValidJsonLike(value)) throw new Error(`Invalid value for ${context}. Expected JSON-compatible value for type ${col._typname}`);
+		return;
+	}
+	if (kind === "range") {
+		validateRangeForColumn(col, value, context);
+		return;
+	}
+	if (kind === "interval") {
+		validateIntervalForColumn(col, value, context);
+		return;
+	}
+	if (kind === "geom") {
+		validateGeometryForColumn(col, value, context);
+		return;
+	}
+}
+function validateComparisonValue(col, key, value, op) {
+	if (value === void 0 || value === null) throw new Error(`Operator ${op} on column ${key} requires a non-null value. Use isnull/notnull for null checks.`);
+	if (col._is_array) {
+		if (!Array.isArray(value)) throw new Error(`Operator ${op} on array column ${key} requires an array value`);
+		for (const [i, v] of value.entries()) validateScalarForColumn(col, v, `column ${key}[${i}]`);
+	} else {
+		if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) throw new Error(`Operator ${op} on scalar column ${key} cannot accept an array value`);
+		validateScalarForColumn(col, value, `column ${key}`);
+	}
+}
+function validateInArrayValues(col, key, values, op) {
+	if (!col._is_array) {
+		let idx = 0;
+		for (const v of values) {
+			validateScalarForColumn(col, v, `column ${key} (element ${idx})`);
+			idx++;
+		}
+	}
+}
+function findJoinOn(base, target) {
+	const bc = base.constraints || [];
+	const tc = target.constraints || [];
+	for (const c of bc) if (c.constraint === "foreign" && c.referenced_table === target.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.columns.map((col, i) => ({
+		left: String(col),
+		right: String(c.referenced_columns[i])
+	}));
+	for (const c of tc) if (c.constraint === "foreign" && c.referenced_table === base.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.referenced_columns.map((rcol, i) => ({
+		left: String(rcol),
+		right: String(c.columns[i])
+	}));
+	return null;
+}
+var TableQueryImpl = class {
+	constructor(schema, tableName) {
+		this.schema = schema;
+		this.table = findTable(schema, tableName);
+	}
+	select(cols) {
+		const table = this.table;
+		const schema = this.schema;
+		const selected = cols && cols.length ? cols : ["*"];
+		const state = {
+			table,
+			selected,
+			where: {},
+			orWhereGroups: [],
+			andOps: [],
+			orOpGroups: [],
+			order: [],
+			limit: void 0,
+			offset: void 0,
+			joins: [],
+			joinSelections: []
+		};
+		return new class {
+			constructor() {
+				this.s = state;
+				this.toSql = () => {
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					const parts = [];
+					const selectParts = [];
+					if (selected.length === 1 && selected[0] === "*") selectParts.push(`"${table.name}".*`);
+					else {
+						const sel = selected;
+						for (const c of sel) findColumn(table, String(c));
+						selectParts.push(sel.map((c) => `"${table.name}"."${c}"`).join(", "));
+					}
+					for (const js of state.joinSelections) if (js.selected.length === 1 && js.selected[0] === "*") selectParts.push(`"${js.target.name}".*`);
+					else {
+						const cols$1 = js.selected;
+						for (const c of cols$1) findColumn(js.target, String(c));
+						selectParts.push(cols$1.map((c) => `"${js.target.name}"."${c}"`).join(", "));
+					}
+					parts.push(`select ${selectParts.join(", ")} from "${schema.name}"."${table.name}"`);
+					for (const j of state.joins) {
+						const onExpr = j.on.map((p$1) => `"${table.name}"."${p$1.left}" = "${j.target.name}"."${p$1.right}"`).join(" and ");
+						parts.push(`${j.type} join "${schema.name}"."${j.target.name}" on ${onExpr}`);
+					}
+					const andParts = [];
+					for (const key in state.where) {
+						const value = state.where[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						if (value === null) {
+							if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+							andParts.push(`"${table.name}"."${key}" is null`);
+						} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+							validateInArrayValues(col, key, value, "in");
+							andParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						} else {
+							validateScalarForColumn(col, value, `column ${key}`);
+							andParts.push(`"${table.name}"."${key}" = :${paramName}`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						}
+					}
+					for (const pred of state.andOps) {
+						const key = String(pred.col);
+						const op = String(pred.op);
+						const col = findColumn(table, key);
+						const qualified = `"${table.name}"."${key}"`;
+						if (op === "isnull" || op === "notnull") {
+							if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
+							andParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
+						} else if (op === "in" || op === "notin") {
+							const val = pred.value;
+							if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
+							validateInArrayValues(col, key, val, op);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							andParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
+							params[paramName] = val;
+							addTypeHintForParam(type_hints, paramName, col, val);
+						} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
+							const val = pred.value;
+							if (typeof val !== "string") throw new Error(`Operator ${op} requires a string value for column ${key}`);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
+							andParts.push(`${qualified} ${sqlOp} :${paramName}`);
+							params[paramName] = val;
+							addTypeHintForParam(type_hints, paramName, col, val);
+						} else {
+							const val = pred.value;
+							if (val === void 0) throw new Error(`Operator ${op} requires a value for column ${key}`);
+							validateComparisonValue(col, key, val, op);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							if (op === "=") andParts.push(`${qualified} = :${paramName}`);
+							else if (op === "!=") andParts.push(`${qualified} <> :${paramName}`);
+							else if (op === "<" || op === "<=" || op === ">" || op === ">=") andParts.push(`${qualified} ${op} :${paramName}`);
+							else throw new Error(`Unsupported operator: ${op}`);
+							params[paramName] = val;
+							addTypeHintForParam(type_hints, paramName, col, val);
+						}
+					}
+					const orGroupSql = [];
+					for (const group of state.orWhereGroups) {
+						const orParts = [];
+						for (const key in group) {
+							const value = group[key];
+							const col = findColumn(table, key);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							if (value === null) {
+								if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+								orParts.push(`"${table.name}"."${key}" is null`);
+							} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+								validateInArrayValues(col, key, value, "in");
+								orParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
+								params[paramName] = value;
+								addTypeHintForParam(type_hints, paramName, col, value);
+							} else {
+								validateScalarForColumn(col, value, `column ${key}`);
+								orParts.push(`"${table.name}"."${key}" = :${paramName}`);
+								params[paramName] = value;
+								addTypeHintForParam(type_hints, paramName, col, value);
+							}
+						}
+						if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
+					}
+					for (const group of state.orOpGroups) {
+						const orParts = [];
+						for (const pred of group) {
+							const key = String(pred.col);
+							const op = String(pred.op);
+							const col = findColumn(table, key);
+							const qualified = `"${table.name}"."${key}"`;
+							if (op === "isnull" || op === "notnull") {
+								if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
+								orParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
+							} else if (op === "in" || op === "notin") {
+								const val = pred.value;
+								if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
+								validateInArrayValues(col, key, val, op);
+								p += 1;
+								const paramName = `${table.name}_${key}_${p}`;
+								orParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
+								params[paramName] = val;
+								addTypeHintForParam(type_hints, paramName, col, val);
+							} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
+								const val = pred.value;
+								if (typeof val !== "string") throw new Error(`Operator ${op} requires a string value for column ${key}`);
+								p += 1;
+								const paramName = `${table.name}_${key}_${p}`;
+								const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
+								orParts.push(`${qualified} ${sqlOp} :${paramName}`);
+								params[paramName] = val;
+								addTypeHintForParam(type_hints, paramName, col, val);
+							} else {
+								const val = pred.value;
+								if (val === void 0) throw new Error(`Operator ${op} requires a value for column ${key}`);
+								validateComparisonValue(col, key, val, op);
+								p += 1;
+								const paramName = `${table.name}_${key}_${p}`;
+								if (op === "=") orParts.push(`${qualified} = :${paramName}`);
+								else if (op === "!=") orParts.push(`${qualified} <> :${paramName}`);
+								else if (op === "<" || op === "<=" || op === ">" || op === ">=") orParts.push(`${qualified} ${op} :${paramName}`);
+								else throw new Error(`Unsupported operator: ${op}`);
+								params[paramName] = val;
+								addTypeHintForParam(type_hints, paramName, col, val);
+							}
+						}
+						if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
+					}
+					if (orGroupSql.length) {
+						const andSql = andParts.length ? `(${andParts.join(" and ")})` : "";
+						const orSql = orGroupSql.join(" or ");
+						const full = andSql ? `${andSql} or ${orSql}` : orSql;
+						if (full.trim().length) parts.push("where " + full);
+					} else if (andParts.length) parts.push("where " + andParts.join(" and "));
+					if (state.order.length) {
+						const orders = [];
+						for (const o of state.order) orders.push(`"${table.name}"."${o.col}" ${o.dir}`);
+						parts.push("order by " + orders.join(", "));
+					}
+					if (state.limit !== void 0) parts.push("limit " + state.limit);
+					if (state.offset !== void 0) parts.push("offset " + state.offset);
+					return {
+						q: parts.join(" "),
+						params,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
+					};
+				};
+			}
+			selectFrom(tableName, cols$1) {
+				const jtName = String(tableName);
+				const join = this.s.joins.find((j) => j.target.name === jtName);
+				if (!join) throw new Error(`selectFrom('${jtName}') requires a prior join('${jtName}') call`);
+				const sel = !cols$1 || cols$1.length === 0 ? ["*"] : cols$1.map(String);
+				if (!(sel.length === 1 && sel[0] === "*")) for (const c of sel) findColumn(join.target, String(c));
+				const existing = this.s.joinSelections.find((js) => js.target.name === jtName);
+				if (existing) {
+					if (existing.selected.includes("*")) return this;
+					if (sel.length === 1 && sel[0] === "*") existing.selected = ["*"];
+					else {
+						const set = new Set(existing.selected);
+						for (const c of sel) set.add(String(c));
+						existing.selected = Array.from(set);
+					}
+				} else this.s.joinSelections.push({
+					target: join.target,
+					selected: sel
+				});
+				return this;
+			}
+			andWhere(where) {
+				for (const k in where) this.s.where[k] = where[k];
+				return this;
+			}
+			/** @deprecated Use andWhere() instead */
+			where(where) {
+				return this.andWhere(where);
+			}
+			orWhere(where) {
+				this.s.orWhereGroups.push(where);
+				return this;
+			}
+			wherePk(pk) {
+				const pkCols = getPrimaryKeyColumns(table);
+				if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+				if (pkCols.length === 1) {
+					const colName = pkCols[0];
+					const colDef = findColumn(table, colName);
+					if (pk === null || pk === void 0) throw new Error(`wherePk on ${table.name} requires a non-null value for primary key column ${colName}`);
+					if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
+					if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
+					validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
+					this.s.where[colName] = pk;
+					return this;
+				} else {
+					if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+					const obj = pk;
+					for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+					for (const colName of pkCols) {
+						if (!(colName in obj)) throw new Error(`wherePk missing key '${colName}'. Required keys: ${pkCols.join(", ")}`);
+						const v = obj[colName];
+						if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
+						if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
+						validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
+						this.s.where[colName] = v;
+					}
+					return this;
+				}
+			}
+			andWhereOp(col, op, ...args) {
+				const value = args[0];
+				this.s.andOps.push({
+					col,
+					op,
+					value
+				});
+				return this;
+			}
+			orWhereOp(col, op, ...args) {
+				const value = args[0];
+				this.s.orOpGroups.push([{
+					col,
+					op,
+					value
+				}]);
+				return this;
+			}
+			andWhereOpGroup(predicates) {
+				const group = predicates.map((p) => ({
+					col: p[0],
+					op: p[1],
+					value: p[2]
+				}));
+				for (const g of group) this.s.andOps.push(g);
+				return this;
+			}
+			orWhereOpGroup(predicates) {
+				const group = predicates.map((p) => ({
+					col: p[0],
+					op: p[1],
+					value: p[2]
+				}));
+				this.s.orOpGroups.push(group);
+				return this;
+			}
+			orderBy(order) {
+				this.s.order = [];
+				const isValidDir = (d) => d === "asc" || d === "desc";
+				if (typeof order === "string") {
+					findColumn(table, String(order));
+					this.s.order.push({
+						col: order,
+						dir: "asc"
+					});
+				} else for (const item of order) {
+					const col = String(item[0]);
+					const dir = String(item[1]);
+					findColumn(table, col);
+					if (!isValidDir(dir)) throw new Error(`Invalid order direction: ${dir}. Allowed: asc | desc`);
+					this.s.order.push({
+						col: item[0],
+						dir
+					});
+				}
+				return this;
+			}
+			limit(n) {
+				if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid limit: ${n}. Limit must be a non-negative integer`);
+				this.s.limit = n;
+				return this;
+			}
+			offset(n) {
+				if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid offset: ${n}. Offset must be a non-negative integer`);
+				this.s.offset = n;
+				return this;
+			}
+			join(tableName, type = "inner") {
+				const target = findTable(schema, String(tableName));
+				const pairs = findJoinOn(table, target);
+				if (!pairs || !pairs.length) throw new Error(`No foreign key relation found between ${table.name} and ${target.name}`);
+				const jt = String(type);
+				if (jt !== "inner" && jt !== "left" && jt !== "right" && jt !== "full") throw new Error(`Invalid join type: ${jt}. Allowed: inner | left | right | full`);
+				this.s.joins.push({
+					type: jt,
+					target,
+					on: pairs
+				});
+				return this;
+			}
+		}();
+	}
+	insert(values) {
+		const table = this.table;
+		const schema = this.schema;
+		const state = {
+			values,
+			returning: []
+		};
+		return new class {
+			constructor() {
+				this.returning = (cols) => {
+					state.returning = cols || [];
+					return this;
+				};
+				this.toSql = () => {
+					const cols = [];
+					const vals = [];
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					for (const key in state.values) {
+						const value = state.values[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						cols.push(`"${key}"`);
+						vals.push(`:${paramName}`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					}
+					const parts = [];
+					parts.push(`insert into "${schema.name}"."${table.name}" (${cols.join(", ")}) values (${vals.join(", ")})`);
+					if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+					return {
+						q: parts.join(" "),
+						params,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
+					};
+				};
+			}
+		}();
+	}
+	update(values) {
+		const table = this.table;
+		const schema = this.schema;
+		const state = {
+			values,
+			where: {},
+			returning: []
+		};
+		return new class {
+			constructor() {
+				this.where = (w) => {
+					for (const k in w) state.where[k] = w[k];
+					return this;
+				};
+				this.wherePk = (pk) => {
+					const pkCols = getPrimaryKeyColumns(table);
+					if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+					if (pkCols.length === 1) {
+						const colName = pkCols[0];
+						const colDef = findColumn(table, colName);
+						if (pk === null || pk === void 0) throw new Error(`wherePk on ${table.name} requires a non-null value for primary key column ${colName}`);
+						if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
+						if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
+						validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
+						state.where[colName] = pk;
+					} else {
+						if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+						const obj = pk;
+						for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+						for (const colName of pkCols) {
+							if (!(colName in obj)) throw new Error(`wherePk missing key '${colName}'. Required keys: ${pkCols.join(", ")}`);
+							const v = obj[colName];
+							if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
+							if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
+							validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
+							state.where[colName] = v;
+						}
+					}
+					return this;
+				};
+				this.returning = (cols) => {
+					state.returning = cols || [];
+					return this;
+				};
+				this.toSql = () => {
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					const setParts = [];
+					for (const key in state.values) {
+						const value = state.values[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						setParts.push(`"${key}" = :${paramName}`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					}
+					const whereClauses = [];
+					for (const key in state.where) {
+						const value = state.where[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						if (value === null) {
+							if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+							whereClauses.push(`"${key}" is null`);
+						} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+							validateInArrayValues(col, key, value, "in");
+							whereClauses.push(`"${key}" = ANY(:${paramName})`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						} else {
+							validateScalarForColumn(col, value, `column ${key}`);
+							whereClauses.push(`"${key}" = :${paramName}`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						}
+					}
+					const parts = [];
+					parts.push(`update "${schema.name}"."${table.name}" set ${setParts.join(", ")}`);
+					if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
+					if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+					return {
+						q: parts.join(" "),
+						params,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
+					};
+				};
+			}
+		}();
+	}
+	delete() {
+		const table = this.table;
+		const schema = this.schema;
+		const state = {
+			where: {},
+			returning: []
+		};
+		return new class {
+			constructor() {
+				this.where = (w) => {
+					for (const k in w) state.where[k] = w[k];
+					return this;
+				};
+				this.wherePk = (pk) => {
+					const pkCols = getPrimaryKeyColumns(table);
+					if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+					if (pkCols.length === 1) {
+						const col = pkCols[0];
+						if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${col}`);
+						state.where[col] = pk;
+					} else {
+						if (!isPlainObject(pk)) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+						const obj = pk;
+						for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+						for (const col of pkCols) {
+							if (!(col in obj)) throw new Error(`wherePk missing key '${col}'. Required keys: ${pkCols.join(", ")}`);
+							state.where[col] = obj[col];
+						}
+					}
+					return this;
+				};
+				this.returning = (cols) => {
+					state.returning = cols || [];
+					return this;
+				};
+				this.toSql = () => {
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					const whereClauses = [];
+					for (const key in state.where) {
+						const value = state.where[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						if (value === null) {
+							if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+							whereClauses.push(`"${key}" is null`);
+						} else if (Array.isArray(value)) {
+							validateInArrayValues(col, key, value, "in");
+							whereClauses.push(`"${key}" = ANY(:${paramName})`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						} else {
+							validateScalarForColumn(col, value, `column ${key}`);
+							whereClauses.push(`"${key}" = :${paramName}`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						}
+					}
+					const parts = [];
+					parts.push(`delete from "${schema.name}"."${table.name}"`);
+					if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
+					if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+					return {
+						q: parts.join(" "),
+						params,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
+					};
+				};
+			}
+		}();
+	}
+};
+function createSqlBuilder(schema) {
+	return { table: (name) => new TableQueryImpl(schema, String(name)) };
+}
+
+//#endregion
+export { Claims, CodeFlow, Meta, PasswordFlow, Rpc, SignUp, Sql, Stats, Status, Tables, Users, Ws, createApi, createSqlBuilder };
 //# sourceMappingURL=centia-io-sdk.js.map