@rebasepro/common 0.17.3 → 0.18.0

package/src/data/buildRoutedRebaseData.ts

@@ -1,103 +0,0 @@
-import { RebaseData, RebaseSdkData } from "@rebasepro/types";
-import { toSnakeCase } from "@rebasepro/utils";
-
-/**
- * The two data-layer shapes that can be routed: the Entity-shaped admin
- * {@link RebaseData} or the flat SDK {@link RebaseSdkData}. Both expose a
- * `.collection(slug)` accessor, which is all the router needs.
- */
-export type RoutableData = RebaseData | RebaseSdkData;
-
-/**
- * Parameters for {@link buildRoutedRebaseData}.
- */
-export interface RoutedRebaseDataParams<T extends RoutableData = RebaseData> {
-    /**
-     * The default data source. Handles every collection that does not
-     * resolve to an entry in `sources` (i.e. server-transport collections,
-     * which ride the Rebase client).
-     */
-    defaultData: T;
-
-    /**
-     * Per-data-source instances for direct and custom transports, keyed by
-     * data-source key (e.g. `"analytics"`). Server-mediated sources are not
-     * listed here — they fall through to `defaultData`.
-     */
-    sources: Record<string, T>;
-
-    /**
-     * Resolve the data-source key for a given collection slug or path.
-     * Typically backed by the collection registry + `resolveDataSource`
-     * (`resolveDataSource(registry.getCollection(path), defs).key`).
-     *
-     * Return `undefined` (or a key absent from `sources`) to route to the
-     * default data source.
-     */
-    resolveKey: (slugOrPath: string) => string | undefined;
-}
-
-/**
- * Build a {@link RebaseData} that routes each collection to the right
- * backend based on its resolved data source.
- *
- * `.collection(path)` (and dynamic `data.products`-style access) resolves the
- * collection's data-source key via `resolveKey` and delegates to the matching
- * entry in `sources`, falling back to `defaultData` when there is no match.
- * Because routing keys off the *path being accessed*, a reference widget
- * inside a Firestore form that points at a Postgres collection is still
- * served by Postgres — routing follows the target, not the ancestor.
- *
- * When `sources` is empty this returns `defaultData` untouched, so the
- * single-driver setup keeps identical behaviour and identity (important for
- * effect dependencies that key off the data instance).
- *
- * @example
- * const data = buildRoutedRebaseData({
- *     defaultData: client.data,
- *     sources: { analytics: buildRebaseData(firestoreDriver) },
- *     resolveKey: (path) => resolveDataSource(registry.getCollection(path), defs).key
- * });
- * await data.products.find();        // → default (server / Postgres)
- * await data.events.find();          // → Firestore, if `events.dataSource === "analytics"`
- */
-export function buildRoutedRebaseData<T extends RoutableData = RebaseData>({
-    defaultData,
-    sources,
-    resolveKey
-}: RoutedRebaseDataParams<T>): T {
-
-    // Fast path: nothing to route → return the default untouched (preserves
-    // referential identity for effect dependencies).
-    if (!sources || Object.keys(sources).length === 0) {
-        return defaultData;
-    }
-
-    function resolve(slugOrPath: string): T {
-        const key = resolveKey(slugOrPath);
-        if (key && sources[key]) return sources[key];
-        return defaultData;
-    }
-
-    function getAccessor(slugOrPath: string) {
-        return (resolve(slugOrPath) as RoutableData).collection(slugOrPath);
-    }
-
-    const target = {
-        collection: getAccessor
-    } as unknown as T;
-
-    return new Proxy(target as object, {
-        get(_target, prop: string | symbol) {
-            if (prop === "collection") return getAccessor;
-            // Ignore Symbol properties (e.g. Symbol.toPrimitive, Symbol.iterator)
-            if (typeof prop === "symbol") return undefined;
-            // Ignore internal JS properties
-            if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return undefined;
-
-            // Convert camelCase property names to snake_case slugs, mirroring
-            // buildRebaseData so dynamic access routes consistently.
-            return getAccessor(toSnakeCase(prop));
-        }
-    }) as T;
-}

package/src/data/filter-conditions.ts

@@ -1,46 +0,0 @@
-/**
- * The `FilterValues` grammar, one level below the wire codec.
- *
- * A field's filter is either one `[op, value]` tuple or an **array** of them —
- * `{ age: [[">=", 18], ["<", 65]] }` — which is what the fluent builder produces
- * from two `.where()` calls on the same column. Reading that shape is grammar,
- * not a driver detail, so every compiler reads it through here.
- *
- * It lived only inside the Postgres compiler, and the Mongo one destructured
- * `const [op, value] = filterParam` regardless: given the array-of-tuples form
- * `op` bound to `[">=", 18]`, no operator matched, and the condition was
- * dropped. Both of them. A read asking for adults under 65 returned every row
- * of the collection with a 200.
- *
- * @module
- */
-
-import type { WhereFilterOp } from "@rebasepro/types";
-
-/** One `[operator, value]` condition. */
-export type FilterTuple = [WhereFilterOp, unknown];
-
-/**
- * Read one field's filter as the list of conditions it stands for.
- *
- * Accepts both declared shapes and normalises them to a list:
- *
- * ```ts
- * toFilterTuples(["==", "active"])          // [["==", "active"]]
- * toFilterTuples([[">=", 18], ["<", 65]])   // [[">=", 18], ["<", 65]]
- * ```
- *
- * A falsy, non-array or empty param has no conditions in it — the empty list,
- * so a caller iterating adds nothing rather than compiling a tuple of
- * `undefined`s and logging about an operator nobody sent.
- */
-export function toFilterTuples(filterParam: unknown): FilterTuple[] {
-    if (!filterParam || !Array.isArray(filterParam) || filterParam.length === 0) return [];
-    // The first element discriminates: a condition starts with an operator
-    // string, a list of conditions starts with a condition. `["in", ["a","b"]]`
-    // is one condition whose value happens to be a list.
-    if (Array.isArray(filterParam[0])) {
-        return filterParam as FilterTuple[];
-    }
-    return [filterParam as FilterTuple];
-}