@rebasepro/sdk-generator 0.0.1-canary.09e5ec5

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

@@ -0,0 +1,102 @@
+/**
+ * Cron Job type definitions for Rebase.
+ *
+ * These types define the shape of cron job definitions, their runtime
+ * status, and execution log entries — used across server-core, client,
+ * and studio packages.
+ */
+/**
+ * A cron job definition file exports this shape as its default export.
+ * See the example cron files in `app/backend/crons/` for usage.
+ */
+export interface CronJobDefinition {
+    schedule: string;
+    /** Human-readable name shown in the Studio UI. */
+    name: string;
+    /** Optional description shown in the Studio UI. */
+    description?: string;
+    /**
+     * Whether the job is enabled at startup. Defaults to `true`.
+     * Can be toggled at runtime via the Admin API.
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of seconds the handler may run before being
+     * considered timed-out. Default: 300 (5 min).
+     */
+    timeoutSeconds?: number;
+    /**
+     * The handler function executed on each tick.
+     * Receives a context object with the data driver and logger.
+     * May return arbitrary JSON-serialisable data stored in the log.
+     */
+    handler: (ctx: CronJobContext) => Promise<unknown> | unknown;
+}
+import type { RebaseClient } from "../controllers/client";
+/**
+ * Context passed to each cron handler invocation.
+ */
+export interface CronJobContext {
+    /** The job's unique ID (derived from filename). */
+    jobId: string;
+    /** The current scheduled tick timestamp. */
+    scheduledAt: Date;
+    /** A simple logger scoped to this job run. */
+    log: (...args: unknown[]) => void;
+    /** The RebaseClient instance to interact with the database. */
+    client: RebaseClient<any>;
+}
+export type CronJobRunState = "idle" | "running" | "success" | "error" | "disabled";
+/**
+ * Full runtime information about a registered cron job.
+ */
+export interface CronJobStatus {
+    /** Unique identifier (derived from filename, e.g. "cleanup-sessions"). */
+    id: string;
+    /** Human-readable name from the definition. */
+    name: string;
+    /** Description from the definition. */
+    description?: string;
+    /** The cron schedule expression. */
+    schedule: string;
+    /** Whether the job is currently enabled. */
+    enabled: boolean;
+    /** Current run state. */
+    state: CronJobRunState;
+    /** ISO timestamp of the last execution start. */
+    lastRunAt?: string;
+    /** ISO timestamp of the next scheduled execution. */
+    nextRunAt?: string;
+    /** Duration of the last run in milliseconds. */
+    lastDurationMs?: number;
+    /** Error message from the last failed run. */
+    lastError?: string;
+    /** Total number of executions since server start. */
+    totalRuns: number;
+    /** Total number of failed executions since server start. */
+    totalFailures: number;
+}
+export type CronLogLevel = "info" | "error" | "warn";
+/**
+ * A single execution log entry stored in the in-memory ring buffer.
+ */
+export interface CronJobLogEntry {
+    /** The job ID this log belongs to. */
+    jobId: string;
+    /** ISO timestamp when execution started. */
+    startedAt: string;
+    /** ISO timestamp when execution finished. */
+    finishedAt: string;
+    /** Duration in milliseconds. */
+    durationMs: number;
+    /** Whether this run succeeded. */
+    success: boolean;
+    /** Error message if the run failed. */
+    error?: string;
+    /** Arbitrary result data returned by the handler. */
+    result?: unknown;
+    /** Captured log lines. */
+    logs: string[];
+    /** Whether this was a manual trigger. */
+    manual?: boolean;
+}

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 = Omit<DataSourceCapabilities, "key" | "label">;
+/** @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 type { Entity } from "./entities";
+import type { EntityCollection, SelectionController } from "./collections";
+import type { FormContext } from "./entity_views";
+import type { User } from "../users";
+import type { RebaseContext } from "../rebase_context";
+import type { SideEntityController } from "../controllers/side_entity_controller";
+/**
+ * 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<M>;
+    /**
+     * 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" | "split";
+    /**
+     * 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 type { EntityCollection } from "./collections";
+import type { Entity, EntityStatus, EntityValues } from "./entities";
+import type { User } from "../users";
+import type { 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, unknown> = Record<string, unknown>, 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, unknown> = Record<string, unknown>, USER extends User = User> {
+    /**
+     * Collection of the entity
+     */
+    collection: EntityCollection<M>;
+    /**
+     * 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, unknown> = Record<string, unknown>, 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, unknown> = Record<string, unknown>, 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, unknown> = Record<string, unknown>, USER extends User = User> {
+    /**
+     * Resolved collection of the entity
+     */
+    collection: EntityCollection<M>;
+    /**
+     * 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, unknown> = Record<string, unknown>, USER extends User = User> {
+    /**
+     * collection of the entity being deleted
+     */
+    collection: EntityCollection<M>;
+    /**
+     * 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, unknown> = Record<string, unknown>, USER extends User = User> {
+    /**
+     * collection of the entity being deleted
+     */
+    collection: EntityCollection<M>;
+    /**
+     * 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, unknown> = Record<string, unknown>> = ({ entity }: {
+    entity: Entity<M>;
+}) => string;

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

@@ -0,0 +1,10 @@
+import type { DataDriver } from "../controllers/data_driver";
+import type { StorageSource } from "../controllers/storage";
+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 type { Entity, EntityValues } from "./entities";
+import type { EntityCollection } from "./collections";
+/**
+ * Context passed to custom fields and entity views.
+ * This is the base definition — `@rebasepro/admin` re-exports a
+ * fully-typed version that narrows the `formex` field.
+ * @group Form custom fields
+ */
+export interface FormContext<M extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * 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" | "split";
+    /**
+     * The underlying formex controller that powers the form.
+     * Prefer importing `FormContext` from `@rebasepro/admin` for the
+     * fully-typed `FormexController<M>` version.
+     */
+    formex: Record<string, unknown>;
+    disabled: boolean;
+}
+export type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = {
+    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, unknown> = Record<string, unknown>> {
+    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 type { Entity } from "./entities";
+import type { User } from "../users";
+import type { 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;
+}