@rebasepro/server-core 0.0.1-canary.4d4fb3e

package/dist/server-core/src/storage/S3StorageController.d.ts

@@ -0,0 +1,36 @@
+/**
+ * S3-compatible storage controller (works with AWS S3 and MinIO)
+ */
+import { StorageController, S3StorageConfig } from './types';
+import { UploadFileProps, UploadFileResult, DownloadConfig, StorageListResult } from '@rebasepro/types';
+/**
+ * S3-compatible storage implementation
+ * Works with AWS S3 and MinIO (with forcePathStyle option)
+ */
+export declare class S3StorageController implements StorageController {
+    private config;
+    private client;
+    constructor(config: S3StorageConfig);
+    getType(): 's3';
+    /**
+     * Validate file before upload
+     */
+    private validateFile;
+    /**
+     * Get the bucket name - either from parameter or config
+     */
+    private getBucket;
+    uploadFile({ file, fileName, path: storagePath, metadata, bucket }: UploadFileProps): Promise<UploadFileResult>;
+    /**
+     * Flatten nested metadata to string values (S3 requirement)
+     */
+    private flattenMetadata;
+    getDownloadURL(storagePath: string, bucket?: string): Promise<DownloadConfig>;
+    getFile(storagePath: string, bucket?: string): Promise<File | null>;
+    deleteFile(storagePath: string, bucket?: string): Promise<void>;
+    list(storagePath: string, options?: {
+        bucket?: string;
+        maxResults?: number;
+        pageToken?: string;
+    }): Promise<StorageListResult>;
+}

package/dist/server-core/src/storage/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Storage module for Rebase backend
+ *
+ * Provides file storage functionality with support for:
+ * - Local filesystem storage (default, zero config)
+ * - S3-compatible storage (AWS S3, MinIO)
+ */
+export * from './types';
+export { LocalStorageController } from './LocalStorageController';
+export { S3StorageController } from './S3StorageController';
+export { createStorageRoutes } from './routes';
+export type { StorageRoutesConfig } from './routes';
+export * from './storage-registry';
+import { BackendStorageConfig, StorageController } from './types';
+/**
+ * Factory function to create a storage controller based on configuration
+ */
+export declare function createStorageController(config: BackendStorageConfig): StorageController;

package/dist/server-core/src/storage/routes.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Storage REST API routes using Hono
+ */
+import { Hono } from 'hono';
+import { StorageController } from './types';
+import { HonoEnv } from '../api/types';
+export interface StorageRoutesConfig {
+    controller: StorageController;
+    /** Base path for storage routes (default: '/api/storage') */
+    basePath?: string;
+    /** Require authentication for write operations (default: true) */
+    requireAuth?: boolean;
+    /** Allow unauthenticated read access to stored files (default: false).
+     *  When false and requireAuth is true, reads also require authentication. */
+    publicRead?: boolean;
+}
+/**
+ * Extract the wildcard portion of a route path from the full request path.
+ *
+ * Hono's `c.req.param('*')` does not work reliably in sub-routers mounted
+ * via `app.route(prefix, subRouter)`. Instead we derive the wildcard value
+ * from the fully-resolved `c.req.path` and `c.req.routePath`.
+ *
+ * For a route `/metadata/*` mounted at `/api/storage`, a request to
+ * `/api/storage/metadata/default/file.jpg` yields routePath
+ * `/api/storage/metadata/*`.  We strip the prefix (everything before `/*`)
+ * plus one character for the trailing `/` to obtain `default/file.jpg`.
+ */
+export declare function extractWildcardPath(c: {
+    req: {
+        path: string;
+        routePath: string;
+    };
+}): string;
+/**
+ * Create storage REST API routes
+ */
+export declare function createStorageRoutes(config: StorageRoutesConfig): Hono<HonoEnv>;

package/dist/server-core/src/storage/storage-registry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Storage Registry
+ *
+ * Manages multiple storage controllers for Rebase backend.
+ * Allows different storage backends for different use cases.
+ *
+ * Usage:
+ * - Single storage: Pass a single StorageController → maps to "(default)"
+ * - Multiple storages: Pass a map of { storageId: StorageController }
+ * - String properties use `storageId` in their config to specify which storage to use
+ * - Properties without `storageId` fallback to "(default)"
+ */
+import { StorageController } from "./types";
+/**
+ * The default storage identifier used when:
+ * - A single storage controller is provided (not a map)
+ * - A property doesn't specify a storageId
+ */
+export declare const DEFAULT_STORAGE_ID = "(default)";
+/**
+ * Registry for managing multiple storage controllers
+ */
+export interface StorageRegistry {
+    /**
+     * Register a storage controller with an ID
+     * @param id - Unique identifier for this storage (e.g., "media", "backups")
+     * @param controller - The StorageController instance
+     */
+    register(id: string, controller: StorageController): void;
+    /**
+     * Get the default storage controller (id = "(default)")
+     * @throws Error if no default storage is registered
+     */
+    getDefault(): StorageController;
+    /**
+     * Get a storage controller by ID
+     * @param id - Storage identifier, or undefined/null for default
+     * @returns The StorageController, or undefined if not found
+     */
+    get(id: string | undefined | null): StorageController | undefined;
+    /**
+     * Get a storage controller by ID, with fallback to default
+     * @param id - Storage identifier, or undefined/null for default
+     * @returns The StorageController (falls back to default if id not found)
+     * @throws Error if neither the specified nor default storage exists
+     */
+    getOrDefault(id: string | undefined | null): StorageController;
+    /**
+     * Check if a storage with the given ID exists
+     */
+    has(id: string): boolean;
+    /**
+     * List all registered storage IDs
+     */
+    list(): string[];
+    /**
+     * Get the number of registered storage controllers
+     */
+    size(): number;
+}
+/**
+ * Default implementation of StorageRegistry
+ */
+export declare class DefaultStorageRegistry implements StorageRegistry {
+    private controllers;
+    /**
+     * Create a StorageRegistry from either a single controller or a map
+     * @param input - Single StorageController (maps to "(default)") or Record<string, StorageController>
+     */
+    static create(input: StorageController | Record<string, StorageController>): DefaultStorageRegistry;
+    register(id: string, controller: StorageController): void;
+    getDefault(): StorageController;
+    get(id: string | undefined | null): StorageController | undefined;
+    getOrDefault(id: string | undefined | null): StorageController;
+    has(id: string): boolean;
+    list(): string[];
+    size(): number;
+}

package/dist/server-core/src/storage/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Storage configuration and types for Rebase backend
+ */
+import { UploadFileProps, UploadFileResult, DownloadConfig, StorageListResult } from "@rebasepro/types";
+/**
+ * Local filesystem storage configuration
+ */
+export interface LocalStorageConfig {
+    type: 'local';
+    /** Base directory for file storage (e.g., './uploads') */
+    basePath: string;
+    /** Maximum file size in bytes (default: 50MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (if not set, all types allowed) */
+    allowedMimeTypes?: string[];
+    /** Base URL for generating download URLs (default: auto-detected from request) */
+    baseUrl?: string;
+}
+/**
+ * S3-compatible storage configuration (works with AWS S3 and MinIO)
+ */
+export interface S3StorageConfig {
+    type: 's3';
+    /** S3 bucket name */
+    bucket: string;
+    /** AWS region (e.g., 'us-east-1') */
+    region?: string;
+    /** Custom endpoint URL (required for MinIO) */
+    endpoint?: string;
+    /** AWS access key ID */
+    accessKeyId: string;
+    /** AWS secret access key */
+    secretAccessKey: string;
+    /** Use path-style URLs (required for MinIO) */
+    forcePathStyle?: boolean;
+    /** Maximum file size in bytes (default: 50MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (if not set, all types allowed) */
+    allowedMimeTypes?: string[];
+    /** URL expiration time in seconds for signed URLs (default: 3600) */
+    signedUrlExpiration?: number;
+}
+/**
+ * Storage configuration - either local filesystem or S3-compatible
+ */
+export type BackendStorageConfig = LocalStorageConfig | S3StorageConfig;
+/**
+ * Storage controller interface for backend implementations
+ */
+export interface StorageController {
+    /**
+     * Upload a file
+     */
+    uploadFile(props: UploadFileProps): Promise<UploadFileResult>;
+    /**
+     * Get a download URL for a file
+     */
+    getDownloadURL(path: string, bucket?: string): Promise<DownloadConfig>;
+    /**
+     * Get file as a File object
+     */
+    getFile(path: string, bucket?: string): Promise<File | null>;
+    /**
+     * Delete a file
+     */
+    deleteFile(path: string, bucket?: string): Promise<void>;
+    /**
+     * List files in a path
+     */
+    list(path: string, options?: {
+        bucket?: string;
+        maxResults?: number;
+        pageToken?: string;
+    }): Promise<StorageListResult>;
+    /**
+     * Get the storage configuration type
+     */
+    getType(): 'local' | 's3';
+}
+/**
+ * Default maximum file size (50MB)
+ */
+export declare const DEFAULT_MAX_FILE_SIZE: number;
+/**
+ * Common image MIME types
+ */
+export declare const IMAGE_MIME_TYPES: string[];
+/**
+ * Common document MIME types
+ */
+export declare const DOCUMENT_MIME_TYPES: string[];

package/dist/server-core/src/types/index.d.ts

@@ -0,0 +1,11 @@
+import { Entity, FetchCollectionProps, FetchEntityProps } from "@rebasepro/types";
+export interface ListenCollectionRequest<M extends Record<string, unknown> = Record<string, unknown>> extends FetchCollectionProps<M> {
+    subscriptionId: string;
+    onUpdate: (entities: Entity<M>[]) => void;
+    onError?: (error: Error) => void;
+}
+export interface ListenEntityRequest<M extends Record<string, unknown> = Record<string, unknown>> extends FetchEntityProps<M> {
+    subscriptionId: string;
+    onUpdate: (entity: Entity<M> | null) => void;
+    onError?: (error: Error) => void;
+}

package/dist/server-core/src/utils/logging.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configure console log levels based on environment variable
+ * Call this early in your application to set up proper logging levels
+ */
+export declare function configureLogLevel(logLevel?: string): void;
+/**
+ * Reset console methods to their original state
+ */
+export declare function resetConsole(): void;

package/dist/server-core/src/utils/sql.d.ts

@@ -0,0 +1,27 @@
+import { SQL } from "drizzle-orm";
+/**
+ * Returns a SQL chunk calling `auth.uid()` — the current user's ID.
+ * This is a Supabase-style helper function created in the `auth` schema
+ * that reads `app.user_id` set per-transaction by `withAuth()`.
+ *
+ * @example
+ * sql`${table.user_id} = ${authUid()}`
+ */
+export declare const authUid: () => SQL;
+/**
+ * Returns a SQL chunk calling `auth.roles()` — the current user's roles
+ * as a comma-separated string.
+ * Reads `app.user_roles` set per-transaction by `withAuth()`.
+ *
+ * @example
+ * sql`auth.roles() ~ 'admin'`
+ */
+export declare const authRoles: () => SQL;
+/**
+ * Returns a SQL chunk calling `auth.jwt()` — the full JWT claims as JSONB.
+ * Reads `app.jwt` set per-transaction by `withAuth()`.
+ *
+ * @example
+ * sql`auth.jwt()->>'sub'`
+ */
+export declare const authJwt: () => SQL;

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;
+        }>;
+    };
+};