@rebasepro/types 0.0.1-canary.0

package/src/controllers/datasource.ts

@@ -0,0 +1,218 @@
+import { CollectionRegistryController } from "./navigation";
+import { Entity, EntityCollection, EntityStatus, EntityValues, FilterValues, TableColumnInfo } from "../types";
+import { RebaseContext } from "../rebase_context";
+
+/**
+ * @group Datasource
+ */
+export interface FetchEntityProps<M extends Record<string, any> = any> {
+    path: string;
+    entityId: string | number;
+    databaseId?: string;
+    collection?: EntityCollection<M, any>
+}
+
+/**
+ * @group Datasource
+ */
+export type ListenEntityProps<M extends Record<string, any> = any> =
+    FetchEntityProps<M>
+    & {
+        onUpdate: (entity: Entity<M> | null) => void,
+        onError?: (error: Error) => void,
+    }
+
+/**
+ * @group Datasource
+ */
+export interface FetchCollectionProps<M extends Record<string, any> = any> {
+    path: string;
+    collection?: EntityCollection<M>;
+    filter?: FilterValues<Extract<keyof M, string>>,
+    limit?: number;
+    startAfter?: unknown;
+    orderBy?: string;
+    searchString?: string;
+    order?: "desc" | "asc";
+}
+
+/**
+ * @group Datasource
+ */
+export type ListenCollectionProps<M extends Record<string, any> = any> =
+    FetchCollectionProps<M> &
+    {
+        onUpdate: (entities: Entity<M>[]) => void;
+        onError?: (error: Error) => void;
+    };
+
+/**
+ * @group Datasource
+ */
+export interface SaveEntityProps<M extends Record<string, any> = any> {
+    path: string;
+    values: Partial<EntityValues<M>>;
+    entityId?: string | number; // can be empty for new entities
+    previousValues?: Partial<EntityValues<M>>;
+    collection?: EntityCollection<M>;
+    status: EntityStatus;
+}
+
+/**
+ * @group Datasource
+ */
+export interface DeleteEntityProps<M extends Record<string, any> = any> {
+    entity: Entity<M>;
+    collection?: EntityCollection<M>;
+}
+
+export type FilterCombinationValidProps = {
+    path: string;
+    databaseId?: string;
+    collection: EntityCollection<any>;
+    filterValues: FilterValues<any>;
+    sortBy?: [string, "asc" | "desc"];
+};
+
+/**
+ * Component in charge of communicating with the data source.
+ * @group Datasource
+ */
+export interface DataSource {
+
+    /**
+     * Key that identifies this data source
+     */
+    key?: string;
+
+    /**
+     * If the data source has been initialised
+     */
+    initialised?: boolean;
+
+    /**
+     * Fetch data from a collection
+     * @param props
+     * @return Promise of entities
+     * @see useCollectionFetch if you need this functionality implemented as a hook
+     */
+    fetchCollection<M extends Record<string, any> = any>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+
+    /**
+     * Listen to a collection in a given path. If you don't implement this method
+     * `fetchCollection` will be used instead, with no real time updates.
+     * @param props
+     * @return Function to cancel subscription
+     * @see useCollectionFetch if you need this functionality implemented as a hook
+     */
+    listenCollection?<M extends Record<string, any> = any>(props: ListenCollectionProps<M>): () => void;
+
+    /**
+     * Retrieve an entity given a path and a collection
+     * @param props
+     */
+    fetchEntity<M extends Record<string, any> = any>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+
+    /**
+     * Get realtime updates on one entity.
+     * @param props
+     * @return Function to cancel subscription
+     */
+    listenEntity?<M extends Record<string, any> = any>(props: ListenEntityProps<M>): () => void;
+
+    /**
+     * Save entity to the specified path
+     * @param props
+     */
+    saveEntity<M extends Record<string, any> = any>(props: SaveEntityProps<M>): Promise<Entity<M>>;
+
+    /**
+     * Delete an entity
+     * @param props
+     * @return was the whole deletion flow successful
+     */
+    deleteEntity<M extends Record<string, any> = any>(props: DeleteEntityProps<M>): Promise<void>;
+
+    /**
+     * Check if the given property is unique in the given collection
+     * @param path Collection path
+     * @param name of the property
+     * @param value
+     * @param entityId
+     * @param collection
+     * @return `true` if there are no other fields besides the given entity
+     */
+    checkUniqueField(
+        path: string,
+        name: string,
+        value: unknown,
+        entityId?: string | number,
+        collection?: EntityCollection
+    ): Promise<boolean>;
+
+    /**
+     * Count the number of entities in a collection
+     */
+    countEntities?<M extends Record<string, any> = any>(props: FetchCollectionProps<M>): Promise<number>;
+
+    /**
+     * Check if the given filter combination is valid
+     * @param props
+     */
+    isFilterCombinationValid?(props: Omit<FilterCombinationValidProps, "collection"> & {
+        databaseId?: string
+    }): boolean;
+
+    /**
+     * Get the object to generate the current time in the datasource
+     */
+    currentTime?: () => unknown;
+
+    delegateToCMSModel?: (data: unknown) => unknown;
+
+    cmsToDelegateModel?: (data: unknown) => unknown;
+
+    initTextSearch?: (props: {
+        context: RebaseContext,
+        path: string,
+        databaseId?: string,
+        collection: EntityCollection,
+        parentCollectionIds?: string[]
+    }) => Promise<boolean>;
+
+    /**
+     * Execute raw SQL (if supported by the datasource)
+     */
+    executeSql?(sql: string, options?: { database?: string, role?: string }): Promise<Record<string, unknown>[]>;
+
+    /**
+     * Fetch the available databases (if supported by the datasource)
+     */
+    fetchAvailableDatabases?(): Promise<string[]>;
+
+    /**
+     * Fetch the available roles (if supported by the datasource)
+     */
+    fetchAvailableRoles?(): Promise<string[]>;
+
+    /**
+     * Fetch the current database name (if supported by the datasource)
+     */
+    fetchCurrentDatabase?(): Promise<string | undefined>;
+
+    /**
+     * Fetch database tables not yet mapped to a collection (if supported)
+     */
+    fetchUnmappedTables?(mappedPaths?: string[]): Promise<string[]>;
+
+    /**
+     * Fetch column metadata for a given table (if supported)
+     */
+    fetchTableColumns?(tableName: string): Promise<TableColumnInfo[]>;
+
+    /**
+     * Flag to indicate if the datasource delegate has requested the initialization of the text search index
+     */
+    needsInitTextSearch?: boolean;
+
+}

package/src/controllers/dialogs_controller.tsx

@@ -0,0 +1,37 @@
+import React from "react";
+
+/**
+ * Controller to open the side dialog
+ * @group Hooks and utilities
+ */
+export interface DialogsController {
+
+    /**
+     * Close the last dialog
+     */
+    close: () => void;
+
+    /**
+     * Open a dialog
+     * @param props
+     */
+    open: <T extends object = object>(props: DialogControllerEntryProps<T>) => { closeDialog: () => void };
+}
+
+/**
+ * Props used to open a side dialog
+ * @group Hooks and utilities
+ */
+export interface DialogControllerEntryProps<T extends object = object> {
+
+    key: string;
+    /**
+     * The component type that will be rendered
+     */
+    Component: React.ComponentType<{ open: boolean, closeDialog: () => void } & T>;
+    /**
+     * Props to pass to the dialog component
+     */
+    props?: T;
+
+}

package/src/controllers/index.ts

@@ -0,0 +1,11 @@
+export * from "./analytics_controller";
+export * from "./auth";
+export * from "./customization_controller";
+export * from "./datasource";
+export * from "./dialogs_controller";
+export * from "./local_config_persistence";
+export * from "./navigation";
+export * from "./side_dialogs_controller";
+export * from "./side_entity_controller";
+export * from "./snackbar";
+export * from "./storage";

package/src/controllers/local_config_persistence.tsx

@@ -0,0 +1,22 @@
+import { EntityCollection } from "../types";
+
+/**
+ * @group Models
+ */
+export type PartialEntityCollection<M extends Record<string, any> = any> = Partial<EntityCollection<M>>;
+
+/**
+ * This interface is in charge of defining the controller that persists
+ * modifications to a collection or collection, and retrieves them back from
+ * a data source, such as local storage or Firestore.
+ */
+export interface UserConfigurationPersistence {
+    onCollectionModified: <M extends Record<string, any> = any>(path: string, partialCollection: PartialEntityCollection<M>) => void;
+    getCollectionConfig: <M extends Record<string, any> = any>(path: string) => PartialEntityCollection<M>;
+    recentlyVisitedPaths: string[];
+    setRecentlyVisitedPaths: (paths: string[]) => void;
+    favouritePaths: string[];
+    setFavouritePaths: (paths: string[]) => void;
+    collapsedGroups: string[];
+    setCollapsedGroups: (paths: string[]) => void;
+}

package/src/controllers/navigation.ts

@@ -0,0 +1,317 @@
+import React from "react";
+import { EntityCollection, EntityReference, RebasePlugin } from "../types";
+
+/**
+ * Controller that handles URL path building and resolution.
+ * @group Models
+ */
+export type CMSUrlController = {
+    /**
+     * Default path under the navigation routes of the CMS will be created.
+     * Defaults to '/'. You may want to change this `basepath` to 'admin' for example.
+     */
+    basePath: string;
+
+    /**
+     * Default path under the collection routes of the CMS will be created.
+     * It defaults to '/c'
+     */
+    baseCollectionPath: string;
+
+    /**
+     * Convert a URL path to a collection or entity path
+     * `/c/products` => `products`
+     * `/my_cms/c/products/B34SAP8Z` => `products/B34SAP8Z`
+     * `/my_cms/my_view` => `my_view`
+     * @param cmsPath
+     */
+    urlPathToDataPath: (cmsPath: string) => string;
+
+    /**
+     * Base url path for the home screen
+     */
+    homeUrl: string;
+
+    /**
+     * Check if a url path belongs to a collection
+     * @param path
+     */
+    isUrlCollectionPath: (urlPath: string) => boolean;
+
+    /**
+     * Build a URL collection path from a data path
+     * `products` => `/c/products`
+     * `products/B34SAP8Z` => `/c/products/B34SAP8Z`
+     * @param path
+     */
+    buildUrlCollectionPath: (path: string) => string;
+
+    /**
+     * Build a URL path for the CMS (e.g. for custom views)
+     * @param path
+     */
+    buildCMSUrlPath: (path: string) => string;
+
+    /**
+     * Turn a path with collection ids into a resolved path.
+     * The ids (typically used in urls) will be replaced with relative paths (typically used in database paths)
+     * @param path
+     */
+    resolveDatabasePathsFrom: (path: string) => string;
+
+    /**
+     * A function to navigate to a specified route or URL.
+     *
+     * @param {string} to - The target route or URL to navigate to.
+     * @param {NavigateOptions} [options] - Optional configuration settings for navigation, such as replace behavior or state data.
+     */
+    navigate: (to: string, options?: NavigateOptions) => void;
+};
+
+/**
+ * Controller that manages the state of the navigation menu,
+ * including resolved views and top-level grouping.
+ * @group Models
+ */
+export type NavigationStateController = {
+    /**
+     * Custom additional views created by the developer, added to the main
+     * navigation
+     */
+    views?: CMSView[];
+
+    /**
+     * Custom additional views created by the developer, added to the admin
+     * navigation
+     */
+    adminViews?: CMSView[];
+
+    /**
+     * Configuration for the views that should be displayed at the top
+     * level of the navigation (e.g. in the home page or the navigation
+     * drawer)
+     */
+    topLevelNavigation?: NavigationResult;
+
+    /**
+     * Is the navigation loading (the configuration persistence has not
+     * loaded yet, or a specified navigation builder has not completed)
+     */
+    loading: boolean;
+
+    /**
+     * Was there an error while loading the navigation data
+     */
+    navigationLoadingError?: unknown;
+
+    /**
+     * Call this method to recalculate the navigation
+     */
+    refreshNavigation: () => void;
+
+    /**
+     * Plugin system allowing to extend the CMS functionality.
+     */
+    plugins?: RebasePlugin<any, any, any>[];
+};
+
+/**
+ * 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[];
+
+};
+
+/**
+ * Legacy monolithic controller that includes the resolved navigation and utility methods and attributes.
+ * It is a combination of CMSUrlController, NavigationStateController, and CollectionRegistryController.
+ * @group Models
+ * @deprecated Use the specific controllers instead.
+ */
+export type NavigationController<EC extends EntityCollection = EntityCollection<any>> =
+    CMSUrlController &
+    NavigationStateController &
+    CollectionRegistryController<EC>;
+
+export interface NavigateOptions {
+    replace?: boolean;
+    state?: unknown;
+    preventScrollReset?: boolean;
+    relative?: "route" | "path";
+    flushSync?: boolean;
+    viewTransition?: boolean;
+}
+
+// currently not used, in favor of a single blocker in `RebaseRoute`
+export type NavigationBlocker = {
+    updateBlockListener: (path: string, block: boolean, basePath?: string) => () => void;
+    isBlocked: (path: string) => boolean;
+    proceed?: () => void;
+    reset?: () => void;
+};
+
+/**
+ * Custom additional views created by the developer, added to the main
+ * navigation.
+ * @group Models
+ */
+export interface CMSView {
+
+    /**
+     * CMS Path you can reach this view from.
+     */
+    slug: string;
+
+    /**
+     * Name of this view
+     */
+    name: string;
+
+    /**
+     * Optional description of this view. You can use Markdown
+     */
+    description?: string;
+
+    /**
+     * Icon key to use in this view.
+     * You can use any of the icons in the Material specs:
+     * https://fonts.google.com/icons
+     * e.g. 'account_tree' or 'person'
+     * Find all the icons in https://rebase.pro/docs/icons
+     */
+    icon?: string | React.ReactNode;
+
+    /**
+     * Should this view be hidden from the main navigation panel.
+     * It will still be accessible if you reach the specified path
+     */
+    hideFromNavigation?: boolean;
+
+    /**
+     * Component to be rendered. This can be any React component, and can use
+     * any of the provided hooks
+     */
+    view: React.ReactNode;
+
+    /**
+     * Optional field used to group top level navigation entries under a
+     * navigation view.
+     * This prop is ignored for admin views.
+     */
+    group?: string;
+
+    /**
+     * If true, a wildcard route (slug/*) is automatically registered
+     * alongside the base route, enabling nested navigation within this view.
+     */
+    nestedRoutes?: boolean;
+
+}
+
+/**
+ * A composable section that can be rendered on the home page.
+ * Use this to add custom content alongside the auto-generated
+ * navigation groups.
+ * @group Models
+ */
+export interface HomePageSection {
+    /**
+     * Unique key for this section.
+     */
+    key: string;
+
+    /**
+     * Title displayed as the section header.
+     */
+    title: string;
+
+    /**
+     * Arbitrary React content rendered inside the section.
+     */
+    children: React.ReactNode;
+}
+
+/**
+ * Used to group navigation entries in the main navigation.
+ */
+export interface NavigationGroupMapping {
+    /**
+     * Name of the group, used to display the group header in the UI
+     */
+    name: string;
+    /**
+     * List of collection ids or view paths that belong to this group.
+     */
+    entries: string[];
+}
+
+export interface NavigationEntry {
+    id: string;
+    url: string;
+    name: string;
+    slug: string;
+    type: "collection" | "view" | "admin";
+    collection?: EntityCollection;
+    view?: CMSView;
+    description?: string;
+    group: string;
+}
+
+export type NavigationResult = {
+
+    allowDragAndDrop: boolean;
+
+    navigationEntries: NavigationEntry[],
+
+    groups: string[],
+
+    onNavigationEntriesUpdate: (entries: NavigationGroupMapping[]) => void;
+};
+

package/src/controllers/side_dialogs_controller.tsx

@@ -0,0 +1,82 @@
+import React from "react";
+
+/**
+ * Controller to open the side dialog
+ * @group Hooks and utilities
+ */
+export interface SideDialogsController {
+
+    /**
+     * Close the last panel
+     */
+    close: () => void;
+
+    /**
+     * List of side panels currently open
+     */
+    sidePanels: SideDialogPanelProps[];
+
+    /**
+     * Override the current side panels
+     * @param panels
+     */
+    setSidePanels: (panels: SideDialogPanelProps[]) => void;
+
+    /**
+     * Open one or multiple side panels
+     * @param props
+     */
+    open: (panelProps: SideDialogPanelProps | SideDialogPanelProps[]) => void;
+
+    /**
+     * Replace the last open panel with the given one
+     * @param props
+     */
+    replace: (panelProps: SideDialogPanelProps | SideDialogPanelProps[]) => void;
+}
+
+/**
+ * Props used to open a side dialog
+ * @group Hooks and utilities
+ */
+export interface SideDialogPanelProps {
+
+    /**
+     * A key that identifies this panel
+     */
+    key: string;
+
+    /**
+     * The component type that will be rendered
+     */
+    component: React.ReactNode;
+
+    /**
+     * Optional width of the panel
+     */
+    width?: string;
+
+    /**
+     * When open, change the URL to this path.
+     * Note that if you want to restore state from a URL you need to add the
+     * logic yourself by listening to URL updates, and probably call `open`.
+     */
+    urlPath?: string;
+
+    /**
+     * If the navigation stack is empty (you landed in the `urlPath` url), what
+     * url path to change to when the panel gets closed.
+     */
+    parentUrlPath?: string;
+
+    /**
+     * Callback when the panel is closed
+     */
+    onClose?: () => void;
+
+    /**
+     * Use this prop to store additional data in the panel
+     */
+    additional?: unknown;
+
+}