@cedarjs/cli 7.0.1-next.333 → 7.0.1-next.466

package/dist/commands/destroy/scaffold/scaffoldHandler.js

@@ -1,8 +1,7 @@
+import { parse } from "@babel/parser";
 import { Listr } from "listr2";
-import pascalcase from "pascalcase";
 import { colors as c } from "@cedarjs/cli-helpers/colors";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
-import { pluralize } from "@cedarjs/utils/cedarPluralize";
 import {
   deleteFilesTask,
   getPaths,
@@ -13,6 +12,7 @@ import {
 import { verifyModelName } from "../../../lib/schemaHelpers.js";
 import {
   files,
+  getScaffoldLayoutNames,
   routes as scaffoldRoutes,
   splitPathAndModel
 } from "../../generate/scaffold/scaffoldHandler.js";
@@ -23,45 +23,83 @@ const removeRoutesWithSet = async ({
 }) => {
   const routes = await scaffoldRoutes({ model, path, nestScaffoldByModel });
   const routeNames = routes.map(extractRouteName);
-  const pluralPascalName = pascalcase(pluralize(model));
-  const layoutName = `${pluralPascalName}Layout`;
-  return removeRoutesFromRouterTask(routeNames, layoutName);
+  const { importName } = getScaffoldLayoutNames(model, path);
+  return removeRoutesFromRouterTask(routeNames, importName);
+};
+const removeNamedImport = (code, source, name) => {
+  const program = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"]
+  }).program;
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== source) {
+      continue;
+    }
+    const specifiers = statement.specifiers;
+    const index = specifiers.findIndex(
+      (specifier2) => specifier2.type === "ImportSpecifier" && specifier2.imported.type === "Identifier" && specifier2.imported.name === name && specifier2.local.name === name
+    );
+    if (index === -1) {
+      continue;
+    }
+    const specifier = specifiers[index];
+    let start;
+    let end;
+    if (specifiers.length === 1) {
+      start = statement.start ?? 0;
+      end = statement.end ?? 0;
+      if (code[end] === "\n") {
+        end++;
+      }
+    } else if (index === specifiers.length - 1) {
+      start = specifiers[index - 1].end ?? 0;
+      end = specifier.end ?? 0;
+    } else {
+      start = specifier.start ?? 0;
+      end = specifiers[index + 1].start ?? 0;
+    }
+    return code.slice(0, start) + code.slice(end);
+  }
+  return code;
 };
 const removeSetImport = () => {
   const routesPath = getPaths().web.routes;
   const routesContent = readFile(routesPath).toString();
-  if (routesContent.match("<Set")) {
+  const unusedNames = ["Set", "PrivateSet"].filter(
+    (name) => !new RegExp(`<${name}\\b`).test(routesContent)
+  );
+  if (unusedNames.length === 0) {
     return "Skipping removal of Set import in Routes.{jsx,tsx}";
   }
-  const cedarRouterImportMatch = routesContent.match(
-    /import {[^]*} from '@cedarjs\/router'/
-  );
-  if (!cedarRouterImportMatch) {
-    return "No @cedarjs/router import found in Routes.{jsx,tsx}";
+  let newRoutesContent = routesContent;
+  try {
+    for (const name of unusedNames) {
+      newRoutesContent = removeNamedImport(
+        newRoutesContent,
+        "@cedarjs/router",
+        name
+      );
+    }
+  } catch {
+    return "Skipping removal of Set import, Routes.{jsx,tsx} couldn't be parsed";
+  }
+  if (newRoutesContent === routesContent) {
+    return "No unused Set or PrivateSet import found in Routes.{jsx,tsx}";
   }
-  const [cedarRouterImport] = cedarRouterImportMatch;
-  const removedSetImport = cedarRouterImport.replace(/,*\s*Set,*/, "");
-  const newRoutesContent = routesContent.replace(
-    cedarRouterImport,
-    removedSetImport
-  );
   writeFile(routesPath, newRoutesContent, { overwriteExisting: true });
-  return "Removed Set import in Routes.{jsx,tsx}";
+  return "Removed unused Set and PrivateSet imports in Routes.{jsx,tsx}";
 };
 const removeLayoutImport = ({
   model: name,
   path: scaffoldPath = ""
 }) => {
-  const pluralPascalName = pascalcase(pluralize(name));
-  const pascalScaffoldPath = scaffoldPath === "" ? scaffoldPath : scaffoldPath.split("/").map(pascalcase).join("/") + "/";
-  const layoutName = `${pluralPascalName}Layout`;
-  const importLayout = `import ${pluralPascalName}Layout from 'src/layouts/${pascalScaffoldPath}${layoutName}'`;
+  const { importName, importPath } = getScaffoldLayoutNames(name, scaffoldPath);
   const routesPath = getPaths().web.routes;
   const routesContent = readFile(routesPath).toString();
-  const newRoutesContent = routesContent.replace(
-    new RegExp(`\\s*${importLayout}`),
-    ""
+  const importLayout = new RegExp(
+    `\\s*import ${importName} from (['"])${importPath}\\1;?`
   );
+  const newRoutesContent = routesContent.replace(importLayout, "");
   writeFile(routesPath, newRoutesContent, { overwriteExisting: true });
   return "Removed layout import from Routes.{jsx,tsx}";
 };

package/dist/commands/dev/devHandler.js

@@ -185,21 +185,33 @@ const handler = async ({
   const rootPackageJson = JSON.parse(
     fs.readFileSync(rootPackageJsonPath, "utf8")
   );
+  const warnUdFallback = (reason) => {
+    console.warn(
+      c.warning(
+        `--ud has no effect: ${reason}. Falling back to classic dev-server mode.`
+      )
+    );
+  };
   const buildUnifiedDevCommand = () => {
     if (!ud) {
       return null;
     }
     if (streamingSsrEnabled) {
+      warnUdFallback("streaming SSR uses its own dev server");
       return null;
     }
     if (!workspace.includes("api") || !workspace.includes("web")) {
+      warnUdFallback("the unified dev server needs both the api and web sides");
       return null;
     }
     if (serverFile) {
+      warnUdFallback(
+        "the unified dev server does not support a custom server file"
+      );
       return null;
     }
     if (!fs.existsSync(cedarPaths.api.src) || !fs.existsSync(cedarPaths.web.src)) {
-      console.log("api.src or web.src does not exist");
+      warnUdFallback("api.src or web.src does not exist");
       return null;
     }
     return [

package/dist/commands/generate/dbAuth/templates/login.webAuthn.tsx.template

@@ -17,7 +17,7 @@ import { useAuth } from 'src/auth'
 const WELCOME_MESSAGE = 'Welcome back!'
 const REDIRECT = routes.home()
 
-const LoginPage = ({ type }) => {
+const LoginPage = ({ type }: { type?: string }) => {
   const {
     isAuthenticated,
     client: webAuthn,
@@ -27,12 +27,12 @@ const LoginPage = ({ type }) => {
   } = useAuth()
   const [shouldShowWebAuthn, setShouldShowWebAuthn] = useState(false)
   const [showWebAuthn, setShowWebAuthn] = useState(
-    webAuthn.isEnabled() && type !== 'password'
+    !!webAuthn?.isEnabled() && type !== 'password'
   )
 
   // should redirect right after login or wait to show the webAuthn prompts?
   useEffect(() => {
-    if (isAuthenticated && (!shouldShowWebAuthn || webAuthn.isEnabled())) {
+    if (isAuthenticated && (!shouldShowWebAuthn || webAuthn?.isEnabled())) {
       navigate(REDIRECT)
     }
   }, [isAuthenticated, shouldShowWebAuthn])
@@ -45,13 +45,13 @@ const LoginPage = ({ type }) => {
   }, [loading, isAuthenticated])
 
   // focus on the ${usernameLowerCase} field as soon as the page loads
-  const ${usernameCamelCase}Ref = useRef()
+  const ${usernameCamelCase}Ref = useRef<HTMLInputElement>(null)
   useEffect(() => {
-    ${usernameCamelCase}Ref.current && ${usernameCamelCase}Ref.current.focus()
+    ${usernameCamelCase}Ref.current?.focus()
   }, [])
 
-  const onSubmit = async (data) => {
-    const webAuthnSupported = await webAuthn.isSupported()
+  const onSubmit = async (data: Record<string, string>) => {
+    const webAuthnSupported = !!(await webAuthn?.isSupported())
 
     if (webAuthnSupported) {
       setShouldShowWebAuthn(true)
@@ -75,30 +75,38 @@ const LoginPage = ({ type }) => {
   }
 
   const onAuthenticate = async () => {
+    if (!webAuthn) {
+      return
+    }
+
     try {
       await webAuthn.authenticate()
       await reauthenticate()
       toast.success(WELCOME_MESSAGE)
       navigate(REDIRECT)
     } catch (e) {
-      if (e.name === 'WebAuthnDeviceNotFoundError') {
+      if (e instanceof Error && e.name === 'WebAuthnDeviceNotFoundError') {
         toast.error(
           'Device not found, log in with ${usernameTitleCase}/${passwordTitleCase} to continue'
         )
         setShowWebAuthn(false)
       } else {
-        toast.error(e.message)
+        toast.error(e instanceof Error ? e.message : String(e))
       }
     }
   }
 
   const onRegister = async () => {
+    if (!webAuthn) {
+      return
+    }
+
     try {
       await webAuthn.register()
       toast.success(WELCOME_MESSAGE)
       navigate(REDIRECT)
     } catch (e) {
-      toast.error(e.message)
+      toast.error(e instanceof Error ? e.message : String(e))
     }
   }
 
@@ -200,7 +208,7 @@ const LoginPage = ({ type }) => {
 
   const formToRender = () => {
     if (showWebAuthn) {
-      if (webAuthn.isEnabled()) {
+      if (webAuthn?.isEnabled()) {
         return <AuthWebAuthnPrompt />
       } else {
         return <RegisterWebAuthnPrompt />
@@ -212,7 +220,7 @@ const LoginPage = ({ type }) => {
 
   const linkToRender = () => {
     if (showWebAuthn) {
-      if (webAuthn.isEnabled()) {
+      if (webAuthn?.isEnabled()) {
         return (
           <div className="rw-login-link">
             <span>or login with </span>{' '}

package/dist/commands/generate/helpers.js

@@ -37,11 +37,33 @@ const redactedModelFields = (fieldNames) => {
   }
   return sensitive;
 };
+const DEFAULT_IGNORE_FIELDS_FOR_INPUT = ["createdAt", "updatedAt"];
+const requiredFieldsInUpdateInput = (model) => {
+  return inputFields(model).filter((field) => {
+    return field.isRequired && !field.isList && !field.isId;
+  }).map((field) => field.name);
+};
+const nullableJsonFieldsInInput = (model) => {
+  return inputFields(model).filter((field) => {
+    return field.type === "Json" && !field.isRequired && !field.isList;
+  }).map((field) => field.name);
+};
+const inputFields = (model) => {
+  const redactedFields = redactedModelFields(
+    model.fields.map((field) => field.name)
+  );
+  return model.fields.filter((field) => {
+    return field.kind !== "object" && !DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(field.name) && !redactedFields.includes(field.name);
+  });
+};
 const relationsForModel = (model) => {
   return model?.fields.filter((f) => f.relationName).map((field) => {
     return field.name;
   });
 };
+const nullableRelationsForModel = (model) => {
+  return model.fields.filter((f) => f.kind === "object" && !f.isList && !f.isRequired).map((f) => f.name);
+};
 const intForeignKeysForModel = (model) => {
   return model.fields.filter((f) => f.name.match(/Id$/) && f.type === "Int").map((f) => f.name);
 };
@@ -74,14 +96,18 @@ const mapPrismaScalarToPagePropTsType = (scalarType) => {
   return prismaScalarToTsType[scalarType] || "unknown";
 };
 export {
+  DEFAULT_IGNORE_FIELDS_FOR_INPUT,
   SENSITIVE_FIELDS,
   forcePluralizeWord,
   intForeignKeysForModel,
   mapPrismaScalarToPagePropTsType,
   mapRouteParamTypeToTsType,
+  nullableJsonFieldsInInput,
+  nullableRelationsForModel,
   pathName,
   redactedModelFields,
   relationsForModel,
   removeGeneratorName,
+  requiredFieldsInUpdateInput,
   validateName
 };

package/dist/commands/generate/ogImage/templates/ogImage.og.tsx.template

@@ -2,7 +2,7 @@ export const data = async () => {
   return new Date()
 }
 
-export const output = ({ data }) => {
+export const output = ({ data }: { data: Date }) => {
   return (
     <>
       <h1>${pageName} og:image</h1>

package/dist/commands/generate/package/templates/tsconfig.json.template

@@ -4,6 +4,7 @@
     "target": "es2023",
     "module": "node20",
     "esModuleInterop": true,
+    "strict": true,
     "skipLibCheck": true,
     "baseUrl": ".",
     "rootDir": "src",

package/dist/commands/generate/realtime/templates/liveQueries/blank/blank.service.ts.template

@@ -1,9 +1,17 @@
 // api/src/services/${name}s/${name}s.ts
+import type { ${typeName}ItemInput } from 'types/graphql'
+
 import type { LiveQueryStorageMechanism } from '@cedarjs/realtime'
 
 import { logger } from 'src/lib/logger'
 
-const ${collectionName} = [
+interface ${typeName}Data {
+  id: string
+  title: string
+  items: { amount: number }[]
+}
+
+const ${collectionName}: ${typeName}Data[] = [
   { id: '1', title: 'First ${modelName}', items: [{ amount: 11 }] },
   { id: '2', title: '2nd ${modelName}', items: [{ amount: 22 }] },
   { id: '3', title: 'Third ${modelName}',  items: [{ amount: 33 }] },
@@ -35,14 +43,14 @@ const ${collectionName} = [
  *   }
  * }
  */
-export const ${liveQueryName} = async ({ id }) => {
+export const ${liveQueryName} = async ({ id }: { id: string }) => {
   const found${modelName} = ${collectionName}.find((a) => a.id === id)
   logger.debug({ id, ${name}: found${modelName} }, `${name} details`)
   return found${modelName}
 }
 
 export const create${typeName}Item = async (
-  { input },
+  { input }: { input: ${typeName}ItemInput },
   { context }: { context: { liveQueryStore: LiveQueryStorageMechanism } }
 ) => {
   const { ${camelName}Id, amount } = input
@@ -63,7 +71,7 @@ export const create${typeName}Item = async (
 }
 
 export const ${modelName} = {
-  largest${typeName}Item: (obj, { root }) => {
+  largest${typeName}Item: (obj: unknown, { root }: { root: ${typeName}Data }) => {
     const [largest] = root.items.sort((a, b) => b.amount - a.amount)
 
     logger.debug({ obj, root }, 'largest ${typeName}Item')

package/dist/commands/generate/realtime/templates/subscriptions/blank/blank.service.ts.template

@@ -1,9 +1,9 @@
 import type { ${subscriptionInputType} } from 'types/graphql'
 
 import { logger } from 'src/lib/logger'
-import type { Publish${typeName}ChannelType } from 'src/subscriptions/${name}/${name}.service.js'
+import type { Publish${typeName}ChannelType } from 'src/subscriptions/${name}/${name}.js'
 
-export const ${subscriptionQueryName} = ({ id }) => [id]
+export const ${subscriptionQueryName} = ({ id }: { id: string }) => [id]
 
 export const ${subscriptionServiceResolver} = async (
   { input }: { input: ${subscriptionInputType} },

package/dist/commands/generate/realtime/templates/subscriptions/blank/blank.ts.template

@@ -39,15 +39,15 @@ export type Publish${typeName}ChannelType = PubSub<Publish${typeName}Channel>
 const ${subscriptionName}Subscription = {
   ${subscriptionName}: {
     subscribe: (
-      _,
-      { id },
+      _: unknown,
+      { id }: { id: string },
       { pubSub }: { pubSub: Publish${typeName}ChannelType }
     ) => {
       logger.debug({ id }, '${name} subscription')
 
       return pubSub.subscribe('${typeName}', id)
     },
-    resolve: (payload) => {
+    resolve: (payload: Publish${typeName}Channel['${typeName}'][1]) => {
       logger.debug({ payload }, '${name} subscription resolve')
 
       return payload

package/dist/commands/generate/scaffold/scaffold.js

@@ -13,7 +13,7 @@ const builder = (yargs) => {
     description: "Generate test files",
     type: "boolean"
   }).option("tailwind", {
-    description: "Generate TailwindCSS version of scaffold.css (automatically set to `true` if TailwindCSS config exists)",
+    description: "Generate TailwindCSS version of scaffold.css (automatically set to `true` if the web side depends on `tailwindcss`)",
     type: "boolean"
   }).option("rollback", {
     description: "Revert all generator actions if an error occurs",

package/dist/commands/generate/scaffold/scaffoldHandler.js

@@ -86,6 +86,18 @@ const getImportComponentNames = (name, scaffoldPath, nestScaffoldByModel = true)
     importLayoutNames: `src/layouts/ScaffoldLayout`
   };
 };
+const getScaffoldLayoutNames = (name, scaffoldPath = "") => {
+  const pluralPascalName = pascalcase(pluralize(name));
+  const directoryName = `${pluralPascalName}ScaffoldLayout`;
+  const pathParts = scaffoldPath === "" ? [] : scaffoldPath.split("/").map(pascalcase);
+  return {
+    directoryName,
+    pathParts,
+    // The name to import the layout as in Routes.{jsx,tsx}
+    importName: pascalcase(scaffoldPath) + directoryName,
+    importPath: ["src/layouts", ...pathParts, directoryName].join("/")
+  };
+};
 const getTemplateStrings = (name, scaffoldPath, nestScaffoldByModel = true) => {
   const nameVars = nameVariants(name);
   const camelScaffoldPath = camelcase(pascalcase(scaffoldPath));
@@ -97,11 +109,21 @@ const getTemplateStrings = (name, scaffoldPath, nestScaffoldByModel = true) => {
     ...getImportComponentNames(name, scaffoldPath, nestScaffoldByModel)
   };
 };
+const webDependsOnTailwindCSS = () => {
+  const webPackageJsonPath = path.join(getPaths().web.base, "package.json");
+  if (!fs.existsSync(webPackageJsonPath)) {
+    return false;
+  }
+  const { dependencies, devDependencies } = JSON.parse(
+    fs.readFileSync(webPackageJsonPath, "utf-8")
+  );
+  return Boolean(
+    dependencies?.["tailwindcss"] || devDependencies?.["tailwindcss"]
+  );
+};
 const shouldUseTailwindCSS = (flag) => {
   if (flag === void 0) {
-    return fs.existsSync(
-      path.join(getPaths().web.config, "tailwind.config.cjs")
-    );
+    return webDependsOnTailwindCSS();
   } else {
     return flag;
   }
@@ -150,7 +172,13 @@ const files = async ({
     }),
     ...await assetFiles(name, tailwind),
     ...await formatters(name, typescript),
-    ...await layoutFiles(name, force, typescript, templateStrings),
+    ...await layoutFiles(
+      name,
+      scaffoldPath,
+      force,
+      typescript,
+      templateStrings
+    ),
     ...await pageFiles(
       name,
       pascalScaffoldPath,
@@ -348,41 +376,57 @@ const modelRelatedVariables = (model) => {
     parsedDateTime: isDateTimeParsed()
   };
 };
-const layoutFiles = async (name, force, generateTypescript, templateStrings) => {
+const layoutFiles = async (name, scaffoldPath, force, generateTypescript, templateStrings) => {
   const fileList = {};
-  const layouts = fs.readdirSync(
+  const extension = generateTypescript ? ".tsx" : ".jsx";
+  const renderLayout = async (templateName, outputPath) => {
+    const template = await generateTemplate(
+      customOrDefaultTemplatePath({
+        side: "web",
+        generator: "scaffold",
+        templatePath: path.join("layouts", templateName)
+      }),
+      {
+        name,
+        pascalScaffoldPath: "",
+        ...templateStrings
+      }
+    );
+    fileList[outputPath] = generateTypescript || !outputPath.endsWith(".jsx") ? template : await transformTSToJS(outputPath, template);
+  };
+  const sharedLayoutDir = path.join(getPaths().web.layouts, "ScaffoldLayout");
+  const sharedLayoutTemplates = fs.readdirSync(
     customOrDefaultTemplatePath({
       side: "web",
       generator: "scaffold",
       templatePath: "layouts"
     })
-  );
-  for (const layout of layouts) {
-    const outputLayoutName = layout.replace(
-      /\.tsx\.template/,
-      generateTypescript ? ".tsx" : ".jsx"
-    );
-    const outputPath = path.join(
-      getPaths().web.layouts,
-      "ScaffoldLayout",
-      outputLayoutName
-    );
-    if (!fs.existsSync(outputPath) || force) {
-      const template = await generateTemplate(
-        customOrDefaultTemplatePath({
-          side: "web",
-          generator: "scaffold",
-          templatePath: path.join("layouts", layout)
-        }),
-        {
-          name,
-          pascalScaffoldPath: "",
-          ...templateStrings
-        }
-      );
-      fileList[outputPath] = generateTypescript ? template : await transformTSToJS(outputPath, template);
+  ).filter((template) => template !== "NamesScaffoldLayout.tsx.template");
+  for (const template of sharedLayoutTemplates) {
+    const isComponent = template.endsWith(".tsx.template");
+    const outputName = isComponent ? template.replace(/\.tsx\.template$/, extension) : template.replace(/\.template$/, "");
+    const exists = isComponent ? [".tsx", ".jsx", ".ts", ".js"].some(
+      (ext) => fs.existsSync(
+        path.join(sharedLayoutDir, outputName.replace(extension, ext))
+      )
+    ) : fs.existsSync(path.join(sharedLayoutDir, outputName));
+    if (!exists || force) {
+      await renderLayout(template, path.join(sharedLayoutDir, outputName));
     }
   }
+  const { directoryName, pathParts } = getScaffoldLayoutNames(
+    name,
+    scaffoldPath
+  );
+  await renderLayout(
+    "NamesScaffoldLayout.tsx.template",
+    path.join(
+      getPaths().web.layouts,
+      ...pathParts,
+      directoryName,
+      directoryName + extension
+    )
+  );
   return fileList;
 };
 const pageFiles = async (name, pascalScaffoldPath = "", generateTypescript, nestScaffoldByModel = true, templateStrings) => {
@@ -424,7 +468,7 @@ const pageFiles = async (name, pascalScaffoldPath = "", generateTypescript, nest
         ...modelRelatedVariables(model)
       }
     );
-    fileList[outputPath] = generateTypescript ? template : await transformTSToJS(outputPath, template);
+    fileList[outputPath] = generateTypescript || !outputPath.endsWith(".jsx") ? template : await transformTSToJS(outputPath, template);
   }
   return fileList;
 };
@@ -472,7 +516,7 @@ const componentFiles = async (name, pascalScaffoldPath = "", generateTypescript,
         ...modelRelatedVariables(model)
       }
     );
-    fileList[outputPath] = generateTypescript ? template : await transformTSToJS(outputPath, template);
+    fileList[outputPath] = generateTypescript || !outputPath.endsWith(".jsx") ? template : await transformTSToJS(outputPath, template);
   }
   return fileList;
 };
@@ -503,8 +547,9 @@ const routes = async ({
     `<Route path="/${paramScaffoldPath}${nameVars.pluralParamName}" page={${pageRoot}${nameVars.pluralPascalName}Page} name="${templateNames.pluralRouteName}" />`
   ];
 };
-const addLayoutImport = () => {
-  const importLayout = `import ScaffoldLayout from 'src/layouts/ScaffoldLayout'`;
+const addLayoutImport = (model, scaffoldPath) => {
+  const { importName, importPath } = getScaffoldLayoutNames(model, scaffoldPath);
+  const importLayout = `import ${importName} from '${importPath}'`;
   const routesPath = getPaths().web.routes;
   const routesContent = readFile(routesPath).toString();
   if (!routesContent.match(importLayout)) {
@@ -618,17 +663,10 @@ const addSetImport = (task) => {
   return `Added ${namesToImport.join(", ")} import to Routes.{jsx,tsx}`;
 };
 const addScaffoldSetToRouter = async (model, scaffoldPath) => {
-  const templateNames = getTemplateStrings(model, scaffoldPath);
-  const nameVars = nameVariants(model);
-  const title = nameVars.pluralPascalName;
-  const titleTo = templateNames.pluralRouteName;
-  const buttonLabel = `New ${nameVars.singularPascalName}`;
-  const buttonTo = templateNames.newRouteName;
   const unauthenticatedRoute = getUnauthenticatedRedirectRoute();
   return addRoutesToRouterTask(
     await routes({ model, path: scaffoldPath }),
-    "ScaffoldLayout",
-    { title, titleTo, buttonLabel, buttonTo },
+    getScaffoldLayoutNames(model, scaffoldPath).importName,
     unauthenticatedRoute ? { unauthenticated: unauthenticatedRoute } : void 0
   );
 };
@@ -669,7 +707,7 @@ const tasks = ({
       },
       {
         title: "Adding layout import...",
-        task: async () => addLayoutImport()
+        task: async () => addLayoutImport(model, path2)
       },
       {
         title: "Adding set import...",
@@ -785,6 +823,7 @@ const splitPathAndModel = (pathSlashModel) => {
 };
 export {
   files,
+  getScaffoldLayoutNames,
   getUnauthenticatedRedirectRoute,
   handler,
   hasLoginRoute,