@rebasepro/common 0.6.1 → 0.7.0

package/dist/collections/CollectionRegistry.d.ts

@@ -1,5 +1,12 @@
 import { EntityCollection } from "@rebasepro/types";
+import { DataSourceRegistry } from "../data/resolveDataSource";
 export declare class CollectionRegistry {
+    /**
+     * Declared data sources, used during normalization to resolve each
+     * collection's engine (so `dataSource`-only collections get the right
+     * capabilities). Empty by default → behaviour keys off `driver` as before.
+     */
+    private dataSources;
     private collectionsByTableName;
     private collectionsBySlug;
     private rootCollections;
@@ -9,7 +16,13 @@ export declare class CollectionRegistry {
     private rawRootCollections;
     private cachedRawCollectionsList;
     private lastRawInputSnapshot;
-    constructor(collections?: EntityCollection[]);
+    constructor(collections?: EntityCollection[], dataSources?: DataSourceRegistry);
+    /**
+     * Provide the declared data sources used to resolve each collection's
+     * engine during normalization. Set this before registering collections.
+     * Returns true if the registry changed (callers may re-register).
+     */
+    setDataSources(dataSources: DataSourceRegistry): boolean;
     reset(): void;
     /**
      * Registers a collection and its subcollections recursively.

package/dist/data/buildRoutedRebaseData.d.ts

@@ -0,0 +1,53 @@
+import { RebaseData } from "@rebasepro/types";
+/**
+ * Parameters for {@link buildRoutedRebaseData}.
+ */
+export interface RoutedRebaseDataParams {
+    /**
+     * 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: RebaseData;
+    /**
+     * Per-data-source {@link RebaseData} 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, RebaseData>;
+    /**
+     * 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 declare function buildRoutedRebaseData({ defaultData, sources, resolveKey }: RoutedRebaseDataParams): RebaseData;

package/dist/data/resolveDataSource.d.ts

@@ -0,0 +1,43 @@
+import { DataSourceDefinition, ResolvedDataSource } from "@rebasepro/types";
+/**
+ * The subset of a collection needed to resolve its data source. Accepting a
+ * structural type (rather than the full `EntityCollection`) keeps this usable
+ * from anywhere — frontend router, backend registry, editor — without coupling
+ * to the collection union.
+ */
+export interface DataSourceResolvable {
+    /** Preferred routing key. */
+    dataSource?: string;
+    /** Legacy engine hint / fallback routing key. */
+    driver?: string;
+    /** Within-engine instance. */
+    databaseId?: string;
+}
+/** A lookup of data-source definitions by key. */
+export type DataSourceRegistry = Record<string, DataSourceDefinition>;
+/**
+ * Build a keyed registry from a list of {@link DataSourceDefinition}s.
+ * Later entries win on key collision.
+ */
+export declare function createDataSourceRegistry(definitions?: DataSourceDefinition[]): DataSourceRegistry;
+/**
+ * Resolve the effective data source for a collection — the single source of
+ * truth shared by the frontend router, the backend driver registry, and the
+ * editor's capability lookups.
+ *
+ * Resolution order:
+ * 1. The routing **key** is `collection.dataSource`, else the legacy
+ *    `collection.driver`, else {@link DEFAULT_DATA_SOURCE_KEY}.
+ * 2. If a definition is registered for that key, it provides `engine`,
+ *    `transport`, and `databaseId`.
+ * 3. Otherwise values are synthesized for backward compatibility: `engine`
+ *    from the legacy `driver` (or the key, or `"postgres"`), `transport`
+ *    defaults to `"server"`, and `databaseId` from the collection.
+ *
+ * `capabilities` are always derived from the resolved `engine`, so two
+ * data sources sharing an engine share capabilities.
+ *
+ * @param collection the collection (or any object carrying the routing fields)
+ * @param registry   optional registry of declared data sources
+ */
+export declare function resolveDataSource(collection: DataSourceResolvable | undefined, registry?: DataSourceRegistry): ResolvedDataSource;

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export * from "./util";
 export * from "./collections";
 export * from "./data/buildRebaseData";
+export * from "./data/buildRoutedRebaseData";
+export * from "./data/resolveDataSource";
 export * from "./data/query_builder";
+export * from "./table-classification";

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { EntityReference, EntityRelation, getDataSourceCapabilities } from "@rebasepro/types";
+import { DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, getDataSourceCapabilities } from "@rebasepro/types";
 import { deepClone, generateForeignKeyName, getIn, isDefaultFieldConfigId, mergeDeep, randomString, removeFunctions, toSnakeCase } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
@@ -1411,8 +1411,57 @@ function applyEnumConditions(enumValues, conditions, context) {
 	return result;
 }
 //#endregion
+//#region src/data/resolveDataSource.ts
+/**
+* Build a keyed registry from a list of {@link DataSourceDefinition}s.
+* Later entries win on key collision.
+*/
+function createDataSourceRegistry(definitions) {
+	const registry = {};
+	for (const def of definitions ?? []) registry[def.key] = def;
+	return registry;
+}
+/**
+* Resolve the effective data source for a collection — the single source of
+* truth shared by the frontend router, the backend driver registry, and the
+* editor's capability lookups.
+*
+* Resolution order:
+* 1. The routing **key** is `collection.dataSource`, else the legacy
+*    `collection.driver`, else {@link DEFAULT_DATA_SOURCE_KEY}.
+* 2. If a definition is registered for that key, it provides `engine`,
+*    `transport`, and `databaseId`.
+* 3. Otherwise values are synthesized for backward compatibility: `engine`
+*    from the legacy `driver` (or the key, or `"postgres"`), `transport`
+*    defaults to `"server"`, and `databaseId` from the collection.
+*
+* `capabilities` are always derived from the resolved `engine`, so two
+* data sources sharing an engine share capabilities.
+*
+* @param collection the collection (or any object carrying the routing fields)
+* @param registry   optional registry of declared data sources
+*/
+function resolveDataSource(collection, registry) {
+	const key = collection?.dataSource ?? collection?.driver ?? DEFAULT_DATA_SOURCE_KEY;
+	const def = registry?.[key];
+	const engine = def?.engine ?? collection?.driver ?? (key !== DEFAULT_DATA_SOURCE_KEY ? key : "postgres");
+	return {
+		key,
+		engine,
+		transport: def?.transport ?? "server",
+		databaseId: collection?.databaseId ?? def?.databaseId,
+		capabilities: getDataSourceCapabilities(engine)
+	};
+}
+//#endregion
 //#region src/collections/CollectionRegistry.ts
 var CollectionRegistry = class {
+	/**
+	* Declared data sources, used during normalization to resolve each
+	* collection's engine (so `dataSource`-only collections get the right
+	* capabilities). Empty by default → behaviour keys off `driver` as before.
+	*/
+	dataSources = {};
 	collectionsByTableName = /* @__PURE__ */ new Map();
 	collectionsBySlug = /* @__PURE__ */ new Map();
 	rootCollections = [];
@@ -1422,9 +1471,20 @@ var CollectionRegistry = class {
 	rawRootCollections = [];
 	cachedRawCollectionsList = null;
 	lastRawInputSnapshot = null;
-	constructor(collections) {
+	constructor(collections, dataSources) {
+		if (dataSources) this.dataSources = dataSources;
 		if (collections) this.registerMultiple(collections);
 	}
+	/**
+	* Provide the declared data sources used to resolve each collection's
+	* engine during normalization. Set this before registering collections.
+	* Returns true if the registry changed (callers may re-register).
+	*/
+	setDataSources(dataSources) {
+		if (deepEqual(this.dataSources, dataSources)) return false;
+		this.dataSources = dataSources ?? {};
+		return true;
+	}
 	reset() {
 		this.collectionsByTableName.clear();
 		this.collectionsBySlug.clear();
@@ -1493,6 +1553,10 @@ var CollectionRegistry = class {
 	}
 	normalizeCollection(collection) {
 		const result = { ...collection };
+		if (result.dataSource && !result.driver) {
+			const engine = resolveDataSource(result, this.dataSources).engine;
+			if (engine) result.driver = engine;
+		}
 		const extractedRelations = this.extractRelationsFromProperties(result.properties);
 		const relResult = result;
 		const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? relResult.relations ?? [] : [];
@@ -2169,6 +2233,125 @@ function buildRebaseData(driver) {
 	} });
 }
 //#endregion
-export { COLLECTION_PATH_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, QueryBuilder, addInitialSlash, and, applyPropertyConditions, buildAdditionalFieldDelegate, buildCollection, buildConditionContext, buildEntityCallbacks, buildEnum, buildEnumValueConfig, buildProperties, buildPropertiesOrBuilder, buildProperty, buildPropertyCallbacks, buildRebaseData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, cond, createRelationRef, createRelationRefWithData, defaultUsersCollection, enumToObjectEntries, evaluateCondition, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getCollectionBySlugWithin, getCollectionPathsCombinations, getColumnName, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEntityImagePreviewPropertyKey, getEnumVarName, getLabelOrConfigFrom, getLastSegment, getLocalChangesBackup, getNavigationEntriesFromPath, getParentReferencesFromPath, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isHidden, isPropertyBuilder, isReadOnly, normalizeToEntityRelation, or, registerConditionOperations, removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlash, resolveArrayProperties, resolveCollectionPathIds, resolveCollectionRelations, resolveDefaultSelectedView, resolveEnumValues, resolveProperties, resolveProperty, resolvePropertyEnum, resolvePropertyRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, sanitizeData, sanitizeRelation, segmentsToStrippedPath, sortProperties, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues };
+//#region src/data/buildRoutedRebaseData.ts
+/**
+* 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"`
+*/
+function buildRoutedRebaseData({ defaultData, sources, resolveKey }) {
+	if (!sources || Object.keys(sources).length === 0) return defaultData;
+	function resolve(slugOrPath) {
+		const key = resolveKey(slugOrPath);
+		if (key && sources[key]) return sources[key];
+		return defaultData;
+	}
+	function getAccessor(slugOrPath) {
+		return resolve(slugOrPath).collection(slugOrPath);
+	}
+	return new Proxy({ collection: getAccessor }, { get(_target, prop) {
+		if (prop === "collection") return getAccessor;
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+		return getAccessor(toSnakeCase(prop));
+	} });
+}
+//#endregion
+//#region src/table-classification.ts
+/** Schemas that are always considered Rebase-internal. */
+var REBASE_INTERNAL_SCHEMAS = ["rebase", "auth"];
+/** Table-name prefixes that mark a table as Rebase-internal regardless of schema. */
+var REBASE_INTERNAL_PREFIXES = [
+	"_rebase_",
+	"_auth_",
+	"drizzle_"
+];
+/**
+* Synchronously classify a table based on naming conventions.
+*
+* @param tableName  - The unqualified name of the table.
+* @param schemaName - The schema the table belongs to (e.g. `"public"`, `"rebase"`).
+* @returns `"rebase-internal"` when the table belongs to a reserved schema or
+*          carries a reserved prefix; `"user"` otherwise.
+*
+* @remarks
+* Junction-table detection requires an async database query and is therefore
+* **not** handled by this function. Use {@link detectJunctionTables} to obtain
+* the set of junction tables, then reclassify as needed.
+*/
+function classifyTable(tableName, schemaName) {
+	if (REBASE_INTERNAL_SCHEMAS.includes(schemaName) || REBASE_INTERNAL_PREFIXES.some((prefix) => tableName.startsWith(prefix))) return "rebase-internal";
+	return "user";
+}
+/**
+* Convenience predicate that checks whether a table is Rebase-internal.
+*
+* @param tableName  - The unqualified name of the table.
+* @param schemaName - The schema the table belongs to.
+* @returns `true` if the table is classified as `"rebase-internal"`.
+*/
+function isRebaseInternalTable(tableName, schemaName) {
+	return classifyTable(tableName, schemaName) === "rebase-internal";
+}
+/** SQL query that detects junction tables in the `public` schema. */
+var JUNCTION_TABLES_SQL = `
+  SELECT t.table_name
+  FROM information_schema.tables t
+  WHERE t.table_schema = 'public'
+    AND t.table_type = 'BASE TABLE'
+    AND NOT EXISTS (
+      SELECT 1
+      FROM information_schema.columns c
+      WHERE c.table_schema = t.table_schema
+        AND c.table_name = t.table_name
+        AND c.column_name NOT IN (
+          SELECT kcu.column_name
+          FROM information_schema.key_column_usage kcu
+          JOIN information_schema.table_constraints tc
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND kcu.table_schema = t.table_schema
+            AND kcu.table_name = t.table_name
+        )
+    )
+`;
+/**
+* Asynchronously detect junction (link) tables in the `public` schema.
+*
+* A junction table is defined as a table where **every** column participates in
+* at least one foreign-key constraint.
+*
+* @param executeSql - A callback that executes a raw SQL string and returns the
+*                     resulting rows.
+* @returns A `Set` containing the names of all detected junction tables.
+*/
+async function detectJunctionTables(executeSql) {
+	const rows = await executeSql(JUNCTION_TABLES_SQL);
+	const junctionTables = /* @__PURE__ */ new Set();
+	for (const row of rows) if (typeof row.table_name === "string") junctionTables.add(row.table_name);
+	return junctionTables;
+}
+//#endregion
+export { COLLECTION_PATH_SEPARATOR, CollectionRegistry, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE, JUNCTION_TABLES_SQL, QueryBuilder, REBASE_INTERNAL_PREFIXES, REBASE_INTERNAL_SCHEMAS, addInitialSlash, and, applyPropertyConditions, buildAdditionalFieldDelegate, buildCollection, buildConditionContext, buildEntityCallbacks, buildEnum, buildEnumValueConfig, buildProperties, buildPropertiesOrBuilder, buildProperty, buildPropertyCallbacks, buildRebaseData, buildRoutedRebaseData, canCreateEntity, canDeleteEntity, canEditEntity, canReadCollection, checkOperation, classifyTable, cond, createDataSourceRegistry, createRelationRef, createRelationRefWithData, defaultUsersCollection, detectJunctionTables, enumToObjectEntries, evaluateCondition, findRelation, fullPathToCollectionSegments, getArrayResolvedProperties, getCollectionBySlugWithin, getCollectionPathsCombinations, getColumnName, getDefaultValueFor, getDefaultValueFortype, getDefaultValuesFor, getEntityImagePreviewPropertyKey, getEnumVarName, getLabelOrConfigFrom, getLastSegment, getLocalChangesBackup, getNavigationEntriesFromPath, getParentReferencesFromPath, getPrimaryKeys, getReferenceFrom, getRelationFrom, getSubcollections, getTableName, getTableVarName, isHidden, isPropertyBuilder, isReadOnly, isRebaseInternalTable, normalizeToEntityRelation, or, registerConditionOperations, removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlash, resolveArrayProperties, resolveCollectionPathIds, resolveCollectionRelations, resolveDataSource, resolveDefaultSelectedView, resolveEnumValues, resolveProperties, resolveProperty, resolvePropertyEnum, resolvePropertyRelation, resolveRelationProperty, resolveStorageFilenameString, resolveStoragePathString, sanitizeData, sanitizeRelation, segmentsToStrippedPath, sortProperties, stripCollectionPath, traverseValueProperty, traverseValuesProperties, updateDateAutoValues };
 
 //# sourceMappingURL=index.es.js.map