@rebasepro/types 0.7.0 → 0.8.0

package/dist/controllers/client.d.ts

@@ -4,6 +4,7 @@ import type { EmailService } from "./email";
 import type { StorageSource } from "./storage";
 import type { CronJobStatus, CronJobLogEntry } from "../types/cron";
 import type { ApiKeysAPI } from "../types/api_keys";
+import type { StorageSourceDefinition } from "../types/storage_source";
 /**
  * Event type for authentication state changes
  */
@@ -191,8 +192,26 @@ export interface RebaseClient<DB = unknown> {
     data: RebaseData;
     /** Unified Authentication layer */
     auth: AuthClient;
-    /** Unified Storage layer */
+    /** Unified Storage layer (default storage source, backward-compatible) */
     storage?: StorageSource;
+    /** Registry of all named storage sources for multi-backend support */
+    storageRegistry?: StorageSourceRegistry;
+    /**
+     * Build a server-backed {@link StorageSource} for a named storage source.
+     * The returned source forwards `storageId` to the backend so requests are
+     * routed to the matching `StorageController`. Used to lazily wire
+     * `transport: "server"` sources on the frontend.
+     */
+    createStorageSource?(storageId: string): StorageSource;
+    /**
+     * Discover the storage sources declared on the backend via
+     * `GET /api/storage/sources`. Server-transport sources are auto-registered
+     * into {@link storageRegistry}; `direct` sources are returned so the app
+     * can supply the live {@link StorageSource} instance. The result is cached
+     * (a failed call is retryable). This makes the backend the single source of
+     * truth for storage-source configuration.
+     */
+    fetchStorageSources?(): Promise<StorageSourceDefinition[]>;
     /**
      * Server-side email service.
      * Available when SMTP or a custom `sendEmail` function is configured.
@@ -229,3 +248,36 @@ export interface RebaseClient<DB = unknown> {
         role?: string;
     }): Promise<Record<string, unknown>[]>;
 }
+/**
+ * Client-side registry for managing multiple storage sources.
+ *
+ * Mirrors the server-side `StorageRegistry` pattern. Allows collection
+ * properties to reference a named storage backend via
+ * `StorageConfig.storageSource`.
+ *
+ * @group Models
+ */
+export interface StorageSourceRegistry {
+    /**
+     * Get a storage source by key.
+     * @param key - Storage source key, or undefined/null for default
+     * @returns The StorageSource, or undefined if not found
+     */
+    get(key: string | undefined | null): StorageSource | undefined;
+    /**
+     * Get the default storage source (key = "(default)").
+     * @throws Error if no default storage is registered
+     */
+    getDefault(): StorageSource;
+    /**
+     * Get a storage source by key, with fallback to default.
+     * @param key - Storage source key, or undefined/null for default
+     * @returns The StorageSource (falls back to default if key not found)
+     * @throws Error if neither the specified nor default storage exists
+     */
+    getOrDefault(key: string | undefined | null): StorageSource;
+    /** Check if a storage source with the given key exists */
+    has(key: string): boolean;
+    /** List all registered storage source keys */
+    list(): string[];
+}

package/dist/controllers/data.d.ts

@@ -1,22 +1,5 @@
 import { Entity, EntityValues } from "../types/entities";
-/**
- * Parameters for querying a collection.
- * Uses PostgREST-style filter syntax for consistency between
- * the SDK (HTTP) and framework (in-process) contexts.
- *
- * @group Data
- */
-/**
- * A where-clause value for a single field.
- *
- * Supports three syntaxes:
- *  1. **Equality shorthand**: raw JS values — `null`, `"active"`, `42`, `true`
- *  2. **Tuple syntax**: `[operator, value]` — `[">", 18]`, `["in", ["a","b"]]`
- *  3. **PostgREST string**: `"eq.published"`, `"gte.18"`, `"in.(a,b)"`
- *
- * @group Data
- */
-export type WhereFieldValue = string | number | boolean | null | [WhereFilterOpShort, any] | [WhereFilterOpShort, any][];
+import { WhereFilterOp, FilterValues } from "../types/filter-operators";
 export type WhereValue<T> = T | T[] | null;
 export interface LogicalCondition {
     type: "and" | "or";
@@ -24,11 +7,14 @@ export interface LogicalCondition {
 }
 export interface FilterCondition {
     column: string;
-    operator: FilterOperator;
+    operator: WhereFilterOp;
     value: unknown;
 }
-/** Short operator strings accepted in the tuple syntax. */
-export type WhereFilterOpShort = "==" | "!=" | ">" | ">=" | "<" | "<=" | "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "not-in" | "array-contains" | "array-contains-any" | "cs" | "csa";
+/**
+ * Parameters for querying a collection.
+ *
+ * @group Data
+ */
 export interface FindParams {
     /** Maximum number of items to return (default: 20) */
     limit?: number;
@@ -37,30 +23,17 @@ export interface FindParams {
     /** Page number (1-indexed), alternative to offset */
     page?: number;
     /**
-     * Filter object. Supports multiple syntaxes per field:
-     *
-     * **Equality shorthand** — raw JS values (null, string, number, boolean):
-     * ```ts
-     * { company_profile_id: null }
-     * { status: "active" }
-     * { age: 18 }
-     * ```
+     * Filter conditions keyed by field name.
+     * Each value is a `[WhereFilterOp, value]` tuple or an array of tuples
+     * for multiple conditions on the same field.
      *
-     * **Tuple syntax** — `[operator, value]`:
-     * ```ts
+     * @example
+     * { status: ["==", "active"] }
      * { age: [">=", 18] }
      * { role: ["in", ["admin", "editor"]] }
-     * { deleted_at: ["!=", null] }
-     * ```
-     *
-     * **PostgREST string syntax** (original format):
-     * ```ts
-     * { status: "eq.published" }
-     * { age: "gte.18" }
-     * { role: "in.(admin,editor)" }
-     * ```
+     * { age: [[">=", 18], ["<", 65]] }
      */
-    where?: Record<string, WhereFieldValue>;
+    where?: FilterValues<string>;
     /** Logical grouping conditions (AND/OR) */
     logical?: LogicalCondition;
     /**
@@ -88,15 +61,14 @@ export interface FindResponse<M extends Record<string, unknown> = Record<string,
         hasMore: boolean;
     };
 }
-export type FilterOperator = WhereFilterOpShort;
 /**
  * Fluent Query Builder Interface supported on both client and server accessors.
  * @group Data
  */
 export interface QueryBuilderInterface<M extends Record<string, unknown> = Record<string, unknown>> {
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): this;
+    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): this;
     where(logicalCondition: LogicalCondition): this;
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): this;
+    orderBy(column: keyof M & string, direction?: "asc" | "desc"): this;
     limit(count: number): this;
     offset(count: number): this;
     search(searchString: string): this;
@@ -156,9 +128,9 @@ export interface CollectionAccessor<M extends Record<string, unknown> = Record<s
      * Count the number of records matching the given filter.
      */
     count?(params?: FindParams): Promise<number>;
-    where<K extends keyof M & string>(column: K, operator: FilterOperator, value: WhereValue<M[K]>): QueryBuilderInterface<M>;
+    where<K extends keyof M & string>(column: K, operator: WhereFilterOp, value: WhereValue<M[K]>): QueryBuilderInterface<M>;
     where(logicalCondition: LogicalCondition): QueryBuilderInterface<M>;
-    orderBy(column: keyof M & string, ascending?: "asc" | "desc"): QueryBuilderInterface<M>;
+    orderBy(column: keyof M & string, direction?: "asc" | "desc"): QueryBuilderInterface<M>;
     limit(count: number): QueryBuilderInterface<M>;
     offset(count: number): QueryBuilderInterface<M>;
     search(searchString: string): QueryBuilderInterface<M>;
@@ -195,7 +167,7 @@ export interface RebaseData {
      * const accessor = data.collection("products");
      * await accessor.find({ limit: 10 });
      */
-    collection(slug: string): CollectionAccessor;
+    collection<M extends Record<string, unknown> = Record<string, unknown>>(slug: string): CollectionAccessor<M>;
     /**
      * Dynamic collection accessor.
      * Access any collection by its slug as a property.

package/dist/controllers/registry.d.ts

@@ -4,7 +4,6 @@ import type { EntityCollectionsBuilder, AppViewsBuilder } from "../types/builder
 import type { EntityCustomView } from "../types/entity_views";
 import type { EntityAction } from "../types/entity_actions";
 import type { AppView, NavigationGroupMapping } from "./navigation";
-import type { RebasePlugin } from "../types/plugins";
 /**
  * Options to enable the built-in collection editor.
  * When provided to `<RebaseCMS>`, the editor is auto-wired as a native feature.
@@ -31,7 +30,6 @@ export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection>
     homePage?: ReactNode;
     entityViews?: EntityCustomView[];
     entityActions?: EntityAction[];
-    plugins?: RebasePlugin[];
     /**
      * Centralized configuration for how collections and views are grouped
      * in the navigation sidebar and home page.

package/dist/index.es.js

@@ -122,29 +122,155 @@ var Vector = class {
 	}
 };
 //#endregion
+//#region src/types/filter-operators.ts
+/** Maps canonical operators to their REST short-code equivalents. */
+var CANONICAL_TO_REST = {
+	"==": "eq",
+	"!=": "neq",
+	">": "gt",
+	">=": "gte",
+	"<": "lt",
+	"<=": "lte",
+	"in": "in",
+	"not-in": "nin",
+	"array-contains": "cs",
+	"array-contains-any": "csa"
+};
+/** Maps REST short-code operators to their canonical equivalents. */
+var REST_TO_CANONICAL = {
+	"eq": "==",
+	"neq": "!=",
+	"gt": ">",
+	"gte": ">=",
+	"lt": "<",
+	"lte": "<=",
+	"in": "in",
+	"nin": "not-in",
+	"cs": "array-contains",
+	"csa": "array-contains-any"
+};
+/** All canonical operator strings for runtime validation. */
+var CANONICAL_OPS = new Set([
+	"<",
+	"<=",
+	"==",
+	"!=",
+	">=",
+	">",
+	"in",
+	"not-in",
+	"array-contains",
+	"array-contains-any"
+]);
+/**
+* Resolve any operator string (canonical or REST short-code) to its
+* canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.
+*
+* @example
+* toCanonicalOp("==")   // "=="
+* toCanonicalOp("eq")   // "=="
+* toCanonicalOp("cs")   // "array-contains"
+* toCanonicalOp("xyz")  // undefined
+*/
+function toCanonicalOp(op) {
+	if (CANONICAL_OPS.has(op)) return op;
+	return REST_TO_CANONICAL[op];
+}
+//#endregion
 //#region src/types/collections.ts
 /**
 * Type guard for PostgreSQL collections.
-* Returns true if the collection uses the Postgres driver (or the default driver).
+* Returns true if the collection uses the Postgres engine (or the default engine).
 * @group Models
 */
 function isPostgresCollection(collection) {
-	return !collection.driver || collection.driver === "postgres";
+	return !collection.engine || collection.engine === "postgres";
 }
 /**
 * Type guard for Firebase / Firestore collections.
 * @group Models
 */
 function isFirebaseCollection(collection) {
-	return collection.driver === "firestore";
+	return collection.engine === "firestore";
 }
 /**
 * Type guard for MongoDB collections.
 * @group Models
 */
 function isMongoDBCollection(collection) {
-	return collection.driver === "mongodb";
+	return collection.engine === "mongodb";
 }
+/**
+* Returns the data path for a collection.
+* For Firestore or MongoDB collections with a `path`, returns that value;
+* otherwise falls back to `slug`.
+*/
+function getCollectionDataPath(collection) {
+	if (isFirebaseCollection(collection) && collection.path) return collection.path;
+	if (isMongoDBCollection(collection) && collection.path) return collection.path;
+	return collection.slug;
+}
+/**
+* Reads a collection's driver-declared subcollections thunk (the `subcollections`
+* field) independent of engine identity, so engine-agnostic code doesn't have to
+* type-guard against a specific driver. Returns `undefined` when the collection
+* declares none.
+*
+* Pair with `getDataSourceCapabilities(engine).supportsSubcollections` to decide
+* whether the engine honours subcollections at all before reading them.
+* @group Models
+*/
+function getDeclaredSubcollections(collection) {
+	return collection.subcollections;
+}
+//#endregion
+//#region src/types/policy.ts
+/** @group Models */
+var policy = {
+	true: () => ({ kind: "true" }),
+	false: () => ({ kind: "false" }),
+	and: (...operands) => ({
+		kind: "and",
+		operands
+	}),
+	or: (...operands) => ({
+		kind: "or",
+		operands
+	}),
+	not: (operand) => ({
+		kind: "not",
+		operand
+	}),
+	compare: (left, op, right) => ({
+		kind: "compare",
+		op,
+		left,
+		right
+	}),
+	rolesOverlap: (roles) => ({
+		kind: "rolesOverlap",
+		roles
+	}),
+	rolesContain: (roles) => ({
+		kind: "rolesContain",
+		roles
+	}),
+	authenticated: () => ({ kind: "authenticated" }),
+	raw: (sql) => ({
+		kind: "raw",
+		sql
+	}),
+	field: (name) => ({
+		kind: "field",
+		name
+	}),
+	literal: (value) => ({
+		kind: "literal",
+		value
+	}),
+	authUid: () => ({ kind: "authUid" }),
+	authRoles: () => ({ kind: "authRoles" })
+};
 //#endregion
 //#region src/types/backend.ts
 /**
@@ -251,13 +377,13 @@ var CAPABILITIES_REGISTRY = {
 	"(default)": DEFAULT_CAPABILITIES
 };
 /**
-* Look up capabilities for a given driver key.
-* If `driver` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
+* Look up capabilities for a given engine key.
+* If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
 * @group Models
 */
-function getDataSourceCapabilities(driver) {
-	if (!driver) return POSTGRES_CAPABILITIES;
-	return CAPABILITIES_REGISTRY[driver] ?? DEFAULT_CAPABILITIES;
+function getDataSourceCapabilities(engine) {
+	if (!engine) return POSTGRES_CAPABILITIES;
+	return CAPABILITIES_REGISTRY[engine] ?? DEFAULT_CAPABILITIES;
 }
 /**
 * Register custom capabilities for a third-party driver.
@@ -267,6 +393,27 @@ function registerDataSourceCapabilities(capabilities) {
 	CAPABILITIES_REGISTRY[capabilities.key] = capabilities;
 }
 //#endregion
+//#region src/types/storage_source.ts
+/**
+* Describes a named storage backend — a place files live.
+*
+* Declared once and shared front + back: the frontend uses it to decide
+* transport (HTTP proxy vs direct SDK), the backend uses the same `key`
+* to resolve a StorageController, and collection properties reference
+* a definition by its `key` via `StorageConfig.storageSource`.
+*
+* This mirrors the {@link DataSourceDefinition} pattern used for databases.
+*
+* @group Models
+*/
+/**
+* The default storage source key, used when a property does not specify
+* a `storageSource`. Shared by the frontend and backend registries so
+* both agree on "the default storage backend".
+* @group Models
+*/
+var DEFAULT_STORAGE_SOURCE_KEY = "(default)";
+//#endregion
 //#region src/types/component_ref.ts
 /**
 * Type guard: checks if a value is a `LazyComponentRef` produced by the
@@ -276,6 +423,6 @@ function isLazyComponentRef(ref) {
 	return typeof ref === "object" && ref !== null && "__rebaseLazy" in ref && ref.__rebaseLazy === true;
 }
 //#endregion
-export { DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MONGODB_CAPABILITIES, POSTGRES_CAPABILITIES, Vector, getDataSourceCapabilities, isBranchAdmin, isDocumentAdmin, isFirebaseCollection, isLazyComponentRef, isMongoDBCollection, isPostgresCollection, isSQLAdmin, isSchemaAdmin, registerDataSourceCapabilities };
+export { CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MONGODB_CAPABILITIES, POSTGRES_CAPABILITIES, REST_TO_CANONICAL, Vector, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, isBranchAdmin, isDocumentAdmin, isFirebaseCollection, isLazyComponentRef, isMongoDBCollection, isPostgresCollection, isSQLAdmin, isSchemaAdmin, policy, registerDataSourceCapabilities, toCanonicalOp };
 
 //# sourceMappingURL=index.es.js.map