@rebasepro/plugin-insights 0.5.0 → 0.6.1

package/src/useInsightsPlugin.tsx

@@ -42,76 +42,79 @@ import { CollectionInsightsInline } from "./components/CollectionInsightsInline"
  */
 export function useInsightsPlugin(config: InsightsPluginConfig): RebasePlugin {
     const { insights, cacheTTL } = config;
-    const slots: SlotContribution[] = [];
 
-    // ── Home page insights ────────────────────────────────────────────
-    if (insights.home && insights.home.length > 0) {
-        const homeInsights = insights.home;
-        slots.push({
-            slot: "home.children.start" as const,
-            Component: (props: Record<string, unknown>) => (
-                <HomeInsightsSlot
-                    {...props}
-                    insights={homeInsights}
-                />
-            ),
-            order: 10,
-        });
-    }
+    return React.useMemo(() => {
+        const slots: SlotContribution[] = [];
 
-    // ── Per-collection insights ───────────────────────────────────────
-    // A single `collections.<slug>` definition serves two slots:
-    // 1. collection.insights  → inline scorecards in the list view
-    // 2. home.card.insight    → compact scorecards on the home card
-    if (insights.collections) {
-        for (const [slug, defs] of Object.entries(insights.collections)) {
-            if (defs.length === 0) continue;
-            const collectionInsights = defs;
-
-            // 1. Inline in collection list view
+        // ── Home page insights ────────────────────────────────────────────
+        if (insights.home && insights.home.length > 0) {
+            const homeInsights = insights.home;
             slots.push({
-                slot: "collection.insights" as const,
-                Component: (props: Record<string, unknown>) => {
-                    const path = props.path as string;
-                    const collectionSlug = path?.split("/").filter(Boolean).pop() ?? "";
-                    if (collectionSlug !== slug) return null;
-                    return (
-                        <CollectionInsightsInline
-                            {...props as { path: string; collection: unknown; parentCollectionSlugs: string[], parentEntityIds: string[] }}
-                            insights={collectionInsights}
-                        />
-                    );
-                },
-                order: 10,
+                slot: "home.children.start" as const,
+                Component: (props: Record<string, unknown>) => (
+                    <HomeInsightsSlot
+                        {...props}
+                        insights={homeInsights}
+                    />
+                ),
+                order: 10
             });
+        }
 
-            // 2. Auto-extract scorecards for home page card
-            slots.push({
-                slot: "home.card.insight" as const,
-                Component: (props: Record<string, unknown>) => {
-                    const cardSlug = props.slug as string;
-                    if (cardSlug !== slug) return null;
-                    return (
-                        <HomeCardInsightSlot
-                            {...props as { slug: string; collection: unknown; context: unknown }}
-                            insights={collectionInsights}
-                        />
-                    );
-                },
-                order: 10,
-            });
+        // ── Per-collection insights ───────────────────────────────────────
+        // A single `collections.<slug>` definition serves two slots:
+        // 1. collection.insights  → inline scorecards in the list view
+        // 2. home.card.insight    → compact scorecards on the home card
+        if (insights.collections) {
+            for (const [slug, defs] of Object.entries(insights.collections)) {
+                if (defs.length === 0) continue;
+                const collectionInsights = defs;
+
+                // 1. Inline in collection list view
+                slots.push({
+                    slot: "collection.insights" as const,
+                    Component: (props: Record<string, unknown>) => {
+                        const path = props.path as string;
+                        const collectionSlug = path?.split("/").filter(Boolean).pop() ?? "";
+                        if (collectionSlug !== slug) return null;
+                        return (
+                            <CollectionInsightsInline
+                                {...props as { path: string; collection: unknown; parentCollectionSlugs: string[], parentEntityIds: string[] }}
+                                insights={collectionInsights}
+                            />
+                        );
+                    },
+                    order: 10
+                });
+
+                // 2. Auto-extract scorecards for home page card
+                slots.push({
+                    slot: "home.card.insight" as const,
+                    Component: (props: Record<string, unknown>) => {
+                        const cardSlug = props.slug as string;
+                        if (cardSlug !== slug) return null;
+                        return (
+                            <HomeCardInsightSlot
+                                {...props as { slug: string; collection: unknown; context: unknown }}
+                                insights={collectionInsights}
+                            />
+                        );
+                    },
+                    order: 10
+                });
+            }
         }
-    }
 
-    return {
-        key: "plugin-insights",
-        slots,
-        providers: [
-            {
-                scope: "root" as const,
-                Component: InsightsProvider as React.ComponentType<React.PropsWithChildren<Record<string, unknown>>>,
-                props: { cacheTTL },
-            },
-        ],
-    };
+        return {
+            key: "plugin-insights",
+            slots,
+            providers: [
+                {
+                    scope: "root" as const,
+                    Component: InsightsProvider as React.ComponentType<React.PropsWithChildren<Record<string, unknown>>>,
+                    props: { cacheTTL }
+                }
+            ]
+        };
+    }, [insights, cacheTTL]);
 }

package/dist/common/src/collections/CollectionRegistry.d.ts

@@ -1,56 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-export declare class CollectionRegistry {
-    private collectionsByTableName;
-    private collectionsBySlug;
-    private rootCollections;
-    private cachedCollectionsList;
-    private rawCollectionsByTableName;
-    private rawCollectionsBySlug;
-    private rawRootCollections;
-    private cachedRawCollectionsList;
-    private lastRawInputSnapshot;
-    constructor(collections?: EntityCollection[]);
-    reset(): void;
-    /**
-     * Registers a collection and its subcollections recursively.
-     * Returns true if the collections have changed, false otherwise.
-     *
-     * Idempotent: compares the raw input (before normalization) against a stored
-     * snapshot. Only re-normalizes and re-registers when the raw input actually changed.
-     * @param collections
-     */
-    registerMultiple(collections: EntityCollection[]): boolean;
-    register(collection: EntityCollection, rawCollection?: EntityCollection): void;
-    private _registerRecursively;
-    normalizeCollection(collection: EntityCollection): EntityCollection;
-    /**
-     * Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
-     * This allows developers to define relations directly on properties without a separate
-     * `relations[]` entry on the collection.
-     */
-    private extractRelationsFromProperties;
-    private normalizeProperties;
-    private normalizeProperty;
-    get(path: string): EntityCollection | undefined;
-    /**
-     * Gets the pristine, un-normalized collection exactly as it was provided.
-     * Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
-     */
-    getRaw(path: string): EntityCollection | undefined;
-    /**
-     * Get collection by resolving multi-segment paths through relations
-     * e.g., "authors/70/posts" resolves to the posts collection
-     */
-    getCollectionByPath(collectionPath: string): EntityCollection | undefined;
-    getCollections(): EntityCollection[];
-    getRawCollections(): EntityCollection[];
-    /**
-     * Resolves a multi-segment path like "products/123/locales" and returns
-     * information about the collections and entity IDs along the path
-     */
-    resolvePathToCollections(path: string): {
-        collections: EntityCollection[];
-        entityIds: (string | number)[];
-        finalCollection: EntityCollection;
-    };
-}

package/dist/common/src/collections/default-collections.d.ts

@@ -1,9 +0,0 @@
-import type { PostgresCollection } from "@rebasepro/types";
-/**
- * Default users collection.
- *
- * Prepended to the developer's collections array by the admin and server.
- * Slug-based dedup (Map keyed by slug, last-write-wins) lets developers
- * override by defining their own collection with `slug: "users"`.
- */
-export declare const defaultUsersCollection: PostgresCollection;

package/dist/common/src/collections/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./CollectionRegistry";
-export * from "./default-collections";

package/dist/common/src/data/buildRebaseData.d.ts

@@ -1,14 +0,0 @@
-import { DataDriver, RebaseData } from "@rebasepro/types";
-/**
- * Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
- *
- * This is the key bridge: any property access like `data.products` returns
- * a `CollectionAccessor` backed by the underlying DataDriver, without
- * needing per-collection code generation.
- *
- * @example
- * const data = buildRebaseData(driver);
- * await data.products.create({ name: "Camera", price: 299 });
- * const { data: items } = await data.products.find({ where: { status: "eq.published" } });
- */
-export declare function buildRebaseData(driver: DataDriver): RebaseData;

package/dist/common/src/data/query_builder.d.ts

@@ -1,55 +0,0 @@
-import { FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator, LogicalCondition, WhereValue, FilterCondition } from "@rebasepro/types";
-export declare function or(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
-export declare function and(...conditions: (FilterCondition | LogicalCondition)[]): LogicalCondition;
-export declare function cond(column: string, operator: FilterOperator, value: unknown): FilterCondition;
-export declare class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
-    private collection;
-    private params;
-    constructor(collection: CollectionAccessor<M>);
-    /**
-     * Add a filter condition to your query.
-     * @example
-     * client.collection('users').where('age', '>=', 18).find()
-     */
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
-    where(logicalCondition: LogicalCondition): this;
-    /**
-     * Order the results by a specific column.
-     * @example
-     * client.collection('users').orderBy('createdAt', 'desc').find()
-     */
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
-    /**
-     * Limit the number of results returned.
-     */
-    limit(count: number): this;
-    /**
-     * Skip the first N results.
-     */
-    offset(count: number): this;
-    /**
-     * Set a free-text search string if supported by the backend.
-     */
-    search(searchString: string): this;
-    /**
-     * Include related entities in the response.
-     * Relations will be populated with full entity data instead of just IDs.
-     *
-     * @param relations - Relation names to include, or "*" for all.
-     * @example
-     * // Include specific relations
-     * client.data.posts.include("tags", "author").find()
-     *
-     * // Include all relations
-     * client.data.posts.include("*").find()
-     */
-    include(...relations: string[]): this;
-    /**
-     * Execute the find query and return the results.
-     */
-    find(): Promise<FindResponse<M>>;
-    /**
-     * Listen to realtime updates matching this query.
-     */
-    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void;
-}

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

@@ -1,4 +0,0 @@
-export * from "./util";
-export * from "./collections";
-export * from "./data/buildRebaseData";
-export * from "./data/query_builder";

package/dist/common/src/util/builders.d.ts

@@ -1,57 +0,0 @@
-import { AdditionalFieldDelegate, ArrayProperty, BooleanProperty, DateProperty, EntityCallbacks, EntityCollection, EnumValueConfig, EnumValues, GeopointProperty, MapProperty, NumberProperty, Properties, Property, ReferenceProperty, StringProperty, User } from "@rebasepro/types";
-/**
- * Identity function we use to defeat the type system of Typescript and build
- * collection views with all its properties
- * @param collection
- * @group Builder
- */
-export declare function buildCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): EntityCollection<M, USER>;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the property keys.
- * @param property
- * @group Builder
- */
-export declare function buildProperty<T, P extends Property = Property>(property: P): P extends StringProperty ? StringProperty : P extends NumberProperty ? NumberProperty : P extends BooleanProperty ? BooleanProperty : P extends DateProperty ? DateProperty : P extends GeopointProperty ? GeopointProperty : P extends ReferenceProperty ? ReferenceProperty : P extends ArrayProperty ? ArrayProperty : P extends MapProperty ? MapProperty : never;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param properties
- * @group Builder
- */
-export declare function buildProperties<M extends Record<string, unknown>>(properties: Properties): Properties;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param propertiesOrBuilder
- * @group Builder
- */
-export declare function buildPropertiesOrBuilder<M extends Record<string, unknown>>(propertiesOrBuilder: Properties): Properties;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param enumValues
- * @group Builder
- */
-export declare function buildEnum(enumValues: EnumValues): EnumValues;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param enumValueConfig
- * @group Builder
- */
-export declare function buildEnumValueConfig(enumValueConfig: EnumValueConfig): EnumValueConfig;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param callbacks
- * @group Builder
- */
-export declare function buildEntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>>(callbacks: EntityCallbacks<M>): EntityCallbacks<M>;
-/**
- * Identity function we use to defeat the type system of Typescript and build
- * additional field delegates views with all its properties
- * @param additionalFieldDelegate
- * @group Builder
- */
-export declare function buildAdditionalFieldDelegate<M extends Record<string, unknown>, USER extends User = User>(additionalFieldDelegate: AdditionalFieldDelegate<M, USER>): AdditionalFieldDelegate<M, USER>;

package/dist/common/src/util/callbacks.d.ts

@@ -1,6 +0,0 @@
-import { EntityCallbacks, Properties } from "@rebasepro/types";
-/**
- * Helper function to extract field-level PropertyCallbacks from a properties schema
- * and wrap them into an EntityCallbacks object recursively.
- */
-export declare const buildPropertyCallbacks: (properties: Properties) => EntityCallbacks | undefined;

package/dist/common/src/util/collections.d.ts

@@ -1,11 +0,0 @@
-import { DefaultSelectedViewBuilder, DefaultSelectedViewParams, EntityCollection, Properties } from "@rebasepro/types";
-export declare function sortProperties<M extends Record<string, unknown>>(properties: Properties, propertiesOrder?: string[]): Properties;
-export declare function resolveDefaultSelectedView(defaultSelectedView: string | DefaultSelectedViewBuilder | undefined, params: DefaultSelectedViewParams): string | undefined;
-export declare function getLocalChangesBackup(collection: EntityCollection): "manual_apply" | "auto_apply";
-/**
- * Returns the primary keys for an entity collection by inspecting the properties
- * and finding any properties with `isId`.
- * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
- * @param collection
- */
-export declare function getPrimaryKeys<M extends Record<string, unknown>>(collection: EntityCollection<M>): Extract<keyof M, string>[];

package/dist/common/src/util/common.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_ONE_OF_TYPE = "type";
-export declare const DEFAULT_ONE_OF_VALUE = "value";

package/dist/common/src/util/conditions.d.ts

@@ -1,26 +0,0 @@
-import { AuthController, ConditionContext, JsonLogicRule, Property } from "@rebasepro/types";
-/**
- * Register custom JSON Logic operations for Rebase.
- * Call this once at app initialization.
- */
-export declare function registerConditionOperations(): void;
-/**
- * Evaluate a JSON Logic rule against the given context.
- */
-export declare function evaluateCondition(rule: JsonLogicRule, context: ConditionContext): unknown;
-/**
- * Build a ConditionContext from the current property resolution context.
- */
-export declare function buildConditionContext(params: {
-    propertyKey?: string;
-    values?: Record<string, unknown>;
-    previousValues?: Record<string, unknown>;
-    path: string;
-    entityId?: string;
-    index?: number;
-    authController: AuthController;
-}): ConditionContext;
-/**
- * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
- */
-export declare function applyPropertyConditions(property: Property, context: ConditionContext): Property;

package/dist/common/src/util/entities.d.ts

@@ -1,58 +0,0 @@
-import { DataType, Entity, EntityReference, EntityRelation, EntityStatus, EntityValues, Properties, Property } from "@rebasepro/types";
-export declare function isReadOnly(property: Property): boolean;
-export declare function isHidden(property: Property): boolean;
-export declare function isPropertyBuilder(property?: Property): boolean;
-export declare function getDefaultValuesFor<M extends Record<string, unknown>>(properties: Properties): Partial<EntityValues<M>>;
-export declare function getDefaultValueFor(property?: Property): unknown;
-export declare function getDefaultValueFortype(type: DataType): unknown;
-/**
- * Update the automatic values in an entity before save
- * @group Driver
- */
-export declare function updateDateAutoValues<M extends Record<string, unknown>>({ inputValues, properties, status, timestampNowValue }: {
-    inputValues: Partial<EntityValues<M>>;
-    properties: Properties;
-    status: EntityStatus;
-    timestampNowValue: unknown;
-}): EntityValues<M>;
-/**
- * Add missing required fields, expected in the collection, to the values of an entity
- * @param values
- * @param properties
- * @group Driver
- */
-export declare function sanitizeData<M extends Record<string, unknown>>(values: EntityValues<M>, properties: Properties): Record<string, unknown>;
-export declare function getReferenceFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityReference;
-export declare function getRelationFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityRelation;
-/**
- * Normalize a value into a proper EntityRelation instance.
- * Handles EntityRelation class instances, and plain objects
- * with `__type === "relation"` or an `isEntityRelation()` method.
- *
- * Returns null if the value cannot be coerced.
- */
-export declare function normalizeToEntityRelation(value: unknown): EntityRelation | null;
-export declare function traverseValuesProperties<M extends Record<string, unknown>>(inputValues: Partial<EntityValues<M>>, properties: Properties, operation: (value: unknown, property: Property) => unknown): EntityValues<M> | undefined;
-export declare function traverseValueProperty(inputValue: unknown, property: Property, operation: (value: unknown, property: Property) => unknown): unknown;
-/**
- * Relation reference types used throughout the server layer.
- * These replace the 50+ manual `{ id, path, __type: "relation" }` constructions.
- */
-export interface RelationRef {
-    readonly id: string | number;
-    readonly path: string;
-    readonly __type: "relation";
-}
-export interface RelationRefWithData extends RelationRef {
-    readonly data: Entity;
-}
-/**
- * Create a lightweight relation stub for CMS views.
- * Replaces inline `{ id, path, __type: "relation" }` object literals.
- */
-export declare function createRelationRef(id: string | number, path: string): RelationRef;
-/**
- * Create a hydrated relation reference that includes the full entity data.
- * Used when entity data has been pre-fetched (e.g., via batch loading or JOINs).
- */
-export declare function createRelationRefWithData(id: string | number, path: string, data: Entity): RelationRefWithData;

package/dist/common/src/util/enums.d.ts

@@ -1,3 +0,0 @@
-import { EnumValueConfig, EnumValues } from "@rebasepro/types";
-export declare function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[];
-export declare function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined;

package/dist/common/src/util/index.d.ts

@@ -1,16 +0,0 @@
-export * from "./collections";
-export * from "./common";
-export * from "./entities";
-export * from "./enums";
-export * from "./paths";
-export * from "./resolutions";
-export * from "./permissions";
-export * from "./references";
-export * from "./navigation_from_path";
-export * from "./parent_references_from_path";
-export * from "./builders";
-export * from "./storage";
-export * from "./callbacks";
-export * from "./relations";
-export * from "./conditions";
-export * from "./navigation_utils";

package/dist/common/src/util/navigation_from_path.d.ts

@@ -1,34 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = {
-    key: string;
-    [key: string]: unknown;
-};
-export type NavigationViewInternal<M extends Record<string, unknown> = Record<string, unknown>> = NavigationViewEntityInternal<M> | NavigationViewCollectionInternal<M> | NavigationViewEntityCustomInternal<M>;
-export interface NavigationViewEntityInternal<M extends Record<string, unknown>> {
-    type: "entity";
-    entityId: string | number;
-    slug: string;
-    path: string;
-    parentCollection: EntityCollection<M>;
-}
-export interface NavigationViewCollectionInternal<M extends Record<string, unknown>> {
-    type: "collection";
-    id: string;
-    slug: string;
-    path: string;
-    collection: EntityCollection<M>;
-}
-export interface NavigationViewEntityCustomInternal<M extends Record<string, unknown>> {
-    type: "custom_view";
-    slug: string;
-    path: string;
-    entityId: string | number;
-    view: EntityCustomView<M>;
-}
-export declare function getNavigationEntriesFromPath(props: {
-    path: string;
-    collections: EntityCollection[] | undefined;
-    currentFullPath?: string;
-    contextEntityViews?: EntityCustomView[];
-}): NavigationViewInternal[];
-export {};

package/dist/common/src/util/navigation_utils.d.ts

@@ -1,20 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-export declare function removeInitialAndTrailingSlashes(s: string): string;
-export declare function removeInitialSlash(s: string): string;
-export declare function removeTrailingSlash(s: string): string;
-export declare function addInitialSlash(s: string): string;
-export declare function getLastSegment(path: string): string;
-export declare function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string;
-/**
- * Find the corresponding view at any depth for a given path.
- * Note that path or segments of the paths can be collection aliases.
- * @param slugOrPath
- * @param collections
- */
-export declare function getCollectionBySlugWithin(slugOrPath: string, collections: EntityCollection[]): EntityCollection | undefined;
-/**
- * Get the subcollection combinations from a path:
- * "sites/es/locales" => ["sites/es/locales", "sites"]
- * @param subpaths
- */
-export declare function getCollectionPathsCombinations(subpaths: string[]): string[];

package/dist/common/src/util/parent_references_from_path.d.ts

@@ -1,6 +0,0 @@
-import { EntityCollection, EntityReference } from "@rebasepro/types";
-export declare function getParentReferencesFromPath(props: {
-    path: string;
-    collections: EntityCollection[] | undefined;
-    currentFullPath?: string;
-}): EntityReference[];

package/dist/common/src/util/paths.d.ts

@@ -1,14 +0,0 @@
-export declare const COLLECTION_PATH_SEPARATOR = "::";
-/**
- * Remove the entity ids from a given path
- * `products/B44RG6APH/locales` => `products::locales`
- * @param path
- */
-export declare function stripCollectionPath(path: string): string;
-export declare function segmentsToStrippedPath(paths: string[]): string;
-/**
- * Extract the collection path routes
- * `products/B44RG6APH/locales` => [`products`, `locales`]
- * @param path
- */
-export declare function fullPathToCollectionSegments(path: string): string[];

package/dist/common/src/util/permissions.d.ts

@@ -1,14 +0,0 @@
-import { Entity, EntityCollection, User } from "@rebasepro/types";
-/**
- * Minimal auth context for permission checking.
- * Only requires the user object — avoids forcing callers to construct
- * a full AuthController just to check permissions.
- */
-export interface AuthContext<USER extends User = User> {
-    user: USER | null;
-}
-export declare function checkOperation<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, entity: Entity<M> | null, targetOperation: "select" | "insert" | "update" | "delete"): boolean;
-export declare function canReadCollection<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>): boolean;
-export declare function canEditEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, path: string, entity: Entity<M> | null): boolean;
-export declare function canCreateEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, path: string, entity: Entity<M> | null): boolean;
-export declare function canDeleteEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authContext: AuthContext<USER>, path: string, entity: Entity<M> | null): boolean;

package/dist/common/src/util/references.d.ts

@@ -1,2 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-export declare function getEntityImagePreviewPropertyKey<M extends Record<string, unknown>>(collection: EntityCollection<M>): string | undefined;

package/dist/common/src/util/relations.d.ts

@@ -1,22 +0,0 @@
-import { EntityCollection, Property, Relation } from "@rebasepro/types";
-export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection, resolveCollection?: (slugOrTable: string) => EntityCollection | undefined): Relation;
-export declare function resolveCollectionRelations(collection: EntityCollection): Record<string, Relation>;
-export declare function resolvePropertyRelation({ propertyKey, property, sourceCollection }: {
-    propertyKey: string;
-    property: Property;
-    sourceCollection: EntityCollection;
-}): Relation | undefined;
-export declare function getTableName(collection: EntityCollection): string;
-export declare function getTableVarName(tableName: string): string;
-export declare function getEnumVarName(tableName: string, propName: string): string;
-export declare function getColumnName(fullColumn: string): string;
-/**
- * Look up a relation by key with forgiving normalization.
- *
- * `resolveCollectionRelations` stores each relation under a single canonical
- * key (no aliases). This helper tries the given key as-is, then falls back to
- * slug form (underscores → hyphens) and snake_case form (hyphens → underscores)
- * so that callers that receive a key from external input (URL path segments,
- * user-provided config, etc.) can still find the right entry.
- */
-export declare function findRelation(resolvedRelations: Record<string, Relation>, key: string): Relation | undefined;