@rebasepro/types 0.10.1-canary.262a5be → 0.10.1-canary.5cd561f

package/dist/call_context.d.ts

@@ -0,0 +1,51 @@
+import type { StorageSource } from "./controllers/storage";
+import type { RebaseClient } from "./controllers/client";
+import type { RebaseSdkData } from "./controllers/data";
+import type { User } from "./users";
+/**
+ * Context that is provided to entity callbacks (hooks).
+ * It contains only the dependencies that are available in both the frontend and the backend.
+ *
+ * This is the *whole* context a collection callback gets, and it lives apart from
+ * {@link RebaseContext} on purpose. `RebaseContext` widens it with nine admin-panel
+ * controllers — navigation, side dialogs, snackbars — none of which exist in a
+ * backend process. Keeping them in one type meant every backend module that
+ * touched a callback signature transitively named the admin UI.
+ *
+ * @group Hooks and utilities
+ */
+export type RebaseCallContext<USER extends User = User> = {
+    /**
+     * The Rebase client instance.
+     * Available in all entity callbacks (beforeSave, afterSave, afterRead,
+     * beforeDelete, afterDelete) and in CollectionActionsProps via context.
+     * Use it to call backend functions, access data, storage, etc.
+     *
+     * @example
+     * // In a beforeSave callback:
+     * const result = await context.client.functions.invoke('my-function', { ... });
+     *
+     * @example
+     * // In a CollectionAction component:
+     * const { client } = props.context;
+     * const result = await client.functions.invoke('extract-job', { url });
+     */
+    client: RebaseClient;
+    /**
+     * Unified data access — `context.data.products.create(...)`.
+     * Access any collection as a dynamic property.
+     *
+     * Returns flat rows (`{ id, ...columns }`), identical to the frontend SDK
+     * client — so `context.data` in a backend callback and `client.data` in the
+     * frontend behave the same way (`row.title`, never `row.values.title`).
+     */
+    data: RebaseSdkData;
+    /**
+     * Used storage implementation
+     */
+    storageSource: StorageSource;
+    /**
+     * Set by the backend when callbacks are executed on the server.
+     */
+    user?: USER;
+};

package/dist/controllers/auth_state.d.ts

@@ -0,0 +1,23 @@
+import type { User } from "../users";
+/**
+ * The read-only slice of authentication state that property resolution needs.
+ *
+ * `dynamicProps`, `conditions` and the JSON-Logic condition context all want the
+ * same one thing: who is asking. They used to be handed the entire
+ * {@link AuthController} — `signOut`, `googleLogin`, `authLoading`, thirty-odd
+ * members of frontend machinery — which meant `properties.ts` named a frontend
+ * controller, and so did `resolveProperty` in `@rebasepro/common`, which the
+ * Postgres schema generator calls at build time. A backend generating DDL had to
+ * satisfy a type with a login method in it.
+ *
+ * `User` already carries `roles` and `metadata`, so this is not a reduction in
+ * what a dynamic property can decide on — only in what it has to be given.
+ * An `AuthController` satisfies this structurally, so the frontend passes the
+ * controller it already has.
+ *
+ * @group Hooks and utilities
+ */
+export interface AuthState<USER extends User = User> {
+    /** The signed-in user, or `null` when nobody is. */
+    user: USER | null;
+}

package/dist/controllers/collection_registry.d.ts

@@ -10,8 +10,12 @@ export type CollectionRegistryController<DB = Record<string, unknown>, EC extend
      * 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.
+     *
+     * `EC`, like {@link getCollection} — this was hardcoded to `CollectionConfig`
+     * while `getCollection` honoured the parameter, so the admin panel got its
+     * view model from one and the raw contract from the other.
      */
-    collections?: CollectionConfig[];
+    collections?: EC[];
     /**
      * Is the registry ready to be used
      */

package/dist/controllers/data_driver.d.ts

@@ -1,6 +1,6 @@
 import type { EntityStatus, EntityValues } from "../types/entities";
 import type { CollectionConfig, FilterValues } from "../types/collections";
-import type { RebaseContext } from "../rebase_context";
+import type { RebaseCallContext } from "../call_context";
 /**
  * @internal
  */
@@ -240,7 +240,7 @@ export interface DataDriver {
     delegateToCMSModel?: (data: unknown) => unknown;
     cmsToDelegateModel?: (data: unknown) => unknown;
     initTextSearch?: (props: {
-        context: RebaseContext;
+        context: RebaseCallContext;
         path: string;
         databaseId?: string;
         collection: CollectionConfig;

package/dist/controllers/index.d.ts

@@ -1,18 +1,9 @@
 export * from "./collection_registry";
-export * from "./analytics_controller";
-export * from "./auth";
+export * from "./auth_state";
 export * from "./data";
 export * from "./database_admin";
 export * from "./data_driver";
-export * from "./local_config_persistence";
-export * from "./navigation";
 export * from "./effective_role";
 export * from "./storage";
 export * from "./email";
 export * from "./client";
-export * from "./customization_controller";
-export * from "./side_panel_controller";
-export * from "./side_dialogs_controller";
-export * from "./dialogs_controller";
-export * from "./snackbar";
-export * from "./registry";

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./errors";
-export * from "./rebase_context";
+export * from "./call_context";
 export * from "./types";
 export * from "./controllers";
 export * from "./users";

package/dist/index.es.js

@@ -264,10 +264,78 @@ function toCanonicalOp(op) {
 	return REST_TO_CANONICAL[op];
 }
 //#endregion
+//#region src/types/admin_block.ts
+/**
+* Every key that belongs inside a collection's `admin` block, as data.
+*
+* The type that describes these fields is `AdminCollectionOptions` in
+* `@rebasepro/admin-types`, and it is erased at build time — but three runtime
+* consumers need the list, and two of them are core:
+*
+* - `serializeCollections`, to drop the block from the contract
+* - the ts-morph schema editor in `@rebasepro/server`, which rewrites collection
+*   files on disk from the admin panel and has to know where each key goes. A key
+*   missing from this list gets written to the *top level* of the file, where the
+*   backend ignores it and the panel never finds it again.
+* - the `collections-admin-block` codemod
+*
+* `@rebasepro/admin-types` re-exports this and asserts it names only real option
+* keys; the count is pinned by a test there.
+*
+* @group Models
+*/
+var ADMIN_COLLECTION_KEYS = [
+	"Actions",
+	"additionalFields",
+	"alwaysApplyDefaultValues",
+	"components",
+	"defaultEntityAction",
+	"defaultFilter",
+	"defaultSelectedView",
+	"defaultSize",
+	"defaultViewMode",
+	"disableDefaultActions",
+	"enabledViews",
+	"entityActions",
+	"entityViews",
+	"exportable",
+	"filterPresets",
+	"fixedFilter",
+	"formAutoSave",
+	"formView",
+	"group",
+	"hideFromNavigation",
+	"hideIdFromCollection",
+	"hideIdFromForm",
+	"icon",
+	"includeJsonView",
+	"inlineEditing",
+	"kanban",
+	"listProperties",
+	"localChangesBackup",
+	"openEntityMode",
+	"orderProperty",
+	"pagination",
+	"previewProperties",
+	"propertiesOrder",
+	"selectionController",
+	"selectionEnabled",
+	"sideDialogWidth",
+	"sort",
+	"titleProperty"
+];
+//#endregion
 //#region src/types/collections.ts
 /**
 * Type guard for PostgreSQL collections.
 * Returns true if the collection uses the Postgres engine (or the default engine).
+*
+* Generic over the *input* type, and narrows by intersection rather than
+* replacement. Narrowing to a bare `PostgresCollectionConfig` discarded whatever
+* the caller actually had — most visibly the admin panel's view model, whose
+* flattened presentation fields vanished the moment a collection passed through
+* one of these guards.
+*
 * @group Models
 */
 function isPostgresCollectionConfig(collection) {
@@ -658,12 +726,36 @@ function toSerializable(value, seen, depth, state, key) {
 * — does not depend on filesystem ordering.
 */
 function serializeCollections(collections) {
-	return [...collections].sort((a, b) => String(a.slug ?? "").localeCompare(String(b.slug ?? ""))).map((collection) => toSerializable(collection, /* @__PURE__ */ new WeakSet(), 0, {
+	return [...collections].sort((a, b) => String(a.slug ?? "").localeCompare(String(b.slug ?? ""))).map((collection) => toSerializable(withoutAdminBlock(collection), /* @__PURE__ */ new WeakSet(), 0, {
 		memo: /* @__PURE__ */ new WeakMap(),
 		truncations: 0
 	})).filter((c) => c !== void 0);
 }
 /**
+* Drop the admin block before the walk.
+*
+* Nothing downstream of serialization is an admin panel. The contract endpoint
+* feeds remote SDK generation, and `rebase build` writes the result into a bundle
+* manifest that only the backend runtime reads. The block would survive the walk
+* as a husk anyway — its React elements and component functions are dropped
+* individually — and that husk has two costs worth avoiding: it puts every custom
+* component's *file path* on an endpoint whose job is to describe data shapes, and
+* it grows a payload that is fetched and cached per project.
+*
+* Removing it here rather than at each call site means one chokepoint, so a future
+* consumer of `serializeCollections` cannot forget.
+*
+* Child collections carry their own block, so this recurses — stripping only the
+* top level was the mistake `stripNonClientFields` in the contract routes already
+* had to fix once for security rules.
+*/
+function withoutAdminBlock(collection) {
+	const { admin: _admin, ...rest } = collection;
+	const nested = rest;
+	if (Array.isArray(nested.subcollections)) nested.subcollections = nested.subcollections.map((child) => withoutAdminBlock(child));
+	return rest;
+}
+/**
 * Rebuild collections received from a contract endpoint.
 *
 * Relation refs become real thunks resolving through the returned set, so
@@ -837,6 +929,6 @@ function isPublicStoragePath(path) {
 	return p.startsWith("public/") || p.startsWith(`default/public/`);
 }
 //#endregion
-export { ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REST_TO_CANONICAL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, canonicalSchemaPayload, computeSchemaVersion, deserializeCollections, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isSQLAdmin, isSchemaAdmin, isSerializedCollectionRef, policy, registerDataSourceCapabilities, resolveClientListLimit, serializeCollections, toCanonicalOp };
+export { ADMIN_COLLECTION_KEYS, ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, BUNDLE_FORMAT_VERSION, CANONICAL_TO_REST, DEFAULT_CAPABILITIES, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, DEFAULT_STORAGE_SOURCE_KEY, DEFAULT_VECTOR_LIST_LIMIT, EntityReference, EntityRelation, FIREBASE_CAPABILITIES, GeoPoint, MAX_LIST_LIMIT, MONGODB_CAPABILITIES, NULL_OPS, POSTGRES_CAPABILITIES, PUBLIC_STORAGE_PREFIX, REST_TO_CANONICAL, RUNTIME_CONTRACT_VERSION, RebaseApiError, RebaseClientError, SCHEMA_VERSION_HEADER, Vector, canonicalSchemaPayload, computeSchemaVersion, deserializeCollections, getCollectionDataPath, getDataSourceCapabilities, getDeclaredSubcollections, isBranchAdmin, isChannelBusInstance, isDocumentAdmin, isFirebaseCollectionConfig, isLazyComponentRef, isMongoDBCollectionConfig, isPostgresCollectionConfig, isPublicStoragePath, isSQLAdmin, isSchemaAdmin, isSerializedCollectionRef, policy, registerDataSourceCapabilities, resolveClientListLimit, serializeCollections, toCanonicalOp };
 
 //# sourceMappingURL=index.es.js.map