@rebasepro/server-postgres 0.9.1-canary.f2f61da → 0.9.1-canary.fd3754b

package/dist/src-Eh-CZosp.js

@@ -0,0 +1,595 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { n as __exportAll } from "./chunk-DSJWtz9O.js";
+//#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/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" }),
+	existsIn: (args) => ({
+		kind: "existsIn",
+		collection: args.collection,
+		where: args.where
+	}),
+	raw: (sql) => ({
+		kind: "raw",
+		sql
+	}),
+	field: (name) => ({
+		kind: "field",
+		name
+	}),
+	outerField: (name) => ({
+		kind: "outerField",
+		name
+	}),
+	literal: (value) => ({
+		kind: "literal",
+		value
+	}),
+	authUid: () => ({ kind: "authUid" }),
+	authRoles: () => ({ kind: "authRoles" })
+};
+//#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";
+}
+/**
+* Type guard: does this admin support document operations?
+* @group Admin
+*/
+function isDocumentAdmin(admin) {
+	return !!admin && (typeof admin.executeAggregate === "function" || typeof admin.fetchCollectionStats === "function");
+}
+/**
+* Type guard: does this admin support schema management?
+* @group Admin
+*/
+function isSchemaAdmin(admin) {
+	return !!admin && (typeof admin.fetchUnmappedTables === "function" || typeof admin.fetchTableMetadata === "function");
+}
+/**
+* Type guard: does this admin support database branching?
+* @group Admin
+*/
+function isBranchAdmin(admin) {
+	return !!admin && typeof admin.createBranch === "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;
+}
+/**
+* Register custom capabilities for a third-party driver.
+* @group Models
+*/
+function registerDataSourceCapabilities(capabilities) {
+	CAPABILITIES_REGISTRY[capabilities.key] = 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
+//#region ../types/src/types/component_ref.ts
+/**
+* Type guard: checks if a value is a `LazyComponentRef` produced by the
+* Vite transform plugin.
+*/
+function isLazyComponentRef(ref) {
+	return typeof ref === "object" && ref !== null && "__rebaseLazy" in ref && ref.__rebaseLazy === true;
+}
+//#endregion
+//#region ../types/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
+//#region ../types/src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	ALL_WHERE_FILTER_OPS: () => ALL_WHERE_FILTER_OPS,
+	CANONICAL_TO_REST: () => CANONICAL_TO_REST,
+	DEFAULT_CAPABILITIES: () => DEFAULT_CAPABILITIES,
+	DEFAULT_DATA_SOURCE_KEY: () => DEFAULT_DATA_SOURCE_KEY,
+	DEFAULT_STORAGE_SOURCE_KEY: () => DEFAULT_STORAGE_SOURCE_KEY,
+	EntityReference: () => EntityReference,
+	EntityRelation: () => EntityRelation,
+	FIREBASE_CAPABILITIES: () => FIREBASE_CAPABILITIES,
+	GeoPoint: () => GeoPoint,
+	MONGODB_CAPABILITIES: () => MONGODB_CAPABILITIES,
+	NULL_OPS: () => NULL_OPS,
+	POSTGRES_CAPABILITIES: () => POSTGRES_CAPABILITIES,
+	PUBLIC_STORAGE_PREFIX: () => PUBLIC_STORAGE_PREFIX,
+	REST_TO_CANONICAL: () => REST_TO_CANONICAL,
+	RebaseApiError: () => RebaseApiError,
+	RebaseClientError: () => RebaseClientError,
+	Vector: () => Vector,
+	getCollectionDataPath: () => getCollectionDataPath,
+	getDataSourceCapabilities: () => getDataSourceCapabilities,
+	getDeclaredSubcollections: () => getDeclaredSubcollections,
+	isBranchAdmin: () => isBranchAdmin,
+	isDocumentAdmin: () => isDocumentAdmin,
+	isFirebaseCollectionConfig: () => isFirebaseCollectionConfig,
+	isLazyComponentRef: () => isLazyComponentRef,
+	isMongoDBCollectionConfig: () => isMongoDBCollectionConfig,
+	isPostgresCollectionConfig: () => isPostgresCollectionConfig,
+	isPublicStoragePath: () => isPublicStoragePath,
+	isSQLAdmin: () => isSQLAdmin,
+	isSchemaAdmin: () => isSchemaAdmin,
+	policy: () => policy,
+	registerDataSourceCapabilities: () => registerDataSourceCapabilities,
+	toCanonicalOp: () => toCanonicalOp
+});
+//#endregion
+export { isSchemaAdmin as a, isPostgresCollectionConfig as c, NULL_OPS as d, REST_TO_CANONICAL as f, Vector as g, EntityRelation as h, isSQLAdmin as i, ALL_WHERE_FILTER_OPS as l, EntityReference as m, DEFAULT_DATA_SOURCE_KEY as n, policy as o, toCanonicalOp as p, getDataSourceCapabilities as r, getDeclaredSubcollections as s, src_exports as t, CANONICAL_TO_REST as u };
+
+//# sourceMappingURL=src-Eh-CZosp.js.map