@rebasepro/studio 0.0.1-canary.4d4fb3e

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

@@ -0,0 +1 @@
+export declare function JSEditor(): import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/JSEditor/JSEditorSidebar.d.ts

@@ -0,0 +1,21 @@
+export interface JSSnippet {
+    id: string;
+    name: string;
+    code: string;
+    createdAt: number;
+    isFavorite?: boolean;
+}
+interface CollectionInfo {
+    slug: string;
+    properties: string[];
+}
+interface JSEditorSidebarProps {
+    collections: CollectionInfo[];
+    snippets: JSSnippet[];
+    history: string[];
+    onSelectSnippet: (code: string) => void;
+    onDeleteSnippet: (id: string) => void;
+    onInsertCode: (code: string) => void;
+}
+export declare const JSEditorSidebar: ({ collections, snippets, history, onSelectSnippet, onDeleteSnippet, onInsertCode, }: JSEditorSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/studio/src/components/JSEditor/JSMonacoEditor.d.ts

@@ -0,0 +1,18 @@
+export type CollectionInfo = {
+    slug: string;
+    name: string;
+    properties: string[];
+};
+export type JSMonacoEditorProps = {
+    value: string;
+    onChange: (value: string | undefined) => void;
+    onRun?: (selectedText?: string) => void;
+    className?: string;
+    readOnly?: boolean;
+    autoFocus?: boolean;
+    /** Collection slugs for basic autocomplete */
+    collectionSlugs?: string[];
+    /** Full collection info with property names for richer type generation */
+    collections?: CollectionInfo[];
+};
+export declare const JSMonacoEditor: ({ value, onChange, onRun, className, readOnly, autoFocus, collectionSlugs, collections }: JSMonacoEditorProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { PostgresPolicy } from "./RLSEditor";
+export interface PolicyEditorProps {
+    policy?: PostgresPolicy;
+    schema: string;
+    table: string;
+    onSave: (policyData: Partial<PostgresPolicy>) => void;
+    onCancel: () => void;
+}
+export declare const PolicyEditor: ({ policy, schema, table, onSave, onCancel }: PolicyEditorProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,19 @@
+export interface PostgresPolicy {
+    policyname: string;
+    tablename: string;
+    permissive: "PERMISSIVE" | "RESTRICTIVE";
+    roles: string[];
+    cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+    qual: string | null;
+    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/RLSEditor/index.d.ts

@@ -0,0 +1 @@
+export * from "./RLSEditor";

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

@@ -0,0 +1,10 @@
+import type { RebaseStudioConfig } from "@rebasepro/types";
+/**
+ * Declarative component to configure the Studio in Rebase.
+ * Renders nothing — purely registers config into the RebaseRegistry.
+ *
+ * The "schema" tool (collection editor view) is now a built-in CMS feature.
+ * When `<RebaseCMS collectionEditor={...}>` is used, the schema view is
+ * automatically injected into Studio — no manual wiring needed.
+ */
+export declare function RebaseStudio({ tools, homePage }: RebaseStudioConfig): null;

package/dist/studio/src/components/SQLEditor/ExplainVisualizer.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export interface ExplainPlanNode {
+    "Node Type": string;
+    "Relation Name"?: string;
+    "Alias"?: string;
+    "Startup Cost": number;
+    "Total Cost": number;
+    "Plan Rows": number;
+    "Plan Width": number;
+    "Actual Startup Time"?: number;
+    "Actual Total Time"?: number;
+    "Actual Rows"?: number;
+    "Actual Loops"?: number;
+    "Filter"?: string;
+    "Index Cond"?: string;
+    "Hash Cond"?: string;
+    "Plans"?: ExplainPlanNode[];
+    [key: string]: unknown;
+}
+export interface ExplainVisualizerProps {
+    plan: ExplainPlanNode;
+    isRoot?: boolean;
+}
+export declare const ExplainVisualizer: React.FC<ExplainVisualizerProps>;

package/dist/studio/src/components/SQLEditor/MonacoEditor.d.ts

@@ -0,0 +1,17 @@
+export type MonacoEditorProps = {
+    value: string;
+    onChange: (value: string | undefined) => void;
+    onRun?: (selectedText?: string) => void;
+    className?: string;
+    readOnly?: boolean;
+    autoFocus?: boolean;
+    schemas?: Record<string, {
+        schemaName: string;
+        tableName: string;
+        columns: {
+            name: string;
+            dataType: string;
+        }[];
+    }[]>;
+};
+export declare const MonacoEditor: ({ value, onChange, onRun, className, readOnly, autoFocus, schemas }: MonacoEditorProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+export interface SQLEditorColumnInfo {
+    name: string;
+    dataType: string;
+    isPrimaryKey: boolean;
+}
+export interface TableInfo {
+    schemaName: string;
+    tableName: string;
+    columns: SQLEditorColumnInfo[];
+}
+export declare const SQLEditor: () => import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/components/SQLEditor/SQLEditorSidebar.d.ts

@@ -0,0 +1,21 @@
+import { TableInfo } from "./SQLEditor";
+export interface Snippet {
+    id: string;
+    name: string;
+    sql: string;
+    createdAt: number;
+    isFavorite?: boolean;
+}
+interface SQLEditorSidebarProps {
+    onSelectSnippet: (sql: string) => void;
+    onTableClick: (tableName: string) => void;
+    snippets: Snippet[];
+    history: string[];
+    onDeleteSnippet: (id: string) => void;
+    schemas: Record<string, TableInfo[]>;
+    isSchemaLoading: boolean;
+    schemaError: string | null;
+    onRetrySchema: () => void;
+}
+export declare const SQLEditorSidebar: ({ onSelectSnippet, onTableClick, snippets, history, onDeleteSnippet, schemas, isSchemaLoading, schemaError, onRetrySchema }: SQLEditorSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/studio/src/components/SQLEditor/SchemaBrowser.d.ts

@@ -0,0 +1,8 @@
+import { TableInfo } from "./SQLEditor";
+export declare const SchemaBrowser: ({ onTableClick, schemas, isSchemaLoading, schemaError, onRetrySchema }: {
+    onTableClick?: (tableName: string) => void;
+    schemas: Record<string, TableInfo[]>;
+    isSchemaLoading: boolean;
+    schemaError: string | null;
+    onRetrySchema: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export declare const StorageView: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import type { HomePageSection } from "@rebasepro/types";
+import React from "react";
+export declare function StudioHomePage({ additionalActions, additionalChildrenStart, additionalChildrenEnd, sections, hiddenGroups, }: {
+    additionalActions?: React.ReactNode;
+    additionalChildrenStart?: React.ReactNode;
+    additionalChildrenEnd?: React.ReactNode;
+    sections?: HomePageSection[];
+    hiddenGroups?: string[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/studio/src/index.d.ts

@@ -0,0 +1,10 @@
+export { StudioBridgeProvider, StudioBridgeContext, useStudioCollectionRegistry, useStudioSideEntityController, useStudioUrlController, useStudioNavigationState, useStudioBreadcrumbs, } from "@rebasepro/core";
+export type { StudioBridge, BreadcrumbEntry, BreadcrumbsController, } from "@rebasepro/core";
+export * from "./components/SQLEditor/SQLEditor";
+export * from "./components/JSEditor/JSEditor";
+export * from "./components/RLSEditor/RLSEditor";
+export * from "./components/RLSEditor/PolicyEditor";
+export * from "./components/StorageView/StorageView";
+export * from "./components/StudioHomePage";
+export * from "./utils/sql_utils";
+export * from "./components/RebaseStudio";

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

@@ -0,0 +1 @@
+export declare function toArray<T>(input?: T | T[]): T[];

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

@@ -0,0 +1,6 @@
+import { 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.
+ */
+export declare function buildCollectionFromTableMetadata(tableName: string, metadata: TableMetadata): Partial<EntityCollection>;

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

@@ -0,0 +1,52 @@
+import { TableInfo } from "../components/SQLEditor/SQLEditor";
+import { EntityCollection } from "@rebasepro/types";
+/**
+ * A table extracted from a SQL query's FROM/JOIN clauses.
+ */
+export interface ExtractedTable {
+    name: string;
+    alias?: string;
+}
+/**
+ * A collection matched to a table in a SQL query.
+ */
+export interface ResolvedQueryCollection {
+    /** DB table name from the SQL AST (e.g. "blog_posts") */
+    tableName: string;
+    /** SQL alias if present (e.g. "bp") */
+    tableAlias?: string;
+    /** The matched collection */
+    collection: EntityCollection;
+    /** Columns from this table that are present in the result set */
+    columns: string[];
+    /** The result column name that holds the primary key for this table (e.g. "id", "author_id") */
+    pkColumn?: string;
+}
+/**
+ * Extract all tables referenced in a SQL query's FROM and JOIN clauses.
+ * Returns an empty array for non-SELECT queries or parse failures.
+ */
+export declare function extractTablesFromQuery(sqlString: string): ExtractedTable[];
+/**
+ * Resolve which collections are referenced by a SQL query.
+ *
+ * Parses the SQL, extracts table names, and matches each against
+ * registered collections via `collection.table` (falling back to
+ * snake_case of `collection.slug`).
+ *
+ * For each matched collection, determines which result columns
+ * belong to that table using the database schema information.
+ */
+export declare function resolveQueryCollections(sqlString: string, schemas: Record<string, TableInfo[]>, collections: EntityCollection[], resultColumns?: string[]): ResolvedQueryCollection[];
+export interface PKMapping {
+    /** The actual column name in the database table */
+    dbColumn: string;
+    /** The column name as it appears in the query result set (may be aliased) */
+    resultColumn: string;
+}
+export interface TableAndPKResult {
+    tableName?: string;
+    primaryKeys?: PKMapping[];
+    error?: string;
+}
+export declare function determineTableAndPK(sqlString: string, columnKey: string, schemas: Record<string, TableInfo[]>): TableAndPKResult;

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

@@ -0,0 +1,7 @@
+export type AnalyticsController = {
+    /**
+     * Callback used to get analytics events from the CMS
+     */
+    onAnalyticsEvent?: (event: AnalyticsEvent, data?: object) => void;
+};
+export type AnalyticsEvent = "entity_click" | "entity_click_from_reference" | "reference_selection_clear" | "reference_selection_toggle" | "reference_selected_single" | "reference_selection_new_entity" | "edit_entity_clicked" | "entity_edited" | "new_entity_click" | "new_entity_saved" | "copy_entity_click" | "entity_copied" | "single_delete_dialog_open" | "multiple_delete_dialog_open" | "single_entity_deleted" | "multiple_entities_deleted" | "drawer_navigate_to_home" | "drawer_navigate_to_collection" | "drawer_navigate_to_view" | "home_navigate_to_collection" | "home_favorite_navigate_to_collection" | "home_navigate_to_view" | "home_navigate_to_admin_view" | "home_favorite_navigate_to_view" | "home_move_card" | "home_move_group" | "home_drop_new_group" | "collection_inline_editing" | "view_mode_changed" | "kanban_card_moved" | "kanban_column_reorder" | "kanban_property_changed" | "kanban_new_entity_in_column" | "kanban_backfill_order" | "card_view_entity_click" | "unmapped_event";

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

@@ -0,0 +1,117 @@
+import { StorageSource } from "./storage";
+import { Role, User } from "../users";
+import { RebaseData } from "./data";
+/**
+ * Capabilities advertised by an auth provider.
+ * UI components use this to show/hide features dynamically
+ * (e.g. password reset, registration, session management).
+ * @group Hooks and utilities
+ */
+export interface AuthCapabilities {
+    emailPasswordLogin?: boolean;
+    googleLogin?: boolean;
+    registration?: boolean;
+    passwordReset?: boolean;
+    sessionManagement?: boolean;
+    profileUpdate?: boolean;
+    emailVerification?: boolean;
+}
+/**
+ * Controller for retrieving the logged user or performing auth related operations.
+ * Note that if you are implementing your AuthController, you probably will want
+ * to do it as the result of a hook.
+ * @group Hooks and utilities
+ */
+export type AuthController<USER extends User = User, ExtraData = unknown> = {
+    /**
+     * The user currently logged in
+     * The values can be: the user object, null if they skipped login
+     */
+    user: USER | null;
+    /**
+     * Initial loading flag. It is used not to display the login screen
+     * when the app first loads, and it has not been checked whether the user
+     * is logged in or not.
+     */
+    initialLoading?: boolean;
+    /**
+     * Loading flag. It is used to display a loading screen when the user is
+     * logging in or out.
+     */
+    authLoading: boolean;
+    /**
+     * Sign out
+     */
+    signOut: () => Promise<void>;
+    /**
+     * Error initializing the authentication
+     */
+    authError?: unknown;
+    /**
+     * Error dispatched by the auth provider
+     */
+    authProviderError?: unknown;
+    /**
+     * You can use this method to retrieve the auth token for the current user.
+     */
+    getAuthToken: () => Promise<string>;
+    /**
+     * Has the user skipped the login process
+     */
+    loginSkipped: boolean;
+    extra: ExtraData;
+    setExtra: (extra: ExtraData) => void;
+    setUser?(user: USER | null): void;
+    setUserRoles?(roles: Role[]): void;
+    /**
+     * Capabilities advertised by the auth provider.
+     * UI components use this to feature-detect what the backend supports.
+     */
+    capabilities?: AuthCapabilities;
+};
+/**
+ * Extended auth controller with common optional auth methods.
+ * Backend implementations (Rebase backend, Firebase, Supabase, etc.)
+ * extend this with their own backend-specific extras.
+ * @group Hooks and utilities
+ */
+export interface AuthControllerExtended<USER extends User = User, ExtraData = unknown> extends AuthController<USER, ExtraData> {
+    /** Login with email and password */
+    emailPasswordLogin?(email: string, password: string): Promise<void>;
+    /** Login with a Google ID token or trigger Google popup */
+    googleLogin?(idToken: string): Promise<void>;
+    /** Register a new user */
+    register?(email: string, password: string, displayName?: string): Promise<void>;
+    /** Skip login (for anonymous access if enabled) */
+    skipLogin?(): void;
+    /** Request password reset email */
+    forgotPassword?(email: string): Promise<void>;
+    /** Reset password using a token */
+    resetPassword?(token: string, password: string): Promise<void>;
+    /** Change password for the authenticated user */
+    changePassword?(oldPassword: string, newPassword: string): Promise<void>;
+    /** Update user profile */
+    updateProfile?(displayName?: string, photoURL?: string): Promise<USER>;
+}
+/**
+ * Implement this function to allow access to specific users.
+ * @group Hooks and utilities
+ */
+export type Authenticator<USER extends User = User> = (props: {
+    /**
+     * Logged-in user or null
+     */
+    user: USER | null;
+    /**
+     * AuthController
+     */
+    authController: AuthController<USER>;
+    /**
+     * Unified data access API
+     */
+    data: RebaseData;
+    /**
+     * Used storage implementation
+     */
+    storageSource: StorageSource;
+}) => boolean | Promise<boolean>;

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

@@ -0,0 +1,58 @@
+import { User } from "../users";
+import { RebaseData } from "./data";
+/**
+ * Event type for authentication state changes
+ */
+export type AuthChangeEvent = 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED';
+/**
+ * Standard session interface representing an authenticated state
+ */
+export interface RebaseSession {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    user: User;
+}
+import { StorageSource } from "./storage";
+/**
+ * Unified Authentication Client Interface
+ * Pure functional SDK interface, decoupled from UI and React hooks
+ */
+export interface AuthClient {
+    /**
+     * Get the current user from the server or cache
+     */
+    getUser(): Promise<User | null>;
+    /**
+     * Get the currently active session
+     */
+    getSession(): RebaseSession | null;
+    /**
+     * Sign out the current user and clear local session
+     */
+    signOut(): Promise<void>;
+    /**
+     * Subscribe to authentication state changes
+     */
+    onAuthStateChange(callback: (event: AuthChangeEvent, session: RebaseSession | null) => void): () => void;
+    /**
+     * Manually refresh the session token
+     */
+    refreshSession(): Promise<RebaseSession>;
+    [key: string]: any;
+}
+/**
+ * Overarching abstraction that unites Data, Auth, and Storage.
+ * Adapters for Supabase or Firebase simply need to implement this interface.
+ */
+export interface RebaseClient<DB = any> {
+    /** Unified Data access layer */
+    data: RebaseData;
+    /** Unified Authentication layer */
+    auth: AuthClient;
+    /** Unified Storage layer */
+    storage?: StorageSource;
+    /** Optional admin panel specific tasks */
+    admin?: any;
+    [key: string]: any;
+}

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

@@ -0,0 +1,44 @@
+import { EntityCollection, EntityReference } from "../types";
+/**
+ * Controller that provides access to the registered entity collections.
+ * @group Models
+ */
+export type CollectionRegistryController<EC extends EntityCollection = EntityCollection<any>> = {
+    /**
+     * List of the mapped collections in the CMS.
+     * Each entry relates to a collection in the root database.
+     * Each of the navigation entries in this field
+     * generates an entry in the main menu.
+     */
+    collections?: EntityCollection[];
+    /**
+     * Is the registry ready to be used
+     */
+    initialised: boolean;
+    /**
+     * Get the collection configuration for a given path.
+     * The collection is resolved from the given path or alias.
+     */
+    getCollection: (slugOrPath: string, includeUserOverride?: boolean) => EC | undefined;
+    /**
+     * Get the raw, un-normalized collection configuration.
+     * This bypasses the `CollectionRegistry` normalization (such as injecting `relation` instances).
+     * This is strictly for the Visual Editor to manipulate AST code without persisting runtime state.
+     */
+    getRawCollection: (slugOrPath: string) => EC | undefined;
+    /**
+     * Retrieve all the related parent references for a given path
+     * @param path
+     */
+    getParentReferencesFromPath: (path: string) => EntityReference[];
+    /**
+     * Retrieve all the related parent collection ids for a given path
+     * @param path
+     */
+    getParentCollectionIds: (path: string) => string[];
+    /**
+     * Resolve paths from a list of ids
+     * @param ids
+     */
+    convertIdsToPaths: (ids: string[]) => string[];
+};

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

@@ -0,0 +1,54 @@
+import React from "react";
+import { EntityLinkBuilder, Locale, EntityAction, EntityCustomView, RebasePlugin, PropertyConfig, SlotContribution } from "../types";
+export type CustomizationController = {
+    /**
+     * Builder for generating utility links for entities
+     */
+    entityLinkBuilder?: EntityLinkBuilder;
+    /**
+     * Use plugins to modify the behaviour of the CMS.
+     */
+    plugins?: RebasePlugin[];
+    /**
+     * Pre-merged slots from plugins + direct slot contributions.
+     */
+    resolvedSlots: SlotContribution[];
+    /**
+     * List of additional custom views for entities.
+     * You can use the key to reference the custom view in
+     * the `entityViews` prop of a collection.
+     *
+     * You can also define an entity view from the UI.
+     */
+    entityViews?: EntityCustomView[];
+    /**
+     * List of actions that can be performed on entities.
+     * These actions are displayed in the entity view and in the collection view.
+     * You can later reuse these actions in the `entityActions` prop of a collection,
+     * by specifying the `key` of the action.
+     */
+    entityActions?: EntityAction[];
+    /**
+     * Format of the dates in the CMS.
+     * Defaults to 'MMMM dd, yyyy, HH:mm:ss'
+     */
+    dateTimeFormat?: string;
+    /**
+     * Locale of the CMS, currently only affecting dates
+     */
+    locale?: Locale;
+    /**
+     * Record of custom form fields to be used in the CMS.
+     * You can use the key to reference the custom field in
+     * the `propertyConfig` prop of a property in a collection.
+     */
+    propertyConfigs: Record<string, PropertyConfig>;
+    components?: {
+        /**
+         * Component to render when a reference is missing
+         */
+        missingReference?: React.ComponentType<{
+            path: string;
+        }>;
+    };
+};