@rebasepro/server-postgres 0.9.1-canary.97e305f → 0.9.1-canary.a57c262

package/src/schema/doctor.ts

@@ -37,7 +37,7 @@ export type IssueSeverity = "error" | "warning" | "info";
 
 export interface DoctorIssue {
     severity: IssueSeverity;
-    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale" | "sdk_not_generated";
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale";
     table?: string;
     column?: string;
     expected?: string;
@@ -61,29 +61,19 @@ export function getExpectedColumnType(prop: Property): string | null {
             const sp = prop as StringProperty;
             if (sp.enum) return "USER-DEFINED"; // pgEnum → USER-DEFINED in information_schema
             if ("isId" in sp && sp.isId === "uuid") return "uuid";
-            if (sp.columnType === "uuid") return "uuid";
-            // A markdown/multiline string compiles to `text`, not varchar — the
-            // generator treats those UI hints as column-type signals, so the
-            // expectation here must too or every such column reads as drift.
-            if (sp.columnType === "text" || sp.ui?.markdown || sp.ui?.multiline) return "text";
+            if (sp.columnType === "text") return "text";
             if (sp.columnType === "char") return "character";
             return "character varying";
         }
         case "number": {
             const np = prop as NumberProperty;
-            if (np.columnType) {
-                // The generator passes any columnType straight through to drizzle,
-                // so mirror that rather than enumerating a subset (which reported
-                // drift for anything unlisted, e.g. smallint). Serial types are
-                // integers with a sequence default; information_schema reports the
-                // underlying width.
-                const serialWidths: Record<string, string> = {
-                    serial: "integer",
-                    bigserial: "bigint",
-                    smallserial: "smallint"
-                };
-                return serialWidths[np.columnType] ?? np.columnType;
-            }
+            if (np.columnType === "double precision") return "double precision";
+            if (np.columnType === "real") return "real";
+            if (np.columnType === "bigint") return "bigint";
+            if (np.columnType === "serial") return "integer"; // serial is integer under the hood
+            if (np.columnType === "bigserial") return "bigint";
+            if (np.columnType === "integer") return "integer";
+            if (np.columnType === "numeric") return "numeric";
             if (np.validation?.integer || ("isId" in np && np.isId)) return "integer";
             return "numeric";
         }
@@ -211,18 +201,15 @@ export async function checkCollectionsVsSdk(
 ): Promise<{ passed: boolean; issues: DoctorIssue[] }> {
     const issues: DoctorIssue[] = [];
 
-    // The typed SDK is opt-in — nothing in a scaffolded project imports it until
-    // you choose to. A project that never generated one isn't drifting, so report
-    // it as information rather than a warning; otherwise `doctor` can never come
-    // back clean on a fresh project and users learn to ignore its output.
+    // Check if SDK file exists
     if (!fs.existsSync(sdkFilePath)) {
         issues.push({
-            severity: "info",
-            category: "sdk_not_generated",
-            message: "Typed SDK not generated (optional).",
-            fix: "Run `rebase generate-sdk` if you want typed collection access"
+            severity: "warning",
+            category: "sdk_stale",
+            message: `Generated SDK typedefs file does not exist at "${sdkFilePath}".`,
+            fix: "Run `rebase generate-sdk`"
         });
-        return { passed: true,
+        return { passed: false,
 issues };
     }
 
@@ -644,15 +631,11 @@ export function renderReport(report: DoctorReport): void {
 }
 
 function renderPhase(label: string, passed: boolean, issues: DoctorIssue[]): void {
-    const errorCount = issues.filter((i) => i.severity === "error").length;
-    const warnCount = issues.filter((i) => i.severity === "warning").length;
-    const infoIssues = issues.filter((i) => i.severity === "info");
-
-    // Informational notes don't make a phase unhealthy, so key the header off
-    // real problems rather than `passed` alone.
-    if (errorCount === 0 && warnCount === 0) {
+    if (passed) {
         logger.info(`  ${chalk.green("✅")} ${label}: ${chalk.green("In sync")}`);
     } else {
+        const errorCount = issues.filter((i) => i.severity === "error").length;
+        const warnCount = issues.filter((i) => i.severity === "warning").length;
         const parts: string[] = [];
         if (errorCount > 0) parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
         if (warnCount > 0) parts.push(`${warnCount} warning${warnCount > 1 ? "s" : ""}`);
@@ -660,14 +643,7 @@ function renderPhase(label: string, passed: boolean, issues: DoctorIssue[]): voi
     }
     logger.info("");
 
-    // Notes render as a quiet one-liner, not a full drift box.
-    for (const issue of infoIssues) {
-        const fixPart = issue.fix ? chalk.gray(` — ${issue.fix}`) : "";
-        logger.info(`  ${chalk.gray("ℹ")} ${chalk.gray(issue.message)}${fixPart}`);
-        logger.info("");
-    }
-
-    for (const issue of issues.filter((i) => i.severity !== "info")) {
+    for (const issue of issues) {
         const severityIcon = issue.severity === "error" ? chalk.red("✗") : chalk.yellow("⚠");
         const categoryLabel = formatCategory(issue.category);
         logger.info(`  ${chalk.gray("┌─")} ${severityIcon} ${chalk.bold(categoryLabel)} ${chalk.gray("─".repeat(Math.max(0, 42 - categoryLabel.length)))}`);
@@ -698,8 +674,7 @@ function formatCategory(cat: DoctorIssue["category"]): string {
         missing_enum: "Missing Enum",
         enum_value_mismatch: "Enum Value Mismatch",
         missing_foreign_key: "Missing Foreign Key",
-        sdk_stale: "Stale SDK Types",
-        sdk_not_generated: "SDK Types Not Generated"
+        sdk_stale: "Stale SDK Types"
     };
     return labels[cat];
 }

package/src/schema/introspect-db.ts

@@ -243,17 +243,7 @@ async function main() {
                 const merged = mergeIndexContent(existing, generatedFiles);
                 fs.writeFileSync(indexPath, merged, "utf-8");
             } else {
-                // --force replaces collections derived from the database, but the
-                // directory can also hold hand-written ones with no table in the
-                // introspected schema (the auth users collection lives in
-                // "rebase"). The backend discovers the whole directory, so an
-                // index listing only introspected tables would silently drop them
-                // from the admin UI while the API still served them.
-                const siblings = fs.readdirSync(outDir)
-                    .filter(f => f.endsWith(".ts") && f !== "index.ts")
-                    .map(f => f.replace(/\.ts$/, ""));
-                const allFiles = [...new Set([...generatedFiles, ...siblings])];
-                const indexContent = generateIndexContent(allFiles);
+                const indexContent = generateIndexContent(generatedFiles);
                 fs.writeFileSync(indexPath, indexContent, "utf-8");
             }
             logger.info(chalk.green(`  ✓ ${indexPath}`));

package/src/services/PersistService.ts

@@ -383,15 +383,8 @@ export class PersistService {
             throw this.toUserFriendlyError(error, collection.slug);
         }
 
-        // Fetch the saved row back through the same walk `GET /:id` serves, so a
-        // write's answer is the read that follows it. This used to be `fetchOne`
-        // — the admin view-model walk — whose `__type: "relation"` refs then
-        // leaked into REST responses, afterSave callbacks, history records and
-        // app-level realtime payloads, none of which see that shape from any
-        // read path. The admin does not need them here either: its rows arrive
-        // over the realtime subscription refetch, which still serves the
-        // view-model walk.
-        const finalEntity = await this.fetchService.fetchOneForRest(collection.slug, savedId, undefined, databaseId);
+        // Fetch the updated/created row to return with proper relation objects
+        const finalEntity = await this.fetchService.fetchOne<M>(collection.slug, savedId, databaseId);
         if (!finalEntity) throw new Error("Could not fetch row after save.");
         return finalEntity;
     }

package/src/services/row-pipeline.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig, Property, Relation } from "@rebasepro/types";
+import { CollectionConfig, Relation } from "@rebasepro/types";
 import { resolveCollectionRelations, findRelation, createRelationRefWithData } from "@rebasepro/common";
 import { normalizeDbValues } from "../data-transformer";
 import { deriveRowAddress } from "./collection-helpers";
@@ -54,67 +54,7 @@ function unwrapJunctionRow(item: Record<string, unknown>): Record<string, unknow
     return nestedKey ? item[nestedKey] as Record<string, unknown> : item;
 }
 
-/**
- * Give back the number a `number` property was declared to be.
- *
- * Postgres returns NUMERIC as a string and drizzle keeps it that way, since a
- * numeric can hold more precision than a double. But the collection declared
- * this property `number` and the OpenAPI spec this server publishes says
- * `type: number`, so serving `"9.99"` breaks its own contract — and breaks it
- * asymmetrically, because a create answers with the number and the read that
- * follows answers with the string. Any client that multiplies a price works
- * until the first refresh.
- *
- * Declaring a property `number` already accepts double precision — that is what
- * the admin has always parsed it to. Columns REST serves that no property
- * declares are left exactly as the database returned them.
- */
-function coerceDeclaredNumber(value: unknown, property: Property | undefined): unknown {
-    if (property?.type !== "number" || typeof value !== "string") return value;
-    const parsed = parseFloat(value);
-    return isNaN(parsed) ? null : parsed;
-}
-
-/** Apply {@link coerceDeclaredNumber} across a row, leaving every other column alone. */
-function coerceDeclaredNumbers(
-    row: Record<string, unknown>,
-    collection: CollectionConfig
-): Record<string, unknown> {
-    const properties = collection.properties;
-    if (!properties) return row;
-
-    const out: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(row)) {
-        out[key] = coerceDeclaredNumber(value, properties[key] as Property | undefined);
-    }
-    return out;
-}
-
 /** Render one target row in the requested style. */
-/**
- * Drop every column the collection marked `excludeFromApi`.
- *
- * Password hashes and verification tokens have to be readable server-side but
- * must never reach a client — and "never" has to mean every exit from this
- * pipeline, including relation targets, or a secret leaks through whichever
- * path was overlooked. Keyed by both the property name and its column name,
- * since a row can arrive keyed either way depending on the caller.
- */
-function stripExcluded(
-    row: Record<string, unknown>,
-    collection: CollectionConfig
-): Record<string, unknown> {
-    const properties = collection.properties as Record<string, Property> | undefined;
-    if (!properties) return row;
-
-    for (const [key, property] of Object.entries(properties)) {
-        if (!property?.excludeFromApi) continue;
-        delete row[key];
-        if (property.columnName) delete row[property.columnName];
-    }
-    return row;
-}
-
 function renderTarget(
     targetRow: Record<string, unknown>,
     targetCollection: CollectionConfig,
@@ -124,7 +64,7 @@ function renderTarget(
     if (style === "inline") {
         // The target's columns, and only those: its address is the consumer's
         // to derive, and merging one in overwrites a real `id` column.
-        return stripExcluded(coerceDeclaredNumbers({ ...targetRow }, targetCollection), targetCollection);
+        return { ...targetRow };
     }
 
     const address = relationTargetAddress(targetRow, targetCollection, registry);
@@ -192,18 +132,15 @@ export function toCmsRow(
         }
     }
 
-    return stripExcluded(normalized, collection);
+    return normalized;
 }
 
 /**
  * The row REST serves: every column under its own name, with the value Postgres
  * returned, and relations inlined as the target's columns.
  *
- * Values are the ones the database returned, except where that contradicts the
- * declared type: a `number` property is served as a number (see
- * {@link coerceDeclaredNumber}). Dates stay as the database returned them —
- * JSON has its own opinions about dates that the admin's view-model does not
- * share.
+ * Deliberately not normalized: REST serves what the database holds, and JSON
+ * has its own opinions about dates that the admin's view-model does not share.
  *
  * Keyed by the row rather than by the relation list — a REST fetch only loads
  * the relations `include` asked for, so the row is the authority on which are
@@ -231,9 +168,9 @@ export function toRestRow(
         } else if (relation && typeof value === "object" && value !== null) {
             flat[key] = renderTarget(value as Record<string, unknown>, relation.target(), "inline", registry);
         } else {
-            flat[key] = coerceDeclaredNumber(value, collection.properties?.[key] as Property | undefined);
+            flat[key] = value;
         }
     }
 
-    return stripExcluded(flat, collection);
+    return flat;
 }

package/src/utils/drizzle-conditions.ts

@@ -1126,19 +1126,6 @@ export class DrizzleConditionBuilder {
             throw new Error(`Vector column '${vectorSearch.property}' not found in table`);
         }
 
-        // The vector is interpolated as a raw SQL literal below (pgvector has no
-        // bind form for the `::vector` cast), so every element must be a finite
-        // number. The REST query parser already enforces this, but this builder
-        // is a shared entry point — validate here too so no future caller can
-        // turn an unchecked value into SQL injection.
-        if (
-            !Array.isArray(vectorSearch.vector) ||
-            vectorSearch.vector.length === 0 ||
-            !vectorSearch.vector.every((n) => typeof n === "number" && Number.isFinite(n))
-        ) {
-            throw new Error("Vector search requires a non-empty array of finite numbers");
-        }
-
         const vectorLiteral = `'[${vectorSearch.vector.join(",")}]'::vector`;
         const distanceFn = vectorSearch.distance || "cosine";