@holo-js/cli 0.1.4 → 0.1.6

package/dist/generators-WX45BI4U.mjs

@@ -1,426 +0,0 @@
-#!/usr/bin/env node
-import {
-  hasRegisteredCreateTableMigration,
-  hasRegisteredMigrationSlug,
-  nextMigrationTemplate
-} from "./chunk-ICJR7TS4.mjs";
-import {
-  resolveStringFlag
-} from "./chunk-XUYKPU5Q.mjs";
-import {
-  writeLine
-} from "./chunk-SRWJU3A5.mjs";
-import {
-  ensureAbsent,
-  fileExists
-} from "./chunk-M7J3YTHR.mjs";
-import {
-  runProjectPrepare
-} from "./chunk-DMH2B4UQ.mjs";
-import "./chunk-D4GG556Y.mjs";
-import "./chunk-BWW5TDFI.mjs";
-import {
-  prepareProjectDiscovery
-} from "./chunk-VT5IDQG6.mjs";
-import "./chunk-QFUSWV3J.mjs";
-import {
-  ensureGeneratedSchemaPlaceholder,
-  ensureProjectConfig
-} from "./chunk-ET7UXHHQ.mjs";
-import {
-  ensureSuffix,
-  loadGeneratedProjectRegistry,
-  relativeImportPath,
-  renderBroadcastTemplate,
-  renderChannelTemplate,
-  renderEventTemplate,
-  renderFactoryTemplate,
-  renderJobTemplate,
-  renderListenerTemplate,
-  renderMarkdownMailTemplate,
-  renderModelTemplate,
-  renderMultiListenerTemplate,
-  renderObserverTemplate,
-  renderSeederTemplate,
-  resolveArtifactPath,
-  resolveNameInfo,
-  splitRequestedName,
-  toKebabCase,
-  toPascalCase,
-  toSnakeCase
-} from "./chunk-3OTCSFDG.mjs";
-import {
-  makeProjectRelativePath,
-  resolveDefaultArtifactPath,
-  writeTextFile
-} from "./chunk-66FHW725.mjs";
-
-// src/generators.ts
-import { createHash } from "crypto";
-import { readFile } from "fs/promises";
-import { 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 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 resolveProjectMailViewFramework(projectRoot) {
-  try {
-    const packageJson = await readFile(resolve(projectRoot, "package.json"), "utf8");
-    const parsed = JSON.parse(packageJson);
-    const dependencies = {
-      ...parsed.dependencies ?? {},
-      ...parsed.devDependencies ?? {}
-    };
-    if (typeof dependencies.nuxt === "string") {
-      return "nuxt";
-    }
-    if (typeof dependencies.next === "string") {
-      return "next";
-    }
-    if (typeof dependencies["@sveltejs/kit"] === "string") {
-      return "sveltekit";
-    }
-  } catch {
-    return "generic";
-  }
-  return "generic";
-}
-async function runMakeModel(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 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`);
-  const generatedSchemaFilePath = await ensureGeneratedSchemaPlaceholder(projectRoot, project.config);
-  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.`);
-    }
-  }
-  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 = {
-  resolveProjectMailViewFramework,
-  toChannelTemplateFileStem
-};
-export {
-  generatorInternals,
-  hasRegisteredEventName,
-  hasRegisteredJobName,
-  hasRegisteredListenerId,
-  hasRegisteredModelName,
-  runMakeBroadcast,
-  runMakeChannel,
-  runMakeEvent,
-  runMakeFactory,
-  runMakeJob,
-  runMakeListener,
-  runMakeMail,
-  runMakeMigration,
-  runMakeModel,
-  runMakeObserver,
-  runMakeSeeder
-};