@holo-js/cli 0.1.9 → 0.2.1

package/dist/generators-DEPLONDJ.mjs

@@ -0,0 +1,520 @@
+import {
+  resolveStringFlag
+} from "./chunk-VRGB6DIS.mjs";
+import {
+  runProjectPrepare
+} from "./chunk-5TEH2QPK.mjs";
+import "./chunk-FGQ2I2YH.mjs";
+import {
+  hasRegisteredCreateTableMigration,
+  hasRegisteredMigrationSlug,
+  nextMigrationTemplate
+} from "./chunk-LXGQCG56.mjs";
+import {
+  writeLine
+} from "./chunk-I7QBCEV7.mjs";
+import {
+  ensureAbsent,
+  fileExists
+} from "./chunk-LBJAJLKU.mjs";
+import "./chunk-D7O4SU6N.mjs";
+import {
+  collectFiles,
+  prepareProjectDiscovery
+} from "./chunk-VP2E62DF.mjs";
+import "./chunk-4OHJC3GL.mjs";
+import {
+  ensureGeneratedSchemaPlaceholder,
+  ensureProjectConfig
+} from "./chunk-YEFJBN56.mjs";
+import {
+  ensureSuffix,
+  loadGeneratedProjectRegistry,
+  relativeImportPath,
+  renderBroadcastTemplate,
+  renderChannelTemplate,
+  renderEventTemplate,
+  renderFactoryTemplate,
+  renderJobTemplate,
+  renderListenerTemplate,
+  renderMarkdownMailTemplate,
+  renderModelTemplate,
+  renderMultiListenerTemplate,
+  renderObserverTemplate,
+  renderSeederTemplate,
+  resolveArtifactPath,
+  resolveNameInfo,
+  splitRequestedName,
+  toKebabCase,
+  toPascalCase,
+  toSnakeCase
+} from "./chunk-J76GH2DR.mjs";
+import {
+  makeProjectRelativePath,
+  resolveDefaultArtifactPath,
+  writeTextFile
+} from "./chunk-ILU426CF.mjs";
+
+// src/generators.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import { basename, extname, resolve } from "path";
+import { normalizeMigrationSlug } from "@holo-js/db";
+var MAIL_VIEW_SCAFFOLDING_UNAVAILABLE_MESSAGE = 'View-backed mail scaffolding requires a renderView runtime binding, which the first-party app scaffolds do not configure yet. Use "--markdown" instead.';
+function hasRegisteredModelName(registry, modelName) {
+  return Boolean(registry?.models.some((entry) => entry.name === modelName));
+}
+function findRegisteredModelByTableName(registry, tableName) {
+  return registry?.models.find((entry) => entry.tableName === tableName);
+}
+async function findGeneratedModelSourceByTableName(projectRoot, modelsPath, tableName) {
+  const files = await collectFiles(resolve(projectRoot, modelsPath));
+  const generatedTableReference = tableName;
+  for (const filePath of files) {
+    const contents = await readFile(filePath, "utf8");
+    if (containsDefineModelTableReference(contents, generatedTableReference)) {
+      return basename(filePath, extname(filePath));
+    }
+  }
+  return void 0;
+}
+function containsDefineModelTableReference(contents, tableName) {
+  let index = 0;
+  while (index < contents.length) {
+    const nextReference = contents.indexOf("defineModel", index);
+    if (nextReference === -1) return false;
+    if (isInsideComment(contents, nextReference)) {
+      index = nextReference + "defineModel".length;
+      continue;
+    }
+    const before = contents[nextReference - 1];
+    const after = contents[nextReference + "defineModel".length];
+    const hasIdentifierBoundary = !isIdentifierCharacter(before) && !isIdentifierCharacter(after);
+    if (!hasIdentifierBoundary) {
+      index = nextReference + "defineModel".length;
+      continue;
+    }
+    const openParenIndex = skipWhitespace(contents, nextReference + "defineModel".length);
+    if (contents[openParenIndex] !== "(") {
+      index = nextReference + "defineModel".length;
+      continue;
+    }
+    const firstArgumentIndex = skipWhitespace(contents, openParenIndex + 1);
+    const quote = contents[firstArgumentIndex];
+    if (quote !== "'" && quote !== '"' && quote !== "`") {
+      index = firstArgumentIndex;
+      continue;
+    }
+    const literal = readStringLiteral(contents, firstArgumentIndex, quote);
+    if (literal?.value === tableName) return true;
+    index = literal?.endIndex ?? firstArgumentIndex + 1;
+  }
+  return false;
+}
+function isInsideComment(contents, position) {
+  let index = 0;
+  while (index < position) {
+    const current = contents[index];
+    const next = contents[index + 1];
+    if (current === "'" || current === '"' || current === "`") {
+      index = readStringLiteral(contents, index, current)?.endIndex ?? index + 1;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      const end = contents.indexOf("\n", index + 2);
+      if (end === -1 || end >= position) return true;
+      index = end + 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      const end = contents.indexOf("*/", index + 2);
+      if (end === -1 || end + 2 >= position) return true;
+      index = end + 2;
+      continue;
+    }
+    index += 1;
+  }
+  return false;
+}
+function isIdentifierCharacter(value) {
+  return typeof value === "string" && /[$\w]/.test(value);
+}
+function skipWhitespace(contents, startIndex) {
+  let index = startIndex;
+  while (/\s/.test(contents[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function readStringLiteral(contents, startIndex, quote) {
+  let value = "";
+  let index = startIndex + 1;
+  while (index < contents.length) {
+    const current = contents[index];
+    if (current === "\\") {
+      const escaped = contents[index + 1];
+      if (typeof escaped === "string") {
+        value += escaped;
+        index += 2;
+        continue;
+      }
+    }
+    if (current === quote) {
+      return { value, endIndex: index + 1 };
+    }
+    if (typeof current === "string") {
+      value += current;
+    }
+    index += 1;
+  }
+  return void 0;
+}
+function hasRegisteredJobName(registry, jobName) {
+  return Boolean(registry?.jobs.some((entry) => entry.name === jobName));
+}
+function hasRegisteredEventName(registry, eventName) {
+  return Boolean(registry?.events.some((entry) => entry.name === eventName));
+}
+function hasRegisteredListenerId(registry, listenerId) {
+  return Boolean(registry?.listeners.some((entry) => entry.id === listenerId));
+}
+function toChannelTemplateFileStem(pattern) {
+  const rawSegments = pattern.trim().replace(/\\/g, "/").replace(/^\.+/, "").split(/[/.]/).map((segment) => segment.trim()).filter(Boolean);
+  const hasOnlyWildcardSegments = rawSegments.length > 0 && rawSegments.every((segment) => /^\{[^}]+\}$/.test(segment));
+  const normalized = pattern.trim().replace(/\\/g, "/").replace(/^\.+/, "").replace(/\{([^}]+)\}/g, "$1").replace(/[^a-z0-9/]+/gi, "-").replace(/-+/g, "-").replace(/^[-/]+|[-/]+$/g, "");
+  const fileStem = normalized.split("/").filter(Boolean).map((segment) => toKebabCase(segment)).join("/") || "channel";
+  if (!hasOnlyWildcardSegments) {
+    return fileStem;
+  }
+  const suffix = createHash("sha1").update(pattern.trim()).digest("hex").slice(0, 8);
+  return `${fileStem}-${suffix}`;
+}
+function resolveChannelArtifactPath(projectRoot, channelsPath, pattern, registry) {
+  const fileStem = toChannelTemplateFileStem(pattern);
+  const filePath = resolveArtifactPath(projectRoot, channelsPath, "", `${fileStem}.ts`);
+  const relativePath = makeProjectRelativePath(projectRoot, filePath);
+  const collidesWithDifferentRegisteredPattern = registry.channels.some((entry) => {
+    return entry.sourcePath === relativePath && entry.pattern !== pattern;
+  });
+  if (!collidesWithDifferentRegisteredPattern) {
+    return filePath;
+  }
+  const suffix = createHash("sha1").update(pattern.trim()).digest("hex").slice(0, 8);
+  return resolveArtifactPath(projectRoot, channelsPath, "", `${fileStem}-${suffix}.ts`);
+}
+function resolveConfiguredBroadcastPath(project) {
+  const configuredPaths = project.config.paths;
+  return configuredPaths.broadcast ?? "server/broadcast";
+}
+function resolveConfiguredChannelsPath(project) {
+  const configuredPaths = project.config.paths;
+  return configuredPaths.channels ?? "server/channels";
+}
+async function runMakeModel(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const generatedSchemaFilePath = await ensureGeneratedSchemaPlaceholder(projectRoot, project.config);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const requestedName = String(input.args[0] ?? "");
+  const options = {
+    migration: input.flags.migration === true,
+    observer: input.flags.observer === true,
+    seeder: input.flags.seeder === true,
+    factory: input.flags.factory === true
+  };
+  const nameInfo = resolveNameInfo(requestedName);
+  const explicitTableName = resolveStringFlag(input.flags, "table");
+  const tableName = explicitTableName ? toSnakeCase(explicitTableName) : nameInfo.tableName;
+  const modelFilePath = resolveArtifactPath(projectRoot, project.config.paths.models, nameInfo.directory, `${nameInfo.baseName}.ts`);
+  const observerInfo = resolveNameInfo(`${requestedName}Observer`, { suffix: "Observer" });
+  const observerFilePath = resolveArtifactPath(projectRoot, project.config.paths.observers, observerInfo.directory, `${observerInfo.baseName}.ts`);
+  const seederInfo = resolveNameInfo(`${requestedName}Seeder`, { suffix: "Seeder" });
+  const seederFilePath = resolveArtifactPath(projectRoot, project.config.paths.seeders, seederInfo.directory, `${seederInfo.baseName}.ts`);
+  const factoryInfo = resolveNameInfo(`${requestedName}Factory`, { suffix: "Factory" });
+  const factoryFilePath = resolveArtifactPath(projectRoot, project.config.paths.factories, factoryInfo.directory, `${factoryInfo.baseName}.ts`);
+  if (await fileExists(modelFilePath) || hasRegisteredModelName(registry, nameInfo.baseName)) {
+    throw new Error(`Model with the same name already exists: ${nameInfo.baseName}.`);
+  }
+  if (options.migration) {
+    const migrationName = normalizeMigrationSlug(`create_${tableName}_table`);
+    if (hasRegisteredMigrationSlug(registry, migrationName) || hasRegisteredCreateTableMigration(registry, tableName)) {
+      throw new Error(`A migration for table "${tableName}" already exists.`);
+    }
+  }
+  const existingTableModel = findRegisteredModelByTableName(registry, tableName);
+  if (existingTableModel) {
+    throw new Error(`Discovered duplicate model "${existingTableModel.name}" for table "${tableName}".`);
+  }
+  const existingGeneratedModelName = await findGeneratedModelSourceByTableName(
+    projectRoot,
+    project.config.paths.models,
+    tableName
+  );
+  if (existingGeneratedModelName) {
+    throw new Error(`Discovered duplicate model "${existingGeneratedModelName}" for table "${tableName}".`);
+  }
+  await ensureAbsent(modelFilePath);
+  if (options.observer) {
+    await ensureAbsent(observerFilePath);
+  }
+  if (options.seeder) {
+    await ensureAbsent(seederFilePath);
+  }
+  if (options.factory) {
+    await ensureAbsent(factoryFilePath);
+  }
+  if (options.observer) {
+    await writeTextFile(observerFilePath, renderObserverTemplate(observerInfo.baseName));
+  }
+  await writeTextFile(modelFilePath, renderModelTemplate({
+    tableName,
+    generatedSchemaImportPath: relativeImportPath(modelFilePath, generatedSchemaFilePath),
+    ...options.observer ? {
+      observerImportPath: relativeImportPath(modelFilePath, observerFilePath),
+      observerClassName: observerInfo.baseName
+    } : {}
+  }));
+  if (options.factory) {
+    await writeTextFile(factoryFilePath, renderFactoryTemplate(
+      relativeImportPath(factoryFilePath, modelFilePath),
+      nameInfo.baseName
+    ));
+  }
+  if (options.seeder) {
+    await writeTextFile(seederFilePath, renderSeederTemplate(seederInfo.snakeStem));
+  }
+  if (options.migration) {
+    const migrationName = normalizeMigrationSlug(`create_${tableName}_table`);
+    const migrationTemplate = await nextMigrationTemplate(
+      migrationName,
+      resolve(projectRoot, project.config.paths.migrations)
+    );
+    const migrationFilePath = resolveDefaultArtifactPath(projectRoot, project.config.paths.migrations, migrationTemplate.fileName);
+    await writeTextFile(migrationFilePath, migrationTemplate.contents);
+  }
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created model: ${makeProjectRelativePath(projectRoot, modelFilePath)}`);
+  if (options.migration) {
+    writeLine(io.stdout, `Registered migration for ${nameInfo.baseName}.`);
+  }
+  if (options.seeder) {
+    writeLine(io.stdout, `Registered seeder for ${nameInfo.baseName}.`);
+  }
+}
+async function runMakeMigration(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const requestedName = String(input.args[0] ?? "");
+  const createTable = typeof input.flags.create === "string" ? normalizeMigrationSlug(input.flags.create) : void 0;
+  const alterTable = typeof input.flags.table === "string" ? normalizeMigrationSlug(input.flags.table) : void 0;
+  if (createTable && alterTable) {
+    throw new Error('Use either "--create" or "--table", not both.');
+  }
+  const requestedSlug = normalizeMigrationSlug(requestedName);
+  if (createTable) {
+    if (hasRegisteredCreateTableMigration(registry, createTable)) {
+      throw new Error(`A migration for table "${createTable}" already exists.`);
+    }
+  } else if (alterTable) {
+    if (hasRegisteredMigrationSlug(registry, requestedSlug)) {
+      throw new Error(`A migration named "${requestedSlug}" already exists.`);
+    }
+  } else if (hasRegisteredMigrationSlug(registry, requestedSlug)) {
+    throw new Error(`A migration named "${requestedSlug}" already exists.`);
+  }
+  const migrationTemplate = await nextMigrationTemplate(
+    requestedSlug,
+    resolve(projectRoot, project.config.paths.migrations),
+    {
+      ...createTable ? { kind: "create_table", tableName: createTable } : {},
+      ...alterTable ? { kind: "alter_table", tableName: alterTable } : {}
+    }
+  );
+  const migrationFilePath = resolveDefaultArtifactPath(projectRoot, project.config.paths.migrations, migrationTemplate.fileName);
+  await writeTextFile(migrationFilePath, migrationTemplate.contents);
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created migration: ${makeProjectRelativePath(projectRoot, migrationFilePath)}`);
+}
+async function runMakeSeeder(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const info = resolveNameInfo(String(input.args[0] ?? ""), { suffix: "Seeder" });
+  const filePath = resolveArtifactPath(projectRoot, project.config.paths.seeders, info.directory, `${info.baseName}.ts`);
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderSeederTemplate(info.snakeStem));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created seeder: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeJob(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const requestedName = String(input.args[0] ?? "");
+  const nameParts = splitRequestedName(requestedName);
+  const directory = nameParts.directory.split("/").filter(Boolean).map((segment) => toKebabCase(segment)).join("/");
+  const fileStem = toKebabCase(nameParts.rawBaseName);
+  const filePath = resolveArtifactPath(projectRoot, project.config.paths.jobs, directory, `${fileStem}.ts`);
+  const jobName = [...directory ? directory.split("/") : [], fileStem].join(".");
+  if (await fileExists(filePath) || hasRegisteredJobName(registry, jobName)) {
+    throw new Error(`Job with the same name already exists: ${jobName}.`);
+  }
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderJobTemplate());
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created job: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeEvent(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const requestedName = String(input.args[0] ?? "");
+  const nameParts = splitRequestedName(requestedName);
+  const directory = nameParts.directory.split("/").filter(Boolean).map((segment) => toKebabCase(segment)).join("/");
+  const fileStem = toKebabCase(nameParts.rawBaseName);
+  const filePath = resolveArtifactPath(projectRoot, project.config.paths.events, directory, `${fileStem}.ts`);
+  const eventName = [...directory ? directory.split("/") : [], fileStem].join(".");
+  if (await fileExists(filePath) || hasRegisteredEventName(registry, eventName)) {
+    throw new Error(`Event with the same name already exists: ${eventName}.`);
+  }
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderEventTemplate(eventName));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created event: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeBroadcast(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const requestedName = String(input.args[0] ?? "");
+  const nameParts = splitRequestedName(requestedName);
+  const directory = nameParts.directory.split("/").filter(Boolean).map((segment) => toKebabCase(segment)).join("/");
+  const fileStem = toKebabCase(nameParts.rawBaseName);
+  const broadcastPath = resolveConfiguredBroadcastPath(project);
+  const filePath = resolveArtifactPath(projectRoot, broadcastPath, directory, `${fileStem}.ts`);
+  const eventName = [...directory ? directory.split("/") : [], fileStem].join(".");
+  if (await fileExists(filePath) || registry.broadcast.some((entry) => entry.name === eventName)) {
+    throw new Error(`Broadcast with the same name already exists: ${eventName}.`);
+  }
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderBroadcastTemplate(eventName));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created broadcast: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeChannel(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const pattern = String(input.args[0] ?? "").trim();
+  if (!pattern) {
+    throw new Error("A channel pattern is required.");
+  }
+  if (registry.channels.some((entry) => entry.pattern === pattern)) {
+    throw new Error(`Channel with the same pattern already exists: ${pattern}.`);
+  }
+  const channelsPath = resolveConfiguredChannelsPath(project);
+  const filePath = resolveChannelArtifactPath(projectRoot, channelsPath, pattern, registry);
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderChannelTemplate(pattern));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created channel: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeListener(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, project.config);
+  const requestedName = String(input.args[0] ?? "");
+  const requestedEvents = Array.isArray(input.flags.event) ? input.flags.event.map((value) => String(value).trim()).filter(Boolean) : [String(input.flags.event ?? "").trim()].filter(Boolean);
+  const eventNames = [...new Set(requestedEvents)];
+  const eventEntries = eventNames.map((eventName) => {
+    const entry = registry?.events.find((candidate) => candidate.name === eventName);
+    if (!entry) {
+      throw new Error(`Unknown event: ${eventName}.`);
+    }
+    return entry;
+  });
+  const nameParts = splitRequestedName(requestedName);
+  const directory = nameParts.directory.split("/").filter(Boolean).map((segment) => toKebabCase(segment)).join("/");
+  const fileStem = toKebabCase(nameParts.rawBaseName);
+  const filePath = resolveArtifactPath(projectRoot, project.config.paths.listeners, directory, `${fileStem}.ts`);
+  const listenerId = [...directory ? directory.split("/") : [], fileStem].join(".");
+  if (await fileExists(filePath) || hasRegisteredListenerId(registry, listenerId)) {
+    throw new Error(`Listener with the same id already exists: ${listenerId}.`);
+  }
+  const templateEvents = eventEntries.map((eventEntry, index) => {
+    const sourceEventBaseName = eventEntry.sourcePath.split("/").pop().replace(/\.[^.]+$/, "");
+    const importName = `${toPascalCase(sourceEventBaseName)}Event${index + 1}`;
+    const importPath = relativeImportPath(filePath, resolve(projectRoot, eventEntry.sourcePath));
+    return {
+      importName,
+      importStatement: eventEntry.exportName && eventEntry.exportName !== "default" ? `import { ${eventEntry.exportName} as ${importName} } from '${importPath}'` : `import ${importName} from '${importPath}'`
+    };
+  });
+  await ensureAbsent(filePath);
+  await writeTextFile(
+    filePath,
+    templateEvents.length === 1 ? renderListenerTemplate(templateEvents[0].importStatement, templateEvents[0].importName) : renderMultiListenerTemplate(templateEvents)
+  );
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created listener: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeObserver(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const info = resolveNameInfo(String(input.args[0] ?? ""), { suffix: "Observer" });
+  const filePath = resolveArtifactPath(projectRoot, project.config.paths.observers, info.directory, `${info.baseName}.ts`);
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderObserverTemplate(info.baseName));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created observer: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeFactory(io, projectRoot, input) {
+  const project = await ensureProjectConfig(projectRoot);
+  const info = resolveNameInfo(String(input.args[0] ?? ""), { suffix: "Factory" });
+  const filePath = resolveArtifactPath(projectRoot, project.config.paths.factories, info.directory, `${info.baseName}.ts`);
+  const baseName = info.baseStem;
+  const modelInfo = splitRequestedName(baseName);
+  const modelFilePath = resolveArtifactPath(
+    projectRoot,
+    project.config.paths.models,
+    info.directory,
+    `${toPascalCase(modelInfo.rawBaseName)}.ts`
+  );
+  await ensureAbsent(filePath);
+  await writeTextFile(filePath, renderFactoryTemplate(
+    relativeImportPath(filePath, modelFilePath),
+    toPascalCase(modelInfo.rawBaseName)
+  ));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created factory: ${makeProjectRelativePath(projectRoot, filePath)}`);
+}
+async function runMakeMail(io, projectRoot, input) {
+  await ensureProjectConfig(projectRoot);
+  const requestedName = String(input.args[0] ?? "");
+  const templateType = input.flags.type === "view" ? "view" : "markdown";
+  if (templateType === "view") {
+    throw new Error(MAIL_VIEW_SCAFFOLDING_UNAVAILABLE_MESSAGE);
+  }
+  const nameParts = splitRequestedName(requestedName);
+  const directory = nameParts.directory.split("/").filter(Boolean).map((segment) => toKebabCase(segment)).join("/");
+  const fileStem = toKebabCase(nameParts.rawBaseName);
+  const mailName = ensureSuffix(toPascalCase(nameParts.rawBaseName), "Mail");
+  const inputTypeName = `${mailName}Input`;
+  const mailFilePath = resolveArtifactPath(projectRoot, "server/mail", directory, `${fileStem}.ts`);
+  await ensureAbsent(mailFilePath);
+  await writeTextFile(mailFilePath, renderMarkdownMailTemplate(mailName, inputTypeName));
+  await runProjectPrepare(projectRoot);
+  writeLine(io.stdout, `Created mail: ${makeProjectRelativePath(projectRoot, mailFilePath)}`);
+}
+var generatorInternals = {
+  toChannelTemplateFileStem
+};
+export {
+  generatorInternals,
+  hasRegisteredEventName,
+  hasRegisteredJobName,
+  hasRegisteredListenerId,
+  hasRegisteredModelName,
+  runMakeBroadcast,
+  runMakeChannel,
+  runMakeEvent,
+  runMakeFactory,
+  runMakeJob,
+  runMakeListener,
+  runMakeMail,
+  runMakeMigration,
+  runMakeModel,
+  runMakeObserver,
+  runMakeSeeder
+};