@rebasepro/common 0.1.2 → 0.2.1

package/dist/util/entities.d.ts

@@ -3,8 +3,8 @@ 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): {} | null | undefined;
-export declare function getDefaultValueFortype(type: DataType): {} | null;
+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

package/dist/util/relations.d.ts

@@ -1,5 +1,5 @@
 import { EntityCollection, Property, Relation } from "@rebasepro/types";
-export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation;
+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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -32,7 +32,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "development": "./src/index.ts",
+      "development": "./dist/index.es.js",
       "import": "./dist/index.es.js",
       "require": "./dist/index.umd.js"
     },
@@ -41,29 +41,27 @@
   "dependencies": {
     "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/types": "0.1.2",
-    "@rebasepro/utils": "0.1.2"
+    "@rebasepro/types": "0.2.1",
+    "@rebasepro/utils": "0.2.1"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
-    "@testing-library/react": "^16.3.0",
+    "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.17.14",
+    "@types/node": "^20.19.41",
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^19.0.8",
-    "@types/react-dom": "^19.0.3",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
     "@types/react-measure": "^2.0.12",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "^4.7.0",
     "babel-plugin-react-compiler": "beta",
     "cross-env": "^7.0.3",
-    "eslint-plugin-react-compiler": "beta",
     "jest": "^29.7.0",
-    "npm-run-all": "^4.1.5",
-    "ts-jest": "^29.3.1",
+    "ts-jest": "^29.4.10",
     "tsd": "^0.31.2",
-    "typescript": "^5.8.3",
-    "vite": "^5.4.17"
+    "typescript": "^5.9.3",
+    "vite": "^5.4.21"
   },
   "files": [
     "dist",

package/src/collections/CollectionRegistry.d.ts

@@ -0,0 +1,56 @@
+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/src/collections/CollectionRegistry.ts

@@ -9,8 +9,6 @@ import {
     Relation,
     RelationProperty,
     StringProperty,
-    OnAction,
-    JoinStep,
     getDataSourceCapabilities
 } from "@rebasepro/types";
 import { deepEqual } from "fast-equals";
@@ -71,8 +69,14 @@ export class CollectionRegistry {
             return false;
         }
 
-        // Raw input has changed — normalize and register
         this.reset();
+        // Phase 0: Populate maps with raw collections first for string target resolution
+        collections.forEach((c) => {
+            if (c.slug) {
+                this.collectionsBySlug.set(c.slug, c);
+            }
+            this.collectionsByTableName.set(getTableName(c), c);
+        });
 
         const normalizedCollections = collections.map(c => this.normalizeCollection({ ...c }));
 
@@ -164,7 +168,7 @@ export class CollectionRegistry {
 
         // 2. Merge with manual relations[] (manual entries win on name conflict)
         const relResult = result as CollectionWithRelations;
-        const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? ((relResult as any).relations ?? []) : [];
+        const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? (relResult.relations ?? []) : [];
         const mergedRelationsRaw = [...extractedRelations];
         for (const manual of manualRelations) {
             const name = manual.relationName;
@@ -182,7 +186,7 @@ export class CollectionRegistry {
         if (getDataSourceCapabilities(result.driver).supportsRelations) {
             mergedRelations = mergedRelationsRaw.map(r => {
                 try {
-                    return sanitizeRelation(r, result);
+                    return sanitizeRelation(r, result, (slug) => this.get(slug));
                 } catch {
                     // sanitizeRelation may throw for incomplete configs
                     // (e.g. missing target). Keep the raw relation as-is.
@@ -191,7 +195,7 @@ export class CollectionRegistry {
             });
 
             // 3. Set the merged relations on the result copy
-            (relResult as any).relations = mergedRelations;
+            relResult.relations = mergedRelations;
         }
 
         // 4. Normalize properties (which stamps relation on each property)
@@ -202,8 +206,8 @@ export class CollectionRegistry {
         if (!result.childCollections) {
             if (getDataSourceCapabilities(result.driver).supportsSubcollections && (result as CollectionWithSubcollections).subcollections) {
                 result.childCollections = (result as CollectionWithSubcollections).subcollections;
-            } else if (getDataSourceCapabilities(result.driver).supportsRelations && (relResult as any).relations) {
-                const manyRelations = (relResult as any).relations.filter((r: Relation) => r.cardinality === "many");
+            } else if (getDataSourceCapabilities(result.driver).supportsRelations && relResult.relations) {
+                const manyRelations = relResult.relations.filter((r: Relation) => r.cardinality === "many");
                 if (manyRelations.length > 0) {
                     result.childCollections = () => manyRelations.map((r: Relation) => {
                         const target = r.target();
@@ -463,31 +467,3 @@ export class CollectionRegistry {
 
 }
 
-function areCollectionListsEqual(a: EntityCollection[], b: EntityCollection[]) {
-    // console.log("Comparing collection lists", a, b);
-    // return true;
-    if (a.length !== b.length) {
-        return false;
-    }
-    const aCopy = [...a];
-    const bCopy = [...b];
-    const aSorted = aCopy.sort((x, y) => x.slug.localeCompare(y.slug));
-    const bSorted = bCopy.sort((x, y) => x.slug.localeCompare(y.slug));
-    return aSorted.every((value, index) => areCollectionsEqual(value, bSorted[index]));
-}
-
-function areCollectionsEqual(a: EntityCollection, b: EntityCollection) {
-    const subcollectionsA = getSubcollections(a);
-    const subcollectionsB = getSubcollections(b);
-    const { driver: _dA, ...restA } = a as EntityCollection & Record<string, unknown>;
-    const { driver: _dB, ...restB } = b as EntityCollection & Record<string, unknown>;
-    // Remove subcollections/relations from comparison objects (already handled above)
-    delete restA.subcollections;
-    delete restB.subcollections;
-    delete (restA as any).relations;
-    delete (restB as any).relations;
-    if (!areCollectionListsEqual(subcollectionsA, subcollectionsB)) {
-        return false;
-    }
-    return deepEqual(removeFunctions(restA), removeFunctions(restB));
-}

package/src/collections/index.d.ts

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

package/src/data/buildRebaseData.d.ts

@@ -0,0 +1,14 @@
+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/src/index.d.ts

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

package/src/types/json-logic-js.d.ts

@@ -1,7 +1,7 @@
 declare module "json-logic-js" {
     interface JsonLogic {
         apply(logic: unknown, data?: unknown): unknown;
-        add_operation<T extends any[]>(name: string, fn: (...args: T) => unknown): void;
+        add_operation<T extends unknown[]>(name: string, fn: (...args: T) => unknown): void;
     }
     const jsonLogic: JsonLogic;
     export default jsonLogic;

package/src/util/builders.d.ts

@@ -0,0 +1,57 @@
+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/src/util/builders.ts

@@ -50,6 +50,7 @@ export function buildProperty<T, P extends Property = Property>(
     P extends ArrayProperty ? ArrayProperty :
     P extends MapProperty ? MapProperty : never {
 
+    // SAFETY: Identity function — P is a subtype of the conditional return type by definition
     return property as unknown as ReturnType<typeof buildProperty<T, P>>;
 }
 

package/src/util/callbacks.d.ts

@@ -0,0 +1,6 @@
+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/src/util/collections.d.ts

@@ -0,0 +1,11 @@
+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/src/util/common.d.ts

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

package/src/util/conditions.d.ts

@@ -0,0 +1,26 @@
+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/src/util/entities.d.ts

@@ -0,0 +1,58 @@
+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/src/util/entities.ts

@@ -44,7 +44,7 @@ export function getDefaultValuesFor<M extends Record<string, unknown>>(propertie
 ...b }), {}) as EntityValues<M>;
 }
 
-export function getDefaultValueFor(property?: Property) {
+export function getDefaultValueFor(property?: Property): unknown {
     if (!property) return undefined;
     if (isPropertyBuilder(property)) return undefined;
     if (property.defaultValue || property.defaultValue === null) {
@@ -58,7 +58,7 @@ export function getDefaultValueFor(property?: Property) {
     }
 }
 
-export function getDefaultValueFortype(type: DataType) {
+export function getDefaultValueFortype(type: DataType): unknown {
     if (type === "string") {
         return null;
     } else if (type === "number") {
@@ -71,6 +71,10 @@ export function getDefaultValueFortype(type: DataType) {
         return [];
     } else if (type === "map") {
         return {};
+    } else if (type === "vector") {
+        return null;
+    } else if (type === "binary") {
+        return null;
     } else {
         return null;
     }

package/src/util/enums.d.ts

@@ -0,0 +1,3 @@
+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/src/util/index.d.ts

@@ -0,0 +1,16 @@
+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/src/util/navigation_from_path.d.ts

@@ -0,0 +1,34 @@
+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/src/util/navigation_utils.d.ts

@@ -0,0 +1,20 @@
+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/src/util/parent_references_from_path.d.ts

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

package/src/util/paths.d.ts

@@ -0,0 +1,14 @@
+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/src/util/permissions.d.ts

@@ -0,0 +1,5 @@
+import { AuthController, Entity, EntityCollection, User } from "@rebasepro/types";
+export declare function canReadCollection<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>): boolean;
+export declare function canEditEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
+export declare function canCreateEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
+export declare function canDeleteEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;

package/src/util/references.d.ts

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

package/src/util/relations.d.ts

@@ -0,0 +1,22 @@
+import { EntityCollection, Property, Relation } from "@rebasepro/types";
+export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): 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;