clivly 0.9.6 → 0.10.0

package/types-Cq5gHCTq.cjs

@@ -0,0 +1,20 @@
+//#region ../core/src/types.ts
+/** Named once so SQL predicates and UI fallbacks cannot drift apart. */
+const OPEN_STAGE_TYPE = "open";
+/** A closed deal is a historical fact: automation never reopens one. */
+function isClosedStageType(type) {
+	return type === "won" || type === "lost";
+}
+//#endregion
+Object.defineProperty(exports, "OPEN_STAGE_TYPE", {
+	enumerable: true,
+	get: function() {
+		return OPEN_STAGE_TYPE;
+	}
+});
+Object.defineProperty(exports, "isClosedStageType", {
+	enumerable: true,
+	get: function() {
+		return isClosedStageType;
+	}
+});

package/types-YJTkXKzU.mjs

@@ -0,0 +1,9 @@
+//#region ../core/src/types.ts
+/** Named once so SQL predicates and UI fallbacks cannot drift apart. */
+const OPEN_STAGE_TYPE = "open";
+/** A closed deal is a historical fact: automation never reopens one. */
+function isClosedStageType(type) {
+	return type === "won" || type === "lost";
+}
+//#endregion
+export { isClosedStageType as n, OPEN_STAGE_TYPE as t };

package/{view-compiler-D_6gfXFr.mjs → view-compiler-BzKk8nY3.mjs}

@@ -1,5 +1,5 @@
-import { t as BASE_REF } from "./projection-hnPSgH6G.mjs";
-import { i as compileProjectionJoins, n as compileProjectionFrom, o as compileProjectionSelect, s as quoteIdent } from "./projection-sql-9zzTVGvf.mjs";
+import { t as BASE_REF } from "./projection-CSGJbZlZ.mjs";
+import { i as compileProjectionJoins, n as compileProjectionFrom, o as compileProjectionSelect, s as quoteIdent } from "./projection-sql-iHoiYr1R.mjs";
 //#region ../core/src/view-compiler.ts
 /**
 * View compiler (Phase 2) — turns a validated entity config into read-only

package/{view-compiler-CmEdAMwj.d.cts → view-compiler-D3zp9S3K.d.cts}

@@ -1,4 +1,4 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-B2RA53nw.cjs";
+import { a as ClivlyEntitiesConfig } from "./entity-config-DNQAMbMS.cjs";
 //#region ../core/src/view-compiler.d.ts
 declare const DEFAULT_VIEW_PREFIX = "crm_src_";
 interface CompileOptions {

package/{view-compiler-Bo7pqXW3.d.mts → view-compiler-TpzDTu7z.d.mts}

@@ -1,4 +1,4 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-B2RA53nw.mjs";
+import { a as ClivlyEntitiesConfig } from "./entity-config-DNQAMbMS.mjs";
 //#region ../core/src/view-compiler.d.ts
 declare const DEFAULT_VIEW_PREFIX = "crm_src_";
 interface CompileOptions {

package/{view-compiler-BHI5E4QI.cjs → view-compiler-ZKZbd3SK.cjs}

@@ -1,5 +1,5 @@
-const require_projection = require("./projection-DEwL-D8R.cjs");
-const require_projection_sql = require("./projection-sql-iHy-Cx6V.cjs");
+const require_projection = require("./projection-Dz6_i1-w.cjs");
+const require_projection_sql = require("./projection-sql-CbXCKt3s.cjs");
 //#region ../core/src/view-compiler.ts
 /**
 * View compiler (Phase 2) — turns a validated entity config into read-only

package/vite.d.cts

@@ -1,4 +1,4 @@
-import { o as ClivlySDK } from "./namespace-probe-DaTJINS-.cjs";
+import { o as ClivlySDK } from "./namespace-probe-DC4tbmLj.cjs";
 import { Plugin } from "vite";
 //#region ../sdk/src/vite.d.ts
 interface ClivlyViteOptions {

package/vite.d.mts

@@ -1,4 +1,4 @@
-import { o as ClivlySDK } from "./namespace-probe-Ckn9yJ6F.mjs";
+import { o as ClivlySDK } from "./namespace-probe-9ScMDR0t.mjs";
 import { Plugin } from "vite";
 //#region ../sdk/src/vite.d.ts
 interface ClivlyViteOptions {

package/internal-BQ47iN6f.cjs

@@ -1,259 +0,0 @@
-const require_projection = require("./projection-DEwL-D8R.cjs");
-const require_entity_config = require("./entity-config-DE30_RpU.cjs");
-//#region ../core/src/projection-draft.ts
-function emptyProjectionDraft(baseTable) {
-	return {
-		baseTable,
-		entityKey: "",
-		fieldBindings: {},
-		identity: { kind: "base_pk" },
-		joins: []
-	};
-}
-/**
-* The ON conditions implied by a foreign key between the two tables, so the
-* builder can pre-fill a join instead of making the user hand-pick columns.
-* Returns [] when no FK relates them — the user then picks manually.
-*/
-function suggestJoinConditions(baseTable, joinTable, schema, joinKey) {
-	const join = schema.find((t) => t.name === joinTable);
-	const conditions = [];
-	for (const column of join?.columnsMeta ?? []) if (column.references?.table === baseTable) conditions.push({
-		left: {
-			table: joinKey,
-			column: column.name
-		},
-		op: "eq",
-		right: {
-			table: require_projection.BASE_REF,
-			column: column.references.column
-		}
-	});
-	return conditions;
-}
-/**
-* Add a join on `joinTable`, keyed and pre-filled.
-*
-* The key is the table's own name where that is free, because it is what the
-* user already calls the table; a collision falls back to `_2`, `_3` and so on.
-* Uniqueness is not cosmetic — the key is the SQL alias and the name every ref
-* addresses the table by, so two joins sharing one would make every ref
-* ambiguous. `base` is reserved for the base table and can never be taken.
-*/
-function addDraftJoin(draft, joinTable, schema) {
-	const taken = /* @__PURE__ */ new Set([require_projection.BASE_REF, ...draft.joins.map((j) => j.key)]);
-	let key = joinTable;
-	let suffix = 2;
-	while (taken.has(key)) {
-		key = `${joinTable}_${suffix}`;
-		suffix += 1;
-	}
-	return {
-		...draft,
-		joins: [...draft.joins, {
-			key,
-			table: joinTable,
-			type: "left",
-			on: suggestJoinConditions(draft.baseTable, joinTable, schema, key)
-		}]
-	};
-}
-/**
-* Remove a join, and everything that addressed it.
-*
-* Refs to a removed join are refs to a table the projection no longer declares.
-* Left in place they fail validation as "unknown ref table", which blames the
-* field — or, worse, the identity — for the join's removal. Identity falls back
-* to the base primary key, the same default a new draft starts from.
-*/
-function removeDraftJoin(draft, joinKey) {
-	const fieldBindings = Object.fromEntries(Object.entries(draft.fieldBindings).filter(([, binding]) => binding.from.table !== joinKey));
-	const identityDependsOnJoin = require_projection.identityRefs(draft.identity, "").some((ref) => ref.table === joinKey);
-	return {
-		...draft,
-		joins: draft.joins.filter((join) => join.key !== joinKey),
-		fieldBindings,
-		identity: identityDependsOnJoin ? { kind: "base_pk" } : draft.identity
-	};
-}
-/**
-* Every table a field or identity may currently read from, in ref order: the
-* base table first, then each join.
-*
-* Returns [] when the base table is not in the discovered schema — there is
-* nothing truthful to offer, and inventing columns would let someone build a
-* projection that cannot compile.
-*/
-function draftRefOptions(draft, schema) {
-	const byName = new Map(schema.map((table) => [table.name, table]));
-	const base = byName.get(draft.baseTable);
-	if (!base) return [];
-	const options = [{
-		ref: require_projection.BASE_REF,
-		label: `${base.name} (${require_projection.BASE_REF})`,
-		columns: base.columns
-	}];
-	for (const join of draft.joins) {
-		const table = byName.get(join.table);
-		if (table) options.push({
-			ref: join.key,
-			label: `${table.name} (${join.key})`,
-			columns: table.columns
-		});
-	}
-	return options;
-}
-/** A draft becomes a projection once it has a valid key and ≥1 binding. */
-function draftToProjection(draft) {
-	if (!require_projection.PROJECTION_KEY_PATTERN.test(draft.entityKey)) return null;
-	if (Object.keys(draft.fieldBindings).length === 0) return null;
-	return {
-		version: 1,
-		kind: "projection",
-		entityKey: draft.entityKey,
-		baseTable: draft.baseTable,
-		joins: draft.joins,
-		fieldBindings: draft.fieldBindings,
-		identity: draft.identity
-	};
-}
-const PROBE_KEY = "draft";
-/**
-* A draft rendered as a projection so the semantic checks can run against it
-* while it is being written, not only once it is finished.
-*
-* `entityKey` is stood in for rather than taken from the draft: it is the one
-* field `validateProjection` never looks at, and a half-typed key would
-* otherwise have to be valid before any join or identity could be checked. The
-* missing or malformed key is reported separately, by `draftErrors`.
-*/
-function probeProjection(draft) {
-	return {
-		version: 1,
-		kind: "projection",
-		entityKey: PROBE_KEY,
-		baseTable: draft.baseTable,
-		joins: draft.joins,
-		fieldBindings: draft.fieldBindings,
-		identity: draft.identity
-	};
-}
-/**
-* `validateProjection` appends its own `projection.` segment to the base path it
-* is given, because in a config the base is the entity that owns the projection
-* (`entities.accounts` → `entities.accounts.projection.identity`). A draft has
-* no owning entity, so passing "projection" as the base produced
-* `projection.projection.identity` — a path no caller could match against, and
-* the reason `draftErrors` was only ever consumed as a flat list of messages.
-*
-* Passing an empty base and dropping the leading separator leaves one
-* convention: every path here starts `projection.` exactly once, whether it came
-* from this module or from the validator.
-*/
-function semanticErrors(draft, schema) {
-	return require_entity_config.validateProjection(probeProjection(draft), schema, "").map((error) => ({
-		...error,
-		path: error.path.startsWith(".") ? error.path.slice(1) : error.path
-	}));
-}
-/**
-* Every reason this draft cannot be saved, one per cause and each anchored to
-* the section that owns it.
-*
-* One lumped "Name the object and map a field." was all this used to return for
-* an incomplete draft, at the bare path "projection". Two consequences, both
-* bad: a builder had nowhere to attach the message, and — because it returned
-* before validating — a fanning join under a `base_pk` identity stayed silent
-* until the draft was otherwise complete, which is well after the point where
-* the user chose the join.
-*/
-function draftErrors(draft, schema) {
-	const errors = [];
-	if (draft.entityKey === "") errors.push({
-		path: "projection.entityKey",
-		message: "Key is required."
-	});
-	else if (!require_projection.PROJECTION_KEY_PATTERN.test(draft.entityKey)) errors.push({
-		path: "projection.entityKey",
-		message: `Key ${require_projection.PROJECTION_KEY_MESSAGE}.`
-	});
-	if (Object.keys(draft.fieldBindings).length === 0) errors.push({
-		path: "projection.fieldBindings",
-		message: "Map at least one field."
-	});
-	if (draft.baseTable === "") {
-		errors.push({
-			path: "projection.baseTable",
-			message: "Pick a base table."
-		});
-		return errors;
-	}
-	errors.push(...semanticErrors(draft, schema));
-	return errors;
-}
-/**
-* Per-join fan-out, for the builder's inline cardinality hints.
-*
-* Answered from the joins alone. Joins are chosen before the key and the fields
-* are filled in, and a fan-out warning is precisely what should steer the
-* identity choice while it is being made — requiring a complete draft put the
-* hint after the decision it exists to inform.
-*/
-function describeCardinality(draft, schema) {
-	const projection = probeProjection(draft);
-	const tablesByName = new Map(schema.map((t) => [t.name, t]));
-	const fanning = new Set(require_entity_config.fanOutJoins(projection, tablesByName).map((j) => j.key));
-	return projection.joins.map((join) => ({
-		joinKey: join.key,
-		fansOut: fanning.has(join.key)
-	}));
-}
-//#endregion
-Object.defineProperty(exports, "addDraftJoin", {
-	enumerable: true,
-	get: function() {
-		return addDraftJoin;
-	}
-});
-Object.defineProperty(exports, "describeCardinality", {
-	enumerable: true,
-	get: function() {
-		return describeCardinality;
-	}
-});
-Object.defineProperty(exports, "draftErrors", {
-	enumerable: true,
-	get: function() {
-		return draftErrors;
-	}
-});
-Object.defineProperty(exports, "draftRefOptions", {
-	enumerable: true,
-	get: function() {
-		return draftRefOptions;
-	}
-});
-Object.defineProperty(exports, "draftToProjection", {
-	enumerable: true,
-	get: function() {
-		return draftToProjection;
-	}
-});
-Object.defineProperty(exports, "emptyProjectionDraft", {
-	enumerable: true,
-	get: function() {
-		return emptyProjectionDraft;
-	}
-});
-Object.defineProperty(exports, "removeDraftJoin", {
-	enumerable: true,
-	get: function() {
-		return removeDraftJoin;
-	}
-});
-Object.defineProperty(exports, "suggestJoinConditions", {
-	enumerable: true,
-	get: function() {
-		return suggestJoinConditions;
-	}
-});

package/internal-ChufvXE6.mjs

@@ -1,212 +0,0 @@
-import { i as identityRefs, n as PROJECTION_KEY_MESSAGE, r as PROJECTION_KEY_PATTERN, t as BASE_REF } from "./projection-hnPSgH6G.mjs";
-import { h as fanOutJoins, m as validateProjection } from "./entity-config-CusbTOJ1.mjs";
-//#region ../core/src/projection-draft.ts
-function emptyProjectionDraft(baseTable) {
-	return {
-		baseTable,
-		entityKey: "",
-		fieldBindings: {},
-		identity: { kind: "base_pk" },
-		joins: []
-	};
-}
-/**
-* The ON conditions implied by a foreign key between the two tables, so the
-* builder can pre-fill a join instead of making the user hand-pick columns.
-* Returns [] when no FK relates them — the user then picks manually.
-*/
-function suggestJoinConditions(baseTable, joinTable, schema, joinKey) {
-	const join = schema.find((t) => t.name === joinTable);
-	const conditions = [];
-	for (const column of join?.columnsMeta ?? []) if (column.references?.table === baseTable) conditions.push({
-		left: {
-			table: joinKey,
-			column: column.name
-		},
-		op: "eq",
-		right: {
-			table: BASE_REF,
-			column: column.references.column
-		}
-	});
-	return conditions;
-}
-/**
-* Add a join on `joinTable`, keyed and pre-filled.
-*
-* The key is the table's own name where that is free, because it is what the
-* user already calls the table; a collision falls back to `_2`, `_3` and so on.
-* Uniqueness is not cosmetic — the key is the SQL alias and the name every ref
-* addresses the table by, so two joins sharing one would make every ref
-* ambiguous. `base` is reserved for the base table and can never be taken.
-*/
-function addDraftJoin(draft, joinTable, schema) {
-	const taken = /* @__PURE__ */ new Set([BASE_REF, ...draft.joins.map((j) => j.key)]);
-	let key = joinTable;
-	let suffix = 2;
-	while (taken.has(key)) {
-		key = `${joinTable}_${suffix}`;
-		suffix += 1;
-	}
-	return {
-		...draft,
-		joins: [...draft.joins, {
-			key,
-			table: joinTable,
-			type: "left",
-			on: suggestJoinConditions(draft.baseTable, joinTable, schema, key)
-		}]
-	};
-}
-/**
-* Remove a join, and everything that addressed it.
-*
-* Refs to a removed join are refs to a table the projection no longer declares.
-* Left in place they fail validation as "unknown ref table", which blames the
-* field — or, worse, the identity — for the join's removal. Identity falls back
-* to the base primary key, the same default a new draft starts from.
-*/
-function removeDraftJoin(draft, joinKey) {
-	const fieldBindings = Object.fromEntries(Object.entries(draft.fieldBindings).filter(([, binding]) => binding.from.table !== joinKey));
-	const identityDependsOnJoin = identityRefs(draft.identity, "").some((ref) => ref.table === joinKey);
-	return {
-		...draft,
-		joins: draft.joins.filter((join) => join.key !== joinKey),
-		fieldBindings,
-		identity: identityDependsOnJoin ? { kind: "base_pk" } : draft.identity
-	};
-}
-/**
-* Every table a field or identity may currently read from, in ref order: the
-* base table first, then each join.
-*
-* Returns [] when the base table is not in the discovered schema — there is
-* nothing truthful to offer, and inventing columns would let someone build a
-* projection that cannot compile.
-*/
-function draftRefOptions(draft, schema) {
-	const byName = new Map(schema.map((table) => [table.name, table]));
-	const base = byName.get(draft.baseTable);
-	if (!base) return [];
-	const options = [{
-		ref: BASE_REF,
-		label: `${base.name} (${BASE_REF})`,
-		columns: base.columns
-	}];
-	for (const join of draft.joins) {
-		const table = byName.get(join.table);
-		if (table) options.push({
-			ref: join.key,
-			label: `${table.name} (${join.key})`,
-			columns: table.columns
-		});
-	}
-	return options;
-}
-/** A draft becomes a projection once it has a valid key and ≥1 binding. */
-function draftToProjection(draft) {
-	if (!PROJECTION_KEY_PATTERN.test(draft.entityKey)) return null;
-	if (Object.keys(draft.fieldBindings).length === 0) return null;
-	return {
-		version: 1,
-		kind: "projection",
-		entityKey: draft.entityKey,
-		baseTable: draft.baseTable,
-		joins: draft.joins,
-		fieldBindings: draft.fieldBindings,
-		identity: draft.identity
-	};
-}
-const PROBE_KEY = "draft";
-/**
-* A draft rendered as a projection so the semantic checks can run against it
-* while it is being written, not only once it is finished.
-*
-* `entityKey` is stood in for rather than taken from the draft: it is the one
-* field `validateProjection` never looks at, and a half-typed key would
-* otherwise have to be valid before any join or identity could be checked. The
-* missing or malformed key is reported separately, by `draftErrors`.
-*/
-function probeProjection(draft) {
-	return {
-		version: 1,
-		kind: "projection",
-		entityKey: PROBE_KEY,
-		baseTable: draft.baseTable,
-		joins: draft.joins,
-		fieldBindings: draft.fieldBindings,
-		identity: draft.identity
-	};
-}
-/**
-* `validateProjection` appends its own `projection.` segment to the base path it
-* is given, because in a config the base is the entity that owns the projection
-* (`entities.accounts` → `entities.accounts.projection.identity`). A draft has
-* no owning entity, so passing "projection" as the base produced
-* `projection.projection.identity` — a path no caller could match against, and
-* the reason `draftErrors` was only ever consumed as a flat list of messages.
-*
-* Passing an empty base and dropping the leading separator leaves one
-* convention: every path here starts `projection.` exactly once, whether it came
-* from this module or from the validator.
-*/
-function semanticErrors(draft, schema) {
-	return validateProjection(probeProjection(draft), schema, "").map((error) => ({
-		...error,
-		path: error.path.startsWith(".") ? error.path.slice(1) : error.path
-	}));
-}
-/**
-* Every reason this draft cannot be saved, one per cause and each anchored to
-* the section that owns it.
-*
-* One lumped "Name the object and map a field." was all this used to return for
-* an incomplete draft, at the bare path "projection". Two consequences, both
-* bad: a builder had nowhere to attach the message, and — because it returned
-* before validating — a fanning join under a `base_pk` identity stayed silent
-* until the draft was otherwise complete, which is well after the point where
-* the user chose the join.
-*/
-function draftErrors(draft, schema) {
-	const errors = [];
-	if (draft.entityKey === "") errors.push({
-		path: "projection.entityKey",
-		message: "Key is required."
-	});
-	else if (!PROJECTION_KEY_PATTERN.test(draft.entityKey)) errors.push({
-		path: "projection.entityKey",
-		message: `Key ${PROJECTION_KEY_MESSAGE}.`
-	});
-	if (Object.keys(draft.fieldBindings).length === 0) errors.push({
-		path: "projection.fieldBindings",
-		message: "Map at least one field."
-	});
-	if (draft.baseTable === "") {
-		errors.push({
-			path: "projection.baseTable",
-			message: "Pick a base table."
-		});
-		return errors;
-	}
-	errors.push(...semanticErrors(draft, schema));
-	return errors;
-}
-/**
-* Per-join fan-out, for the builder's inline cardinality hints.
-*
-* Answered from the joins alone. Joins are chosen before the key and the fields
-* are filled in, and a fan-out warning is precisely what should steer the
-* identity choice while it is being made — requiring a complete draft put the
-* hint after the decision it exists to inform.
-*/
-function describeCardinality(draft, schema) {
-	const projection = probeProjection(draft);
-	const tablesByName = new Map(schema.map((t) => [t.name, t]));
-	const fanning = new Set(fanOutJoins(projection, tablesByName).map((j) => j.key));
-	return projection.joins.map((join) => ({
-		joinKey: join.key,
-		fansOut: fanning.has(join.key)
-	}));
-}
-//#endregion
-export { draftToProjection as a, suggestJoinConditions as c, draftRefOptions as i, describeCardinality as n, emptyProjectionDraft as o, draftErrors as r, removeDraftJoin as s, addDraftJoin as t };