@kozou/svelte-ui 0.2.1 → 1.1.0

package/build/server/chunks/{zod-from-table-CCy3rZQi.js → composite-form-C6ci57iZ.js}

@@ -1,6 +1,6 @@
-import { y as noop, G as parse, C as onDestroy, X as tick, S as stringify$1, c as __toESM, _ as __commonJSMin, a as __exportAll } from './internal-BERZdLJL.js';
+import { y as noop, G as parse, C as onDestroy, X as tick, S as stringify$1, c as __toESM, _ as __commonJSMin, a as __exportAll } from './internal-Cuea68jL.js';
 import { u as get$1, ad as writable, n as derived$1, Y as readonly, x as getContext } from './dev-yFiAtg5l.js';
-import { i as invalidateAll, b as applyAction, a as afterNavigate } from './client-PK7K0DFj.js';
+import { i as invalidateAll, b as applyAction, a as afterNavigate } from './client-_87vxA9R.js';
 import { a as app } from './app-DST8OmzT.js';
 import './index-5kYmxIr9.js';
 import { toJSONSchema, config, safeParseAsync } from 'zod/v4/core';
@@ -2388,6 +2388,191 @@ async function superValidate(data, adapter, options) {
 	}
 	return output;
 }
+//#endregion
+//#region src/lib/form/relation-field-config.ts
+/**
+* Whether an option can round-trip through the picker contract. A key
+* containing an EMPTY-STRING component collides with the contract's ''
+* unselected sentinel — picking it would corrupt the write (the component
+* would be normalized to null) — so such options are not offered (a
+* documented limitation, see {@link promoteCompositeMemberWidgets}).
+*/
+function isPickableOption(option) {
+	return (Array.isArray(option.id) ? option.id : [option.id]).every((part) => part !== "");
+}
+/**
+* The composite picker's explicit clear value. The empty string cannot mean
+* "clear" on the native path: an unselected (e.g. partial-null) current
+* value renders the select at '' too, and an untouched no-JS save must keep
+* the baseline values rather than erase them. A real composite option value
+* always contains a comma (two or more components), so this marker cannot
+* collide with one.
+*/
+var COMPOSITE_CLEAR_VALUE = "__clear__";
+/**
+* Name of the single form control a composite picker submits. A no-JS
+* (non-enhanced) submission cannot fan the selection out to the component
+* fields itself, so the picker's `<select>` carries the canonical encoded id
+* under this synthetic name and the server decodes it into the component
+* fields ahead of validation (see `readFormWithCompositePicks`). The enhanced
+* path ignores it (the form store travels in superforms' JSON envelope).
+*/
+function compositeParamName(field) {
+	return `__composite__${field}`;
+}
+var TEXT_LIKE_BASE_TYPES = new Set([
+	"text",
+	"character varying",
+	"varchar",
+	"character",
+	"char",
+	"bpchar",
+	"citext",
+	"name"
+]);
+function isTextSearchable(dataType) {
+	const lower = dataType.trim().toLowerCase();
+	if (lower.includes("[")) return false;
+	const paren = lower.indexOf("(");
+	const base = (paren === -1 ? lower : lower.slice(0, paren)).trim();
+	return TEXT_LIKE_BASE_TYPES.has(base);
+}
+/** Resolve the searchable label column of a picker target, or `null` when the
+*  picker would be unusable (no text-searchable label). */
+function searchableLabel(target) {
+	const labelField = target.displayField ?? target.primaryKey[0];
+	const labelColumn = target.columns.find((c) => c.name === labelField);
+	if (labelColumn === void 0 || !isTextSearchable(labelColumn.dataType)) return null;
+	return {
+		labelField,
+		searchFields: [labelField]
+	};
+}
+function relationFieldConfigs(table, schema) {
+	const configs = [];
+	for (const relation of table.relations) {
+		const fields = relation.fields ?? [relation.field];
+		const referencedColumns = relation.references.columns ?? [relation.references.column];
+		if (referencedColumns.length !== fields.length) continue;
+		const resource = `${relation.references.schema}.${relation.references.table}`;
+		const target = schema.tables.find((t) => t.qualifiedName === resource);
+		if (target === void 0) continue;
+		const primaryKey = target.primaryKey;
+		if (primaryKey.length !== referencedColumns.length || !primaryKey.every((column) => referencedColumns.includes(column))) continue;
+		const label = searchableLabel(target);
+		if (label === null) continue;
+		if (fields.length === 1) {
+			configs.push({
+				field: fields[0],
+				resource,
+				...label
+			});
+			continue;
+		}
+		if (table.columns.some((c) => c.name === compositeParamName(fields[0]))) continue;
+		const keyFields = primaryKey.map((column) => fields[referencedColumns.indexOf(column)]);
+		configs.push({
+			field: fields[0],
+			fields: [...fields],
+			keyFields,
+			resource,
+			...label
+		});
+	}
+	const claims = /* @__PURE__ */ new Map();
+	for (const relation of table.relations) for (const field of relation.fields ?? [relation.field]) claims.set(field, (claims.get(field) ?? 0) + 1);
+	return configs.filter((config) => {
+		const fields = config.fields ?? [config.field];
+		if (fields.length === 1) return true;
+		return fields.every((field) => claims.get(field) === 1);
+	});
+}
+/**
+* Pick a scalar input widget for a column from its `dataType`.
+*
+* Used to demote a single-column foreign key that core marked `relation-select`
+* but that has no usable picker config (it references a non-PK unique column).
+* Without this it would render an empty, unselectable relation dropdown; the
+* scalar input lets the operator type the raw value instead. Mirrors the
+* type-based arm of core's widget inference, but keyed on the formatted
+* `dataType` exposed on `ColumnContext`.
+*/
+function scalarWidgetForDataType(dataType) {
+	const type = dataType.toLowerCase();
+	if (type === "uuid") return "uuid";
+	if (type === "boolean" || type === "bool") return "boolean";
+	if (type === "date") return "date";
+	if (type.includes("timestamp") || type.startsWith("time")) return "datetime";
+	if (type === "json" || type === "jsonb") return "json";
+	if (type.includes("int") || type.includes("numeric") || type.includes("decimal") || type.includes("double") || type === "real") return "number";
+	return "text";
+}
+/**
+* Return a copy of `table` with each unpickable single-column relation-select
+* column demoted to a scalar widget (see {@link scalarWidgetForDataType}).
+*
+* The create / edit routes build BOTH the rendered widget and the zod
+* validation schema from this, so a demoted field validates as the scalar type
+* the operator actually sees rather than the loose relation-select union.
+* Composite foreign-key columns are untouched: core never marks them
+* `relation-select` (they carry type-based scalar widgets), and the composite
+* picker writes through those scalar fields rather than replacing them.
+*/
+function demoteUnpickableRelations(table, relations) {
+	const pickable = new Set(relations.filter((r) => (r.fields ?? [r.field]).length === 1).map((r) => r.field));
+	return {
+		...table,
+		columns: table.columns.map((c) => c.widget === "relation-select" && !pickable.has(c.name) ? {
+			...c,
+			widget: scalarWidgetForDataType(c.dataType)
+		} : c)
+	};
+}
+/**
+* Return a copy of `table` with every composite-picker component column
+* switched to the `relation-select` widget, so the form layer treats it as a
+* picker-held value rather than a typed scalar input:
+*
+*  - zodFromColumn applies the picker semantics: the unselected default is
+*    `''` and a required component rejects an empty submission — without
+*    this, superforms initializes an absent required numeric component to
+*    `0`, and the suppressed (never-rendered) member columns would silently
+*    submit a fabricated `(0, 0, ...)` reference;
+*  - buildMutationPayload normalizes `''` to null (or drops it for a
+*    DB-supplied column) instead of letting it coerce.
+*
+* The columns themselves are never rendered — the composite picker replaces
+* them — so the widget change is purely a validation / payload contract.
+* Apply AFTER {@link demoteUnpickableRelations} (which would demote the
+* promoted members straight back).
+*
+* Known limitation: the contract reserves '' as the unselected sentinel
+* (matching the single-column picker), so a key that contains an
+* EMPTY-STRING component cannot round-trip through the form — a required
+* component rejects it and an optional one normalizes it to null. The
+* picker therefore does not offer such options ({@link isPickableOption}),
+* the native decoder treats them as malformed, and the current-value seeding
+* skips them; an untouched edit save of a row already holding such a key
+* still normalizes the '' component (this predates composite support — the
+* single-column picker has the same property). Such keys are pathological
+* schema design and remain manageable through the API.
+*/
+function promoteCompositeMemberWidgets(table, relations) {
+	const members = /* @__PURE__ */ new Set();
+	for (const config of relations) {
+		const fields = config.fields ?? [config.field];
+		if (fields.length < 2) continue;
+		for (const field of fields) members.add(field);
+	}
+	if (members.size === 0) return table;
+	return {
+		...table,
+		columns: table.columns.map((c) => members.has(c.name) ? {
+			...c,
+			widget: "relation-select"
+		} : c)
+	};
+}
 
 //#region ../../node_modules/.pnpm/memoize-weak@1.0.2/node_modules/memoize-weak/lib/memoize.js
 var require_memoize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -6869,6 +7054,11 @@ function dbCanSupplyColumn(column) {
 	return column.defaultExpr !== null || column.readonly;
 }
 function zodFromColumn(column) {
+	if (column.widget === "relation-select") {
+		const required = !column.nullable && !dbCanSupplyColumn(column);
+		const id = z.union([required ? z.string().min(1) : z.string(), z.number()]);
+		return (column.nullable ? id.nullable() : id).default("");
+	}
 	const base = pickBase(column);
 	if (dbCanSupplyColumn(column)) {
 		const inner = column.nullable ? base.nullable() : base;
@@ -6887,7 +7077,6 @@ function pickBase(column) {
 		case "enum-select":
 			if (column.enumValues && column.enumValues.length > 0) return z.enum(column.enumValues);
 			return z.string();
-		case "relation-select": return z.union([z.string(), z.number()]);
 		case "uuid": return z.guid();
 		case "json": return z.unknown();
 		case "image-url":
@@ -6901,11 +7090,17 @@ function pickBase(column) {
 function isEmpty(value) {
 	return value === "" || value === void 0;
 }
-function buildMutationPayload(table, data) {
+function buildMutationPayload(table, data, mode = "create") {
 	const byName = new Map(table.columns.map((c) => [c.name, c]));
 	const payload = {};
 	for (const [key, value] of Object.entries(data)) {
 		const column = byName.get(key);
+		if (column?.widget === "relation-select" && value === "") {
+			if (!(dbCanSupplyColumn(column) && (mode === "create" || column.readonly))) {
+				payload[key] = null;
+				continue;
+			}
+		}
 		if (column && dbCanSupplyColumn(column) && isEmpty(value)) continue;
 		payload[key] = value;
 	}
@@ -6918,6 +7113,53 @@ function zodFromTable(table) {
 	for (const column of table.columns) shape[column.name] = zodFromColumn(column);
 	return z.object(shape);
 }
+//#endregion
+//#region src/lib/server/composite-form.ts
+/**
+* Return what the route action should hand to `superValidate`: the request
+* itself when the table has no pickers, the raw FormData when it carries the
+* enhanced JSON envelope, or a plain object holding the native submission
+* with each composite pick decoded into its component fields. Returns `null`
+* for a malformed composite control — wrong arity, invalid percent-encoding,
+* or an empty-string component — so the action can reject the submission:
+* letting it fall through to the schema defaults would silently CLEAR an
+* optional relation instead of reporting the bad value (a required one
+* already fails validation through the '' defaults).
+*/
+async function readFormWithCompositePicks(request, relations) {
+	if (relations.length === 0) return request;
+	const contentType = request.headers.get("content-type") ?? "";
+	if (!contentType.includes("application/x-www-form-urlencoded") && !contentType.includes("multipart/form-data")) return request;
+	const data = await request.formData();
+	if (data.has("__superform_json")) return data;
+	const fields = {};
+	for (const [key, value] of data.entries()) if (typeof value === "string" && value !== "") fields[key] = value;
+	for (const config of relations) {
+		const keyFields = config.keyFields ?? [config.field];
+		if (keyFields.length < 2) continue;
+		const param = compositeParamName(config.field);
+		const raw = fields[param];
+		if (typeof raw !== "string") continue;
+		delete fields[param];
+		if (raw === "") continue;
+		if (raw === "__clear__") {
+			for (const field of keyFields) delete fields[field];
+			continue;
+		}
+		let components;
+		try {
+			components = raw.split(",").map((part) => decodeURIComponent(part));
+		} catch {
+			return null;
+		}
+		if (components.length !== keyFields.length) return null;
+		if (components.some((part) => part === "")) return null;
+		keyFields.forEach((field, i) => {
+			fields[field] = components[i];
+		});
+	}
+	return fields;
+}
 
-export { superValidate as a, buildMutationPayload as b, zodFromTable as c, superForm as s, zod as z };
-//# sourceMappingURL=zod-from-table-CCy3rZQi.js.map
+export { COMPOSITE_CLEAR_VALUE as C, relationFieldConfigs as a, buildMutationPayload as b, compositeParamName as c, demoteUnpickableRelations as d, superValidate as e, zodFromTable as f, isPickableOption as i, promoteCompositeMemberWidgets as p, readFormWithCompositePicks as r, superForm as s, zod as z };
+//# sourceMappingURL=composite-form-C6ci57iZ.js.map