@rebasepro/types 0.6.1 → 0.8.0

package/dist/controllers/client.d.ts

@@ -3,6 +3,8 @@ import type { RebaseData } from "./data";
 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
  */
@@ -102,6 +104,19 @@ export interface AdminAPI {
     deleteUser(userId: string): Promise<{
         success: boolean;
     }>;
+    resetPassword(userId: string, options?: {
+        password?: string;
+    }): Promise<{
+        user: AdminUser;
+        temporaryPassword?: string;
+        invitationSent?: boolean;
+    }>;
+    listRoles(): Promise<{
+        roles: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
     bootstrap(): Promise<{
         success: boolean;
         message: string;
@@ -177,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.
@@ -190,6 +223,8 @@ export interface RebaseClient<DB = unknown> {
     cron?: CronAPI;
     /** Custom backend functions API */
     functions?: FunctionsAPI;
+    /** Service API keys management API */
+    apiKeys?: ApiKeysAPI;
     /** Base HTTP URL of the backend server */
     baseUrl?: string;
     /** WebSocket client for realtime subscriptions */
@@ -213,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/navigation.d.ts

@@ -1,6 +1,5 @@
 import React from "react";
 import type { EntityCollection } from "../types/collections";
-import type { RebasePlugin } from "../types/plugins";
 /**
  * Controller that handles URL path building and resolution.
  * @group Models
@@ -89,15 +88,11 @@ export type NavigationStateController = {
     /**
      * Was there an error while loading the navigation data
      */
-    navigationLoadingError?: unknown;
+    navigationLoadingError?: Error;
     /**
      * Call this method to recalculate the navigation
      */
     refreshNavigation: () => void;
-    /**
-     * Plugin system allowing to extend the CMS functionality.
-     */
-    plugins?: RebasePlugin[];
 };
 export interface NavigateOptions {
     replace?: boolean;
@@ -107,12 +102,6 @@ export interface NavigateOptions {
     flushSync?: boolean;
     viewTransition?: boolean;
 }
-export type NavigationBlocker = {
-    updateBlockListener: (path: string, block: boolean, basePath?: string) => () => void;
-    isBlocked: (path: string) => boolean;
-    proceed?: () => void;
-    reset?: () => void;
-};
 /**
  * Custom additional views created by the developer, added to the main
  * navigation.
@@ -153,14 +142,25 @@ export interface AppView {
     group?: string;
     /**
      * Component to be rendered. This can be any React component, and can use
-     * any of the provided hooks
+     * any of the provided hooks.
+     *
+     * Pass a `ComponentType` to enable lazy rendering — the component will
+     * only be instantiated when the route is visited. This is recommended
+     * for dynamic views generated from database data.
      */
-    view: React.ReactNode;
+    view: React.ReactNode | React.ComponentType;
     /**
      * If true, a wildcard route (slug/*) is automatically registered
      * alongside the base route, enabling nested navigation within this view.
      */
     nestedRoutes?: boolean;
+    /**
+     * Restrict this view to users with at least one of the listed roles.
+     * When omitted or empty, the view is visible to all authenticated users.
+     * Applied during view resolution — the view is filtered out entirely
+     * (not just hidden from nav) if the user lacks a matching role.
+     */
+    roles?: string[];
 }
 /**
  * A composable section that can be rendered on the home page.

package/dist/controllers/registry.d.ts

@@ -1,10 +1,9 @@
 import { ReactNode } from "react";
 import type { EntityCollection } from "../types/collections";
-import type { EntityCollectionsBuilder } from "../types/builders";
+import type { EntityCollectionsBuilder, AppViewsBuilder } from "../types/builders";
 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.
@@ -22,10 +21,15 @@ export interface CollectionEditorOptions {
 }
 export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection> {
     collections?: EC[] | EntityCollectionsBuilder<EC>;
+    /**
+     * Custom top-level views added to the main navigation.
+     * Accepts a static array of views or an async builder function
+     * that receives the current user/auth context for role-based views.
+     */
+    views?: AppView[] | AppViewsBuilder;
     homePage?: ReactNode;
     entityViews?: EntityCustomView[];
     entityActions?: EntityAction[];
-    plugins?: RebasePlugin[];
     /**
      * Centralized configuration for how collections and views are grouped
      * in the navigation sidebar and home page.
@@ -43,7 +47,7 @@ export interface RebaseCMSConfig<EC extends EntityCollection = EntityCollection>
     collectionEditor?: boolean | CollectionEditorOptions;
 }
 export interface RebaseStudioConfig {
-    tools?: ("sql" | "js" | "rls" | "schema" | "storage" | "cron" | "schema-visualizer" | "branches" | "api" | "logs")[];
+    tools?: ("sql" | "js" | "rls" | "schema" | "storage" | "cron" | "schema-visualizer" | "branches" | "api" | "logs" | "api-keys")[];
     homePage?: ReactNode;
     devViews?: AppView[];
 }

package/dist/index.es.js

@@ -122,30 +122,156 @@ 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
 /**
 * Type guard: does this admin support SQL operations?
@@ -177,6 +303,13 @@ function isBranchAdmin(admin) {
 }
 //#endregion
 //#region src/types/data_source.ts
+/**
+* The default data-source key, used when a collection does not name a
+* `dataSource`. Shared by the frontend router and the backend driver
+* registry so both agree on "the default database".
+* @group Models
+*/
+var DEFAULT_DATA_SOURCE_KEY = "(default)";
 /** @group Models */
 var POSTGRES_CAPABILITIES = {
 	key: "postgres",
@@ -244,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.
@@ -260,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
@@ -269,6 +423,6 @@ function isLazyComponentRef(ref) {
 	return typeof ref === "object" && ref !== null && "__rebaseLazy" in ref && ref.__rebaseLazy === true;
 }
 //#endregion
-export { DEFAULT_CAPABILITIES, 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