@betterstart/cli 0.1.70 → 0.1.71

package/dist/cli.js

@@ -6969,6 +6969,180 @@ ${hasDraft ? `            <Button
 // src/generators/form/form-single.ts
 import fs21 from "fs";
 import path21 from "path";
+function parseCardGroups(allFormFields) {
+  const groups = [];
+  let currentFields = [];
+  let nextTitle = "";
+  let nextDescription = "";
+  for (const field of allFormFields) {
+    if (field.type === "break") {
+      if (currentFields.length > 0) {
+        groups.push(buildGroup(currentFields, nextTitle, nextDescription));
+      }
+      nextTitle = field.label || "";
+      nextDescription = field.hint || "";
+      currentFields = [];
+      continue;
+    }
+    if (field.type === "separator") continue;
+    currentFields.push(field);
+  }
+  if (currentFields.length > 0) {
+    groups.push(buildGroup(currentFields, nextTitle, nextDescription));
+  }
+  return groups;
+}
+function buildGroup(fields, titleOverride, description) {
+  const firstField = fields[0];
+  const title = titleOverride || firstField.label || firstField.name;
+  const varPrefix = toCamelCase(firstField.name);
+  return {
+    title,
+    description,
+    varPrefix,
+    componentName: `${toPascalCase(firstField.name)}Card`,
+    fields,
+    flatFields: flattenFields(fields).filter((f) => !isLayoutField(f.type))
+  };
+}
+function analyzeGroup(fields) {
+  const tabFieldNames = /* @__PURE__ */ new Set();
+  for (const f of fields) {
+    if (f.type === "tabs" && f.tabs) {
+      for (const tab of f.tabs) {
+        if (tab.fields) for (const tf of tab.fields) tabFieldNames.add(tf.name);
+      }
+    }
+  }
+  const relFields = collectRelationshipFields(fields, tabFieldNames);
+  const listFieldsWithNested = [];
+  function collectLists(flds) {
+    for (const f of flds) {
+      if (f.type === "list" && f.fields && f.fields.length > 0 && !f.hidden) {
+        listFieldsWithNested.push(f);
+      }
+      if (f.type === "group" && f.fields) collectLists(f.fields);
+      if (f.type === "tabs" && f.tabs) {
+        for (const tab of f.tabs) {
+          if (tab.fields) collectLists(tab.fields);
+        }
+      }
+    }
+  }
+  collectLists(fields);
+  const hasTabsField = fields.some((f) => f.type === "tabs");
+  const tabsField = fields.find((f) => f.type === "tabs");
+  const firstTabName = tabsField?.tabs?.[0]?.name || "";
+  return { relFields, listFieldsWithNested, hasTabsField, tabsField, firstTabName, tabFieldNames };
+}
+function buildGroupFieldsJSX(group3, analysis, skipLabel) {
+  const indent = "            ";
+  return group3.fields.map((f) => {
+    if (f.type === "tabs" && f.tabs) {
+      const tabsList = f.tabs.map((t) => `              <TabsTrigger value="${t.name}">${t.label}</TabsTrigger>`).join("\n");
+      const tabsContent = f.tabs.map((t) => {
+        const tabFields = (t.fields || []).map((tf) => generateFieldJSX2(tf, "                ")).join("\n");
+        return `              <TabsContent value="${t.name}" className="space-y-6">
+${tabFields}
+              </TabsContent>`;
+      }).join("\n");
+      return `${indent}<Tabs value={activeTab} onValueChange={setActiveTab} className="w-full">
+              <TabsList>
+${tabsList}
+              </TabsList>
+${tabsContent}
+${indent}</Tabs>`;
+    }
+    if (analysis.tabFieldNames.has(f.name)) return "";
+    return generateFieldJSX2(f, indent, { skipLabel });
+  }).filter(Boolean).join("\n");
+}
+function buildGroupRelState(analysis) {
+  return analysis.relFields.map((f) => {
+    const relPlural = toPascalCase(pluralize(f.relationship || ""));
+    return `  const [${f.name}Open, set${toPascalCase(f.name)}Open] = React.useState(false)
+  const { data: ${f.relationship}Data } = use${relPlural}()`;
+  }).filter((v, i, a) => a.indexOf(v) === i).join("\n");
+}
+function buildGroupFieldArrayHooks(analysis) {
+  return analysis.listFieldsWithNested.map((field) => {
+    const pascalFieldName = toPascalCase(field.name);
+    return `  const [${field.name}Expanded, set${pascalFieldName}Expanded] = React.useState<string | undefined>(undefined)
+  const ${field.name}FieldArray = useFieldArray({
+    control: form.control,
+    name: '${field.name}'
+  })`;
+  }).join("\n");
+}
+function generateCardComponent(group3, schema, analysis) {
+  const singular = singularize(schema.name);
+  const Singular = toPascalCase(singular);
+  const zodFields = buildZodFields2(group3.flatFields);
+  const defaultValues = buildDefaultValues2(group3.flatFields);
+  const isSingleField = group3.fields.length === 1 && group3.title === (group3.fields[0].label || group3.fields[0].name);
+  const fieldsJSX = buildGroupFieldsJSX(group3, analysis, isSingleField);
+  const relState = buildGroupRelState(analysis);
+  const fieldArrayHooks = buildGroupFieldArrayHooks(analysis);
+  const needsReact = analysis.relFields.length > 0 || analysis.listFieldsWithNested.length > 0;
+  const descriptionLine = group3.description ? `
+            <CardDescription>${group3.description}</CardDescription>` : "";
+  return `const ${group3.varPrefix}Schema = z.object({
+${zodFields}
+})
+
+function ${group3.componentName}({ initialData }: { initialData?: ${Singular}Data | null }) {
+  const queryClient = useQueryClient()${analysis.hasTabsField ? `
+  const [activeTab, setActiveTab] = useQueryState('tab', { defaultValue: '${analysis.firstTabName}' })` : ""}${relState ? `
+${relState}` : ""}
+
+  const mutation = useMutation({
+    mutationFn: (data: Upsert${Singular}Input) => upsert${Singular}(data),
+    onSuccess: () => {
+      toast.success('${group3.title} saved')
+      queryClient.invalidateQueries({ queryKey: ['${schema.name}'] })
+    },
+    onError: (error: Error) => {
+      toast.error(error.message || 'Failed to save')
+    }
+  })
+
+  const isPending = mutation.isPending
+
+  const form = useForm<z.infer<typeof ${group3.varPrefix}Schema>>({
+    resolver: zodResolver(${group3.varPrefix}Schema),
+    defaultValues: {
+${defaultValues}
+    }
+  })
+${fieldArrayHooks ? `
+${fieldArrayHooks}
+` : ""}
+  return (
+    <Form {...form}>
+      <form onSubmit={form.handleSubmit((values) => {
+        const cleaned = Object.fromEntries(
+          Object.entries(values).map(([key, value]) => [key, value === undefined ? '' : value])
+        )
+        mutation.mutate(cleaned as Upsert${Singular}Input)
+      })}>
+        <Card>
+          <CardHeader>
+            <CardTitle>${group3.title}</CardTitle>${descriptionLine}
+          </CardHeader>
+          <CardContent className="space-y-6">
+${fieldsJSX}
+          </CardContent>
+          <CardFooter>
+            <Button type="submit" disabled={isPending} size="sm">
+              {isPending ? 'Saving...' : 'Save'}
+            </Button>
+          </CardFooter>
+        </Card>
+      </form>
+    </Form>
+  )
+}`;
+}
 function generateSingleForm(schema, cwd, pagesDir, options = {}) {
   const entityDir = path21.join(cwd, pagesDir, schema.name);
   const formFilePath = path21.join(entityDir, `${schema.name}-form.tsx`);
@@ -6980,15 +7154,7 @@ function generateSingleForm(schema, cwd, pagesDir, options = {}) {
   const allFormFields = schema.fields.filter(
     (f) => !f.primaryKey && f.name !== "createdAt" && f.name !== "updatedAt"
   );
-  const flatFields = flattenFields(allFormFields);
-  const tabFieldNames = /* @__PURE__ */ new Set();
-  for (const f of schema.fields) {
-    if (f.type === "tabs" && f.tabs) {
-      for (const tab of f.tabs) {
-        if (tab.fields) for (const tf of tab.fields) tabFieldNames.add(tf.name);
-      }
-    }
-  }
+  const cardGroups = parseCardGroups(allFormFields);
   const hasBoolean = hasFieldType(schema.fields, "boolean");
   const hasImage = hasFieldType(schema.fields, "image");
   const hasVideo = hasFieldType(schema.fields, "video");
@@ -7003,48 +7169,20 @@ function generateSingleForm(schema, cwd, pagesDir, options = {}) {
   const hasSeparator = hasFieldType(schema.fields, "separator");
   const hasRelationship = hasFieldType(schema.fields, "relationship");
   const hasTabsField = schema.fields.some((f) => f.type === "tabs");
-  const tabsField = schema.fields.find((f) => f.type === "tabs");
-  const firstTabName = tabsField?.tabs?.[0]?.name || "";
-  const mainRelFields = collectRelationshipFields(schema.fields, tabFieldNames);
-  const listFieldsWithNested = [];
-  function collectListFieldsSingle(fields) {
-    for (const f of fields) {
-      if (f.type === "list" && f.fields && f.fields.length > 0 && !f.hidden) {
-        listFieldsWithNested.push(f);
-      }
-      if (f.type === "group" && f.fields) collectListFieldsSingle(f.fields);
-      if (f.type === "tabs" && f.tabs) {
-        for (const tab of f.tabs) {
-          if (tab.fields) collectListFieldsSingle(tab.fields);
-        }
-      }
-    }
-  }
-  collectListFieldsSingle(allFormFields);
+  const flatFields = flattenFields(allFormFields);
   const hasList = hasFieldType(schema.fields, "list");
-  const hasNestedList = listFieldsWithNested.length > 0;
+  const hasNestedList = cardGroups.some((g) => analyzeGroup(g.fields).listFieldsWithNested.length > 0);
   const hasSimpleList = hasList && flatFields.some((f) => f.type === "list" && (!f.fields || f.fields.length === 0));
-  const zodFields = buildZodFields2(flatFields);
-  const defaultValues = buildDefaultValues2(flatFields);
-  const formFieldsJSX = allFormFields.map((f) => {
-    if (f.type === "tabs" && f.tabs) {
-      const tabsList = f.tabs.map((t) => `            <TabsTrigger value="${t.name}">${t.label}</TabsTrigger>`).join("\n");
-      const tabsContent = f.tabs.map((t) => {
-        const tabFields = (t.fields || []).map((tf) => generateFieldJSX2(tf, "              ")).join("\n");
-        return `            <TabsContent value="${t.name}" className="space-y-6 p-6 rounded-2xl border bg-card">
-${tabFields}
-            </TabsContent>`;
-      }).join("\n");
-      return `          <Tabs value={activeTab} onValueChange={setActiveTab} className="w-full">
-            <TabsList>
-${tabsList}
-            </TabsList>
-${tabsContent}
-          </Tabs>`;
+  const allRelFields = [];
+  for (const g of cardGroups) {
+    const a = analyzeGroup(g.fields);
+    for (const rf of a.relFields) {
+      if (!allRelFields.some((e) => e.relationship === rf.relationship)) {
+        allRelFields.push(rf);
+      }
     }
-    if (tabFieldNames.has(f.name)) return "";
-    return generateFieldJSX2(f);
-  }).filter(Boolean).join("\n");
+  }
+  const needsReact = allRelFields.length > 0 || hasNestedList;
   const uiImports = buildUiImports({
     hasBoolean,
     hasTextarea,
@@ -7063,30 +7201,29 @@ ${tabsContent}
     hasSimpleList,
     hasNestedList
   });
+  uiImports.push(`import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle
+} from '@cms/components/ui/card'`);
   const lucideIcons = [];
   if (hasRelationship) lucideIcons.push("Check", "ChevronsUpDown");
   if (hasNestedList) {
     if (!lucideIcons.includes("Plus")) lucideIcons.push("Plus");
     if (!lucideIcons.includes("X")) lucideIcons.push("X");
   }
-  const relHookImports = mainRelFields.map((f) => {
+  const relHookImports = allRelFields.map((f) => {
     const relPlural = toPascalCase(pluralize(f.relationship || ""));
     return `import { use${relPlural} } from '@cms/hooks/use-${f.relationship}'`;
   }).filter((v, i, a) => a.indexOf(v) === i).join("\n");
-  const relState = mainRelFields.map((f) => {
-    const relPlural = toPascalCase(pluralize(f.relationship || ""));
-    return `  const [${f.name}Open, set${toPascalCase(f.name)}Open] = React.useState(false)
-  const { data: ${f.relationship}Data } = use${relPlural}()`;
-  }).filter((v, i, a) => a.indexOf(v) === i).join("\n");
-  const fieldArrayHooks = listFieldsWithNested.map((field) => {
-    const pascalFieldName = toPascalCase(field.name);
-    return `  const [${field.name}Expanded, set${pascalFieldName}Expanded] = React.useState<string | undefined>(undefined)
-  const ${field.name}FieldArray = useFieldArray({
-    control: form.control,
-    name: '${field.name}'
-  })`;
-  }).join("\n");
-  const needsReact = mainRelFields.length > 0 || hasNestedList;
+  const cardComponents = cardGroups.map((group3) => {
+    const analysis = analyzeGroup(group3.fields);
+    return generateCardComponent(group3, schema, analysis);
+  });
+  const cardRenders = cardGroups.map((g) => `        <${g.componentName} initialData={initialData} />`).join("\n");
   const content = `'use client'
 ${needsReact ? "\nimport * as React from 'react'" : ""}
 import { zodResolver } from '@hookform/resolvers/zod'
@@ -7103,75 +7240,17 @@ import type {
 } from '@cms/actions/${schema.name}'
 import { upsert${Singular} } from '@cms/actions/${schema.name}'
 
-const formSchema = z.object({
-${zodFields}
-})
-
-export type FormValues = z.infer<typeof formSchema>
+${cardComponents.join("\n\n")}
 
 interface ${Singular}FormProps {
   initialData?: ${Singular}Data | null
 }
 
 export function ${Singular}Form({ initialData }: ${Singular}FormProps) {
-  const queryClient = useQueryClient()${hasTabsField ? `
-  const [activeTab, setActiveTab] = useQueryState('tab', { defaultValue: '${firstTabName}' })` : ""}${relState ? `
-${relState}` : ""}
-
-  const upsertMutation = useMutation({
-    mutationFn: (data: Upsert${Singular}Input) => upsert${Singular}(data),
-    onSuccess: () => {
-      toast.success('${schema.label} saved successfully')
-      queryClient.invalidateQueries({ queryKey: ['${schema.name}'] })
-    },
-    onError: (error: Error) => {
-      toast.error(error.message || 'Failed to save ${schema.label.toLowerCase()}')
-    }
-  })
-
-  const isPending = upsertMutation.isPending
-
-  const form = useForm<FormValues>({
-    resolver: zodResolver(formSchema),
-    defaultValues: {
-${defaultValues}
-    }
-  })
-${fieldArrayHooks ? `
-${fieldArrayHooks}
-` : ""}
-  function onSubmit(values: FormValues) {
-    const cleanedValues = Object.fromEntries(
-      Object.entries(values).map(([key, value]) => [key, value === undefined ? '' : value])
-    ) as FormValues
-
-    upsertMutation.mutate(cleanedValues as Upsert${Singular}Input)
-  }
-
   return (
-    <Form {...form}>
-      <form id="${schema.name}-form" onSubmit={form.handleSubmit(onSubmit, (errors) => {
-        console.error('Form validation errors:', errors)
-        const firstError = Object.values(errors)[0]
-        if (firstError?.message) {
-          toast.error(String(firstError.message))
-        } else {
-          toast.error('Please fix the form errors before submitting')
-        }
-      })} className="space-y-6">
-        <div className="space-y-6 p-6 rounded-2xl border bg-card">
-${formFieldsJSX}
-        </div>
-
-        <div className="flex items-center fixed bottom-0 md:left-[calc(var(--sidebar-width))] w-screen md:w-[calc(100svw-var(--sidebar-width)-4px)] right-0 bg-secondary border-t">
-          <div className="flex mx-auto py-4 w-full max-w-5xl items-center justify-end gap-2">
-            <Button type="submit" disabled={isPending} size="lg">
-              {isPending ? 'Saving...' : 'Save'}
-            </Button>
-          </div>
-        </div>
-      </form>
-    </Form>
+    <div className="space-y-6">
+${cardRenders}
+    </div>
   )
 }
 `;
@@ -9998,14 +10077,12 @@ function defaultSettingsSchema() {
       name: "settings",
       type: "single",
       label: "Settings",
-      description: "General site settings",
+      description: "General Settings",
       icon: "Settings",
       fields: [
         { name: "siteName", type: "string", label: "Site Name", default: "BetterStart" },
-        { name: "tagline", type: "string", label: "Tagline" },
-        { name: "separator1", type: "separator" },
-        { name: "logo", type: "image", label: "Logo" },
-        { name: "favicon", type: "image", label: "Favicon" }
+        { name: "break1", type: "break" },
+        { name: "logo", type: "image", label: "Logo" }
       ]
     },
     null,