clivly 0.7.4 → 0.9.0

package/{view-compiler-ChWr_Lml.mjs → view-compiler-DlTpOfZi.mjs}

@@ -1,3 +1,58 @@
+import { r as identityRefs, t as BASE_REF } from "./projection-D7xmQP4S.mjs";
+//#region ../core/src/projection-sql.ts
+/**
+* SQL generation for projection-backed entities.
+*
+* Base and joins are aliased by their ref key (`base`, then each join's `key`),
+* which is what allows the same table to be joined twice and keeps generated
+* SQL independent of host table names.
+*
+* Pure string generation — no DB access. Identifiers are escaped so output is
+* deterministic and injection-safe.
+*/
+/** Quote a single identifier part, escaping embedded double-quotes. */
+function quoteIdent(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+function refSql(ref) {
+	return `${quoteIdent(ref.table)}.${quoteIdent(ref.column)}`;
+}
+/**
+* The identity expression, aliased as `id`. Composite identities concatenate
+* their parts with `::`; validation guarantees every part is NOT NULL and
+* non-text, which is what makes the concatenation collision-free.
+*/
+function identitySql(projection, basePkColumn) {
+	const refs = identityRefs(projection.identity, basePkColumn);
+	if (projection.identity.kind === "composite") return `CONCAT_WS('::', ${refs.map((ref) => `${refSql(ref)}::text`).join(", ")}) AS ${quoteIdent("id")}`;
+	const [ref] = refs;
+	if (!ref) throw new Error("projection identity resolved to no column");
+	return `${refSql(ref)} AS ${quoteIdent("id")}`;
+}
+function compileProjectionSelect(projection, basePkColumn) {
+	const selectItems = [identitySql(projection, basePkColumn)];
+	const columns = ["id"];
+	for (const [field, binding] of Object.entries(projection.fieldBindings)) {
+		selectItems.push(`${refSql(binding.from)} AS ${quoteIdent(field)}`);
+		columns.push(field);
+	}
+	return {
+		columns,
+		selectItems
+	};
+}
+function compileProjectionJoins(projection) {
+	return projection.joins.map((join) => {
+		const keyword = join.type === "inner" ? "INNER JOIN" : "LEFT JOIN";
+		const on = join.on.map((c) => `${refSql(c.left)} = ${refSql(c.right)}`).join(" AND ");
+		return `${keyword} ${quoteIdent(join.table)} AS ${quoteIdent(join.key)} ON ${on}`;
+	});
+}
+/** `FROM <baseTable> AS "base"` — the alias every ref resolves against. */
+function compileProjectionFrom(projection) {
+	return `FROM ${quoteIdent(projection.baseTable)} AS ${quoteIdent(BASE_REF)}`;
+}
+//#endregion
 //#region ../core/src/view-compiler.ts
 /**
 * View compiler (Phase 2) — turns a validated entity config into read-only
@@ -22,10 +77,6 @@
 const SOURCE_KEY = "id";
 const DEFAULT_VIEW_PREFIX = "crm_src_";
 const DEFAULT_ROLE = "primary";
-/** Quote a single identifier part, escaping embedded double-quotes. */
-function quoteIdent(name) {
-	return `"${name.replace(/"/g, "\"\"")}"`;
-}
 /** Emit a SQL literal for a scalar filter value. */
 function quoteLiteral(value) {
 	if (typeof value === "number") return String(value);
@@ -106,17 +157,24 @@ function compileRelationship(relName, rel, source, related) {
 		refColumn: refCol
 	};
 }
-function compileEntityView(config, entityKey, options = {}) {
-	const entity = config.entities[entityKey];
-	if (!entity) throw new Error(`entity "${entityKey}" is not defined`);
-	const viewName = `${options.viewPrefix ?? "crm_src_"}${entityKey}`;
-	const src = entity.source;
+/** SELECT items for a legacy single-table entity: source key, then fields. */
+function legacySelect(entity, src) {
 	const selectItems = [`${quoteIdent(src)}.${quoteIdent(SOURCE_KEY)} AS ${quoteIdent("id")}`];
 	const columns = ["id"];
 	for (const [field, column] of Object.entries(entity.fields)) {
 		selectItems.push(`${quoteIdent(src)}.${quoteIdent(column)} AS ${quoteIdent(field)}`);
 		columns.push(field);
 	}
+	return {
+		columns,
+		selectItems
+	};
+}
+/**
+* Relationship JOINs for a legacy entity. Appends each relationship's ref
+* column to `columns`/`selectItems` in place, preserving the existing order.
+*/
+function legacyJoins(config, entity, columns, selectItems) {
 	const joins = [];
 	for (const [relName, rel] of Object.entries(entity.relationships ?? {})) {
 		const compiled = compileRelationship(relName, rel, entity, config.entities[rel.entity]);
@@ -126,12 +184,23 @@ function compileEntityView(config, entityKey, options = {}) {
 			columns.push(compiled.refColumn);
 		}
 	}
-	const conditions = compileFilterConditions(src, entity.filter);
-	if (options.orgScope) conditions.push(`${quoteIdent(src)}.${quoteIdent(options.orgScope.column)} = ${quoteLiteral(options.orgScope.value)}`);
+	return joins;
+}
+function compileEntityView(config, entityKey, options = {}) {
+	const entity = config.entities[entityKey];
+	if (!entity) throw new Error(`entity "${entityKey}" is not defined`);
+	const viewName = `${options.viewPrefix ?? "crm_src_"}${entityKey}`;
+	const src = entity.source;
+	const projection = entity.projection;
+	const filterTable = projection ? BASE_REF : src;
+	const { selectItems, columns } = projection ? compileProjectionSelect(projection, SOURCE_KEY) : legacySelect(entity, src);
+	const joins = projection ? compileProjectionJoins(projection) : legacyJoins(config, entity, columns, selectItems);
+	const conditions = compileFilterConditions(filterTable, entity.filter);
+	if (options.orgScope) conditions.push(`${quoteIdent(filterTable)}.${quoteIdent(options.orgScope.column)} = ${quoteLiteral(options.orgScope.value)}`);
 	const lines = [
 		options.securityInvoker ?? true ? `CREATE OR REPLACE VIEW ${quoteIdent(viewName)} WITH (security_invoker = true) AS` : `CREATE OR REPLACE VIEW ${quoteIdent(viewName)} AS`,
 		`SELECT ${selectItems.join(", ")}`,
-		`FROM ${quoteIdent(src)}`,
+		projection ? compileProjectionFrom(projection) : `FROM ${quoteIdent(src)}`,
 		...joins
 	];
 	if (conditions.length > 0) lines.push(`WHERE ${conditions.join(" AND ")}`);

package/{view-compiler-BIwvm-o2.cjs → view-compiler-DplczSjF.cjs}

@@ -1,3 +1,58 @@
+const require_projection = require("./projection-C5244vGa.cjs");
+//#region ../core/src/projection-sql.ts
+/**
+* SQL generation for projection-backed entities.
+*
+* Base and joins are aliased by their ref key (`base`, then each join's `key`),
+* which is what allows the same table to be joined twice and keeps generated
+* SQL independent of host table names.
+*
+* Pure string generation — no DB access. Identifiers are escaped so output is
+* deterministic and injection-safe.
+*/
+/** Quote a single identifier part, escaping embedded double-quotes. */
+function quoteIdent(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+function refSql(ref) {
+	return `${quoteIdent(ref.table)}.${quoteIdent(ref.column)}`;
+}
+/**
+* The identity expression, aliased as `id`. Composite identities concatenate
+* their parts with `::`; validation guarantees every part is NOT NULL and
+* non-text, which is what makes the concatenation collision-free.
+*/
+function identitySql(projection, basePkColumn) {
+	const refs = require_projection.identityRefs(projection.identity, basePkColumn);
+	if (projection.identity.kind === "composite") return `CONCAT_WS('::', ${refs.map((ref) => `${refSql(ref)}::text`).join(", ")}) AS ${quoteIdent("id")}`;
+	const [ref] = refs;
+	if (!ref) throw new Error("projection identity resolved to no column");
+	return `${refSql(ref)} AS ${quoteIdent("id")}`;
+}
+function compileProjectionSelect(projection, basePkColumn) {
+	const selectItems = [identitySql(projection, basePkColumn)];
+	const columns = ["id"];
+	for (const [field, binding] of Object.entries(projection.fieldBindings)) {
+		selectItems.push(`${refSql(binding.from)} AS ${quoteIdent(field)}`);
+		columns.push(field);
+	}
+	return {
+		columns,
+		selectItems
+	};
+}
+function compileProjectionJoins(projection) {
+	return projection.joins.map((join) => {
+		const keyword = join.type === "inner" ? "INNER JOIN" : "LEFT JOIN";
+		const on = join.on.map((c) => `${refSql(c.left)} = ${refSql(c.right)}`).join(" AND ");
+		return `${keyword} ${quoteIdent(join.table)} AS ${quoteIdent(join.key)} ON ${on}`;
+	});
+}
+/** `FROM <baseTable> AS "base"` — the alias every ref resolves against. */
+function compileProjectionFrom(projection) {
+	return `FROM ${quoteIdent(projection.baseTable)} AS ${quoteIdent(require_projection.BASE_REF)}`;
+}
+//#endregion
 //#region ../core/src/view-compiler.ts
 /**
 * View compiler (Phase 2) — turns a validated entity config into read-only
@@ -22,10 +77,6 @@
 const SOURCE_KEY = "id";
 const DEFAULT_VIEW_PREFIX = "crm_src_";
 const DEFAULT_ROLE = "primary";
-/** Quote a single identifier part, escaping embedded double-quotes. */
-function quoteIdent(name) {
-	return `"${name.replace(/"/g, "\"\"")}"`;
-}
 /** Emit a SQL literal for a scalar filter value. */
 function quoteLiteral(value) {
 	if (typeof value === "number") return String(value);
@@ -106,17 +157,24 @@ function compileRelationship(relName, rel, source, related) {
 		refColumn: refCol
 	};
 }
-function compileEntityView(config, entityKey, options = {}) {
-	const entity = config.entities[entityKey];
-	if (!entity) throw new Error(`entity "${entityKey}" is not defined`);
-	const viewName = `${options.viewPrefix ?? "crm_src_"}${entityKey}`;
-	const src = entity.source;
+/** SELECT items for a legacy single-table entity: source key, then fields. */
+function legacySelect(entity, src) {
 	const selectItems = [`${quoteIdent(src)}.${quoteIdent(SOURCE_KEY)} AS ${quoteIdent("id")}`];
 	const columns = ["id"];
 	for (const [field, column] of Object.entries(entity.fields)) {
 		selectItems.push(`${quoteIdent(src)}.${quoteIdent(column)} AS ${quoteIdent(field)}`);
 		columns.push(field);
 	}
+	return {
+		columns,
+		selectItems
+	};
+}
+/**
+* Relationship JOINs for a legacy entity. Appends each relationship's ref
+* column to `columns`/`selectItems` in place, preserving the existing order.
+*/
+function legacyJoins(config, entity, columns, selectItems) {
 	const joins = [];
 	for (const [relName, rel] of Object.entries(entity.relationships ?? {})) {
 		const compiled = compileRelationship(relName, rel, entity, config.entities[rel.entity]);
@@ -126,12 +184,23 @@ function compileEntityView(config, entityKey, options = {}) {
 			columns.push(compiled.refColumn);
 		}
 	}
-	const conditions = compileFilterConditions(src, entity.filter);
-	if (options.orgScope) conditions.push(`${quoteIdent(src)}.${quoteIdent(options.orgScope.column)} = ${quoteLiteral(options.orgScope.value)}`);
+	return joins;
+}
+function compileEntityView(config, entityKey, options = {}) {
+	const entity = config.entities[entityKey];
+	if (!entity) throw new Error(`entity "${entityKey}" is not defined`);
+	const viewName = `${options.viewPrefix ?? "crm_src_"}${entityKey}`;
+	const src = entity.source;
+	const projection = entity.projection;
+	const filterTable = projection ? require_projection.BASE_REF : src;
+	const { selectItems, columns } = projection ? compileProjectionSelect(projection, SOURCE_KEY) : legacySelect(entity, src);
+	const joins = projection ? compileProjectionJoins(projection) : legacyJoins(config, entity, columns, selectItems);
+	const conditions = compileFilterConditions(filterTable, entity.filter);
+	if (options.orgScope) conditions.push(`${quoteIdent(filterTable)}.${quoteIdent(options.orgScope.column)} = ${quoteLiteral(options.orgScope.value)}`);
 	const lines = [
 		options.securityInvoker ?? true ? `CREATE OR REPLACE VIEW ${quoteIdent(viewName)} WITH (security_invoker = true) AS` : `CREATE OR REPLACE VIEW ${quoteIdent(viewName)} AS`,
 		`SELECT ${selectItems.join(", ")}`,
-		`FROM ${quoteIdent(src)}`,
+		projection ? compileProjectionFrom(projection) : `FROM ${quoteIdent(src)}`,
 		...joins
 	];
 	if (conditions.length > 0) lines.push(`WHERE ${conditions.join(" AND ")}`);

package/{view-compiler-Bn_EJJMO.d.mts → view-compiler-Ll9cbIJz.d.cts}

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

package/vite.d.cts

@@ -1,4 +1,4 @@
-import { o as ClivlySDK } from "./namespace-probe-DRzOtaRT.cjs";
+import { o as ClivlySDK } from "./namespace-probe-BSH_p9TK.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-B4WE45TH.mjs";
+import { o as ClivlySDK } from "./namespace-probe-Dsp5uNkS.mjs";
 import { Plugin } from "vite";
 //#region ../sdk/src/vite.d.ts
 interface ClivlyViteOptions {

package/drizzle-B89tLo4T.mjs

@@ -1,31 +0,0 @@
-import { Table, getTableColumns, getTableName, is } from "drizzle-orm";
-//#region ../core/src/drizzle.ts
-/**
-* Derive Clivly's discovery shape (table + column names) from a Drizzle schema
-* object — the `* as schema` you pass to `drizzle(client, { schema })`. This
-* delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
-* `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
-* against your entity config.
-*
-* Column names are the real database column names (e.g. `full_name`), not the
-* Drizzle property keys (`fullName`). Non-table values in the schema object
-* (relations, enums, helpers) are ignored.
-*
-* `drizzle-orm` is an **optional peer dependency** — you only need it installed
-* when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
-* stays dependency-free.
-*/
-function discoverFromDrizzle(schema) {
-	const tables = [];
-	for (const value of Object.values(schema)) {
-		if (!is(value, Table)) continue;
-		const columns = getTableColumns(value);
-		tables.push({
-			name: getTableName(value),
-			columns: Object.values(columns).map((column) => column.name)
-		});
-	}
-	return tables;
-}
-//#endregion
-export { discoverFromDrizzle as t };

package/drizzle-CFOr9dU9.d.mts

@@ -1,20 +0,0 @@
-import { u as DiscoveredSchemaTable } from "./entity-config-DoUCXtq5.mjs";
-//#region ../core/src/drizzle.d.ts
-/**
- * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
- * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
- * delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
- * `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
- * against your entity config.
- *
- * Column names are the real database column names (e.g. `full_name`), not the
- * Drizzle property keys (`fullName`). Non-table values in the schema object
- * (relations, enums, helpers) are ignored.
- *
- * `drizzle-orm` is an **optional peer dependency** — you only need it installed
- * when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
- * stays dependency-free.
- */
-declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
-//#endregion
-export { discoverFromDrizzle as t };

package/drizzle-DiReZf6d.cjs

@@ -1,36 +0,0 @@
-let drizzle_orm = require("drizzle-orm");
-//#region ../core/src/drizzle.ts
-/**
-* Derive Clivly's discovery shape (table + column names) from a Drizzle schema
-* object — the `* as schema` you pass to `drizzle(client, { schema })`. This
-* delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
-* `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
-* against your entity config.
-*
-* Column names are the real database column names (e.g. `full_name`), not the
-* Drizzle property keys (`fullName`). Non-table values in the schema object
-* (relations, enums, helpers) are ignored.
-*
-* `drizzle-orm` is an **optional peer dependency** — you only need it installed
-* when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
-* stays dependency-free.
-*/
-function discoverFromDrizzle(schema) {
-	const tables = [];
-	for (const value of Object.values(schema)) {
-		if (!(0, drizzle_orm.is)(value, drizzle_orm.Table)) continue;
-		const columns = (0, drizzle_orm.getTableColumns)(value);
-		tables.push({
-			name: (0, drizzle_orm.getTableName)(value),
-			columns: Object.values(columns).map((column) => column.name)
-		});
-	}
-	return tables;
-}
-//#endregion
-Object.defineProperty(exports, "discoverFromDrizzle", {
-	enumerable: true,
-	get: function() {
-		return discoverFromDrizzle;
-	}
-});

package/drizzle-DmeKSqeF.d.cts

@@ -1,20 +0,0 @@
-import { u as DiscoveredSchemaTable } from "./entity-config-DoUCXtq5.cjs";
-//#region ../core/src/drizzle.d.ts
-/**
- * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
- * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
- * delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
- * `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
- * against your entity config.
- *
- * Column names are the real database column names (e.g. `full_name`), not the
- * Drizzle property keys (`fullName`). Non-table values in the schema object
- * (relations, enums, helpers) are ignored.
- *
- * `drizzle-orm` is an **optional peer dependency** — you only need it installed
- * when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
- * stays dependency-free.
- */
-declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
-//#endregion
-export { discoverFromDrizzle as t };

package/mappings-config-DsUa7-1w.d.mts

@@ -1,41 +0,0 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-DoUCXtq5.mjs";
-//#region ../core/src/mappings-config.d.ts
-/**
- * Mappings → Entity Config bridge.
- *
- * `crm_entity_mappings` rows are the single source of truth for how a host
- * schema maps onto Clivly's CRM concepts. This module compiles those rows into
- * a `ClivlyEntitiesConfig` — the contract the view compiler and sync engine
- * consume — so the persisted mapping and the runtime pipeline never diverge.
- *
- * The row model has no explicit entity-key column (it's keyed by
- * `sourceTable + targetConcept + role`), but the config's `relationships`
- * reference other entities *by key*. This builder therefore derives a stable
- * key per row and resolves each relationship's `entity` reference through the
- * same derivation — so a relationship stored as `entity: "<relatedTable>"`
- * (the shape `mappings.suggest` produces) resolves to the right entity.
- */
-/**
- * A persisted `crm_entity_mappings` row, narrowed to the columns the builder
- * reads. Structurally compatible with the Drizzle row (jsonb columns typed
- * loosely) so the API layer can pass `db.select()` results straight in.
- */
-interface EntityMappingRow {
-  fieldMap: Record<string, string>;
-  filter?: Record<string, unknown> | null;
-  relationships?: Record<string, unknown> | null;
-  role?: string | null;
-  sourceTable: string;
-  status?: string | null;
-  targetConcept: string;
-  targetObjectTypeId?: string | null;
-}
-/**
- * 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.
- */
-declare function mappingsToEntitiesConfig(rows: EntityMappingRow[]): ClivlyEntitiesConfig;
-//#endregion
-export { mappingsToEntitiesConfig as n, EntityMappingRow as t };

package/mappings-config-XmzB4dag.d.cts

@@ -1,41 +0,0 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-DoUCXtq5.cjs";
-//#region ../core/src/mappings-config.d.ts
-/**
- * Mappings → Entity Config bridge.
- *
- * `crm_entity_mappings` rows are the single source of truth for how a host
- * schema maps onto Clivly's CRM concepts. This module compiles those rows into
- * a `ClivlyEntitiesConfig` — the contract the view compiler and sync engine
- * consume — so the persisted mapping and the runtime pipeline never diverge.
- *
- * The row model has no explicit entity-key column (it's keyed by
- * `sourceTable + targetConcept + role`), but the config's `relationships`
- * reference other entities *by key*. This builder therefore derives a stable
- * key per row and resolves each relationship's `entity` reference through the
- * same derivation — so a relationship stored as `entity: "<relatedTable>"`
- * (the shape `mappings.suggest` produces) resolves to the right entity.
- */
-/**
- * A persisted `crm_entity_mappings` row, narrowed to the columns the builder
- * reads. Structurally compatible with the Drizzle row (jsonb columns typed
- * loosely) so the API layer can pass `db.select()` results straight in.
- */
-interface EntityMappingRow {
-  fieldMap: Record<string, string>;
-  filter?: Record<string, unknown> | null;
-  relationships?: Record<string, unknown> | null;
-  role?: string | null;
-  sourceTable: string;
-  status?: string | null;
-  targetConcept: string;
-  targetObjectTypeId?: string | null;
-}
-/**
- * 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.
- */
-declare function mappingsToEntitiesConfig(rows: EntityMappingRow[]): ClivlyEntitiesConfig;
-//#endregion
-export { mappingsToEntitiesConfig as n, EntityMappingRow as t };