@clivly/core 0.9.7 → 0.10.0

package/dist/entity-heuristics.mjs

@@ -1,4 +1,4 @@
-import { a as MATERIALIZING_CONCEPTS } from "./entity-config-DwGXbUo_.mjs";
+import { a as MATERIALIZING_CONCEPTS } from "./entity-config-DpHPMFIS.mjs";
 import { CONCEPT_TIERS, FIELD_TIERS, RELATIONSHIP_TIERS, W, isAmbiguous, isNumericLike, isTextLike, isTimestampLike, tierFor } from "./mapping-score.mjs";
 //#region src/entity-heuristics.ts
 const TARGET_CONCEPTS = [
@@ -250,6 +250,38 @@ function matchesConcept(tableName, concept) {
 	if (entry.names.some((name) => candidates.some((candidate) => candidate.includes(name)))) return { exact: false };
 	return null;
 }
+const SENSITIVE_COLUMNS = /* @__PURE__ */ new Set([
+	"password",
+	"password_hash",
+	"passwordhash",
+	"access_token",
+	"accesstoken",
+	"api_key",
+	"apikey",
+	"client_secret",
+	"clientsecret",
+	"encrypted_password",
+	"encryptedpassword",
+	"refresh_token",
+	"refreshtoken",
+	"id_token",
+	"idtoken",
+	"password_digest",
+	"passworddigest",
+	"private_key",
+	"privatekey",
+	"secret",
+	"session_token",
+	"sessiontoken"
+]);
+/**
+* Does this table carry credentials? Such tables are withheld from suggestions
+* and from bulk apply, so one click can never map an auth table into the CRM.
+* They stay manually selectable — an explicit, informed choice is legitimate.
+*/
+function hasSensitiveColumns(columns) {
+	return columns.some((column) => SENSITIVE_COLUMNS.has(column.toLowerCase().replaceAll("-", "_")));
+}
 function metaFor(table, column) {
 	return table.columnsMeta?.find((c) => c.name === column);
 }
@@ -461,4 +493,4 @@ function toFieldMap(scored) {
 	return map;
 }
 //#endregion
-export { TARGET_CONCEPTS, matchesConcept, requiredFieldsFor, scoreConcepts, scoreFieldMap, scoreRelationships, suggestCursorField, suggestDiscriminatorColumns, toFieldMap, topConcept, validateMapping };
+export { TARGET_CONCEPTS, hasSensitiveColumns, matchesConcept, requiredFieldsFor, scoreConcepts, scoreFieldMap, scoreRelationships, suggestCursorField, suggestDiscriminatorColumns, toFieldMap, topConcept, validateMapping };

package/dist/index.cjs

@@ -1,218 +1,154 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_auth_adapter = require("./auth-adapter.cjs");
-const require_projection = require("./projection-OJYCYmS_.cjs");
-const require_entity_config = require("./entity-config-25v_udeY.cjs");
+const require_projection = require("./projection-DFgCoyZl.cjs");
+const require_schema_meta = require("./schema-meta-Cgi0MnHh.cjs");
+const require_entity_config = require("./entity-config-C5jBmG2C.cjs");
 const require_mapping_form = require("./mapping-form.cjs");
 const require_mappings_config = require("./mappings-config.cjs");
-const require_view_compiler = require("./view-compiler-D30HNRnA.cjs");
+const require_view_compiler = require("./view-compiler-DP4Fbj7-.cjs");
 const require_sync_engine = require("./sync-engine.cjs");
-//#region src/projection-draft.ts
-function emptyProjectionDraft(baseTable) {
-	return {
-		baseTable,
-		entityKey: "",
-		fieldBindings: {},
-		identity: { kind: "base_pk" },
-		joins: []
-	};
-}
+const require_types = require("./types.cjs");
+//#region src/slug.ts
 /**
-* 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.
+* The one `slugify`.
+*
+* Three byte-identical copies existed before this module — in `@clivly/api`
+* (the custom object-type slug), in `apps/web`'s onboarding route (the
+* organisation slug), and in `@clivly/sdk`. The first two now import this; the
+* SDK's copy stays where it is on purpose, because `@clivly/sdk` cannot depend
+* on this package and its own comment records that its pattern is deliberately
+* kept in step with the server's by hand.
+*
+* Note that the two callers this replaces slug *different things* — an
+* object type and an organisation. They share a transform, not a namespace.
+* Sharing the function stops the transform drifting; it does not make those two
+* identifiers the same identifier.
 */
-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;
-}
+const NON_ALNUM = /[^a-z0-9]+/g;
+const EDGE_HYPHENS = /(^-|-$)/g;
 /**
-* Add a join on `joinTable`, keyed and pre-filled.
+* Lowercase, trim, collapse every run of non-alphanumerics to one hyphen, and
+* drop leading/trailing hyphens. `"Participant Info"` becomes
+* `"participant-info"`.
 *
-* 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.
+* The result is NOT guaranteed to be an acceptable slug. Both
+* `OBJECT_TYPE_SLUG_PATTERN` (server) and `PROJECTION_KEY_PATTERN` (this
+* package) require a leading letter, and this function happily returns
+* `"2024-invoices"` for `"2024 Invoices"`. Callers that need an
+* acceptance-guaranteed identifier want `toObjectTypeSlug`.
 */
-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)
-		}]
-	};
+function slugify(value) {
+	return value.toLowerCase().trim().replace(NON_ALNUM, "-").replace(EDGE_HYPHENS, "");
 }
 /**
-* Remove a join, and everything that addressed it.
+* Prefixed onto a slug that would otherwise not start with a letter.
 *
-* 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.
+* Chosen over trimming the offending characters because dropping them loses
+* information the user typed: `"2024 Invoices"` would become `"invoices"`,
+* which collides with a genuinely different object of that name.
 */
-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
-	};
-}
+const LEADING_DIGIT_PREFIX = "obj-";
+/** Mirrors `PROJECTION_KEY_PATTERN` / the server's `OBJECT_TYPE_SLUG_PATTERN`. */
+const MUST_START_WITH_LETTER = /^[a-z]/;
 /**
-* Every table a field or identity may currently read from, in ref order: the
-* base table first, then each join.
+* A slug the server will accept, derived from a display name.
 *
-* 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.
+* `slugify` alone is not enough: the server's `OBJECT_TYPE_SLUG_PATTERN`
+* (`apps/server/src/index.ts`) demands a leading letter, so a name beginning
+* with a digit slugs to something the platform rejects at push time — long
+* after the object was authored. `@clivly/sdk`'s `custom-slug.ts` already knows
+* this case and deliberately withholds `"2024-invoices"` as a suggestion
+* because it would be rejected too.
+*
+* The prefix is applied ONLY when the derived slug does not already start with
+* a letter, so the overwhelmingly common name is untouched.
+*
+* This value must be shown to whoever authored the name. It is the identifier
+* the host app declares as its `objectType`, so a slug derived silently is a
+* slug the developer cannot copy into their config.
+*
+* Returns an empty string for a name with no alphanumerics at all — the caller
+* decides whether that is "keep typing" or an error, since only it knows
+* whether the field is still being edited.
 */
-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;
+function toObjectTypeSlug(displayName) {
+	const slug = slugify(displayName);
+	if (slug === "") return "";
+	return MUST_START_WITH_LETTER.test(slug) ? slug : `${LEADING_DIGIT_PREFIX}${slug}`;
+}
+//#endregion
+//#region src/stage-rules.ts
+const CONDITION_OPS = /* @__PURE__ */ new Set([
+	"is_empty",
+	"is_not_empty",
+	"equals",
+	"not_equals",
+	"greater_than",
+	"less_than",
+	"before",
+	"after"
+]);
+function isCondition(value) {
+	if (!value || typeof value !== "object") return false;
+	const condition = value;
+	return typeof condition.field === "string" && condition.field.length > 0 && typeof condition.op === "string" && CONDITION_OPS.has(condition.op) && (condition.value === void 0 || typeof condition.value === "string");
 }
-/** 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
-	};
+/** Host fields arrive as strings; null and "" are both absent. */
+function isEmpty(value) {
+	return value === null || value === void 0 || value === "";
 }
-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
-	};
+function compareNumbers(raw, operand, op) {
+	const left = Number(raw);
+	const right = Number(operand);
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return op === "greater_than" ? left > right : left < right;
 }
-/**
-* `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
-	}));
+function compareDates(raw, operand, op) {
+	const left = new Date(raw).getTime();
+	const right = new Date(operand ?? "").getTime();
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return op === "before" ? left < right : left > right;
 }
 /**
-* Every reason this draft cannot be saved, one per cause and each anchored to
-* the section that owns it.
+* Whether one condition holds for a host row.
 *
-* 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.
+* `mappedFields` is the set of columns the organization actually exposed. A
+* condition naming anything outside it never matches, whatever the operator: a
+* rule referencing a dropped column must fail safe, because treating the field
+* as null would make `is_empty` match every deal.
 */
-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;
+function matchesCondition(condition, fields, mappedFields) {
+	if (!mappedFields.has(condition.field)) return false;
+	const raw = fields[condition.field] ?? null;
+	if (condition.op === "is_empty") return isEmpty(raw);
+	if (condition.op === "is_not_empty") return !isEmpty(raw);
+	if (isEmpty(raw)) return false;
+	const value = raw;
+	if (condition.op === "equals") return value === condition.value;
+	if (condition.op === "not_equals") return value !== condition.value;
+	if (condition.op === "greater_than" || condition.op === "less_than") return compareNumbers(value, condition.value, condition.op);
+	return compareDates(value, condition.value, condition.op);
 }
 /**
-* Per-join fan-out, for the builder's inline cardinality hints.
+* The id of the first rule whose conditions all hold, or null when none do.
+*
+* Returns a rule id rather than a stage key because the caller needs the
+* matched rule's `allowClose` before it may move a deal into a closed stage.
 *
-* 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.
+* `rules` must arrive already ordered — stage position first, then rule
+* position within a stage. Sorting needs stage rows this module deliberately
+* does not see.
+*
+* A rule with no conditions never matches: an empty list would otherwise
+* vacuously AND to true and capture every deal, which is the opposite of what
+* a half-written rule should do.
 */
-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)
-	}));
+function evaluateStage(rules, fields, mappedFields) {
+	for (const rule of rules) {
+		if (!Array.isArray(rule.conditions) || rule.conditions.length === 0 || !rule.conditions.every(isCondition)) continue;
+		if (rule.conditions.every((condition) => matchesCondition(condition, fields, mappedFields))) return rule.id;
+	}
+	return null;
 }
 //#endregion
 exports.BASE_REF = require_projection.BASE_REF;
@@ -221,12 +157,13 @@ exports.CRM_CONCEPTS = require_entity_config.CRM_CONCEPTS;
 exports.ClivlyConfigError = require_entity_config.ClivlyConfigError;
 exports.DEFAULT_VIEW_PREFIX = require_view_compiler.DEFAULT_VIEW_PREFIX;
 exports.MATERIALIZING_CONCEPTS = require_entity_config.MATERIALIZING_CONCEPTS;
+exports.OPEN_STAGE_TYPE = require_types.OPEN_STAGE_TYPE;
 exports.PREVIEW_MAX_ROWS = require_view_compiler.PREVIEW_MAX_ROWS;
-exports.addDraftJoin = addDraftJoin;
+exports.PROJECTION_KEY_PATTERN = require_projection.PROJECTION_KEY_PATTERN;
 exports.authCustom = require_auth_adapter.authCustom;
 exports.buildFilterFromDiscriminator = require_mapping_form.buildFilterFromDiscriminator;
 exports.buildRelationships = require_mapping_form.buildRelationships;
-exports.columnMetaFor = require_entity_config.columnMetaFor;
+exports.columnMetaFor = require_schema_meta.columnMetaFor;
 exports.compileEntityView = require_view_compiler.compileEntityView;
 exports.compileEntityViews = require_view_compiler.compileEntityViews;
 exports.compileProjectionFrom = require_view_compiler.compileProjectionFrom;
@@ -234,30 +171,30 @@ exports.compileProjectionIdentity = require_view_compiler.compileProjectionIdent
 exports.compileProjectionJoins = require_view_compiler.compileProjectionJoins;
 exports.compileProjectionPreview = require_view_compiler.compileProjectionPreview;
 exports.compileProjectionSelect = require_view_compiler.compileProjectionSelect;
-exports.coversUniqueKey = require_entity_config.coversUniqueKey;
+exports.coversUniqueKey = require_schema_meta.coversUniqueKey;
 exports.defineClivlyConfig = require_entity_config.defineClivlyConfig;
-exports.describeCardinality = describeCardinality;
-exports.draftErrors = draftErrors;
-exports.draftRefOptions = draftRefOptions;
-exports.draftToProjection = draftToProjection;
-exports.emptyProjectionDraft = emptyProjectionDraft;
 exports.entitiesConfigSchema = require_entity_config.entitiesConfigSchema;
+exports.evaluateStage = evaluateStage;
 exports.explainEntitiesConfig = require_view_compiler.explainEntitiesConfig;
 exports.fanOutJoins = require_entity_config.fanOutJoins;
 exports.filterSchema = require_entity_config.filterSchema;
-exports.hasRichMeta = require_entity_config.hasRichMeta;
+exports.hasRichMeta = require_schema_meta.hasRichMeta;
 exports.identityRefs = require_projection.identityRefs;
+exports.isClosedStageType = require_types.isClosedStageType;
 exports.joinFansOut = require_entity_config.joinFansOut;
 exports.mappingsToEntitiesConfig = require_mappings_config.mappingsToEntitiesConfig;
-exports.primaryKeyColumns = require_entity_config.primaryKeyColumns;
+exports.matchesCondition = matchesCondition;
+exports.primaryKeyColumns = require_schema_meta.primaryKeyColumns;
+exports.projectionFields = require_entity_config.projectionFields;
 exports.projectionSchema = require_projection.projectionSchema;
 exports.quoteIdent = require_view_compiler.quoteIdent;
 exports.reconcile = require_sync_engine.reconcile;
 exports.relationshipSchema = require_entity_config.relationshipSchema;
 exports.relationshipViaSignature = require_mapping_form.relationshipViaSignature;
 exports.relationshipsSchema = require_entity_config.relationshipsSchema;
-exports.removeDraftJoin = removeDraftJoin;
 exports.runSync = require_sync_engine.runSync;
-exports.suggestJoinConditions = suggestJoinConditions;
+exports.slugify = slugify;
+exports.toObjectTypeSlug = toObjectTypeSlug;
 exports.validateEntitiesConfig = require_entity_config.validateEntitiesConfig;
 exports.validateProjection = require_entity_config.validateProjection;
+exports.validateProjectionFilter = require_entity_config.validateProjectionFilter;