@rebasepro/sdk-generator 0.0.1-canary.4d4fb3e

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

@@ -0,0 +1,64 @@
+/**
+ * Describes the capabilities and features supported by a data source (driver).
+ *
+ * Each driver (Postgres, Firebase, MongoDB, etc.) declares which features it
+ * supports. The CMS uses this descriptor to:
+ * - Show/hide editor tabs (e.g. Relations for SQL, Subcollections for Firebase)
+ * - Filter the property type picker (e.g. `relation` for SQL, `reference` for Firebase)
+ * - Toggle driver-specific form controls (e.g. `columnType` for SQL)
+ *
+ * @group Models
+ */
+export interface DataSourceCapabilities {
+    /** Unique driver key (e.g. "postgres", "firestore", "mongodb") */
+    key: string;
+    /** Human-readable label for the UI (e.g. "PostgreSQL", "Firebase / Firestore") */
+    label: string;
+    /** Does this source support SQL-style relations (JOINs)? */
+    supportsRelations: boolean;
+    /** Does this source support nested subcollections? */
+    supportsSubcollections: boolean;
+    /** Does this source support Row Level Security policies? */
+    supportsRLS: boolean;
+    /** Does this source support document references (Firebase-style)? */
+    supportsReferences: boolean;
+    /** Does this source support SQL column type annotations? */
+    supportsColumnTypes: boolean;
+    /** Does this source support real-time listeners? */
+    supportsRealtime: boolean;
+    /** Does this source support SQL admin operations (SQL editor, EXPLAIN, etc.)? */
+    supportsSQLAdmin: boolean;
+    /** Does this source support document admin operations (aggregation, stats)? */
+    supportsDocumentAdmin: boolean;
+    /** Does this source support schema admin (unmapped tables, table metadata)? */
+    supportsSchemaAdmin: boolean;
+}
+/**
+ * Subset of DataSourceCapabilities containing only feature flags.
+ * Useful when you only need to check capabilities without UI metadata.
+ * @group Models
+ */
+export type DataSourceFeatures = Pick<DataSourceCapabilities, "supportsRelations" | "supportsSubcollections" | "supportsRLS" | "supportsReferences" | "supportsColumnTypes" | "supportsRealtime" | "supportsSQLAdmin" | "supportsDocumentAdmin" | "supportsSchemaAdmin">;
+/** @group Models */
+export declare const POSTGRES_CAPABILITIES: DataSourceCapabilities;
+/** @group Models */
+export declare const FIREBASE_CAPABILITIES: DataSourceCapabilities;
+/** @group Models */
+export declare const MONGODB_CAPABILITIES: DataSourceCapabilities;
+/**
+ * Fallback capabilities when the driver is unknown.
+ * Enables everything so nothing is hidden unexpectedly.
+ * @group Models
+ */
+export declare const DEFAULT_CAPABILITIES: DataSourceCapabilities;
+/**
+ * Look up capabilities for a given driver key.
+ * If `driver` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
+ * @group Models
+ */
+export declare function getDataSourceCapabilities(driver?: string): DataSourceCapabilities;
+/**
+ * Register custom capabilities for a third-party driver.
+ * @group Models
+ */
+export declare function registerDataSourceCapabilities(capabilities: DataSourceCapabilities): void;

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

@@ -0,0 +1,145 @@
+/**
+ * New or existing status
+ * @group Models
+ */
+export type EntityStatus = "new" | "existing" | "copy";
+/**
+ * Representation of an entity fetched from the driver
+ * @group Models
+ */
+export interface Entity<M extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * ID of the entity
+     */
+    id: string | number;
+    /**
+     * A string representing the path of the referenced document (relative
+     * to the root of the database).
+     */
+    path: string;
+    /**
+     * Current values
+     */
+    values: EntityValues<M>;
+    /**
+     * Which driver this entity belongs to (e.g., 'postgres', 'firestore').
+     * If not specified, the default driver is assumed.
+     */
+    driver?: string;
+    /**
+     * Which database within the driver (e.g., for Firestore multi-database).
+     * If not specified, the default database of the driver is used.
+     */
+    databaseId?: string;
+}
+/**
+ * This type represents a record of key value pairs as described in an
+ * entity collection.
+ * @group Models
+ */
+export type EntityValues<M extends Record<string, unknown>> = M;
+/**
+ * Props for creating an EntityReference
+ */
+export interface EntityReferenceProps {
+    /** ID of the entity */
+    id: string;
+    /** Path of the collection (relative to the root of the database) */
+    path: string;
+    /** Which driver (e.g., 'postgres', 'firestore'). Defaults to "(default)" */
+    driver?: string;
+    /** Which database within the driver. Defaults to "(default)" */
+    databaseId?: string;
+}
+/**
+ * Class used to create a reference to an entity in a different path.
+ *
+ * @example
+ * // Simple reference (most common case - single driver, single db)
+ * new EntityReference({ id: "123", path: "users" })
+ *
+ * // Reference to a different driver (e.g., Firestore)
+ * new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
+ *
+ * // Reference to a specific database within a driver
+ * new EntityReference({ id: "123", path: "orders", driver: "postgres", databaseId: "orders_db" })
+ */
+export declare class EntityReference {
+    readonly __type = "reference";
+    /**
+     * ID of the entity
+     */
+    readonly id: string;
+    /**
+     * A string representing the path of the referenced document (relative
+     * to the root of the database).
+     */
+    readonly path: string;
+    /**
+     * Which driver (e.g., 'postgres', 'firestore').
+     * Defaults to "(default)" if not specified.
+     */
+    readonly driver?: string;
+    /**
+     * Which database within the driver.
+     * Defaults to "(default)" if not specified.
+     */
+    readonly databaseId?: string;
+    /**
+     * Create a reference to an entity.
+     *
+     * @example
+     * // Simple reference (most common case)
+     * new EntityReference({ id: "123", path: "users" })
+     *
+     * // With driver
+     * new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
+     */
+    constructor(props: EntityReferenceProps);
+    get pathWithId(): string;
+    /**
+     * Get the full path including driver and database prefixes if specified.
+     * For the common case (single driver, single db), this just returns pathWithId.
+     */
+    get fullPath(): string;
+    isEntityReference(): boolean;
+}
+/**
+ * Class used to create a reference to an entity in a different path
+ */
+export declare class EntityRelation {
+    readonly __type = "relation";
+    /**
+     * ID of the entity
+     */
+    readonly id: string | number;
+    /**
+     * A string representing the path of the referenced document (relative
+     * to the root of the database).
+     */
+    readonly path: string;
+    /**
+     * Pre-fetched data payload to eliminate N+1 queries.
+     * When present, clients can use this directly instead of fetching.
+     */
+    readonly data?: Entity;
+    constructor(id: string | number, path: string, data?: Entity);
+    get pathWithId(): string;
+    isEntityReference(): boolean;
+    isEntityRelation(): boolean;
+}
+export declare class GeoPoint {
+    /**
+     * The latitude of this GeoPoint instance.
+     */
+    readonly latitude: number;
+    /**
+     * The longitude of this GeoPoint instance.
+     */
+    readonly longitude: number;
+    constructor(latitude: number, longitude: number);
+}
+export declare class Vector {
+    readonly value: number[];
+    constructor(value: number[]);
+}

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

@@ -0,0 +1,98 @@
+import React from "react";
+import { Entity } from "./entities";
+import { EntityCollection, SelectionController } from "./collections";
+import { FormContext } from "./entity_views";
+import { User } from "../users";
+import { RebaseContext } from "../rebase_context";
+import { SideEntityController } from "../controllers";
+/**
+ * An entity action is a custom action that can be performed on an entity.
+ * They are displayed in the entity view and in the collection view.
+ */
+export interface EntityAction<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User> {
+    /**
+     * Title of the action
+     */
+    name: string;
+    /**
+     * Key of the action. You only need to provide this if you want to
+     * override the default actions, or if you are not passing the action
+     * directly to the `entityActions` prop of a collection.
+     * You can define your actions at the app level, in which case you
+     * must provide a key.
+     * The default actions are:
+     * - edit
+     * - delete
+     * - copy
+     */
+    key?: string;
+    /**
+     * Icon of the action
+     */
+    icon?: React.ReactElement;
+    /**
+     * Callback when the action is clicked
+     * @param props
+     */
+    onClick(props: EntityActionClickProps<M, USER>): Promise<void> | void;
+    /**
+     * Optional callback in case you want to disable the action
+     * @param props
+     */
+    isEnabled?(props: EntityActionClickProps<M, USER>): boolean;
+    /**
+     * Show this action collapsed in the menu of the collection view.
+     * Defaults to true
+     * If false, the action will be shown in the menu
+     */
+    collapsed?: boolean;
+    /**
+     * Show this action in the form, defaults to true
+     */
+    includeInForm?: boolean;
+}
+export type EntityActionClickProps<M extends Record<string, unknown>, USER extends User = User> = {
+    entity?: Entity<M>;
+    context: RebaseContext<USER>;
+    path?: string;
+    collection?: EntityCollection<Record<string, unknown>, any>;
+    /**
+     * Optional form context, present if the action is being called from a form.
+     * This allows you to access the form state and methods, including modifying the form values.
+     */
+    formContext?: FormContext;
+    /**
+     * Present if this actions is being called from a side dialog only
+     */
+    sideEntityController?: SideEntityController;
+    /**
+     * Is the action being called from the collection view or from the entity form view?
+     */
+    view: "collection" | "form";
+    /**
+     * If the action is rendered in the form, is it open in a side panel or full screen?
+     */
+    openEntityMode: "side_panel" | "full_screen";
+    /**
+     * Optional selection controller, present if the action is being called from a collection view
+     */
+    selectionController?: SelectionController;
+    /**
+     * Optional highlight function to highlight the entity in the collection view
+     * @param entity
+     */
+    highlightEntity?: (entity: Entity<Record<string, unknown>>) => void;
+    /**
+     * Optional unhighlight function to remove the highlight from the entity in the collection view
+     * @param entity
+     */
+    unhighlightEntity?: (entity: Entity<Record<string, unknown>>) => void;
+    /**
+     * Optional function to navigate back (e.g. when deleting an entity or navigating from a form)
+     */
+    navigateBack?: () => void;
+    /**
+     * Callback to be called when the collection changes, e.g. after an entity is deleted or created.
+     */
+    onCollectionChange?: () => void;
+};

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

@@ -0,0 +1,173 @@
+import { EntityCollection } from "./collections";
+import { Entity, EntityStatus, EntityValues } from "./entities";
+import { User } from "../users";
+import { RebaseCallContext } from "../rebase_context";
+/**
+ * This interface defines all the callbacks that can be used when an entity
+ * is being created, updated or deleted.
+ * Useful for adding your own logic or blocking the execution of the operation.
+ * @group Models
+ */
+export type EntityCallbacks<M extends Record<string, any> = any, USER extends User = User> = {
+    /**
+     * Callback used after fetching data
+     * @param props
+     */
+    afterRead?(props: EntityAfterReadProps<M, USER>): Promise<Entity<M>> | Entity<M>;
+    /**
+     * Callback used before saving, you need to return the values that will get
+     * saved. If you throw an error in this method the process stops, and an
+     * error snackbar gets displayed.
+     * This runs after schema validation.
+     * @param props
+     */
+    beforeSave?(props: EntityBeforeSaveProps<M, USER>): Promise<Partial<EntityValues<M>>> | Partial<EntityValues<M>>;
+    /**
+     * Callback used when save is successful
+     * @param props
+     */
+    afterSave?(props: EntityAfterSaveProps<M, USER>): Promise<void> | void;
+    /**
+     * Callback used when saving fails
+     * @param props
+     */
+    afterSaveError?(props: EntityAfterSaveErrorProps<M, USER>): Promise<void> | void;
+    /**
+     * Callback used before the entity is deleted.
+     * If you throw an error in this method the process stops, and an
+     * error snackbar gets displayed.
+     *
+     * @param props
+     */
+    beforeDelete?(props: EntityBeforeDeleteProps<M, USER>): void;
+    /**
+     * Callback used after the entity is deleted.
+     *
+     * @param props
+     */
+    afterDelete?(props: EntityAfterDeleteProps<M, USER>): void;
+};
+/**
+ * Parameters passed to hooks when an entity is fetched
+ * @group Models
+ */
+export interface EntityAfterReadProps<M extends Record<string, any> = any, USER extends User = User> {
+    /**
+     * Collection of the entity
+     */
+    collection: EntityCollection<Record<string, unknown>, any>;
+    /**
+     * Full path of the CMS where this collection is being fetched.
+     * Might contain unresolved aliases.
+     */
+    path: string;
+    /**
+     * Fetched entity
+     */
+    entity: Entity<M>;
+    /**
+     * Context of the app status
+     */
+    context: RebaseCallContext<USER>;
+}
+/**
+ * Parameters passed to hooks before an entity is saved
+ * @group Models
+ */
+export type EntityBeforeSaveProps<M extends Record<string, any> = any, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
+    entityId?: string | number;
+};
+/**
+ * Parameters passed to hooks before an entity is saved
+ * @group Models
+ */
+export type EntityAfterSaveErrorProps<M extends Record<string, any> = any, USER extends User = User> = Omit<EntityAfterSaveProps<M, USER>, "entityId"> & {
+    entityId?: string | number;
+};
+/**
+ * Parameters passed to hooks when an entity is saved
+ * @group Models
+ */
+export interface EntityAfterSaveProps<M extends Record<string, any> = any, USER extends User = User> {
+    /**
+     * Resolved collection of the entity
+     */
+    collection: EntityCollection<Record<string, unknown>, any>;
+    /**
+     * Full path of the CMS where this entity is being saved.
+     * Might contain unresolved aliases.
+     */
+    path: string;
+    /**
+     * ID of the entity
+     */
+    entityId: string | number;
+    /**
+     * Values being saved
+     */
+    values: Partial<EntityValues<M>>;
+    /**
+     * Previous values
+     */
+    previousValues?: Partial<EntityValues<M>>;
+    /**
+     * New or existing entity
+     */
+    status: EntityStatus;
+    /**
+     * Context of the app status
+     */
+    context: RebaseCallContext<USER>;
+}
+/**
+ * Parameters passed to hooks when an entity is deleted
+ * @group Models
+ */
+export interface EntityBeforeDeleteProps<M extends Record<string, any> = any, USER extends User = User> {
+    /**
+     * collection of the entity being deleted
+     */
+    collection: EntityCollection<Record<string, unknown>, any>;
+    /**
+     * Path of the parent collection
+     */
+    path: string;
+    /**
+     * Deleted entity id
+     */
+    entityId: string | number;
+    /**
+     * Deleted entity
+     */
+    entity: Entity<M>;
+    /**
+     * Context of the app status
+     */
+    context: RebaseCallContext<USER>;
+}
+/**
+ * Parameters passed to hooks after an entity is deleted
+ * @group Models
+ */
+export interface EntityAfterDeleteProps<M extends Record<string, any> = any, USER extends User = User> {
+    /**
+     * collection of the entity being deleted
+     */
+    collection: EntityCollection<Record<string, unknown>, any>;
+    /**
+     * Path of the parent collection
+     */
+    path: string;
+    /**
+     * Deleted entity id
+     */
+    entityId: string | number;
+    /**
+     * Deleted entity
+     */
+    entity: Entity<M>;
+    /**
+     * Context of the app status
+     */
+    context: RebaseCallContext<USER>;
+}

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

@@ -0,0 +1,7 @@
+import { Entity } from "./entities";
+/**
+ * @group Models
+ */
+export type EntityLinkBuilder<M extends Record<string, any> = any> = ({ entity }: {
+    entity: Entity<M>;
+}) => string;

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

@@ -0,0 +1,9 @@
+import { DataDriver, StorageSource } from "../controllers";
+export type EntityOverrides = {
+    /**
+     * Internal driver override for this collection.
+     * Used by the CMS engine to route data operations.
+     */
+    driver?: DataDriver;
+    storageSource?: StorageSource;
+};

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

@@ -0,0 +1,61 @@
+import React from "react";
+import { Entity, EntityValues } from "./entities";
+import { EntityCollection } from "./collections";
+/**
+ * Context passed to custom fields and entity views.
+ * This is the base definition — `@rebasepro/cms` re-exports a
+ * fully-typed version that narrows the `formex` field.
+ * @group Form custom fields
+ */
+export interface FormContext<M extends Record<string, any> = any> {
+    /**
+     * Current values of the entity
+     */
+    values: M;
+    /**
+     * Update the value of a field
+     */
+    setFieldValue: (key: string, value: unknown, shouldValidate?: boolean) => void;
+    /**
+     * Save the entity.
+     */
+    save: (values: M) => void;
+    /**
+     * Collection of the entity being modified
+     */
+    collection?: EntityCollection<M>;
+    /**
+     * Entity id, it can be undefined if it's a new entity
+     */
+    entityId?: string | number;
+    /**
+     * Path this entity is located at
+     */
+    path?: string;
+    status: "new" | "existing" | "copy";
+    entity?: Entity<M>;
+    savingError?: Error;
+    openEntityMode: "side_panel" | "full_screen";
+    /**
+     * The underlying formex controller that powers the form.
+     * Prefer importing `FormContext` from `@rebasepro/cms` for the
+     * fully-typed `FormexController<M>` version.
+     */
+    formex: Record<string, unknown>;
+    disabled: boolean;
+}
+export type EntityCustomView<M extends Record<string, any> = any> = {
+    key: string;
+    name: string;
+    tabComponent?: React.ReactNode;
+    includeActions?: boolean | "bottom";
+    Builder?: React.ComponentType<EntityCustomViewParams<M>>;
+    position?: "start" | "end";
+};
+export interface EntityCustomViewParams<M extends Record<string, any> = any> {
+    collection: EntityCollection<M>;
+    entity?: Entity<M>;
+    modifiedValues?: EntityValues<M>;
+    formContext: FormContext<M>;
+    parentCollectionIds?: string[];
+}

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

@@ -0,0 +1,21 @@
+import { Entity } from "./entities";
+import { User } from "../users";
+import { RebaseContext } from "../rebase_context";
+/**
+ * You can use this configuration to add additional fields to the data
+ * exports
+ * @group Models
+ */
+export interface ExportConfig<USER extends User = User> {
+    additionalFields: ExportMappingFunction<USER>[];
+}
+/**
+ * @group Models
+ */
+export interface ExportMappingFunction<USER extends User = User> {
+    key: string;
+    builder: ({ entity, context }: {
+        entity: Entity<any>;
+        context: RebaseContext<USER>;
+    }) => Promise<string> | string;
+}

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

@@ -0,0 +1,22 @@
+export * from "./entities";
+export * from "./chips";
+export * from "./properties";
+export * from "./collections";
+export * from "./relations";
+export * from "./locales";
+export * from "./entity_link_builder";
+export * from "./user_management_delegate";
+export * from "./entity_callbacks";
+export * from "./entity_overrides";
+export * from "./export_import";
+export * from "./modify_collections";
+export * from "./websockets";
+export * from "./backend";
+export * from "./translations";
+export * from "./plugins";
+export * from "./builders";
+export * from "./slots";
+export * from "./entity_actions";
+export * from "./property_config";
+export * from "./entity_views";
+export * from "./data_source";

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

@@ -0,0 +1,4 @@
+/**
+ * @group Models
+ */
+export type Locale = "af" | "ar" | "arDZ" | "arMA" | "arSA" | "az" | "be" | "bg" | "bn" | "ca" | "cs" | "cy" | "da" | "de" | "el" | "enAU" | "enCA" | "enGB" | "enIN" | "enNZ" | "enUS" | "eo" | "es" | "et" | "eu" | "faIR" | "fi" | "fil" | "fr" | "frCA" | "frCH" | "gd" | "gl" | "gu" | "he" | "hi" | "hr" | "hu" | "hy" | "id" | "is" | "it" | "ja" | "ka" | "kk" | "kn" | "ko" | "lb" | "lt" | "lv" | "mk" | "ms" | "mt" | "nb" | "nl" | "nlBE" | "nn" | "pl" | "pt" | "ptBR" | "ro" | "ru" | "sk" | "sl" | "sr" | "srLatn" | "sv" | "ta" | "te" | "th" | "tr" | "ug" | "uk" | "uz" | "vi" | "zhCN" | "zhTW";

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

@@ -0,0 +1,5 @@
+import { EntityCollection } from "./collections";
+export type ModifyCollectionProps = {
+    collection: EntityCollection;
+    parentPaths: string[];
+};