@clivly/core 0.7.4 → 0.9.0

package/dist/drizzle.cjs

@@ -1,7 +1,83 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let drizzle_orm = require("drizzle-orm");
+let drizzle_orm_pg_core = require("drizzle-orm/pg-core");
 //#region src/drizzle.ts
 /**
+* Every unique key on a table, as DB column-name tuples. Primary keys count —
+* fan-out detection asks "do these join columns cover a unique key?", and a PK
+* answers that as well as any explicit unique constraint.
+*
+* Returns `undefined` if reflection fails (non-pg table, or a drizzle version
+* without config access), meaning "unknown, cannot determine". Returns `[]`
+* when reflection succeeds and the table genuinely has none. That distinction
+* is load-bearing: `hasRichMeta` uses it to tell "metadata unavailable" from
+* "confirmed no constraints", and projection validation fails closed on the
+* former.
+*/
+function buildUniqueConstraints(table) {
+	const keys = [];
+	try {
+		const config = (0, drizzle_orm_pg_core.getTableConfig)(table);
+		for (const column of config.columns ?? []) if (column.isUnique || column.primary) keys.push([column.name]);
+		for (const pk of config.primaryKeys ?? []) keys.push(pk.columns.map((c) => c.name));
+		for (const constraint of config.uniqueConstraints ?? []) keys.push(constraint.columns.map((c) => c.name));
+		for (const index of config.indexes ?? []) {
+			if (!index.config?.unique) continue;
+			const columns = (index.config.columns ?? []).map((c) => c?.name).filter((name) => Boolean(name));
+			if (columns.length > 0) keys.push(columns);
+		}
+	} catch {
+		return;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	return keys.filter((key) => {
+		const id = [...key].sort().join("\0");
+		if (seen.has(id) || key.length === 0) return false;
+		seen.add(id);
+		return true;
+	});
+}
+/**
+* Per-column metadata (type, PK, nullability, FK edges) for a Drizzle table.
+* Structural only — no DB round-trip, so it is safe to recompute on every
+* heartbeat. FK reflection is best-effort; a non-Postgres table still gets
+* name/type/PK/nullable.
+*/
+function buildColumnsMeta(table) {
+	const columns = (0, drizzle_orm.getTableColumns)(table);
+	const fkByColumn = /* @__PURE__ */ new Map();
+	try {
+		for (const fk of (0, drizzle_orm_pg_core.getTableConfig)(table).foreignKeys) {
+			const ref = fk.reference();
+			const foreignTable = (0, drizzle_orm.getTableName)(ref.foreignTable);
+			ref.columns.forEach((col, index) => {
+				const foreignCol = ref.foreignColumns[index];
+				if (foreignCol) fkByColumn.set(col.name, {
+					table: foreignTable,
+					column: foreignCol.name
+				});
+			});
+		}
+	} catch {}
+	return Object.values(columns).map((col) => {
+		const references = fkByColumn.get(col.name);
+		let type;
+		try {
+			type = col.getSQLType();
+		} catch {
+			type = void 0;
+		}
+		return {
+			name: col.name,
+			type,
+			nullable: !col.notNull,
+			isPrimaryKey: Boolean(col.primary),
+			isForeignKey: references !== void 0,
+			...references ? { references } : {}
+		};
+	});
+}
+/**
 * 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
@@ -21,12 +97,17 @@ function discoverFromDrizzle(schema) {
 	for (const value of Object.values(schema)) {
 		if (!(0, drizzle_orm.is)(value, drizzle_orm.Table)) continue;
 		const columns = (0, drizzle_orm.getTableColumns)(value);
+		const uniqueConstraints = buildUniqueConstraints(value);
 		tables.push({
 			name: (0, drizzle_orm.getTableName)(value),
-			columns: Object.values(columns).map((column) => column.name)
+			columns: Object.values(columns).map((column) => column.name),
+			columnsMeta: buildColumnsMeta(value),
+			...uniqueConstraints === void 0 ? {} : { uniqueConstraints }
 		});
 	}
 	return tables;
 }
 //#endregion
+exports.buildColumnsMeta = buildColumnsMeta;
+exports.buildUniqueConstraints = buildUniqueConstraints;
 exports.discoverFromDrizzle = discoverFromDrizzle;

package/dist/drizzle.d.cts

@@ -1,5 +1,26 @@
-import { DiscoveredSchemaTable } from "./entity-config.cjs";
+import { DiscoveredColumnMeta, DiscoveredSchemaTable } from "./entity-config.cjs";
+import { Table } from "drizzle-orm";
 //#region src/drizzle.d.ts
+/**
+ * Every unique key on a table, as DB column-name tuples. Primary keys count —
+ * fan-out detection asks "do these join columns cover a unique key?", and a PK
+ * answers that as well as any explicit unique constraint.
+ *
+ * Returns `undefined` if reflection fails (non-pg table, or a drizzle version
+ * without config access), meaning "unknown, cannot determine". Returns `[]`
+ * when reflection succeeds and the table genuinely has none. That distinction
+ * is load-bearing: `hasRichMeta` uses it to tell "metadata unavailable" from
+ * "confirmed no constraints", and projection validation fails closed on the
+ * former.
+ */
+declare function buildUniqueConstraints(table: unknown): string[][] | undefined;
+/**
+ * Per-column metadata (type, PK, nullability, FK edges) for a Drizzle table.
+ * Structural only — no DB round-trip, so it is safe to recompute on every
+ * heartbeat. FK reflection is best-effort; a non-Postgres table still gets
+ * name/type/PK/nullable.
+ */
+declare function buildColumnsMeta(table: Table): DiscoveredColumnMeta[];
 /**
  * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
  * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
@@ -17,4 +38,4 @@ import { DiscoveredSchemaTable } from "./entity-config.cjs";
  */
 declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
 //#endregion
-export { discoverFromDrizzle };
+export { buildColumnsMeta, buildUniqueConstraints, discoverFromDrizzle };

package/dist/drizzle.d.mts

@@ -1,5 +1,26 @@
-import { DiscoveredSchemaTable } from "./entity-config.mjs";
+import { DiscoveredColumnMeta, DiscoveredSchemaTable } from "./entity-config.mjs";
+import { Table } from "drizzle-orm";
 //#region src/drizzle.d.ts
+/**
+ * Every unique key on a table, as DB column-name tuples. Primary keys count —
+ * fan-out detection asks "do these join columns cover a unique key?", and a PK
+ * answers that as well as any explicit unique constraint.
+ *
+ * Returns `undefined` if reflection fails (non-pg table, or a drizzle version
+ * without config access), meaning "unknown, cannot determine". Returns `[]`
+ * when reflection succeeds and the table genuinely has none. That distinction
+ * is load-bearing: `hasRichMeta` uses it to tell "metadata unavailable" from
+ * "confirmed no constraints", and projection validation fails closed on the
+ * former.
+ */
+declare function buildUniqueConstraints(table: unknown): string[][] | undefined;
+/**
+ * Per-column metadata (type, PK, nullability, FK edges) for a Drizzle table.
+ * Structural only — no DB round-trip, so it is safe to recompute on every
+ * heartbeat. FK reflection is best-effort; a non-Postgres table still gets
+ * name/type/PK/nullable.
+ */
+declare function buildColumnsMeta(table: Table): DiscoveredColumnMeta[];
 /**
  * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
  * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
@@ -17,4 +38,4 @@ import { DiscoveredSchemaTable } from "./entity-config.mjs";
  */
 declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
 //#endregion
-export { discoverFromDrizzle };
+export { buildColumnsMeta, buildUniqueConstraints, discoverFromDrizzle };

package/dist/drizzle.mjs

@@ -1,6 +1,82 @@
 import { Table, getTableColumns, getTableName, is } from "drizzle-orm";
+import { getTableConfig } from "drizzle-orm/pg-core";
 //#region src/drizzle.ts
 /**
+* Every unique key on a table, as DB column-name tuples. Primary keys count —
+* fan-out detection asks "do these join columns cover a unique key?", and a PK
+* answers that as well as any explicit unique constraint.
+*
+* Returns `undefined` if reflection fails (non-pg table, or a drizzle version
+* without config access), meaning "unknown, cannot determine". Returns `[]`
+* when reflection succeeds and the table genuinely has none. That distinction
+* is load-bearing: `hasRichMeta` uses it to tell "metadata unavailable" from
+* "confirmed no constraints", and projection validation fails closed on the
+* former.
+*/
+function buildUniqueConstraints(table) {
+	const keys = [];
+	try {
+		const config = getTableConfig(table);
+		for (const column of config.columns ?? []) if (column.isUnique || column.primary) keys.push([column.name]);
+		for (const pk of config.primaryKeys ?? []) keys.push(pk.columns.map((c) => c.name));
+		for (const constraint of config.uniqueConstraints ?? []) keys.push(constraint.columns.map((c) => c.name));
+		for (const index of config.indexes ?? []) {
+			if (!index.config?.unique) continue;
+			const columns = (index.config.columns ?? []).map((c) => c?.name).filter((name) => Boolean(name));
+			if (columns.length > 0) keys.push(columns);
+		}
+	} catch {
+		return;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	return keys.filter((key) => {
+		const id = [...key].sort().join("\0");
+		if (seen.has(id) || key.length === 0) return false;
+		seen.add(id);
+		return true;
+	});
+}
+/**
+* Per-column metadata (type, PK, nullability, FK edges) for a Drizzle table.
+* Structural only — no DB round-trip, so it is safe to recompute on every
+* heartbeat. FK reflection is best-effort; a non-Postgres table still gets
+* name/type/PK/nullable.
+*/
+function buildColumnsMeta(table) {
+	const columns = getTableColumns(table);
+	const fkByColumn = /* @__PURE__ */ new Map();
+	try {
+		for (const fk of getTableConfig(table).foreignKeys) {
+			const ref = fk.reference();
+			const foreignTable = getTableName(ref.foreignTable);
+			ref.columns.forEach((col, index) => {
+				const foreignCol = ref.foreignColumns[index];
+				if (foreignCol) fkByColumn.set(col.name, {
+					table: foreignTable,
+					column: foreignCol.name
+				});
+			});
+		}
+	} catch {}
+	return Object.values(columns).map((col) => {
+		const references = fkByColumn.get(col.name);
+		let type;
+		try {
+			type = col.getSQLType();
+		} catch {
+			type = void 0;
+		}
+		return {
+			name: col.name,
+			type,
+			nullable: !col.notNull,
+			isPrimaryKey: Boolean(col.primary),
+			isForeignKey: references !== void 0,
+			...references ? { references } : {}
+		};
+	});
+}
+/**
 * 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
@@ -20,12 +96,15 @@ function discoverFromDrizzle(schema) {
 	for (const value of Object.values(schema)) {
 		if (!is(value, Table)) continue;
 		const columns = getTableColumns(value);
+		const uniqueConstraints = buildUniqueConstraints(value);
 		tables.push({
 			name: getTableName(value),
-			columns: Object.values(columns).map((column) => column.name)
+			columns: Object.values(columns).map((column) => column.name),
+			columnsMeta: buildColumnsMeta(value),
+			...uniqueConstraints === void 0 ? {} : { uniqueConstraints }
 		});
 	}
 	return tables;
 }
 //#endregion
-export { discoverFromDrizzle };
+export { buildColumnsMeta, buildUniqueConstraints, discoverFromDrizzle };