clivly 0.1.0 → 0.2.1

package/mapping-form-BHtPexzI.mjs

@@ -0,0 +1,47 @@
+//#region ../core/src/mapping-form.ts
+/**
+* Build the filter for a discriminated entity: rows where `column` equals
+* `value` belong to this entity (e.g. `role = "owner"`). Returns `undefined`
+* when either side is blank so the caller can omit the filter entirely.
+*/
+function buildFilterFromDiscriminator(column, value) {
+	const col = column?.trim();
+	const val = value.trim();
+	if (!col || val === "") return;
+	return { [col]: { eq: val } };
+}
+/**
+* A stable identity string for a relationship's `via`. Two candidates on the
+* same source table always differ in their join (`fkOn`+column, join-table
+* keys, or raw SQL), so this disambiguates candidates the heuristic gives the
+* same `name` (every contact→company candidate is named "company").
+*/
+function relationshipViaSignature(via) {
+	if ("fkOn" in via) return `fk:${via.fkOn}:${via.column}`;
+	if ("through" in via) return `through:${via.through}:${via.localKey}:${via.foreignKey}`;
+	return `raw:${via.$raw}`;
+}
+/**
+* Compile the selected relationship candidates into the persisted
+* `RelationshipsMap`. Returns `undefined` for an empty selection so the caller
+* omits the field.
+*/
+function buildRelationships(candidates) {
+	if (candidates.length === 0) return;
+	const map = {};
+	for (const candidate of candidates) {
+		let key = candidate.name;
+		let suffix = 2;
+		while (key in map) {
+			key = `${candidate.name}_${suffix}`;
+			suffix++;
+		}
+		map[key] = {
+			entity: candidate.entityTable,
+			via: candidate.via
+		};
+	}
+	return map;
+}
+//#endregion
+export { buildRelationships as n, relationshipViaSignature as r, buildFilterFromDiscriminator as t };

package/mapping-form-CUlFVfG8.d.cts

@@ -0,0 +1,35 @@
+import { _ as RelationshipsMap, d as FilterExpr, g as RelationshipVia } from "./entity-config-GczjD3y8.cjs";
+
+//#region ../core/src/mapping-form.d.ts
+/**
+ * A relationship the mapping UI can offer or has configured, in the shape the
+ * heuristic suggester produces. `entityTable` is the *host table name*; the
+ * mappings→config compiler resolves it to the canonical entity key, so it is
+ * persisted verbatim as the relationship's `entity` reference.
+ */
+interface RelationshipCandidate {
+  entityTable: string;
+  name: string;
+  via: RelationshipVia;
+}
+/**
+ * Build the filter for a discriminated entity: rows where `column` equals
+ * `value` belong to this entity (e.g. `role = "owner"`). Returns `undefined`
+ * when either side is blank so the caller can omit the filter entirely.
+ */
+declare function buildFilterFromDiscriminator(column: string | null | undefined, value: string): FilterExpr | undefined;
+/**
+ * A stable identity string for a relationship's `via`. Two candidates on the
+ * same source table always differ in their join (`fkOn`+column, join-table
+ * keys, or raw SQL), so this disambiguates candidates the heuristic gives the
+ * same `name` (every contact→company candidate is named "company").
+ */
+declare function relationshipViaSignature(via: RelationshipVia): string;
+/**
+ * Compile the selected relationship candidates into the persisted
+ * `RelationshipsMap`. Returns `undefined` for an empty selection so the caller
+ * omits the field.
+ */
+declare function buildRelationships(candidates: RelationshipCandidate[]): RelationshipsMap | undefined;
+//#endregion
+export { relationshipViaSignature as i, buildFilterFromDiscriminator as n, buildRelationships as r, RelationshipCandidate as t };

package/mapping-form-DdmDebC3.cjs

@@ -0,0 +1,64 @@
+//#region ../core/src/mapping-form.ts
+/**
+* Build the filter for a discriminated entity: rows where `column` equals
+* `value` belong to this entity (e.g. `role = "owner"`). Returns `undefined`
+* when either side is blank so the caller can omit the filter entirely.
+*/
+function buildFilterFromDiscriminator(column, value) {
+	const col = column?.trim();
+	const val = value.trim();
+	if (!col || val === "") return;
+	return { [col]: { eq: val } };
+}
+/**
+* A stable identity string for a relationship's `via`. Two candidates on the
+* same source table always differ in their join (`fkOn`+column, join-table
+* keys, or raw SQL), so this disambiguates candidates the heuristic gives the
+* same `name` (every contact→company candidate is named "company").
+*/
+function relationshipViaSignature(via) {
+	if ("fkOn" in via) return `fk:${via.fkOn}:${via.column}`;
+	if ("through" in via) return `through:${via.through}:${via.localKey}:${via.foreignKey}`;
+	return `raw:${via.$raw}`;
+}
+/**
+* Compile the selected relationship candidates into the persisted
+* `RelationshipsMap`. Returns `undefined` for an empty selection so the caller
+* omits the field.
+*/
+function buildRelationships(candidates) {
+	if (candidates.length === 0) return;
+	const map = {};
+	for (const candidate of candidates) {
+		let key = candidate.name;
+		let suffix = 2;
+		while (key in map) {
+			key = `${candidate.name}_${suffix}`;
+			suffix++;
+		}
+		map[key] = {
+			entity: candidate.entityTable,
+			via: candidate.via
+		};
+	}
+	return map;
+}
+//#endregion
+Object.defineProperty(exports, "buildFilterFromDiscriminator", {
+	enumerable: true,
+	get: function() {
+		return buildFilterFromDiscriminator;
+	}
+});
+Object.defineProperty(exports, "buildRelationships", {
+	enumerable: true,
+	get: function() {
+		return buildRelationships;
+	}
+});
+Object.defineProperty(exports, "relationshipViaSignature", {
+	enumerable: true,
+	get: function() {
+		return relationshipViaSignature;
+	}
+});

package/mapping-form-kjSiJaCX.d.mts

@@ -0,0 +1,35 @@
+import { _ as RelationshipsMap, d as FilterExpr, g as RelationshipVia } from "./entity-config-D1DFyeUp.mjs";
+
+//#region ../core/src/mapping-form.d.ts
+/**
+ * A relationship the mapping UI can offer or has configured, in the shape the
+ * heuristic suggester produces. `entityTable` is the *host table name*; the
+ * mappings→config compiler resolves it to the canonical entity key, so it is
+ * persisted verbatim as the relationship's `entity` reference.
+ */
+interface RelationshipCandidate {
+  entityTable: string;
+  name: string;
+  via: RelationshipVia;
+}
+/**
+ * Build the filter for a discriminated entity: rows where `column` equals
+ * `value` belong to this entity (e.g. `role = "owner"`). Returns `undefined`
+ * when either side is blank so the caller can omit the filter entirely.
+ */
+declare function buildFilterFromDiscriminator(column: string | null | undefined, value: string): FilterExpr | undefined;
+/**
+ * A stable identity string for a relationship's `via`. Two candidates on the
+ * same source table always differ in their join (`fkOn`+column, join-table
+ * keys, or raw SQL), so this disambiguates candidates the heuristic gives the
+ * same `name` (every contact→company candidate is named "company").
+ */
+declare function relationshipViaSignature(via: RelationshipVia): string;
+/**
+ * Compile the selected relationship candidates into the persisted
+ * `RelationshipsMap`. Returns `undefined` for an empty selection so the caller
+ * omits the field.
+ */
+declare function buildRelationships(candidates: RelationshipCandidate[]): RelationshipsMap | undefined;
+//#endregion
+export { relationshipViaSignature as i, buildFilterFromDiscriminator as n, buildRelationships as r, RelationshipCandidate as t };

package/mapping-score-A2lRnlpk.d.mts

@@ -0,0 +1,49 @@
+//#region ../core/src/mapping-score.d.ts
+type Tier = "High" | "Medium" | "Low";
+interface Scored<T> {
+  /** Human-readable chips, e.g. `type text`, `name matches "contacts"`. */
+  reasons: string[];
+  /** Internal — used for ranking and the apply threshold. Never rendered. */
+  score: number;
+  tier: Tier;
+  value: T;
+}
+/** Tier cut-offs: score >= high → High; >= medium → Medium; else Low. */
+interface Thresholds {
+  high: number;
+  medium: number;
+}
+declare const CONCEPT_TIERS: Thresholds;
+declare const FIELD_TIERS: Thresholds;
+declare const RELATIONSHIP_TIERS: Thresholds;
+/** Two concept candidates closer than this are treated as ambiguous. */
+declare const AMBIGUITY_MARGIN = 15;
+/** Signal weights. Tuned against fixtures; adjust here, not at call sites. */
+declare const W: {
+  readonly nameExact: 50;
+  readonly nameSubstring: 25;
+  readonly definingColumn: 20;
+  readonly hasPrimaryKey: 10;
+  readonly hasRows: 10;
+  readonly emptyTable: -20;
+  readonly fieldNameMatch: 50;
+  readonly typeCompatible: 30;
+  readonly typeMismatch: -30;
+  readonly requiredNotNull: 10;
+  readonly fkResolved: 60;
+  readonly fkNameHint: 30;
+  readonly joinTable: 20;
+};
+declare function tierFor(score: number, t: Thresholds): Tier;
+declare function isTextLike(type: string | undefined): boolean;
+declare function isNumericLike(type: string | undefined): boolean;
+declare function isTimestampLike(type: string | undefined): boolean;
+/**
+ * True when the top two candidates are too close to call. Callers must never
+ * one-click apply an ambiguous result — the user picks.
+ */
+declare function isAmbiguous(ranked: Array<{
+  score: number;
+}>): boolean;
+//#endregion
+export { Scored as a, W as c, isTextLike as d, isTimestampLike as f, RELATIONSHIP_TIERS as i, isAmbiguous as l, CONCEPT_TIERS as n, Thresholds as o, tierFor as p, FIELD_TIERS as r, Tier as s, AMBIGUITY_MARGIN as t, isNumericLike as u };

package/mapping-score-BJNe0lFn.mjs

@@ -0,0 +1,87 @@
+//#region ../core/src/mapping-score.ts
+const CONCEPT_TIERS = {
+	high: 70,
+	medium: 40
+};
+const FIELD_TIERS = {
+	high: 70,
+	medium: 40
+};
+const RELATIONSHIP_TIERS = {
+	high: 60,
+	medium: 30
+};
+/** Two concept candidates closer than this are treated as ambiguous. */
+const AMBIGUITY_MARGIN = 15;
+/** Signal weights. Tuned against fixtures; adjust here, not at call sites. */
+const W = {
+	nameExact: 50,
+	nameSubstring: 25,
+	definingColumn: 20,
+	hasPrimaryKey: 10,
+	hasRows: 10,
+	emptyTable: -20,
+	fieldNameMatch: 50,
+	typeCompatible: 30,
+	typeMismatch: -30,
+	requiredNotNull: 10,
+	fkResolved: 60,
+	fkNameHint: 30,
+	joinTable: 20
+};
+function tierFor(score, t) {
+	if (score >= t.high) return "High";
+	if (score >= t.medium) return "Medium";
+	return "Low";
+}
+const TEXT_TYPES = [
+	"text",
+	"varchar",
+	"char",
+	"citext",
+	"uuid",
+	"string"
+];
+const NUMERIC_TYPES = [
+	"numeric",
+	"decimal",
+	"int",
+	"integer",
+	"bigint",
+	"smallint",
+	"float",
+	"double",
+	"real",
+	"money"
+];
+const TIMESTAMP_TYPES = [
+	"timestamp",
+	"timestamptz",
+	"date",
+	"datetime"
+];
+function matchesType(type, list) {
+	if (!type) return false;
+	const normalized = type.toLowerCase();
+	return list.some((t) => normalized.startsWith(t));
+}
+function isTextLike(type) {
+	return matchesType(type, TEXT_TYPES);
+}
+function isNumericLike(type) {
+	return matchesType(type, NUMERIC_TYPES);
+}
+function isTimestampLike(type) {
+	return matchesType(type, TIMESTAMP_TYPES);
+}
+/**
+* True when the top two candidates are too close to call. Callers must never
+* one-click apply an ambiguous result — the user picks.
+*/
+function isAmbiguous(ranked) {
+	const [first, second] = ranked;
+	if (!(first && second)) return false;
+	return first.score - second.score < 15;
+}
+//#endregion
+export { W as a, isTextLike as c, RELATIONSHIP_TIERS as i, isTimestampLike as l, CONCEPT_TIERS as n, isAmbiguous as o, FIELD_TIERS as r, isNumericLike as s, AMBIGUITY_MARGIN as t, tierFor as u };

package/mapping-score-BcjC0ZQs.d.cts

@@ -0,0 +1,49 @@
+//#region ../core/src/mapping-score.d.ts
+type Tier = "High" | "Medium" | "Low";
+interface Scored<T> {
+  /** Human-readable chips, e.g. `type text`, `name matches "contacts"`. */
+  reasons: string[];
+  /** Internal — used for ranking and the apply threshold. Never rendered. */
+  score: number;
+  tier: Tier;
+  value: T;
+}
+/** Tier cut-offs: score >= high → High; >= medium → Medium; else Low. */
+interface Thresholds {
+  high: number;
+  medium: number;
+}
+declare const CONCEPT_TIERS: Thresholds;
+declare const FIELD_TIERS: Thresholds;
+declare const RELATIONSHIP_TIERS: Thresholds;
+/** Two concept candidates closer than this are treated as ambiguous. */
+declare const AMBIGUITY_MARGIN = 15;
+/** Signal weights. Tuned against fixtures; adjust here, not at call sites. */
+declare const W: {
+  readonly nameExact: 50;
+  readonly nameSubstring: 25;
+  readonly definingColumn: 20;
+  readonly hasPrimaryKey: 10;
+  readonly hasRows: 10;
+  readonly emptyTable: -20;
+  readonly fieldNameMatch: 50;
+  readonly typeCompatible: 30;
+  readonly typeMismatch: -30;
+  readonly requiredNotNull: 10;
+  readonly fkResolved: 60;
+  readonly fkNameHint: 30;
+  readonly joinTable: 20;
+};
+declare function tierFor(score: number, t: Thresholds): Tier;
+declare function isTextLike(type: string | undefined): boolean;
+declare function isNumericLike(type: string | undefined): boolean;
+declare function isTimestampLike(type: string | undefined): boolean;
+/**
+ * True when the top two candidates are too close to call. Callers must never
+ * one-click apply an ambiguous result — the user picks.
+ */
+declare function isAmbiguous(ranked: Array<{
+  score: number;
+}>): boolean;
+//#endregion
+export { Scored as a, W as c, isTextLike as d, isTimestampLike as f, RELATIONSHIP_TIERS as i, isAmbiguous as l, CONCEPT_TIERS as n, Thresholds as o, tierFor as p, FIELD_TIERS as r, Tier as s, AMBIGUITY_MARGIN as t, isNumericLike as u };

package/mapping-score-D9gfhtRu.cjs

@@ -0,0 +1,146 @@
+//#region ../core/src/mapping-score.ts
+const CONCEPT_TIERS = {
+	high: 70,
+	medium: 40
+};
+const FIELD_TIERS = {
+	high: 70,
+	medium: 40
+};
+const RELATIONSHIP_TIERS = {
+	high: 60,
+	medium: 30
+};
+/** Two concept candidates closer than this are treated as ambiguous. */
+const AMBIGUITY_MARGIN = 15;
+/** Signal weights. Tuned against fixtures; adjust here, not at call sites. */
+const W = {
+	nameExact: 50,
+	nameSubstring: 25,
+	definingColumn: 20,
+	hasPrimaryKey: 10,
+	hasRows: 10,
+	emptyTable: -20,
+	fieldNameMatch: 50,
+	typeCompatible: 30,
+	typeMismatch: -30,
+	requiredNotNull: 10,
+	fkResolved: 60,
+	fkNameHint: 30,
+	joinTable: 20
+};
+function tierFor(score, t) {
+	if (score >= t.high) return "High";
+	if (score >= t.medium) return "Medium";
+	return "Low";
+}
+const TEXT_TYPES = [
+	"text",
+	"varchar",
+	"char",
+	"citext",
+	"uuid",
+	"string"
+];
+const NUMERIC_TYPES = [
+	"numeric",
+	"decimal",
+	"int",
+	"integer",
+	"bigint",
+	"smallint",
+	"float",
+	"double",
+	"real",
+	"money"
+];
+const TIMESTAMP_TYPES = [
+	"timestamp",
+	"timestamptz",
+	"date",
+	"datetime"
+];
+function matchesType(type, list) {
+	if (!type) return false;
+	const normalized = type.toLowerCase();
+	return list.some((t) => normalized.startsWith(t));
+}
+function isTextLike(type) {
+	return matchesType(type, TEXT_TYPES);
+}
+function isNumericLike(type) {
+	return matchesType(type, NUMERIC_TYPES);
+}
+function isTimestampLike(type) {
+	return matchesType(type, TIMESTAMP_TYPES);
+}
+/**
+* True when the top two candidates are too close to call. Callers must never
+* one-click apply an ambiguous result — the user picks.
+*/
+function isAmbiguous(ranked) {
+	const [first, second] = ranked;
+	if (!(first && second)) return false;
+	return first.score - second.score < 15;
+}
+//#endregion
+Object.defineProperty(exports, "AMBIGUITY_MARGIN", {
+	enumerable: true,
+	get: function() {
+		return AMBIGUITY_MARGIN;
+	}
+});
+Object.defineProperty(exports, "CONCEPT_TIERS", {
+	enumerable: true,
+	get: function() {
+		return CONCEPT_TIERS;
+	}
+});
+Object.defineProperty(exports, "FIELD_TIERS", {
+	enumerable: true,
+	get: function() {
+		return FIELD_TIERS;
+	}
+});
+Object.defineProperty(exports, "RELATIONSHIP_TIERS", {
+	enumerable: true,
+	get: function() {
+		return RELATIONSHIP_TIERS;
+	}
+});
+Object.defineProperty(exports, "W", {
+	enumerable: true,
+	get: function() {
+		return W;
+	}
+});
+Object.defineProperty(exports, "isAmbiguous", {
+	enumerable: true,
+	get: function() {
+		return isAmbiguous;
+	}
+});
+Object.defineProperty(exports, "isNumericLike", {
+	enumerable: true,
+	get: function() {
+		return isNumericLike;
+	}
+});
+Object.defineProperty(exports, "isTextLike", {
+	enumerable: true,
+	get: function() {
+		return isTextLike;
+	}
+});
+Object.defineProperty(exports, "isTimestampLike", {
+	enumerable: true,
+	get: function() {
+		return isTimestampLike;
+	}
+});
+Object.defineProperty(exports, "tierFor", {
+	enumerable: true,
+	get: function() {
+		return tierFor;
+	}
+});

package/mappings-config-CYPrzB3K.mjs

@@ -0,0 +1,99 @@
+import { t as CANONICAL_FIELDS } from "./entity-config-DoR0khce.mjs";
+//#region ../core/src/mappings-config.ts
+const RESERVED_FIELD = "id";
+/**
+* Restrict a persisted field map to what the mirror can actually store: drop
+* the reserved `id` key (for every concept) and, for materialized concepts
+* (contact/company), any key that isn't canonical. This makes the pipeline
+* resilient to legacy or mis-suggested field maps — a stray `id` no longer
+* blocks the whole sync.
+*/
+function canonicalFields(concept, fieldMap) {
+	const allowed = CANONICAL_FIELDS[concept];
+	const result = {};
+	for (const [field, column] of Object.entries(fieldMap)) {
+		if (field === RESERVED_FIELD) continue;
+		if (allowed && !allowed.includes(field)) continue;
+		result[field] = column;
+	}
+	return result;
+}
+const DEFAULT_ROLE = "primary";
+const ACTIVE_STATUS = "active";
+function isEligible(row) {
+	return (row.status ?? ACTIVE_STATUS) === ACTIVE_STATUS && Object.keys(row.fieldMap ?? {}).length > 0;
+}
+/**
+* Preferred key for a row: the bare source table when it backs a single entity,
+* else role-suffixed so multiple roles on one table stay distinct and stable
+* (the primary role keeps the bare name). Uniqueness is still enforced by the
+* caller in case two rows land on the same preferred key.
+*/
+function preferredKey(row, tableCounts) {
+	const role = row.role ?? DEFAULT_ROLE;
+	if ((tableCounts.get(row.sourceTable) ?? 0) <= 1) return row.sourceTable;
+	return role === DEFAULT_ROLE ? row.sourceTable : `${row.sourceTable}__${role}`;
+}
+function uniquify(base, used) {
+	if (!used.has(base)) {
+		used.add(base);
+		return base;
+	}
+	let suffix = 2;
+	while (used.has(`${base}__${suffix}`)) suffix++;
+	const key = `${base}__${suffix}`;
+	used.add(key);
+	return key;
+}
+function buildEntity(row, refIndex) {
+	const entity = {
+		concept: row.targetConcept,
+		source: row.sourceTable,
+		role: row.role ?? DEFAULT_ROLE,
+		fields: canonicalFields(row.targetConcept, row.fieldMap)
+	};
+	if (row.targetConcept === "custom" && row.targetObjectTypeId) entity.targetObjectTypeId = row.targetObjectTypeId;
+	if (row.filter && Object.keys(row.filter).length > 0) entity.filter = row.filter;
+	if (row.relationships && Object.keys(row.relationships).length > 0) {
+		const relationships = {};
+		for (const [name, spec] of Object.entries(row.relationships)) {
+			const rel = spec;
+			relationships[name] = {
+				entity: refIndex.get(rel.entity) ?? rel.entity,
+				via: rel.via
+			};
+		}
+		entity.relationships = relationships;
+	}
+	return entity;
+}
+/**
+* Compile persisted mapping rows into a `ClivlyEntitiesConfig`. Only `active`
+* rows with at least one mapped field are included; disabled/suggested rows and
+* unmapped rows are skipped. Returns `{ entities: {} }` when nothing is
+* eligible — a no-op the view compiler and sync engine both tolerate.
+*/
+function mappingsToEntitiesConfig(rows) {
+	const eligible = rows.filter(isEligible);
+	const tableCounts = /* @__PURE__ */ new Map();
+	for (const row of eligible) tableCounts.set(row.sourceTable, (tableCounts.get(row.sourceTable) ?? 0) + 1);
+	const used = /* @__PURE__ */ new Set();
+	const tableAnchor = /* @__PURE__ */ new Map();
+	const assigned = [];
+	for (const row of eligible) {
+		const key = uniquify(preferredKey(row, tableCounts), used);
+		assigned.push({
+			row,
+			key
+		});
+		if ((row.role ?? DEFAULT_ROLE) === DEFAULT_ROLE || !tableAnchor.has(row.sourceTable)) tableAnchor.set(row.sourceTable, key);
+	}
+	const refIndex = /* @__PURE__ */ new Map();
+	for (const { key } of assigned) refIndex.set(key, key);
+	for (const [table, key] of tableAnchor) if (!refIndex.has(table)) refIndex.set(table, key);
+	const entities = {};
+	for (const { row, key } of assigned) entities[key] = buildEntity(row, refIndex);
+	return { entities };
+}
+//#endregion
+export { mappingsToEntitiesConfig as t };