import { Form } from '@components/common/form/Form.js'; import { InputField } from '@components/common/form/InputField.js'; import { NumberField } from '@components/common/form/NumberField.js'; import { SelectField } from '@components/common/form/SelectField.js'; import { TextareaField } from '@components/common/form/TextareaField.js'; import { ToggleField } from '@components/common/form/ToggleField.js'; import { Button } from '@components/common/ui/Button.js'; import { toast } from '@components/common/ui/Sonner.js'; import { _ } from '@evershop/evershop/lib/locale/translate/_'; import axios from 'axios'; import { ChevronDown, Plus, Trash2 } from 'lucide-react'; import React, { useState } from 'react'; import { useFieldArray, useFormContext } from 'react-hook-form'; const TYPE_OPTIONS = [ { value: 'short_text', label: _('Short text') }, { value: 'long_text', label: _('Long text') }, { value: 'rich_text', label: _('Rich text') }, { value: 'integer', label: _('Integer') }, { value: 'number', label: _('Number') }, { value: 'boolean', label: _('Boolean') }, { value: 'date', label: _('Date') }, { value: 'color', label: _('Color') }, { value: 'url', label: 'URL' }, { value: 'group', label: _('Group') } ]; // Sub-fields are one level deep, scalar leaves only — no nested groups and no // block-editor `rich_text` (which is a single top-level field). const SUB_TYPE_OPTIONS = TYPE_OPTIONS.filter( (o) => o.value !== 'group' && o.value !== 'rich_text' ); const FORM_ID = 'metafieldDefinitionForm'; const SECTION_TITLE = 'text-[11px] font-semibold uppercase tracking-wider text-muted-foreground'; export interface EditableDefinition { uuid: string; name: string; description?: string; key: string; type: string; isList?: boolean; required?: boolean; visibleToCustomer?: boolean; validations?: Array<{ type: string; min?: number; max?: number; pattern?: string; values?: Array; }>; subFields?: Array<{ key: string; name: string; type: string }>; } interface Props { ownerType: string; /** When provided, the form edits this definition (PATCH) instead of creating. */ definition?: EditableDefinition; onSaved: () => void; } function toNumber(value: unknown): number | undefined { if (value === '' || value === undefined || value === null) return undefined; const n = Number(value); return Number.isNaN(n) ? undefined : n; } /** Decompose a definition into the flat form fields the editor renders. */ function toFormDefaults(def: EditableDefinition): Record { const d: Record = { name: def.name, description: def.description ?? '', fieldKey: def.key, fieldType: def.type, isList: !!def.isList, required: !!def.required, visibleToCustomer: def.visibleToCustomer !== false, subFields: def.subFields ?? [] }; for (const v of def.validations ?? []) { if (v.type === 'size') { if (v.min != null) d.sizeMin = v.min; if (v.max != null) d.sizeMax = v.max; } else if (v.type === 'range') { if (v.min != null) d.rangeMin = v.min; if (v.max != null) d.rangeMax = v.max; } else if (v.type === 'regexp') { d.pattern = v.pattern; } else if (v.type === 'choices') { d.acceptedValues = (v.values ?? []).join(', '); } } return d; } /** Repeating editor for a group's sub-fields (shown only when type = group). */ function SubFieldsBuilder() { const { control } = useFormContext(); const { fields, append, remove } = useFieldArray({ control, name: 'subFields' as never }); return (
{_('Sub-fields')}
{fields.map((item, index) => (
))}
); } /** * Validation rules for the field, conditioned on the selected type (§3.7). * Collapsible (default closed) to keep the dialog short. The fields stay mounted * while collapsed (`hidden`, not unmounted) so their values survive toggling * under the form's `shouldUnregister`. */ function ValidationRules({ type }: { type: string }) { const [open, setOpen] = useState(false); const isText = type === 'short_text' || type === 'long_text'; const isNumeric = type === 'integer' || type === 'number'; const hasPattern = type === 'short_text' || type === 'url'; const hasChoices = type === 'short_text' || type === 'integer' || type === 'number'; if (!isText && !isNumeric && !hasPattern && !hasChoices) return null; return (
{isText && (
)} {isNumeric && (
)} {hasPattern && ( )} {hasChoices && ( )}
); } /** Group → sub-field builder; everything else → validation rules. */ function TypeSpecificFields() { const { watch } = useFormContext(); const type = watch('fieldType') || 'short_text'; if (type === 'group') return ; return ; } /** * In-context create/edit form for a metafield definition. Without `definition` * it creates (`POST /api/metafield-definitions`); with one it edits * (`PATCH /api/metafield-definitions/:uuid`) and the immutable fields (key, type, * allow-multiple) are shown read-only. `namespace` is not shown — it defaults to * `custom`. Mount inside a Dialog (see MetafieldSection). */ export function DefinitionEditor({ ownerType, definition, onSaved }: Props) { const isEdit = !!definition; const [submitting, setSubmitting] = useState(false); const defaultValues = isEdit ? toFormDefaults(definition as EditableDefinition) : { fieldType: 'short_text', visibleToCustomer: true, isList: false, required: false }; const handleSubmit = async (data: Record) => { const type = data.fieldType || 'short_text'; const body: Record = { ownerType, fieldKey: data.fieldKey, name: data.name, fieldType: type, isList: !!data.isList, required: !!data.required, visibleToCustomer: data.visibleToCustomer !== false }; if (data.description) body.description = data.description; if (type === 'group') { const subFields = (Array.isArray(data.subFields) ? data.subFields : []) .filter((s: any) => s && s.key && s.name) .map((s: any) => ({ key: s.key, name: s.name, type: s.type || 'short_text' })); if (subFields.length === 0) { toast.error(_('A group needs at least one sub-field')); return; } body.subFields = subFields; } else { // Build the validations array, type-aware (stale fields from other types // are ignored because each rule is gated by the current type). const validations: Array> = []; if (type === 'short_text' || type === 'long_text') { const min = toNumber(data.sizeMin); const max = toNumber(data.sizeMax); if (min !== undefined || max !== undefined) { validations.push({ type: 'size', ...(min !== undefined ? { min } : {}), ...(max !== undefined ? { max } : {}) }); } } if (type === 'integer' || type === 'number') { const min = toNumber(data.rangeMin); const max = toNumber(data.rangeMax); if (min !== undefined || max !== undefined) { validations.push({ type: 'range', ...(min !== undefined ? { min } : {}), ...(max !== undefined ? { max } : {}) }); } } if ((type === 'short_text' || type === 'url') && data.pattern) { validations.push({ type: 'regexp', pattern: data.pattern }); } if (type === 'short_text' || type === 'integer' || type === 'number') { const accepted = String(data.acceptedValues || '') .split(',') .map((s) => s.trim()) .filter(Boolean); if (accepted.length) { const values = type === 'short_text' ? accepted : accepted.map(Number).filter((n) => !Number.isNaN(n)); validations.push({ type: 'choices', values }); } } // On edit, always send `validations` (even empty) so the user can clear // the last rule; on create, omit when empty. if (validations.length || isEdit) body.validations = validations; } setSubmitting(true); try { if (isEdit) { await axios.patch( `/api/metafield-definitions/${(definition as EditableDefinition).uuid}`, body ); toast.success(_('Custom field updated')); } else { await axios.post('/api/metafield-definitions', body); toast.success(_('Custom field created')); } onSaved(); } catch (e) { const err = e as { response?: { data?: { error?: { message?: string } } }; }; const fallback = isEdit ? _('Failed to update field') : _('Failed to create field'); toast.error(err.response?.data?.error?.message ?? fallback); } finally { setSubmitting(false); } }; return (
); }