@rebasepro/types 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/types/relations.d.ts

@@ -22,6 +22,23 @@ export type OnAction = "cascade" | "restrict" | "no action" | "set null" | "set
  * @group Models
  */
 export declare const JUNCTION_PIVOT_KEY = "_pivot";
+/**
+ * The key a row carries the totals of its counted relations under.
+ *
+ * An include that asks for a count — `include: { tags: { limit: 4, count: true } }`
+ * — serves, beside the (capped) `tags`, how many related rows there are in all:
+ * `{ id: 1, tags: [ …4 rows ], _count: { tags: 37 } }`. One object per row,
+ * keyed by relation name, so counting a second relation adds a key rather than
+ * a second top-level name.
+ *
+ * Leading underscore, like {@link JUNCTION_PIVOT_KEY} and `_matches`: it
+ * describes the read, not the record, and no column or form writes it. A
+ * collection with a property of this name cannot ask for a count — the read
+ * answers 400 rather than writing over the column.
+ *
+ * @group Models
+ */
+export declare const INCLUDE_COUNT_KEY = "_count";
 /**
  * What kind of link a relation is.
  *
@@ -108,6 +125,23 @@ export interface BelongsToRelation extends RelationBase {
      * Defaults to `<relationName>_id`.
      */
     localKey?: string;
+    /**
+     * Whether Rebase creates a btree index on {@link localKey}. Defaults to
+     * `true`.
+     *
+     * Postgres indexes the key a foreign key *points at* but never the column
+     * holding it, so without one every read from the other side seq-scans this
+     * table: a `hasMany`/`hasOne` include, a nested listing such as
+     * `/authors/5/posts`, and the `ON DELETE` check when a target row is
+     * deleted. The derived index is skipped on its own when the column already
+     * leads one — the primary key, a `validation.unique`, or an entry in
+     * `indexes:` — so it never duplicates an index you declared.
+     *
+     * Set `false` for a table so write-heavy that the index costs more than
+     * the lookups it serves, or when you keep an index of your own on the
+     * column outside Rebase's `indexes:` block.
+     */
+    index?: boolean;
 }
 /**
  * The target holds the foreign key, and at most one target row points back.
@@ -234,7 +268,7 @@ export interface ManyToManyRelation extends RelationBase {
          *     through: {
          *         table: "org_members",
          *         properties: {
-         *             role: { type: "string", enum: ["owner", "admin", "member"],
+         *             role: { type: "string", enum: { owner: "Owner", admin: "Admin", member: "Member" },
          *                     defaultValue: "member", validation: { required: true } },
          *             joinedAt: { type: "date", autoValue: "on_create" }
          *         }
@@ -364,6 +398,8 @@ export interface ResolvedBelongsTo extends ResolvedRelationBase {
     shared: false;
     /** Column on this collection's table. */
     localKey: string;
+    /** As authored, with the default filled in — see {@link BelongsToRelation.index}. */
+    index: boolean;
 }
 /** @group Models */
 export interface ResolvedHasOne extends ResolvedRelationBase {

package/dist/types/resource_kinds.d.ts

@@ -167,11 +167,13 @@ export interface TopicOptions extends DeclareOptions {
  *
  * `attempt` counts from 1. Worth branching on: the first delivery and the
  * fourth are the same call, but the fourth is where it is worth logging loudly.
+ * `signal` is aborted when the attempt runs past the job queue's `timeoutMs`.
  */
 export type TopicHandler<T> = (event: T, context: {
     attempt: number;
     topic: string;
     subscription: string;
+    signal: AbortSignal;
 }) => Promise<void> | void;
 /** A declared subscription, as recorded in the graph and wired at boot. */
 export interface TopicSubscription<T = unknown> {
@@ -279,11 +281,15 @@ export interface QueueOptions extends DeclareOptions {
     /** Attempts before a job is left failed. Default 5. */
     maxAttempts?: number;
 }
-/** What a queue's handler receives. `attempt` counts from 1. */
+/**
+ * What a queue's handler receives. `attempt` counts from 1; `signal` is
+ * aborted when the attempt runs past the job queue's `timeoutMs`.
+ */
 export type QueueHandler<T> = (payload: T, context: {
     attempt: number;
     queue: string;
     jobId: string;
+    signal: AbortSignal;
 }) => Promise<void> | void;
 /** Per-job options at enqueue time. */
 export interface QueueEnqueueOptions {

package/dist/types/storage_authorize.d.ts

@@ -18,6 +18,11 @@ export interface StorageAuthorizeUser {
 export interface StorageAuthorizeContext {
     /** Object key, bucket prefix stripped and traversal already sanitized. */
     key: string;
+    /**
+     * The bucket, by one name per bucket. On S3 and GCS, whose source serves a
+     * single bucket, this is always `"default"` — also when the request named
+     * the provider's bucket (`acme-media`), which reaches the same objects.
+     */
     bucket: string;
     operation: StorageOperation;
     /** Null when the route allows unauthenticated access. */

package/dist/types/websockets.d.ts

@@ -69,6 +69,13 @@ export interface CollectionUpdateMeta {
     hasMore: boolean;
     /** The opaque cursor continuing this listing — see `PaginationMeta.nextCursor`. */
     nextCursor?: string;
+    /**
+     * When `total` was counted, ISO-8601 — present only when it was not
+     * counted for this frame. A server with `REALTIME_RECOUNT_INTERVAL_MS` set
+     * reuses a big list's total for that long rather than counting it on every
+     * write; `hasMore` is then judged against the reused total.
+     */
+    totalAsOf?: string;
     /**
      * The count could not be taken, so `total` is missing and `hasMore` is a
      * floor rather than an answer.
@@ -97,6 +104,14 @@ export interface SingleUpdateMessage extends WebSocketMessage {
     type: "single_update";
     subscriptionId: string;
     row: Record<string, unknown> | null;
+    /**
+     * The row's version: the `ETag` a `GET /:id` of it answers, to send back
+     * as `If-Match` on a `PATCH` or `DELETE`. Sent only to a `subscribe_one`
+     * that asked with `etag: true`, and never beside a `null` row. A server
+     * that predates it ignores the ask and sends no tag; a client that does
+     * not ask gets frames without one.
+     */
+    etag?: string;
 }
 /**
  * Lightweight patch message sent to collection subscribers when a single
@@ -151,6 +166,22 @@ export interface BroadcastMessage extends WebSocketMessage {
      */
     seq?: number;
 }
+/**
+ * Server → client: the sequence number the sender's own broadcast took on a
+ * retained channel, sent to the sender in place of the message itself (which
+ * is never echoed back).
+ *
+ * Sent only to a socket that opted into `channel_seq` when it opened (see the
+ * socket's `hello`). With it, every member of a retained channel hears of
+ * every number, one way or the other, so a client that sees a hole in the
+ * sequence knows it missed a message and can ask for it — which is what the
+ * SDK does.
+ */
+export interface BroadcastAckMessage extends WebSocketMessage {
+    type: "broadcast_ack";
+    channel: string;
+    seq: number;
+}
 /**
  * Server → client: the whole roster of a channel.
  *
@@ -276,4 +307,4 @@ export interface ChannelHistoryMessage extends WebSocketMessage {
  * {@link WebSocketMessage}, whose `type` is a bare `string`, and a `string`
  * discriminates nothing.
  */
-export type ChannelMessage = BroadcastMessage | PresenceStateMessage | PresenceDiffMessage | ChannelHistoryMessage | ChannelErrorMessage;
+export type ChannelMessage = BroadcastMessage | BroadcastAckMessage | PresenceStateMessage | PresenceDiffMessage | ChannelHistoryMessage | ChannelErrorMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/types",
-  "version": "0.24.0",
+  "version": "0.24.1-canary.gcb918fc",
   "description": "Rebase type definitions — shared interfaces and controller types",
   "keywords": [
     "rebase",