@rebasepro/common 0.23.0 → 0.24.0

package/dist/collections/CollectionRegistry.d.ts

@@ -24,6 +24,13 @@ export declare class CollectionRegistry {
     getGlobalCallbacks(): CollectionCallbacks | undefined;
     private collectionsByTableName;
     private collectionsBySlug;
+    /**
+     * Root collections whose driver stores them under a `path` other than
+     * their slug, by that path. A list, because the path is only unique within
+     * a data source: two collections in different databases may both be stored
+     * at `customer`.
+     */
+    private collectionsByDataPath;
     private rootCollections;
     private cachedCollectionsList;
     private rawCollectionsByTableName;
@@ -49,11 +56,61 @@ export declare class CollectionRegistry {
      */
     registerMultiple(collections: CollectionConfig[]): boolean;
     register(collection: CollectionConfig, rawCollection?: CollectionConfig): void;
+    /**
+     * Index a root collection by the path its driver stores it under, when
+     * that is not its slug. Only roots: a subcollection's `path` is relative to
+     * the record it hangs off, so it names nothing on its own.
+     */
+    private indexDataPath;
     private _registerRecursively;
     normalizeCollection(collection: CollectionConfig): CollectionConfig;
     private normalizeProperties;
     private normalizeProperty;
-    get(path: string): CollectionConfig | undefined;
+    /**
+     * The collection registered under `path`: by slug, by slug with hyphens
+     * for underscores, by table name, and last by the `path` a root Firestore
+     * or MongoDB collection declares for its driver.
+     *
+     * One string can name two collections. Declaring `slug: "fs_diagnosis",
+     * path: "diagnosis"` is how a Firestore collection sits beside a Postgres
+     * collection whose slug is `diagnosis` — and a reference read back from
+     * Firestore carries `diagnosis`. The order above settles it in favour of the
+     * slug unless `preferredDriver` is given: then the first collection whose
+     * data source or engine is `preferredDriver` wins. Pass a reference's
+     * `driver`, or the data source of the record the path was read from.
+     */
+    get(path: string, preferredDriver?: string): CollectionConfig | undefined;
+    /** Every collection {@link get} could answer `path` with, in its order. */
+    private candidatesFor;
+    /**
+     * The path a collection's rows are stored under, for the path the admin
+     * addresses it by.
+     *
+     * The admin addresses a collection by its slug — in routes, in
+     * `data.collection(...)`, in the `path` of every entity it lists — because
+     * the slug is what is unique. A Firestore or MongoDB collection may declare
+     * a `path` of its own ({@link getCollectionDataPath}), and its driver has to
+     * be handed that one, under every record and subcollection too:
+     * `fs_diagnosis/abc/locales` is stored at `diagnosis/abc/locales`.
+     *
+     * A path that names no registered collection, or runs only through
+     * collections stored under their slugs, comes back unchanged.
+     */
+    resolveDataPath(path: string): string;
+    /**
+     * The path the admin addresses a collection by, for a path its rows are
+     * stored under: the inverse of {@link resolveDataPath}, for a reference
+     * read back from its driver.
+     *
+     * The root is the longest leading run of segments naming a collection, and
+     * becomes its slug when the run is where that collection is stored. Each
+     * subcollection after a record id is matched by where it is stored too. A
+     * path that already names its collections by slug comes back unchanged.
+     *
+     * `preferredDriver` decides between a collection stored at the path and one
+     * whose slug it is, as in {@link get}.
+     */
+    resolveCollectionPath(path: string, preferredDriver?: string): string;
     /**
      * 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.
@@ -68,9 +125,21 @@ export declare class CollectionRegistry {
     getRawCollections(): CollectionConfig[];
     /**
      * Resolves a multi-segment path like "products/123/locales" and returns
-     * information about the collections and entity IDs along the path
+     * information about the collections and entity IDs along the path.
+     *
+     * A slug may contain slashes (`content/de-DE/podcasts`), so the root is
+     * the longest leading run of segments naming a registered collection, and
+     * each subcollection is matched the same way among its parent's.
+     *
+     * @param options.allowRecordPath accept a path that ends at a record
+     * (`…/{id}`) and resolve it to the collection holding that record, with the
+     * id last in `entityIds`. Without it such a path is an error. Only the
+     * registry can tell the two shapes apart, because only it knows where each
+     * slug ends.
      */
-    resolvePathToCollections(path: string): {
+    resolvePathToCollections(path: string, options?: {
+        allowRecordPath?: boolean;
+    }): {
         collections: CollectionConfig[];
         entityIds: (string | number)[];
         finalCollection: CollectionConfig;

package/dist/data/buildRebaseData.d.ts

@@ -22,6 +22,21 @@ export interface EntityDataOptions {
         relations?: unknown[];
         slug?: string;
     } | undefined;
+    /**
+     * Translate the path a collection is addressed by into the path its driver
+     * stores it under.
+     *
+     * The admin addresses every collection by its slug, and a Firestore or
+     * MongoDB collection may declare a `path` of its own: `fs_diagnosis` stored
+     * at `diagnosis`, and `fs_diagnosis/abc/locales` at `diagnosis/abc/locales`.
+     * Only the driver is handed the stored path. Rows keep the address they
+     * were asked for by, because that is what the admin resolves their
+     * collection, routes and deletes by.
+     *
+     * Late-bound, like `resolveCollection`. Absent, or answering `undefined`,
+     * the address is the stored path.
+     */
+    resolveDataPath?: (path: string) => string | undefined;
 }
 export declare function buildRebaseData(driver: DataDriver, options?: EntityDataOptions): RebaseData;
 /**

package/dist/data/cursor.d.ts

@@ -1,4 +1,4 @@
-import type { OrderByTuple } from "@rebasepro/types";
+import { type OrderByTuple } from "@rebasepro/types";
 /**
  * The keyset-cursor wire codec.
  *