@rebasepro/types 0.11.1-canary.gfd39654 → 0.12.0

package/dist/types/project_manifest.d.ts

@@ -24,29 +24,48 @@
  * work: two repositories never need to know about each other, only about the
  * project.
  */
+import type { StorageSourceDefinition } from "./storage_source";
 /**
  * Which kind of thing an app is.
  *
  * - `backend` — the collections/hooks/functions that define the project's API.
  *   Exactly one per *project* (not per repository); the registry enforces it.
- * - `static`  — a pre-built client bundle (SPA, static site) served over CDN.
- * - `admin`   — the Rebase admin panel, either hosted by the platform or built
- *   into this repository.
- * - `mobile`  — a native app. Registration only: it gets client credentials and
- *   configuration, and is never built or hosted here.
- * - `custom`  — an arbitrary container image built from a Dockerfile. The eject
- *   hatch: full control, no managed-runtime guarantees.
+ * - `static`  — a pre-built client bundle (SPA, static site), served from the
+ *   backend process at its declared `path` or from a CDN. The admin panel is
+ *   one of these: it is an app in the user's repository like any other.
+ *
+ * That is the whole list. Ownership of the server process is a property of the
+ * backend app ({@link RebaseBackendAppConfig.runtime}), not an app type.
  */
-export type RebaseAppType = "backend" | "static" | "admin" | "mobile" | "custom";
+export type RebaseAppType = "backend" | "static";
 /**
  * The backend app: the project's API surface.
  *
  * Paths are relative to the directory holding `rebase.json`. The defaults match
  * the layout `rebase init` scaffolds, so a stock project may declare simply
- * `{ "type": "backend" }`.
+ * `{ "type": "backend", "runtime": "managed" }`.
  */
 export interface RebaseBackendAppConfig {
     type: "backend";
+    /**
+     * Who owns the process this backend runs in.
+     *
+     * - `managed` — the platform's runtime image boots this project's bundle.
+     *   You supply collections, functions, crons and schema; Rebase supplies the
+     *   server.
+     * - `custom` — this repository builds its own image and entrypoint. The
+     *   escape hatch: full control, no managed-runtime guarantees.
+     *
+     * Independent of *where* it runs. Both run on Rebase Cloud and both
+     * self-host — the destination lives in `.rebase/cloud.json`, not here. See
+     * `docker/docker-compose.selfhost.yml`, which boots a managed bundle on a
+     * developer's own Docker host.
+     *
+     * This is authored rather than inferred on purpose. It is the single most
+     * consequential fact about a deployment, and inferring it is what used to
+     * land projects on the custom runtime without anyone choosing it.
+     */
+    runtime: "managed" | "custom";
     /** Directory of the config package (collections + index). Default `config`. */
     config?: string;
     /** Directory of server functions. Default `backend/functions`. */
@@ -58,22 +77,23 @@ export interface RebaseBackendAppConfig {
      * Default `backend/src/schema.generated.ts`.
      */
     schema?: string;
-    /**
-     * Which collections source the runtime uses.
-     *
-     * - `cms` (default) — collections come from the config package.
-     * - `baas` — collections are introspected from the live database at boot and
-     *   the config package is not required.
-     */
-    mode?: "cms" | "baas";
     /**
      * Module path (relative to `config`) exporting the auth users collection as
      * its default export. Default `collections/users`.
      */
     usersCollection?: string;
+    /**
+     * `runtime: "custom"` only. Dockerfile path relative to the repository root.
+     * Default `Dockerfile`.
+     */
+    dockerfile?: string;
+    /** `runtime: "custom"` only. Build context relative to the root. Default `.`. */
+    context?: string;
+    /** `runtime: "custom"` only. Port the container listens on. Default 8080. */
+    port?: number;
 }
 /**
- * A static client bundle — SPA or static site — built here and served from CDN.
+ * A static client bundle — SPA or static site — built here and served at `path`.
  */
 export interface RebaseStaticAppConfig {
     type: "static";
@@ -84,54 +104,47 @@ export interface RebaseStaticAppConfig {
     /** Directory of built assets, relative to the repository root. */
     output: string;
     /**
-     * Serve `index.html` for unmatched paths (client-side routing).
+     * Public base path this app is served under. Default `/`.
+     *
+     * Several static apps run in one process, each at its own path — the API at
+     * `/api`, a site at `/`, the admin at `/admin` — which is what keeps a
+     * self-hosted deployment a single container.
+     *
+     * **This is a build-time input, not only a serving concern.** An app mounted
+     * at `/admin` must be *built* for `/admin` (Vite's `base`), or `index.html`
+     * loads and every asset 404s: a blank page with no server error. `rebase
+     * build` passes it as `REBASE_APP_BASE` and asserts the emitted HTML honours
+     * it. Changing this value requires rebuilding the app.
+     */
+    path?: string;
+    /**
+     * Serve `index.html` for unmatched paths under `path` (client-side routing).
      * Default `true` — the overwhelmingly common case for a client app, and a
      * static *site* generator emits real files for its routes anyway.
      */
     spa?: boolean;
 }
+export type RebaseAppConfig = RebaseBackendAppConfig | RebaseStaticAppConfig;
 /**
- * The admin panel.
- *
- * `hosted` is the default and means the platform serves it — nothing is built
- * into this repository and nothing ships in the bundle. `bundled` builds it here,
- * which is what a self-hosted or air-gapped deployment wants.
- */
-export interface RebaseAdminAppConfig {
-    type: "admin";
-    mode?: "hosted" | "bundled";
-    /** Only for `bundled`: package directory containing the admin sources. */
-    root?: string;
-    /** Only for `bundled`: build command. */
-    build?: string;
-    /** Only for `bundled`: directory of built assets. */
-    output?: string;
-}
-/**
- * A native app. Registered for credentials and configuration; never built here.
- */
-export interface RebaseMobileAppConfig {
-    type: "mobile";
-    platform: "ios" | "android" | "other";
-}
-/**
- * An app built from a Dockerfile into an arbitrary image.
+ * One declared storage source, as authored in `rebase.json`.
  *
- * This is the deliberate escape hatch. A project containing one is not eligible
- * for the managed runtime — the platform cannot make guarantees about an image
- * it did not build — but it still deploys, and nothing else about the project
- * changes.
+ * The key comes from the enclosing record, so this is
+ * {@link StorageSourceDefinition} minus its `key` — the same document the
+ * runtime registry and the frontend router consume, expressed the way a JSON
+ * object naturally expresses "a set of named things".
  */
-export interface RebaseCustomAppConfig {
-    type: "custom";
-    /** Dockerfile path relative to the repository root. */
-    dockerfile?: string;
-    /** Build context relative to the repository root. Default `.`. */
-    context?: string;
-    /** Port the container listens on. Default 8080. */
-    port?: number;
+export interface RebaseStorageSourceConfig {
+    /** Engine backing this source: `local`, `s3`, `gcs`, or a custom id. */
+    engine: string;
+    /**
+     * How the frontend reaches it. Default `server` (proxied through
+     * `/api/storage`). `direct` means a provider SDK talks to the bucket and the
+     * backend is not in the upload path.
+     */
+    transport?: "server" | "direct";
+    /** Human-readable label for the console and the admin UI. */
+    label?: string;
 }
-export type RebaseAppConfig = RebaseBackendAppConfig | RebaseStaticAppConfig | RebaseAdminAppConfig | RebaseMobileAppConfig | RebaseCustomAppConfig;
 /**
  * `rebase.json` — the authored project manifest.
  */
@@ -139,13 +152,17 @@ export interface RebaseProjectManifest {
     /** JSON Schema URL, for editor completion. Ignored by the tooling. */
     $schema?: string;
     /**
-     * The runtime **major** this project targets, as a semver range
+     * The runtime contract **major** this project targets, as a semver range
      * (e.g. `^1`, `~1.4`, or an exact `1.4.2` to pin).
      *
      * The platform upgrades patches and minors underneath a project without
      * asking; it never crosses a major. See {@link RUNTIME_CONTRACT_VERSION}.
+     *
+     * Named `rebase` rather than `runtime` so that `runtime` means exactly one
+     * thing — {@link RebaseBackendAppConfig.runtime}, who owns the process. It
+     * reads like `engines` in a `package.json`, which is what it is.
      */
-    runtime: string;
+    rebase: string;
     /**
      * Apps this repository contributes, keyed by app name. The key is the app's
      * identity within the project: it is what `rebase deploy <app>` names, what
@@ -153,6 +170,28 @@ export interface RebaseProjectManifest {
      * not collide with.
      */
     apps: Record<string, RebaseAppConfig>;
+    /**
+     * Storage sources this project uses, keyed by source key.
+     *
+     * **Topology only — never credentials.** Which buckets exist is a property of
+     * the project and belongs in the repository; how to reach each one is a
+     * property of the deployment and lives in the environment, read per source
+     * from `<BASE>__<KEY>` (`S3_BUCKET__MEDIA` for a source keyed `media`). The
+     * default source takes no suffix, so a single-bucket project configured with
+     * plain `S3_BUCKET` keeps working having declared nothing at all.
+     *
+     * Declared here rather than only in the config package because this file is
+     * the one artifact a host can read *before* running a build. That is what
+     * lets a console show "this project wants a `media` bucket, and it has none"
+     * on a project's first deploy, and it is why the managed and custom runtimes
+     * can present the same list — a custom build emits no bundle manifest, so a
+     * declaration that lived only in compiled config would leave every custom
+     * project invisible.
+     *
+     * Omitted entirely means one default source, which is the overwhelmingly
+     * common project and must not be required to say so.
+     */
+    storage?: Record<string, RebaseStorageSourceConfig>;
 }
 /**
  * The per-checkout project link.
@@ -192,8 +231,16 @@ export interface ManagedCompatibility {
  * not read. A runtime accepts any bundle whose `bundleFormat` is less than or
  * equal to its own — old bundles keep booting on new runtimes, which is the
  * whole point of separating the artifact from the engine.
+ *
+ * - **1** — `mode: "cms" | "baas" | "static"`, `entry.static` a single directory
+ *   string, `entry.admin` for a bundled admin panel.
+ * - **2** — `kind: "backend" | "static"`, `entry.static` a list of
+ *   {@link RebaseBundleStatic}, `entry.admin` removed. A format-1 runtime reading
+ *   one of these would find no `mode` and an array where it expects a string, so
+ *   the bump is what turns that into a refusal to boot instead of a bundle that
+ *   starts and serves nothing.
  */
-export declare const BUNDLE_FORMAT_VERSION = 1;
+export declare const BUNDLE_FORMAT_VERSION = 2;
 /**
  * The runtime contract major.
  *
@@ -217,10 +264,24 @@ export interface RebaseBundleEntrypoints {
     schema?: string;
     /** Module exporting the auth users collection (default export). */
     usersCollection?: string;
-    /** Built admin assets, when the admin panel is bundled rather than hosted. */
-    admin?: string;
-    /** Built static assets to serve from the runtime, when not on a CDN. */
-    static?: string;
+    /**
+     * Built static apps to serve from this process, in declaration order.
+     *
+     * A list rather than a single directory because one process serves several
+     * apps at different paths — a site at `/` and the admin at `/admin`. The
+     * runtime mounts them longest-path-first so the `/`-rooted app's catch-all
+     * does not claim its siblings' URLs.
+     */
+    static?: RebaseBundleStatic[];
+}
+/** One built static app inside a bundle. */
+export interface RebaseBundleStatic {
+    /** Public base path, e.g. `/` or `/admin`. */
+    path: string;
+    /** Bundle-relative directory holding the built assets. */
+    dir: string;
+    /** Serve `index.html` for unmatched paths under `path`. */
+    spa: boolean;
 }
 /**
  * A native module found in the dependency closure.
@@ -263,15 +324,17 @@ export interface RebaseBundleManifest {
     /**
      * What the runtime does with this bundle.
      *
-     * - `cms` — a backend with declared collections; the runtime provisions their
-     *   tables and serves the data API.
-     * - `baas` — a backend that introspects an existing database rather than
-     *   declaring collections.
-     * - `static` — no backend at all: the bundle is a built SPA (`entry.static`),
-     *   and the runtime only serves those assets. No database, no data sources —
-     *   this is how a `static`/`admin` app runs on the same image as the backend.
+     * - `backend` — boot the full server: database, auth and the data API, plus
+     *   any static apps in `entry.static`.
+     * - `static` — no backend at all: serve `entry.static` and nothing else. No
+     *   database, no auth, no data sources. This is how a static app runs on the
+     *   same image as the backend.
+     *
+     * Replaces an earlier `mode: "cms" | "baas" | "static"`. The cms/baas
+     * distinction was never a third kind of thing — it is simply whether
+     * `entry.config` is present, so it is derived rather than declared.
      */
-    mode: "cms" | "baas" | "static";
+    kind: "backend" | "static";
     entry: RebaseBundleEntrypoints;
     /** Collection slugs contained in the bundle, for quick inspection. */
     collections?: string[];
@@ -302,6 +365,17 @@ export interface RebaseBundleManifest {
     storage?: {
         /** Whether the config package exports a `storageAuthorize` hook. */
         authorize: boolean;
+        /**
+         * Every storage source this bundle expects, resolved at build time from
+         * `rebase.json`'s `storage` block merged with any `storageSources` the
+         * config package exports.
+         *
+         * Recorded so the runtime does not have to import user code to learn its
+         * own topology, and so a host can tell — from the artifact alone, before
+         * starting anything — which buckets need configuring. Absent on bundles
+         * built before this field existed, which means one default source.
+         */
+        sources?: StorageSourceDefinition[];
     };
     deps: {
         /** Runtime dependencies of user code, as declared. */
@@ -325,7 +399,6 @@ export interface RebaseProjectContract {
         version: string;
         contract: number;
     };
-    mode: "cms" | "baas";
     /** Full collection definitions, serialized — the input to SDK generation. */
     collections: unknown[];
     /** Collection slugs, for cheap inspection without parsing the definitions. */

package/dist/types/properties.d.ts

@@ -1,6 +1,5 @@
 import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
 import type { Relation, ResolvedRelation } from "./relations";
-import type { FilterValues } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
 import type { AuthState } from "../controllers/auth_state";
 import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks";
@@ -35,15 +34,40 @@ export type Property = StringProperty | NumberProperty | BooleanProperty | DateP
 export type Properties = {
     [key: string]: Property;
 };
+/**
+ * `Omit` that survives a union.
+ *
+ * `Property` is a union discriminated on `type`, and a bare `Omit<Property, K>`
+ * collapses it into one object whose `type` is the union of every tag — so
+ * `property.type === "string"` stops narrowing and the concrete property types
+ * become unreachable. The `T extends unknown` clause makes it distribute, so
+ * each member is omitted from separately and keeps its own discriminant.
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * The fields that describe a property's **column**, which only an engine with
+ * columns has.
+ *
+ * `columnType` names a Postgres type (`uuid`, `bigserial`, `jsonb`, `text[]`)
+ * and `columnName` overrides the snake_case derivation used to build a column
+ * name. `DataSourceCapabilities.supportsColumnTypes` already reported this at
+ * runtime — `false` for both document engines — while the types let a MongoDB
+ * property declare `columnType: "bigserial"`.
+ *
+ * They stay declared on the concrete property interfaces rather than moving,
+ * because that is where their per-type value unions live; what changes is that
+ * the document engines' property aliases omit them.
+ */
+type SqlColumnFields = "columnType" | "columnName";
 export type PostgresProperty = Exclude<Property, ReferenceProperty>;
 export type PostgresProperties = {
     [key: string]: PostgresProperty;
 };
-export type FirebaseProperty = Exclude<Property, RelationProperty>;
+export type FirebaseProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type FirebaseProperties = {
     [key: string]: FirebaseProperty;
 };
-export type MongoProperty = Exclude<Property, RelationProperty>;
+export type MongoProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type MongoProperties = {
     [key: string]: MongoProperty;
 };
@@ -113,7 +137,7 @@ export interface BaseProperty<CustomProps = unknown> {
     description?: string;
     /**
      * You can use this prop to reuse a property that has been defined
-     * in the top level of the CMS in the prop `fields`.
+     * in the top level of the admin in the prop `fields`.
      * All the configuration will be taken from the inherited config, and
      * overwritten by the current property config.
      */
@@ -398,19 +422,6 @@ export interface ReferenceProperty extends BaseProperty {
      * property.
      */
     path?: string;
-    /**
-     * Allow selection of entities that pass the given filter only.
-     * e.g. `fixedFilter: { age: [">=", 18] }`
-     */
-    fixedFilter?: FilterValues<string>;
-    /**
-     * Should the reference include the ID of the entity. Defaults to `true`
-     */
-    includeId?: boolean;
-    /**
-     * Should the reference include a link to the entity (open the entity details). Defaults to `true`
-     */
-    includeEntityLink?: boolean;
 }
 /**
  * A schema-level relationship between collections **within a single
@@ -469,24 +480,6 @@ export interface RelationProperty extends BaseProperty {
      * collection's `relations` array.
      */
     resolvedRelation?: ResolvedRelation;
-    /**
-     * Allow selection of entities that pass the given filter only.
-     * e.g. `fixedFilter: { age: [">=", 18] }`
-     */
-    fixedFilter?: FilterValues<string>;
-    /**
-     * Should the reference include the ID of the entity. Defaults to `true`
-     */
-    includeId?: boolean;
-    /**
-     * Should the reference include a link to the entity (open the entity details). Defaults to `true`
-     */
-    includeEntityLink?: boolean;
-    /**
-     * Choose the widget to use for selecting the relation.
-     * Defaults to `select`.
-     */
-    widget?: "select" | "dialog";
 }
 export interface ArrayProperty extends BaseProperty {
     type: "array";
@@ -549,16 +542,6 @@ export interface ArrayProperty extends BaseProperty {
      * Rules for validating this property
      */
     validation?: ArrayPropertyValidationSchema;
-    /**
-     * Can the elements in this array be reordered. Defaults to `true`.
-     * This prop has no effect if `disabled` is set to true.
-     */
-    sortable?: boolean;
-    /**
-     * Can the elements in this array be added. Defaults to `true`
-     * This prop has no effect if `disabled` is set to true.
-     */
-    canAddElements?: boolean;
 }
 export interface MapProperty extends BaseProperty {
     type: "map";
@@ -578,6 +561,12 @@ export interface MapProperty extends BaseProperty {
      * Order in which the properties are displayed.
      * If you are specifying your collection as code, the order is the same as the
      * one you define in `properties`, and you don't need to specify this prop.
+     *
+     * Stays on the property rather than moving to the `admin` block, unlike the
+     * rest of the map's presentation options: `sortProperties` in
+     * `@rebasepro/common` reads it recursively, and `@rebasepro/firebase` calls
+     * that when it builds collections. A core package cannot read the admin
+     * block — the field exists only once `@rebasepro/admin-types` is installed.
      */
     propertiesOrder?: string[];
     /**
@@ -586,13 +575,13 @@ export interface MapProperty extends BaseProperty {
      * will be considered valid, even if you set `required` in the properties.
      */
     validation?: PropertyValidationSchema;
-    /**
-     * Properties that are displayed when rendered as a preview
-     */
-    previewProperties?: string[];
     /**
      * Render this map as a key-value table that allows to use
      * arbitrary keys. You don't need to define the properties in this case.
+     *
+     * Core rather than admin despite the wording: it says the map has no
+     * declared shape, which is what the OpenAPI generator emits the schema
+     * from (`additionalProperties` instead of a property list).
      */
     keyValue?: boolean;
 }

package/dist/types/storage_source.d.ts

@@ -81,3 +81,63 @@ export interface ResolvedStorageSource {
     /** Human-readable label. */
     label?: string;
 }
+/**
+ * The environment-variable suffix for a storage or data source key.
+ *
+ * `""` for the default source — so a single-bucket project keeps configuring
+ * plain `S3_BUCKET` — and `__<KEY>` for every named one, uppercased with
+ * non-alphanumerics collapsed to underscores: `media-cdn` → `S3_BUCKET__MEDIA_CDN`.
+ *
+ * The rule derives the variable name from the declared key rather than
+ * discovering keys by scanning the environment. Scanning would have to guess how
+ * `S3_BUCKET__MEDIA_CDN` splits into a key; deriving cannot be ambiguous, and a
+ * typo surfaces as a missing source at boot instead of a silently ignored
+ * variable.
+ *
+ * It lives in this package, with no dependencies, because four things must agree
+ * on it exactly: the CLI (validating a build), the runtime (reading its own
+ * environment), the control plane (writing a tenant's Secret), and the docs. A
+ * second implementation of a naming convention is a second chance to disagree.
+ *
+ * @group Models
+ */
+export declare function storageEnvSuffix(key: string, defaultKey?: string): string;
+/**
+ * Two distinct keys that collapse onto the same variable name, or `null`.
+ *
+ * `media-cdn` and `media_cdn` are different source keys but the same suffix, so
+ * without this one of them silently reads the other's configuration. Returns the
+ * offending pair rather than throwing, so each caller can raise it in its own
+ * idiom — a `BundleError` at boot, a build failure in the CLI, a rejected deploy
+ * in a control plane.
+ *
+ * @group Models
+ */
+export declare function findStorageSuffixCollision(keys: string[], defaultKey?: string): {
+    a: string;
+    b: string;
+    suffix: string;
+} | null;
+/** The `storage` block of `rebase.json`, structurally. */
+export type DeclaredStorageSources = Record<string, {
+    engine: string;
+    transport?: StorageSourceTransport;
+    label?: string;
+}>;
+/**
+ * Merge the two places a project may declare storage sources into one list.
+ *
+ * `rebase.json` is authoritative for every field it states. Config code may add
+ * sources it does not mention and fill in fields it left out, but may not
+ * contradict it: the manifest is what a host reads to decide which buckets need
+ * configuring, and a runtime that quietly disagreed with it would put the
+ * console back to describing a topology the tenant does not have — the exact
+ * failure this whole mechanism exists to end.
+ *
+ * Note what is *not* here: no default source is invented when both inputs are
+ * empty. That decision belongs to the resolver, which knows whether declaring
+ * nothing means "one plain bucket" (it does) or "no storage at all".
+ *
+ * @group Models
+ */
+export declare function normalizeStorageSources(declared: DeclaredStorageSources | StorageSourceDefinition[] | undefined, exported: StorageSourceDefinition[] | undefined): StorageSourceDefinition[];

package/dist/types/websockets.d.ts

@@ -115,40 +115,3 @@ export interface ChannelHistoryMessage extends WebSocketMessage {
      */
     latestSeq?: number;
 }
-/**
- * Column metadata returned by table introspection.
- */
-export interface TableColumnInfo {
-    column_name: string;
-    data_type: string;
-    udt_name: string;
-    is_nullable: string;
-    column_default: string | null;
-    character_maximum_length: number | null;
-    /** Enum values, populated for USER-DEFINED (enum) columns */
-    enum_values?: string[];
-}
-export interface TableForeignKeyInfo {
-    column_name: string;
-    foreign_table_name: string;
-    foreign_column_name: string;
-}
-export interface TableJunctionInfo {
-    junction_table_name: string;
-    source_column_name: string;
-    target_table_name: string;
-    target_column_name: string;
-}
-export interface TablePolicyInfo {
-    policy_name: string;
-    roles: string[];
-    cmd: string;
-    qual?: string;
-    with_check?: string;
-}
-export interface TableMetadata {
-    columns: TableColumnInfo[];
-    foreignKeys: TableForeignKeyInfo[];
-    junctions: TableJunctionInfo[];
-    policies: TablePolicyInfo[];
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/types",
   "type": "module",
-  "version": "0.11.1-canary.gfd39654",
+  "version": "0.12.0",
   "description": "Rebase type definitions — shared interfaces and controller types",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"

package/src/controllers/collection_registry.ts

@@ -11,7 +11,7 @@ export type CollectionRegistryController<
 > = {
 
     /**
-     * List of the mapped collections in the CMS.
+     * List of the mapped collections in the admin.
      * Each entry relates to a collection in the root database.
      * Each of the navigation entries in this field
      * generates an entry in the main menu.