@rebasepro/admin 0.11.1-canary.gfd39654 → 0.12.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/admin",
   "type": "module",
-  "version": "0.11.1-canary.gfd39654",
+  "version": "0.12.0",
   "description": "Rebase CMS — content management views, forms, and routing",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -83,14 +83,14 @@
     "react-dropzone": "^15.0.0",
     "react-use-measure": "^2.1.7",
     "zod": "^4.4.3",
-    "@rebasepro/common": "0.11.1-canary.gfd39654",
-    "@rebasepro/forms": "0.11.1-canary.gfd39654",
-    "@rebasepro/inference": "0.11.1-canary.gfd39654",
-    "@rebasepro/utils": "0.11.1-canary.gfd39654",
-    "@rebasepro/ui": "0.11.1-canary.gfd39654",
-    "@rebasepro/app": "0.11.1-canary.gfd39654",
-    "@rebasepro/types": "0.11.1-canary.gfd39654",
-    "@rebasepro/admin-types": "0.11.1-canary.gfd39654"
+    "@rebasepro/admin-types": "0.12.0",
+    "@rebasepro/app": "0.12.0",
+    "@rebasepro/common": "0.12.0",
+    "@rebasepro/forms": "0.12.0",
+    "@rebasepro/types": "0.12.0",
+    "@rebasepro/inference": "0.12.0",
+    "@rebasepro/ui": "0.12.0",
+    "@rebasepro/utils": "0.12.0"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/src/collection_editor/CollectionEditorDialogsContext.tsx

@@ -5,7 +5,7 @@ import React, { createContext, useContext } from "react";
  * sets and CollectionEditorDialogs reads.
  *
  * This indirection exists because ConfigControllerProvider is a root-scope
- * plugin provider that wraps <RebaseShell>, therefore living ABOVE the CMS
+ * plugin provider that wraps <RebaseShell>, therefore living ABOVE the admin
  * context providers (CollectionRegistryContext, NavigationStateContext,
  * UrlContext).  The actual dialog components need those contexts, so they
  * must render inside the shell tree.

package/src/collection_editor/ConfigControllerProvider.tsx

@@ -245,7 +245,7 @@ parentEntityIds,
         }, [onAnalyticsEvent, pathSuggestions]);
 
         // Build the dialog props objects that will be consumed by
-        // CollectionEditorDialogs (rendered inside RebaseShell where CMS
+        // CollectionEditorDialogs (rendered inside RebaseShell where admin
         // contexts are available).
         const collectionDialogProps = useMemo(() => {
             if (!currentDialog) return undefined;

package/src/collection_editor/_cms_internals.ts

@@ -1,7 +1,7 @@
 /**
  * Internal re-exports for the collection editor module.
  * This avoids circular imports by pointing directly at source files
- * rather than going through the CMS barrel (index.ts).
+ * rather than going through the admin barrel (index.ts).
  */
 
 // Hooks

package/src/collection_editor/extensibility_types.ts

@@ -160,7 +160,7 @@ export interface CollectionEditorExtensionProps {
      * reading from React contexts.
      *
      * Use this when embedding the collection editor outside of the Rebase
-     * CMS, where the Rebase context providers are not available.
+     * admin, where the Rebase context providers are not available.
      *
      * Default: false (standard Rebase mode).
      */

package/src/collection_editor/index.ts

@@ -1,9 +1,9 @@
 // Collection Editor — moved from @rebasepro/studio
-// This module provides the visual schema/collection editor for the CMS.
+// This module provides the visual schema/collection editor for the admin.
 //
 // IMPORTANT: Heavy UI components (CollectionEditorDialog, CollectionStudioView,
 // CollectionsStudioView, PropertyForm, PropertyFormDialog) are NOT re-exported
-// here to keep the main CMS bundle lean. Import them from
+// here to keep the main admin bundle lean. Import them from
 // "@rebasepro/admin/collection_editor_ui" instead — they live in a separate chunk
 // that is loaded on demand.
 

package/src/collection_editor/serializable_types.ts

@@ -23,7 +23,8 @@ import type {
     OnAction,
     PropertyConditions,
     PropertyValidationSchema,
-    SecurityRule
+    SecurityRule,
+    WhereFilterOp
 } from "@rebasepro/types";
 import type {
     CollectionSize,
@@ -47,7 +48,9 @@ export interface SerializableAdminBaseOptions {
     disabled?: boolean | SerializablePropertyDisabledConfig;
     widthPercentage?: number;
     customProps?: unknown;
-    // Field and Preview are dropped (ComponentRef is not serializable)
+    /** Narrows the filter operators offered for this property. Plain data. */
+    filterOperators?: readonly WhereFilterOp[];
+    // Field, Preview and Filter are dropped (ComponentRef is not serializable)
 }
 
 /** JSON-serializable version of `PropertyDisabledConfig`. Already serializable. */
@@ -113,7 +116,12 @@ export interface SerializableAdminStringOptions extends SerializableAdminBaseOpt
     markdown?: boolean;
     previewAsTag?: boolean;
     clearable?: boolean;
-    url?: boolean | "image" | "video" | "audio" | "file";
+    /**
+     * How a string holding a URL is rendered. Was mirrored here as `url`, the
+     * name of the *core* flag that says the string is a URL at all — so this
+     * option had no serializable form and the core flag had two.
+     */
+    urlPreview?: "image" | "video" | "audio" | "file";
 }
 
 /** JSON-serializable version of `AdminNumberOptions`. */
@@ -134,18 +142,26 @@ export interface SerializableAdminVectorOptions extends SerializableAdminBaseOpt
 /** JSON-serializable version of `AdminReferenceOptions`. */
 export interface SerializableAdminReferenceOptions extends SerializableAdminBaseOptions {
     previewProperties?: string[];
+    fixedFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
 }
 
 /** JSON-serializable version of `AdminRelationOptions`. */
 export interface SerializableAdminRelationOptions extends SerializableAdminBaseOptions {
     previewProperties?: string[];
     widget?: "select" | "dialog";
+    fixedFilter?: FilterValues<string>;
+    includeId?: boolean;
+    includeEntityLink?: boolean;
 }
 
 /** JSON-serializable version of `AdminArrayOptions`. */
 export interface SerializableAdminArrayOptions extends SerializableAdminBaseOptions {
     expanded?: boolean;
     minimalistView?: boolean;
+    sortable?: boolean;
+    canAddElements?: boolean;
 }
 
 /** JSON-serializable version of `AdminMapOptions`. */
@@ -153,6 +169,7 @@ export interface SerializableAdminMapOptions extends SerializableAdminBaseOption
     expanded?: boolean;
     minimalistView?: boolean;
     spreadChildren?: boolean;
+    previewProperties?: string[];
 }
 
 // ── Serializable base property ────────────────────────────────────────
@@ -168,6 +185,12 @@ export interface SerializableBaseProperty {
     description?: string;
     propertyConfig?: string;
     columnName?: string;
+    /**
+     * Server-side guarantee that the column never reaches an API response — a
+     * password hash, a verification token. Absent from this mirror until now,
+     * so editing a collection in the panel silently unset it.
+     */
+    excludeFromApi?: boolean;
     validation?: PropertyValidationSchema;
     defaultValue?: unknown;
     /**
@@ -196,6 +219,8 @@ export interface SerializableStringProperty extends SerializableBaseProperty {
     storage?: SerializableStorageConfig;
     userSelect?: boolean;
     email?: boolean;
+    /** The string holds a URL. Feeds the generated OpenAPI contract. */
+    url?: boolean;
     reference?: SerializableReferenceProperty;
 }
 
@@ -257,9 +282,6 @@ export interface SerializableReferenceProperty extends SerializableBaseProperty
     type: "reference";
     isId?: boolean;
     path?: string;
-    fixedFilter?: FilterValues<string>;
-    includeId?: boolean;
-    includeEntityLink?: boolean;
 }
 
 /**
@@ -309,10 +331,6 @@ export interface SerializableRelationProperty extends SerializableBaseProperty {
      * went on describing a shape nothing produced, and the cast hid it.
      */
     relation?: SerializableRelation;
-    fixedFilter?: FilterValues<string>;
-    includeId?: boolean;
-    includeEntityLink?: boolean;
-    widget?: "select" | "dialog";
     // overrides are dropped (can contain non-serializable CollectionConfig fields)
 }
 
@@ -329,8 +347,6 @@ export interface SerializableArrayProperty extends SerializableBaseProperty {
         valueField?: string;
     };
     validation?: ArrayPropertyValidationSchema;
-    sortable?: boolean;
-    canAddElements?: boolean;
 }
 
 /** JSON-serializable `MapProperty`. */
@@ -341,7 +357,6 @@ export interface SerializableMapProperty extends SerializableBaseProperty {
     properties?: SerializableProperties;
     propertiesOrder?: string[];
     validation?: PropertyValidationSchema;
-    previewProperties?: string[];
     keyValue?: boolean;
 }
 
@@ -453,7 +468,23 @@ export interface SerializableCollectionConfig {
     // ── SQL / Postgres-specific ───────────────────────────────────────
     table?: string;
     schema?: string;
+    /**
+     * Collection-level relations, `target` as a slug — a thunk does not
+     * serialize, same as on a relation property.
+     *
+     * Absent from this mirror until now, and `buildCollectionFromTableMetadata`
+     * is the reason it matters: importing a table detects its foreign keys and
+     * junctions, puts them on the form, and the save then dropped every one of
+     * them. The import looked like it worked.
+     */
+    relations?: SerializableRelation[];
     securityRules?: readonly SecurityRule[];
+    /** Removes the framework's injected baseline RLS policies. */
+    disableDefaultPolicies?: boolean;
+
+    // ── Write behaviour ───────────────────────────────────────────────
+    /** Whether a write naming an undeclared field is rejected with a 400. */
+    strictWrites?: boolean;
 
     // ── Owner ─────────────────────────────────────────────────────────
     ownerId?: string;

package/src/collection_editor/serializable_utils.ts

@@ -8,7 +8,7 @@
  * @module
  */
 
-import type { ArrayProperty, BinaryProperty, BooleanProperty, DateProperty, GeopointProperty, MapProperty, NumberProperty, Properties, Property, ReferenceProperty, RelationProperty, StorageConfig, StringProperty, VectorProperty } from "@rebasepro/types";
+import { isRelationalCollectionConfig, type Relation, type ArrayProperty, type BinaryProperty, type BooleanProperty, type DateProperty, type GeopointProperty, type MapProperty, type NumberProperty, type Properties, type Property, type ReferenceProperty, type RelationProperty, type StorageConfig, type StringProperty, type VectorProperty } from "@rebasepro/types";
 import type { AdminPropertyOptions } from "@rebasepro/admin-types";
 import type { AdminCollection } from "@rebasepro/admin-types";
 
@@ -27,6 +27,7 @@ import type {
     SerializableProperties,
     SerializableProperty,
     SerializableReferenceProperty,
+    SerializableRelation,
     SerializableRelationProperty,
     SerializableStorageConfig,
     SerializableStringProperty,
@@ -51,13 +52,22 @@ export type CollectionLookup = (slug: string) => AdminCollection | undefined;
  * Strip non-serializable fields from a `AdminPropertyOptions`.
  * Removes `Field` and `Preview` (ComponentRef).
  */
+/**
+ * Every `ComponentRef` on a property's admin block. These are components, not
+ * data, and none of them survives `JSON.stringify` — a function-valued key is
+ * dropped from the output object with no error, so a component written here
+ * would leave a key that reads back as missing rather than as itself.
+ *
+ * `Filter` was absent from this list while `Field` and `Preview` were named
+ * twice, once destructured and once compared by string.
+ */
+const NON_SERIALIZABLE_ADMIN_KEYS = ["Field", "Preview", "Filter"];
+
 function toSerializableAdminOptions(ui: AdminPropertyOptions | undefined): SerializableAdminBaseOptions | undefined {
     if (!ui) return undefined;
-    const { Field, Preview, ...rest } = ui as AdminPropertyOptions & Record<string, unknown>;
-    // Only return if there are remaining fields
     const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(rest)) {
-        if (key !== "Field" && key !== "Preview" && value !== undefined) {
+    for (const [key, value] of Object.entries(ui as Record<string, unknown>)) {
+        if (!NON_SERIALIZABLE_ADMIN_KEYS.includes(key) && value !== undefined) {
             result[key] = value;
         }
     }
@@ -121,6 +131,48 @@ function resolveRelationTarget(target: RelationProperty["relation"] extends infe
     return undefined;
 }
 
+/**
+ * A `Relation` as JSON: `target` resolved from its thunk down to a slug.
+ *
+ * Switched on `kind` and assigned without a cast, so the compiler checks that
+ * each branch writes the fields its kind owns and no others. This used to be
+ * built as an untyped bag and cast into place — which is how the target
+ * interface drifted a whole refactor behind the code writing to it.
+ *
+ * Shared by the relation *property* and the collection-level `relations` array,
+ * which had no serializer at all: `buildCollectionFromTableMetadata` fills that
+ * array from the table's foreign keys and junctions on import, and every one of
+ * them was dropped on save.
+ */
+function toSerializableRelation(link: Relation): SerializableRelation {
+    const target = resolveRelationTarget(link.target);
+    const common = {
+        ...(target ? { target } : {}),
+        ...(link.relationName ? { relationName: link.relationName } : {}),
+        ...(link.onUpdate ? { onUpdate: link.onUpdate } : {}),
+        ...(link.onDelete ? { onDelete: link.onDelete } : {})
+    };
+    switch (link.kind) {
+        case "belongsTo":
+            return { kind: "belongsTo", ...common, ...(link.localKey ? { localKey: link.localKey } : {}) };
+        case "hasOne":
+        case "hasMany":
+            return {
+                kind: link.kind,
+                ...common,
+                ...(link.foreignKeyOnTarget ? { foreignKeyOnTarget: link.foreignKeyOnTarget } : {})
+            };
+        case "manyToMany":
+            return { kind: "manyToMany", ...common, ...(link.through ? { through: link.through } : {}) };
+        case "via":
+            return { kind: "via", ...common, cardinality: link.cardinality, joinPath: link.joinPath };
+        default: {
+            const exhaustive: never = link;
+            throw new Error(`Unhandled relation kind: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+
 /**
  * Strip non-serializable base property fields.
  * Returns a clean object with only the common serializable fields from BaseProperty.
@@ -134,6 +186,7 @@ function toSerializableBaseFields(property: Property): Omit<SerializableBaseProp
     if (property.description) result.description = property.description;
     if (property.propertyConfig) result.propertyConfig = property.propertyConfig;
     if (property.columnName) result.columnName = property.columnName;
+    if (property.excludeFromApi !== undefined) result.excludeFromApi = property.excludeFromApi;
     if (property.defaultValue !== undefined) result.defaultValue = property.defaultValue;
     if (property.conditions) result.conditions = property.conditions;
     if (property.metadata) result.metadata = property.metadata;
@@ -164,6 +217,7 @@ export function toSerializableProperty(property: Property): SerializableProperty
             if (sp.enum) result.enum = sp.enum;
             if (sp.userSelect) result.userSelect = sp.userSelect;
             if (sp.email) result.email = sp.email;
+            if (sp.url) result.url = sp.url;
 
             // Convert validation.matches from RegExp to string
             if (sp.validation) {
@@ -255,9 +309,6 @@ export function toSerializableProperty(property: Property): SerializableProperty
             };
             if (rp.isId !== undefined) result.isId = rp.isId;
             if (rp.path) result.path = rp.path;
-            if (rp.fixedFilter) result.fixedFilter = rp.fixedFilter;
-            if (rp.includeId !== undefined) result.includeId = rp.includeId;
-            if (rp.includeEntityLink !== undefined) result.includeEntityLink = rp.includeEntityLink;
             return result;
         }
 
@@ -278,54 +329,8 @@ export function toSerializableProperty(property: Property): SerializableProperty
                 // no others. This used to be built as an untyped bag and cast
                 // into place — which is how the target interface drifted a
                 // whole refactor behind the code writing to it.
-                const target = resolveRelationTarget(link.target);
-                const common = {
-                    ...(target ? { target } : {}),
-                    ...(link.relationName ? { relationName: link.relationName } : {}),
-                    ...(link.onUpdate ? { onUpdate: link.onUpdate } : {}),
-                    ...(link.onDelete ? { onDelete: link.onDelete } : {})
-                };
-                switch (link.kind) {
-                    case "belongsTo":
-                        result.relation = {
-                            kind: "belongsTo",
-                            ...common,
-                            ...(link.localKey ? { localKey: link.localKey } : {})
-                        };
-                        break;
-                    case "hasOne":
-                    case "hasMany":
-                        result.relation = {
-                            kind: link.kind,
-                            ...common,
-                            ...(link.foreignKeyOnTarget ? { foreignKeyOnTarget: link.foreignKeyOnTarget } : {})
-                        };
-                        break;
-                    case "manyToMany":
-                        result.relation = {
-                            kind: "manyToMany",
-                            ...common,
-                            ...(link.through ? { through: link.through } : {})
-                        };
-                        break;
-                    case "via":
-                        result.relation = {
-                            kind: "via",
-                            ...common,
-                            cardinality: link.cardinality,
-                            joinPath: link.joinPath
-                        };
-                        break;
-                    default: {
-                        const exhaustive: never = link;
-                        throw new Error(`Unhandled relation kind: ${JSON.stringify(exhaustive)}`);
-                    }
-                }
+                result.relation = toSerializableRelation(link);
             }
-            if (rl.fixedFilter) result.fixedFilter = rl.fixedFilter;
-            if (rl.includeId !== undefined) result.includeId = rl.includeId;
-            if (rl.includeEntityLink !== undefined) result.includeEntityLink = rl.includeEntityLink;
-            if (rl.widget) result.widget = rl.widget;
             // overrides are dropped (may hold a non-serializable CollectionConfig)
             return result;
         }
@@ -338,8 +343,6 @@ export function toSerializableProperty(property: Property): SerializableProperty
             };
             if (ap.columnType) result.columnType = ap.columnType;
             if (ap.validation) result.validation = ap.validation;
-            if (ap.sortable !== undefined) result.sortable = ap.sortable;
-            if (ap.canAddElements !== undefined) result.canAddElements = ap.canAddElements;
 
             // Recursively serialize the "of" property
             if (ap.of) {
@@ -371,7 +374,6 @@ export function toSerializableProperty(property: Property): SerializableProperty
             if (mp.columnType) result.columnType = mp.columnType;
             if (mp.validation) result.validation = mp.validation;
             if (mp.propertiesOrder) result.propertiesOrder = mp.propertiesOrder;
-            if (mp.previewProperties) result.previewProperties = mp.previewProperties;
             if (mp.keyValue) result.keyValue = mp.keyValue;
 
             // Recursively serialize nested properties
@@ -448,7 +450,10 @@ export function toSerializableCollectionConfig(collection: AdminCollection): Ser
     if (collection.titleProperty) result.titleProperty = collection.titleProperty as string;
     if (collection.ownerId) result.ownerId = collection.ownerId;
     if (collection.metadata) result.metadata = collection.metadata;
-    if (collection.table) result.table = collection.table;
+    if (isRelationalCollectionConfig(collection) && collection.table) result.table = collection.table;
+    if (isRelationalCollectionConfig(collection) && collection.relations?.length) {
+        result.relations = collection.relations.map(toSerializableRelation);
+    }
     if ("schema" in collection && collection.schema) result.schema = collection.schema as string;
     if (collection.orderProperty) result.orderProperty = collection.orderProperty as string;
 
@@ -462,6 +467,10 @@ export function toSerializableCollectionConfig(collection: AdminCollection): Ser
     if (collection.enabledViews) result.enabledViews = collection.enabledViews;
     if (collection.disableDefaultActions) result.disableDefaultActions = collection.disableDefaultActions;
     if (collection.securityRules) result.securityRules = collection.securityRules;
+    if (isRelationalCollectionConfig(collection) && collection.disableDefaultPolicies !== undefined) {
+        result.disableDefaultPolicies = collection.disableDefaultPolicies;
+    }
+    if (collection.strictWrites !== undefined) result.strictWrites = collection.strictWrites;
 
     // Enum-like fields
     if (collection.openEntityMode) result.openEntityMode = collection.openEntityMode;

package/src/collection_editor/ui/collection_editor/CollectionEditorDialog.tsx

@@ -53,7 +53,7 @@ import { AICollectionGeneratorPopover } from "./AICollectionGeneratorPopover";
 import { AIModifiedPathsProvider, useAIModifiedPaths } from "./AIModifiedPathsContext";
 import { CollectionGenerationCallback, CollectionOperation } from "../../api/generateCollectionApi";
 import { CollectionRLSTab } from "./CollectionRLSTab";
-import { buildCollectionFromTableMetadata } from "../../pgColumnToProperty";
+import { buildCollectionFromTableMetadata } from "@rebasepro/common";
 import { mergeDeep, randomString, removeUndefined } from "@rebasepro/utils";
 import type { CollectionEditorExtensionProps, CollectionEditorTab } from "../../extensibility_types";
 

package/src/collection_editor/ui/collection_editor/CollectionRLSTab.tsx

@@ -1,5 +1,4 @@
 
-import { SecurityRule as GeneratedSecurityRule } from "@rebasepro/types";
 import { getPolicyNamesForRule, getPolicyNamesForRules } from "@rebasepro/utils";
 import { getEffectiveSecurityRules } from "@rebasepro/common";
 import React, { useState, useEffect, useMemo } from "react";
@@ -42,27 +41,9 @@ import {
 import { useFormex } from "@rebasepro/forms";
 import { useRebaseContext } from "@rebasepro/app";
 import type { AdminCollection } from "@rebasepro/admin-types";
+import type { PostgresPolicy, SecurityOperation, SecurityRule } from "@rebasepro/types";
 
-/** Postgres RLS policy shape — defined inline to avoid depending on @rebasepro/studio */
-export interface PostgresPolicy {
-    policyname: string;
-    tablename: string;
-    permissive: "PERMISSIVE" | "RESTRICTIVE";
-    roles: string[];
-    cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
-    qual: string | null;
-    with_check: string | null;
-    status?: "live" | "code_only" | "both";
-}
-
-interface SecurityRule {
-    name: string;
-    operation?: string;
-    mode?: string;
-    using?: string;
-    withCheck?: string;
-    roles?: string[];
-}
+export type { PostgresPolicy } from "@rebasepro/types";
 
 type CollectionWithSecurity = AdminCollection & {
     securityRules?: SecurityRule[];
@@ -71,6 +52,64 @@ type CollectionWithSecurity = AdminCollection & {
     alias?: string;
 };
 
+/**
+ * `pg_policies` reports the operation and the permissive flag in upper case;
+ * `SecurityRule` names them in lower case. These two used to be `.toLowerCase()`
+ * assigned straight into a `SecurityRule`, which typechecks only against a
+ * `string` field — and this file declared its own local `SecurityRule` with
+ * `operation?: string`, so it did. Against the real type it does not: an
+ * unrecognised `cmd` would have been written into the collection as a policy
+ * operation that compiles to nothing.
+ */
+function toSecurityOperation(cmd: PostgresPolicy["cmd"] | undefined): SecurityOperation | undefined {
+    switch (cmd) {
+        case "SELECT": return "select";
+        case "INSERT": return "insert";
+        case "UPDATE": return "update";
+        case "DELETE": return "delete";
+        case "ALL": return "all";
+        default: return undefined;
+    }
+}
+
+function toSecurityMode(permissive: PostgresPolicy["permissive"] | undefined): SecurityRule["mode"] {
+    // Absent stays absent. `permissive` is the default, so writing it out
+    // changes nothing semantically — but this value is serialized into the
+    // user's collection file, and defaulting here would grow a `mode:
+    // "permissive"` on every rule the editor touches. The `.toLowerCase()`
+    // this replaced returned `undefined` for an absent value; that part was
+    // right, and only the widened type was wrong.
+    if (!permissive) return undefined;
+    return permissive === "RESTRICTIVE" ? "restrictive" : "permissive";
+}
+
+/**
+ * Build a {@link SecurityRule} from a `pg_policies` row.
+ *
+ * `SecurityRule` is a discriminated union and this is the part the local shadow
+ * type flattened away: a raw-SQL rule *requires* `using`, so a policy with only
+ * a `WITH CHECK` clause — every INSERT-only policy — is not one. It is a
+ * roles-only rule carrying the check. Assembling the object field-by-field
+ * against `operation?: string` accepted all of these and told the compiler
+ * nothing.
+ */
+function toSecurityRule(policy: Partial<PostgresPolicy>): SecurityRule {
+    const base = {
+        name: policy.policyname ?? "",
+        operation: toSecurityOperation(policy.cmd),
+        mode: toSecurityMode(policy.permissive),
+        roles: policy.roles ? [...policy.roles] : undefined
+    };
+    if (policy.qual) {
+        return {
+            ...base,
+            using: policy.qual,
+            withCheck: policy.with_check || undefined
+        };
+    }
+    return base;
+}
+
 export function CollectionRLSTab() {
     const { values, setFieldValue } = useFormex<CollectionWithSecurity>();
     const [editingPolicy, setEditingPolicy] = useState<PostgresPolicy | "new" | null>(null);
@@ -186,7 +225,7 @@ export function CollectionRLSTab() {
         if (!tableName) return new Set<string>();
         const effectiveRules = getEffectiveSecurityRules(values as AdminCollection);
         return getPolicyNamesForRules(
-            [...(rules as unknown as GeneratedSecurityRule[]), ...effectiveRules],
+            [...rules, ...effectiveRules],
             tableName
         );
     }, [rules, tableName, values]);
@@ -194,14 +233,7 @@ export function CollectionRLSTab() {
     const unmappedPolicies = dbPolicies.filter(dp => !generatedPolicyNames.has(dp.policyname));
 
     const handleSave = async (newPolicy: Partial<PostgresPolicy>) => {
-        const rule: SecurityRule = {
-            name: newPolicy.policyname ?? "",
-            operation: newPolicy.cmd?.toLowerCase(),
-            mode: newPolicy.permissive?.toLowerCase(),
-            using: newPolicy.qual || undefined,
-            withCheck: newPolicy.with_check || undefined,
-            roles: newPolicy.roles
-        };
+        const rule: SecurityRule = toSecurityRule(newPolicy);
 
         let newRules;
         if (editingPolicy === "new") {
@@ -240,7 +272,7 @@ export function CollectionRLSTab() {
                                             {/* Unnamed rules are still named in Postgres — show what they compile to
                                                 rather than an empty heading. */}
                                             {rule.name || (tableName
-                                                ? getPolicyNamesForRule(rule as unknown as GeneratedSecurityRule, tableName).join(", ")
+                                                ? getPolicyNamesForRule(rule, tableName).join(", ")
                                                 : "Unnamed policy")}
                                         </Typography>
                                     </div>
@@ -251,11 +283,11 @@ export function CollectionRLSTab() {
                                 </div>
                                 <div className="flex items-center gap-1 sm:gap-2 shrink-0">
                                     <Button size="small" variant="text" onClick={() => setEditingPolicy({
-                                        policyname: rule.name,
+                                        policyname: rule.name ?? "",
                                         tablename: values.id || values.table || values.alias || "your_table",
                                         permissive: (rule.mode || "permissive").toUpperCase() as PostgresPolicy["permissive"],
                                         cmd: (rule.operation || "ALL").toUpperCase() as PostgresPolicy["cmd"],
-                                        roles: rule.roles || [],
+                                        roles: [...(rule.roles ?? [])],
                                         qual: rule.using || null,
                                         with_check: rule.withCheck || null
                                     })}>
@@ -305,14 +337,7 @@ export function CollectionRLSTab() {
                                     </div>
                                     <div className="flex items-center gap-1 sm:gap-2 shrink-0">
                                         <Button size="small" variant="outlined" color="primary" onClick={() => {
-                                             const rule: SecurityRule = {
-                                                name: dp.policyname,
-                                                operation: dp.cmd?.toLowerCase(),
-                                                mode: dp.permissive?.toLowerCase(),
-                                                using: dp.qual || undefined,
-                                                withCheck: dp.with_check || undefined,
-                                                roles: dp.roles
-                                            };
+                                             const rule: SecurityRule = toSecurityRule(dp);
                                             setFieldValue("securityRules", [...rules, rule]);
                                         }}>
                                             Import to codebase

package/src/collection_editor/ui/collection_editor/EntityActionsEditTab.tsx

@@ -145,7 +145,7 @@ export function EntityActionsEditTab({
                     title={<>Remove this action?</>}
                     body={<>This will <b>not
                         delete any data</b>, only
-                        the action in the CMS</>}/>}
+                        the action in the admin</>}/>}
 
             <EntityActionsSelectDialog
                 open={addEntityActionDialogOpen}

package/src/collection_editor/ui/collection_editor/GetCodeDialog.tsx

@@ -27,7 +27,7 @@ export function GetCodeDialog({
         <DialogContent>
 
             <Typography variant={"body2"} className={"my-4 mb-8"}>
-                If you want to customise the collection in code, you can add this collection code to your CMS
+                If you want to customise the collection in code, you can add this collection code to your admin
                 app configuration.
                 More info in the <a
                     rel="noopener noreferrer"

package/src/collection_editor/ui/collection_editor/SubcollectionsEditTab.tsx

@@ -214,7 +214,7 @@ export function SubcollectionsEditTab({
                     title={<>Delete this subcollection?</>}
                     body={<> This will <b>not
                         delete any data</b>, only
-                        the collection in the CMS</>}/>}
+                        the collection in the admin</>}/>}
             {viewToDelete &&
                 <ConfirmationDialog open={Boolean(viewToDelete)}
                     onAccept={() => {
@@ -225,7 +225,7 @@ export function SubcollectionsEditTab({
                     title={<>Remove this view?</>}
                     body={<>This will <b>not
                         delete any data</b>, only
-                        the view in the CMS</>}/>}
+                        the view in the admin</>}/>}
 
             <CollectionEditorDialog
                 open={Boolean(currentDialog)}