@rebasepro/server-postgres 0.24.0 → 0.24.1-canary.g19596ef

package/dist/{introspect-db-logic-kCETE8TY.js → introspect-db-logic-BCc1Jym2.js}

@@ -1,7 +1,9 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
 import { a as buildSearchColumnSpec, u as searchColumnStamps } from "./search-column-BM-GV6vH.js";
+import { p as foreignKeyIndexSpec } from "./source-DB6xJv3p.js";
 import { DEFAULT_SEARCH_COLUMN, DEFAULT_SEARCH_LANGUAGE } from "@rebasepro/types";
+import { getGeneratedPolicyNames, policyToSecurityRule } from "@rebasepro/common";
 import { firstFreeKey, toPostgresIdentifier, toWireKey } from "@rebasepro/utils";
 //#region src/schema/introspect-db-naming.ts
 /**
@@ -276,8 +278,8 @@ function stringStorage(col) {
 		case "character varying":
 			if (typeof col.character_maximum_length === "number" && col.character_maximum_length > 0) return { keys: [`columnType: ${literal("varchar")}`] };
 			return {
-				keys: [`columnType: ${literal("varchar")}`],
-				note: `"${col.column_name}" is a varchar with no length; the planner always writes one (255 unless \`validation.max\` says otherwise), so a push would plan a narrowing type change.`
+				keys: [],
+				note: `"${col.column_name}" is a varchar with no length, declared as text: a push would plan converting it to text, which keeps every value.`
 			};
 		case "character": return { keys: [`columnType: ${literal("char")}`] };
 		case "uuid": return { keys: [`columnType: ${literal("uuid")}`] };
@@ -708,6 +710,41 @@ function classifyJunction(table, context) {
 	};
 }
 /**
+* A policy expression that reads who is asking: the `app.uid` setting every
+* request runs with, `rebase.uid()` (or the retired `auth.uid()`), the JWT,
+* or the session's own role.
+*/
+var CALLER_IDENTITY = /current_setting\(\s*'app\.(uid|user_id|jwt)'|\b(rebase|auth)\.(uid|jwt)\s*\(|\bcurrent_user\b|\bsession_user\b/i;
+/**
+* The tables whose row-level security hands each caller rows of their own,
+* with the policies that do it.
+*
+* Structure in the sense this module means: a policy is a rule the database
+* enforces, and one that compares a row to the caller's identity says the rows
+* belong to users. That is the app's data. A young database holds three
+* customers and one order; by row count the customers are "a 3-row code list"
+* and the orders a child reached only through them, and both go missing from
+* the navigation of the app that owns them.
+*/
+function callerScopedTables(metadata) {
+	const scoped = /* @__PURE__ */ new Map();
+	for (const policy of metadata.policies ?? []) {
+		if (!CALLER_IDENTITY.test(policy.qual ?? "") && !CALLER_IDENTITY.test(policy.with_check ?? "")) continue;
+		scoped.set(policy.table_name, [...scoped.get(policy.table_name) ?? [], policy.policy_name]);
+	}
+	return scoped;
+}
+/** An entity because its policies give each user their own rows — see {@link callerScopedTables}. */
+function classifyCallerScoped(table, perCaller) {
+	const policies = perCaller.get(table);
+	if (!policies) return null;
+	return {
+		table,
+		role: "entity",
+		reason: `its row-level security gives each user their own rows (${policies.join(", ")}), so they are the app's data`
+	};
+}
+/**
 * A small, referenced, self-contained code list.
 *
 * Requires: something references it, it references nothing, it carries few and
@@ -833,8 +870,9 @@ function pickOwner(meta, constraints) {
 function classifyTables(metadata, tables) {
 	const context = buildContext(metadata, tables);
 	const result = /* @__PURE__ */ new Map();
+	const perCaller = callerScopedTables(metadata);
 	for (const table of tables.keys()) {
-		const classification = classifyJunction(table, context) ?? classifyLookup(table, context) ?? classifyOwnedChild(table, context) ?? {
+		const classification = classifyJunction(table, context) ?? classifyCallerScoped(table, perCaller) ?? classifyLookup(table, context) ?? classifyOwnedChild(table, context) ?? {
 			table,
 			role: "entity",
 			reason: "no structural evidence that it is a join table, a code list, or owned by another table"
@@ -913,6 +951,32 @@ function deriveKanbanProperty(facts) {
 		return fact.column.column_name;
 	}
 }
+/** Names a string column goes by when it holds a board's card order (a fractional-indexing key). */
+var ORDER_KEY_NAMES = /* @__PURE__ */ new Set([
+	"__order",
+	"order_key",
+	"sort_key",
+	"rank",
+	"lexorank",
+	"position_key"
+]);
+/**
+* The string column that can hold a board's card order, or nothing.
+*
+* A board without `orderProperty` cannot keep a card's position within a
+* column, and the config validator says so on every generate — so a board is
+* emitted only when the table already has somewhere to store the order. A
+* legacy table almost never does; asking its owner to add a hidden column
+* just to satisfy generated output was the wrong way round.
+*/
+function deriveKanbanOrderProperty(facts) {
+	for (const fact of facts.values()) {
+		if (fact.isPk || fact.isFk || fact.isGenerated || fact.enumValues) continue;
+		if (fact.propType !== "string") continue;
+		if (!/^(text|character varying)$/.test(fact.column.data_type)) continue;
+		if (ORDER_KEY_NAMES.has(fact.column.column_name.toLowerCase())) return fact.column.column_name;
+	}
+}
 /**
 * The column a list should be sorted by, newest first.
 *
@@ -1302,6 +1366,57 @@ function sortPropertiesOrder(entries) {
 var ADMIN_TYPES_PACKAGE = "@rebasepro/cms-types";
 var COMMON_PACKAGE = "@rebasepro/common";
 var TYPES_PACKAGE = "@rebasepro/types";
+/**
+* The table's row-level security policies, as the collection's `securityRules`.
+*
+* A table's policies are its access model, and a collection that describes
+* none leaves every one of them an "orphan": `doctor` fails on it, every push
+* warns about it, and a push drops one whose name has the shape an unnamed
+* rule compiles to (`<table>_<op>_<hash>`, which is every rule on a database
+* Rebase built). Described here, each is recreated from its rule as it was.
+*
+* Read back with `policyToSecurityRule` — what Studio's "Import from table"
+* and "Import to codebase" use — so the `TO` list, the mode and both clauses
+* come back as they are. The framework's own defaults
+* (`<table>_default_admin_read` and friends) are left out: every collection is
+* given them anyway, and described twice they would be written twice.
+*/
+function renderSecurityRules(tableName, policies) {
+	const injected = getGeneratedPolicyNames({
+		name: tableName,
+		slug: tableName,
+		table: tableName,
+		properties: {}
+	});
+	const own = policies.filter((policy) => policy.table_name === tableName && !injected.has(policy.policy_name));
+	if (own.length === 0) return "";
+	return `
+    // The table's row-level security policies, read from the database. \`rebase db push\`
+    // recreates each from its rule, so a policy is changed here from now on.\n    securityRules: [${own.map((policy) => {
+		const rule = policyToSecurityRule({
+			policyname: policy.policy_name,
+			cmd: toPolicyCommand(policy.cmd),
+			permissive: policy.permissive.toUpperCase() === "RESTRICTIVE" ? "RESTRICTIVE" : "PERMISSIVE",
+			roles: policy.roles,
+			qual: policy.qual,
+			with_check: policy.with_check
+		});
+		return `\n        {\n${Object.entries(rule).map(([key, value]) => {
+			return `            ${key}: ${Array.isArray(value) ? `[${value.map((item) => quote(String(item))).join(", ")}]` : quote(String(value))}`;
+		}).join(",\n")}\n        },`;
+	}).join("")}\n    ],`;
+}
+/** `pg_policies.cmd`, narrowed to the commands a policy can have. */
+function toPolicyCommand(cmd) {
+	switch (cmd.toUpperCase()) {
+		case "SELECT": return "SELECT";
+		case "INSERT": return "INSERT";
+		case "UPDATE": return "UPDATE";
+		case "DELETE": return "DELETE";
+		case "ALL": return "ALL";
+		default: return;
+	}
+}
 /** Adds entries to a property's `validation` block, creating it if absent. */
 function withValidation(extra, entries) {
 	if (entries.length === 0) return extra;
@@ -1565,7 +1680,11 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			if (!hasGeneratedKey(extra, "autoValue") && !hasGeneratedKey(extra, "defaultValue")) {
 				const fallback = literalDefaultOf(col, finalPropType);
 				if (fallback && "source" in fallback) extra += `\n            defaultValue: ${fallback.source},`;
-				else if (fallback) fileNotes.push(fallback.note);
+				else if (fallback) {
+					const expression = col.column_default?.trim();
+					if (col.is_nullable === "NO" && expression) extra += `\n            databaseDefault: ${JSON.stringify(`sql\`${expression}\``)},`;
+					else fileNotes.push(fallback.note);
+				}
 			}
 		}
 		const declaredValidation = [];
@@ -1666,6 +1785,9 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			const onDelete = onDeleteOf(fk, required);
 			const requiredLine = required ? "\n            validation: { required: true }," : "";
 			const onDeleteLine = onDelete ? `,\n                onDelete: ${quote(onDelete)}` : "";
+			const derivedIndex = foreignKeyIndexSpec(context.metadata?.schema ?? "public", tableName, fk.column_name);
+			const indexLine = context.metadata?.indexes !== void 0 && meta.pks[0] !== fk.column_name && !context.metadata.indexes.some((i) => i.table_name === tableName && i.index_name === derivedIndex.indexName) ? `,\n                // The database has no index of Rebase's on ${commentText(fk.column_name)}. Delete this line to have one built.
+                index: false` : "";
 			propertyBlocks.set(relName, `
         ${propKey(relName)}: {
             name: ${quote(relHumanName)},
@@ -1674,7 +1796,7 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
             relation: {
                 kind: "belongsTo",
                 target: ${relationTarget(targetCollectionCamel)},
-                localKey: ${quote(fk.column_name)}${onDeleteLine}
+                localKey: ${quote(fk.column_name)}${onDeleteLine}${indexLine}
             }
         },`);
 		}
@@ -1769,6 +1891,7 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 	if (search.note) fileNotes.push(search.note);
 	const searchBlock = search.block ?? "";
 	const relationsBlock = relationsOutput ? `\n    relations: [${relationsOutput}\n    ],` : "";
+	const securityRulesBlock = renderSecurityRules(tableName, context.metadata?.policies ?? []);
 	const sortedPropertiesOrder = sortPropertiesOrder(orderEntries);
 	for (const key of sortedPropertiesOrder) propsOutput += propertyBlocks.get(key) || "";
 	const adminEntries = [`icon: ${quote(icon)}`];
@@ -1781,7 +1904,11 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 			const titleProperty = deriveTitleProperty(derivedFacts);
 			if (titleProperty) adminEntries.push(`display: { title: ${quote(asProperty(titleProperty))} }`);
 			const kanbanProperty = deriveKanbanProperty(derivedFacts);
-			if (kanbanProperty) adminEntries.push(`kanban: {\n            columnProperty: ${quote(asProperty(kanbanProperty))}\n        }`);
+			const orderProperty = kanbanProperty ? deriveKanbanOrderProperty(derivedFacts) : void 0;
+			if (kanbanProperty && orderProperty) {
+				adminEntries.push(`kanban: {\n            columnProperty: ${quote(asProperty(kanbanProperty))}\n        }`);
+				adminEntries.push(`orderProperty: ${quote(asProperty(orderProperty))}`);
+			} else if (kanbanProperty) adminEntries.push(`// A board over ${quote(asProperty(kanbanProperty))} fits this table, but a board needs a string column to keep each card's order in. Add one, then declare kanban: { columnProperty: ${quote(asProperty(kanbanProperty))} } and orderProperty: "<that property>".`);
 			const sort = deriveSort(derivedFacts);
 			if (sort) adminEntries.push(`sort: [${quote(asProperty(sort[0]))}, "desc"]`);
 		}
@@ -1793,7 +1920,7 @@ function generateCollectionFile(tableName, meta, allFks, joinTables, tablesMap,
 	const descriptionBlock = tableComment ? `\n    description: ${quote(tableComment)},` : "";
 	const pgSchema = context.metadata?.schema;
 	const schemaBlock = pgSchema && pgSchema !== "public" ? `\n    schema: ${quote(pgSchema)},` : "";
-	const classificationNote = classification && classification.role !== "entity" ? `\n// Introspected as a ${commentText(classification.role)}: ${commentText(classification.reason)}.\n` : "";
+	const classificationNote = classification && classification.role !== "entity" ? `\n// Introspected as ${/^[aeiou]/.test(classification.role) ? "an" : "a"} ${commentText(classification.role)}: ${commentText(classification.reason)}.\n` : "";
 	for (const note of fileNotes) context.notes?.push(`${tableName}: ${note}`);
 	const storageNote = fileNotes.length > 0 ? `\n// ⚠ Not reproduced exactly by \`rebase db push\` — read before pushing:\n${fileNotes.map((n) => `//   - ${commentText(n)}`).join("\n")}\n` : "";
 	const collectionVarName = toCollectionVarName(tableName);
@@ -1807,7 +1934,7 @@ ${open}
     slug: ${quote(tableName)},
     table: ${quote(tableName)},${schemaBlock}${descriptionBlock}${searchBlock}
     properties: {${propsOutput}
-    },${relationsBlock}${adminBlock}
+    },${relationsBlock}${securityRulesBlock}${adminBlock}
 ${close}
 
 export default ${collectionVarName};
@@ -1868,4 +1995,4 @@ function safeHostFromUrl(url) {
 //#endregion
 export { compositeKeySkipReason as a, getIconForTable as c, safeHostFromUrl as d, singularize as f, humanize as g, mapPgType as h, buildTablesMap as i, identifyJoinTables as l, lookupCandidates as m, COMMON_PACKAGE as n, generateCollectionFile as o, classifyTables as p, buildEnumMap as r, generateIndexContent as s, ADMIN_TYPES_PACKAGE as t, mergeIndexContent as u };
 
-//# sourceMappingURL=introspect-db-logic-kCETE8TY.js.map
+//# sourceMappingURL=introspect-db-logic-BCc1Jym2.js.map