@rebasepro/cms 0.17.3 → 0.18.0

package/src/collection_editor/extensibility_types.ts

@@ -1,168 +0,0 @@
-/**
- * Extension point types for the collection editor UI.
- *
- * These types define props that let external consumers customize the editor
- * without forking the UI: property type presets, type filtering,
- * custom form field slots, and tab visibility.
- *
- * All extension points are additive and optional — the standard Rebase
- * editor experience is unchanged when these props are not provided.
- *
- * @module
- */
-
-import type React from "react";
-import type { SerializableProperty, SerializableCollectionConfig } from "./serializable_types";
-
-// ═══════════════════════════════════════════════════════════════════════
-// PROPERTY TYPE PRESETS
-// ═══════════════════════════════════════════════════════════════════════
-
-/**
- * The base property data types supported by Rebase.
- * Derived from the `type` discriminant on `SerializableProperty`.
- */
-export type PropertyType = SerializableProperty["type"];
-
-/**
- * A higher-level "preset" that maps to a base Rebase property type
- * with pre-filled configuration. Presets replace the default type picker
- * in the property form when provided.
- *
- * @example
- * ```typescript
- * const emailPreset: PropertyTypePreset = {
- *     id: "email",
- *     label: "Email",
- *     baseType: "string",
- *     icon: "Mail",
- *     defaults: { email: true },
- *     detect: (p) => p.type === "string" && "email" in p && p.email === true,
- * };
- * ```
- */
-export interface PropertyTypePreset {
-    /** Unique identifier for this preset (e.g. "email", "phone", "currency"). */
-    id: string;
-
-    /** Display label shown in the type picker. */
-    label: string;
-
-    /** The underlying Rebase property type this maps to. */
-    baseType: PropertyType;
-
-    /** Icon to show in the picker (Lucide icon name string or React node). */
-    icon?: string | React.ReactNode;
-
-    /** Default property config applied when this preset is selected. */
-    defaults: Partial<SerializableProperty>;
-
-    /**
-     * Optional: detect this preset from an existing property.
-     * Used when loading existing schemas to show the correct preset label
-     * instead of the raw base type. First match wins.
-     * If not provided, falls back to matching by `baseType` alone.
-     */
-    detect?: (property: SerializableProperty) => boolean;
-}
-
-// ═══════════════════════════════════════════════════════════════════════
-// TAB VISIBILITY
-// ═══════════════════════════════════════════════════════════════════════
-
-/**
- * The tabs available in the collection editor.
- */
-export type CollectionEditorTab = "general" | "display" | "properties" | "rls";
-
-// ═══════════════════════════════════════════════════════════════════════
-// CUSTOM FORM FIELD SLOTS
-// ═══════════════════════════════════════════════════════════════════════
-
-/**
- * Parameters passed to the `renderExtraPropertyFields` render prop.
- */
-export interface ExtraPropertyFieldsParams {
-    /** Current metadata values from `property.metadata`. */
-    metadata: Record<string, unknown>;
-    /** Callback to update a single metadata key. Triggers dirty-state tracking. */
-    onMetadataChange: (key: string, value: unknown) => void;
-    /** The full current property being edited (serializable form). */
-    property: SerializableProperty;
-    /** The collection this property belongs to (serializable form). */
-    collection: SerializableCollectionConfig;
-}
-
-/**
- * Parameters passed to the `renderExtraCollectionFields` render prop.
- */
-export interface ExtraCollectionFieldsParams {
-    /** Current metadata values from `collection.metadata`. */
-    metadata: Record<string, unknown>;
-    /** Callback to update a single metadata key. Triggers dirty-state tracking. */
-    onMetadataChange: (key: string, value: unknown) => void;
-    /** The full current collection being edited (serializable form). */
-    collection: SerializableCollectionConfig;
-}
-
-// ═══════════════════════════════════════════════════════════════════════
-// COMBINED EXTENSION PROPS
-// ═══════════════════════════════════════════════════════════════════════
-
-/**
- * All extension props for the collection editor UI.
- *
- * This interface groups every customization point into a single type
- * that can be intersected with component props interfaces for clean threading.
- *
- * All fields are optional — when not provided, the standard Rebase
- * editor experience is unchanged (backward compatible).
- */
-export interface CollectionEditorExtensionProps {
-    /**
-     * Custom property type presets. When provided, these REPLACE the default
-     * type picker entirely. To include standard Rebase types alongside custom
-     * ones, include them explicitly in the array.
-     *
-     * When not provided, the standard Rebase widget picker is shown.
-     */
-    propertyTypePresets?: PropertyTypePreset[];
-
-    /**
-     * Property types to hide from the type picker.
-     * Only applies when `propertyTypePresets` is NOT provided.
-     * When `propertyTypePresets` IS provided, this prop is ignored.
-     */
-    hiddenPropertyTypes?: PropertyType[];
-
-    /**
-     * Render additional form fields below the standard property configuration.
-     * Metadata is stored in `property.metadata`.
-     */
-    renderExtraPropertyFields?: (params: ExtraPropertyFieldsParams) => React.ReactNode;
-
-    /**
-     * Render additional form fields in the collection editor's General tab.
-     * Metadata is stored in `collection.metadata`.
-     */
-    renderExtraCollectionFields?: (params: ExtraCollectionFieldsParams) => React.ReactNode;
-
-    /**
-     * Which tabs to show in the collection editor.
-     * Default: all tabs are shown (current behavior).
-     */
-    visibleTabs?: CollectionEditorTab[];
-
-    /**
-     * When true, the editor runs in standalone mode — all Rebase-specific
-     * context dependencies (snackbar, auth, collection registry, import,
-     * navigation state, URL controller) use safe defaults instead of
-     * reading from React contexts.
-     *
-     * Use this when embedding the collection editor outside of the Rebase
-     * admin, where the Rebase context providers are not available.
-     *
-     * Default: false (standard Rebase mode).
-     */
-    standalone?: boolean;
-}

package/src/collection_editor/index.ts

@@ -1,108 +0,0 @@
-// Collection Editor — moved from @rebasepro/studio
-// This module provides the visual schema/collection editor for the admin.
-//
-// IMPORTANT: Heavy UI components (CollectionEditorDialog, CollectionStudioView,
-// CollectionsStudioView, PropertyForm, PropertyFormDialog) are NOT re-exported
-// here to keep the main admin bundle lean. Import them from
-// "@rebasepro/cms/collection_editor_ui" instead — they live in a separate chunk
-// that is loaded on demand.
-
-
-export {
-    useCollectionEditorController
-} from "./useCollectionEditorController";
-export {
-    useCollectionsConfigController
-} from "./useCollectionsConfigController";
-export {
-    useLocalCollectionsConfigController
-} from "./useLocalCollectionsConfigController";
-export {
-    useJsonCollectionsConfigController,
-    type UseJsonCollectionsConfigControllerOptions,
-} from "./useJsonCollectionsConfigController";
-
-export {
-    toSerializableCollectionConfig,
-    toSerializableProperty,
-    toSerializableProperties,
-    fromSerializableCollectionConfig,
-    fromSerializableCollectionConfigs,
-    fromSerializableProperty,
-    fromSerializableProperties,
-} from "./serializable_utils";
-
-export type {
-    SerializableCollectionConfig,
-    SerializableProperty,
-    SerializableProperties,
-    SerializableBaseProperty,
-    SerializableStringProperty,
-    SerializableNumberProperty,
-    SerializableBooleanProperty,
-    SerializableDateProperty,
-    SerializableGeopointProperty,
-    SerializableReferenceProperty,
-    SerializableRelationProperty,
-    SerializableArrayProperty,
-    SerializableMapProperty,
-    SerializableVectorProperty,
-    SerializableBinaryProperty,
-    SerializableStorageConfig,
-    SerializableStringValidation,
-    SerializableDateValidation,
-    JsonCollectionStore,
-} from "./serializable_types";
-
-export type {
-    PropertyTypePreset,
-    PropertyType,
-    CollectionEditorTab,
-    CollectionEditorExtensionProps,
-    ExtraPropertyFieldsParams,
-    ExtraCollectionFieldsParams,
-} from "./extensibility_types";
-
-export {
-    validateCollectionJson,
-    type CollectionValidationError,
-    type CollectionValidationResult
-} from "./validateCollectionJson";
-
-export type {
-    CollectionsConfigController, DeleteCollectionParams, SaveCollectionParams, UpdateCollectionParams, CollectionsSetupInfo, UpdatePropertiesOrderParams, UpdateKanbanColumnsOrderParams
-} from "./types/config_controller";
-export type {
-    CollectionEditorController
-} from "./types/collection_editor_controller";
-
-export type {
-    CollectionInference
-} from "./types/collection_inference";
-
-export {
-    buildCollectionGenerationCallback,
-    CollectionGenerationApiError,
-    DEFAULT_COLLECTION_GENERATION_ENDPOINT
-} from "./api/generateCollectionApi";
-
-export type {
-    CollectionGenerationCallback,
-    GenerateCollectionRequest,
-    GenerateCollectionResult,
-    CollectionOperation,
-    CollectionOperationType,
-    BuildCollectionGenerationCallbackProps
-} from "./api/generateCollectionApi";
-
-export { MissingReferenceWidget } from "./ui/MissingReferenceWidget";
-
-export * from "./ui/collection_editor/util";
-
-// Re-export types only from heavy UI components (runtime code is in the separate chunk)
-export type { CollectionEditorDialogProps } from "./ui/collection_editor/CollectionEditorDialog";
-export type { CollectionStudioViewProps } from "./ui/collection_editor/CollectionStudioView";
-export type { CollectionsStudioViewProps } from "./ui/collection_editor/CollectionsStudioView";
-export type { RouterCollectionStudioViewProps } from "./ui/collection_editor/RouterCollectionStudioView";
-export type { RouterCollectionsStudioViewProps } from "./ui/collection_editor/RouterCollectionsStudioView";
-export type { PropertyFormProps, OnPropertyChangedParams } from "./ui/collection_editor/PropertyEditView";

package/src/collection_editor/liveSchemaClient.ts

@@ -1,285 +0,0 @@
-/**
- * The panel's client for live schema editing.
- *
- * Three calls, mirroring the routes: ask whether this backend can do it, ask
- * what a change would do, then do it. `plan` and `apply` are deliberately
- * separate here as well as on the server, because a UI that could only
- * try-and-see would be asking somebody to discover that their change is refused
- * by pressing a button on a live database.
- *
- * ## Partial payloads are the caller's problem, not this module's
- *
- * Every call takes the **whole** collection. Live editing computes the proposed
- * state by replacing one collection in the set, so a patch would read as a set
- * of removals — every property it does not mention — and be refused.
- *
- * The editor's own save path posts partials (`saveProperty` follows up with a
- * one-key `collection/save` carrying `partial: true`), so
- * `useLocalCollectionsConfigController` assembles the whole collection before
- * it gets here. Accepting a patch and merging it in this module would put that
- * reconstruction one layer away from the collections it needs to read.
- */
-
-/** A constraint the change asks for that the statements will not carry. */
-export interface WithheldConstraint {
-    target: string;
-    kind: "not-null";
-    reason: string;
-    remedy: string;
-}
-
-/** What the server says a change would do. Mirrors `SchemaChangePlan`. */
-export interface LiveSchemaPlan {
-    applicable: boolean;
-    verdict: "safe" | "diverges" | "needs-migration";
-    changes: Array<{
-        kind: string;
-        verdict: "safe" | "diverges" | "needs-migration";
-        collection: string;
-        property?: string;
-        detail: string;
-        remedy?: string;
-    }>;
-    statements: string[];
-    files: string[];
-    message: string;
-    /**
-     * Applicable, and still not fully enforced.
-     *
-     * Not a refusal, so it does not belong in `changes` — but it is the one
-     * thing on a plan somebody might want to stop and read, so the dialog gives
-     * it its own place rather than another bullet in the list.
-     */
-    withheldConstraints: WithheldConstraint[];
-    /**
-     * What still has to happen after this lands.
-     *
-     * Empty almost always. The case it exists for: a project that replays
-     * versioned migrations, where applying here changes *this* database and
-     * commits `drizzle/schema.sql`, but writes no migration — so the next
-     * environment built from migrations would not have the change.
-     */
-    followUp?: string[];
-}
-
-export interface LiveSchemaResult {
-    applied: boolean;
-    applyError?: string;
-    committed: { sha: string; branch: string; files: string[] };
-    statements: string[];
-    summary: string;
-    withheldConstraints: WithheldConstraint[];
-    followUp?: string[];
-}
-
-/**
- * Whether this backend can edit its schema, and what is missing when it cannot.
- *
- * `canPlan` is separate from `enabled` deliberately: previewing a change needs
- * no repository, so a deployment running from a bundle can still show somebody
- * exactly what their change would do. Greying out the preview as well would be
- * a worse answer than the truth.
- */
-export interface LiveSchemaStatus {
-    enabled: boolean;
-    canPlan: boolean;
-    /**
-     * Whether *this caller* may apply, as opposed to whether the server can.
-     *
-     * Applying commits to the repository under an author, and a credential is
-     * not an author — so an API key or the service key may preview a change and
-     * not make one. Reported here so the panel can grey out the button and say
-     * why, rather than letting somebody read a plan, decide, press, and only
-     * then be refused.
-     */
-    canApply: boolean;
-    applyRefusedBecause?: string;
-    applyRefusedCode?: string;
-    repository?: string;
-    /** The branch a commit would land on. */
-    branch?: string;
-    code?: string;
-    reason?: string;
-}
-
-/**
- * Why live editing is not available here.
- *
- * Distinguished from an ordinary failure because both are expected states with
- * their own explanation, and a UI should say which rather than showing a
- * stack: a Mongo backend will never support this, and a bundle deployment has
- * no source to edit.
- */
-export type LiveSchemaUnavailable =
-    | { reason: "unsupported"; message: string }
-    | { reason: "no-repository"; message: string };
-
-export class LiveSchemaError extends Error {
-    constructor(
-        message: string,
-        readonly code: string | undefined,
-        readonly changes?: LiveSchemaPlan["changes"]
-    ) {
-        super(message);
-        this.name = "LiveSchemaError";
-    }
-}
-
-const UNAVAILABLE: Record<string, LiveSchemaUnavailable["reason"]> = {
-    SCHEMA_EDITING_UNSUPPORTED: "unsupported",
-    SCHEMA_EDITING_NO_REPOSITORY: "no-repository"
-};
-
-export interface LiveSchemaClientOptions {
-    /** Base for the routes, e.g. `https://api.example.com/api/schema`. */
-    baseUrl: string;
-    getAuthToken?: () => Promise<string | null> | string | null;
-    fetchImpl?: typeof fetch;
-}
-
-export interface ProposedCollectionChange {
-    collectionId: string;
-    /**
-     * The **whole** collection as it should end up — not a patch. See the
-     * module comment: a partial reads as a set of removals.
-     */
-    collection: Record<string, unknown>;
-}
-
-export function createLiveSchemaClient(options: LiveSchemaClientOptions) {
-    const doFetch = options.fetchImpl ?? fetch;
-    const base = options.baseUrl.replace(/\/$/, "");
-
-    const post = async <T>(path: string, body: ProposedCollectionChange): Promise<T> => {
-        const token = await options.getAuthToken?.();
-        const headers: Record<string, string> = { "Content-Type": "application/json" };
-        if (token) headers.Authorization = `Bearer ${token}`;
-
-        const response = await doFetch(`${base}${path}`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body)
-        });
-
-        if (response.ok) return await response.json() as T;
-
-        // Parsed rather than assumed: the server answers a structured error, and
-        // the code is what tells an expected refusal from a broken request.
-        let payload: { error?: { code?: string; message?: string; details?: { changes?: LiveSchemaPlan["changes"] } } } = {};
-        try {
-            payload = await response.json() as typeof payload;
-        } catch {
-            payload = { error: { message: await response.text().catch(() => "") } };
-        }
-
-        throw new LiveSchemaError(
-            payload.error?.message || `Schema request failed with ${response.status}`,
-            payload.error?.code,
-            payload.error?.details?.changes
-        );
-    };
-
-    return {
-        /**
-         * Whether this backend can edit its schema.
-         *
-         * Never throws. Every way of failing to get an answer — a backend too
-         * old to have the endpoint, an unreachable one, a session that is not
-         * an admin — means the same thing to a caller deciding whether to offer
-         * the control, and turning that into an exception each caller has to
-         * catch would only produce four copies of this `catch`.
-         */
-        status: async (): Promise<LiveSchemaStatus> => {
-            try {
-                const token = await options.getAuthToken?.();
-                const response = await doFetch(`${base}/status`, {
-                    headers: token ? { Authorization: `Bearer ${token}` } : {}
-                });
-                const body = await response.json().catch(() => ({})) as
-                    Partial<LiveSchemaStatus> & { error?: { code?: string; message?: string } };
-
-                if (response.ok) {
-                    return {
-                        enabled: body.enabled === true,
-                        canPlan: body.canPlan === true,
-                        // Absent on a backend from before capabilities existed.
-                        // Read as "yes" there, because on that server being
-                        // through the admin gate *was* the whole permission —
-                        // defaulting to no would take the feature away from
-                        // every deployment that has not upgraded.
-                        canApply: body.canApply ?? body.enabled === true,
-                        applyRefusedBecause: body.applyRefusedBecause,
-                        applyRefusedCode: body.applyRefusedCode,
-                        repository: body.repository,
-                        branch: body.branch,
-                        code: body.code,
-                        reason: body.reason
-                    };
-                }
-                return {
-                    enabled: false,
-                    canPlan: false,
-                    canApply: false,
-                    code: body.error?.code,
-                    reason: body.error?.message
-                        ?? `The backend refused to say whether its schema is editable (HTTP ${response.status}).`
-                };
-            } catch (err) {
-                return {
-                    enabled: false,
-                    canPlan: false,
-                    canApply: false,
-                    reason: err instanceof Error ? err.message : "The backend could not be reached."
-                };
-            }
-        },
-
-        /** What the change would do. No side effects. */
-        plan: (change: ProposedCollectionChange) => post<LiveSchemaPlan>("/plan", change),
-
-        /** Commit the change, then apply it. */
-        apply: (change: ProposedCollectionChange) => post<LiveSchemaResult>("/apply", change)
-    };
-}
-
-/** The client's shape, for the hook and the tests that fake it. */
-export type LiveSchemaClient = ReturnType<typeof createLiveSchemaClient>;
-
-/**
- * Whether an error means live editing is unavailable here, rather than that the
- * change was wrong.
- *
- * Returns the reason so a caller can say which, and `undefined` for anything
- * else — a refused change is not an unavailable feature, and conflating them
- * would hide the refusal that the user needs to read.
- */
-export function asUnavailable(err: unknown): LiveSchemaUnavailable | undefined {
-    if (!(err instanceof LiveSchemaError) || !err.code) return undefined;
-    const reason = UNAVAILABLE[err.code];
-    return reason ? { reason, message: err.message } : undefined;
-}
-
-/** The person closed the dialog without applying. Not an error; an answer. */
-export class SchemaChangeCancelled extends Error {
-    constructor() {
-        super("The schema change was not applied.");
-        this.name = "SchemaChangeCancelled";
-    }
-}
-
-/**
- * Was this rejection the person saying no?
- *
- * A save has to *reject* when it is cancelled — resolving would leave the form
- * believing it saved. But a caller that treats every rejection as a failure
- * then reports the user's own choice back to them as an error, which is what
- * the collection editor did: a console error and a red snackbar reading "Error
- * persisting collection: The schema change was not applied."
- *
- * Matched by name rather than `instanceof`, which is unreliable the moment two
- * copies of this module end up in one bundle — the class is then a different
- * identity and every check silently answers false.
- */
-export function isSchemaChangeCancelled(err: unknown): boolean {
-    return err instanceof Error && err.name === "SchemaChangeCancelled";
-}

package/src/collection_editor/relation_kinds.ts

@@ -1,44 +0,0 @@
-import type { RelationKind } from "@rebasepro/types";
-
-/**
- * How each relation kind is named and explained in the editor UI.
- *
- * One table, shared by every surface that lets someone pick a kind — the
- * relations tab and the relation property form — so the two cannot describe the
- * same thing differently, and so a sixth kind added to the union fails to
- * compile here rather than quietly going missing from a dropdown.
- *
- * The descriptions all answer the same question, because it is the only
- * question that distinguishes the first four: *where is the foreign key?*
- */
-export const RELATION_KINDS: Record<RelationKind, { label: string; description: string }> = {
-    belongsTo: {
-        label: "Belongs to",
-        description: "One target row. The foreign key is a column on this table."
-    },
-    hasOne: {
-        label: "Has one",
-        description: "One target row. The foreign key is a column on the target's table."
-    },
-    hasMany: {
-        label: "Has many",
-        description: "Many target rows. The foreign key is a column on the target's table."
-    },
-    manyToMany: {
-        label: "Many to many",
-        description: "Many target rows, linked through a junction table."
-    },
-    via: {
-        label: "Via a join path",
-        description: "Reached by joining across several tables. Read-only."
-    }
-};
-
-/** The kinds, in the order they are offered. */
-export const RELATION_KIND_ORDER = Object.keys(RELATION_KINDS) as RelationKind[];
-
-/** Which link field, if any, a kind is configured with. */
-export const kindUsesLocalKey = (kind: RelationKind) => kind === "belongsTo";
-export const kindUsesForeignKeyOnTarget = (kind: RelationKind) => kind === "hasOne" || kind === "hasMany";
-export const kindUsesThrough = (kind: RelationKind) => kind === "manyToMany";
-export const kindUsesJoinPath = (kind: RelationKind) => kind === "via";