@rebasepro/common 0.10.0 → 0.10.1-canary.0a881d4

package/dist/util/collections.d.ts

@@ -1,11 +1,3 @@
-import { DefaultSelectedViewBuilder, DefaultSelectedViewParams, CollectionConfig, Properties } from "@rebasepro/types";
+import { CollectionConfig, Properties } from "@rebasepro/types";
 export declare function sortProperties<M extends Record<string, unknown>>(properties: Properties, propertiesOrder?: string[]): Properties;
-export declare function resolveDefaultSelectedView(defaultSelectedView: string | DefaultSelectedViewBuilder | undefined, params: DefaultSelectedViewParams): string | undefined;
-export declare function getLocalChangesBackup(collection: CollectionConfig): "manual_apply" | "auto_apply";
-/**
- * Returns the primary keys for a entity collection by inspecting the properties
- * and finding any properties with `isId`.
- * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
- * @param collection
- */
 export declare function getPrimaryKeys<M extends Record<string, unknown>>(collection: CollectionConfig<M>): Extract<keyof M, string>[];

package/dist/util/conditions.d.ts

@@ -1,4 +1,4 @@
-import { AuthController, ConditionContext, JsonLogicRule, Property } from "@rebasepro/types";
+import { AuthState, ConditionContext, JsonLogicRule } from "@rebasepro/types";
 /**
  * Register custom JSON Logic operations for Rebase.
  * Call this once at app initialization.
@@ -18,9 +18,8 @@ export declare function buildConditionContext(params: {
     path: string;
     entityId?: string;
     index?: number;
-    authController: AuthController;
+    authController: AuthState;
 }): ConditionContext;
 /**
  * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
  */
-export declare function applyPropertyConditions(property: Property, context: ConditionContext): Property;

package/dist/util/entities.d.ts

@@ -1,6 +1,4 @@
 import { DataType, Entity, EntityReference, EntityRelation, EntityStatus, EntityValues, Properties, Property } from "@rebasepro/types";
-export declare function isReadOnly(property: Property): boolean;
-export declare function isHidden(property: Property): boolean;
 export declare function isPropertyBuilder(property?: Property): boolean;
 export declare function getDefaultValuesFor<M extends Record<string, unknown>>(properties: Properties): Partial<EntityValues<M>>;
 export declare function getDefaultValueFor(property?: Property): unknown;

package/dist/util/index.d.ts

@@ -7,9 +7,6 @@ export * from "./paths";
 export * from "./resolutions";
 export * from "./policy";
 export * from "./permissions";
-export * from "./references";
-export * from "./navigation_from_path";
-export * from "./parent_references_from_path";
 export * from "./builders";
 export * from "./storage";
 export * from "./callbacks";
@@ -17,5 +14,3 @@ export * from "./relations";
 export * from "./auth-default-policies";
 export * from "./junction-policies";
 export * from "./conditions";
-export * from "./navigation_utils";
-export * from "./filter-operator-resolution";

package/dist/util/permissions.d.ts

@@ -1,12 +1,15 @@
-import { Entity, CollectionConfig, SecurityOperation, User } from "@rebasepro/types";
+import { AuthState, Entity, CollectionConfig, SecurityOperation, User } from "@rebasepro/types";
 /**
  * Minimal auth context for permission checking.
  * Only requires the user object — avoids forcing callers to construct
  * a full AuthController just to check permissions.
+ *
+ * An alias, not a second definition: {@link AuthState} in `@rebasepro/types` is
+ * the same shape and is what `dynamicProps` and the JSON-Logic condition context
+ * now take, so declaring it twice would be the `WhereFilterOp` mistake again —
+ * two copies that agree only by luck.
  */
-export interface AuthContext<USER extends User = User> {
-    user: USER | null;
-}
+export type AuthContext<USER extends User = User> = AuthState<USER>;
 /**
  * How to resolve a policy result that cannot be decided client-side (a raw-SQL
  * escape-hatch rule, or a row-column reference with no row in hand).

package/dist/util/resolutions.d.ts

@@ -1,4 +1,4 @@
-import { ArrayProperty, AuthController, CollectionConfig, EnumValueConfig, EnumValues, NumberProperty, Properties, Property, Relation, RelationProperty, StringProperty } from "@rebasepro/types";
+import { ArrayProperty, AuthState, CollectionConfig, EnumValueConfig, EnumValues, NumberProperty, Properties, Property, Relation, RelationProperty, StringProperty } from "@rebasepro/types";
 type PropertyConfig = {
     property: unknown;
     [key: string]: unknown;
@@ -16,7 +16,7 @@ export type ResolvePropertyProps<M extends Record<string, unknown> = Record<stri
     index?: number;
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
-    authController: AuthController;
+    authController: AuthState;
 };
 export declare function resolveProperty<M extends Record<string, unknown> = Record<string, unknown>>(props: ResolvePropertyProps<M>): Property | null;
 export declare function resolveRelationProperty(property: RelationProperty, relations: Relation[], propertyKey?: string): RelationProperty;
@@ -40,7 +40,7 @@ export declare function resolveProperties<M extends Record<string, unknown>>({ p
     index?: number;
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
-    authController: AuthController;
+    authController: AuthState;
 }): Properties;
 export declare function resolveArrayProperties<M>({ propertyKey, property, ignoreMissingFields, ...props }: {
     propertyKey?: string;
@@ -52,7 +52,7 @@ export declare function resolveArrayProperties<M>({ propertyKey, property, ignor
     index?: number;
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
-    authController: AuthController;
+    authController: AuthState;
 }): Property[];
 export declare function getArrayResolvedProperties({ propertyKey, propertyValue, property, ...props }: {
     propertyValue: unknown;
@@ -65,7 +65,7 @@ export declare function getArrayResolvedProperties({ propertyKey, propertyValue,
     entityId?: string | number;
     index?: number;
     propertyConfigs?: Record<string, PropertyConfig>;
-    authController: AuthController;
+    authController: AuthState;
 }): Property[];
 export declare function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined;
 export declare function getSubcollections<M extends Record<string, unknown> = Record<string, unknown>>(collection: CollectionConfig<M>): CollectionConfig<Record<string, unknown>>[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.10.1-canary.0a881d4",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -40,8 +40,8 @@
   "dependencies": {
     "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/types": "0.10.0",
-    "@rebasepro/utils": "0.10.0"
+    "@rebasepro/types": "0.10.1-canary.0a881d4",
+    "@rebasepro/utils": "0.10.1-canary.0a881d4"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
@@ -50,10 +50,7 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^25.9.3",
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
     "@types/react-measure": "^2.0.12",
-    "@vitejs/plugin-react": "^6.0.2",
     "babel-plugin-react-compiler": "beta",
     "cross-env": "^10.1.0",
     "jest": "^30.4.2",
@@ -92,6 +89,7 @@
     "testEnvironment": "node",
     "moduleNameMapper": {
       "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js",
+      "^@rebasepro/admin-types$": "<rootDir>/../admin-types/src/index.ts",
       "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
       "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
       "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"

package/src/collections/default-collections.ts

@@ -6,6 +6,12 @@ import { defineCollection } from "../util/builders";
  * Prepended to the developer's collections array by the admin and server.
  * Slug-based dedup (Map keyed by slug, last-write-wins) lets developers
  * override by defining their own collection with `slug: "users"`.
+ *
+ * Schema only — no `admin` block. This package is on the backend's dependency path,
+ * where that field does not exist: `@rebasepro/admin-types` adds it by declaration
+ * merging, and a BaaS install never installs that. The scaffolded
+ * `config/collections/users.ts` carries the presentation for projects that want this
+ * collection in their panel, which is also where it is editable.
  */
 export const defaultUsersCollection = defineCollection({
     name: "Users",
@@ -14,23 +20,17 @@ export const defaultUsersCollection = defineCollection({
     auth: true,
     table: "users",
     schema: "rebase",
-    icon: "Users",
-    group: "Settings",
-    openEntityMode: "dialog",
-    disableDefaultActions: ["copy"],
     securityRules: [
         { operation: "select",
 roles: ["admin"] },
         { operations: ["insert", "update", "delete"],
 roles: ["admin"] }
     ],
-    sort: ["createdAt", "desc"],
     properties: {
         id: {
             name: "ID",
             type: "string",
-            isId: "uuid",
-            ui: { readOnly: true }
+            isId: "uuid"
         },
         email: {
             name: "Email",
@@ -47,8 +47,7 @@ unique: true }
         photoURL: {
             name: "Photo URL",
             type: "string",
-            columnName: "photo_url",
-            ui: { url: "image" }
+            columnName: "photo_url"
         },
         roles: {
             name: "Roles",
@@ -68,58 +67,43 @@ unique: true }
             name: "Password Hash",
             type: "string",
             columnName: "password_hash",
-            excludeFromApi: true,
-            ui: { hideFromCollection: true,
-disabled: { hidden: true } }
+            excludeFromApi: true
         },
         emailVerified: {
             name: "Email Verified",
             type: "boolean",
             columnName: "email_verified",
-            defaultValue: false,
-            ui: { hideFromCollection: true,
-disabled: { hidden: true } }
+            defaultValue: false
         },
         emailVerificationToken: {
             name: "Email Verification Token",
             type: "string",
             columnName: "email_verification_token",
-            excludeFromApi: true,
-            ui: { hideFromCollection: true,
-disabled: { hidden: true } }
+            excludeFromApi: true
         },
         emailVerificationSentAt: {
             name: "Email Verification Sent At",
             type: "date",
-            columnName: "email_verification_sent_at",
-            ui: { hideFromCollection: true,
-disabled: { hidden: true } }
+            columnName: "email_verification_sent_at"
         },
         metadata: {
             name: "Metadata",
             type: "map",
             keyValue: true,
             properties: {},
-            defaultValue: {},
-            ui: { hideFromCollection: true,
-disabled: { hidden: true } }
+            defaultValue: {}
         },
         createdAt: {
             name: "Created At",
             type: "date",
             columnName: "created_at",
-            autoValue: "on_create",
-            ui: { readOnly: true }
+            autoValue: "on_create"
         },
         updatedAt: {
             name: "Updated At",
             type: "date",
             columnName: "updated_at",
-            autoValue: "on_update",
-            ui: { hideFromCollection: true,
-disabled: { hidden: true } }
+            autoValue: "on_update"
         }
-    },
-    listProperties: ["displayName", "email", "roles", "createdAt"],
-    propertiesOrder: ["id", "email", "displayName", "roles", "createdAt"]
+    }
 });

package/src/util/collections.ts

@@ -1,6 +1,4 @@
 import {
-    DefaultSelectedViewBuilder,
-    DefaultSelectedViewParams,
     CollectionConfig,
     Properties,
     Property
@@ -85,34 +83,8 @@ export function sortProperties<M extends Record<string, unknown>>(properties: Pr
     }
 }
 
-export function resolveDefaultSelectedView(
-    defaultSelectedView: string | DefaultSelectedViewBuilder | undefined,
-    params: DefaultSelectedViewParams
-) {
-    if (!defaultSelectedView) {
-        return undefined;
-    } else if (typeof defaultSelectedView === "string") {
-        return defaultSelectedView;
-    } else {
-        return defaultSelectedView(params);
-    }
-}
-
 
-export function getLocalChangesBackup(collection: CollectionConfig) {
-    if (!collection.localChangesBackup) {
-        return "manual_apply";
-    }
-
-    return collection.localChangesBackup;
-}
 
-/**
- * Returns the primary keys for a entity collection by inspecting the properties
- * and finding any properties with `isId`.
- * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
- * @param collection
- */
 export function getPrimaryKeys<M extends Record<string, unknown>>(collection: CollectionConfig<M>): Extract<keyof M, string>[] {
     const properties = collection.properties;
     if (!properties) {

package/src/util/conditions.ts

@@ -1,7 +1,7 @@
 import jsonLogic from "json-logic-js";
 import {
     ArrayProperty,
-    AuthController,
+    AuthState,
     ConditionContext,
     EnumValueConfig,
     JsonLogicRule,
@@ -123,7 +123,7 @@ export function buildConditionContext(params: {
     path: string;
     entityId?: string;
     index?: number;
-    authController: AuthController;
+    authController: AuthState;
 }): ConditionContext {
     const {
         propertyKey,
@@ -161,191 +161,3 @@ export function buildConditionContext(params: {
 /**
  * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
  */
-export function applyPropertyConditions(
-    property: Property,
-    context: ConditionContext
-): Property {
-    const { conditions } = property;
-    if (!conditions) return property;
-
-    const result = { ...property };
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // FIELD STATE CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    // Evaluate disabled condition
-    if (conditions.disabled) {
-        const isDisabled = evaluateCondition(conditions.disabled, context);
-        if (isDisabled) {
-            result.ui = result.ui || {};
-            result.ui.disabled = {
-                clearOnDisabled: conditions.clearOnDisabled ?? false,
-                disabledMessage: conditions.disabledMessage,
-                hidden: false
-            };
-        }
-    }
-
-    // Evaluate hidden condition
-    if (conditions.hidden) {
-        const isHidden = evaluateCondition(conditions.hidden, context);
-        if (isHidden) {
-            result.ui = result.ui || {};
-            result.ui.disabled = {
-                ...(typeof result.ui?.disabled === "object" ? result.ui.disabled : {}),
-                hidden: true,
-                clearOnDisabled: conditions.clearOnDisabled ?? false
-            };
-        }
-    }
-
-    // Evaluate readOnly condition
-    if (conditions.readOnly) {
-        const isReadOnly = evaluateCondition(conditions.readOnly, context);
-        if (isReadOnly) {
-            result.ui = result.ui || {};
-            result.ui.readOnly = true;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // VALIDATION CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    // Evaluate required condition
-    if (conditions.required !== undefined) {
-        const isRequired = evaluateCondition(conditions.required, context) as boolean;
-        result.validation = {
-            ...result.validation,
-            required: isRequired as boolean | undefined,
-            requiredMessage: conditions.requiredMessage
-        };
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // VALUE CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    // Apply default value for new entities
-    if (context.isNew && conditions.defaultValue !== undefined) {
-        result.defaultValue = evaluateCondition(conditions.defaultValue, context) as Property["defaultValue"];
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // ENUM CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    if ("enum" in result && result.enum && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
-        (result as Record<string, unknown>).enum = applyEnumConditions(
-            result.enum as EnumValueConfig[],
-            conditions,
-            context
-        );
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // REFERENCE CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    if (result.type === "reference") {
-        if (conditions.referencePath) {
-            (result as ReferenceProperty).path = evaluateCondition(conditions.referencePath, context) as string;
-        }
-        if (conditions.referenceFilter) {
-            (result as ReferenceProperty).fixedFilter = evaluateCondition(conditions.referenceFilter, context) as ReferenceProperty["fixedFilter"];
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // ARRAY CONDITIONS
-    // ═══════════════════════════════════════════════════════════════════════
-
-    if (result.type === "array") {
-        if (conditions.canAddElements !== undefined) {
-            (result as ArrayProperty).canAddElements = evaluateCondition(conditions.canAddElements, context) as boolean;
-        }
-        if (conditions.sortable !== undefined) {
-            (result as ArrayProperty).sortable = evaluateCondition(conditions.sortable, context) as boolean;
-        }
-    }
-
-    return result;
-}
-
-/**
- * Convert an object with numeric keys back to an array.
- * Firestore stores arrays as {"0": "a", "1": "b"} to avoid nested arrays.
- */
-function objectToArray(obj: unknown): string[] {
-    if (Array.isArray(obj)) return obj.map(String);
-    if (obj && typeof obj === "object") {
-        const keys = Object.keys(obj);
-        if (keys.length > 0 && keys.every(k => !isNaN(Number(k)))) {
-            return keys
-                .sort((a, b) => Number(a) - Number(b))
-                .map(k => (obj as Record<string, unknown>)[k])
-                .filter((v): v is string => typeof v === "string" || typeof v === "number")
-                .map(String);
-        }
-    }
-    return [];
-}
-
-/**
- * Apply enum-specific conditions to filter and modify enum values.
- */
-function applyEnumConditions(
-    enumValues: EnumValueConfig[],
-    conditions: PropertyConditions,
-    context: ConditionContext
-): EnumValueConfig[] {
-    let result = [...enumValues];
-
-    // Apply allowedEnumValues filter
-    if (conditions.allowedEnumValues) {
-        const allowed = evaluateCondition(conditions.allowedEnumValues, context);
-        // Handle both array format and object-with-numeric-keys format (Firestore workaround)
-        const allowedArray = objectToArray(allowed);
-        if (allowedArray.length > 0) {
-            result = result.filter(ev => allowedArray.includes(String(ev.id)));
-        }
-    }
-
-    // Apply excludedEnumValues filter
-    if (conditions.excludedEnumValues) {
-        const excluded = evaluateCondition(conditions.excludedEnumValues, context);
-        // Handle both array format and object-with-numeric-keys format
-        const excludedArray = objectToArray(excluded);
-        if (excludedArray.length > 0) {
-            result = result.filter(ev => !excludedArray.includes(String(ev.id)));
-        }
-    }
-
-    // Apply individual enum conditions
-    if (conditions.enumConditions) {
-        result = result
-            .map(ev => {
-                const evConditions = conditions.enumConditions?.[ev.id];
-                if (!evConditions) return ev;
-
-                // Check hidden condition first
-                if (evConditions.hidden && evaluateCondition(evConditions.hidden, context)) {
-                    return null; // Will be filtered out
-                }
-
-                // Check disabled condition
-                if (evConditions.disabled && evaluateCondition(evConditions.disabled, context)) {
-                    return {
-                        ...ev,
-                        disabled: true
-                    };
-                }
-
-                return ev;
-            })
-            .filter((ev): ev is EnumValueConfig => ev !== null);
-    }
-
-    return result;
-}

package/src/util/entities.ts

@@ -11,23 +11,6 @@ import {
 import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
 import { mergeDeep } from "@rebasepro/utils";
 
-export function isReadOnly(property: Property): boolean {
-    if (property.ui?.readOnly)
-        return true;
-    if (property.type === "date") {
-        if (property.autoValue)
-            return true;
-    }
-    if (property.type === "reference") {
-        return !property.path && !("Field" in (property.ui || {}) && property.ui?.Field);
-    }
-    return false;
-}
-
-export function isHidden(property: Property): boolean {
-    return typeof property.ui?.disabled === "object" && Boolean(property.ui?.disabled.hidden);
-}
-
 export function isPropertyBuilder(property?: Property) {
     return typeof property?.dynamicProps === "function";
 }

package/src/util/index.ts

@@ -7,9 +7,6 @@ export * from "./paths";
 export * from "./resolutions";
 export * from "./policy";
 export * from "./permissions";
-export * from "./references";
-export * from "./navigation_from_path";
-export * from "./parent_references_from_path";
 export * from "./builders";
 export * from "./storage";
 export * from "./callbacks";
@@ -17,5 +14,3 @@ export * from "./relations";
 export * from "./auth-default-policies";
 export * from "./junction-policies";
 export * from "./conditions";
-export * from "./navigation_utils";
-export * from "./filter-operator-resolution";

package/src/util/permissions.test.ts

@@ -1,5 +1,5 @@
 import { canCreateEntity, canEditEntity, canDeleteEntity, canReadCollection } from "./permissions";
-import { CollectionConfig, AuthController, Entity, User, SecurityRule } from "@rebasepro/types";
+import { AuthState, CollectionConfig, Entity, User, SecurityRule } from "@rebasepro/types";
 
 describe("Permissions Evaluator", () => {
 
@@ -25,23 +25,18 @@ describe("Permissions Evaluator", () => {
         roles: ["admin"]
     };
 
-    const mockAuthController: AuthController<User> = {
-        user: mockUser,
-        initialLoading: false,
-        authLoading: false,
-        loginSkipped: false,
-        signOut: async () => { },
-        getAuthToken: async () => "token",
-        setExtra: () => { },
-        extra: undefined
+    // Just the user now. Faking `signOut`, `getAuthToken`, `authLoading` and the
+    // rest of a frontend controller was never anything these assertions read.
+    const mockAuthController: AuthState<User> = {
+        user: mockUser
     };
 
-    const adminAuthController: AuthController<User> = {
+    const adminAuthController: AuthState<User> = {
         ...mockAuthController,
         user: adminUser
     };
 
-    const unauthenticatedController: AuthController<User> = {
+    const unauthenticatedController: AuthState<User> = {
         ...mockAuthController,
         user: null
     };
@@ -709,7 +704,7 @@ isAnonymous: false,
 photoURL: null,
                 roles: ["editor"]
             };
-            const editorAuth: AuthController<User> = { ...mockAuthController,
+            const editorAuth: AuthState<User> = { ...mockAuthController,
 user: editorUser };
 
             const collection = createMockCollection([
@@ -820,7 +815,7 @@ using: "status = 'draft'" }
         test("58. Missing authController ('blankAuth') handled gracefully", () => {
             const collection = createMockCollection([{ operation: "insert",
 roles: ["admin"] }]);
-            const blankAuth = { user: null } as unknown as AuthController<User>;
+            const blankAuth = { user: null } as unknown as AuthState<User>;
             expect(canCreateEntity(collection, blankAuth, "test", null)).toBe(false);
         });
 

package/src/util/permissions.ts

@@ -1,4 +1,4 @@
-import { Entity, CollectionConfig, getDataSourceCapabilities, SecurityOperation, SecurityRule, User } from "@rebasepro/types";
+import { AuthState, Entity, CollectionConfig, getDataSourceCapabilities, SecurityOperation, SecurityRule, User } from "@rebasepro/types";
 import { securityRuleToConditions } from "./policy/securityRuleToConditions";
 import { evaluatePolicy, PolicyEvalContext, TriState } from "./policy/evaluatePolicy";
 
@@ -6,10 +6,13 @@ import { evaluatePolicy, PolicyEvalContext, TriState } from "./policy/evaluatePo
  * Minimal auth context for permission checking.
  * Only requires the user object — avoids forcing callers to construct
  * a full AuthController just to check permissions.
+ *
+ * An alias, not a second definition: {@link AuthState} in `@rebasepro/types` is
+ * the same shape and is what `dynamicProps` and the JSON-Logic condition context
+ * now take, so declaring it twice would be the `WhereFilterOp` mistake again —
+ * two copies that agree only by luck.
  */
-export interface AuthContext<USER extends User = User> {
-    user: USER | null;
-}
+export type AuthContext<USER extends User = User> = AuthState<USER>;
 
 /**
  * How to resolve a policy result that cannot be decided client-side (a raw-SQL