@rebasepro/server-postgres 0.16.1-canary.gef08a6e → 0.17.0

package/src/schema/generate-postgres-ddl-logic.ts

@@ -20,6 +20,7 @@ import {
     vectorIndexStatements,
     type VectorIndexPlan
 } from "./vector-index";
+import { buildCollectionIndexSpecs, collectionIndexStatements } from "./collection-index";
 import { REBASE_SCHEMA } from "@rebasepro/types";
 
 // --- Helper Functions ---
@@ -734,6 +735,13 @@ export const generatePostgresDdl = async (
                 indexStatements.push(`-- No ANN index on "${skip.schema}"."${skip.table}"."${skip.column}": ${skip.reason}`);
             }
 
+            // The collection's own `indexes:` block. Last of the three index
+            // producers, and the only one the developer wrote deliberately
+            // rather than getting as a side effect of another feature.
+            indexStatements.push(...collectionIndexStatements(
+                buildCollectionIndexSpecs(collection, resolveColumnName)
+            ));
+
             // The implicit primary key, for a collection that declares none.
             const hasPk = columns.some(c => c.includes("PRIMARY KEY"));
             if (!hasPk) {
@@ -762,16 +770,20 @@ export const generatePostgresDdl = async (
         }
     }
 
-    if (fkStatements.length > 0) {
-        ddl += "-- Foreign Key Constraints\n";
-        ddl += fkStatements.join("\n") + "\n\n";
-    }
-
+    // Indexes before foreign keys. Today every FK targets a primary key created
+    // inline, so the order is safe by accident; the moment a declared
+    // `unique: true` index can back an FK target, a constraint emitted first
+    // would reference an index that does not exist yet.
     if (indexStatements.length > 0) {
         ddl += "-- Indexes\n";
         ddl += indexStatements.join("\n") + "\n\n";
     }
 
+    if (fkStatements.length > 0) {
+        ddl += "-- Foreign Key Constraints\n";
+        ddl += fkStatements.join("\n") + "\n\n";
+    }
+
     if (policyStatements.length > 0) {
         ddl += "-- Row Level Security Policies\n";
         ddl += policyStatements.join("");

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

@@ -17,7 +17,7 @@ export function inferPropertyFromData(
     sampleValues: unknown[],
     isPk: boolean,
     /**
-     * False when generating for a project without `@rebasepro/admin-types`, where
+     * False when generating for a project without `@rebasepro/cms-types`, where
      * `BaseProperty` declares no `admin` field and the block below would not
      * compile. The type-level inferences (`propType`, `url`, `storage`) are
      * unaffected — only the form-widget hints are dropped.

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

@@ -594,7 +594,7 @@ export interface GeneratedFile {
  *
  * There are two of them and they are not interchangeable:
  *
- * - `admin-types` — `@rebasepro/admin-types`. Its index side-effect-imports
+ * - `admin-types` — `@rebasepro/cms-types`. Its index side-effect-imports
  *   `augment.ts`, so importing it is also what *declares* the `admin` block. Only a
  *   project that depends on the package can resolve it.
  * - `common` — `@rebasepro/common`. Same key inference, no admin surface, no React
@@ -607,7 +607,7 @@ export interface GeneratedFile {
  * The last two emit **no admin block, on the collection or on any property**. That is
  * not a downgrade: `@rebasepro/types` declares no `admin` field at all, so the block
  * introspection used to emit was a type error in every headless project it was
- * written into. See `packages/admin-types/src/augment.ts`.
+ * written into. See `packages/cms-types/src/augment.ts`.
  */
 export type CollectionBuilder = "admin-types" | "common" | "annotation";
 
@@ -616,12 +616,12 @@ export type CollectionBuilder = "admin-types" | "common" | "annotation";
  *
  * Written as constants rather than inline in the import templates below because
  * `scripts/headless-guard/check-types.mjs` scans core sources for `from
- * "@rebasepro/admin-types"` and cannot tell a real import from one this module
+ * "@rebasepro/cms-types"` and cannot tell a real import from one this module
  * *writes*. It is right to be that blunt — the guard's whole value is that it
  * cannot be reasoned around — so the string simply never appears in that shape
  * here. Inlining them back into the templates re-breaks `check:types-headless`.
  */
-export const ADMIN_TYPES_PACKAGE = "@rebasepro/admin-types";
+export const ADMIN_TYPES_PACKAGE = "@rebasepro/cms-types";
 export const COMMON_PACKAGE = "@rebasepro/common";
 export const TYPES_PACKAGE = "@rebasepro/types";
 

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

@@ -49,10 +49,10 @@ function declaredDependencies(manifestPath: string): Set<string> {
  * at the moment of generation. The alternatives are all proxies for it: `rebase.json`'s
  * `apps` block says a CMS scaffold declared an admin app, and a `frontend/` directory
  * says one was scaffolded, but neither is what the compiler consults, and either can be
- * true of a project whose `config` package does not depend on `@rebasepro/admin-types`.
+ * true of a project whose `config` package does not depend on `@rebasepro/cms-types`.
  *
  * Ambiguity resolves towards the admin panel: a project that declares both packages has
- * a panel, and `@rebasepro/admin-types` is the flavour that keeps the `admin` block.
+ * a panel, and `@rebasepro/cms-types` is the flavour that keeps the `admin` block.
  */
 export function detectCollectionBuilder(outDir: string): CollectionBuilder {
     let dir = path.resolve(outDir);

package/src/schema/introspect-db.ts

@@ -110,12 +110,12 @@ async function main() {
         const checkFacts = parseCheckConstraints(metadata.checks);
 
         // Which builder the generated files may import — read from the manifests
-        // above `outDir`, because a project without `@rebasepro/admin-types` cannot
+        // above `outDir`, because a project without `@rebasepro/cms-types` cannot
         // resolve that import and has no `admin` block to write into either.
         const builder = detectCollectionBuilder(outDir);
         if (builder === "annotation") {
             outWarn(chalk.yellow(
-                "⚠ Neither @rebasepro/admin-types nor @rebasepro/common is declared above " +
+                "⚠ Neither @rebasepro/cms-types nor @rebasepro/common is declared above " +
                 `${outDir}.`
             ));
             outWarn(chalk.gray(

package/src/services/realtimeService.ts

@@ -462,6 +462,23 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
             }
         }
 
+        // The shared rows go before the announcement, not after it. Every
+        // `removePresence` below publishes a departure — to local members and
+        // over the bus — while `sendPresenceState` answers a *newly arriving*
+        // subscriber from this table. Announcing first leaves a window where the
+        // table still lists someone who has left: a client hydrating inside it is
+        // handed the ghost, and the diff that would have corrected it was
+        // broadcast before that client existed, so it holds the ghost until the
+        // TTL sweep rather than for the length of one statement.
+        //
+        // One statement for every channel the client was in, rather than one per
+        // channel below — a disconnect is the common case, not a rare one. The
+        // subscription and timer cleanup above stays synchronous on purpose: it
+        // is what leaks if the database is slow, and it owes nothing to the
+        // shared table. With no bus configured this is a no-op that never awaits
+        // a query.
+        await this.presenceStoreOp(() => this.presenceStore!.removeClient(clientId), "client removal");
+
         // Remove from all broadcast channels
         for (const [channel, members] of this.channels.entries()) {
             if (members.has(clientId)) {
@@ -475,10 +492,6 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         for (const [channel] of this.presence) {
             this.removePresence(clientId, channel, { skipStore: true });
         }
-
-        // One statement for every channel the client was in, rather than one
-        // per channel above — a disconnect is the common case, not a rare one.
-        void this.presenceStoreOp(() => this.presenceStore!.removeClient(clientId), "client removal");
     }
 
     private async handleMessage(clientId: string, message: WebSocketMessage, authContext?: SubscriptionAuthContext) {

package/src/websocket.ts

@@ -273,7 +273,7 @@ code } }
                         verifiedUser = { uid: "service", roles: ["admin"], isAdmin: true };
                     } else {
                         // Standard JWT path
-                        const jwtPayload = extractUserFromToken(token);
+                        const jwtPayload = await extractUserFromToken(token);
                         if (jwtPayload) {
                             verifiedUser = {
                                 uid: jwtPayload.uid,