@rebasepro/admin 0.0.1-canary.eae7889 → 0.0.1-canary.eb08332

package/src/form/validation.ts

@@ -1,5 +1,5 @@
 import type { Properties } from "@rebasepro/types";
-import type { ArrayProperty, MapProperty, NumberProperty, Property, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty, StringProperty } from "@rebasepro/types";
+import type { ArrayProperty, MapProperty, NumberProperty, Property, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty, StringProperty, VectorProperty, BinaryProperty } from "@rebasepro/types";
 ;
 import { z, ZodTypeAny } from "zod";
 import { enumToObjectEntries, isPropertyBuilder } from "@rebasepro/common";
@@ -7,7 +7,7 @@ import { getValueInPath, hydrateRegExp } from "@rebasepro/utils";
 
 export type CustomFieldValidator = (props: {
     name: string,
-    value: any,
+    value: unknown,
     property: Property,
     entityId?: string | number,
     parentProperty?: MapProperty | ArrayProperty,
@@ -18,13 +18,13 @@ interface PropertyContext<P extends Property> {
     parentProperty?: MapProperty | ArrayProperty,
     entityId?: string | number,
     customFieldValidator?: CustomFieldValidator,
-    name?: any
+    name?: string
 }
 
 export function getEntitySchema<M extends Record<string, unknown>>(
     entityId: string | number | undefined,
     properties: Properties,
-    customFieldValidator?: CustomFieldValidator): z.ZodObject<any> {
+    customFieldValidator?: CustomFieldValidator): z.ZodObject<Record<string, ZodTypeAny>> {
     const shape: Record<string, ZodTypeAny> = {};
     Object.entries(properties as Record<string, Property>)
         .forEach(([name, property]) => {
@@ -74,11 +74,15 @@ export function mapPropertyToZod(propertyContext: PropertyContext<Property>): Zo
         return getZodReferenceSchema(propertyContext as PropertyContext<ReferenceProperty>);
     } else if (property.type === "relation") {
         return getZodRelationSchema(propertyContext as PropertyContext<RelationProperty>);
+    } else if (property.type === "vector") {
+        return getZodVectorSchema(propertyContext as PropertyContext<VectorProperty>);
+    } else if (property.type === "binary") {
+        return getZodBinarySchema(propertyContext as PropertyContext<BinaryProperty>);
     }
 
     // Log the error but don't crash the form
     console.error("Unsupported data type in zod mapping", property);
-    const dataType = "dataType" in (property as unknown as Record<string, unknown>) ? String((property as unknown as Record<string, unknown>).dataType) : "unknown";
+    const dataType = "dataType" in (property as Record<string, unknown>) ? String((property as Record<string, unknown>).dataType) : "unknown";
     return z.any().refine(
         () => false,
         { message: `Unsupported data type: ${dataType}` }
@@ -149,14 +153,14 @@ function getZodStringSchema({
         const allowedValues = (isRequired ? entries : [...entries, null])
             .map((enumValueConfig) => enumValueConfig?.id ?? null);
         schema = schema.refine(
-            (value: any) => allowedValues.includes(value),
+            (value: unknown) => allowedValues.includes(value as string | null),
             { message: `Must be one of: ${allowedValues.filter(Boolean).join(", ")}` }
         );
     }
 
     if (isRequired && !property.enum) {
         schema = schema.refine(
-            (value: any) => value !== undefined && value !== null && value !== "",
+            (value: unknown) => value !== undefined && value !== null && value !== "",
             { message: validation?.requiredMessage ? validation.requiredMessage : "Required" }
         );
     }
@@ -164,36 +168,36 @@ function getZodStringSchema({
     if (validation) {
 
         if (validation.min || validation.min === 0) schema = schema.refine(
-            (value: any) => value == null || value.length >= validation.min!,
+            (value: unknown) => value == null || (typeof value === "string" && value.length >= validation.min!),
             { message: `${property.name} must be min ${validation.min} characters long` }
         );
         if (validation.max || validation.max === 0) schema = schema.refine(
-            (value: any) => value == null || value.length <= validation.max!,
+            (value: unknown) => value == null || (typeof value === "string" && value.length <= validation.max!),
             { message: `${property.name} must be max ${validation.max} characters long` }
         );
         if (validation.matches) {
             const regExp = typeof validation.matches === "string" ? hydrateRegExp(validation.matches) : validation.matches;
             if (regExp) {
                 schema = schema.refine(
-                    (value: any) => value == null || regExp.test(value),
+                    (value: unknown) => value == null || (typeof value === "string" && regExp.test(value)),
                     { message: validation.matchesMessage ?? "Invalid format" }
                 );
             }
         }
-        if (validation.trim) schema = z.preprocess((v: any) => typeof v === "string" ? v.trim() : v, schema);
-        if (validation.lowercase) schema = z.preprocess((v: any) => typeof v === "string" ? v.toLowerCase() : v, schema);
-        if (validation.uppercase) schema = z.preprocess((v: any) => typeof v === "string" ? v.toUpperCase() : v, schema);
+        if (validation.trim) schema = z.preprocess((v: unknown) => typeof v === "string" ? v.trim() : v, schema);
+        if (validation.lowercase) schema = z.preprocess((v: unknown) => typeof v === "string" ? v.toLowerCase() : v, schema);
+        if (validation.uppercase) schema = z.preprocess((v: unknown) => typeof v === "string" ? v.toUpperCase() : v, schema);
         if (property.email) schema = schema.refine(
-            (value: any) => value == null || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+            (value: unknown) => value == null || (typeof value === "string" && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)),
             { message: `${property.name} must be an email` }
         );
-        if (property.url) {
+        if (property.ui?.url) {
             if (!property.storage || property.storage?.storeUrl) {
                 schema = schema.refine(
-                    (value: any) => {
+                    (value: unknown) => {
                         if (value == null) return true;
                         try {
-                            new URL(value);
+                            new URL(value as string);
                             return true;
                         } catch {
                             return false;
@@ -225,14 +229,14 @@ function getZodNumberSchema({
             const n = Number(val);
             return isNaN(n) ? val : n; // pass through non-numeric to let refine catch it
         },
-        z.number({ invalid_type_error: "Must be a number" }).nullable()
+        z.number({ error: "Must be a number" }).nullable()
     );
 
     const isRequired = validation?.required || property.isId === true || property.isId === "manual";
 
     if (isRequired) {
         schema = schema.refine(
-            (value: any) => value !== undefined && value !== null,
+            (value: unknown) => value !== undefined && value !== null,
             { message: validation?.requiredMessage ? validation.requiredMessage : "Required" }
         );
     }
@@ -240,31 +244,31 @@ function getZodNumberSchema({
     if (validation) {
 
         if (validation.min || validation.min === 0) schema = schema.refine(
-            (value: any) => value == null || value >= validation.min!,
+            (value: unknown) => value == null || (typeof value === "number" && value >= validation.min!),
             { message: `${property.name} must be higher or equal to ${validation.min}` }
         );
         if (validation.max || validation.max === 0) schema = schema.refine(
-            (value: any) => value == null || value <= validation.max!,
+            (value: unknown) => value == null || (typeof value === "number" && value <= validation.max!),
             { message: `${property.name} must be lower or equal to ${validation.max}` }
         );
         if (validation.lessThan || validation.lessThan === 0) schema = schema.refine(
-            (value: any) => value == null || value < validation.lessThan!,
+            (value: unknown) => value == null || (typeof value === "number" && value < validation.lessThan!),
             { message: `${property.name} must be higher than ${validation.lessThan}` }
         );
         if (validation.moreThan || validation.moreThan === 0) schema = schema.refine(
-            (value: any) => value == null || value > validation.moreThan!,
+            (value: unknown) => value == null || (typeof value === "number" && value > validation.moreThan!),
             { message: `${property.name} must be lower than ${validation.moreThan}` }
         );
         if (validation.positive) schema = schema.refine(
-            (value: any) => value == null || value > 0,
+            (value: unknown) => value == null || (typeof value === "number" && value > 0),
             { message: `${property.name} must be positive` }
         );
         if (validation.negative) schema = schema.refine(
-            (value: any) => value == null || value < 0,
+            (value: unknown) => value == null || (typeof value === "number" && value < 0),
             { message: `${property.name} must be negative` }
         );
         if (validation.integer) schema = schema.refine(
-            (value: any) => value == null || Number.isInteger(value),
+            (value: unknown) => value == null || (typeof value === "number" && Number.isInteger(value)),
             { message: `${property.name} must be an integer` }
         );
     }
@@ -284,7 +288,7 @@ function getZodGeoPointSchema({
 
     if (validation?.required) {
         schema = schema.refine(
-            (value: any) => value !== undefined && value !== null,
+            (value: unknown) => value !== undefined && value !== null,
             { message: validation.requiredMessage ? validation.requiredMessage : "Required" }
         );
     }
@@ -311,17 +315,17 @@ function getZodDateSchema({
     if (validation) {
         if (validation.required) {
             schema = schema.refine(
-                (value: any) => value !== undefined && value !== null,
+                (value: unknown) => value !== undefined && value !== null,
                 { message: validation?.requiredMessage ? validation.requiredMessage : "Required" }
             );
         }
 
         if (validation.min) schema = schema.refine(
-            (value: any) => value == null || value >= validation.min!,
+            (value: unknown) => value == null || (value instanceof Date && value >= validation.min!),
             { message: `${property.name} must be after ${validation.min}` }
         );
         if (validation.max) schema = schema.refine(
-            (value: any) => value == null || value <= validation.max!,
+            (value: unknown) => value == null || (value instanceof Date && value <= validation.max!),
             { message: `${property.name} must be before ${validation.min}` }
         );
     }
@@ -341,7 +345,7 @@ function getZodReferenceSchema({
     if (validation) {
         if (validation.required) {
             schema = schema.refine(
-                (value: any) => value !== undefined && value !== null,
+                (value: unknown) => value !== undefined && value !== null,
                 { message: validation?.requiredMessage ? validation.requiredMessage : "Required" }
             );
         }
@@ -366,7 +370,7 @@ function getZodRelationSchema({
     if (validation) {
         if (validation.required) {
             schema = schema.refine(
-                (value: any) => {
+                (value: unknown) => {
                     if (isMany) {
                         return value !== undefined && value !== null && Array.isArray(value) && value.length > 0;
                     }
@@ -393,7 +397,7 @@ function getZodBooleanSchema({
     if (validation) {
         if (validation.required) {
             schema = schema.refine(
-                (value: any) => value !== undefined && value !== null,
+                (value: unknown) => value !== undefined && value !== null,
                 { message: validation?.requiredMessage ? validation.requiredMessage : "Required" }
             );
         }
@@ -442,17 +446,19 @@ function getZodArraySchema({
             });
             arraySchema = z.array(
                 z.any().superRefine(async (object, ctx) => {
-                    // Find the matching schema from zodProperties based on the path
-                    const parentPath = ctx.path.slice(0, -1).join(".");
-                    const index = ctx.path[ctx.path.length - 1];
-                    const key = parentPath ? `${parentPath}[${index}]` : `${name}[${index}]`;
-                    const zodProperty = getValueInPath(zodProperties, key) as ZodTypeAny | undefined;
-                    if (zodProperty) {
-                        const result = await zodProperty.safeParseAsync(object);
-                        if (!result.success) {
-                            result.error.issues.forEach((issue) => {
-                                ctx.addIssue(issue);
-                            });
+                    // In Zod v4, ctx.path is not available in superRefine.
+                    // Instead, iterate all zodProperties and validate against each.
+                    for (const [key, zodProperty] of Object.entries(zodProperties)) {
+                        if (zodProperty) {
+                            const result = await (zodProperty as ZodTypeAny).safeParseAsync(object);
+                            if (!result.success) {
+                                result.error.issues.forEach((issue) => {
+                                    ctx.addIssue({
+                                        code: "custom",
+                                        message: issue.message
+                                    });
+                                });
+                            }
                         }
                     }
                 })
@@ -476,13 +482,13 @@ function getZodArraySchema({
             if (arrayUniqueFields) {
                 if (typeof arrayUniqueFields === "boolean") {
                     arraySchema = arraySchema.refine(
-                        (values: any) => !values || values.length === new Set(values.map((v: any) => v)).size,
+                        (values: unknown) => !values || !Array.isArray(values) || values.length === new Set(values).size,
                         { message: `${property.name} should have unique values within the array` }
                     );
                 } else if (Array.isArray(arrayUniqueFields)) {
                     arrayUniqueFields.forEach(([fieldName, childProperty]) => {
                         arraySchema = arraySchema.refine(
-                            (values: any) => !values || values.length === new Set(values.map((v: any) => v && v[fieldName])).size,
+                            (values: unknown) => !values || !Array.isArray(values) || values.length === new Set(values.map((v: unknown) => v && typeof v === "object" ? (v as Record<string, unknown>)[fieldName] : v)).size,
                             { message: `${property.name} → ${childProperty.name ?? fieldName}: should have unique values within the array` }
                         );
                     });
@@ -495,25 +501,73 @@ function getZodArraySchema({
     if (validation) {
         if (validation.required) {
             arraySchema = arraySchema.refine(
-                (value: any) => value !== undefined && value !== null && value.length > 0,
+                (value: unknown) => value !== undefined && value !== null && Array.isArray(value) && value.length > 0,
                 { message: validation?.requiredMessage ? validation.requiredMessage : "Required" }
             );
         }
         if (validation.min || validation.min === 0) arraySchema = arraySchema.refine(
-            (value: any) => !value || value.length >= validation.min!,
+            (value: unknown) => !value || !Array.isArray(value) || value.length >= validation.min!,
             { message: `${property.name} should be min ${validation.min} entries long` }
         );
         if (validation.max) arraySchema = arraySchema.refine(
-            (value: any) => !value || value.length <= validation.max!,
+            (value: unknown) => !value || !Array.isArray(value) || value.length <= validation.max!,
             { message: `${property.name} should be max ${validation.max} entries long` }
         );
         // Handle uniqueInArray at the array level
         if (validation.uniqueInArray) {
             arraySchema = arraySchema.refine(
-                (values: any) => !values || values.length === new Set(values.map((v: any) => v)).size,
+                (values: unknown) => !values || !Array.isArray(values) || values.length === new Set(values).size,
                 { message: `${property.name} should have unique values within the array` }
             );
         }
     }
     return arraySchema;
 }
+
+function getZodVectorSchema({
+    property
+}: PropertyContext<VectorProperty>): ZodTypeAny {
+    let schema: ZodTypeAny = z.preprocess(
+        (val: unknown) => {
+            if (val && typeof val === "object" && "__type" in val && (val as Record<string, unknown>).__type === "Vector") {
+                return (val as Record<string, unknown>).value;
+            }
+            if (val && typeof val === "object" && "value" in val && Array.isArray((val as Record<string, unknown>).value)) {
+                return (val as Record<string, unknown>).value;
+            }
+            return val;
+        },
+        z.array(z.number()).nullable().optional()
+    );
+
+    if (property.dimensions) {
+        schema = schema.refine(
+            (val: unknown) => val === null || val === undefined || (Array.isArray(val) && val.length === property.dimensions),
+            { message: `${property.name ?? "Vector"} must have exactly ${property.dimensions} dimensions` }
+        );
+    }
+
+    if (property.validation?.required) {
+        schema = schema.refine(
+            (val: unknown) => val !== null && val !== undefined && Array.isArray(val) && val.length > 0,
+            { message: property.validation?.requiredMessage ?? "Required" }
+        );
+    }
+
+    return schema;
+}
+
+function getZodBinarySchema({
+    property
+}: PropertyContext<BinaryProperty>): ZodTypeAny {
+    let schema: ZodTypeAny = z.string().nullable().optional();
+    const validation = property.validation;
+
+    if (validation?.required) {
+        schema = schema.nullable().optional().refine(
+            (value: unknown) => value !== undefined && value !== null && value !== "",
+            { message: validation.requiredMessage ? validation.requiredMessage : "Required" }
+        );
+    }
+    return schema;
+}

package/src/hooks/index.ts

@@ -1,8 +1,8 @@
-export * from "./useSideEntityController";
-export * from "./useEntitySelectionDialog";
-export * from "./useBuildSideEntityController";
+export * from "./useSidePanel";
+export * from "./useSelectionDialog";
+export * from "./useBuildSidePanel";
 export * from "./useResolvedNavigationFrom";
-export * from "./useEntityHistory";
+export * from "./useHistory";
 export * from "./navigation/contexts";
 export * from "./navigation/useBuildCollectionRegistryController";
 export * from "./navigation/useBuildNavigationStateController";

package/src/hooks/navigation/contexts/CollectionRegistryContext.tsx

@@ -1,17 +1,18 @@
-import type { EntityCollection } from "@rebasepro/types";
+import type { CollectionConfig } from "@rebasepro/types";
 import React, { createContext } from "react";
-import { CollectionRegistryController, EntityReference } from "@rebasepro/types";
+import { CollectionRegistryController } from "@rebasepro/types";
 
 export const CollectionRegistryContext = createContext<CollectionRegistryController>({
     getCollection: () => undefined,
     getRawCollection: () => undefined,
     getParentReferencesFromPath: () => [],
-    getParentCollectionIds: () => [],
+    getParentCollectionSlugs: () => [],
+    getParentEntityIds: () => [],
     convertIdsToPaths: () => [],
     initialised: false
 });
 
-export function useCollectionRegistryController<DB = Record<string, unknown>, EC extends EntityCollection = EntityCollection<any>>(): CollectionRegistryController<DB, EC> {
+export function useCollectionRegistryController<DB = Record<string, unknown>, EC extends CollectionConfig = CollectionConfig>(): CollectionRegistryController<DB, EC> {
     const context = React.useContext(CollectionRegistryContext);
     if (context === undefined) {
         throw new Error("useCollectionRegistryController must be used within a CollectionRegistryContext.Provider");

package/src/hooks/navigation/contexts/NavigationStateContext.tsx

@@ -1,6 +1,6 @@
-import type { NavigationStateController, AppView, NavigationResult, RebasePlugin } from "@rebasepro/types";
+import type { NavigationStateController } from "@rebasepro/types";
 import React, { createContext } from "react";
-;
+
 
 export const NavigationStateContext = createContext<NavigationStateController>({
     loading: true,

package/src/hooks/navigation/contexts/UrlContext.tsx

@@ -1,8 +1,7 @@
 import type { UrlController } from "@rebasepro/types";
 import React, { createContext } from "react";
-import { NavigateOptions } from "react-router-dom";
 
-;
+
 
 export const UrlContext = createContext<UrlController>({
     basePath: "/",

package/src/hooks/navigation/useAsyncResolver.ts

@@ -0,0 +1,100 @@
+import { useCallback, useEffect, useRef, useState, useMemo } from "react";
+
+export type UseAsyncResolverResult<T> = {
+    data: T;
+    loading: boolean;
+    error: Error | undefined;
+    refresh: () => void;
+};
+
+/**
+ * Generic hook that resolves an async value with loading/error/refresh
+ * state management, cancellation on unmount or deps change, and
+ * ref-based change detection to prevent unnecessary state updates.
+ *
+ * Extracted from the common pattern in useResolvedCollections and
+ * useResolvedViews.
+ */
+export function useAsyncResolver<T>({
+    resolver,
+    initialValue,
+    isEqual,
+    deps,
+    disabled,
+}: {
+    /** Async function that resolves the data */
+    resolver: () => Promise<T>;
+    /** Initial value before first resolution */
+    initialValue: T;
+    /** Equality check to prevent unnecessary state updates */
+    isEqual: (a: T, b: T) => boolean;
+    /** Effect dependencies — when these change, resolver re-runs */
+    deps: React.DependencyList;
+    /** When true, skip resolution */
+    disabled?: boolean;
+}): UseAsyncResolverResult<T> {
+
+    const [data, setData] = useState<T>(initialValue);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<Error | undefined>(undefined);
+    const [refreshTrigger, setRefreshTrigger] = useState(0);
+
+    const refresh = useCallback(() => {
+        setRefreshTrigger(prev => prev + 1);
+    }, []);
+
+    // Ref for change detection — avoids state updates when data hasn't changed
+    const dataRef = useRef<T>(initialValue);
+
+    // Store resolver in a ref so we always call the latest version
+    // without adding it to effect deps (it's typically a new closure each render)
+    const resolverRef = useRef(resolver);
+    resolverRef.current = resolver;
+
+    // Same for isEqual
+    const isEqualRef = useRef(isEqual);
+    isEqualRef.current = isEqual;
+
+    useEffect(() => {
+        if (disabled) return;
+
+        let cancelled = false;
+
+        (async () => {
+            try {
+                const result = await resolverRef.current();
+
+                if (cancelled) return;
+
+                // Only update state if data actually changed
+                if (!isEqualRef.current(dataRef.current, result)) {
+                    dataRef.current = result;
+                    setData(result);
+                }
+
+                setError(undefined);
+            } catch (e) {
+                if (!cancelled) {
+                    console.error(e);
+                    setError(e as Error);
+                }
+            } finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        })();
+
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...deps, refreshTrigger, disabled]);
+
+    return useMemo(() => ({
+        data,
+        loading,
+        error,
+        refresh
+    }), [data, loading, error, refresh]);
+}