@rebasepro/types 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/types/auth_adapter.d.ts

@@ -303,6 +303,23 @@ export interface UserCreationPrepareResult {
     /** Whether an invitation was sent (only relevant when hookHandledEmail is true). */
     invitationSent: boolean;
 }
+/**
+ * What the door creating a user knows about its caller, for
+ * `AuthAdapter.prepareUserCreation()`.
+ *
+ * @group Auth
+ */
+export interface UserCreationOptions {
+    /**
+     * Whether the caller may waive the password policy with
+     * `skipPasswordPolicy: true` in the body. The doors set it for an
+     * administrator (the service key signs in as one) and for nobody else, so
+     * an adapter that reads the flag is taking an administrator at their word —
+     * an import of accounts whose passwords were set under another system's
+     * rules. Absent, the flag waives nothing.
+     */
+    mayWaivePasswordPolicy?: boolean;
+}
 /**
  * What a create body for an auth collection may name beyond the collection's
  * own declared fields — see `AuthAdapter.describeUserCreationContract()`.
@@ -322,6 +339,16 @@ export interface UserCreationWriteContract {
      * deletes it before the row is ever built.
      */
     extraFields: string[];
+    /**
+     * Each body's `prepareUserCreation` touches nothing but its own result —
+     * no hook, no email, no write — so a bulk create may prepare several at
+     * once. The built-in adapter's path with no `onCreateUser`, no
+     * `onAdminCreateUser` and the default `hashPassword` is: it hashes a
+     * password and normalizes an email, and a 1,000-row bulk spent half a
+     * minute hashing one password at a time. Leave it unset when a hook runs:
+     * preparations then run one at a time, in the order the rows were given.
+     */
+    independent?: boolean;
 }
 /**
  * Result of `AuthAdapter.finalizeUserCreation()`.
@@ -505,11 +532,15 @@ export interface AuthAdapter {
      *
      * If not implemented, the collection saves values as-is (no password hashing).
      *
+     * A chosen `password` is held to the password policy unless the body says
+     * `skipPasswordPolicy: true` and `options.mayWaivePasswordPolicy` is set.
+     *
      * @param values - Raw request body from the client.
      * @param collectionAuth - The parsed `AuthCollectionConfig` from the collection (if `auth` is an object).
+     * @param options - What the door knows about its caller.
      * @returns Processed values ready for `driver.save()`, plus metadata for the post-save step.
      */
-    prepareUserCreation?(values: Record<string, unknown>, collectionAuth?: unknown): Promise<UserCreationPrepareResult>;
+    prepareUserCreation?(values: Record<string, unknown>, collectionAuth?: unknown, options?: UserCreationOptions): Promise<UserCreationPrepareResult>;
     /**
      * Describe what a create body for this auth collection is allowed to name,
      * so unknown-field validation can run on it.

package/dist/types/backend.d.ts

@@ -6,6 +6,7 @@ import type { AuthAdapter } from "./auth_adapter.js";
 import type { HistoryConfig } from "../controllers/client.js";
 import type { ChannelBusSetting } from "./channel_bus.js";
 import type { SchemaEditingAdmin } from "./schema_editing.js";
+import type { AccessModel } from "./scopes.js";
 /**
  * Abstract database connection interface.
  * Represents a connection to any database system.
@@ -252,6 +253,52 @@ export interface RealtimeChannelsConfig {
      * Defaults to 1000. `REALTIME_MAX_SUBSCRIPTIONS_PER_SOCKET` wins over it.
      */
     maxSubscriptionsPerSocket?: number;
+    /**
+     * How many sockets one user (one identity: a signed-in user, an API key's
+     * user, an impersonated user) may hold open on one server instance. The
+     * next one's `AUTHENTICATE` is refused with `TOO_MANY_SOCKETS` and the
+     * socket closed with 4002; the SDK keeps retrying with backoff, so it gets
+     * in once another closes. A positive whole number, checked at boot.
+     * Unset (the default) is no ceiling. `REALTIME_MAX_SOCKETS_PER_USER` wins
+     * over it.
+     */
+    maxSocketsPerUser?: number;
+    /**
+     * The longest a change waits for the refetch that delivers it, in ms. A
+     * refetch waits for 300 ms without a change, and at most this long under a
+     * steady stream of writes. Defaults to 1000. A positive whole number,
+     * checked at boot. `REALTIME_REFETCH_MAX_WAIT_MS` wins over it.
+     */
+    refetchMaxWaitMs?: number;
+    /**
+     * How long a big list subscription's total may be reused before it is
+     * counted again, in ms. Unset (the default), every frame counts. Frames
+     * that reuse it carry `meta.totalAsOf`. `REALTIME_RECOUNT_INTERVAL_MS`
+     * wins over it.
+     */
+    recountIntervalMs?: number;
+    /**
+     * The smallest last total at which {@link recountIntervalMs} applies;
+     * smaller lists are counted on every frame. Defaults to 100 000.
+     * `REALTIME_RECOUNT_MIN_ROWS` wins over it.
+     */
+    recountMinRows?: number;
+    /**
+     * How changes are captured for realtime. `auto` (the default) installs
+     * database-level capture where the connection can and falls back to
+     * announcing the API's own writes where it cannot; `trigger` asks for
+     * capture and warns when it is refused; `wal` is `trigger` until WAL
+     * streaming ships; `off` announces the API's own writes only.
+     * `REALTIME_CDC` wins over it.
+     */
+    cdc?: "auto" | "wal" | "trigger" | "off";
+    /**
+     * The URL path the realtime socket accepts upgrades on. Defaults to the
+     * one the server derives from where it is mounted — `/` for a server at
+     * `/api`, which is where the SDK dials. Set it when clients dial elsewhere
+     * (a `websocketUrl` with a path). See {@link RealtimeSocketOptions.path}.
+     */
+    path?: string;
 }
 /**
  * Abstract realtime provider interface.
@@ -445,8 +492,19 @@ export interface SqlScriptResult {
     tables: SqlScriptTable[];
     /** The last statement's command: `SELECT`, `UPDATE`, `CREATE TABLE` … */
     command?: string;
-    /** How many rows the last statement returned or changed, when its command reports a count. */
+    /**
+     * How many rows the last statement returned or changed, when its command
+     * reports a count — or, for a {@link truncated} result, how many it
+     * returned, of which {@link rows} holds the first.
+     */
     rowCount?: number;
+    /**
+     * The last statement returned more than a run keeps, and {@link rows}
+     * holds only its first rows. The Studio console's door keeps at most
+     * 10,000 rows, or 32 Mi characters of values, of one result: a run that
+     * held every row of a million-row table took the server down with it.
+     */
+    truncated?: boolean;
     /** What the database said while the script ran, in order. */
     notices: SqlScriptNotice[];
     /**
@@ -457,6 +515,22 @@ export interface SqlScriptResult {
      */
     effectiveRole?: string;
 }
+/**
+ * A query's result being read a batch at a time — see `SQLAdmin.openSqlCursor`.
+ *
+ * @group Admin
+ */
+export interface SqlCursor {
+    /** The result's column names, in order. */
+    readonly columns: string[];
+    /**
+     * The next rows, each value the text the database wrote for it and `null`
+     * for NULL — `null` once there are none left.
+     */
+    read(): Promise<(string | null)[][] | null>;
+    /** End the read and give the session back. Safe to call more than once. */
+    close(): Promise<void>;
+}
 /**
  * Administrative operations for SQL-based databases (PostgreSQL, MySQL, etc.).
  * Used by the SQL Editor, RLS Editor, and schema browser.
@@ -472,12 +546,19 @@ export interface SQLAdmin {
      * before it is reused. For SQL a person wrote (the Studio editor), which
      * may `SET ROLE` and must not leave that on a pooled connection the
      * server's own queries use next.
+     *
+     * `maxResultBytes` refuses a result whose rows take more than that many
+     * bytes, with an error whose `code` is `RESULT_TOO_LARGE`, rather than
+     * return it — never a part of it. On a session of its own the read stops
+     * there; elsewhere the rows are measured once read. The WebSocket
+     * `EXECUTE_SQL` door sets it for every caller.
      */
     executeSql(sql: string, options?: {
         database?: string;
         role?: string;
         params?: unknown[];
         isolateSession?: boolean;
+        maxResultBytes?: number;
     }): Promise<Record<string, unknown>[]>;
     /**
      * Run a script a person wrote — the Studio SQL console — and describe what
@@ -490,11 +571,35 @@ export interface SQLAdmin {
      * no other. A script that leaves a transaction open is refused, and the
      * transaction rolled back: nothing outlives the run to be committed or
      * rolled back by a later one.
+     *
+     * Aborting `signal` cancels the run: the statement in progress is stopped
+     * (`pg_cancel_backend` on a Postgres server; the in-process development
+     * database cannot be interrupted, and the run ends on its own), and the
+     * promise rejects.
      */
     runSqlScript?(sql: string, options?: {
         database?: string;
         role?: string;
+        signal?: AbortSignal;
     }): Promise<SqlScriptResult>;
+    /**
+     * Read the whole result of ONE query a person wrote, a batch at a time —
+     * the Studio SQL console's "Download full result as CSV", which the
+     * console's 10,000-row cap would otherwise leave no way to get.
+     *
+     * Through a server-side cursor, in a read-only transaction, on a session
+     * of its own, as `role`: a write is refused by the database, and a second
+     * statement by the protocol. Each batch is read when the previous one has
+     * been consumed, so memory holds one batch whatever the result's size;
+     * every read runs under the session's `statement_timeout`. The session is
+     * reset and returned when the cursor is closed — which the caller must do,
+     * on success, failure or a reader that went away.
+     */
+    openSqlCursor?(sql: string, options?: {
+        database?: string;
+        role?: string;
+        batchSize?: number;
+    }): Promise<SqlCursor>;
     /**
      * Fetch the available databases on the server.
      */
@@ -520,6 +625,21 @@ export interface SQLAdmin {
      * Fetch the current database name.
      */
     fetchCurrentDatabase?(): Promise<string | undefined>;
+    /**
+     * Hold a `LISTEN` on `channel`, on a connection of its own that stays open
+     * and comes back after a drop, and call `onNotify` with each payload — what
+     * wakes the job worker when another process enqueues, instead of a poll
+     * every two seconds.
+     *
+     * Resolves once listening, with the stop. Rejects when no such connection
+     * can be had — an in-process database, a first connect that fails — so the
+     * caller can fall back to polling. `onReconnect` is called each time a
+     * dropped connection is listening again: whatever was sent meanwhile is
+     * lost. `channel` must be a plain identifier.
+     */
+    listen?(channel: string, onNotify: (payload: string) => void, options?: {
+        onReconnect?: () => void;
+    }): Promise<() => Promise<void>>;
 }
 /**
  * Administrative operations for document-based databases (MongoDB, Firestore, etc.).
@@ -778,6 +898,24 @@ export interface RealtimeSocketOptions {
     } | {
         message: string;
     }>;
+    /**
+     * Verify a session token presented to `AUTHENTICATE` with the backend's own
+     * keys, when the socket has no auth adapter to ask: who it names, or null
+     * when it does not verify. The server passes its backend's; absent, the
+     * driver falls back to the process default.
+     */
+    verifyAccessToken?: (token: string) => Promise<{
+        uid: string;
+        roles?: string[];
+        isAnonymous?: boolean;
+        claims?: Record<string, unknown>;
+    } | null>;
+    /**
+     * The backend's access model — what a session's roles hold on the socket's
+     * admin frames. The server passes its backend's; absent, the driver falls
+     * back to the process default.
+     */
+    accessModel?: AccessModel;
     /**
      * The largest frame accepted, in bytes — the data API's body limit. `0` or
      * less for none. Defaults to the server's default body limit.
@@ -799,6 +937,29 @@ export interface RealtimeSocketOptions {
      * identity that has since signed out, been revoked, demoted or deleted.
      */
     identityRecheckIntervalMs?: number;
+    /**
+     * How often a socket that asked for heartbeats (`?rebase_caps=heartbeat`)
+     * is sent one, in ms (default 30 000). The SDK redials after two missed.
+     */
+    heartbeatIntervalMs?: number;
+    /**
+     * How many sockets one identity may hold open on this server; the next
+     * one's `AUTHENTICATE` is refused with `TOO_MANY_SOCKETS` and the socket
+     * closed (4002). Unset for no ceiling. See `realtime.maxSocketsPerUser`.
+     */
+    maxSocketsPerUser?: number;
+    /**
+     * The URL path the socket accepts upgrades on (default `/`). The SDK dials
+     * its `baseUrl` with no extra segment, so for a server mounted at `/api`
+     * this is `/`, and for one at `/app/api` it is `/app`. A trailing `/` is
+     * ignored, and so is the query string.
+     *
+     * An upgrade to any other path is not this socket's: it is left untouched
+     * for another `upgrade` listener on the same `http.Server` — a host app's
+     * own WebSocket server — or, when the socket's listener is the only one,
+     * answered `404` and closed, so the client is not left hanging.
+     */
+    path?: string;
 }
 /**
  * A `BackendBootstrapper` encapsulates all driver-specific initialization logic.
@@ -876,8 +1037,11 @@ export interface BackendBootstrapper {
      */
     initializeRealtime?(config: unknown, driverResult: InitializedDriver): Promise<RealtimeProvider | undefined>;
     /**
-     * Mount any driver-specific HTTP routes (e.g., custom admin endpoints).
-     * Called after all drivers are initialized.
+     * Never called: the server mounts no route on a bootstrapper's behalf. A
+     * driver that needs HTTP routes exports a route factory, and the app
+     * mounts it where it chooses.
+     *
+     * @deprecated Never called. Will be removed in a future release.
      */
     mountRoutes?(app: unknown, basePath: string, driverResult: InitializedDriver): void;
     /**
@@ -1029,7 +1193,7 @@ export interface InitializedDriver {
     connection?: DatabaseConnection;
     /**
      * Opaque handle that the bootstrapper can use in subsequent hooks
-     * (e.g., `initializeAuth`, `mountRoutes`) to access driver internals.
+     * (e.g., `initializeAuth`, `getAdmin`) to access driver internals.
      * Not used by the coordinator.
      */
     internals?: unknown;

package/dist/types/backup.d.ts

@@ -87,6 +87,25 @@ export interface BackupScheduleStatus {
      */
     historyError?: string;
 }
+/**
+ * A short-lived link to one backup's bytes, from `POST /admin/backups/download-url`.
+ *
+ * The URL needs no `Authorization` header — the token in it stands in for one,
+ * for this backup only — so a browser can be sent to it and stream the dump to
+ * disk instead of holding it in the page.
+ */
+export interface BackupDownloadLink {
+    /**
+     * `…/admin/backups/download?key=…&token=…`. The server answers it as a
+     * path on itself; the SDK's `downloadUrl()` answers it absolute, on the
+     * client's own base URL.
+     */
+    url: string;
+    /** The token in {@link url}, on its own. */
+    token: string;
+    /** Seconds until the link stops working (60). */
+    expiresIn: number;
+}
 /** What the backup listing (`GET /admin/backups`) answers. */
 export interface BackupListing {
     /** Backups at the destination, newest first. */

package/dist/types/cron.d.ts

@@ -1,4 +1,5 @@
 import type { RebaseServerClient } from "../controllers/client.js";
+import type { RegisteredDatabase } from "./register.js";
 /**
  * Cron Job type definitions for Rebase.
  *
@@ -10,7 +11,7 @@ import type { RebaseServerClient } from "../controllers/client.js";
  * A cron job definition file exports this shape as its default export.
  * See the example cron files in `app/backend/crons/` for usage.
  */
-export interface CronJobDefinition {
+export interface CronJobDefinition<DB = RegisteredDatabase> {
     schedule: string;
     /**
      * IANA time zone the schedule is read in, e.g. `"Europe/Madrid"`.
@@ -84,20 +85,21 @@ export interface CronJobDefinition {
      * Receives a context object with the data driver and logger.
      * May return arbitrary JSON-serialisable data stored in the log.
      */
-    handler: (ctx: CronJobContext) => Promise<unknown> | unknown;
+    handler: (ctx: CronJobContext<DB>) => Promise<unknown> | unknown;
 }
 /**
  * Context passed to each cron handler invocation.
  */
-export interface CronJobContext {
+export interface CronJobContext<DB = RegisteredDatabase> {
     /** The job's unique ID (derived from filename). */
     jobId: string;
     /** The current scheduled tick timestamp. */
     scheduledAt: Date;
     /**
-     * A simple logger scoped to this job run. Each line is kept with the
-     * run's log entry and also written to the server log at `info`, with a
-     * `cron` field holding the job ID.
+     * A simple logger scoped to this job run. Each line is written to the
+     * server log at `info`, with a `cron` field holding the job ID, and kept
+     * with the run's log entry — the first 500 lines or 64 KB of them,
+     * whichever comes first, then one line saying how many more there were.
      */
     log: (...args: unknown[]) => void;
     /**
@@ -156,7 +158,7 @@ export interface CronJobContext {
      *     }
      * });
      */
-    rebase: RebaseServerClient;
+    rebase: RebaseServerClient<DB>;
 }
 export type CronJobRunState = "idle" | "running" | "success" | "error" | "disabled";
 /**
@@ -244,3 +246,16 @@ export interface CronJobLogEntry {
     /** Whether this was a manual trigger. */
     manual?: boolean;
 }
+/**
+ * The answer to a manual trigger made with `?async=1`
+ * (`client.cron.triggerJob(id, { async: true })`): the run has started and
+ * carries on after the answer. Its outcome is in the run history, as the entry
+ * with `manual: true` and this `startedAt`.
+ */
+export interface CronJobStarted {
+    accepted: true;
+    /** ISO timestamp the run started at — the `startedAt` of its log entry. */
+    startedAt: string;
+    /** The job's status as the run began. */
+    job: CronJobStatus;
+}

package/dist/types/database_adapter.d.ts

@@ -171,9 +171,11 @@ export interface DatabaseAdapter {
      */
     getAdmin?(driverResult: InitializedDriver): DatabaseAdmin | undefined;
     /**
-     * Mount any database-specific HTTP routes (e.g., custom admin endpoints).
+     * Never called: the server mounts no route on an adapter's behalf. A
+     * driver that needs HTTP routes exports a route factory, and the app
+     * mounts it where it chooses.
      *
-     * Called after all adapters are initialized.
+     * @deprecated Never called. Will be removed in a future release.
      */
     mountRoutes?(app: unknown, basePath: string, driverResult: InitializedDriver): void;
     /**
@@ -196,8 +198,29 @@ export interface DatabaseAdapterInitConfig {
      * name none when this is the default.
      */
     dataSourceKey?: string;
-    /** The shared collection registry to register into. */
-    collectionRegistry: CollectionRegistryInterface;
+    /**
+     * The backend's shared collection registry. No bundled driver reads it —
+     * each builds and returns its own on `InitializedDriver.collectionRegistry`
+     * — so a caller opening a driver on its own (a script, a test) leaves it out.
+     */
+    collectionRegistry?: CollectionRegistryInterface;
+    /**
+     * Whether opening the driver may change the database (default `true`).
+     *
+     * The server's boot owns its schema, so the driver provisions what it needs
+     * while it opens: the restricted role requests run as under RLS, the
+     * branch-metadata table, channel-history tables, change-capture triggers.
+     *
+     * `false` opens it with no DDL of any kind — what a script, a REPL or a
+     * test that only reads and writes rows wants, and what a process that does
+     * not own the schema must ask for. A connection that would bypass
+     * row-level security still sends a user's requests through the restricted
+     * role; when an earlier boot never created that role, those requests fail
+     * rather than run unfiltered. Change capture is not installed
+     * (`realtime.provision` reads as `false`); whether change events are
+     * consumed is still `realtime.subscribe`.
+     */
+    provision?: boolean;
     /**
      * Whether this driver should describe its own schema.
      *
@@ -251,9 +274,12 @@ export interface DatabaseAdapterInitConfig {
      * runtime otherwise refuses to boot without.
      *
      * Absent means both — every caller that predates this field is a
-     * single-process deployment, where both are true.
+     * single-process deployment, where both are true. `false` is a process
+     * that takes no part in realtime at all: nothing installed, nothing
+     * consumed, and its writes not announced to the processes that serve
+     * realtime (a script, a REPL).
      */
-    realtime?: {
+    realtime?: false | {
         /**
          * Consume change events: open the `LISTEN` connection, start CDC or the
          * app-level fallback. False for a process that serves no websockets.

package/dist/types/entities.d.ts

@@ -32,6 +32,17 @@ export interface Entity<M extends Record<string, unknown> = Record<string, unkno
      * and a record fetched by id never has one.
      */
     searchMatches?: SearchMatch[];
+    /**
+     * The version of the row this entity was read at: the `ETag` the read
+     * reported, for a `findById`, a `PATCH` answer or a live row frame. A
+     * form saves with it as `If-Match`, so a write made against a version
+     * someone has since replaced is refused instead of reverting their change.
+     *
+     * Absent for a row from a list, from a cache, or from a server or data
+     * source that does not report versions — a save then is unconditional,
+     * as it always was.
+     */
+    etag?: string;
     /**
      * Which driver this entity belongs to (e.g., 'postgres', 'firestore').
      * If not specified, the default driver is assumed.

package/dist/types/history.d.ts

@@ -27,8 +27,20 @@ export interface EntityHistoryEntry {
     action: "create" | "update" | "delete";
     /** Which fields changed. `null` for creates and deletes. */
     changed_fields: string[] | null;
+    /** The row after the change; for a delete, the row that was deleted. */
     values: Record<string, unknown> | null;
+    /**
+     * On an update, what the changed fields held before it. `null` for creates
+     * and deletes. Which fields it holds depends on {@link format}.
+     */
     previous_values: Record<string, unknown> | null;
+    /**
+     * How the entry was stored. Absent or `1`: `previous_values` is the whole
+     * row before the change. `2`: it holds the `changed_fields` only — a field
+     * that is absent from it was absent before — and every other field is
+     * unchanged, so it is in `values`.
+     */
+    format?: 1 | 2;
     updated_by: string | null;
     /** ISO-8601. A driver storing a native date converts on read. */
     updated_at: string;
@@ -46,7 +58,9 @@ export interface RecordHistoryParams {
     updatedBy?: string | null;
 }
 /**
- * How much history to keep. Pruning runs per row after each write.
+ * How much history to keep. Both rules are applied to a row after each write
+ * to it; `ttlDays` is also applied to every row by an hourly sweep, so the
+ * history of a row nobody writes again (a deleted one) still ages out.
  * @group Backend
  */
 export interface HistoryRetentionConfig {

package/dist/types/index.d.ts

@@ -35,3 +35,4 @@ export * from "./project_manifest.js";
 export * from "./collection_contract.js";
 export * from "./schema_version.js";
 export * from "./storage_authorize.js";
+export * from "./register.js";

package/dist/types/project_manifest.d.ts

@@ -83,6 +83,14 @@ export interface RebaseBackendAppConfig {
      * its default export. Default `collections/users`.
      */
     usersCollection?: string;
+    /**
+     * Type server-side data from the generated `Database`. When `true`, every
+     * `rebase generate-sdk` — `rebase dev`'s included, and the first one on a
+     * fresh clone — writes the types and the `Register` declaration to
+     * `<config>/generated/`. `rebase generate-sdk --register` sets it.
+     * Default `false`.
+     */
+    registerDatabase?: boolean;
     /**
      * `runtime: "custom"` only. Dockerfile path relative to the repository root.
      * Default `Dockerfile`.

package/dist/types/properties.d.ts

@@ -5,6 +5,12 @@ import type { ColorKey, ColorScheme } from "./chips.js";
 import type { AuthState } from "../controllers/auth_state.js";
 import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks.js";
 import type { User } from "../users/index.js";
+/**
+ * A SQL expression, written in template form: ``"sql`gen_random_uuid()`"``.
+ * The `sql` and backticks are markup; the text between them is the SQL.
+ * @group Entity properties
+ */
+export type SqlExpression = `sql\`${string}\``;
 /**
  * Callbacks/Hooks for individual property fields
  * @group Entity properties
@@ -372,6 +378,25 @@ export interface BaseProperty<CustomProps = unknown> {
      * ```
      */
     access?: FieldAccess;
+    /**
+     * The database fills this column when a create leaves it empty: a
+     * `NOT NULL DEFAULT <expression>` column such as `gen_random_uuid()`,
+     * `nextval(…)` or `now()`, whose value no property can state.
+     *
+     * A `validation.required` field with it may be left out of a create, by
+     * the admin form and by the API alike, and a create that sends it as `null`
+     * leaves it to the database rather than storing `NULL`. It is still
+     * required when a stored record is edited. The generated SDK's `Insert`
+     * type makes the field optional. Defaults to `false`.
+     *
+     * Give the expression, in the template form `isId` takes
+     * (``databaseDefault: "sql`gen_random_uuid()`"``), and the schema planner
+     * writes it as the column's `DEFAULT`, so `rebase db push` keeps it. `true`
+     * declares a DEFAULT someone else wrote and the planner does not write
+     * one, so a push plans dropping it. "Import from table" and
+     * `rebase schema introspect` set the expression they read.
+     */
+    databaseDefault?: boolean | SqlExpression;
     /**
      * Use this to define dynamic properties that change based on certain conditions
      * or on the entity's values. For example, you can make a field read-only if
@@ -421,8 +446,9 @@ export interface StringProperty extends BaseProperty {
      */
     defaultValue?: string;
     /**
-     * Optional database column type. If not set, it defaults to `varchar` or `uuid` depending on `isId` configuration.
-     * Use `text` for strings with unbound length, `char` for fixed-length strings, or `varchar` for variable-length strings with a limit.
+     * Optional database column type. If not set, it is `text` — or `uuid` for an `isId: "uuid"` key.
+     * `validation.max` does not bound a `text` column; declare `varchar` (or `char`) to get a
+     * width, which is then taken from `validation.max` (255 when it states none).
      */
     columnType?: "varchar" | "text" | "char" | "uuid";
     /**

package/dist/types/register.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The project-wide registry of generated types, filled by module augmentation.
+ *
+ * Empty by default, and every server-side data surface is untyped while it is:
+ * `context.data`, `rebase.dataAsAdmin`, a cron's `ctx.rebase` and a function's
+ * `ctx.rebase` accept any collection by any name and hand back open records.
+ *
+ * A project that generated its types with `rebase generate-sdk` registers its
+ * `Database` once, in any file the TypeScript program includes:
+ *
+ * ```ts
+ * // src/rebase-env.d.ts — or the top of any module file
+ * import type { Database } from "./generated/database.types";
+ *
+ * declare module "@rebasepro/types" {
+ *     interface Register {
+ *         database: Database;
+ *     }
+ * }
+ * ```
+ *
+ * From then on every one of those surfaces is typed from it: rows, filters,
+ * sorts, `include`, and the inputs `create` and `update` accept. Nothing about
+ * the runtime changes; the registration is a declaration.
+ *
+ * A single function or cron can still name its own type instead —
+ * `defineFunction<Database>(…)`, `defineCron<Database>({…})` — which wins over
+ * the registration.
+ *
+ * @group Data
+ */
+export interface Register {
+}
+/**
+ * The `Database` a project registered on {@link Register}, or `unknown` when it
+ * registered none — which is what keeps an unregistered project's server-side
+ * data untyped, exactly as it was before the registry existed.
+ *
+ * @group Data
+ */
+export type RegisteredDatabase = Register extends {
+    database: infer DB;
+} ? DB : unknown;