@rebasepro/studio 0.3.0 → 0.5.0

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

@@ -1,4 +1,4 @@
-import { Role, User } from "../users";
+import type { User } from "../users";
 /**
  * Result of creating a new user via admin flow.
  * Contains the created user plus information about how credentials were delivered.
@@ -15,56 +15,46 @@ export interface UserCreationResult<USER extends User = User> {
     temporaryPassword?: string;
 }
 /**
- * Delegate to manage users, roles, and their permissions.
- * This interface allows the CMS to be completely agnostic of the underlying
- * authentication provider or backend.
+ * Delegate to manage auth-specific user operations.
+ *
+ * This interface allows the CMS to be agnostic of the underlying
+ * authentication provider or backend. User/role CRUD is now handled
+ * by the collection system; this delegate only exposes auth-specific
+ * operations (password hashing, invitations, bootstrap).
  *
  * @group Models
  */
 export interface UserManagementDelegate<USER extends User = User> {
     /**
-     * Are the users and roles currently being fetched?
+     * Are auth-related operations currently loading?
      */
     loading: boolean;
     /**
-     * List of users managed by the CMS.
+     * In-memory list of users (used for client-side filtering fallback).
      */
-    users: USER[];
+    users?: USER[];
     /**
-     * Optional error if users failed to load.
+     * Error from fetching the users list, if any.
      */
     usersError?: Error;
     /**
-     * Function to get a user by its uid. This is used to show
-     * user information when assigning ownership of an entity.
-     * @param uid
+     * Look up a single user by UID from the in-memory cache.
      */
-    getUser: (uid: string) => USER | null;
+    getUser?: (uid: string) => USER | null;
     /**
-     * Search users with server-side pagination.
-     * When provided, the CMS will use this for the users table
-     * instead of loading all users into memory.
+     * Server-side user search with pagination.
      */
-    searchUsers?: (options: {
+    searchUsers?: (params: {
         search?: string;
         limit?: number;
         offset?: number;
-        orderBy?: string;
-        orderDir?: "asc" | "desc";
-        roleId?: string;
     }) => Promise<{
         users: USER[];
         total: number;
     }>;
-    /**
-     * Save a user (create or update)
-     * @param user
-     */
-    saveUser?: (user: USER) => Promise<USER>;
     /**
      * Create a new user with invitation/password generation support.
      * Returns additional info about how the credentials were delivered.
-     * Falls back to saveUser if not provided.
      */
     createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
     /**
@@ -73,42 +63,15 @@ export interface UserManagementDelegate<USER extends User = User> {
      * or a flag indicating an email invitation was sent.
      */
     resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
-    /**
-     * Delete a user
-     * @param user
-     */
-    deleteUser?: (user: USER) => Promise<void>;
-    /**
-     * List of roles defined in the CMS.
-     */
-    roles?: Role[];
-    /**
-     * Optional error if roles failed to load.
-     */
-    rolesError?: Error;
-    /**
-     * Save a role (create or update)
-     * @param role
-     */
-    saveRole?: (role: Role) => Promise<void>;
-    /**
-     * Delete a role
-     * @param role
-     */
-    deleteRole?: (role: Role) => Promise<void>;
     /**
      * Is the currently logged in user an admin?
      */
     isAdmin?: boolean;
-    /**
-     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
-     */
-    allowDefaultRolesCreation?: boolean;
     /**
      * Optionally define roles for a given user. This is useful when the roles
      * are coming from a separate provider than the one issuing the tokens.
      */
-    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    defineRolesFor?: (user: USER) => Promise<string[] | undefined> | string[] | undefined;
     /**
      * Whether any admin users exist. Used by the bootstrap banner to decide
      * whether to prompt.  Populated via a lightweight check (e.g. `limit=1`

package/dist/types/src/users/index.d.ts

@@ -1,2 +1 @@
 export * from "./user";
-export * from "./roles";

package/dist/types/src/users/user.d.ts

@@ -35,7 +35,6 @@ export type User = {
     readonly isAnonymous: boolean;
     /**
      * Role IDs assigned to this user (e.g. ["admin", "editor"]).
-     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
      */
     roles?: string[];
     /**

package/dist/ui/src/components/Card.d.ts

@@ -1,9 +1,8 @@
 import React from "react";
-type CardProps = {
+declare const Card: React.ForwardRefExoticComponent<{
     children: React.ReactNode;
     style?: React.CSSProperties;
     onClick?: (e?: React.MouseEvent) => void;
     className?: string;
-};
-declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+} & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 export { Card };

package/dist/ui/src/components/FilterChip.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-export interface FilterChipProps {
+export interface FilterChipProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
     /**
      * The text label displayed on the chip.
      */
@@ -8,10 +8,6 @@ export interface FilterChipProps {
      * Whether the chip is currently in an active/selected state.
      */
     active?: boolean;
-    /**
-     * Callback when the chip is clicked.
-     */
-    onClick?: () => void;
     /**
      * Optional icon rendered before the label.
      */
@@ -21,10 +17,6 @@ export interface FilterChipProps {
      * @default "medium"
      */
     size?: "small" | "medium";
-    /**
-     * Additional class names.
-     */
-    className?: string;
     /**
      * Whether the chip is disabled.
      */
@@ -39,4 +31,4 @@ export interface FilterChipProps {
  *
  * @group Interactive components
  */
-export declare function FilterChip({ children, active, onClick, icon, size, className, disabled }: FilterChipProps): import("react/jsx-runtime").JSX.Element;
+export declare const FilterChip: React.ForwardRefExoticComponent<FilterChipProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/ui/src/components/VirtualTable/VirtualTableProps.d.ts

@@ -224,6 +224,12 @@ export type OnVirtualTableColumnResizeParams = {
     key: string;
     column: VirtualTableColumn;
 };
+/**
+ * @see Table
+ * @group Components
+ */
+export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "not-in" | "array-contains-any";
+export type FilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, unknown] | [WhereFilterOp, unknown][]>>;
 /**
  * @see Table
  * @group Components
@@ -233,11 +239,11 @@ export type VirtualTableSort = "asc" | "desc" | undefined;
  * @see Table
  * @group Components
  */
-export type VirtualTableFilterValues<Key extends string> = Partial<Record<Key, [VirtualTableWhereFilterOp, unknown]>>;
+export type VirtualTableFilterValues<Key extends string> = FilterValues<Key>;
 /**
  * Filter conditions in a `Query.where()` clause are specified using the
  * strings `<`, `<=`, `==`, `>=`, `>`, `array-contains`, `in`, and `array-contains-any`.
  * @see Table
  * @group Models
  */
-export type VirtualTableWhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "not-in" | "array-contains-any";
+export type VirtualTableWhereFilterOp = WhereFilterOp;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/studio",
   "type": "module",
-  "version": "0.3.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.3.0",
-    "@rebasepro/core": "0.3.0",
-    "@rebasepro/common": "0.3.0",
-    "@rebasepro/types": "0.3.0",
-    "@rebasepro/ui": "0.3.0",
-    "@rebasepro/utils": "0.3.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.3.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/JSEditor/JSMonacoEditor.tsx

@@ -129,25 +129,12 @@ interface AdminUser {
     updatedAt: string;
 }
 
-interface RebaseRole {
-    id: string;
-    name: string;
-    isAdmin: boolean;
-    defaultPermissions: Record<string, unknown> | null;
-    config: Record<string, unknown> | null;
-}
-
 interface RebaseAdmin {
     listUsers(): Promise<{ users: AdminUser[] }>;
     getUser(userId: string): Promise<{ user: AdminUser }>;
     createUser(data: { email: string; displayName?: string; password?: string; roles?: string[] }): Promise<{ user: AdminUser }>;
     updateUser(userId: string, data: { email?: string; displayName?: string; password?: string; roles?: string[] }): Promise<{ user: AdminUser }>;
     deleteUser(userId: string): Promise<{ success: boolean }>;
-    listRoles(): Promise<{ roles: RebaseRole[] }>;
-    getRole(roleId: string): Promise<{ role: RebaseRole }>;
-    createRole(data: { id: string; name: string; isAdmin?: boolean; defaultPermissions?: Record<string, unknown>; config?: Record<string, unknown> }): Promise<{ role: RebaseRole }>;
-    updateRole(roleId: string, data: { name?: string; isAdmin?: boolean; defaultPermissions?: Record<string, unknown>; config?: Record<string, unknown> }): Promise<{ role: RebaseRole }>;
-    deleteRole(roleId: string): Promise<{ success: boolean }>;
     bootstrap(): Promise<{ success: boolean; message: string; user: { uid: string; roles: string[] } }>;
 }
 

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.test.ts

@@ -311,6 +311,7 @@ character_maximum_length: null }
 
             const prop = collection.properties!.tags as ArrayProperty;
             expect(prop.type).toBe("array");
+            expect(prop.columnType).toBe("text[]");
             expect(!Array.isArray(prop.of) && prop.of?.type).toBe("string");
         });
 

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.
@@ -159,12 +159,29 @@ label: v.replace(/_/g, " ").replace(/\b\w/g, (c: string) => c.toUpperCase()) }))
             };
 
         case "array":
-        case "ARRAY":
+        case "ARRAY": {
+            let innerType = "string";
+            let colType: ArrayProperty["columnType"] = undefined;
+            if (udt_name === "_text" || udt_name === "_varchar") {
+                innerType = "string";
+                colType = "text[]";
+            } else if (udt_name === "_int4" || udt_name === "_int2" || udt_name === "_int8") {
+                innerType = "number";
+                colType = "integer[]";
+            } else if (udt_name === "_bool") {
+                innerType = "boolean";
+                colType = "boolean[]";
+            } else if (udt_name === "_numeric") {
+                innerType = "number";
+                colType = "numeric[]";
+            }
             return {
                 type: "array",
                 name: prettifiedName,
-                of: { type: "string" }
+                columnType: colType,
+                of: { type: innerType }
             } as ArrayProperty;
+        }
 
         default:
             // Fallback: treat unknown types as string
@@ -195,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) {
@@ -254,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;
         });