@betterstart/cli 0.1.67 → 0.1.69

package/dist/cli.js

@@ -1753,7 +1753,18 @@ function generateFormActions(schema, cwd, actionsDir, options) {
   const formName = schema.name;
   const tableName = `${toCamelCase(formName)}Submissions`;
   const pascal = toPascalCase(formName);
+  const kebab = toKebabCase(formName);
   const fields = getAllFormSchemaFields(schema);
+  const absActionsDir = path6.join(cwd, actionsDir);
+  const dirPath = path6.join(absActionsDir, `${kebab}-form`);
+  const oldFilePath = path6.join(absActionsDir, `${kebab}-form.ts`);
+  if (!options.force && (fs6.existsSync(dirPath) || fs6.existsSync(oldFilePath))) {
+    return { files: [] };
+  }
+  if (options.force) {
+    if (fs6.existsSync(oldFilePath)) fs6.unlinkSync(oldFilePath);
+    if (fs6.existsSync(dirPath)) fs6.rmSync(dirPath, { recursive: true });
+  }
   const dataFields = fields.map((f) => {
     let tsType = "string";
     if (f.type === "number") tsType = "number";
@@ -1772,25 +1783,10 @@ function generateFormActions(schema, cwd, actionsDir, options) {
       return { success: false, error: '${f.label} is required' }
     }`
   ).join("\n    ");
-  const kebab = toKebabCase(formName);
-  const filePath = path6.join(cwd, actionsDir, `${kebab}-form.ts`);
-  const dir = path6.dirname(filePath);
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  if (fs6.existsSync(filePath) && !options.force) {
-    return { files: [path6.relative(cwd, filePath)] };
-  }
   const mailchimpImport = schema.mailchimp ? `
 import { addToMailchimpAudience } from '@cms/utils/mailchimp'` : "";
   const mailchimpCall = generateMailchimpCode(schema, fields);
-  const content = `'use server'
-
-import { desc, eq, or } from 'drizzle-orm'
-import db from '@cms/db'
-import { ${tableName} } from '@cms/db/schema'
-import { getFormSettings } from '@cms/actions/form-settings'
-import { sendWebhook } from '@cms/utils/webhook'${mailchimpImport}
-
-export interface ${pascal}SubmissionData {
+  const typesContent = `export interface ${pascal}SubmissionData {
   id: number
 ${dataFields}
   ipAddress: string | null
@@ -1822,6 +1818,13 @@ export interface Delete${pascal}SubmissionResult {
   error?: string
   count?: number
 }
+`;
+  const getSubmissionsContent = `'use server'
+
+import { desc } from 'drizzle-orm'
+import db from '@cms/db'
+import { ${tableName} } from '@cms/db/schema'
+import type { ${pascal}SubmissionsResponse, ${pascal}SubmissionData } from './types'
 
 export async function get${pascal}Submissions(): Promise<${pascal}SubmissionsResponse> {
   try {
@@ -1835,6 +1838,13 @@ export async function get${pascal}Submissions(): Promise<${pascal}SubmissionsRes
     throw new Error('Failed to fetch ${formName} submissions')
   }
 }
+`;
+  const getSubmissionContent = `'use server'
+
+import { eq } from 'drizzle-orm'
+import db from '@cms/db'
+import { ${tableName} } from '@cms/db/schema'
+import type { ${pascal}SubmissionData } from './types'
 
 export async function get${pascal}Submission(id: number): Promise<${pascal}SubmissionData | null> {
   try {
@@ -1849,6 +1859,14 @@ export async function get${pascal}Submission(id: number): Promise<${pascal}Submi
     throw new Error('Failed to fetch ${formName} submission')
   }
 }
+`;
+  const createContent = `'use server'
+
+import db from '@cms/db'
+import { ${tableName} } from '@cms/db/schema'
+import { getFormSettings } from '@cms/actions/form-settings'
+import { sendWebhook } from '@cms/utils/webhook'${mailchimpImport}
+import type { Create${pascal}SubmissionInput, Create${pascal}SubmissionResult, ${pascal}SubmissionData } from './types'
 
 export async function create${pascal}Submission(
   data: Create${pascal}SubmissionInput
@@ -1899,6 +1917,13 @@ export async function create${pascal}Submission(
     }
   }
 }
+`;
+  const deleteContent = `'use server'
+
+import { eq } from 'drizzle-orm'
+import db from '@cms/db'
+import { ${tableName} } from '@cms/db/schema'
+import type { Delete${pascal}SubmissionResult } from './types'
 
 export async function delete${pascal}Submission(id: number): Promise<Delete${pascal}SubmissionResult> {
   try {
@@ -1912,6 +1937,13 @@ export async function delete${pascal}Submission(id: number): Promise<Delete${pas
     }
   }
 }
+`;
+  const deleteBulkContent = `'use server'
+
+import { eq, or } from 'drizzle-orm'
+import db from '@cms/db'
+import { ${tableName} } from '@cms/db/schema'
+import type { Delete${pascal}SubmissionResult } from './types'
 
 export async function deleteBulk${pascal}Submissions(ids: number[]): Promise<Delete${pascal}SubmissionResult> {
   try {
@@ -1928,6 +1960,10 @@ export async function deleteBulk${pascal}Submissions(ids: number[]): Promise<Del
     }
   }
 }
+`;
+  const exportCsvContent = `'use server'
+
+import { get${pascal}Submissions } from './get-${kebab}-submissions'
 
 export async function export${pascal}SubmissionsCSV(): Promise<string> {
   const { submissions } = await get${pascal}Submissions()
@@ -1947,14 +1983,41 @@ export async function export${pascal}SubmissionsCSV(): Promise<string> {
   )
   return [headers, ...rows].join('\\n')
 }
+`;
+  const exportJsonContent = `'use server'
+
+import { get${pascal}Submissions } from './get-${kebab}-submissions'
 
 export async function export${pascal}SubmissionsJSON(): Promise<string> {
   const { submissions } = await get${pascal}Submissions()
   return JSON.stringify(submissions, null, 2)
 }
 `;
-  fs6.writeFileSync(filePath, content, "utf-8");
-  return { files: [path6.relative(cwd, filePath)] };
+  const barrelContent = `export type { ${pascal}SubmissionData, ${pascal}SubmissionsResponse, Create${pascal}SubmissionInput, Create${pascal}SubmissionResult, Delete${pascal}SubmissionResult } from './types'
+export { get${pascal}Submissions } from './get-${kebab}-submissions'
+export { get${pascal}Submission } from './get-${kebab}-submission'
+export { create${pascal}Submission } from './create-${kebab}-submission'
+export { delete${pascal}Submission } from './delete-${kebab}-submission'
+export { deleteBulk${pascal}Submissions } from './delete-bulk-${kebab}-submissions'
+export { export${pascal}SubmissionsCSV } from './export-${kebab}-submissions-csv'
+export { export${pascal}SubmissionsJSON } from './export-${kebab}-submissions-json'
+`;
+  const files = [
+    { name: "types.ts", content: typesContent },
+    { name: `get-${kebab}-submissions.ts`, content: getSubmissionsContent },
+    { name: `get-${kebab}-submission.ts`, content: getSubmissionContent },
+    { name: `create-${kebab}-submission.ts`, content: createContent },
+    { name: `delete-${kebab}-submission.ts`, content: deleteContent },
+    { name: `delete-bulk-${kebab}-submissions.ts`, content: deleteBulkContent },
+    { name: `export-${kebab}-submissions-csv.ts`, content: exportCsvContent },
+    { name: `export-${kebab}-submissions-json.ts`, content: exportJsonContent },
+    { name: "index.ts", content: barrelContent }
+  ];
+  fs6.mkdirSync(dirPath, { recursive: true });
+  for (const file of files) {
+    fs6.writeFileSync(path6.join(dirPath, file.name), file.content, "utf-8");
+  }
+  return { files: files.map((f) => path6.relative(cwd, path6.join(dirPath, f.name))) };
 }
 
 // src/generators/form-pipeline/form-component-multistep.ts
@@ -3400,16 +3463,527 @@ ${blocks.join("\n\n")}
 
   return record
 }
-`;
+`;
+}
+
+// src/generators/actions/entity-file-contents.ts
+function genTypesContent(ctx) {
+  const parts = [
+    ctx.dataInterface,
+    ctx.displayDataInterface || null,
+    ctx.responseInterface,
+    ctx.filtersInterface,
+    ctx.createInterface,
+    `export interface Create${ctx.Singular}Result {
+  success: boolean
+  error?: string
+  ${ctx.camelSingular}?: ${ctx.Singular}Data
+}`,
+    ctx.updateInterface,
+    `export interface Update${ctx.Singular}Result {
+  success: boolean
+  error?: string
+  ${ctx.camelSingular}?: ${ctx.Singular}Data
+}`,
+    `export interface Delete${ctx.Singular}Result {
+  success: boolean
+  error?: string
+}`,
+    `export const CACHE_TAG = '${ctx.cacheTag}'`
+  ];
+  return parts.filter(Boolean).join("\n\n") + "\n";
+}
+function genHelpersContent(ctx) {
+  const hasSlugify = ctx.hasAutoSlug;
+  const hasPopulate = ctx.hasListRels;
+  if (!hasSlugify && !hasPopulate) return null;
+  const lines = [];
+  if (hasPopulate) {
+    lines.push(`import db from '@cms/db'`);
+    const tables = [...new Set(ctx.listRelTableImports)].sort();
+    if (tables.length > 0) {
+      lines.push(`import { ${tables.join(", ")} } from '@cms/db/schema'`);
+    }
+    lines.push(`import { inArray } from 'drizzle-orm'`);
+    lines.push(`import type { ${ctx.Singular}Data } from './types'`);
+    lines.push("");
+  }
+  if (hasSlugify) {
+    lines.push(`export function slugify(text: string): string {`);
+    lines.push(`  return text.toLowerCase().trim().replace(/[^\\w\\s-]/g, '').replace(/\\s+/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '')`);
+    lines.push(`}`);
+    lines.push("");
+  }
+  if (hasPopulate) {
+    const exportedFn = ctx.populateListRelsFn.replace("async function", "export async function").trim();
+    lines.push(exportedFn);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function genGetPluralContent(ctx) {
+  const dbImports = [ctx.tableVar, ...ctx.relTableImports].sort();
+  const drizzle = ["asc"];
+  if (ctx.hasSearch || ctx.filterableFields.length > 1) drizzle.push("and");
+  if (ctx.hasSearch) drizzle.push("ilike", "or");
+  if (ctx.filterableFields.some(() => true)) drizzle.push("eq");
+  if (ctx.hasRelationships) drizzle.push("sql");
+  const sortedDrizzle = [...new Set(drizzle)].sort();
+  const typeImports = [`${ctx.Plural}Response`, `Get${ctx.Plural}Filters`, `${ctx.Singular}Data`];
+  const populateImport = ctx.hasListRels ? `
+import { populate${ctx.Singular}ListRelationships } from './helpers'` : "";
+  return `'use server'
+
+import db from '@cms/db'
+import { ${dbImports.join(", ")} } from '@cms/db/schema'
+import { ${sortedDrizzle.join(", ")} } from 'drizzle-orm'
+import type { ${typeImports.sort().join(", ")} } from './types'${populateImport}
+
+export async function get${ctx.Plural}(filters?: Get${ctx.Plural}Filters): Promise<${ctx.Plural}Response> {
+  try {
+    const conditions = []
+${ctx.searchBlock}${ctx.filterConditions}
+
+    const query = ${ctx.listSelectClause}
+
+    const orderedQuery = conditions.length > 0
+      ? query.where(and(...conditions)).orderBy(asc(${ctx.tableVar}.sortOrder))
+      : query.orderBy(asc(${ctx.tableVar}.sortOrder))
+
+    const results = filters?.limit && filters.limit > 0
+      ? await orderedQuery.limit(filters.limit)
+      : await orderedQuery${ctx.listResultMapping}
+  } catch (error) {
+    console.error('Error fetching ${ctx.plural}:', error)
+    return { ${ctx.camelPlural}: [], total: 0 }
+  }
+}
+`;
+}
+function genGetByIdContent(ctx) {
+  const dbImports = [ctx.tableVar, ...ctx.relTableImports].sort();
+  const drizzle = ["eq"];
+  if (ctx.hasRelationships) drizzle.push("sql");
+  const sortedDrizzle = [...new Set(drizzle)].sort();
+  const populateImport = ctx.hasListRels ? `
+import { populate${ctx.Singular}ListRelationships } from './helpers'` : "";
+  return `'use server'
+
+import db from '@cms/db'
+import { ${dbImports.join(", ")} } from '@cms/db/schema'
+import { ${sortedDrizzle.join(", ")} } from 'drizzle-orm'
+import type { ${ctx.Singular}Data } from './types'${populateImport}
+
+export async function get${ctx.Singular}ById(id: number): Promise<${ctx.Singular}Data | null> {
+  try {
+    const result = await ${ctx.selectClause}.where(eq(${ctx.tableVar}.id, id)).limit(1)
+    if (result.length === 0) return null
+    ${ctx.singleRowReturn}
+  } catch (error) {
+    console.error('Error fetching ${ctx.singular}:', error)
+    return null
+  }
+}
+`;
+}
+function genGetBySlugContent(ctx) {
+  if (!ctx.hasSlug) return null;
+  const returnType = ctx.hasHtmlOutput ? `${ctx.Singular}DisplayData` : `${ctx.Singular}Data`;
+  const dbImports = [ctx.tableVar, ...ctx.relTableImports].sort();
+  const drizzle = ["eq"];
+  if (ctx.hasRelationships) drizzle.push("sql");
+  const sortedDrizzle = [...new Set(drizzle)].sort();
+  const typeImport = ctx.hasHtmlOutput ? `${ctx.Singular}DisplayData` : `${ctx.Singular}Data`;
+  const extraTypes = ctx.hasListRels && ctx.hasHtmlOutput ? `, ${ctx.Singular}Data` : "";
+  const populateImport = ctx.hasListRels ? `
+import { populate${ctx.Singular}ListRelationships } from './helpers'` : "";
+  return `'use server'
+
+import db from '@cms/db'
+import { ${dbImports.join(", ")} } from '@cms/db/schema'
+import { ${sortedDrizzle.join(", ")} } from 'drizzle-orm'
+import type { ${typeImport}${extraTypes} } from './types'${populateImport}
+
+export async function get${ctx.Singular}BySlug(slug: string): Promise<${returnType} | null> {
+  try {
+    const result = await ${ctx.displaySelectClause}.where(eq(${ctx.tableVar}.slug, slug)).limit(1)
+    if (result.length === 0) return null
+    ${ctx.displaySingleRowReturn}
+  } catch (error) {
+    console.error('Error fetching ${ctx.singular} by slug:', error)
+    return null
+  }
+}
+`;
+}
+function genCreateContent(ctx) {
+  const slugImport = ctx.hasAutoSlug ? `
+import { slugify } from './helpers'` : "";
+  return `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { desc } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+import type { Create${ctx.Singular}Input, Create${ctx.Singular}Result, ${ctx.Singular}Data } from './types'${slugImport}
+
+export async function create${ctx.Singular}(input: Create${ctx.Singular}Input): Promise<Create${ctx.Singular}Result> {
+  try {${ctx.autoSlugCreate}
+    const maxSortOrderResult = await db
+      .select({ maxOrder: ${ctx.tableVar}.sortOrder })
+      .from(${ctx.tableVar})
+      .orderBy(desc(${ctx.tableVar}.sortOrder))
+      .limit(1)
+    const nextSortOrder = (maxSortOrderResult[0]?.maxOrder ?? 0) + 1
+${ctx.htmlCreateBlock}
+    const result = await db.insert(${ctx.tableVar}).values({
+${ctx.createMappings},${ctx.hasHtmlOutput ? `
+${ctx.htmlCreateMappings},` : ""}${ctx.hasDraft ? `
+      published: input.published ?? false,` : ""}
+      sortOrder: nextSortOrder,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    }).returning()
+
+    updateTag(CACHE_TAG)
+
+    return {
+      success: true,
+      ${ctx.camelSingular}: result[0] as ${ctx.Singular}Data
+    }
+  } catch (error) {
+    console.error('Error creating ${ctx.singular}:', error)
+    throw new Error(error instanceof Error ? error.message : 'Failed to create ${ctx.singular}')
+  }
+}
+`;
+}
+function genUpdateContent(ctx) {
+  const slugImport = ctx.hasAutoSlug ? `
+import { slugify } from './helpers'` : "";
+  const htmlUpdateBlock = ctx.hasHtmlOutput ? `
+    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
+` + ctx.htmlOutputFields.map((f) => `    if (processedData.${f.name} !== undefined) {
+      processedData.${f.name}Html = renderMarkdownSync(String(processedData.${f.name} || ''))
+    }`).join("\n") + "\n" : "";
+  return `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+import type { Update${ctx.Singular}Input, Update${ctx.Singular}Result, ${ctx.Singular}Data } from './types'${slugImport}
+
+export async function update${ctx.Singular}(input: Update${ctx.Singular}Input): Promise<Update${ctx.Singular}Result> {
+  try {
+    const { id, ...updateData } = input
+${ctx.autoSlugUpdate}
+    const fieldMeta = [
+    ${ctx.fieldMeta}
+    ]
+
+    const processedData: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(updateData)) {
+      if (key === 'published') { processedData[key] = value; continue }
+      const field = fieldMeta.find(f => f.name === key)
+      if (!field) continue
+      if (field.type === 'list') {
+        processedData[key] = value || []
+      } else if (!field.required && ['date', 'timestamp', 'time', 'string', 'varchar', 'text', 'select'].includes(field.type)) {
+        processedData[key] = value && value !== '' ? value : null
+      } else {
+        processedData[key] = value
+      }
+    }
+${htmlUpdateBlock}
+    const result = await db.update(${ctx.tableVar})
+      .set({ ...processedData, updatedAt: new Date().toISOString() })
+      .where(eq(${ctx.tableVar}.id, id))
+      .returning()
+
+    if (result.length === 0) throw new Error('${ctx.Singular} not found')
+
+    updateTag(CACHE_TAG)
+
+    return {
+      success: true,
+      ${ctx.camelSingular}: result[0] as ${ctx.Singular}Data
+    }
+  } catch (error) {
+    console.error('Error updating ${ctx.singular}:', error)
+    throw new Error(error instanceof Error ? error.message : 'Failed to update ${ctx.singular}')
+  }
+}
+`;
+}
+function genDeleteContent(ctx) {
+  return `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+import type { Delete${ctx.Singular}Result } from './types'
+
+export async function delete${ctx.Singular}(id: number): Promise<Delete${ctx.Singular}Result> {
+  try {
+    await db.delete(${ctx.tableVar}).where(eq(${ctx.tableVar}.id, id))
+    updateTag(CACHE_TAG)
+    return { success: true }
+  } catch (error) {
+    console.error('Error deleting ${ctx.singular}:', error)
+    return { success: false, error: error instanceof Error ? error.message : 'Failed to delete ${ctx.singular}' }
+  }
+}
+`;
+}
+function genDeleteBulkContent(ctx) {
+  return `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { inArray } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+import type { Delete${ctx.Singular}Result } from './types'
+
+export async function deleteBulk${ctx.Plural}(ids: number[]): Promise<Delete${ctx.Singular}Result> {
+  try {
+    if (ids.length === 0) return { success: false, error: 'No items selected for deletion' }
+    await db.delete(${ctx.tableVar}).where(inArray(${ctx.tableVar}.id, ids))
+    updateTag(CACHE_TAG)
+    return { success: true }
+  } catch (error) {
+    console.error('Error deleting ${ctx.plural}:', error)
+    return { success: false, error: error instanceof Error ? error.message : 'Failed to delete ${ctx.plural}' }
+  }
+}
+`;
+}
+function genSortOrderContent(ctx) {
+  return `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { asc, desc, eq, gt, lt } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+
+export async function update${ctx.Singular}SortOrder(
+  id: number,
+  direction: 'up' | 'down'
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const current = await db.select({ id: ${ctx.tableVar}.id, sortOrder: ${ctx.tableVar}.sortOrder }).from(${ctx.tableVar}).where(eq(${ctx.tableVar}.id, id)).limit(1)
+    if (current.length === 0) return { success: false, error: '${ctx.Singular} not found' }
+
+    const currentSortOrder = current[0].sortOrder
+    const adjacent = await db
+      .select({ id: ${ctx.tableVar}.id, sortOrder: ${ctx.tableVar}.sortOrder })
+      .from(${ctx.tableVar})
+      .where(direction === 'up' ? lt(${ctx.tableVar}.sortOrder, currentSortOrder) : gt(${ctx.tableVar}.sortOrder, currentSortOrder))
+      .orderBy(direction === 'up' ? desc(${ctx.tableVar}.sortOrder) : asc(${ctx.tableVar}.sortOrder))
+      .limit(1)
+
+    if (adjacent.length === 0) return { success: true }
+
+    await db.update(${ctx.tableVar}).set({ sortOrder: adjacent[0].sortOrder }).where(eq(${ctx.tableVar}.id, id))
+    await db.update(${ctx.tableVar}).set({ sortOrder: currentSortOrder }).where(eq(${ctx.tableVar}.id, adjacent[0].id))
+    updateTag(CACHE_TAG)
+    return { success: true }
+  } catch (error) {
+    console.error('Error updating sort order:', error)
+    return { success: false, error: error instanceof Error ? error.message : 'Failed to update sort order' }
+  }
+}
+`;
+}
+function genBulkSortOrderContent(ctx) {
+  return `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+
+export async function bulkUpdate${ctx.Plural}SortOrder(
+  updates: Array<{ id: number; sortOrder: number }>
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    if (updates.length === 0) return { success: true }
+    await Promise.all(updates.map((u) => db.update(${ctx.tableVar}).set({ sortOrder: u.sortOrder }).where(eq(${ctx.tableVar}.id, u.id))))
+    updateTag(CACHE_TAG)
+    return { success: true }
+  } catch (error) {
+    console.error('Error bulk updating sort order:', error)
+    return { success: false, error: error instanceof Error ? error.message : 'Failed to bulk update sort order' }
+  }
+}
+`;
+}
+function genM2MFiles(ctx) {
+  const files = [];
+  for (const f of ctx.m2mFields) {
+    const rel = f.relationship || "";
+    const RelPascal = toPascalCase(rel);
+    const relSingular = singularize(rel);
+    const junctionVar = toCamelCase(`${ctx.singular}${RelPascal}`);
+    const entityIdCol = `${ctx.singular}Id`;
+    const relIdCol = `${relSingular}Id`;
+    const kebabRel = rel.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+    files.push({
+      name: `get-${kebabRel}-for-${ctx.singular}.ts`,
+      content: `'use server'
+
+import db from '@cms/db'
+import { ${junctionVar} } from '@cms/db/schema'
+import { eq } from 'drizzle-orm'
+
+export async function get${RelPascal}For${ctx.Singular}(${ctx.singular}Id: number): Promise<number[]> {
+  try {
+    const results = await db.select({ ${relIdCol}: ${junctionVar}.${relIdCol} }).from(${junctionVar}).where(eq(${junctionVar}.${entityIdCol}, ${ctx.singular}Id))
+    return results.map(r => r.${relIdCol})
+  } catch (error) {
+    console.error('Error fetching ${rel} for ${ctx.singular}:', error)
+    return []
+  }
+}
+`
+    });
+    files.push({
+      name: `set-${kebabRel}-for-${ctx.singular}.ts`,
+      content: `'use server'
+
+import db from '@cms/db'
+import { ${junctionVar} } from '@cms/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+
+export async function set${RelPascal}For${ctx.Singular}(${ctx.singular}Id: number, ${rel}Ids: number[]): Promise<{ success: boolean; error?: string }> {
+  try {
+    await db.delete(${junctionVar}).where(eq(${junctionVar}.${entityIdCol}, ${ctx.singular}Id))
+    if (${rel}Ids.length > 0) {
+      await db.insert(${junctionVar}).values(${rel}Ids.map(${relSingular}Id => ({ ${entityIdCol}: ${ctx.singular}Id, ${relIdCol}: ${relSingular}Id })))
+    }
+    updateTag(CACHE_TAG)
+    return { success: true }
+  } catch (error) {
+    console.error('Error setting ${rel} for ${ctx.singular}:', error)
+    return { success: false, error: error instanceof Error ? error.message : 'Failed to set ${rel}' }
+  }
+}
+`
+    });
+  }
+  return files;
+}
+function genDistinctFiles(ctx) {
+  if (!ctx.hasFilters) return [];
+  return ctx.filters.map((filter) => {
+    const fieldPascal = toPascalCase(filter.field);
+    const kebabField = filter.field.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+    const kebabPlural = ctx.plural.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+    return {
+      name: `get-distinct-${kebabPlural}-${kebabField}.ts`,
+      content: `'use server'
+
+import db from '@cms/db'
+import { ${ctx.tableVar} } from '@cms/db/schema'
+import { asc, isNotNull } from 'drizzle-orm'
+
+export async function getDistinct${ctx.Plural}${fieldPascal}(): Promise<string[]> {
+  try {
+    const results = await db
+      .selectDistinct({ value: ${ctx.tableVar}.${filter.field} })
+      .from(${ctx.tableVar})
+      .where(isNotNull(${ctx.tableVar}.${filter.field}))
+      .orderBy(asc(${ctx.tableVar}.${filter.field}))
+    return results.map((r) => String(r.value)).filter(Boolean)
+  } catch (error) {
+    console.error('Error fetching distinct ${ctx.plural} ${filter.field}:', error)
+    return []
+  }
+}
+`
+    };
+  });
+}
+function genBarrelContent(files, ctx) {
+  const lines = [];
+  const typeNames = [
+    `${ctx.Singular}Data`,
+    ctx.hasHtmlOutput ? `${ctx.Singular}DisplayData` : null,
+    `${ctx.Plural}Response`,
+    `Get${ctx.Plural}Filters`,
+    `Create${ctx.Singular}Input`,
+    `Create${ctx.Singular}Result`,
+    `Update${ctx.Singular}Input`,
+    `Update${ctx.Singular}Result`,
+    `Delete${ctx.Singular}Result`
+  ].filter(Boolean);
+  lines.push(`export type { ${typeNames.join(", ")} } from './types'`);
+  lines.push("");
+  for (const file of files) {
+    if (file.name === "types.ts" || file.name === "helpers.ts") continue;
+    const exportMatches = file.content.matchAll(/export async function (\w+)/g);
+    const fnNames = [...exportMatches].map((m) => m[1]);
+    if (fnNames.length > 0) {
+      const modulePath = "./" + file.name.replace(/\.ts$/, "");
+      lines.push(`export { ${fnNames.join(", ")} } from '${modulePath}'`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
 }
 
 // src/generators/actions/entity-actions.ts
 function generateActions(schema, cwd, actionsDir, options = {}) {
   const absActionsDir = path12.join(cwd, actionsDir);
-  const filePath = path12.join(absActionsDir, `${schema.name}.ts`);
-  if (fs12.existsSync(filePath) && !options.force) {
+  const dirPath = path12.join(absActionsDir, schema.name);
+  const oldFilePath = path12.join(absActionsDir, `${schema.name}.ts`);
+  if (!options.force && (fs12.existsSync(dirPath) || fs12.existsSync(oldFilePath))) {
     return { files: [] };
   }
+  if (options.force) {
+    if (fs12.existsSync(oldFilePath)) fs12.unlinkSync(oldFilePath);
+    if (fs12.existsSync(dirPath)) fs12.rmSync(dirPath, { recursive: true });
+  }
+  const ctx = buildEntityContext(schema);
+  const kebabSingular = toKebabCase(ctx.singular);
+  const kebabPlural = toKebabCase(ctx.plural);
+  const files = [];
+  files.push({ name: "types.ts", content: genTypesContent(ctx) });
+  const helpersContent = genHelpersContent(ctx);
+  if (helpersContent) {
+    files.push({ name: "helpers.ts", content: helpersContent });
+  }
+  files.push({ name: `get-${kebabPlural}.ts`, content: genGetPluralContent(ctx) });
+  files.push({ name: `get-${kebabSingular}-by-id.ts`, content: genGetByIdContent(ctx) });
+  const bySlugContent = genGetBySlugContent(ctx);
+  if (bySlugContent) {
+    files.push({ name: `get-${kebabSingular}-by-slug.ts`, content: bySlugContent });
+  }
+  files.push({ name: `create-${kebabSingular}.ts`, content: genCreateContent(ctx) });
+  files.push({ name: `update-${kebabSingular}.ts`, content: genUpdateContent(ctx) });
+  files.push({ name: `delete-${kebabSingular}.ts`, content: genDeleteContent(ctx) });
+  files.push({ name: `delete-bulk-${kebabPlural}.ts`, content: genDeleteBulkContent(ctx) });
+  files.push({ name: `update-${kebabSingular}-sort-order.ts`, content: genSortOrderContent(ctx) });
+  files.push({ name: `bulk-update-${kebabPlural}-sort-order.ts`, content: genBulkSortOrderContent(ctx) });
+  files.push(...genM2MFiles(ctx));
+  files.push(...genDistinctFiles(ctx));
+  files.push({ name: "index.ts", content: genBarrelContent(files, ctx) });
+  fs12.mkdirSync(dirPath, { recursive: true });
+  for (const file of files) {
+    fs12.writeFileSync(path12.join(dirPath, file.name), file.content, "utf-8");
+  }
+  return { files: files.map((f) => path12.join(actionsDir, schema.name, f.name)) };
+}
+function buildEntityContext(schema) {
   const singular = singularize(schema.name);
   const plural = pluralize(schema.name);
   const Singular = toPascalCase(singular);
@@ -3452,6 +4026,7 @@ function generateActions(schema, cwd, actionsDir, options = {}) {
   const hasSearch = (schema.search?.fields || []).length > 0;
   const searchFields = schema.search?.fields || [];
   const hasFilters = (schema.filters || []).length > 0;
+  const hasAutoSlug = schema.autoSlugify?.enabled === true;
   const allDbFields = [...regularDbFields];
   if (hasDraft && !hasPublished) {
     allDbFields.push({ name: "published", type: "boolean", required: true });
@@ -3473,23 +4048,8 @@ function generateActions(schema, cwd, actionsDir, options = {}) {
   const filterableFields = allDbFields.filter(
     (f) => !f.primaryKey && f.name !== "createdAt" && f.name !== "updatedAt" && f.name !== "sortOrder" && ["string", "varchar", "text", "boolean", "number", "decimal"].includes(f.type)
   );
-  const drizzleImports = ["asc", "desc", "eq", "gt", "inArray", "lt"];
-  if (hasSearch || filterableFields.length > 1) drizzleImports.push("and");
-  if (hasSearch) drizzleImports.push("ilike", "or");
-  if (hasRelationships) drizzleImports.push("sql");
-  if (hasFilters) drizzleImports.push("isNotNull");
-  const sortedDrizzleImports = [...new Set(drizzleImports)].sort();
-  const dbImports = /* @__PURE__ */ new Set([tableVar]);
-  for (const f of relationshipFields) dbImports.add(toCamelCase(f.relationship));
-  for (const f of m2mFields) {
-    const junctionVar = toCamelCase(`${singular}${toPascalCase(f.relationship || "")}`);
-    dbImports.add(junctionVar);
-    dbImports.add(toCamelCase(f.relationship || ""));
-  }
-  for (const q of allListRelQueries) {
-    dbImports.add(q.relTable);
-  }
-  const sortedDbImports = [...dbImports].sort();
+  const relTableImports = relationshipFields.map((f) => toCamelCase(f.relationship));
+  const listRelTableImports = allListRelQueries.map((q) => q.relTable);
   const dataFields = allDbFields.map(
     (f) => `  ${quotePropertyName(f.name)}: ${getFieldType(f, "output")}${f.required ? "" : " | null"}`
   ).join("\n");
@@ -3501,9 +4061,10 @@ ${htmlFieldTypes}` : ""}${m2mFieldTypes ? `
 ${m2mFieldTypes}` : ""}
 }`;
   const displayDbFields = allDbFields.filter((f) => !htmlOutputFields.some((h) => h.name === f.name));
-  const displayDataFields = displayDbFields.map((f) => `  ${quotePropertyName(f.name)}: ${getFieldType(f, "output")}${f.required ? "" : " | null"}`).join("\n");
-  const displayDataInterface = hasHtmlOutput ? `
-export interface ${Singular}DisplayData {
+  const displayDataFields = displayDbFields.map(
+    (f) => `  ${quotePropertyName(f.name)}: ${getFieldType(f, "output")}${f.required ? "" : " | null"}`
+  ).join("\n");
+  const displayDataInterface = hasHtmlOutput ? `export interface ${Singular}DisplayData {
 ${displayDataFields}${htmlFieldTypes ? `
 ${htmlFieldTypes}` : ""}${m2mFieldTypes ? `
 ${m2mFieldTypes}` : ""}
@@ -3551,14 +4112,7 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
       )
     }
 ` : "";
-  const resultMapping = hasRelationships ? buildResultMapping(
-    allDbFields,
-    relationshipFields,
-    Plural,
-    camelPlural,
-    Singular,
-    hasListRels
-  ) : hasListRels ? `
+  const resultMapping = hasRelationships ? buildResultMapping(allDbFields, relationshipFields, Plural, camelPlural, Singular, hasListRels) : hasListRels ? `
 
     const populated${Plural} = await Promise.all(
       results.map(record => populate${Singular}ListRelationships(record as ${Singular}Data))
@@ -3572,72 +4126,26 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
       ${camelPlural}: results as ${Singular}Data[],
       total: results.length
     }`;
-  const listResultMapping = hasHtmlOutput && hasRelationships ? buildResultMapping(listDbFields, relationshipFields, Plural, camelPlural, Singular, hasListRels) : resultMapping;
+  const listResultMapping = hasHtmlOutput && hasRelationships ? buildResultMapping(
+    listDbFields,
+    relationshipFields,
+    Plural,
+    camelPlural,
+    Singular,
+    hasListRels
+  ) : resultMapping;
   const fieldMeta = createFields.map((f) => `{ name: '${f.name}', type: '${f.type}', required: ${f.required ?? false} }`).join(",\n    ");
   const createMappings = createFields.map((f) => `      ${f.name}: ${generateFieldMapping(f)}`).join(",\n");
   const htmlCreateBlock = hasHtmlOutput ? `
     const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
 ` + htmlOutputFields.map((f) => `    const ${f.name}Html = renderMarkdownSync(input.${f.name} || '')`).join("\n") + "\n" : "";
   const htmlCreateMappings = htmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n");
-  const distinctFns = hasFilters ? (schema.filters || []).map(
-    (filter) => `
-export async function getDistinct${Plural}${toPascalCase(filter.field)}(): Promise<string[]> {
-  try {
-    const results = await db
-      .selectDistinct({ value: ${tableVar}.${filter.field} })
-      .from(${tableVar})
-      .where(isNotNull(${tableVar}.${filter.field}))
-      .orderBy(asc(${tableVar}.${filter.field}))
-    return results.map((r) => String(r.value)).filter(Boolean)
-  } catch (error) {
-    console.error('Error fetching distinct ${plural} ${filter.field}:', error)
-    return []
-  }
-}`
-  ).join("\n") : "";
-  const m2mHelpers = hasM2M ? m2mFields.map((f) => {
-    const rel = f.relationship || "";
-    const RelPascal = toPascalCase(rel);
-    const relSingular = singularize(rel);
-    const junctionVar = toCamelCase(`${singular}${RelPascal}`);
-    const entityIdCol = `${singular}Id`;
-    const relIdCol = `${relSingular}Id`;
-    return `
-export async function get${RelPascal}For${Singular}(${singular}Id: number): Promise<number[]> {
-  try {
-    const results = await db.select({ ${relIdCol}: ${junctionVar}.${relIdCol} }).from(${junctionVar}).where(eq(${junctionVar}.${entityIdCol}, ${singular}Id))
-    return results.map(r => r.${relIdCol})
-  } catch (error) {
-    console.error('Error fetching ${rel} for ${singular}:', error)
-    return []
-  }
-}
-
-export async function set${RelPascal}For${Singular}(${singular}Id: number, ${rel}Ids: number[]): Promise<{ success: boolean; error?: string }> {
-  try {
-    await db.delete(${junctionVar}).where(eq(${junctionVar}.${entityIdCol}, ${singular}Id))
-    if (${rel}Ids.length > 0) {
-      await db.insert(${junctionVar}).values(${rel}Ids.map(${relSingular}Id => ({ ${entityIdCol}: ${singular}Id, ${relIdCol}: ${relSingular}Id })))
-    }
-    updateTag(CACHE_TAG)
-    return { success: true }
-  } catch (error) {
-    console.error('Error setting ${rel} for ${singular}:', error)
-    return { success: false, error: error instanceof Error ? error.message : 'Failed to set ${rel}' }
-  }
-}`;
-  }).join("\n") : "";
-  const slugifyHelper = schema.autoSlugify?.enabled ? `
-function slugify(text: string): string {
-  return text.toLowerCase().trim().replace(/[^\\w\\s-]/g, '').replace(/\\s+/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '')
-}
-` : "";
-  const autoSlugCreate = schema.autoSlugify?.enabled ? `
+  const autoSlugCreate = hasAutoSlug ? `
     if ((!input.${schema.autoSlugify.targetField} || input.${schema.autoSlugify.targetField} === '') && input.${schema.autoSlugify.sourceField}) {
       input.${schema.autoSlugify.targetField} = slugify(input.${schema.autoSlugify.sourceField})
     }
 ` : "";
-  const autoSlugUpdate = schema.autoSlugify?.enabled ? `
+  const autoSlugUpdate = hasAutoSlug ? `
     if (updateData.${schema.autoSlugify.sourceField}) {
       if (updateData.${schema.autoSlugify.targetField} === '' || updateData.${schema.autoSlugify.targetField} === undefined) {
         updateData.${schema.autoSlugify.targetField} = slugify(updateData.${schema.autoSlugify.sourceField})
@@ -3674,230 +4182,54 @@ function slugify(text: string): string {
     }
     return `return result[0] as ${displayType}`;
   })() : singleRowReturn;
-  const content = `'use server'
-
-import db from '@cms/db'
-import { ${sortedDbImports.join(", ")} } from '@cms/db/schema'
-import { ${sortedDrizzleImports.join(", ")} } from 'drizzle-orm'
-import { updateTag } from 'next/cache'
-
-const CACHE_TAG = '${cacheTag}'
-
-${dataInterface}${displayDataInterface}
-
-${responseInterface}
-
-${filtersInterface}
-
-${createInterface}
-
-export interface Create${Singular}Result {
-  success: boolean
-  error?: string
-  ${camelSingular}?: ${Singular}Data
-}
-
-${updateInterface}
-
-export interface Update${Singular}Result {
-  success: boolean
-  error?: string
-  ${camelSingular}?: ${Singular}Data
-}
-
-export interface Delete${Singular}Result {
-  success: boolean
-  error?: string
-}
-${slugifyHelper}${populateListRelsFn}
-export async function get${Plural}(filters?: Get${Plural}Filters): Promise<${Plural}Response> {
-  try {
-    const conditions = []
-${searchBlock}${filterConditions}
-
-    const query = ${listSelectClause}
-
-    const orderedQuery = conditions.length > 0
-      ? query.where(and(...conditions)).orderBy(asc(${tableVar}.sortOrder))
-      : query.orderBy(asc(${tableVar}.sortOrder))
-
-    const results = filters?.limit && filters.limit > 0
-      ? await orderedQuery.limit(filters.limit)
-      : await orderedQuery${listResultMapping}
-  } catch (error) {
-    console.error('Error fetching ${plural}:', error)
-    return { ${camelPlural}: [], total: 0 }
-  }
-}
-${distinctFns}
-
-export async function get${Singular}ById(id: number): Promise<${Singular}Data | null> {
-  try {
-    const result = await ${selectClause}.where(eq(${tableVar}.id, id)).limit(1)
-    if (result.length === 0) return null
-    ${singleRowReturn}
-  } catch (error) {
-    console.error('Error fetching ${singular}:', error)
-    return null
-  }
-}${hasSlug ? `
-
-export async function get${Singular}BySlug(slug: string): Promise<${hasHtmlOutput ? `${Singular}DisplayData` : `${Singular}Data`} | null> {
-  try {
-    const result = await ${displaySelectClause}.where(eq(${tableVar}.slug, slug)).limit(1)
-    if (result.length === 0) return null
-    ${displaySingleRowReturn}
-  } catch (error) {
-    console.error('Error fetching ${singular} by slug:', error)
-    return null
-  }
-}` : ""}
-
-export async function create${Singular}(input: Create${Singular}Input): Promise<Create${Singular}Result> {
-  try {${autoSlugCreate}
-    const maxSortOrderResult = await db
-      .select({ maxOrder: ${tableVar}.sortOrder })
-      .from(${tableVar})
-      .orderBy(desc(${tableVar}.sortOrder))
-      .limit(1)
-    const nextSortOrder = (maxSortOrderResult[0]?.maxOrder ?? 0) + 1
-${htmlCreateBlock}
-    const result = await db.insert(${tableVar}).values({
-${createMappings},${hasHtmlOutput ? `
-${htmlCreateMappings},` : ""}${hasDraft ? `
-      published: input.published ?? false,` : ""}
-      sortOrder: nextSortOrder,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString()
-    }).returning()
-
-    updateTag(CACHE_TAG)
-
-    return {
-      success: true,
-      ${camelSingular}: result[0] as ${Singular}Data
-    }
-  } catch (error) {
-    console.error('Error creating ${singular}:', error)
-    throw new Error(error instanceof Error ? error.message : 'Failed to create ${singular}')
-  }
-}
-
-export async function update${Singular}(input: Update${Singular}Input): Promise<Update${Singular}Result> {
-  try {
-    const { id, ...updateData } = input
-${autoSlugUpdate}
-    const fieldMeta = [
-    ${fieldMeta}
-    ]
-
-    const processedData: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(updateData)) {
-      if (key === 'published') { processedData[key] = value; continue }
-      const field = fieldMeta.find(f => f.name === key)
-      if (!field) continue
-      if (field.type === 'list') {
-        processedData[key] = value || []
-      } else if (!field.required && ['date', 'timestamp', 'time', 'string', 'varchar', 'text', 'select'].includes(field.type)) {
-        processedData[key] = value && value !== '' ? value : null
-      } else {
-        processedData[key] = value
-      }
-    }
-${hasHtmlOutput ? `
-    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
-` + htmlOutputFields.map((f) => `    if (processedData.${f.name} !== undefined) {
-      processedData.${f.name}Html = renderMarkdownSync(String(processedData.${f.name} || ''))
-    }`).join("\n") + "\n" : ""}
-    const result = await db.update(${tableVar})
-      .set({ ...processedData, updatedAt: new Date().toISOString() })
-      .where(eq(${tableVar}.id, id))
-      .returning()
-
-    if (result.length === 0) throw new Error('${Singular} not found')
-
-    updateTag(CACHE_TAG)
-
-    return {
-      success: true,
-      ${camelSingular}: result[0] as ${Singular}Data
-    }
-  } catch (error) {
-    console.error('Error updating ${singular}:', error)
-    throw new Error(error instanceof Error ? error.message : 'Failed to update ${singular}')
-  }
-}
-
-export async function delete${Singular}(id: number): Promise<Delete${Singular}Result> {
-  try {
-    await db.delete(${tableVar}).where(eq(${tableVar}.id, id))
-    updateTag(CACHE_TAG)
-    return { success: true }
-  } catch (error) {
-    console.error('Error deleting ${singular}:', error)
-    return { success: false, error: error instanceof Error ? error.message : 'Failed to delete ${singular}' }
-  }
-}
-
-export async function deleteBulk${Plural}(ids: number[]): Promise<Delete${Singular}Result> {
-  try {
-    if (ids.length === 0) return { success: false, error: 'No items selected for deletion' }
-    await db.delete(${tableVar}).where(inArray(${tableVar}.id, ids))
-    updateTag(CACHE_TAG)
-    return { success: true }
-  } catch (error) {
-    console.error('Error deleting ${plural}:', error)
-    return { success: false, error: error instanceof Error ? error.message : 'Failed to delete ${plural}' }
-  }
-}
-
-export async function update${Singular}SortOrder(
-  id: number,
-  direction: 'up' | 'down'
-): Promise<{ success: boolean; error?: string }> {
-  try {
-    const current = await db.select({ id: ${tableVar}.id, sortOrder: ${tableVar}.sortOrder }).from(${tableVar}).where(eq(${tableVar}.id, id)).limit(1)
-    if (current.length === 0) return { success: false, error: '${Singular} not found' }
-
-    const currentSortOrder = current[0].sortOrder
-    const adjacent = await db
-      .select({ id: ${tableVar}.id, sortOrder: ${tableVar}.sortOrder })
-      .from(${tableVar})
-      .where(direction === 'up' ? lt(${tableVar}.sortOrder, currentSortOrder) : gt(${tableVar}.sortOrder, currentSortOrder))
-      .orderBy(direction === 'up' ? desc(${tableVar}.sortOrder) : asc(${tableVar}.sortOrder))
-      .limit(1)
-
-    if (adjacent.length === 0) return { success: true }
-
-    await db.update(${tableVar}).set({ sortOrder: adjacent[0].sortOrder }).where(eq(${tableVar}.id, id))
-    await db.update(${tableVar}).set({ sortOrder: currentSortOrder }).where(eq(${tableVar}.id, adjacent[0].id))
-    updateTag(CACHE_TAG)
-    return { success: true }
-  } catch (error) {
-    console.error('Error updating sort order:', error)
-    return { success: false, error: error instanceof Error ? error.message : 'Failed to update sort order' }
-  }
-}
-
-export async function bulkUpdate${Plural}SortOrder(
-  updates: Array<{ id: number; sortOrder: number }>
-): Promise<{ success: boolean; error?: string }> {
-  try {
-    if (updates.length === 0) return { success: true }
-    await Promise.all(updates.map((u) => db.update(${tableVar}).set({ sortOrder: u.sortOrder }).where(eq(${tableVar}.id, u.id))))
-    updateTag(CACHE_TAG)
-    return { success: true }
-  } catch (error) {
-    console.error('Error bulk updating sort order:', error)
-    return { success: false, error: error instanceof Error ? error.message : 'Failed to bulk update sort order' }
-  }
-}${m2mHelpers}
-`;
-  if (!fs12.existsSync(absActionsDir)) {
-    fs12.mkdirSync(absActionsDir, { recursive: true });
-  }
-  fs12.writeFileSync(filePath, content, "utf-8");
-  return { files: [path12.join(actionsDir, `${schema.name}.ts`)] };
+  return {
+    singular,
+    plural,
+    Singular,
+    Plural,
+    tableVar,
+    camelSingular,
+    camelPlural,
+    cacheTag,
+    hasRelationships,
+    hasM2M,
+    hasListRels,
+    hasHtmlOutput,
+    hasSlug,
+    hasDraft,
+    hasSearch,
+    hasFilters,
+    hasAutoSlug,
+    searchFields,
+    htmlOutputFields,
+    m2mFields,
+    filterableFields,
+    relTableImports,
+    listRelTableImports,
+    dataInterface,
+    displayDataInterface,
+    responseInterface,
+    filtersInterface,
+    createInterface,
+    updateInterface,
+    selectClause,
+    listSelectClause,
+    displaySelectClause,
+    filterConditions,
+    searchBlock,
+    resultMapping,
+    listResultMapping,
+    singleRowReturn,
+    displaySingleRowReturn,
+    fieldMeta,
+    createMappings,
+    htmlCreateBlock,
+    htmlCreateMappings,
+    autoSlugCreate,
+    autoSlugUpdate,
+    populateListRelsFn,
+    filters: schema.filters || []
+  };
 }
 
 // src/generators/actions/single-actions.ts
@@ -3905,21 +4237,27 @@ import fs13 from "fs";
 import path13 from "path";
 function generateSingleActions(schema, cwd, actionsDir, options = {}) {
   const absActionsDir = path13.join(cwd, actionsDir);
-  const filePath = path13.join(absActionsDir, `${schema.name}.ts`);
-  if (fs13.existsSync(filePath) && !options.force) {
+  const dirPath = path13.join(absActionsDir, schema.name);
+  const oldFilePath = path13.join(absActionsDir, `${schema.name}.ts`);
+  if (!options.force && (fs13.existsSync(dirPath) || fs13.existsSync(oldFilePath))) {
     return { files: [] };
   }
+  if (options.force) {
+    if (fs13.existsSync(oldFilePath)) fs13.unlinkSync(oldFilePath);
+    if (fs13.existsSync(dirPath)) fs13.rmSync(dirPath, { recursive: true });
+  }
   const singular = singularize(schema.name);
   const Singular = toPascalCase(singular);
   const tableVar = toCamelCase(schema.name);
   const camelSingular = toCamelCase(singular);
+  const kebabSingular = toKebabCase(singular);
   const dbFields = flattenFields(schema.fields).filter(
     (f) => !(f.type === "relationship" && f.multiple === true)
   );
-  const singleHtmlOutputFields = dbFields.filter(
+  const htmlOutputFields = dbFields.filter(
     (f) => (f.type === "richtext" || f.type === "markdown") && f.output === "html"
   );
-  const singleHasHtmlOutput = singleHtmlOutputFields.length > 0;
+  const hasHtmlOutput = htmlOutputFields.length > 0;
   const allDbFields = [...dbFields];
   if (!dbFields.some((f) => f.name === "createdAt")) {
     allDbFields.push({ name: "createdAt", type: "timestamp", required: true });
@@ -3933,39 +4271,34 @@ function generateSingleActions(schema, cwd, actionsDir, options = {}) {
   const dataFields = allDbFields.map(
     (f) => `  ${quotePropertyName(f.name)}: ${getFieldType(f, "output")}${f.required ? "" : " | null"}`
   ).join("\n");
-  const singleHtmlFieldTypes = singleHtmlOutputFields.map((f) => `  ${f.name}Html: string`).join("\n");
-  const dataInterface = `export interface ${Singular}Data {
-${dataFields}${singleHtmlFieldTypes ? `
-${singleHtmlFieldTypes}` : ""}
-}`;
+  const htmlFieldTypes = htmlOutputFields.map((f) => `  ${f.name}Html: string`).join("\n");
   const upsertInterfaceFields = upsertFields.map(
     (f) => `  ${quotePropertyName(f.name)}${f.required ? "" : "?"}: ${getFieldType(f, "input")}`
   ).join("\n");
-  const upsertInterface = `export interface Upsert${Singular}Input {
-${upsertInterfaceFields}
-}`;
-  const upsertMappings = upsertFields.map((f) => `      ${f.name}: ${generateFieldMapping(f)}`).join(",\n");
   const fieldMeta = upsertFields.map((f) => `{ name: '${f.name}', type: '${f.type}', required: ${f.required ?? false} }`).join(",\n    ");
+  const upsertMappings = upsertFields.map((f) => `      ${f.name}: ${generateFieldMapping(f)}`).join(",\n");
   const cacheTag = `${schema.name}:all`;
-  const singleHtmlUpsertMappings = singleHtmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n");
-  const content = `'use server'
+  const typesContent = [
+    `export interface ${Singular}Data {
+${dataFields}${htmlFieldTypes ? `
+${htmlFieldTypes}` : ""}
+}`,
+    `export interface Upsert${Singular}Input {
+${upsertInterfaceFields}
+}`,
+    `export interface Upsert${Singular}Result {
+  success: boolean
+  error?: string
+  ${camelSingular}?: ${Singular}Data
+}`,
+    `export const CACHE_TAG = '${cacheTag}'`
+  ].join("\n\n") + "\n";
+  const getContent = `'use server'
 
 import db from '@cms/db'
 import { ${tableVar} } from '@cms/db/schema'
 import { eq } from 'drizzle-orm'
-import { updateTag } from 'next/cache'
-
-const CACHE_TAG = '${cacheTag}'
-
-${dataInterface}
-
-${upsertInterface}
-
-export interface Upsert${Singular}Result {
-  success: boolean
-  error?: string
-  ${camelSingular}?: ${Singular}Data
-}
+import type { ${Singular}Data } from './types'
 
 export async function get${Singular}(): Promise<${Singular}Data | null> {
   try {
@@ -3977,6 +4310,20 @@ export async function get${Singular}(): Promise<${Singular}Data | null> {
     return null
   }
 }
+`;
+  const htmlUpsertBlock = hasHtmlOutput ? `
+    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
+` + htmlOutputFields.map((f) => `    if (processedData.${f.name} !== undefined) {
+      processedData.${f.name}Html = renderMarkdownSync(String(processedData.${f.name} || ''))
+    }`).join("\n") + "\n" + htmlOutputFields.map((f) => `    const ${f.name}Html = renderMarkdownSync(input.${f.name} || '')`).join("\n") + "\n" : "";
+  const htmlUpsertMappings = hasHtmlOutput ? "\n" + htmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n") + "," : "";
+  const upsertContent = `'use server'
+
+import db from '@cms/db'
+import { ${tableVar} } from '@cms/db/schema'
+import { updateTag } from 'next/cache'
+import { CACHE_TAG } from './types'
+import type { Upsert${Singular}Input, Upsert${Singular}Result, ${Singular}Data } from './types'
 
 export async function upsert${Singular}(input: Upsert${Singular}Input): Promise<Upsert${Singular}Result> {
   try {
@@ -3996,18 +4343,14 @@ export async function upsert${Singular}(input: Upsert${Singular}Input): Promise<
         processedData[key] = value
       }
     }
-${singleHasHtmlOutput ? `
-    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
-` + singleHtmlOutputFields.map((f) => `    if (processedData.${f.name} !== undefined) {
-      processedData.${f.name}Html = renderMarkdownSync(String(processedData.${f.name} || ''))
-    }`).join("\n") + "\n" + singleHtmlOutputFields.map((f) => `    const ${f.name}Html = renderMarkdownSync(input.${f.name} || '')`).join("\n") + "\n" : ""}
+${htmlUpsertBlock}
     const now = new Date().toISOString()
 
     const result = await db
       .insert(${tableVar})
       .values({
         id: 1,
-${upsertMappings},${singleHasHtmlOutput ? "\n" + singleHtmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n") + "," : ""}
+${upsertMappings},${htmlUpsertMappings}
         createdAt: now,
         updatedAt: now
       })
@@ -4029,11 +4372,21 @@ ${upsertMappings},${singleHasHtmlOutput ? "\n" + singleHtmlOutputFields.map((f)
   }
 }
 `;
-  if (!fs13.existsSync(absActionsDir)) {
-    fs13.mkdirSync(absActionsDir, { recursive: true });
+  const barrelContent = `export type { ${Singular}Data, Upsert${Singular}Input, Upsert${Singular}Result } from './types'
+export { get${Singular} } from './get-${kebabSingular}'
+export { upsert${Singular} } from './upsert-${kebabSingular}'
+`;
+  const files = [
+    { name: "types.ts", content: typesContent },
+    { name: `get-${kebabSingular}.ts`, content: getContent },
+    { name: `upsert-${kebabSingular}.ts`, content: upsertContent },
+    { name: "index.ts", content: barrelContent }
+  ];
+  fs13.mkdirSync(dirPath, { recursive: true });
+  for (const file of files) {
+    fs13.writeFileSync(path13.join(dirPath, file.name), file.content, "utf-8");
   }
-  fs13.writeFileSync(filePath, content, "utf-8");
-  return { files: [path13.join(actionsDir, `${schema.name}.ts`)] };
+  return { files: files.map((f) => path13.join(actionsDir, schema.name, f.name)) };
 }
 
 // src/generators/cache.ts
@@ -4106,7 +4459,7 @@ ${entries.join(",\n")}
 }
 function generateCachedQueries(configs) {
   const actionImports = [];
-  const typeImports = [];
+  const typeImportsBySchema = /* @__PURE__ */ new Map();
   const fns = [];
   for (const c of configs) {
     if (c.isSingle) {
@@ -4120,7 +4473,9 @@ export const getCached${c.pascalSingular} = async () => {
       continue;
     }
     actionImports.push(`get${c.pascalPlural}`);
-    typeImports.push(`Get${c.pascalPlural}Filters`);
+    const types = typeImportsBySchema.get(c.name) || [];
+    types.push(`Get${c.pascalPlural}Filters`);
+    typeImportsBySchema.set(c.name, types);
     if (c.hasSlug) actionImports.push(`get${c.pascalSingular}BySlug`);
     for (const n of c.nestedLookups) actionImports.push(`get${n.pascalName}BySlug`);
     fns.push(`
@@ -4149,11 +4504,7 @@ export const getCached${n.pascalName}BySlug = async (${c.singularName}Slug: stri
     }
   }
   actionImports.sort();
-  typeImports.sort();
-  const typeImportStr = typeImports.length > 0 ? `${typeImports.map((t) => {
-    const schemaName = t.replace(/^Get/, "").replace(/Filters$/, "").toLowerCase();
-    return `import type { ${t} } from '@cms/actions/${schemaName}'`;
-  }).join("\n")}
+  const typeImportStr = typeImportsBySchema.size > 0 ? `${Array.from(typeImportsBySchema.entries()).map(([schemaName, types]) => `import type { ${types.sort().join(", ")} } from '@cms/actions/${schemaName}'`).join("\n")}
 ` : "";
   const actionsBySchema = /* @__PURE__ */ new Map();
   for (const c of configs) {
@@ -12200,6 +12551,7 @@ var CORE_DEPS = [
   "input-otp",
   "react-resizable-panels",
   "recharts",
+  "shadcn",
   "tw-animate-css",
   "usehooks-ts",
   "vaul"
@@ -14942,8 +15294,15 @@ var removeCommand = new Command4("remove").alias("rm").description("Remove all g
       isDir: true
     });
   }
+  const actionsDir = path46.join(cwd, cmsDir, "lib", "actions", kebabName);
   const actionsFile = path46.join(cwd, cmsDir, "lib", "actions", `${kebabName}.ts`);
-  if (fs41.existsSync(actionsFile)) {
+  if (fs41.existsSync(actionsDir)) {
+    targets.push({
+      path: actionsDir,
+      label: `${path46.join(cmsDir, "lib", "actions", kebabName)}/`,
+      isDir: true
+    });
+  } else if (fs41.existsSync(actionsFile)) {
     targets.push({
       path: actionsFile,
       label: path46.join(cmsDir, "lib", "actions", `${kebabName}.ts`),