@rebasepro/studio 0.4.0 → 0.5.0

package/dist/studio/src/components/RLSEditor/RLSEditor.d.ts

@@ -8,12 +8,6 @@ export interface PostgresPolicy {
     with_check: string | null;
     status?: "live" | "code_only" | "both";
 }
-export interface TableRLSStatus {
-    schemaName: string;
-    tableName: string;
-    rlsEnabled: boolean;
-    policies: PostgresPolicy[];
-}
 export declare const RLSEditor: ({ apiUrl }: {
     apiUrl?: string;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/SchemaVisualizer/schema-visualizer.utils.d.ts

@@ -1,9 +1,5 @@
 import type { Node, Edge } from "@xyflow/react";
 export declare const NODE_WIDTH = 280;
-/** Header with a single line of text (junction tables or tableName === collectionName). */
-export declare const HEADER_HEIGHT_SINGLE = 33;
-/** Header with two lines (name + subtitle when collectionName !== tableName). */
-export declare const HEADER_HEIGHT_DOUBLE = 47;
 /**
  * Compute the correct header height for a table node.
  */
@@ -12,10 +8,6 @@ export declare const getHeaderHeight: (opts: {
     collectionName: string;
     tableName: string;
 }) => number;
-/**
- * Estimate the pixel height of a table node based on column count.
- */
-export declare const estimateNodeHeight: (columnCount: number, headerHeight?: number) => number;
 /**
  * Get the vertical center Y of a specific column row (0-indexed)
  * relative to the top of the node.

package/dist/studio/src/utils/pgColumnToProperty.d.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, TableMetadata } from "@rebasepro/types";
+import type { EntityCollection, TableMetadata } from "@rebasepro/types";
 /**
  * Builds a partial EntityCollection from PostgreSQL table metadata.
  * This is used when creating a new collection from an existing database table.

package/dist/types/src/types/backend.d.ts

@@ -1,5 +1,6 @@
 import type { Entity } from "./entities";
 import type { EntityCollection, FilterValues, WhereFilterOp } from "./collections";
+import type { AuthAdapter } from "./auth_adapter";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -182,6 +183,24 @@ export interface RealtimeProvider {
      * Notify all relevant subscribers of an entity update
      */
     notifyEntityUpdate(path: string, entityId: string, entity: Entity | null, databaseId?: string): Promise<void>;
+    /**
+     * Called when the HTTP server is ready and listening.
+     * Useful for providers that need the server address for callbacks.
+     */
+    onServerReady?(serverInfo: {
+        port: number;
+        hostname?: string;
+    }): void;
+    /**
+     * Gracefully shut down the realtime provider.
+     * Called during server shutdown to clean up resources.
+     */
+    destroy?(): Promise<void>;
+    /**
+     * Stop the internal LISTEN client (e.g., PostgreSQL LISTEN/NOTIFY).
+     * Called during graceful shutdown before closing database connections.
+     */
+    stopListening?(): Promise<void>;
 }
 /**
  * Abstract collection registry interface.
@@ -464,6 +483,22 @@ export interface BackendBootstrapper {
      * (e.g., `"postgres"`, `"mongodb"`, `"mysql"`).
      */
     type: string;
+    /**
+     * Unique identifier for this bootstrapper instance.
+     * Used to register the driver in the driver registry.
+     * Defaults to `type` if not set.
+     */
+    id?: string;
+    /**
+     * Whether this bootstrapper provides the default driver.
+     * When true, the coordinator uses this driver as the primary one.
+     */
+    isDefault?: boolean;
+    /**
+     * Run database migrations for this driver.
+     * Called by the coordinator after all drivers are initialized.
+     */
+    runMigrations?(config: unknown, driverResult: InitializedDriver): Promise<void>;
     /**
      * Create a DataDriver from the given config.
      * This is the only **required** method.
@@ -498,7 +533,7 @@ export interface BackendBootstrapper {
     /**
      * Initialize WebSocket server for realtime operations.
      */
-    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import("../controllers/data_driver").DataDriver, config?: unknown): Promise<void> | void;
+    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import("../controllers/data_driver").DataDriver, config?: unknown, authAdapter?: AuthAdapter): Promise<void> | void;
 }
 /**
  * Result of `BackendBootstrapper.initializeDriver()`.

package/dist/types/src/types/collections.d.ts

@@ -343,6 +343,23 @@ export interface BaseEntityCollection<M extends Record<string, unknown> = Record
      * Builder for the collection actions rendered in the toolbar
      */
     Actions?: ComponentRef<CollectionActionsProps>[];
+    /**
+     * The database table name for this collection.
+     * Automatically set for PostgreSQL collections.
+     * For non-SQL backends, this may be undefined.
+     */
+    table?: string;
+    /**
+     * Relations defined for this collection.
+     * Populated at normalization time from inline relation properties
+     * or explicit relation definitions.
+     */
+    relations?: Relation[];
+    /**
+     * Security rules for this collection (Row Level Security).
+     * When defined, the backend enforces access control policies.
+     */
+    securityRules?: SecurityRule[];
 }
 /**
  * A collection backed by PostgreSQL (or any SQL database).
@@ -436,7 +453,10 @@ export interface MongoDBCollection<M extends Record<string, unknown> = Record<st
  * @group Models
  */
 export type EntityCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> = PostgresCollection<M, USER> | FirebaseCollection<M, USER> | MongoDBCollection<M, USER>;
-/** An EntityCollection that supports SQL-style relations (e.g. Postgres). */
+/**
+ * An EntityCollection that supports SQL-style relations (e.g. Postgres).
+ * @deprecated Use `EntityCollection` directly — `table`, `relations`, and `securityRules` are now on `BaseEntityCollection`.
+ */
 export type CollectionWithRelations<M extends Record<string, unknown> = Record<string, unknown>> = EntityCollection<M> & {
     table?: string;
     relations?: Relation[];

package/dist/types/src/types/properties.d.ts

@@ -641,14 +641,6 @@ export interface MapProperty extends BaseProperty {
      * Properties that are displayed when rendered as a preview
      */
     previewProperties?: string[];
-    /**
-     * Allow the user to add only some keys in this map.
-     * By default, all properties of the map have the corresponding field in
-     * the form view. Setting this flag to true allows to pick only some.
-     * Useful for map that can have a lot of sub-properties that may not be
-     * needed
-     */
-    pickOnlySomeKeys?: boolean;
     /**
      * Render this map as a key-value table that allows to use
      * arbitrary keys. You don't need to define the properties in this case.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/studio",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
   "types": "dist/studio/src/index.d.ts",
@@ -15,19 +15,19 @@
     "pgsql-ast-parser": "12.0.2",
     "prism-react-renderer": "^2.4.1",
     "react-dropzone": "^14.4.1",
-    "@rebasepro/client": "0.4.0",
-    "@rebasepro/common": "0.4.0",
-    "@rebasepro/core": "0.4.0",
-    "@rebasepro/types": "0.4.0",
-    "@rebasepro/ui": "0.4.0",
-    "@rebasepro/utils": "0.4.0"
+    "@rebasepro/client": "0.5.0",
+    "@rebasepro/common": "0.5.0",
+    "@rebasepro/utils": "0.5.0",
+    "@rebasepro/core": "0.5.0",
+    "@rebasepro/types": "0.5.0",
+    "@rebasepro/ui": "0.5.0"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
     "react-dom": ">=19.0.0",
     "react-router": "^7.0.0",
     "react-router-dom": "^7.0.0",
-    "@rebasepro/admin": "0.4.0"
+    "@rebasepro/admin": "0.5.0"
   },
   "peerDependenciesMeta": {
     "@rebasepro/admin": {

package/src/components/JSEditor/JSEditor.tsx

@@ -166,7 +166,7 @@ function detectCollectionsInResult(
     for (const slug of mentionedSlugs) {
         const normalised = toSnakeCase(slug);
         const col = collections.find(c => {
-            const tableName = (c as EntityCollection & { table?: string }).table || toSnakeCase(c.slug);
+            const tableName = ("table" in c ? c.table : undefined) || toSnakeCase(c.slug);
             return c.slug === slug || tableName === normalised || toSnakeCase(c.slug) === normalised;
         });
         if (col) {

package/src/components/RLSEditor/RLSEditor.tsx

@@ -50,7 +50,7 @@ export interface PostgresPolicy {
     status?: "live" | "code_only" | "both";
 }
 
-export interface TableRLSStatus {
+interface TableRLSStatus {
     schemaName: string;
     tableName: string;
     rlsEnabled: boolean;

package/src/components/SchemaVisualizer/schema-visualizer.utils.ts

@@ -4,9 +4,9 @@ import type { Node, Edge } from "@xyflow/react";
 // ─── Layout Constants ─────────────────────────────────────────────────
 export const NODE_WIDTH = 280;
 /** Header with a single line of text (junction tables or tableName === collectionName). */
-export const HEADER_HEIGHT_SINGLE = 33;
+const HEADER_HEIGHT_SINGLE = 33;
 /** Header with two lines (name + subtitle when collectionName !== tableName). */
-export const HEADER_HEIGHT_DOUBLE = 47;
+const HEADER_HEIGHT_DOUBLE = 47;
 const ROW_HEIGHT = 28; // height per column row
 
 /**
@@ -26,7 +26,7 @@ export const getHeaderHeight = (opts: {
 /**
  * Estimate the pixel height of a table node based on column count.
  */
-export const estimateNodeHeight = (columnCount: number, headerHeight: number = HEADER_HEIGHT_DOUBLE): number =>
+const estimateNodeHeight = (columnCount: number, headerHeight: number = HEADER_HEIGHT_DOUBLE): number =>
     headerHeight + Math.max(columnCount, 1) * ROW_HEIGHT + 4; // +4 for bottom padding
 
 /**

package/src/components/SchemaVisualizer/useSchemaGraph.ts

@@ -46,9 +46,9 @@ const extractColumns = (collection: EntityCollection): ColumnInfo[] => {
         if (prop.type === "relation") continue; // Relations are shown as edges, not columns
 
         const isPk =
-            ("isId" in prop && Boolean((prop as unknown as Record<string, unknown>).isId)) ||
+            ("isId" in prop && Boolean(prop.isId)) ||
             (!Object.values(properties).some(
-                (p) => "isId" in p && Boolean((p as unknown as Record<string, unknown>).isId)
+                (p) => "isId" in p && Boolean(p.isId)
             ) &&
                 propName === "id");
 

package/src/utils/pgColumnToProperty.ts

@@ -1,4 +1,4 @@
-import { EntityCollection, Property, StringProperty, NumberProperty, ArrayProperty, TableColumnInfo, TableMetadata } from "@rebasepro/types";
+import type { EntityCollection, Property, StringProperty, NumberProperty, ArrayProperty, TableColumnInfo, TableMetadata, SecurityOperation, SecurityRule } from "@rebasepro/types";
 
 /**
  * Maps a PostgreSQL column data type to a Rebase property type.
@@ -212,13 +212,7 @@ export function buildCollectionFromTableMetadata(
         localKey?: string;
         through?: { table: string; sourceColumn: string; targetColumn: string };
     }> = [];
-    const securityRules: Array<{
-        name: string;
-        operations: string[];
-        roles: string[];
-        qual: string | null | undefined;
-        with_check: string | null | undefined;
-    }> = [];
+    const securityRules: SecurityRule[] = [];
 
     // Parse columns
     for (const column of metadata.columns) {
@@ -271,22 +265,31 @@ export function buildCollectionFromTableMetadata(
         for (const policy of metadata.policies) {
             // Attempt to map typical cmds to operations.
             // Postgres cmd: SELECT, INSERT, UPDATE, DELETE, ALL
-            let operations: string[] = [];
+            let operations: SecurityOperation[] = [];
             switch (policy.cmd) {
-                case "ALL": operations = ["read", "create", "update", "delete"]; break;
-                case "SELECT": operations = ["read"]; break;
-                case "INSERT": operations = ["create"]; break;
+                case "ALL": operations = ["all"]; break;
+                case "SELECT": operations = ["select"]; break;
+                case "INSERT": operations = ["insert"]; break;
                 case "UPDATE": operations = ["update"]; break;
                 case "DELETE": operations = ["delete"]; break;
             }
-            securityRules.push({
-                name: policy.policy_name,
-                operations,
-                // roles is string[] e.g., ["public", "authenticated"]
-                roles: policy.roles ?? [],
-                qual: policy.qual,
-                with_check: policy.with_check
-            });
+            const qual = policy.qual ?? undefined;
+            const withCheck = policy.with_check ?? undefined;
+            if (qual) {
+                securityRules.push({
+                    name: policy.policy_name,
+                    operations,
+                    roles: policy.roles ?? [],
+                    using: qual,
+                    ...(withCheck ? { withCheck } : {})
+                });
+            } else {
+                securityRules.push({
+                    name: policy.policy_name,
+                    operations,
+                    roles: policy.roles ?? [],
+                });
+            }
         }
     }
 

package/src/utils/sql_utils.ts

@@ -105,7 +105,7 @@ export function resolveQueryCollections(
     for (const table of tables) {
         // Match table name against collection table or slug->snake_case
         const matched = collections.find(c => {
-            const tableName = (c as EntityCollection & { table?: string }).table || toSnakeCase(c.slug);
+            const tableName = ("table" in c ? c.table : undefined) || toSnakeCase(c.slug);
             return tableName === table.name;
         });