@rebasepro/types 0.8.0 → 0.9.0

package/dist/controllers/{side_entity_controller.d.ts → side_panel_controller.d.ts}

@@ -1,10 +1,10 @@
 import type { Entity } from "../types/entities";
-import type { EntityCollection } from "../types/collections";
+import type { CollectionConfig } from "../types/collections";
 /**
  * Props used to open a side dialog
  * @group Hooks and utilities
  */
-export interface EntitySidePanelProps<M extends Record<string, unknown> = Record<string, unknown>> {
+export interface SidePanelBindingProps<M extends Record<string, unknown> = Record<string, unknown>> {
     /**
      * Absolute path of the entity
      */
@@ -31,7 +31,7 @@ export interface EntitySidePanelProps<M extends Record<string, unknown> = Record
      * Collection representing the entities of this view.
      * If you leave it blank it will be induced by your navigation
      */
-    collection?: EntityCollection<M>;
+    collection?: CollectionConfig<M>;
     /**
      * Should update the URL when opening the dialog.
      * Consider that if the collection that you provide is not defined in the base
@@ -74,7 +74,7 @@ export interface EntitySidePanelProps<M extends Record<string, unknown> = Record
  * Controller to open the side dialog displaying entity forms
  * @group Hooks and utilities
  */
-export interface SideEntityController {
+export interface SidePanelController {
     /**
      * Close the last panel
      */
@@ -84,14 +84,14 @@ export interface SideEntityController {
      * of the view is fetched from the collections you have specified in the
      * navigation.
      * At least you need to pass the path of the entity you would like
-     * to edit. You can set an entityId if you would like to edit and existing one
+     * to edit. You can set a entityId if you would like to edit and existing one
      * (or a new one with that id).
      * @param props
      */
-    open: <M extends Record<string, unknown> = Record<string, unknown>>(props: EntitySidePanelProps<M>) => void;
+    open: <M extends Record<string, unknown> = Record<string, unknown>>(props: SidePanelBindingProps<M>) => void;
     /**
      * Replace the last open entity panel with the given one.
      * @param props
      */
-    replace: <M extends Record<string, unknown> = Record<string, unknown>>(props: EntitySidePanelProps<M>) => void;
+    replace: <M extends Record<string, unknown> = Record<string, unknown>>(props: SidePanelBindingProps<M>) => void;
 }

package/dist/controllers/storage.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Path prefix that marks an object as **public**. Files stored under this
+ * prefix are served without any auth token via a stable, permanent,
+ * CDN-cacheable URL (see {@link StorageSource.getSignedUrl}). Shared by the
+ * client SDK and the backend so both agree on which objects are public.
+ *
+ * @group Models
+ */
+export declare const PUBLIC_STORAGE_PREFIX = "public/";
+/**
+ * True when a storage key/path points at a public object (lives under
+ * {@link PUBLIC_STORAGE_PREFIX}). The check is applied to the key *within the
+ * bucket* — strip any `bucket/` and `scheme://` prefixes first.
+ *
+ * @group Models
+ */
+export declare function isPublicStoragePath(path: string | null | undefined): boolean;
 /**
  * @group Models
  */
@@ -6,6 +23,13 @@ export interface UploadFileProps {
     key: string;
     metadata?: Record<string, unknown>;
     bucket?: string;
+    /**
+     * Store this object as **public**: it is placed under
+     * {@link PUBLIC_STORAGE_PREFIX} and served via a stable, token-less,
+     * permanent URL (safe to persist in a database and cache on a CDN).
+     * Defaults to `false` (private, short-lived signed URLs).
+     */
+    public?: boolean;
 }
 /**
  * @group Models
@@ -67,6 +91,21 @@ export declare interface DownloadMetadata {
      */
     contentType: string;
     customMetadata: Record<string, unknown>;
+    /**
+     * Optional short-lived download token (for local/server-mediated storage).
+     * Absent for public objects, which need no token.
+     */
+    token?: string;
+    /**
+     * Optional remaining lifetime of the token, in seconds.
+     */
+    tokenExpiresIn?: number;
+    /**
+     * True when this object is public: it is served without a token via a
+     * stable, permanent, CDN-cacheable URL. When set, the client builds a
+     * token-less URL and caches it indefinitely.
+     */
+    public?: boolean;
 }
 /**
  * @group Models

package/dist/errors.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Structured initializer for {@link RebaseApiError}.
+ *
+ * @group Errors
+ */
+export interface RebaseErrorInit {
+    /**
+     * HTTP status code, when the error originated from an HTTP response.
+     * Left `undefined` for realtime/WebSocket, network, and client-side
+     * logic errors that have no HTTP status.
+     */
+    status?: number;
+    /** Stable, machine-readable error code (e.g. `"NOT_FOUND"`, `"BAD_REQUEST"`). */
+    code?: string;
+    /** Structured error payload returned by the server, when present. */
+    details?: unknown;
+    /** The underlying error this one wraps, if any. */
+    cause?: unknown;
+}
+/**
+ * The single error type thrown across the entire Rebase client surface —
+ * HTTP data/control-plane calls, realtime/WebSocket operations, and
+ * client-side logic errors (e.g. an unknown collection accessor). A `catch`
+ * block only ever needs to check for this one class:
+ *
+ * ```ts
+ * import { RebaseApiError } from "@rebasepro/client"; // re-exported
+ *
+ * try {
+ *   await client.data.products.update(id, { price: 9 });
+ * } catch (e) {
+ *   if (e instanceof RebaseApiError) {
+ *     if (e.status === 404) { ... }   // HTTP failures carry a status
+ *     console.error(e.code, e.details);
+ *   }
+ * }
+ * ```
+ *
+ * `status` is present for HTTP failures and `undefined` otherwise, so its
+ * presence distinguishes transport-level errors from realtime/logic errors.
+ *
+ * @group Errors
+ */
+export declare class RebaseApiError extends Error {
+    /** HTTP status code, or `undefined` for non-HTTP errors. */
+    readonly status?: number;
+    /** Stable machine-readable error code, when the server supplied one. */
+    readonly code?: string;
+    /** Structured error payload from the server, when present. */
+    readonly details?: unknown;
+    constructor(message: string, init?: RebaseErrorInit);
+}
+/**
+ * Client-side logic error — raised before any request is made (e.g. accessing
+ * an unknown collection accessor when a typed dictionary is configured).
+ *
+ * A subclass of {@link RebaseApiError} (with no `status`), so a single
+ * `catch (e) { if (e instanceof RebaseApiError) ... }` handles it too.
+ *
+ * @group Errors
+ */
+export declare class RebaseClientError extends RebaseApiError {
+    constructor(message: string);
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./errors";
 export * from "./rebase_context";
 export * from "./types";
 export * from "./controllers";

package/dist/index.es.js

@@ -1,6 +1,63 @@
+//#region src/errors.ts
+/**
+* The single error type thrown across the entire Rebase client surface —
+* HTTP data/control-plane calls, realtime/WebSocket operations, and
+* client-side logic errors (e.g. an unknown collection accessor). A `catch`
+* block only ever needs to check for this one class:
+*
+* ```ts
+* import { RebaseApiError } from "@rebasepro/client"; // re-exported
+*
+* try {
+*   await client.data.products.update(id, { price: 9 });
+* } catch (e) {
+*   if (e instanceof RebaseApiError) {
+*     if (e.status === 404) { ... }   // HTTP failures carry a status
+*     console.error(e.code, e.details);
+*   }
+* }
+* ```
+*
+* `status` is present for HTTP failures and `undefined` otherwise, so its
+* presence distinguishes transport-level errors from realtime/logic errors.
+*
+* @group Errors
+*/
+var RebaseApiError = class extends Error {
+	/** HTTP status code, or `undefined` for non-HTTP errors. */
+	status;
+	/** Stable machine-readable error code, when the server supplied one. */
+	code;
+	/** Structured error payload from the server, when present. */
+	details;
+	constructor(message, init = {}) {
+		super(message);
+		this.name = "RebaseApiError";
+		this.status = init.status;
+		this.code = init.code;
+		this.details = init.details;
+		if (init.cause !== void 0) this.cause = init.cause;
+	}
+};
+/**
+* Client-side logic error — raised before any request is made (e.g. accessing
+* an unknown collection accessor when a typed dictionary is configured).
+*
+* A subclass of {@link RebaseApiError} (with no `status`), so a single
+* `catch (e) { if (e instanceof RebaseApiError) ... }` handles it too.
+*
+* @group Errors
+*/
+var RebaseClientError = class extends RebaseApiError {
+	constructor(message) {
+		super(message);
+		this.name = "RebaseClientError";
+	}
+};
+//#endregion
 //#region src/types/entities.ts
 /**
-* Class used to create a reference to an entity in a different path.
+* Class used to create a reference to a entity in a different path.
 *
 * @example
 * // Simple reference (most common case - single driver, single db)
@@ -34,7 +91,7 @@ var EntityReference = class {
 	*/
 	databaseId;
 	/**
-	* Create a reference to an entity.
+	* Create a reference to a entity.
 	*
 	* @example
 	* // Simple reference (most common case)
@@ -68,7 +125,7 @@ var EntityReference = class {
 	}
 };
 /**
-* Class used to create a reference to an entity in a different path
+* Class used to create a reference to a entity in a different path
 */
 var EntityRelation = class {
 	__type = "relation";
@@ -134,7 +191,13 @@ var CANONICAL_TO_REST = {
 	"in": "in",
 	"not-in": "nin",
 	"array-contains": "cs",
-	"array-contains-any": "csa"
+	"array-contains-any": "csa",
+	"like": "like",
+	"ilike": "ilike",
+	"not-like": "nlike",
+	"not-ilike": "nilike",
+	"is-null": "isnull",
+	"is-not-null": "notnull"
 };
 /** Maps REST short-code operators to their canonical equivalents. */
 var REST_TO_CANONICAL = {
@@ -147,10 +210,26 @@ var REST_TO_CANONICAL = {
 	"in": "in",
 	"nin": "not-in",
 	"cs": "array-contains",
-	"csa": "array-contains-any"
+	"csa": "array-contains-any",
+	"like": "like",
+	"ilike": "ilike",
+	"nlike": "not-like",
+	"nilike": "not-ilike",
+	"isnull": "is-null",
+	"notnull": "is-not-null"
 };
-/** All canonical operator strings for runtime validation. */
-var CANONICAL_OPS = new Set([
+/**
+* Operators that test for null/not-null and therefore ignore their value.
+* Codecs normalize the value of these conditions to `null`.
+*/
+var NULL_OPS = new Set(["is-null", "is-not-null"]);
+/**
+* Every canonical operator, in a stable order. Useful for engine capability
+* declarations ({@link DataSourceCapabilities.filterOperators}) and for
+* building operator subsets.
+* @group Models
+*/
+var ALL_WHERE_FILTER_OPS = [
 	"<",
 	"<=",
 	"==",
@@ -160,8 +239,16 @@ var CANONICAL_OPS = new Set([
 	"in",
 	"not-in",
 	"array-contains",
-	"array-contains-any"
-]);
+	"array-contains-any",
+	"like",
+	"ilike",
+	"not-like",
+	"not-ilike",
+	"is-null",
+	"is-not-null"
+];
+/** All canonical operator strings for runtime validation. */
+var CANONICAL_OPS = new Set(ALL_WHERE_FILTER_OPS);
 /**
 * Resolve any operator string (canonical or REST short-code) to its
 * canonical `WhereFilterOp` form. Returns `undefined` for unknown operators.
@@ -183,21 +270,21 @@ function toCanonicalOp(op) {
 * Returns true if the collection uses the Postgres engine (or the default engine).
 * @group Models
 */
-function isPostgresCollection(collection) {
+function isPostgresCollectionConfig(collection) {
 	return !collection.engine || collection.engine === "postgres";
 }
 /**
 * Type guard for Firebase / Firestore collections.
 * @group Models
 */
-function isFirebaseCollection(collection) {
+function isFirebaseCollectionConfig(collection) {
 	return collection.engine === "firestore";
 }
 /**
 * Type guard for MongoDB collections.
 * @group Models
 */
-function isMongoDBCollection(collection) {
+function isMongoDBCollectionConfig(collection) {
 	return collection.engine === "mongodb";
 }
 /**
@@ -206,8 +293,8 @@ function isMongoDBCollection(collection) {
 * otherwise falls back to `slug`.
 */
 function getCollectionDataPath(collection) {
-	if (isFirebaseCollection(collection) && collection.path) return collection.path;
-	if (isMongoDBCollection(collection) && collection.path) return collection.path;
+	if (isFirebaseCollectionConfig(collection) && collection.path) return collection.path;
+	if (isMongoDBCollectionConfig(collection) && collection.path) return collection.path;
 	return collection.slug;
 }
 /**
@@ -256,6 +343,11 @@ var policy = {
 		roles
 	}),
 	authenticated: () => ({ kind: "authenticated" }),
+	existsIn: (args) => ({
+		kind: "existsIn",
+		collection: args.collection,
+		where: args.where
+	}),
 	raw: (sql) => ({
 		kind: "raw",
 		sql
@@ -264,6 +356,10 @@ var policy = {
 		kind: "field",
 		name
 	}),
+	outerField: (name) => ({
+		kind: "outerField",
+		name
+	}),
 	literal: (value) => ({
 		kind: "literal",
 		value
@@ -320,6 +416,7 @@ var POSTGRES_CAPABILITIES = {
 	supportsReferences: false,
 	supportsColumnTypes: true,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: true,
 	supportsDocumentAdmin: false,
 	supportsSchemaAdmin: true
@@ -334,6 +431,7 @@ var FIREBASE_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: false,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS.filter((op) => op !== "like" && op !== "ilike" && op !== "not-like" && op !== "not-ilike"),
 	supportsSQLAdmin: false,
 	supportsDocumentAdmin: false,
 	supportsSchemaAdmin: false
@@ -348,6 +446,7 @@ var MONGODB_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: false,
 	supportsRealtime: false,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: false,
 	supportsDocumentAdmin: true,
 	supportsSchemaAdmin: true
@@ -366,6 +465,7 @@ var DEFAULT_CAPABILITIES = {
 	supportsReferences: true,
 	supportsColumnTypes: true,
 	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
 	supportsSQLAdmin: true,
 	supportsDocumentAdmin: true,
 	supportsSchemaAdmin: true
@@ -423,6 +523,33 @@ function isLazyComponentRef(ref) {
 	return typeof ref === "object" && ref !== null && "__rebaseLazy" in ref && ref.__rebaseLazy === true;
 }
 //#endregion
-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 };
+//#region src/controllers/storage.ts
+/**
+* Path prefix that marks an object as **public**. Files stored under this
+* prefix are served without any auth token via a stable, permanent,
+* CDN-cacheable URL (see {@link StorageSource.getSignedUrl}). Shared by the
+* client SDK and the backend so both agree on which objects are public.
+*
+* @group Models
+*/
+var PUBLIC_STORAGE_PREFIX = "public/";
+/**
+* True when a storage key/path points at a public object (lives under
+* {@link PUBLIC_STORAGE_PREFIX}). The check is applied to the key *within the
+* bucket* — strip any `bucket/` and `scheme://` prefixes first.
+*
+* @group Models
+*/
+function isPublicStoragePath(path) {
+	if (!path) return false;
+	let p = path;
+	const scheme = p.indexOf("://");
+	if (scheme !== -1) p = p.substring(scheme + 3);
+	p = p.replace(/^\/+/, "");
+	if (p.split("/").some((seg) => seg === "..")) return false;
+	return p.startsWith("public/") || p.startsWith(`default/public/`);
+}
+//#endregion
+export { ALL_WHERE_FILTER_OPS, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REST_TO_CANONICAL, RebaseApiError, RebaseClientError, Vector, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, isBranchAdmin, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isSQLAdmin, isSchemaAdmin, policy, registerDataSourceCapabilities, toCanonicalOp };
 
 //# sourceMappingURL=index.es.js.map