@questpie/admin 1.1.1 → 3.0.0

package/dist/client/builder/types/action-registry.mjs

@@ -0,0 +1,276 @@
+import { buildPrefillUrl } from "../../hooks/use-prefill-params.mjs";
+
+//#region src/client/builder/types/action-registry.ts
+/**
+* Create a "Create" action
+*/
+function createCreateAction(opts) {
+	return {
+		id: "create",
+		label: {
+			key: "action.create",
+			fallback: "Create"
+		},
+		icon: {
+			type: "icon",
+			props: { name: "ph:plus" }
+		},
+		variant: "default",
+		handler: {
+			type: "navigate",
+			path: "create"
+		},
+		...opts
+	};
+}
+/**
+* Create a "Duplicate" action (bulk action, shows only when 1 item selected)
+*/
+function createDuplicateAction(opts) {
+	return {
+		id: "duplicate",
+		label: {
+			key: "action.duplicate",
+			fallback: "Duplicate"
+		},
+		icon: {
+			type: "icon",
+			props: { name: "ph:copy" }
+		},
+		variant: "ghost",
+		visible: (ctx) => {
+			if (Array.isArray(ctx.item)) return ctx.item.length === 1;
+			return !!ctx.item;
+		},
+		handler: {
+			type: "custom",
+			fn: async (ctx) => {
+				const item = Array.isArray(ctx.item) ? ctx.item[0] : ctx.item;
+				if (!item) return;
+				const { id, createdAt, updatedAt, ...data } = item;
+				const prefillUrl = buildPrefillUrl(`${ctx.helpers.basePath}/collections/${ctx.collection}/create`, data);
+				ctx.helpers.navigate(prefillUrl);
+			}
+		},
+		...opts
+	};
+}
+/**
+* Create a "Delete Many" (bulk delete) action
+*
+* Note: The actual deletion is handled by BulkActionToolbar via onBulkDelete callback.
+* This action definition just configures the UI and confirmation.
+*/
+function createDeleteManyAction(opts) {
+	return {
+		id: "deleteMany",
+		label: {
+			key: "action.deleteSelected",
+			fallback: "Delete Selected"
+		},
+		icon: {
+			type: "icon",
+			props: { name: "ph:trash" }
+		},
+		variant: "destructive",
+		confirmation: {
+			title: {
+				key: "confirm.deleteSelectedTitle",
+				fallback: "Delete selected items?"
+			},
+			description: {
+				key: "confirm.deleteSelectedDescription",
+				fallback: "This action cannot be undone. All selected items will be permanently deleted."
+			},
+			confirmLabel: {
+				key: "confirm.deleteAll",
+				fallback: "Delete All"
+			},
+			destructive: true
+		},
+		handler: {
+			type: "custom",
+			fn: async () => {}
+		},
+		...opts
+	};
+}
+/**
+* Create a "Restore" action for a single soft-deleted item
+*/
+function createRestoreAction(opts) {
+	return {
+		id: "restore",
+		label: {
+			key: "action.restore",
+			fallback: "Restore"
+		},
+		icon: {
+			type: "icon",
+			props: { name: "ph:arrow-counter-clockwise" }
+		},
+		variant: "secondary",
+		visible: (ctx) => {
+			const item = ctx.item;
+			if (Array.isArray(item)) return false;
+			return !!item?.deletedAt;
+		},
+		confirmation: {
+			title: {
+				key: "confirm.restoreItemTitle",
+				fallback: "Restore item?"
+			},
+			description: {
+				key: "confirm.restoreItemDescription",
+				fallback: "This item will become visible in normal list views again."
+			},
+			confirmLabel: {
+				key: "action.restore",
+				fallback: "Restore"
+			},
+			destructive: false
+		},
+		handler: {
+			type: "api",
+			endpoint: "{id}/restore",
+			method: "POST"
+		},
+		...opts
+	};
+}
+/**
+* Create a "Restore Many" (bulk restore) action
+*/
+function createRestoreManyAction(opts) {
+	return {
+		id: "restoreMany",
+		label: {
+			key: "action.restoreSelected",
+			fallback: "Restore Selected"
+		},
+		icon: {
+			type: "icon",
+			props: { name: "ph:arrow-counter-clockwise" }
+		},
+		variant: "secondary",
+		visible: (ctx) => {
+			return (Array.isArray(ctx.item) ? ctx.item : []).some((item) => !!item?.deletedAt);
+		},
+		confirmation: {
+			title: {
+				key: "confirm.restoreSelectedTitle",
+				fallback: "Restore selected items?"
+			},
+			description: {
+				key: "confirm.restoreSelectedDescription",
+				fallback: "Selected items will be restored and visible again."
+			},
+			confirmLabel: {
+				key: "confirm.restoreAll",
+				fallback: "Restore All"
+			},
+			destructive: false
+		},
+		handler: {
+			type: "custom",
+			fn: async () => {}
+		},
+		...opts
+	};
+}
+/**
+* Create a "Delete" action for single item (form view)
+*/
+function createDeleteAction(opts) {
+	return {
+		id: "delete",
+		label: {
+			key: "action.delete",
+			fallback: "Delete"
+		},
+		icon: {
+			type: "icon",
+			props: { name: "ph:trash" }
+		},
+		variant: "destructive",
+		confirmation: {
+			title: {
+				key: "confirm.deleteItemTitle",
+				fallback: "Delete item?"
+			},
+			description: {
+				key: "confirm.deleteItemDescription",
+				fallback: "This action cannot be undone. The item will be permanently deleted."
+			},
+			confirmLabel: {
+				key: "action.delete",
+				fallback: "Delete"
+			},
+			destructive: true
+		},
+		handler: {
+			type: "api",
+			endpoint: "{id}",
+			method: "DELETE"
+		},
+		...opts
+	};
+}
+/**
+* Creates an action registry proxy for type-safe action building
+*/
+function createActionRegistryProxy() {
+	return {
+		create: (opts) => createCreateAction(opts),
+		duplicate: (opts) => createDuplicateAction(opts),
+		delete: (opts) => createDeleteAction(opts),
+		deleteMany: (opts) => createDeleteManyAction(opts),
+		restore: (opts) => createRestoreAction(opts),
+		restoreMany: (opts) => createRestoreManyAction(opts),
+		action: (def) => def
+	};
+}
+/**
+* Get default header actions for a collection
+*/
+function getDefaultHeaderActions() {
+	return {
+		primary: [createCreateAction()],
+		secondary: []
+	};
+}
+/**
+* Get default bulk actions for a collection
+*/
+function getDefaultBulkActions() {
+	return [
+		createDeleteManyAction(),
+		createRestoreManyAction(),
+		createDuplicateAction()
+	];
+}
+/**
+* Get default form actions for a collection (edit view)
+*/
+function getDefaultFormActions() {
+	return {
+		primary: [],
+		secondary: [
+			createDuplicateAction(),
+			createRestoreAction(),
+			createDeleteAction()
+		]
+	};
+}
+/**
+* Get complete default actions config
+*/
+function getDefaultActionsConfig() {
+	return {
+		header: getDefaultHeaderActions(),
+		bulk: getDefaultBulkActions()
+	};
+}
+
+//#endregion
+export { createActionRegistryProxy, getDefaultActionsConfig, getDefaultFormActions };

package/dist/client/builder/types/action-types.d.mts

@@ -0,0 +1,226 @@
+import { I18nText } from "../../i18n/types.mjs";
+import { IconComponent, MaybeLazyComponent } from "./common.mjs";
+import { FieldDefinition } from "../field/field.mjs";
+import { ComponentReference } from "../../../server/augmentation/common.mjs";
+import "../../../server/augmentation.mjs";
+
+//#region src/client/builder/types/action-types.d.ts
+
+/**
+ * Action helpers provided to action handlers
+ */
+interface ActionHelpers {
+  /** Navigate to a path */
+  navigate: (path: string) => void;
+  /** Show toast notification */
+  toast: {
+    success: (message: string) => void;
+    error: (message: string) => void;
+    info: (message: string) => void;
+    warning: (message: string) => void;
+  };
+  /**
+   * Translate a message key
+   * @param key - Translation key
+   * @param params - Interpolation parameters
+   */
+  t: (key: string, params?: Record<string, unknown>) => string;
+  /**
+   * Invalidate collection queries (triggers refetch)
+   * @param collection - Collection name (defaults to current collection)
+   */
+  invalidateCollection: (collection?: string) => Promise<void>;
+  /**
+   * Invalidate a specific item query
+   * @param id - Item ID
+   * @param collection - Collection name (defaults to current collection)
+   */
+  invalidateItem: (id: string, collection?: string) => Promise<void>;
+  /**
+   * Invalidate all queries
+   */
+  invalidateAll: () => Promise<void>;
+  /**
+   * Refresh the current view/data (alias for invalidateCollection)
+   * @deprecated Use invalidateCollection() instead for clarity
+   */
+  refresh: () => void;
+  /** Close the current dialog */
+  closeDialog: () => void;
+  /** Base path for admin routes */
+  basePath: string;
+}
+/**
+ * Query client interface for advanced query operations
+ */
+interface ActionQueryClient {
+  /** Invalidate queries matching the filter */
+  invalidateQueries: (filters: {
+    queryKey?: readonly unknown[];
+  }) => Promise<void>;
+  /** Refetch queries matching the filter */
+  refetchQueries: (filters: {
+    queryKey?: readonly unknown[];
+  }) => Promise<void>;
+  /** Reset queries matching the filter */
+  resetQueries: (filters: {
+    queryKey?: readonly unknown[];
+  }) => Promise<void>;
+}
+/**
+ * Context provided to action handlers and callbacks
+ */
+interface ActionContext<TItem = any> {
+  /** Item(s) being acted upon - single item for form actions, array for bulk */
+  item?: TItem;
+  /** Multiple items (for bulk actions) */
+  items?: TItem[];
+  /** Collection name */
+  collection: string;
+  /** Action helpers */
+  helpers: ActionHelpers;
+  /** Query client for advanced cache operations */
+  queryClient: ActionQueryClient;
+  /** Auth client for authentication operations (signUp, signIn, etc.) */
+  authClient?: any | null;
+}
+/**
+ * Navigate handler - navigates to a path
+ */
+interface NavigateHandler<TItem = any> {
+  type: "navigate";
+  /** Path to navigate to (can be a function for dynamic paths) */
+  path: string | ((item: TItem) => string);
+}
+/**
+ * Props for dialog components
+ */
+interface ActionDialogProps<TItem = any> {
+  /** Item being acted upon */
+  item?: TItem;
+  /** Multiple items for bulk actions */
+  items?: TItem[];
+  /** Collection name */
+  collection: string;
+  /** Close the dialog */
+  onClose: () => void;
+  /** Success callback */
+  onSuccess?: () => void;
+}
+/**
+ * Dialog handler - opens a dialog component
+ */
+interface DialogHandler<TItem = any> {
+  type: "dialog";
+  /** Component to render in the dialog */
+  component: MaybeLazyComponent<ActionDialogProps<TItem>>;
+}
+/**
+ * Form handler configuration
+ *
+ * Uses FieldDefinition from the admin builder for full field system support.
+ * Fields are validated automatically using buildValidationSchema.
+ */
+interface ActionFormConfig<TItem = any> {
+  /** Dialog title */
+  title: I18nText;
+  /** Dialog description */
+  description?: I18nText;
+  /** Form fields using FieldDefinition */
+  fields: Record<string, FieldDefinition>;
+  /** Default values */
+  defaultValues?: Record<string, any>;
+  /** Submit handler */
+  onSubmit: (data: Record<string, any>, ctx: ActionContext<TItem>) => void | Promise<void>;
+  /** Submit button label */
+  submitLabel?: I18nText;
+  /** Cancel button label */
+  cancelLabel?: I18nText;
+  /** Dialog width */
+  width?: "sm" | "md" | "lg" | "xl";
+}
+/**
+ * Form handler - opens a form dialog
+ */
+interface FormHandler<TItem = any> {
+  type: "form";
+  /** Form configuration */
+  config: ActionFormConfig<TItem>;
+}
+/**
+ * API handler - calls an API endpoint
+ */
+interface ApiHandler {
+  type: "api";
+  /** Endpoint path (can include {id} placeholder) */
+  endpoint: string;
+  /** HTTP method */
+  method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  /** Request body factory */
+  body?: (ctx: ActionContext) => Record<string, any>;
+}
+/**
+ * Custom handler - runs arbitrary code
+ */
+interface CustomHandler<TItem = any> {
+  type: "custom";
+  /** Handler function */
+  fn: (ctx: ActionContext<TItem>) => void | Promise<void>;
+}
+/**
+ * Server handler - executes action on the server via API.
+ * Used for server-defined actions where the handler runs server-side.
+ */
+interface ServerHandler {
+  type: "server";
+  /** Server action ID (matches ServerActionDefinition.id) */
+  actionId: string;
+  /** Collection name for the action endpoint */
+  collection: string;
+}
+/**
+ * Union of all action handler types
+ */
+type ActionHandler<TItem = any> = NavigateHandler<TItem> | DialogHandler<TItem> | FormHandler<TItem> | ApiHandler | CustomHandler<TItem> | ServerHandler;
+/**
+ * Confirmation dialog configuration
+ */
+interface ConfirmationConfig {
+  /** Dialog title */
+  title: I18nText;
+  /** Dialog description */
+  description?: I18nText;
+  /** Confirm button label */
+  confirmLabel?: I18nText;
+  /** Cancel button label */
+  cancelLabel?: I18nText;
+  /** Use destructive styling */
+  destructive?: boolean;
+}
+/**
+ * Button variant types (matching shadcn button variants)
+ */
+type ActionVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+/**
+ * Complete action definition
+ */
+interface ActionDefinition<TItem = any> {
+  /** Unique action identifier */
+  id: string;
+  /** Display label */
+  label: I18nText;
+  /** Icon component or server-defined component reference */
+  icon?: IconComponent | ComponentReference;
+  /** Button variant */
+  variant?: ActionVariant;
+  /** Whether action is visible (static or dynamic) */
+  visible?: boolean | ((ctx: ActionContext<TItem>) => boolean);
+  /** Whether action is disabled (static or dynamic) */
+  disabled?: boolean | ((ctx: ActionContext<TItem>) => boolean);
+  /** Action handler */
+  handler: ActionHandler<TItem>;
+  /** Confirmation dialog before executing */
+  confirmation?: ConfirmationConfig;
+}
+//#endregion
+export { ActionDefinition };

package/dist/client/builder/types/collection-types.mjs

@@ -0,0 +1,10 @@
+//#region src/client/builder/types/collection-types.ts
+/**
+* Helper to get column config object (normalizes string to object)
+*/
+function normalizeColumnConfig(column) {
+	return typeof column === "string" ? { field: column } : column;
+}
+
+//#endregion
+export { normalizeColumnConfig };

package/dist/client/builder/types/common.d.mts

@@ -0,0 +1,46 @@
+import { I18nText } from "../../i18n/types.mjs";
+import * as React from "react";
+
+//#region src/client/builder/types/common.d.ts
+
+/**
+ * Dynamic I18n text resolver (supports functions based on form values)
+ */
+type DynamicI18nText = I18nText | ((values: Record<string, any>) => I18nText);
+/**
+ * Component that can be lazy-loaded or direct
+ * Supports React.lazy, dynamic imports, and direct components
+ */
+type MaybeLazyComponent<TProps = any> = React.LazyExoticComponent<React.ComponentType<TProps>> | (() => Promise<{
+  default: React.ComponentType<TProps>;
+}>) | React.ComponentType<TProps>;
+/**
+ * Icon component type
+ * Icons are always synchronous - no lazy loading needed for small SVGs
+ */
+type IconComponent = React.ComponentType<React.SVGProps<SVGSVGElement> & {
+  className?: string;
+}>;
+/**
+ * Base field props that are provided by the form (runtime)
+ * These should be omitted when inferring field options from component props
+ */
+type BaseFieldProps = {
+  name: string;
+  value: any;
+  onChange?: (value: any) => void;
+  onBlur: () => void;
+  disabled?: boolean;
+  readOnly?: boolean;
+  error?: string;
+  label?: string;
+  description?: string;
+  placeholder?: string;
+  required?: boolean;
+  localized?: boolean;
+  locale?: string;
+  control?: any;
+  className?: string;
+};
+//#endregion
+export { BaseFieldProps, DynamicI18nText, IconComponent, MaybeLazyComponent };