@rebasepro/common 0.6.0 → 0.7.0

package/dist/index.umd.js

@@ -1440,8 +1440,57 @@
 		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 ?? _rebasepro_types.DEFAULT_DATA_SOURCE_KEY;
+		const def = registry?.[key];
+		const engine = def?.engine ?? collection?.driver ?? (key !== _rebasepro_types.DEFAULT_DATA_SOURCE_KEY ? key : "postgres");
+		return {
+			key,
+			engine,
+			transport: def?.transport ?? "server",
+			databaseId: collection?.databaseId ?? def?.databaseId,
+			capabilities: (0, _rebasepro_types.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 = [];
@@ -1451,9 +1500,20 @@
 		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 ((0, fast_equals.deepEqual)(this.dataSources, dataSources)) return false;
+			this.dataSources = dataSources ?? {};
+			return true;
+		}
 		reset() {
 			this.collectionsByTableName.clear();
 			this.collectionsBySlug.clear();
@@ -1522,6 +1582,10 @@
 		}
 		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 = (0, _rebasepro_types.getDataSourceCapabilities)(result.driver).supportsRelations ? relResult.relations ?? [] : [];
@@ -2198,11 +2262,133 @@
 		} });
 	}
 	//#endregion
+	//#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((0, _rebasepro_utils.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
 	exports.COLLECTION_PATH_SEPARATOR = COLLECTION_PATH_SEPARATOR;
 	exports.CollectionRegistry = CollectionRegistry;
 	exports.DEFAULT_ONE_OF_TYPE = DEFAULT_ONE_OF_TYPE;
 	exports.DEFAULT_ONE_OF_VALUE = DEFAULT_ONE_OF_VALUE;
+	exports.JUNCTION_TABLES_SQL = JUNCTION_TABLES_SQL;
 	exports.QueryBuilder = QueryBuilder;
+	exports.REBASE_INTERNAL_PREFIXES = REBASE_INTERNAL_PREFIXES;
+	exports.REBASE_INTERNAL_SCHEMAS = REBASE_INTERNAL_SCHEMAS;
 	exports.addInitialSlash = addInitialSlash;
 	exports.and = and;
 	exports.applyPropertyConditions = applyPropertyConditions;
@@ -2217,15 +2403,19 @@
 	exports.buildProperty = buildProperty;
 	exports.buildPropertyCallbacks = buildPropertyCallbacks;
 	exports.buildRebaseData = buildRebaseData;
+	exports.buildRoutedRebaseData = buildRoutedRebaseData;
 	exports.canCreateEntity = canCreateEntity;
 	exports.canDeleteEntity = canDeleteEntity;
 	exports.canEditEntity = canEditEntity;
 	exports.canReadCollection = canReadCollection;
 	exports.checkOperation = checkOperation;
+	exports.classifyTable = classifyTable;
 	exports.cond = cond;
+	exports.createDataSourceRegistry = createDataSourceRegistry;
 	exports.createRelationRef = createRelationRef;
 	exports.createRelationRefWithData = createRelationRefWithData;
 	exports.defaultUsersCollection = defaultUsersCollection;
+	exports.detectJunctionTables = detectJunctionTables;
 	exports.enumToObjectEntries = enumToObjectEntries;
 	exports.evaluateCondition = evaluateCondition;
 	exports.findRelation = findRelation;
@@ -2253,6 +2443,7 @@
 	exports.isHidden = isHidden;
 	exports.isPropertyBuilder = isPropertyBuilder;
 	exports.isReadOnly = isReadOnly;
+	exports.isRebaseInternalTable = isRebaseInternalTable;
 	exports.normalizeToEntityRelation = normalizeToEntityRelation;
 	exports.or = or;
 	exports.registerConditionOperations = registerConditionOperations;
@@ -2262,6 +2453,7 @@
 	exports.resolveArrayProperties = resolveArrayProperties;
 	exports.resolveCollectionPathIds = resolveCollectionPathIds;
 	exports.resolveCollectionRelations = resolveCollectionRelations;
+	exports.resolveDataSource = resolveDataSource;
 	exports.resolveDefaultSelectedView = resolveDefaultSelectedView;
 	exports.resolveEnumValues = resolveEnumValues;
 	exports.resolveProperties = resolveProperties;