@rebasepro/server-postgresql 0.1.2 → 0.2.3

package/src/schema/default-collections.ts

@@ -0,0 +1,69 @@
+import { PostgresCollection } from "@rebasepro/types";
+
+export const defaultUsersCollection: PostgresCollection = {
+    name: "Users",
+    singularName: "User",
+    slug: "users",
+    table: "users",
+    schema: "rebase",
+    icon: "Users",
+    group: "Settings",
+    properties: {
+        id: {
+            name: "ID",
+            type: "string",
+            isId: "uuid"
+        },
+        email: {
+            name: "Email",
+            type: "string",
+            validation: { required: true, unique: true }
+        },
+        password_hash: {
+            name: "Password Hash",
+            type: "string",
+            ui: { hideFromCollection: true }
+        },
+        display_name: {
+            name: "Display Name",
+            type: "string"
+        },
+        photo_url: {
+            name: "Photo URL",
+            type: "string"
+        },
+        email_verified: {
+            name: "Email Verified",
+            type: "boolean",
+            defaultValue: false
+        },
+        email_verification_token: {
+            name: "Email Verification Token",
+            type: "string",
+            ui: { hideFromCollection: true }
+        },
+        email_verification_sent_at: {
+            name: "Email Verification Sent At",
+            type: "date",
+            ui: { hideFromCollection: true }
+        },
+        metadata: {
+            name: "Metadata",
+            type: "map",
+            defaultValue: {},
+            ui: { hideFromCollection: true }
+        },
+        created_at: {
+            name: "Created At",
+            type: "date",
+            autoValue: "on_create",
+            ui: { readOnly: true, hideFromCollection: true }
+        },
+        updated_at: {
+            name: "Updated At",
+            type: "date",
+            autoValue: "on_update",
+            ui: { readOnly: true, hideFromCollection: true }
+        }
+    }
+};

package/src/schema/doctor-cli.ts

@@ -5,14 +5,17 @@
  */
 import path from "path";
 import chalk from "chalk";
+import fs from "fs";
 import { runDoctor } from "./doctor";
 
 async function main() {
     const collectionsArg = process.argv.find((a) => a.startsWith("--collections="));
     const schemaArg = process.argv.find((a) => a.startsWith("--schema="));
+    const sdkArg = process.argv.find((a) => a.startsWith("--sdk="));
 
-    const collectionsPath = collectionsArg?.split("=")[1] ?? path.join("..", "shared", "collections");
+    const collectionsPath = collectionsArg?.split("=")[1] ?? path.join("..", "config", "collections");
     const schemaPath = schemaArg?.split("=")[1] ?? path.join("src", "schema.generated.ts");
+    const sdkPath = sdkArg?.split("=")[1] ?? path.join("..", "generated", "sdk", "database.types.ts");
 
     // Load .env
     try {
@@ -32,6 +35,7 @@ async function main() {
     const report = await runDoctor({
         collectionsPath: path.resolve(process.cwd(), collectionsPath),
         schemaPath: path.resolve(process.cwd(), schemaPath),
+        sdkPath: path.resolve(process.cwd(), sdkPath),
         databaseUrl: databaseUrl ?? undefined
     });
 

package/src/schema/doctor.ts

@@ -14,6 +14,7 @@ import { pathToFileURL } from "url";
 import chalk from "chalk";
 import { EntityCollection, isPostgresCollection, Property, NumberProperty, StringProperty, DateProperty, ArrayProperty, MapProperty, RelationProperty } from "@rebasepro/types";
 import { generateSchema } from "./generate-drizzle-schema-logic";
+import { generateTypedefs } from "@rebasepro/sdk-generator";
 import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 
@@ -35,7 +36,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";
+    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;
@@ -46,6 +47,7 @@ export interface DoctorIssue {
 
 export interface DoctorReport {
     collectionsToSchema: { passed: boolean; issues: DoctorIssue[] };
+    collectionsToSdk: { passed: boolean; issues: DoctorIssue[] };
     schemaToDatabase: { passed: boolean; issues: DoctorIssue[] };
     summary: { passed: number; warnings: number; errors: number };
 }
@@ -92,6 +94,10 @@ export function getExpectedColumnType(prop: Property): string | null {
             return null; // FK columns are derived from the relation, not from the property
         case "reference":
             return "character varying"; // References default to varchar FK
+        case "vector":
+            return "USER-DEFINED";
+        case "binary":
+            return "bytea";
         default:
             return null;
     }
@@ -139,6 +145,9 @@ export async function loadCollections(collectionsPath: string): Promise<EntityCo
         }
     }
 
+    // Sort collections by slug alphabetically to ensure deterministic comparison
+    collections.sort((a, b) => a.slug.localeCompare(b.slug));
+
     return collections;
 }
 
@@ -203,9 +212,61 @@ issues };
 issues };
 }
 
+export async function checkCollectionsVsSdk(
+    collections: EntityCollection[],
+    sdkFilePath: string
+): Promise<{ passed: boolean; issues: DoctorIssue[] }> {
+    const issues: DoctorIssue[] = [];
+
+    // Check if SDK file exists
+    if (!fs.existsSync(sdkFilePath)) {
+        issues.push({
+            severity: "warning",
+            category: "sdk_stale",
+            message: `Generated SDK typedefs file does not exist at "${sdkFilePath}".`,
+            fix: "Run `rebase generate-sdk`"
+        });
+        return { passed: false, issues };
+    }
+
+    try {
+        const expectedSdk = generateTypedefs(collections);
+        const actualSdk = await fsPromises.readFile(sdkFilePath, "utf-8");
+
+        // Normalize whitespace for comparison
+        const normalize = (s: string) =>
+            s
+                .replace(/\/\/.*$/gm, "") // strip single-line comments
+                .replace(/\/\*[\s\S]*?\*\//g, "") // strip multi-line comments
+                .replace(/\s+/g, " ")
+                .trim();
+
+        if (normalize(expectedSdk) !== normalize(actualSdk)) {
+            issues.push({
+                severity: "warning",
+                category: "sdk_stale",
+                message: "Generated SDK types are out of date — collection definitions have changed since last SDK generation.",
+                fix: "Run `rebase generate-sdk`"
+            });
+        }
+    } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        issues.push({
+            severity: "warning",
+            category: "sdk_stale",
+            message: `Could not regenerate SDK types for comparison: ${message}`,
+            fix: "Run `rebase generate-sdk` to verify"
+        });
+    }
+
+    return { passed: issues.length === 0, issues };
+}
+
 // ── Phase 2: Collections ↔ Database ──────────────────────────────────────
 
 interface DbColumn {
+    table_schema: string;
+    table_name: string;
     column_name: string;
     data_type: string;
     is_nullable: string;
@@ -229,27 +290,45 @@ export async function checkCollectionsVsDatabase(
     const { Pool } = pgModule.default ?? pgModule;
     const pool = new Pool({ connectionString: databaseUrl });
 
+    // Determine all schemas defined by the collections, plus public and rebase
+    const schemas = Array.from(new Set([
+        "public",
+        "rebase",
+        ...collections
+            .filter(isPostgresCollection)
+            .map(c => c.schema)
+            .filter((s): s is string => !!s)
+    ]));
+
     try {
-        // Fetch all tables in the public schema
-        const tablesResult = await pool.query<{ table_name: string }>(
-            "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'"
+        // Fetch all tables in the defined schemas
+        const tablesResult = await pool.query<{ table_schema: string; table_name: string }>(
+            `SELECT table_schema, table_name 
+             FROM information_schema.tables 
+             WHERE table_schema = ANY($1) AND table_type = 'BASE TABLE'`,
+            [schemas]
         );
-        const existingTables = new Set(tablesResult.rows.map((r) => r.table_name));
+        const existingTables = new Set(tablesResult.rows.map((r) => 
+            r.table_schema === "public" ? r.table_name : `${r.table_schema}.${r.table_name}`
+        ));
 
-        // Fetch all columns
+        // Fetch all columns in the defined schemas
         const columnsResult = await pool.query<DbColumn>(
-            `SELECT table_name, column_name, data_type, is_nullable, udt_name
+            `SELECT table_schema, table_name, column_name, data_type, is_nullable, udt_name
              FROM information_schema.columns
-             WHERE table_schema = 'public'
-             ORDER BY table_name, ordinal_position`
+             WHERE table_schema = ANY($1)
+             ORDER BY table_schema, table_name, ordinal_position`,
+            [schemas]
         );
         const columnsByTable = new Map<string, DbColumn[]>();
         for (const row of columnsResult.rows) {
-            const tableName = (row as unknown as Record<string, string>).table_name;
-            if (!columnsByTable.has(tableName)) {
-                columnsByTable.set(tableName, []);
+            const tableSchema = row.table_schema;
+            const tableName = row.table_name;
+            const key = tableSchema === "public" ? tableName : `${tableSchema}.${tableName}`;
+            if (!columnsByTable.has(key)) {
+                columnsByTable.set(key, []);
             }
-            columnsByTable.get(tableName)!.push(row);
+            columnsByTable.get(key)!.push(row);
         }
 
         // Fetch enums
@@ -267,18 +346,22 @@ export async function checkCollectionsVsDatabase(
             enumsByName.get(row.enum_name)!.push(row.enum_value);
         }
 
-        // Fetch foreign key constraints
+        // Fetch foreign key constraints in the defined schemas
         const fksResult = await pool.query<{
             constraint_name: string;
+            table_schema: string;
             table_name: string;
             column_name: string;
+            foreign_table_schema: string;
             foreign_table_name: string;
             foreign_column_name: string;
         }>(
             `SELECT
                 tc.constraint_name,
+                tc.table_schema,
                 tc.table_name,
                 kcu.column_name,
+                ccu.table_schema AS foreign_table_schema,
                 ccu.table_name AS foreign_table_name,
                 ccu.column_name AS foreign_column_name
              FROM information_schema.table_constraints AS tc
@@ -286,14 +369,18 @@ export async function checkCollectionsVsDatabase(
                  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 = 'public'`
+             WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = ANY($1)`,
+            [schemas]
         );
         const fksByTable = new Map<string, typeof fksResult.rows>();
         for (const row of fksResult.rows) {
-            if (!fksByTable.has(row.table_name)) {
-                fksByTable.set(row.table_name, []);
+            const tableSchema = row.table_schema;
+            const tableName = row.table_name;
+            const key = tableSchema === "public" ? tableName : `${tableSchema}.${tableName}`;
+            if (!fksByTable.has(key)) {
+                fksByTable.set(key, []);
             }
-            fksByTable.get(row.table_name)!.push(row);
+            fksByTable.get(key)!.push(row);
         }
 
         // ── Compare each collection against the database ─────────────────
@@ -302,20 +389,22 @@ export async function checkCollectionsVsDatabase(
 
         for (const collection of postgresCollections) {
             const tableName = getTableName(collection);
+            const schemaName = collection.schema || "public";
+            const fullTableName = schemaName === "public" ? tableName : `${schemaName}.${tableName}`;
 
             // Check table existence
-            if (!existingTables.has(tableName)) {
+            if (!existingTables.has(fullTableName)) {
                 issues.push({
                     severity: "error",
                     category: "missing_table",
-                    table: tableName,
-                    message: `Table "${tableName}" does not exist in the database.`,
+                    table: fullTableName,
+                    message: `Table "${fullTableName}" does not exist in the database.`,
                     fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                 });
                 continue; // Skip column checks for missing tables
             }
 
-            const dbColumns = columnsByTable.get(tableName) ?? [];
+            const dbColumns = columnsByTable.get(fullTableName) ?? [];
             const dbColumnMap = new Map(dbColumns.map((c) => [c.column_name, c]));
 
             // System columns that Rebase always creates
@@ -333,27 +422,36 @@ export async function checkCollectionsVsDatabase(
                             issues.push({
                                 severity: "error",
                                 category: "missing_column",
-                                table: tableName,
+                                table: fullTableName,
                                 column: fkColName,
-                                message: `Foreign key column "${fkColName}" for relation "${propName}" is missing from table "${tableName}".`,
+                                message: `Foreign key column "${fkColName}" for relation "${propName}" is missing from table "${fullTableName}".`,
                                 fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                             });
                         }
 
                         // Check FK constraint exists
-                        const tableFks = fksByTable.get(tableName) ?? [];
-                        const hasFk = tableFks.some((fk) => fk.column_name === fkColName);
+                        const tableFks = fksByTable.get(fullTableName) ?? [];
+                        let targetTableName = "unknown";
+                        let targetSchemaName = "public";
+                        try {
+                            const targetColl = relation.target();
+                            targetTableName = getTableName(targetColl);
+                            targetSchemaName = targetColl.schema || "public";
+                        } catch { /* ignore */ }
+
+                        const hasFk = tableFks.some((fk) => 
+                            fk.column_name === fkColName && 
+                            fk.foreign_table_name === targetTableName &&
+                            fk.foreign_table_schema === targetSchemaName
+                        );
+
                         if (dbColumnMap.has(fkColName) && !hasFk) {
-                            let targetTableName = "unknown";
-                            try {
-                                targetTableName = getTableName(relation.target());
-                            } catch { /* ignore */ }
                             issues.push({
                                 severity: "warning",
                                 category: "missing_foreign_key",
-                                table: tableName,
+                                table: fullTableName,
                                 column: fkColName,
-                                message: `Column "${fkColName}" exists but has no FOREIGN KEY constraint referencing "${targetTableName}".`,
+                                message: `Column "${fkColName}" exists but has no FOREIGN KEY constraint referencing "${targetSchemaName === "public" ? targetTableName : `${targetSchemaName}.${targetTableName}`}".`,
                                 fix: "Run `rebase db push` or add the constraint manually"
                             });
                         }
@@ -371,9 +469,9 @@ export async function checkCollectionsVsDatabase(
                     issues.push({
                         severity: "error",
                         category: "missing_column",
-                        table: tableName,
+                        table: fullTableName,
                         column: colName,
-                        message: `Column "${colName}" is defined in collection "${collection.slug}" but missing from table "${tableName}".`,
+                        message: `Column "${colName}" is defined in collection "${collection.slug}" but missing from table "${fullTableName}".`,
                         fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                     });
                     continue;
@@ -383,15 +481,19 @@ export async function checkCollectionsVsDatabase(
                 const expectedType = getExpectedColumnType(prop);
                 if (expectedType) {
                     const actualType = dbCol.data_type;
-                    if (actualType !== expectedType) {
+                    let isMismatch = actualType !== expectedType;
+                    if (prop.type === "vector" && dbCol.udt_name !== "vector") {
+                        isMismatch = true;
+                    }
+                    if (isMismatch) {
                         issues.push({
                             severity: "warning",
                             category: "type_mismatch",
-                            table: tableName,
+                            table: fullTableName,
                             column: colName,
-                            expected: expectedType,
-                            actual: actualType,
-                            message: `Column "${colName}" in table "${tableName}": expected type "${expectedType}" but found "${actualType}".`,
+                            expected: prop.type === "vector" ? "vector" : expectedType,
+                            actual: dbCol.udt_name === "vector" ? "vector" : actualType,
+                            message: `Column "${colName}" in table "${fullTableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${dbCol.udt_name === "vector" ? "vector" : actualType}".`,
                             fix: "Review collection property type or run a migration"
                         });
                     }
@@ -407,7 +509,7 @@ export async function checkCollectionsVsDatabase(
                             issues.push({
                                 severity: "warning",
                                 category: "missing_enum",
-                                table: tableName,
+                                table: fullTableName,
                                 column: colName,
                                 expected: enumName,
                                 message: `Enum type "${enumName}" is defined in collection but not found in the database.`,
@@ -429,11 +531,11 @@ export async function checkCollectionsVsDatabase(
                                 issues.push({
                                     severity: "warning",
                                     category: "enum_value_mismatch",
-                                    table: tableName,
+                                    table: fullTableName,
                                     column: colName,
                                     expected: expectedValues.join(", "),
                                     actual: dbEnumValues.join(", "),
-                                    message: `Enum values for "${colName}" in table "${tableName}" are out of sync (${parts.join("; ")}).`,
+                                    message: `Enum values for "${colName}" in table "${fullTableName}" are out of sync (${parts.join("; ")}).`,
                                     fix: "Run `rebase db push` to update the enum"
                                 });
                             }
@@ -447,12 +549,14 @@ export async function checkCollectionsVsDatabase(
             for (const relation of Object.values(resolvedRelations)) {
                 if (relation.cardinality === "many" && relation.direction === "owning" && relation.through) {
                     const junctionTable = relation.through.table;
-                    if (!existingTables.has(junctionTable)) {
+                    const junctionSchema = collection.schema || "public";
+                    const fullJunctionTable = junctionSchema === "public" ? junctionTable : `${junctionSchema}.${junctionTable}`;
+                    if (!existingTables.has(fullJunctionTable)) {
                         issues.push({
                             severity: "error",
                             category: "missing_table",
-                            table: junctionTable,
-                            message: `Junction table "${junctionTable}" for many-to-many relation "${relation.relationName}" is missing.`,
+                            table: fullJunctionTable,
+                            message: `Junction table "${fullJunctionTable}" for many-to-many relation "${relation.relationName}" is missing.`,
                             fix: "Run `rebase db push` or `rebase db generate && rebase db migrate`"
                         });
                     }
@@ -489,6 +593,13 @@ export function renderReport(report: DoctorReport): void {
         report.schemaToDatabase.issues
     );
 
+    // Phase 3
+    renderPhase(
+        "Collections → SDK Types",
+        report.collectionsToSdk.passed,
+        report.collectionsToSdk.issues
+    );
+
     // Summary
     console.log(chalk.gray("  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
     const { passed, warnings, errors } = report.summary;
@@ -554,7 +665,8 @@ function formatCategory(cat: DoctorIssue["category"]): string {
         schema_stale: "Stale Schema",
         missing_enum: "Missing Enum",
         enum_value_mismatch: "Enum Value Mismatch",
-        missing_foreign_key: "Missing Foreign Key"
+        missing_foreign_key: "Missing Foreign Key",
+        sdk_stale: "Stale SDK Types"
     };
     return labels[cat];
 }
@@ -564,6 +676,7 @@ function formatCategory(cat: DoctorIssue["category"]): string {
 export async function runDoctor(options: {
     collectionsPath: string;
     schemaPath: string;
+    sdkPath: string;
     databaseUrl?: string;
 }): Promise<DoctorReport> {
     console.log("");
@@ -591,14 +704,19 @@ issues: [] };
         console.log(chalk.gray("    Set DATABASE_URL in your .env to enable full drift detection."));
     }
 
-    const allIssues = [...collectionsToSchema.issues, ...schemaToDatabase.issues];
+    // Phase 3: Collections ↔ SDK Types
+    console.log(chalk.gray("  Checking Collections → SDK Types..."));
+    const collectionsToSdk = await checkCollectionsVsSdk(collections, options.sdkPath);
+
+    const allIssues = [...collectionsToSchema.issues, ...schemaToDatabase.issues, ...collectionsToSdk.issues];
     const summary = {
-        passed: [collectionsToSchema, schemaToDatabase].filter((p) => p.passed).length,
+        passed: [collectionsToSchema, schemaToDatabase, collectionsToSdk].filter((p) => p.passed).length,
         warnings: allIssues.filter((i) => i.severity === "warning").length,
         errors: allIssues.filter((i) => i.severity === "error").length
     };
 
     const report: DoctorReport = { collectionsToSchema,
+collectionsToSdk,
 schemaToDatabase,
 summary };
     renderReport(report);