@rebasepro/server-postgres 0.12.1-canary.g4e7bcbf → 0.12.1-canary.g52d71ee

package/src/schema/introspect-db-types.ts

@@ -0,0 +1,56 @@
+/**
+ * The PostgreSQL type → Rebase property type mapping.
+ *
+ * Split out of `introspect-db-logic` so that the structural analysis can use it
+ * without importing the generator, which imports the analysis. Re-exported from
+ * `introspect-db-logic` so existing callers keep their import path.
+ */
+
+/**
+ * Map a PostgreSQL data type to a Rebase property type.
+ */
+export function mapPgType(dataType: string): string {
+    const dt = dataType.toLowerCase();
+
+    // Interval MUST be checked before numeric ("interval" contains "int")
+    if (dt === "interval") return "string";
+
+    // Array types MUST be checked before numeric ("_int4" contains "int")
+    if (dt === "array" || dt.startsWith("_")) return "array";
+
+    // Numeric types
+    if (
+        dt.includes("int") || // integer, smallint, bigint
+        dt.includes("numeric") ||
+        dt.includes("decimal") ||
+        dt.includes("serial") || // serial, bigserial
+        dt === "real" ||
+        dt === "float4" ||
+        dt === "float8" ||
+        dt === "double precision" ||
+        dt === "money"
+    ) {
+        return "number";
+    }
+
+    // Boolean
+    if (dt.includes("bool")) return "boolean";
+
+    // Date / Time
+    if (dt.includes("time") || dt.includes("date")) return "date";
+
+    // JSON
+    if (dt === "json" || dt === "jsonb") return "map";
+
+    // Binary
+    if (dt === "bytea") return "binary";
+
+    // Network types
+    if (dt === "inet" || dt === "cidr" || dt === "macaddr" || dt === "macaddr8") return "string";
+
+    // UUID
+    if (dt === "uuid") return "string";
+
+    // Text/varchar/char — default to string
+    return "string";
+}

package/src/schema/introspect-db.ts

@@ -7,19 +7,16 @@ import * as dotenv from "dotenv";
 import readline from "readline";
 
 import {
-    TableRow,
-    TableColumn,
-    EnumValue,
-    PrimaryKeyRow,
-    ForeignKeyRow,
     buildTablesMap,
     buildEnumMap,
-    identifyJoinTables,
     generateCollectionFile,
     generateIndexContent,
     mergeIndexContent,
     safeHostFromUrl
 } from "./introspect-db-logic";
+import { countRowsUpTo, readSchemaMetadata } from "./introspect-db-queries";
+import { classifyTables, lookupCandidates, LOOKUP_MAX_ROWS } from "./introspect-db-structure";
+import { parseCheckConstraints } from "./introspect-db-constraints";
 import { logger } from "@rebasepro/server";
 
 async function main() {
@@ -89,82 +86,41 @@ async function main() {
     logger.info(chalk.gray(`Introspecting schema '${pgSchema}'...`));
 
     try {
-        // 1. Get Tables
-        const { rows: tables } = await client.query<TableRow>(`
-            SELECT table_name
-            FROM information_schema.tables
-            WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-              AND table_name NOT LIKE 'drizzle_%'
-              AND table_name NOT LIKE 'rebase_%'
-            ORDER BY table_name
-        `, [pgSchema]);
-
-        // 2. Get Columns
-        const { rows: columns } = await client.query<TableColumn>(`
-            SELECT 
-                c.table_name, 
-                c.column_name, 
-                c.data_type, 
-                c.udt_name, 
-                c.is_nullable, 
-                c.column_default,
-                (SELECT a.atttypmod FROM pg_attribute a 
-                 JOIN pg_class pc ON a.attrelid = pc.oid 
-                 WHERE pc.relname = c.table_name 
-                   AND a.attname = c.column_name 
-                   AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod
-            FROM information_schema.columns c
-            WHERE c.table_schema = $1
-        `, [pgSchema]);
-
-        // 2b. Get Enum Types and their values
-        const { rows: enumValues } = await client.query<EnumValue>(`
-            SELECT t.typname AS enum_name,
-                   e.enumlabel AS enum_value,
-                   e.enumsortorder AS sort_order
-            FROM pg_type t
-            JOIN pg_enum e ON t.oid = e.enumtypid
-            JOIN pg_namespace n ON t.typnamespace = n.oid
-            WHERE n.nspname = $1
-            ORDER BY t.typname, e.enumsortorder
-        `, [pgSchema]);
-
-        // Build a map: enum_name -> ordered list of values
-        const enumMap = buildEnumMap(enumValues);
-
-        // 3. Get Primary Keys
-        const { rows: pks } = await client.query<PrimaryKeyRow>(`
-            SELECT t.relname as table_name, a.attname as column_name
-            FROM   pg_index i
-            JOIN   pg_attribute a ON a.attrelid = i.indrelid
-                                AND a.attnum = ANY(i.indkey)
-            JOIN   pg_class t ON t.oid = i.indrelid
-            JOIN   pg_namespace n ON n.oid = t.relnamespace
-            WHERE  i.indisprimary AND n.nspname = $1
-        `, [pgSchema]);
+        const metadata = await readSchemaMetadata(client, pgSchema);
+        const enumMap = buildEnumMap(metadata.enumValues);
+        const tablesMap = buildTablesMap(metadata.tables, metadata.columns, metadata.pks, metadata.fks);
+        const fks = metadata.fks;
+
+        // Only tables that could structurally be a code list are counted, and
+        // each count stops at the threshold — see `countRowsUpTo`. Introspection
+        // runs against a database it does not own, so "cheap on a table of any
+        // size" is a requirement, not an optimization.
+        for (const table of lookupCandidates(metadata, tablesMap)) {
+            try {
+                metadata.rowCounts[table] = await countRowsUpTo(client, pgSchema, table, LOOKUP_MAX_ROWS);
+            } catch (err) {
+                // A table this run cannot read is simply not classified as a code
+                // list; everything else about it still generates.
+                logger.info(chalk.gray(`  (skipped row count for ${table}: ${err instanceof Error ? err.message : String(err)})`));
+            }
+        }
 
-        // 4. Get Foreign Keys
-        const { rows: fks } = await client.query<ForeignKeyRow>(`
-            SELECT
-                tc.table_name, 
-                kcu.column_name, 
-                ccu.table_name AS foreign_table_name,
-                ccu.column_name AS foreign_column_name 
-            FROM 
-                information_schema.table_constraints AS tc 
-                JOIN information_schema.key_column_usage AS kcu
-                  ON tc.constraint_name = kcu.constraint_name
-                  AND tc.table_schema = kcu.table_schema
-                JOIN information_schema.constraint_column_usage AS ccu
-                  ON ccu.constraint_name = tc.constraint_name
-                  AND ccu.table_schema = tc.table_schema
-            WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1
-        `, [pgSchema]);
+        const classifications = classifyTables(metadata, tablesMap);
+        const checkFacts = parseCheckConstraints(metadata.checks);
+        const joinTables = new Set(
+            Array.from(classifications.values())
+                .filter((c) => c.role === "junction")
+                .map((c) => c.table)
+        );
 
-        const tablesMap = buildTablesMap(tables, columns, pks, fks);
-        const joinTables = identifyJoinTables(tablesMap);
+        const roleCount = (role: string) =>
+            Array.from(classifications.values()).filter((c) => c.role === role).length;
 
-        logger.info(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
+        logger.info(chalk.blue(`Found ${tablesMap.size} tables.`));
+        logger.info(chalk.gray(
+            `  ${roleCount("entity")} entities, ${joinTables.size} join tables (folded into relations), ` +
+            `${roleCount("lookup")} code lists, ${roleCount("owned-child")} owned by another table (hidden from navigation).`
+        ));
 
         let runDataInference = false;
         if (args["--no-data-inference"]) {
@@ -224,7 +180,8 @@ async function main() {
                     joinTables,
                     tablesMap,
                     enumMap,
-                    sampleData
+                    sampleData,
+                    { metadata, classifications, checkFacts }
                 );
 
                 fs.writeFileSync(filePath, fileContent, "utf-8");

package/src/services/BranchService.ts

@@ -64,20 +64,41 @@ function validateIdentifier(value: string, label: string): void {
 }
 
 /**
- * Sanitize a user-provided branch name to a safe PostgreSQL identifier.
- * Only allows alphanumeric characters and underscores.
+ * Postgres truncates identifiers at NAMEDATALEN-1 = 63 bytes, and does it
+ * silently. The prefix comes out of the same budget.
  */
-function sanitizeBranchName(name: string): string {
-    return name.replace(/[^a-zA-Z0-9_]/g, "");
+const MAX_BRANCH_NAME_LENGTH = 63 - BRANCH_DB_PREFIX.length;
+
+/**
+ * Check a user-provided branch name, and otherwise leave it exactly as given.
+ *
+ * This used to strip everything outside [a-zA-Z0-9_], so `my-feature` was
+ * quietly created as `myfeature`: the name you typed was not the name `list`
+ * gave back. Nothing ever needed that. Every identifier this service builds is
+ * double-quoted (see `CREATE DATABASE` below), which is what makes a hyphen
+ * safe, and `validateIdentifier` has always accepted hyphens for the `--from`
+ * source database — the two disagreed about the same character class.
+ *
+ * Refusing a name we cannot represent is better than representing a different
+ * one, which is also why the length is checked here rather than left to
+ * Postgres, whose answer to an over-long identifier is a silent rename.
+ */
+function assertValidBranchName(name: string): void {
+    validateIdentifier(name, "branch name");
+    if (name.length > MAX_BRANCH_NAME_LENGTH) {
+        throw new Error(
+            `Branch name "${name}" is too long: ${name.length} characters, maximum ${MAX_BRANCH_NAME_LENGTH}. ` +
+            "Postgres truncates identifiers past 63 bytes, which would give the branch a name you did not choose."
+        );
+    }
 }
 
 /**
  * Convert a user-facing branch name to the actual PostgreSQL database name.
  */
 function toBranchDbName(name: string): string {
-    const sanitized = sanitizeBranchName(name);
-    if (!sanitized) throw new Error("Branch name must contain at least one alphanumeric character.");
-    return `${BRANCH_DB_PREFIX}${sanitized}`;
+    assertValidBranchName(name);
+    return `${BRANCH_DB_PREFIX}${name}`;
 }
 
 export class BranchService {
@@ -120,15 +141,14 @@ export class BranchService {
         }
 
         const dbName = toBranchDbName(name);
-        const sanitizedName = sanitizeBranchName(name);
         const sourceDb = options?.source || this.poolManager.defaultDatabaseName;
 
         // Check if branch already exists
         const existing = await this.db.execute(
-            sql`SELECT name FROM rebase.branches WHERE name = ${sanitizedName} OR db_name = ${dbName}`
+            sql`SELECT name FROM rebase.branches WHERE name = ${name} OR db_name = ${dbName}`
         );
         if ((existing.rows as unknown[]).length > 0) {
-            throw new Error(`Branch "${sanitizedName}" already exists.`);
+            throw new Error(`Branch "${name}" already exists.`);
         }
 
         // Disconnect any idle pools to the source DB so TEMPLATE works.
@@ -158,12 +178,12 @@ export class BranchService {
         // Record metadata in the default database
         const now = new Date();
         await this.db.execute(
-            sql`INSERT INTO rebase.branches (name, db_name, parent_db, created_at) 
-                VALUES (${sanitizedName}, ${dbName}, ${sourceDb}, ${now.toISOString()})`
+            sql`INSERT INTO rebase.branches (name, db_name, parent_db, created_at)
+                VALUES (${name}, ${dbName}, ${sourceDb}, ${now.toISOString()})`
         );
 
         return {
-            name: sanitizedName,
+            name,
             parentDatabase: sourceDb,
             createdAt: now
         };
@@ -174,20 +194,35 @@ export class BranchService {
      * Cannot delete the main/default database.
      */
     async deleteBranch(name: string): Promise<void> {
-        const sanitizedName = sanitizeBranchName(name);
-        const dbName = toBranchDbName(name);
+        assertValidBranchName(name);
 
-        // Safety: never delete the default database
-        if (dbName === this.poolManager.defaultDatabaseName) {
+        // Safety, first pass: a request that would target the default database
+        // is refused before any metadata is read, so the answer costs nothing
+        // and cannot depend on what a row happens to say.
+        if (toBranchDbName(name) === this.poolManager.defaultDatabaseName) {
             throw new Error("Cannot delete the main database.");
         }
 
-        // Verify the branch exists in our metadata
+        // Verify the branch exists, and take the database name from the row
+        // rather than deriving it again. A branch created before names stopped
+        // being stripped is recorded as `rb_myfeature` while `my-feature` now
+        // derives `rb_my-feature`; re-deriving would drop a database this row
+        // never named — or, if that name happened to exist, somebody else's.
+        // The stored value is the only one that is true by construction.
         const existing = await this.db.execute(
-            sql`SELECT db_name FROM rebase.branches WHERE name = ${sanitizedName}`
+            sql`SELECT db_name FROM rebase.branches WHERE name = ${name}`
         );
-        if ((existing.rows as unknown[]).length === 0) {
-            throw new Error(`Branch "${sanitizedName}" not found.`);
+        const existingRows = existing.rows as Record<string, unknown>[];
+        if (existingRows.length === 0) {
+            throw new Error(`Branch "${name}" not found.`);
+        }
+        const dbName = existingRows[0].db_name as string;
+
+        // Safety, second pass: the first checked a name we derived, this checks
+        // the one we are about to drop. They differ for any row written under
+        // the old scheme, and it is this one that governs.
+        if (dbName === this.poolManager.defaultDatabaseName) {
+            throw new Error("Cannot delete the main database.");
         }
 
         // Disconnect any pools to this branch before dropping
@@ -201,7 +236,7 @@ export class BranchService {
             const pgError = extractPgError(err);
             if (pgError?.code === PG_OBJECT_IN_USE) {
                 throw new Error(
-                    `Cannot delete branch "${sanitizedName}": the database has active connections. ` +
+                    `Cannot delete branch "${name}": the database has active connections. ` +
                     "Close other clients and try again."
                 );
             }
@@ -210,7 +245,7 @@ export class BranchService {
 
         // Remove metadata
         await this.db.execute(
-            sql`DELETE FROM rebase.branches WHERE name = ${sanitizedName}`
+            sql`DELETE FROM rebase.branches WHERE name = ${name}`
         );
     }
 
@@ -242,15 +277,16 @@ export class BranchService {
      * Get info about a specific branch.
      */
     async getBranchInfo(name: string): Promise<BranchInfo | undefined> {
-        const sanitizedName = sanitizeBranchName(name);
+        assertValidBranchName(name);
 
         const result = await this.db.execute(sql`
-            SELECT 
+            SELECT
                 b.name,
+                b.db_name,
                 b.parent_db,
                 b.created_at
             FROM rebase.branches b
-            WHERE b.name = ${sanitizedName}
+            WHERE b.name = ${name}
         `);
 
         const rows = result.rows as Record<string, unknown>[];
@@ -258,10 +294,12 @@ export class BranchService {
 
         const row = rows[0];
 
-        // Attempt to get size — may fail if the DB was externally dropped
+        // Attempt to get size — may fail if the DB was externally dropped.
+        // Same reason as `deleteBranch`: the size of a re-derived name is the
+        // size of some other database, or of nothing.
         let sizeBytes: number | undefined;
         try {
-            const dbName = toBranchDbName(sanitizedName);
+            const dbName = row.db_name as string;
             const sizeResult = await this.db.execute(
                 sql`SELECT pg_database_size(${dbName}) as size_bytes`
             );

package/src/services/FetchService.ts

@@ -12,6 +12,7 @@ import {
     requirePrimaryKeys,
     deriveRowAddress,
     parseIdValues,
+    idCanAddressTable,
     buildCompositeId,
     COMPOSITE_ID_SEPARATOR
 } from "./collection-helpers";
@@ -23,6 +24,7 @@ import { PostgresCollectionRegistry } from "../collections/PostgresCollectionReg
 import { toFlatRow, toRestRow, isJunctionRelation } from "./row-pipeline";
 import { isNestedPath, resolveNestedPath, type NestedPathHop } from "./nested-path";
 import { ApiError, logger } from "@rebasepro/server";
+import { reachedDatabase } from "../utils/pg-error-utils";
 
 /** Type-safe accessor for Drizzle's relational query API via dynamic table name */
 type DbQueryAccessor = Record<string, RelationalQueryBuilder<any, any>> | undefined;
@@ -588,6 +590,11 @@ idColumn };
             throw new Error(`ID field '${idInfo.fieldName}' not found in table for collection '${collectionPath}'`);
         }
 
+        // An address the key columns cannot hold names no row — the same answer
+        // as a well-formed id nobody has. Asking Postgres instead raises 22P02
+        // and aborts the transaction around this read.
+        if (!idCanAddressTable(id, table, idInfoArray)) return undefined;
+
         const parsedIdObj = parseIdValues(id, idInfoArray);
         const parsedId = parsedIdObj[idInfo.fieldName];
 
@@ -618,6 +625,7 @@ idColumn };
                     logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
+                if (reachedDatabase(e)) throw e;
                 logger.warn(`[FetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select`, { error: e });
             }
         }
@@ -743,6 +751,7 @@ idColumn };
                     logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
+                if (reachedDatabase(e)) throw e;
                 logger.warn(`[FetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select`, { error: e });
             }
         }
@@ -1173,6 +1182,7 @@ relatedTo: hop }, include
                     logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
+                if (reachedDatabase(e)) throw e;
                 logger.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back`, { error: e });
             }
         }
@@ -1246,6 +1256,9 @@ relatedTo: hop }, include
         const idInfo = idInfoArray[0];
         const idField = table[idInfo.fieldName as keyof typeof table] as AnyPgColumn;
 
+        // See `fetchOne`: an unaddressable id is a 404, not a database error.
+        if (!idCanAddressTable(id, table, idInfoArray)) return null;
+
         const parsedIdObj = parseIdValues(id, idInfoArray);
         const parsedId = parsedIdObj[idInfo.fieldName];
 
@@ -1279,6 +1292,7 @@ relatedTo: hop }, include
                     logger.error(`[FetchService] ResolvedRelation inference error for collection '${collectionPath}': ${e.message}`);
                     logger.error("Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.");
                 }
+                if (reachedDatabase(e)) throw e;
                 logger.warn(`[fetchOneForRest] db.query.findFirst failed for ${collectionPath}, falling back`, { error: e });
             }
         }

package/src/services/PersistService.ts

@@ -1,7 +1,7 @@
 import { eq, and, sql, SQL } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
 // import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { CollectionConfig, Properties, ResolvedRelation, type ResolvedManyToMany, isManyToMany } from "@rebasepro/types";
+import { CollectionConfig, Properties, ResolvedRelation, type ResolvedManyToMany, isManyToMany, hasForeignKeyOnTarget } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
 import {
@@ -240,16 +240,30 @@ export class PersistService {
                     throw ApiError.notFound(`No row "${id}" in "${collectionPath}" to update.`);
                 }
             } else {
-                // One-to-many create: stamp the parent's id onto the child's FK.
+                // One-to-many create: stamp the parent's key onto the child's FK.
                 const targetColumnName = this.resolveParentForeignKeyColumn(hop);
 
                 if (targetColumnName) {
-                    const parsedParentId = parentIdForWrite();
+                    // Not necessarily the id in the path: a link with a
+                    // `sourceKey` is pointed at a column on the parent row, and
+                    // stamping the id would create a child that belongs to
+                    // nobody — a row the read path would never return again.
+                    const parentKeyValue = hasForeignKeyOnTarget(hop.relation)
+                        ? await this.relationService.parentKeyValue(hop.parentCollection, hop.relation, hop.parentId)
+                        : parentIdForWrite();
+
+                    if (parentKeyValue === undefined) {
+                        throw ApiError.badRequest(
+                            `Cannot create under "${collectionPath}": the parent row has no value in ` +
+                            `\`sourceKey\`, so the new row has nothing to point at.`
+                        );
+                    }
+
                     const existingValue = (effectiveValues as Record<string, unknown>)[targetColumnName];
-                    if (existingValue !== undefined && existingValue !== null && existingValue !== parsedParentId) {
-                        logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent id '${parsedParentId}'.`);
+                    if (existingValue !== undefined && existingValue !== null && existingValue !== parentKeyValue) {
+                        logger.warn(`Overriding provided value '${existingValue}' for FK '${targetColumnName}' with path parent key '${parentKeyValue}'.`);
                     }
-                    (effectiveValues as Record<string, unknown>)[targetColumnName] = parsedParentId;
+                    (effectiveValues as Record<string, unknown>)[targetColumnName] = parentKeyValue;
                 }
             }
         }