@rebasepro/server-core 0.3.0 → 0.5.0

package/dist/types/src/types/entity_views.d.ts

@@ -56,41 +56,32 @@ export type EntityCustomView<M extends Record<string, unknown> = Record<string,
     Builder?: ComponentRef<EntityCustomViewParams<M>>;
     position?: "start" | "end";
 };
-export interface EntityCustomViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
-    collection: EntityCollection<M>;
-    entity?: Entity<M>;
-    modifiedValues?: EntityValues<M>;
-    formContext: FormContext<M>;
-    parentCollectionSlugs?: string[];
-    parentEntityIds?: string[];
-}
 /**
- * Configuration for customizing the read-only detail view of an entity.
- * Only used when `defaultEntityAction` is set to `"view"` on the collection.
+ * Configuration to replace the default entity form with a custom component.
+ * The Builder receives the same props as entity view tabs (entity, formContext, etc.)
+ * and has full control over the UI.
+ *
+ * The form tab still appears in the tab bar but renders your Builder
+ * instead of the auto-generated field form.
+ *
  * @group Models
  */
-export type EntityDetailViewConfig<M extends Record<string, unknown> = Record<string, unknown>> = {
-    /**
-     * Custom component rendered above the property display in the detail view.
-     */
-    Header?: ComponentRef<EntityDetailViewParams<M>>;
+export type FormViewConfig<M extends Record<string, unknown> = Record<string, unknown>> = {
     /**
-     * Custom component rendered below the property display in the detail view.
+     * Custom component that replaces the default form.
      */
-    Footer?: ComponentRef<EntityDetailViewParams<M>>;
+    Builder: ComponentRef<EntityCustomViewParams<M>>;
     /**
-     * Completely replace the default detail view with a custom component.
-     * When set, Header and Footer are ignored.
+     * If true, the save/delete action bar is rendered alongside the custom view.
+     * Defaults to true.
      */
-    Builder?: ComponentRef<EntityDetailViewParams<M>>;
+    includeActions?: boolean;
 };
-/**
- * Props passed to detail view customization components (Header, Footer, Builder).
- * @group Models
- */
-export interface EntityDetailViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
+export interface EntityCustomViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
     collection: EntityCollection<M>;
-    entity: Entity<M>;
-    path: string;
-    onEditClick: () => void;
+    entity?: Entity<M>;
+    modifiedValues?: EntityValues<M>;
+    formContext: FormContext<M>;
+    parentCollectionSlugs?: string[];
+    parentEntityIds?: string[];
 }

package/dist/types/src/types/properties.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentRef } from "./component_ref";
-import type { EntityReference, EntityRelation, EntityValues, GeoPoint, Entity, Vector } from "./entities";
-import type { Relation, JoinStep, OnAction } from "./relations";
+import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
+import type { JoinStep, OnAction, Relation } from "./relations";
 import type { EntityCollection, FilterValues } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
 import type { AuthController } from "../controllers/auth";
@@ -104,8 +104,8 @@ export interface BaseUIConfig<CustomProps = unknown> {
     disabled?: boolean | PropertyDisabledConfig;
     widthPercentage?: number;
     customProps?: CustomProps;
-    Field?: ComponentRef;
-    Preview?: ComponentRef;
+    Field?: ComponentRef<any>;
+    Preview?: ComponentRef<any>;
 }
 export interface BaseProperty<CustomProps = unknown> {
     ui?: BaseUIConfig<CustomProps>;
@@ -185,7 +185,7 @@ export interface StringProperty extends BaseProperty {
      * Optional database column type. If not set, it defaults to `varchar` or `uuid` depending on `isId` configuration.
      * Use `text` for strings with unbound length, `char` for fixed-length strings, or `varchar` for variable-length strings with a limit.
      */
-    columnType?: "varchar" | "text" | "char";
+    columnType?: "varchar" | "text" | "char" | "uuid";
     /**
      * Rules for validating this property
      */
@@ -541,9 +541,11 @@ export interface ArrayProperty extends BaseProperty {
     ui?: ArrayUIConfig;
     type: "array";
     /**
-     * Optional database column type. Defaults to `jsonb`.
+     * Optional database column type. By default, maps to a native Postgres array
+     * (e.g. `text[]`, `integer[]`/`numeric[]`, `boolean[]`) if the element type
+     * is a primitive, otherwise defaults to `jsonb`.
      */
-    columnType?: "json" | "jsonb";
+    columnType?: "json" | "jsonb" | "text[]" | "integer[]" | "boolean[]" | "numeric[]";
     /**
      * The property of this array.
      * You can specify any property (except another Array property)
@@ -639,14 +641,6 @@ export interface MapProperty extends BaseProperty {
      * Properties that are displayed when rendered as a preview
      */
     previewProperties?: string[];
-    /**
-     * Allow the user to add only some keys in this map.
-     * By default, all properties of the map have the corresponding field in
-     * the form view. Setting this flag to true allows to pick only some.
-     * Useful for map that can have a lot of sub-properties that may not be
-     * needed
-     */
-    pickOnlySomeKeys?: boolean;
     /**
      * 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.

package/dist/types/src/types/user_management_delegate.d.ts

@@ -1,4 +1,4 @@
-import { Role, User } from "../users";
+import type { User } from "../users";
 /**
  * Result of creating a new user via admin flow.
  * Contains the created user plus information about how credentials were delivered.
@@ -15,56 +15,46 @@ export interface UserCreationResult<USER extends User = User> {
     temporaryPassword?: string;
 }
 /**
- * Delegate to manage users, roles, and their permissions.
- * This interface allows the CMS to be completely agnostic of the underlying
- * authentication provider or backend.
+ * Delegate to manage auth-specific user operations.
+ *
+ * This interface allows the CMS to be agnostic of the underlying
+ * authentication provider or backend. User/role CRUD is now handled
+ * by the collection system; this delegate only exposes auth-specific
+ * operations (password hashing, invitations, bootstrap).
  *
  * @group Models
  */
 export interface UserManagementDelegate<USER extends User = User> {
     /**
-     * Are the users and roles currently being fetched?
+     * Are auth-related operations currently loading?
      */
     loading: boolean;
     /**
-     * List of users managed by the CMS.
+     * In-memory list of users (used for client-side filtering fallback).
      */
-    users: USER[];
+    users?: USER[];
     /**
-     * Optional error if users failed to load.
+     * Error from fetching the users list, if any.
      */
     usersError?: Error;
     /**
-     * Function to get a user by its uid. This is used to show
-     * user information when assigning ownership of an entity.
-     * @param uid
+     * Look up a single user by UID from the in-memory cache.
      */
-    getUser: (uid: string) => USER | null;
+    getUser?: (uid: string) => USER | null;
     /**
-     * Search users with server-side pagination.
-     * When provided, the CMS will use this for the users table
-     * instead of loading all users into memory.
+     * Server-side user search with pagination.
      */
-    searchUsers?: (options: {
+    searchUsers?: (params: {
         search?: string;
         limit?: number;
         offset?: number;
-        orderBy?: string;
-        orderDir?: "asc" | "desc";
-        roleId?: string;
     }) => Promise<{
         users: USER[];
         total: number;
     }>;
-    /**
-     * Save a user (create or update)
-     * @param user
-     */
-    saveUser?: (user: USER) => Promise<USER>;
     /**
      * Create a new user with invitation/password generation support.
      * Returns additional info about how the credentials were delivered.
-     * Falls back to saveUser if not provided.
      */
     createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
     /**
@@ -73,42 +63,15 @@ export interface UserManagementDelegate<USER extends User = User> {
      * or a flag indicating an email invitation was sent.
      */
     resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
-    /**
-     * Delete a user
-     * @param user
-     */
-    deleteUser?: (user: USER) => Promise<void>;
-    /**
-     * List of roles defined in the CMS.
-     */
-    roles?: Role[];
-    /**
-     * Optional error if roles failed to load.
-     */
-    rolesError?: Error;
-    /**
-     * Save a role (create or update)
-     * @param role
-     */
-    saveRole?: (role: Role) => Promise<void>;
-    /**
-     * Delete a role
-     * @param role
-     */
-    deleteRole?: (role: Role) => Promise<void>;
     /**
      * Is the currently logged in user an admin?
      */
     isAdmin?: boolean;
-    /**
-     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
-     */
-    allowDefaultRolesCreation?: boolean;
     /**
      * Optionally define roles for a given user. This is useful when the roles
      * are coming from a separate provider than the one issuing the tokens.
      */
-    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    defineRolesFor?: (user: USER) => Promise<string[] | undefined> | string[] | undefined;
     /**
      * Whether any admin users exist. Used by the bootstrap banner to decide
      * whether to prompt.  Populated via a lightweight check (e.g. `limit=1`

package/dist/types/src/users/index.d.ts

@@ -1,2 +1 @@
 export * from "./user";
-export * from "./roles";

package/dist/types/src/users/user.d.ts

@@ -35,7 +35,6 @@ export type User = {
     readonly isAnonymous: boolean;
     /**
      * Role IDs assigned to this user (e.g. ["admin", "editor"]).
-     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
      */
     roles?: string[];
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-core",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Database-Agnostic Backend Core for Rebase",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -54,10 +54,10 @@
     "ts-morph": "27.0.2",
     "ws": "^8.20.1",
     "zod": "^3.25.76",
-    "@rebasepro/common": "0.3.0",
-    "@rebasepro/types": "0.3.0",
-    "@rebasepro/client": "0.3.0",
-    "@rebasepro/utils": "0.3.0"
+    "@rebasepro/common": "0.5.0",
+    "@rebasepro/client": "0.5.0",
+    "@rebasepro/types": "0.5.0",
+    "@rebasepro/utils": "0.5.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/api/errors.ts

@@ -70,13 +70,32 @@ export interface ErrorResponse {
     };
 }
 
+/**
+ * General shape of errors that flow through the API error handler.
+ * Extends Error with optional HTTP status, error code, and details.
+ */
+export interface RebaseApiError extends Error {
+    statusCode?: number;
+    code?: string;
+    details?: unknown;
+}
+
+/**
+ * Type guard for errors that carry optional API metadata (statusCode, code, details).
+ * Returns true for any Error instance — the optional properties are then
+ * checked via normal property access.
+ */
+export function isRebaseApiError(error: unknown): error is RebaseApiError {
+    return error instanceof Error;
+}
+
 /**
  * Hono error-handling middleware (`app.onError`).
  * Converts any error into the canonical `{ error: { message, code } }` shape.
  */
 export const errorHandler: ErrorHandler = (err, c) => {
     // Typecast custom error properties
-    const error = err as Error & { statusCode?: number; code?: string; details?: unknown, name?: string };
+    const error: RebaseApiError = err;
 
     if (error instanceof ApiError || error.name === "ApiError") {
         // Operational errors — log at warn level

package/src/api/openapi-generator.ts

@@ -314,7 +314,7 @@ content: { "application/json": { schema: { $ref: "#/components/schemas/ErrorResp
         };
 
         // ── Subcollection routes ──────────────────────────────────────
-        const relations = (collection as EntityCollection & { relations?: Relation[] }).relations;
+        const relations = collection.relations;
         if (relations && relations.length > 0) {
             for (const relation of relations) {
                 const relationName = relation.relationName;

package/src/api/rest/api-generator.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { DataDriver, Entity, EntityCollection, FetchCollectionProps, DataHooks, BackendHookContext, RestFetchService } from "@rebasepro/types";
 import { QueryOptions, HonoEnv } from "../types";
-import { ApiError } from "../errors";
+import { ApiError, isRebaseApiError } from "../errors";
 import { parseQueryOptions } from "./query-parser";
 import { httpMethodToOperation, isOperationAllowed } from "../../auth/api-keys/api-key-permission-guard";
 import type { ApiKeyMasked } from "../../auth/api-keys/api-key-types";
@@ -87,9 +87,9 @@ export class RestApiGenerator {
         // GET /collection/count - Count entities (with optional filters)
         this.router.get(`${basePath}/count`, async (c) => {
             this.enforceApiKeyPermission(c, collection.slug);
-            const queryDict = c.req.query();
+            const queryDict = c.req.queries();
             const queryOptions = parseQueryOptions(queryDict);
-            const searchString = queryDict.searchString as string | undefined;
+            const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : undefined;
             const driver = c.get("driver") || this.driver;
 
             const total = await this.countRawEntities(driver, resolvedCollection, queryOptions, searchString);
@@ -99,9 +99,9 @@ export class RestApiGenerator {
         // GET /collection - List entities
         this.router.get(basePath, async (c) => {
             this.enforceApiKeyPermission(c, collection.slug);
-            const queryDict = c.req.query();
+            const queryDict = c.req.queries();
             const queryOptions = parseQueryOptions(queryDict);
-            const searchString = queryDict.searchString as string | undefined;
+            const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : undefined;
 
             const driver = c.get("driver") || this.driver;
             const fetchService = this.getFetchService(driver);
@@ -161,7 +161,7 @@ export class RestApiGenerator {
         this.router.get(`${basePath}/:id`, async (c) => {
             this.enforceApiKeyPermission(c, collection.slug);
             const id = c.req.param("id");
-            const queryDict = c.req.query();
+            const queryDict = c.req.queries();
             const queryOptions = parseQueryOptions(queryDict);
             const driver = c.get("driver") || this.driver;
             const fetchService = this.getFetchService(driver);
@@ -234,9 +234,10 @@ export class RestApiGenerator {
 
                 return c.json(response, 201);
             } catch (error) {
-                const err = error as Error & { code?: string };
-                err.code = err.code || "BAD_REQUEST";
-                throw err;
+                if (isRebaseApiError(error) && !error.code) {
+                    error.code = "BAD_REQUEST";
+                }
+                throw error;
             }
         });
 
@@ -282,9 +283,10 @@ export class RestApiGenerator {
 
                 return c.json(response);
             } catch (error) {
-                const err = error as Error & { code?: string };
-                err.code = err.code || "BAD_REQUEST";
-                throw err;
+                if (isRebaseApiError(error) && !error.code) {
+                    error.code = "BAD_REQUEST";
+                }
+                throw error;
             }
         });
 
@@ -386,15 +388,18 @@ entityId };
 
             this.enforceApiKeyPermission(c, c.req.param("parent"));
 
+            const hookCtx = this.buildHookContext(c, "GET");
+
             if (parsed.entityId === "count") {
                 // GET /parent/:parentId/child/count — count child entities
-                const queryDict = c.req.query();
+                const queryDict = c.req.queries();
                 const queryOptions = parseQueryOptions(queryDict);
+                const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : undefined;
                 
                 const total = driver.countEntities ? await driver.countEntities({
                     path: parsed.collectionPath,
                     filter: queryOptions.where as FetchCollectionProps["filter"],
-                    searchString: queryDict.searchString as string | undefined
+                    searchString
                 }) : 0;
                 
                 return c.json({ count: total });
@@ -405,26 +410,42 @@ entityId };
                     entityId: parsed.entityId
                 });
                 if (!entity) throw ApiError.notFound("Entity not found");
-                return c.json(this.flattenEntity(entity));
+
+                const flatResult = this.flattenEntity(entity);
+                const hookResult = await this.applyAfterRead(c.req.param("parent"), flatResult, hookCtx);
+                if (!hookResult) throw ApiError.notFound("Entity not found");
+
+                return c.json(hookResult);
             } else {
                 // GET /parent/:parentId/child — list entities
-                const queryDict = c.req.query();
+                const queryDict = c.req.queries();
                 const queryOptions = parseQueryOptions(queryDict);
+                const searchString = Array.isArray(queryDict.searchString) ? queryDict.searchString[queryDict.searchString.length - 1] : undefined;
                 const entities = await driver.fetchCollection({
                     path: parsed.collectionPath,
                     filter: queryOptions.where as FetchCollectionProps["filter"],
                     limit: queryOptions.limit,
                     orderBy: queryOptions.orderBy?.[0]?.field,
                     order: queryOptions.orderBy?.[0]?.direction === "desc" ? "desc" : "asc",
-                    searchString: queryDict.searchString as string | undefined
+                    searchString
                 });
+
+                let flatEntities = entities.map(e => this.flattenEntity(e));
+                flatEntities = await this.applyAfterReadBatch(c.req.param("parent"), flatEntities, hookCtx);
+
+                const total = driver.countEntities ? await driver.countEntities({
+                    path: parsed.collectionPath,
+                    filter: queryOptions.where as FetchCollectionProps["filter"],
+                    searchString
+                }) : flatEntities.length;
+
                 return c.json({
-                    data: entities.map(e => this.flattenEntity(e)),
+                    data: flatEntities,
                     meta: {
-                        total: entities.length,
+                        total,
                         limit: queryOptions.limit,
                         offset: queryOptions.offset,
-                        hasMore: false
+                        hasMore: (queryOptions.offset || 0) + flatEntities.length < total
                     }
                 });
             }
@@ -439,9 +460,14 @@ entityId };
             if (!parsed || parsed.entityId) return next();
 
             const driver = c.get("driver") || this.driver;
+            const hookCtx = this.buildHookContext(c, "POST");
 
             this.enforceApiKeyPermission(c, c.req.param("parent"));
-            const body = await c.req.json().catch(() => ({}));
+            let body = await c.req.json().catch(() => ({}));
+
+            if (this.dataHooks?.beforeSave) {
+                body = await this.dataHooks.beforeSave(parsed.collectionPath, body, undefined, hookCtx);
+            }
 
             const entity = await driver.saveEntity({
                 path: parsed.collectionPath,
@@ -449,7 +475,15 @@ entityId };
                 status: "new"
             });
 
-            return c.json(this.formatResponse(entity), 201);
+            const response = this.formatResponse(entity);
+
+            if (this.dataHooks?.afterSave) {
+                Promise.resolve(this.dataHooks.afterSave(parsed.collectionPath, response as Record<string, unknown>, hookCtx)).catch(err => {
+                    console.error("[BackendHooks] data.afterSave error:", err instanceof Error ? err.message : err);
+                });
+            }
+
+            return c.json(response, 201);
         });
 
         // PUT /<subcollection-path>/:id — update entity
@@ -461,10 +495,15 @@ entityId };
             if (!parsed || !parsed.entityId) return next();
 
             const driver = c.get("driver") || this.driver;
+            const hookCtx = this.buildHookContext(c, "PUT");
 
             this.enforceApiKeyPermission(c, c.req.param("parent"));
 
-            const body = await c.req.json().catch(() => ({}));
+            let body = await c.req.json().catch(() => ({}));
+
+            if (this.dataHooks?.beforeSave) {
+                body = await this.dataHooks.beforeSave(parsed.collectionPath, body, parsed.entityId, hookCtx);
+            }
 
             const entity = await driver.saveEntity({
                 path: parsed.collectionPath,
@@ -473,7 +512,15 @@ entityId };
                 status: "existing"
             });
 
-            return c.json(this.formatResponse(entity));
+            const response = this.formatResponse(entity);
+
+            if (this.dataHooks?.afterSave) {
+                Promise.resolve(this.dataHooks.afterSave(parsed.collectionPath, response as Record<string, unknown>, hookCtx)).catch(err => {
+                    console.error("[BackendHooks] data.afterSave error:", err instanceof Error ? err.message : err);
+                });
+            }
+
+            return c.json(response);
         });
 
         // DELETE /<subcollection-path>/:id — delete entity
@@ -485,6 +532,7 @@ entityId };
             if (!parsed || !parsed.entityId) return next();
 
             const driver = c.get("driver") || this.driver;
+            const hookCtx = this.buildHookContext(c, "DELETE");
 
             this.enforceApiKeyPermission(c, c.req.param("parent"));
 
@@ -495,8 +543,18 @@ entityId };
 
             if (!existingEntity) throw ApiError.notFound("Entity not found");
 
+            if (this.dataHooks?.beforeDelete) {
+                await this.dataHooks.beforeDelete(parsed.collectionPath, parsed.entityId, hookCtx);
+            }
+
             await driver.deleteEntity({ entity: existingEntity });
 
+            if (this.dataHooks?.afterDelete) {
+                Promise.resolve(this.dataHooks.afterDelete(parsed.collectionPath, parsed.entityId, hookCtx)).catch(err => {
+                    console.error("[BackendHooks] data.afterDelete error:", err instanceof Error ? err.message : err);
+                });
+            }
+
             return new Response(null, { status: 204 });
         });
     }