@rebasepro/server-postgresql 0.2.1 → 0.2.3

package/dist/types/src/controllers/data.d.ts

@@ -76,6 +76,21 @@ export interface FindResponse<M extends Record<string, unknown> = Record<string,
         hasMore: boolean;
     };
 }
+export type FilterOperator = WhereFilterOpShort;
+/**
+ * Fluent Query Builder Interface supported on both client and server accessors.
+ * @group Data
+ */
+export interface QueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): this;
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    search(searchString: string): this;
+    include(...relations: string[]): this;
+    find(): Promise<FindResponse<M>>;
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
+}
 /**
  * A single collection's CRUD accessor.
  *
@@ -124,6 +139,12 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
      * Count the number of records matching the given filter.
      */
     count?(params?: FindParams): Promise<number>;
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): QueryBuilderInterface<M>;
+    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilderInterface<M>;
+    limit(count: number): QueryBuilderInterface<M>;
+    offset(count: number): QueryBuilderInterface<M>;
+    search(searchString: string): QueryBuilderInterface<M>;
+    include(...relations: string[]): QueryBuilderInterface<M>;
 }
 /**
  * The unified data access object.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -43,6 +43,7 @@
       "node"
     ],
     "moduleNameMapper": {
+      "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
       "^@rebasepro/common$": "<rootDir>/../common/src/index.ts",
       "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
       "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
@@ -67,11 +68,11 @@
     "hono": "^4.12.21",
     "pg": "^8.21.0",
     "ws": "^8.20.1",
-    "@rebasepro/sdk-generator": "0.2.1",
-    "@rebasepro/common": "0.2.1",
-    "@rebasepro/types": "0.2.1",
-    "@rebasepro/server-core": "0.2.1",
-    "@rebasepro/utils": "0.2.1"
+    "@rebasepro/common": "0.2.3",
+    "@rebasepro/server-core": "0.2.3",
+    "@rebasepro/types": "0.2.3",
+    "@rebasepro/utils": "0.2.3",
+    "@rebasepro/sdk-generator": "0.2.3"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/PostgresBackendDriver.ts

@@ -117,7 +117,7 @@ export class PostgresBackendDriver implements DataDriver {
         if (!collection && !path) return { collection: undefined,
 callbacks: undefined,
 propertyCallbacks: undefined };
-        const registryCollection = this.registry.getCollectionByPath(path);
+        const registryCollection = this.registry?.getCollectionByPath(path);
         const resolvedCollection = registryCollection
             ? { ...collection,
 ...registryCollection } as EntityCollection<M>
@@ -166,7 +166,8 @@ propertyCallbacks: undefined };
                 user: this.user,
                 driver: this,
                 data: this.data,
-                client: this.client
+                client: this.client,
+                storageSource: this.client?.storage
             } as unknown as RebaseCallContext; // Backend context
             return Promise.all(entities.map(async (entity) => {
                 let fetched = entity;
@@ -276,7 +277,8 @@ propertyCallbacks: undefined };
                 user: this.user,
                 driver: this,
                 data: this.data,
-                client: this.client
+                client: this.client,
+                storageSource: this.client?.storage
             } as unknown as RebaseCallContext; // Backend context
             if (callbacks?.afterRead) {
                 entity = await callbacks.afterRead({
@@ -359,7 +361,8 @@ propertyCallbacks: undefined };
             user: this.user,
             driver: this,
             data: this.data,
-            client: this.client
+            client: this.client,
+            storageSource: this.client?.storage
         } as unknown as RebaseCallContext;
 
         // Fetch previous values for callbacks AND history recording
@@ -534,7 +537,8 @@ propertyCallbacks: undefined };
             user: this.user,
             driver: this,
             data: this.data,
-            client: this.client
+            client: this.client,
+            storageSource: this.client?.storage
         } as unknown as RebaseCallContext;
 
         if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {

package/src/cli.ts

@@ -478,11 +478,16 @@ async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void>
                 const errorOutput = stderr || stdout;
                 if (errorOutput) {
                     const lines = errorOutput.split("\n").filter((l: string) => l.trim());
+                    let printedCount = 0;
                     for (const line of lines) {
                         if (line.toLowerCase().includes("error") || line.includes("cannot") || line.includes("already exists") || line.includes("does not exist") || line.includes("violates") || line.includes("permission denied")) {
                             console.error(chalk.red(`  ${line.trim()}`));
+                            printedCount++;
                         }
                     }
+                    if (printedCount === 0) {
+                        lines.slice(0, 10).forEach(line => console.error(chalk.red(`  ${line.trim()}`)));
+                    }
                 }
                 console.error("");
                 process.exit(1);

package/src/schema/default-collections.ts

@@ -5,6 +5,7 @@ export const defaultUsersCollection: PostgresCollection = {
     singularName: "User",
     slug: "users",
     table: "users",
+    schema: "rebase",
     icon: "Users",
     group: "Settings",
     properties: {

package/src/schema/doctor.ts

@@ -265,6 +265,8 @@ export async function checkCollectionsVsSdk(
 // ── Phase 2: Collections ↔ Database ──────────────────────────────────────
 
 interface DbColumn {
+    table_schema: string;
+    table_name: string;
     column_name: string;
     data_type: string;
     is_nullable: string;
@@ -288,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
@@ -326,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
@@ -345,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 ─────────────────
@@ -361,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
@@ -392,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"
                             });
                         }
@@ -430,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;
@@ -450,11 +489,11 @@ export async function checkCollectionsVsDatabase(
                         issues.push({
                             severity: "warning",
                             category: "type_mismatch",
-                            table: tableName,
+                            table: fullTableName,
                             column: colName,
                             expected: prop.type === "vector" ? "vector" : expectedType,
                             actual: dbCol.udt_name === "vector" ? "vector" : actualType,
-                            message: `Column "${colName}" in table "${tableName}": expected type "${prop.type === "vector" ? "vector" : expectedType}" but found "${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"
                         });
                     }
@@ -470,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.`,
@@ -492,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"
                                 });
                             }
@@ -510,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`"
                         });
                     }

package/test/postgresDataDriver.test.ts

@@ -35,7 +35,12 @@ describe("PostgresBackendDriver", () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
-        delegate = new PostgresBackendDriver(mockDb, mockRealtimeService);
+        const mockRegistry = {
+            getCollectionByPath: jest.fn().mockReturnValue({ slug: "test_coll", properties: {} }),
+            getCollections: jest.fn().mockReturnValue([]),
+            getTable: jest.fn().mockReturnValue({})
+        } as any;
+        delegate = new PostgresBackendDriver(mockDb, mockRealtimeService, mockRegistry);
     });
 
     it("should initialize correctly", () => {
@@ -661,5 +666,129 @@ status: "new" });
             executeSqlSpy.mockRestore();
         });
     });
+
+    describe("storageSource in Callbacks", () => {
+        it("should inject storageSource: client.storage into contextForCallback in fetchCollection", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const afterReadSpy = jest.fn().mockImplementation(async ({ entity }) => entity);
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    afterRead: afterReadSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "fetchCollection").mockResolvedValueOnce([
+                { id: "e1", path: "test_coll", values: {} } as any
+            ]);
+
+            await delegate.fetchCollection({
+                path: "test_coll",
+                collection: mockCollectionWithCallback
+            });
+
+            expect(afterReadSpy).toHaveBeenCalled();
+            const callArgs = afterReadSpy.mock.calls[0][0];
+            expect(callArgs.context).toBeDefined();
+            expect(callArgs.context.storageSource).toBe(mockStorage);
+        });
+
+        it("should inject storageSource in fetchEntity", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const afterReadSpy = jest.fn().mockImplementation(async ({ entity }) => entity);
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    afterRead: afterReadSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "fetchEntity").mockResolvedValueOnce(
+                { id: "e1", path: "test_coll", values: {} } as any
+            );
+
+            await delegate.fetchEntity({
+                path: "test_coll",
+                entityId: "e1",
+                collection: mockCollectionWithCallback
+            });
+
+            expect(afterReadSpy).toHaveBeenCalled();
+            const callArgs = afterReadSpy.mock.calls[0][0];
+            expect(callArgs.context.storageSource).toBe(mockStorage);
+        });
+
+        it("should inject storageSource in saveEntity beforeSave and afterSave", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const beforeSaveSpy = jest.fn().mockImplementation(async ({ values }) => values);
+            const afterSaveSpy = jest.fn();
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    beforeSave: beforeSaveSpy,
+                    afterSave: afterSaveSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "fetchEntity").mockResolvedValue(undefined);
+            jest.spyOn(delegate.entityService, "saveEntity").mockResolvedValueOnce(
+                { id: "e1", path: "test_coll", values: { name: "test" } } as any
+            );
+
+            await delegate.saveEntity({
+                path: "test_coll",
+                entityId: "e1",
+                values: { name: "test" },
+                collection: mockCollectionWithCallback,
+                status: "existing"
+            });
+
+            expect(beforeSaveSpy).toHaveBeenCalled();
+            expect(beforeSaveSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+            expect(afterSaveSpy).toHaveBeenCalled();
+            expect(afterSaveSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+        });
+
+        it("should inject storageSource in deleteEntity beforeDelete and afterDelete", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const beforeDeleteSpy = jest.fn().mockImplementation(async () => true);
+            const afterDeleteSpy = jest.fn();
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    beforeDelete: beforeDeleteSpy,
+                    afterDelete: afterDeleteSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "deleteEntity").mockResolvedValueOnce();
+
+            await delegate.deleteEntity({
+                entity: { id: "e1", path: "test_coll", values: {} } as any,
+                collection: mockCollectionWithCallback
+            });
+
+            expect(beforeDeleteSpy).toHaveBeenCalled();
+            expect(beforeDeleteSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+            expect(afterDeleteSpy).toHaveBeenCalled();
+            expect(afterDeleteSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+        });
+    });
 });