@rebasepro/types 0.11.1-canary.gfd39654 → 0.12.0

package/src/types/properties.ts

@@ -2,7 +2,6 @@ import type { ComponentRef } from "./component_ref";
 
 import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
 import type { JoinStep, OnAction, Relation, ResolvedRelation } from "./relations";
-import type { CollectionConfig, FilterValues, WhereFilterOp } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
 import type { AuthState } from "../controllers/auth_state";
 import type { AfterReadProps, BeforeSaveProps } from "./entity_callbacks";
@@ -65,19 +64,49 @@ 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;
 };
 
 // MongoDB is a document store: it uses references (stored pointers), not
 // SQL-style relations/joins. Same gating as Firestore.
-export type MongoProperty = Exclude<Property, RelationProperty>;
+//
+// `vector` goes with them: it is pgvector-shaped, only `@rebasepro/server-postgres`
+// reads it, and `supportsVectors` on the engine's capabilities says so.
+export type MongoProperty = DistributiveOmit<Exclude<Property, RelationProperty | VectorProperty>, SqlColumnFields>;
 export type MongoProperties = {
     [key: string]: MongoProperty;
 };
@@ -164,7 +193,7 @@ export interface BaseProperty<CustomProps = unknown> {
 
     /**
      * 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.
      */
@@ -473,20 +502,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;
 }
 
 /**
@@ -548,29 +563,6 @@ export interface RelationProperty extends BaseProperty {
      * collection's `relations` array.
      */
     resolvedRelation?: ResolvedRelation;
-
-    // ─── UI configuration ───
-
-    /**
-     * 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 {
@@ -634,17 +626,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 {
@@ -665,6 +646,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[];
     /**
@@ -673,13 +660,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/src/types/storage_source.ts

@@ -88,3 +88,133 @@ 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 function storageEnvSuffix(key: string, defaultKey: string = DEFAULT_STORAGE_SOURCE_KEY): string {
+    if (!key || key === defaultKey) return "";
+    const normalized = key
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toUpperCase();
+    if (!normalized) {
+        throw new Error(
+            `Source key "${key}" cannot be turned into an environment variable name. ` +
+            "Use a key containing at least one letter or digit."
+        );
+    }
+    return `__${normalized}`;
+}
+
+/**
+ * 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 function findStorageSuffixCollision(
+    keys: string[],
+    defaultKey: string = DEFAULT_STORAGE_SOURCE_KEY
+): { a: string; b: string; suffix: string } | null {
+    const seen = new Map<string, string>();
+    for (const key of keys) {
+        const suffix = storageEnvSuffix(key, defaultKey);
+        const existing = seen.get(suffix);
+        if (existing !== undefined && existing !== key) {
+            return { a: existing, b: key, suffix };
+        }
+        seen.set(suffix, key);
+    }
+    return 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 function normalizeStorageSources(
+    declared: DeclaredStorageSources | StorageSourceDefinition[] | undefined,
+    exported: StorageSourceDefinition[] | undefined
+): StorageSourceDefinition[] {
+    const merged = new Map<string, StorageSourceDefinition>();
+
+    // Two shapes, one meaning. `rebase.json` states sources as a record keyed by
+    // source key, which is how JSON expresses a set of named things; the bundle
+    // manifest stores the already-resolved array. Accepting both is what lets the
+    // CLI and the runtime call this with what each of them happens to hold.
+    const declaredEntries: [string, { engine: string; transport?: StorageSourceTransport; label?: string }][] =
+        Array.isArray(declared)
+            ? declared.filter(d => d?.key).map(d => [d.key, d])
+            : Object.entries(declared ?? {});
+
+    for (const [key, config] of declaredEntries) {
+        merged.set(key, {
+            key,
+            engine: config.engine,
+            transport: config.transport ?? "server",
+            ...(config.label !== undefined ? { label: config.label } : {})
+        });
+    }
+
+    for (const definition of exported ?? []) {
+        if (!definition?.key) continue;
+        const existing = merged.get(definition.key);
+        if (!existing) {
+            merged.set(definition.key, {
+                key: definition.key,
+                engine: definition.engine,
+                transport: definition.transport ?? "server",
+                ...(definition.label !== undefined ? { label: definition.label } : {})
+            });
+            continue;
+        }
+        // Fill gaps only. `rebase.json` stated these; code does not overrule it.
+        if (existing.label === undefined && definition.label !== undefined) {
+            existing.label = definition.label;
+        }
+    }
+
+    return Array.from(merged.values());
+}

package/src/types/websockets.ts

@@ -115,45 +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[];
-}