@rebasepro/types 0.20.0 → 0.21.0

package/dist/call_context.d.ts

@@ -3,6 +3,25 @@ import type { StorageSource } from "./controllers/storage.js";
 import type { RebaseClient } from "./controllers/client.js";
 import type { RebaseSdkData } from "./controllers/data.js";
 import type { User } from "./users/index.js";
+/**
+ * The client a collection callback is handed as `context.client`: the Rebase
+ * client **without `data`**.
+ *
+ * A callback's queries go through {@link RebaseCallContext.data}. This client
+ * is for everything else — functions, storage, email, and `dataAsAdmin` when a
+ * callback deliberately needs an admin's reach.
+ *
+ * `data` is left off because server-side there is none. The object is the
+ * `rebase` singleton, which omits `data` so that its admin-scoped plane has
+ * exactly one name. This used to be declared as the full `RebaseClient`, so
+ * `context.client.data.collection(…)` compiled and then threw "Cannot read
+ * properties of undefined" in production. In the browser the panel's client
+ * does carry a `data`, but `context.data` is the accessor there too: one name
+ * for a callback's queries on both sides of the wire.
+ *
+ * @group Hooks and utilities
+ */
+export type RebaseCallbackClient<DB = unknown> = Omit<RebaseClient<DB>, "data">;
 /**
  * Context that is provided to entity callbacks (hooks).
  * It contains only the dependencies that are available in both the frontend and the backend.
@@ -51,6 +70,8 @@ export type RebaseCallContext<USER extends User = User> = {
      * user-scoped operation to admin. For queries in a callback use
      * {@link data}; come here for functions, storage and email.
      *
+     * There is no `context.client.data`: see {@link RebaseCallbackClient}.
+     *
      * @example
      * // In a beforeSave callback:
      * const result = await context.client.functions.invoke('my-function', { ... });
@@ -60,7 +81,7 @@ export type RebaseCallContext<USER extends User = User> = {
      * const { client } = props.context;
      * const result = await client.functions.invoke('extract-job', { url });
      */
-    client: RebaseClient;
+    client: RebaseCallbackClient;
     /**
      * Unified data access — `context.data.products.create(...)`.
      * Access any collection as a dynamic property.
@@ -107,7 +128,7 @@ export type RebaseCallContext<USER extends User = User> = {
      * practice — the backend has always passed it, and the callbacks guide
      * documented `context.driver.withAuth(user)` in all six locales. The
      * contract simply did not name it, so `buildCallContext` was cast through
-     * `as unknown as RebaseCallContext` and nothing about the object was
+     * `as RebaseCallContext` and nothing about the object was
      * type-checked at all.
      *
      * The guide no longer recommends `withAuth` — {@link data} is already

package/dist/controllers/data_driver.d.ts

@@ -279,6 +279,25 @@ export interface DeleteManyProps<M extends Record<string, unknown> = Record<stri
     /** See {@link DeleteProps.hard}. */
     hard?: boolean;
 }
+/**
+ * Addressing ONE link of a many-to-many, to set the columns it carries.
+ *
+ * `path` is the relation on a row — `posts/1/tags` — and `targetId` the row on
+ * the far side, so the pair names exactly one junction row. Not a `SaveProps`,
+ * because a save at that address means "write the target row", and a link's own
+ * columns are not the target's: two posts sharing a tag see one tag and two
+ * different links.
+ *
+ * @internal
+ */
+export interface UpdateRelationPivotProps {
+    /** The nested relation path, e.g. `posts/1/tags`. */
+    path: string;
+    /** The far side's key. */
+    targetId: string | number;
+    /** The junction columns to set, keyed by the property key `through.properties` declares. */
+    pivot: Record<string, unknown>;
+}
 /**
  * One operation of a {@link DataDriver.batchWrite}.
  *
@@ -429,6 +448,20 @@ export interface DataDriver {
      * @param path Collection path
      */
     deleteAll?(path: string): Promise<void>;
+    /**
+     * Set the columns ONE many-to-many link carries, leaving the membership
+     * alone — `manyToMany`'s `through.properties`.
+     *
+     * `PATCH /api/data/<c>/<id>/<relation>/<targetId>` with a `_pivot` body
+     * reaches this. The membership array cannot express it: sending one element
+     * would unlink everything else, and re-sending the whole set to change one
+     * value reintroduces the lost update the membership diff exists to avoid.
+     *
+     * Optional. A driver whose junctions carry nothing but the two keys leaves
+     * it undefined, and the REST layer answers `RELATION_PIVOT_UNSUPPORTED`
+     * rather than pretending the write landed.
+     */
+    updateRelationPivot?(props: UpdateRelationPivotProps): Promise<void>;
     /**
      * Delete many rows in one transaction, addressed by id.
      *

package/dist/errors.d.ts

@@ -132,21 +132,6 @@ export declare class RebaseClientError extends RebaseApiError {
      */
     constructor(message: string, init?: RebaseErrorInit);
 }
-/**
- * Build the stub a client installs for a contract method it cannot serve.
- *
- * `listen`, `listenById` and `count` are part of `SDKCollectionClient`, not
- * optional extras — a caller should be able to write
- * `client.data.posts.count()` without asking first, and a transport that cannot
- * serve it should answer with a sentence naming the configuration that would,
- * rather than with `undefined is not a function` at the call site. Where the
- * transport genuinely cannot (a client built with `realtime: false`, a driver
- * with no `listenCollection`), it installs one of these instead of omitting the
- * method.
- *
- * @param message What to tell the caller, naming the fix.
- * @group Errors
- */
 export declare function unsupportedMethod<F>(message: string): F;
 /**
  * Can this method actually do anything?

package/dist/index.es.js

@@ -81,21 +81,6 @@ var RebaseClientError = class extends RebaseApiError {
 * agree about it, and a module-local symbol would not.
 */
 var UNSUPPORTED_METHOD = Symbol.for("rebase.unsupportedMethod");
-/**
-* Build the stub a client installs for a contract method it cannot serve.
-*
-* `listen`, `listenById` and `count` are part of `SDKCollectionClient`, not
-* optional extras — a caller should be able to write
-* `client.data.posts.count()` without asking first, and a transport that cannot
-* serve it should answer with a sentence naming the configuration that would,
-* rather than with `undefined is not a function` at the call site. Where the
-* transport genuinely cannot (a client built with `realtime: false`, a driver
-* with no `listenCollection`), it installs one of these instead of omitting the
-* method.
-*
-* @param message What to tell the caller, naming the fix.
-* @group Errors
-*/
 function unsupportedMethod(message) {
 	const stub = () => {
 		throw new RebaseClientError(message, { code: "REALTIME_DISABLED" });
@@ -574,23 +559,41 @@ function nestAdminKeysOf(source, adminKeys) {
 function nestAdminCollectionKeys(collection) {
 	return nestAdminKeysOf(collection, ADMIN_COLLECTION_KEYS);
 }
+/** A record of properties, keyed by name — a map's `properties`, or a `oneOf` block's. */
+function nestEachProperty(properties) {
+	return Object.fromEntries(Object.entries(properties).map(([key, child]) => [key, isNestable(child) ? nestAdminPropertyKeys(child) : child]));
+}
+/** Anything the walk can descend into: a plain object, not an array. */
+function isNestable(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 /**
 * {@link nestAdminKeysOf} for a property, applied to its children too.
 *
-* A map property carries `properties`, an array property carries `of`, and both
-* hold properties with `admin` blocks of their own. A flat `readOnly` left on a
-* child is as dead — and as fatal at the next boot — as one left on the parent,
-* so the walk goes all the way down.
+* A map property carries `properties`, an array property carries `of`, and an
+* array of typed blocks carries `oneOf.properties` — a record of properties like
+* a map's. All of them hold properties with `admin` blocks of their own. A flat
+* `readOnly` left on a child is as dead — and as fatal at the next boot — as one
+* left on the parent, so the walk goes all the way down.
+*
+* `oneOf` was the container this walk did not know about, and it is the one the
+* block-based collection templates are built out of: every block inside them
+* kept its flat `markdown`, and the collection they created would not boot.
 *
 * @group Models
 */
 function nestAdminPropertyKeys(property) {
 	const nested = nestAdminKeysOf(property, ADMIN_PROPERTY_KEYS);
 	const children = nested.properties;
-	if (children && typeof children === "object" && !Array.isArray(children)) nested.properties = Object.fromEntries(Object.entries(children).map(([key, child]) => [key, child && typeof child === "object" && !Array.isArray(child) ? nestAdminPropertyKeys(child) : child]));
+	if (isNestable(children)) nested.properties = nestEachProperty(children);
+	const oneOf = nested.oneOf;
+	if (isNestable(oneOf) && isNestable(oneOf.properties)) nested.oneOf = {
+		...oneOf,
+		properties: nestEachProperty(oneOf.properties)
+	};
 	const of = nested.of;
-	if (Array.isArray(of)) nested.of = of.map((entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? nestAdminPropertyKeys(entry) : entry);
-	else if (of && typeof of === "object") nested.of = nestAdminPropertyKeys(of);
+	if (Array.isArray(of)) nested.of = of.map((entry) => isNestable(entry) ? nestAdminPropertyKeys(entry) : entry);
+	else if (isNestable(of)) nested.of = nestAdminPropertyKeys(of);
 	return nested;
 }
 //#endregion