@rebasepro/server-core 0.7.0 → 0.9.0

package/dist/src-B4OLmNVa.js

@@ -0,0 +1,437 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+//#region ../types/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 ../types/src/types/entities.ts
+/**
+* Class used to create a reference to a entity in a different path.
+*
+* @example
+* // Simple reference (most common case - single driver, single db)
+* new EntityReference({ id: "123", path: "users" })
+*
+* // Reference to a different driver (e.g., Firestore)
+* new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
+*
+* // Reference to a specific database within a driver
+* new EntityReference({ id: "123", path: "orders", driver: "postgres", databaseId: "orders_db" })
+*/
+var EntityReference = class {
+	__type = "reference";
+	/**
+	* ID of the entity
+	*/
+	id;
+	/**
+	* A string representing the path of the referenced document (relative
+	* to the root of the database).
+	*/
+	path;
+	/**
+	* Which driver (e.g., 'postgres', 'firestore').
+	* Defaults to "(default)" if not specified.
+	*/
+	driver;
+	/**
+	* Which database within the driver.
+	* Defaults to "(default)" if not specified.
+	*/
+	databaseId;
+	/**
+	* Create a reference to a entity.
+	*
+	* @example
+	* // Simple reference (most common case)
+	* new EntityReference({ id: "123", path: "users" })
+	*
+	* // With driver
+	* new EntityReference({ id: "123", path: "analytics", driver: "firestore" })
+	*/
+	constructor(props) {
+		this.id = props.id;
+		this.path = props.path;
+		this.driver = props.driver;
+		this.databaseId = props.databaseId;
+	}
+	get pathWithId() {
+		return `${this.path}/${this.id}`;
+	}
+	/**
+	* Get the full path including driver and database prefixes if specified.
+	* For the common case (single driver, single db), this just returns pathWithId.
+	*/
+	get fullPath() {
+		const parts = [];
+		if (this.driver && this.driver !== "(default)") parts.push(this.driver);
+		if (this.databaseId && this.databaseId !== "(default)") parts.push(this.databaseId);
+		if (parts.length > 0) return `${parts.join(":")}:::${this.path}/${this.id}`;
+		return this.pathWithId;
+	}
+	isEntityReference() {
+		return true;
+	}
+};
+/**
+* Class used to create a reference to a entity in a different path
+*/
+var EntityRelation = class {
+	__type = "relation";
+	/**
+	* ID of the entity
+	*/
+	id;
+	/**
+	* A string representing the path of the referenced document (relative
+	* to the root of the database).
+	*/
+	path;
+	/**
+	* Pre-fetched data payload to eliminate N+1 queries.
+	* When present, clients can use this directly instead of fetching.
+	*/
+	data;
+	constructor(id, path, data) {
+		this.id = id;
+		this.path = path;
+		this.data = data;
+	}
+	get pathWithId() {
+		return `${this.path}/${this.id}`;
+	}
+	isEntityReference() {
+		return false;
+	}
+	isEntityRelation() {
+		return true;
+	}
+};
+var GeoPoint = class {
+	/**
+	* The latitude of this GeoPoint instance.
+	*/
+	latitude;
+	/**
+	* The longitude of this GeoPoint instance.
+	*/
+	longitude;
+	constructor(latitude, longitude) {
+		this.latitude = latitude;
+		this.longitude = longitude;
+	}
+};
+var Vector = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+//#endregion
+//#region ../types/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",
+	"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 = {
+	"eq": "==",
+	"neq": "!=",
+	"gt": ">",
+	"gte": ">=",
+	"lt": "<",
+	"lte": "<=",
+	"in": "in",
+	"nin": "not-in",
+	"cs": "array-contains",
+	"csa": "array-contains-any",
+	"like": "like",
+	"ilike": "ilike",
+	"nlike": "not-like",
+	"nilike": "not-ilike",
+	"isnull": "is-null",
+	"notnull": "is-not-null"
+};
+/**
+* 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 = [
+	"<",
+	"<=",
+	"==",
+	"!=",
+	">=",
+	">",
+	"in",
+	"not-in",
+	"array-contains",
+	"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.
+*
+* @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 ../types/src/types/collections.ts
+/**
+* Type guard for PostgreSQL collections.
+* Returns true if the collection uses the Postgres engine (or the default engine).
+* @group Models
+*/
+function isPostgresCollectionConfig(collection) {
+	return !collection.engine || collection.engine === "postgres";
+}
+/**
+* Type guard for Firebase / Firestore collections.
+* @group Models
+*/
+function isFirebaseCollectionConfig(collection) {
+	return collection.engine === "firestore";
+}
+/**
+* Type guard for MongoDB collections.
+* @group Models
+*/
+function isMongoDBCollectionConfig(collection) {
+	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 (isFirebaseCollectionConfig(collection) && collection.path) return collection.path;
+	if (isMongoDBCollectionConfig(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 ../types/src/types/backend.ts
+/**
+* Type guard: does this admin support SQL operations?
+* @group Admin
+*/
+function isSQLAdmin(admin) {
+	return !!admin && typeof admin.executeSql === "function";
+}
+//#endregion
+//#region ../types/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",
+	label: "PostgreSQL",
+	supportsRelations: true,
+	supportsSubcollections: false,
+	supportsRLS: true,
+	supportsReferences: false,
+	supportsColumnTypes: true,
+	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
+	supportsSQLAdmin: true,
+	supportsDocumentAdmin: false,
+	supportsSchemaAdmin: true
+};
+/** @group Models */
+var FIREBASE_CAPABILITIES = {
+	key: "firestore",
+	label: "Firebase / Firestore",
+	supportsRelations: false,
+	supportsSubcollections: true,
+	supportsRLS: false,
+	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
+};
+/** @group Models */
+var MONGODB_CAPABILITIES = {
+	key: "mongodb",
+	label: "MongoDB",
+	supportsRelations: false,
+	supportsSubcollections: true,
+	supportsRLS: false,
+	supportsReferences: true,
+	supportsColumnTypes: false,
+	supportsRealtime: false,
+	filterOperators: ALL_WHERE_FILTER_OPS,
+	supportsSQLAdmin: false,
+	supportsDocumentAdmin: true,
+	supportsSchemaAdmin: true
+};
+/**
+* Fallback capabilities when the driver is unknown.
+* Enables everything so nothing is hidden unexpectedly.
+* @group Models
+*/
+var DEFAULT_CAPABILITIES = {
+	key: "(default)",
+	label: "Default",
+	supportsRelations: true,
+	supportsSubcollections: true,
+	supportsRLS: true,
+	supportsReferences: true,
+	supportsColumnTypes: true,
+	supportsRealtime: true,
+	filterOperators: ALL_WHERE_FILTER_OPS,
+	supportsSQLAdmin: true,
+	supportsDocumentAdmin: true,
+	supportsSchemaAdmin: true
+};
+var CAPABILITIES_REGISTRY = {
+	postgres: POSTGRES_CAPABILITIES,
+	firestore: FIREBASE_CAPABILITIES,
+	mongodb: MONGODB_CAPABILITIES,
+	"(default)": DEFAULT_CAPABILITIES
+};
+/**
+* Look up capabilities for a given engine key.
+* If `engine` is undefined or not found, returns `DEFAULT_CAPABILITIES`.
+* @group Models
+*/
+function getDataSourceCapabilities(engine) {
+	if (!engine) return POSTGRES_CAPABILITIES;
+	return CAPABILITIES_REGISTRY[engine] ?? DEFAULT_CAPABILITIES;
+}
+//#endregion
+//#region ../types/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
+export { RebaseClientError as _, getCollectionDataPath as a, CANONICAL_TO_REST as c, toCanonicalOp as d, EntityReference as f, RebaseApiError as g, Vector as h, isSQLAdmin as i, NULL_OPS as l, GeoPoint as m, DEFAULT_DATA_SOURCE_KEY as n, getDeclaredSubcollections as o, EntityRelation as p, getDataSourceCapabilities as r, isPostgresCollectionConfig as s, DEFAULT_STORAGE_SOURCE_KEY as t, REST_TO_CANONICAL as u };
+
+//# sourceMappingURL=src-B4OLmNVa.js.map