@dereekb/dbx-cli 13.11.0 → 13.11.1

package/firebase-api-manifest/main.js

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/main.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { dirname as dirname3, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve3 } from "node:path";
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/parse-functions.ts
+import { readFileSync } from "node:fs";
+import { Node, Project } from "ts-morph";
+function parseFunctionsConfig(functionsTsPath) {
+  const project = new Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  const text = readFileSync(functionsTsPath, "utf8");
+  const sourceFile = project.createSourceFile("functions.ts", text, { overwrite: true });
+  const importIdentToModule = collectImportSpecifierMap(sourceFile);
+  const result = [];
+  for (const variable of sourceFile.getVariableDeclarations()) {
+    const initializer = readFunctionsConfigInitializer(variable);
+    if (initializer) collectGroupsFromConfig(initializer, importIdentToModule, result);
+  }
+  return result;
+}
+function readFunctionsConfigInitializer(variable) {
+  let result;
+  if (isFunctionsConfigVariable(variable)) {
+    const initializer = variable.getInitializer();
+    if (initializer && Node.isObjectLiteralExpression(initializer)) result = initializer;
+  }
+  return result;
+}
+function collectGroupsFromConfig(initializer, importIdentToModule, sink) {
+  for (const property of initializer.getProperties()) {
+    const group = readGroupFromProperty(property, importIdentToModule);
+    if (group) sink.push(group);
+  }
+}
+function readGroupFromProperty(property, importIdentToModule) {
+  if (!Node.isPropertyAssignment(property)) return void 0;
+  const valueExpr = property.getInitializer();
+  if (!valueExpr || !Node.isArrayLiteralExpression(valueExpr)) return void 0;
+  const first = valueExpr.getElements()[0];
+  if (!first || !Node.isIdentifier(first)) return void 0;
+  const className = first.getText();
+  const importedFromModule = importIdentToModule.get(className);
+  if (!importedFromModule) return void 0;
+  return { groupKey: property.getName(), className, importedFromModule };
+}
+function isFunctionsConfigVariable(variable) {
+  const name = variable.getName();
+  return name.endsWith("FIREBASE_FUNCTIONS_CONFIG");
+}
+function collectImportSpecifierMap(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = decl.getModuleSpecifierValue();
+    for (const named of decl.getNamedImports()) {
+      const localName = named.getAliasNode()?.getText() ?? named.getName();
+      map.set(localName, moduleSpecifier);
+    }
+  }
+  return map;
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/resolve-package.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+var _pathsCache;
+function loadTsconfigPaths(workspaceRoot) {
+  if (_pathsCache) return _pathsCache;
+  const tsconfigPath = join(workspaceRoot, "tsconfig.base.json");
+  const raw = readFileSync2(tsconfigPath, "utf8");
+  const cleaned = stripJsonComments(raw);
+  const tsconfig = JSON.parse(cleaned);
+  const paths = tsconfig.compilerOptions?.paths ?? {};
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(paths)) {
+    if (Array.isArray(value) && value[0]) {
+      map.set(key, resolve(workspaceRoot, value[0]));
+    }
+  }
+  _pathsCache = map;
+  return map;
+}
+function resolveModuleToPackage(input) {
+  const { workspaceRoot, importingFile, moduleSpecifier } = input;
+  if (moduleSpecifier.startsWith(".")) {
+    const importingDir = dirname(importingFile);
+    const candidatePath = resolve(importingDir, moduleSpecifier);
+    return locatePackageForPath(workspaceRoot, candidatePath);
+  }
+  const paths = loadTsconfigPaths(workspaceRoot);
+  const indexFile = paths.get(moduleSpecifier);
+  if (indexFile) return locatePackageForPath(workspaceRoot, indexFile);
+  return locatePackageInNodeModules({ workspaceRoot, importingFile, moduleSpecifier });
+}
+function locatePackageInNodeModules(input) {
+  const { importingFile, moduleSpecifier } = input;
+  let current = dirname(importingFile);
+  while (current && current !== dirname(current)) {
+    const candidateRoot = join(current, "node_modules", moduleSpecifier);
+    const pkgJson = join(candidateRoot, "package.json");
+    if (existsSync(pkgJson)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgJson, "utf8"));
+        if (pkg.name) return { packageName: pkg.name, packageRoot: candidateRoot };
+      } catch {
+      }
+    }
+    current = dirname(current);
+  }
+  return void 0;
+}
+function locatePackageForPath(workspaceRoot, startPath) {
+  let current = startPath;
+  while (current && current !== workspaceRoot && current !== dirname(current)) {
+    if (existsSync(join(current, "package.json"))) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join(current, "package.json"), "utf8"));
+        if (pkg.name) return { packageName: pkg.name, packageRoot: current };
+      } catch {
+      }
+    }
+    current = dirname(current);
+  }
+  return void 0;
+}
+function relPath(workspaceRoot, absolutePath) {
+  return relative(workspaceRoot, absolutePath).split("\\").join("/");
+}
+function stripJsonComments(text) {
+  return text.replaceAll(/\/\*[\s\S]*?\*\//g, "").replaceAll(/^\s*\/\/.*$/gm, "");
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/find-api-files.ts
+import { readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/extract-crud.ts
+import { Node as Node2, Project as Project2 } from "ts-morph";
+var SUPPORTED_VERBS = /* @__PURE__ */ new Set(["create", "read", "update", "delete", "query"]);
+function extractCrudEntries(source) {
+  const project = new Project2({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+  const sourceFile = project.createSourceFile(source.name, source.text, { overwrite: true });
+  const entries = [];
+  const modelKeys = [];
+  const crudConfigType = findTypeAliasByEnding(sourceFile, "ModelCrudFunctionsConfig");
+  const groupName = inferGroupName(sourceFile);
+  const functionsClassName = findFunctionsClassName(sourceFile);
+  if (crudConfigType) {
+    const literal = crudConfigType.getTypeNode();
+    if (literal && Node2.isTypeLiteral(literal)) {
+      for (const member of literal.getMembers()) {
+        if (!Node2.isPropertySignature(member)) continue;
+        const modelName = member.getName();
+        modelKeys.push(modelName);
+        const valueNode = member.getTypeNode();
+        if (!valueNode) continue;
+        if (isNullLiteralType(valueNode)) continue;
+        if (Node2.isTypeLiteral(valueNode)) {
+          for (const verbMember of valueNode.getMembers()) {
+            if (!Node2.isPropertySignature(verbMember)) continue;
+            const verb = verbMember.getName();
+            if (!SUPPORTED_VERBS.has(verb)) continue;
+            const verbValueNode = verbMember.getTypeNode();
+            if (!verbValueNode) continue;
+            collectVerbEntries({ modelName, verb, valueNode: verbValueNode, entries });
+          }
+        }
+      }
+    }
+  }
+  const functionTypeMap = findTypeAliasByEnding(sourceFile, "FunctionTypeMap");
+  if (functionTypeMap) {
+    const literal = functionTypeMap.getTypeNode();
+    if (literal && Node2.isTypeLiteral(literal)) {
+      for (const member of literal.getMembers()) {
+        if (!Node2.isPropertySignature(member)) continue;
+        const key = member.getName();
+        const valueNode = member.getTypeNode();
+        const tuple = valueNode ? readTupleParamsResult(valueNode) : void 0;
+        entries.push({
+          model: key,
+          verb: "standalone",
+          specifier: void 0,
+          paramsTypeName: tuple?.params,
+          resultTypeName: tuple?.result,
+          line: member.getStartLineNumber()
+        });
+      }
+    }
+  }
+  return { groupName, modelKeys, entries, functionsClassName };
+}
+function findTypeAliasByEnding(sourceFile, ending) {
+  for (const alias of sourceFile.getTypeAliases()) {
+    if (alias.getName().endsWith(ending) && alias.getTypeNode()) return alias;
+  }
+  return void 0;
+}
+function findFunctionsClassName(sourceFile) {
+  for (const cls of sourceFile.getClasses()) {
+    if (!cls.isAbstract()) continue;
+    const name = cls.getName();
+    if (name?.endsWith("Functions")) return name;
+  }
+  return void 0;
+}
+function inferGroupName(sourceFile) {
+  for (const alias of sourceFile.getTypeAliases()) {
+    const name = alias.getName();
+    if (name.endsWith("ModelCrudFunctionsConfig")) {
+      const stem = name.slice(0, -"ModelCrudFunctionsConfig".length);
+      if (stem.length > 0) return stem;
+    }
+  }
+  for (const alias of sourceFile.getTypeAliases()) {
+    const name = alias.getName();
+    if (name.endsWith("FunctionTypeMap")) {
+      const stem = name.slice(0, -"FunctionTypeMap".length);
+      if (stem.length > 0) return stem;
+    }
+  }
+  return void 0;
+}
+function isNullLiteralType(node) {
+  if (Node2.isLiteralTypeNode(node)) {
+    const literal = node.getLiteral();
+    if (Node2.isNullLiteral(literal)) return true;
+  }
+  return false;
+}
+function collectVerbEntries(input) {
+  const { modelName, verb, valueNode, entries } = input;
+  if (Node2.isTypeLiteral(valueNode)) {
+    for (const specMember of valueNode.getMembers()) {
+      if (!Node2.isPropertySignature(specMember)) continue;
+      const specifier = specMember.getName();
+      const leafNode = specMember.getTypeNode();
+      const leaf2 = leafNode ? readTupleParamsResult(leafNode) ?? readBareParams(leafNode) : void 0;
+      entries.push({
+        model: modelName,
+        verb,
+        specifier,
+        paramsTypeName: leaf2?.params,
+        resultTypeName: leaf2?.result,
+        line: specMember.getStartLineNumber()
+      });
+    }
+    return;
+  }
+  const leaf = readTupleParamsResult(valueNode) ?? readBareParams(valueNode);
+  entries.push({
+    model: modelName,
+    verb,
+    specifier: void 0,
+    paramsTypeName: leaf?.params,
+    resultTypeName: leaf?.result,
+    line: valueNode.getStartLineNumber()
+  });
+}
+function readTupleParamsResult(node) {
+  if (!Node2.isTupleTypeNode(node)) return void 0;
+  const elements = node.getElements();
+  if (elements.length === 0) return void 0;
+  const params = elements[0] ? typeNodeName(elements[0]) : void 0;
+  const result = elements[1] ? typeNodeName(elements[1]) : void 0;
+  return { params, result };
+}
+function readBareParams(node) {
+  const params = typeNodeName(node);
+  if (!params) return void 0;
+  return { params, result: void 0 };
+}
+function typeNodeName(node) {
+  if (Node2.isTypeReference(node)) {
+    return node.getTypeName().getText();
+  }
+  const text = node.getText().trim();
+  return text.length > 0 ? text : void 0;
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/find-api-files.ts
+function findApiFiles(packageRoot) {
+  const libRoot = join2(packageRoot, "src", "lib");
+  if (!safeIsDirectory(libRoot)) return [];
+  const out = [];
+  const seenClassNames = /* @__PURE__ */ new Set();
+  for (const file of walkApiFiles(libRoot)) {
+    const text = readFileSync3(file, "utf8");
+    const extraction = extractCrudEntries({ name: file, text });
+    if (!extraction.functionsClassName) continue;
+    if (seenClassNames.has(extraction.functionsClassName)) continue;
+    seenClassNames.add(extraction.functionsClassName);
+    out.push({ filePath: file, className: extraction.functionsClassName, extraction });
+  }
+  return out;
+}
+function* walkApiFiles(dir) {
+  for (const entry of readdirSync(dir).sort()) {
+    if (entry === "node_modules" || entry === "dist") continue;
+    const p = join2(dir, entry);
+    const stat = statSync(p);
+    if (stat.isDirectory()) {
+      yield* walkApiFiles(p);
+    } else if (isApiFile(entry)) {
+      yield p;
+    }
+  }
+}
+function isApiFile(name) {
+  if (name.endsWith(".spec.ts") || name.endsWith(".test.ts")) return false;
+  return name.endsWith(".api.ts") || name.endsWith(".api.d.ts");
+}
+function safeIsDirectory(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/bind-validators.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join3, resolve as resolve2 } from "node:path";
+function deriveValidatorName(paramsTypeName) {
+  if (!paramsTypeName) return "";
+  return paramsTypeName.charAt(0).toLowerCase() + paramsTypeName.slice(1) + "Type";
+}
+function isExportedFromPackage(input) {
+  const { packageRoot, identifier } = input;
+  const indexPath = locateBarrelEntry(packageRoot);
+  if (!indexPath) return false;
+  return findIdentifierInBarrelChain(indexPath, identifier, /* @__PURE__ */ new Set());
+}
+function locateBarrelEntry(packageRoot) {
+  const candidates = [join3(packageRoot, "src", "index.ts"), join3(packageRoot, "src", "index.d.ts"), join3(packageRoot, "index.d.ts"), join3(packageRoot, "index.ts")];
+  return candidates.find((candidate) => existsSync2(candidate));
+}
+var EXPORT_DECL_PATTERNS = [/export\s+(?:declare\s+)?const\s+IDENT\b/, /export\s+(?:declare\s+)?function\s+IDENT\b/, /export\s*\{[^}]*\bIDENT\b[^}]*\}/];
+function findIdentifierInBarrelChain(filePath, identifier, visited) {
+  if (visited.has(filePath)) return false;
+  visited.add(filePath);
+  let text;
+  try {
+    text = readFileSync4(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  for (const pattern of EXPORT_DECL_PATTERNS) {
+    const re = new RegExp(pattern.source.replace("IDENT", escapeRegExp(identifier)));
+    if (re.test(text)) return true;
+  }
+  const dir = dirname2(filePath);
+  for (const reExportTarget of collectReExportTargets(text)) {
+    const resolved = resolveReExport(dir, reExportTarget);
+    if (!resolved) continue;
+    if (findIdentifierInBarrelChain(resolved, identifier, visited)) return true;
+  }
+  return false;
+}
+function collectReExportTargets(text) {
+  const out = [];
+  const re = /export\s*(?:\*|\{[^}]*\})\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    out.push(match[1]);
+  }
+  return out;
+}
+function resolveReExport(fromDir, target) {
+  if (!target.startsWith(".")) return void 0;
+  const candidate = isAbsolute2(target) ? target : resolve2(fromDir, target);
+  let result;
+  for (const ext of [".ts", ".mts", ".d.ts", "/index.ts", "/index.mts", "/index.d.ts"]) {
+    const probe = hasTsModuleExtension(candidate) ? candidate : candidate + ext;
+    const resolved = resolveExistingTsPath(probe);
+    if (resolved) {
+      result = resolved;
+      break;
+    }
+  }
+  return result;
+}
+function hasTsModuleExtension(value) {
+  return value.endsWith(".ts") || value.endsWith(".mts");
+}
+function resolveExistingTsPath(probe) {
+  if (!existsSync2(probe)) return void 0;
+  const stat = statSync2(probe);
+  if (stat.isFile()) return probe;
+  if (!stat.isDirectory()) return void 0;
+  const sourceIndex = join3(probe, "index.ts");
+  if (existsSync2(sourceIndex)) return sourceIndex;
+  const declarationIndex = join3(probe, "index.d.ts");
+  return existsSync2(declarationIndex) ? declarationIndex : void 0;
+}
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/emit.ts
+import { format, resolveConfig } from "prettier";
+async function renderManifest(input) {
+  const { outputFile, entries, projectName, namespace } = input;
+  const importsByPackage = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.packageName || !entry.validatorName) continue;
+    const set = importsByPackage.get(entry.packageName) ?? /* @__PURE__ */ new Set();
+    set.add(entry.validatorName);
+    importsByPackage.set(entry.packageName, set);
+  }
+  const importLines = [...importsByPackage.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([pkg, names]) => {
+    const sortedNames = [...names].sort((a, b) => a.localeCompare(b)).join(", ");
+    return `import { ${sortedNames} } from '${pkg}';`;
+  });
+  const entryLines = entries.map((e) => renderEntry(e));
+  const source = `/* eslint-disable @nx/enforce-module-boundaries */
+// AUTO-GENERATED \u2014 DO NOT EDIT.
+// Run \`pnpm nx run ${projectName}:generate-api-manifest\` to refresh.
+
+${importLines.join("\n")}
+import { type CliApiManifest } from '@dereekb/dbx-cli';
+
+export const ${namespace}: CliApiManifest = [
+${entryLines.join(",\n")}
+];
+`;
+  return formatWithPrettier(source, outputFile);
+}
+function renderEntry({ entry, validatorName }) {
+  const fields = [
+    `model: ${JSON.stringify(entry.model)}`,
+    `verb: ${JSON.stringify(entry.verb)}`,
+    entry.specifier ? `specifier: ${JSON.stringify(entry.specifier)}` : void 0,
+    entry.paramsTypeName ? `paramsTypeName: ${JSON.stringify(entry.paramsTypeName)}` : void 0,
+    validatorName ? `paramsValidator: ${validatorName}` : void 0,
+    entry.resultTypeName ? `resultTypeName: ${JSON.stringify(entry.resultTypeName)}` : void 0,
+    `groupName: ${JSON.stringify(entry.groupName)}`,
+    `sourceFile: ${JSON.stringify(entry.sourceFile)}`
+  ];
+  return `  { ${fields.filter((v) => Boolean(v)).join(", ")} }`;
+}
+async function formatWithPrettier(source, outputFile) {
+  const config = await resolveConfig(outputFile);
+  return format(source, { ...config, filepath: outputFile });
+}
+
+// packages/dbx-cli/firebase-api-manifest/src/generate-api-manifest/main.ts
+var WORKSPACE_ROOT = process.cwd();
+async function main() {
+  const flags = parseFlags(process.argv.slice(2));
+  if (!flags.functionsConfig || !flags.output) {
+    printUsageAndExit();
+    return;
+  }
+  const functionsConfigPath = resolveWorkspacePath(flags.functionsConfig);
+  const outputFile = resolveWorkspacePath(flags.output);
+  const outputDir = dirname3(outputFile);
+  const projectName = flags.project ?? "<cli>";
+  const namespace = deriveNamespace(flags.project);
+  if (!existsSync3(functionsConfigPath)) {
+    throw new Error(`functions-config file not found: ${functionsConfigPath}`);
+  }
+  const groups = parseFunctionsConfig(functionsConfigPath);
+  if (groups.length === 0) {
+    throw new Error(`No function groups discovered in ${relPath(WORKSPACE_ROOT, functionsConfigPath)}.`);
+  }
+  const packageCache = /* @__PURE__ */ new Map();
+  const apiFilesCache = /* @__PURE__ */ new Map();
+  const collected = [];
+  let missingValidators = 0;
+  let skippedGroups = 0;
+  for (const group of groups) {
+    const pkg = resolveModuleToPackage({ workspaceRoot: WORKSPACE_ROOT, importingFile: functionsConfigPath, moduleSpecifier: group.importedFromModule });
+    if (!pkg) {
+      console.warn(`[skip] ${group.groupKey}: cannot resolve module '${group.importedFromModule}' for class ${group.className}`);
+      skippedGroups++;
+      continue;
+    }
+    if (!packageCache.has(pkg.packageRoot)) packageCache.set(pkg.packageRoot, pkg);
+    if (!apiFilesCache.has(pkg.packageRoot)) apiFilesCache.set(pkg.packageRoot, findApiFiles(pkg.packageRoot));
+    const apiFiles = apiFilesCache.get(pkg.packageRoot) ?? [];
+    const match = apiFiles.find((f) => f.className === group.className);
+    if (!match) {
+      console.warn(`[skip] ${group.groupKey}: no .api.{ts,d.ts} under ${pkg.packageName} declares 'export abstract class ${group.className}'`);
+      skippedGroups++;
+      continue;
+    }
+    if (match.extraction.entries.length === 0) {
+      console.warn(`[skip] ${group.groupKey}: ${group.className} is not a CRUD model group (no *ModelCrudFunctionsConfig in ${relPath(WORKSPACE_ROOT, match.filePath)})`);
+      skippedGroups++;
+      continue;
+    }
+    const groupName = match.extraction.groupName ?? group.className.replace(/Functions$/, "");
+    const sourceFileRel = relPath(WORKSPACE_ROOT, match.filePath);
+    for (const entry of match.extraction.entries) {
+      if (flags.only && !flags.only.has(entry.model)) continue;
+      if (entry.verb === "standalone") continue;
+      const enriched = { entry: { ...entry, groupName, sourceFile: sourceFileRel } };
+      if (entry.paramsTypeName) {
+        const validatorName = deriveValidatorName(entry.paramsTypeName);
+        const found = isExportedFromPackage({ packageRoot: pkg.packageRoot, identifier: validatorName });
+        if (found) {
+          enriched.packageName = pkg.packageName;
+          enriched.validatorName = validatorName;
+        } else {
+          missingValidators++;
+          const specPart = entry.specifier ? "/" + entry.specifier : "";
+          console.warn(`[no-validator] ${pkg.packageName} \xB7 ${entry.model}/${entry.verb}${specPart} \u2192 ${validatorName} not exported`);
+        }
+      }
+      collected.push(enriched);
+    }
+  }
+  collected.sort(compareEntries);
+  ensureOutputDir(outputDir);
+  const formatted = await renderManifest({ outputFile, entries: collected, projectName, namespace });
+  if (existsSync3(outputFile) && readFileSync5(outputFile, "utf8") === formatted) {
+    console.log(`[unchanged] ${relative2(WORKSPACE_ROOT, outputFile)}`);
+  } else {
+    writeFileSync(outputFile, formatted);
+    console.log(`[wrote] ${relative2(WORKSPACE_ROOT, outputFile)}`);
+  }
+  const groupCount = packageCache.size === 0 ? 0 : new Set(collected.map((c) => c.entry.groupName)).size;
+  console.log(`Summary: ${groupCount} groups \xB7 ${collected.length} entries \xB7 ${collected.length - missingValidators} validators bound \xB7 ${missingValidators} missing \xB7 ${skippedGroups} skipped`);
+  if (flags.strict && missingValidators > 0) {
+    console.error(`[strict] ${missingValidators} validator(s) missing \u2014 failing build.`);
+    process.exit(1);
+  }
+}
+function compareEntries(a, b) {
+  if (a.entry.model !== b.entry.model) return a.entry.model.localeCompare(b.entry.model);
+  if (a.entry.verb !== b.entry.verb) return a.entry.verb.localeCompare(b.entry.verb);
+  return (a.entry.specifier ?? "").localeCompare(b.entry.specifier ?? "");
+}
+function ensureOutputDir(outputDir) {
+  if (!existsSync3(outputDir)) mkdirSync(outputDir, { recursive: true });
+}
+function resolveWorkspacePath(value) {
+  return isAbsolute3(value) ? value : resolve3(WORKSPACE_ROOT, value);
+}
+function deriveNamespace(projectName) {
+  const base = (projectName ?? "cli").replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return `${base.toUpperCase()}_API_MANIFEST`;
+}
+function parseFlags(argv) {
+  let only;
+  let strict = false;
+  let functionsConfig;
+  let output;
+  let project;
+  for (const arg of argv) {
+    if (arg === "--strict") {
+      strict = true;
+    } else if (arg.startsWith("--only=")) {
+      const list = arg.slice("--only=".length).split(",").map((s) => s.trim()).filter(Boolean);
+      if (list.length > 0) only = new Set(list);
+    } else if (arg.startsWith("--functions-config=")) {
+      functionsConfig = arg.slice("--functions-config=".length);
+    } else if (arg.startsWith("--output=")) {
+      output = arg.slice("--output=".length);
+    } else if (arg.startsWith("--project=")) {
+      project = arg.slice("--project=".length);
+    }
+  }
+  return { only, strict, functionsConfig, output, project };
+}
+function printUsageAndExit() {
+  console.error(String.raw`generate-api-manifest
+
+Usage:
+  node dist/packages/dbx-cli/firebase-api-manifest/main.js \
+    --project=<name> \
+    --functions-config=<path-to-functions.ts> \
+    --output=<path-to-manifest.generated.ts> \
+    [--only=model[,model]] [--strict]
+
+Required flags:
+  --functions-config=<path>  Path to the app's functions.ts (workspace-relative ok).
+  --output=<path>            Path to the manifest TS file to write (workspace-relative ok).
+
+Optional:
+  --project=<name>           Project name to show in the regenerate banner.
+  --only=<csv>               Filter to listed model names.
+  --strict                   Fail when any validator binding is missing.`);
+  process.exit(1);
+}
+try {
+  await main();
+} catch (e) {
+  console.error(e);
+  process.exit(1);
+}

package/firebase-api-manifest/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@dereekb/dbx-cli-firebase-api-manifest",
+  "version": "13.11.1",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "prettier": "3.8.3",
+    "ts-morph": "^21.0.0"
+  }
+}

package/index.cjs.js

@@ -7102,20 +7102,30 @@ var MANIFEST_HELP_DATA_FORMATS = new Set([
     'both'
 ]);
 var DATA_HELP_FLAG = '--data-help';
+/**
+ * Default name of the parent command that groups all per-model manifest commands.
+ * Surfaces as `<cli> model <model> <action>` so the top-level `--help` stays focused
+ * on first-class commands instead of dumping every model.
+ */ var DEFAULT_MANIFEST_MODEL_COMMAND_NAME = 'model';
 /**
  * Builds yargs `CommandModule[]` from a generated {@link CliApiManifest}.
  *
- * Groups entries by `model`, emitting one parent command per model and one child action per entry
- * (named `<verb>` or `<verb>-<specifier>`). Each child accepts `--data <json>`, validates the
+ * Returns a single parent command (default name `model`) whose subcommands are the per-model
+ * dispatch commands. Each per-model subcommand has one child action per entry
+ * (named `<verb>` or `<verb>-<specifier>`). Each leaf accepts `--data <json>`, validates the
  * payload against the entry's bound arktype validator (when present), and dispatches via the
  * authenticated CLI context's `callModel` helper. Standalone entries are skipped because they
  * are not dispatched through the `/model/call` endpoint.
  *
+ * Wrapping under `model` keeps the top-level `--help` short — users invoke
+ * `<cli> model --help` to see the full list of available models.
+ *
  * @param manifest - The generated manifest array.
  * @param options - Optional overrides; see {@link BuildManifestCommandsOptions}.
- * @returns The yargs `CommandModule[]` ready to be passed to `runCli({ apiCommands })`.
+ * @returns The yargs `CommandModule[]` ready to be passed to `runCli({ apiCommands })`. Empty
+ *   when the manifest has no callable entries.
  */ function buildManifestCommands(manifest, options) {
-    var _ref, _ref1, _ref2, _ref3;
+    var _ref, _ref1, _ref2, _ref3, _ref4;
     var callable = manifest.filter(function(e) {
         return !SKIPPED_VERBS.has(e.verb);
     });
@@ -7147,38 +7157,55 @@ var DATA_HELP_FLAG = '--data-help';
             }
         }
     }
+    if (byModel.size === 0) {
+        return [];
+    }
     var argv = (_ref = options === null || options === void 0 ? void 0 : options.argv) !== null && _ref !== void 0 ? _ref : process.argv;
     var dataHelpFormat = (_ref1 = options === null || options === void 0 ? void 0 : options.dataHelpFormat) !== null && _ref1 !== void 0 ? _ref1 : detectDataHelpFormat(argv);
     var focusHelp = ((_ref2 = options === null || options === void 0 ? void 0 : options.focusHelpOnDataHelp) !== null && _ref2 !== void 0 ? _ref2 : true) && hasDataHelpFlag(argv) && !hasAllHelpFlag(argv);
     var hideOnFocus = focusHelp ? (_ref3 = options === null || options === void 0 ? void 0 : options.hiddenWhenFocused) !== null && _ref3 !== void 0 ? _ref3 : STANDARD_GLOBAL_OPTION_NAMES : [];
-    var commands = [];
-    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-    try {
-        for(var _iterator1 = _to_consumable_array(byModel.entries()).sort(function(param, param1) {
-            var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
-            return a.localeCompare(b);
-        })[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-            var _step_value = _sliced_to_array(_step1.value, 2), model = _step_value[0], entries = _step_value[1];
-            commands.push(buildModelCommand(model, entries, {
-                dataHelpFormat: dataHelpFormat,
-                hideOnFocus: hideOnFocus
-            }));
-        }
-    } catch (err) {
-        _didIteratorError1 = true;
-        _iteratorError1 = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
-            }
-        } finally{
-            if (_didIteratorError1) {
-                throw _iteratorError1;
+    var modelCommandName = (_ref4 = options === null || options === void 0 ? void 0 : options.modelCommandName) !== null && _ref4 !== void 0 ? _ref4 : DEFAULT_MANIFEST_MODEL_COMMAND_NAME;
+    var sortedModels = _to_consumable_array(byModel.entries()).sort(function(param, param1) {
+        var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
+        return a.localeCompare(b);
+    });
+    var context = {
+        dataHelpFormat: dataHelpFormat,
+        hideOnFocus: hideOnFocus
+    };
+    return [
+        {
+            command: "".concat(modelCommandName, " <model>"),
+            describe: "Call typed model APIs (".concat(byModel.size, " model").concat(byModel.size === 1 ? '' : 's', "). Use `").concat(modelCommandName, " --help` to list them."),
+            builder: function builder(yargs) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = sortedModels[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _step_value = _sliced_to_array(_step.value, 2), model = _step_value[0], entries = _step_value[1];
+                        yargs.command(buildModelCommand(model, entries, context));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                hideGlobalOptions(yargs, hideOnFocus);
+                return yargs.demandCommand(1, 'Please specify a model.');
+            },
+            handler: function handler() {
+                return undefined;
             }
         }
-    }
-    return commands;
+    ];
 }
 /**
  * Returns true if `--data-help` (with or without a value) appears anywhere in
@@ -8092,6 +8119,7 @@ exports.CliError = CliError;
 exports.DEFAULT_CLI_OIDC_SCOPES = DEFAULT_CLI_OIDC_SCOPES;
 exports.DEFAULT_CLI_SECRET_PATTERNS = DEFAULT_CLI_SECRET_PATTERNS;
 exports.DEFAULT_MANIFEST_HELP_DATA_FORMAT = DEFAULT_MANIFEST_HELP_DATA_FORMAT;
+exports.DEFAULT_MANIFEST_MODEL_COMMAND_NAME = DEFAULT_MANIFEST_MODEL_COMMAND_NAME;
 exports.DUMP_MERGE_MODES = DUMP_MERGE_MODES;
 exports.DUMP_OUTPUT_MODES = DUMP_OUTPUT_MODES;
 exports.MODEL_WRITE_OIDC_SCOPES = MODEL_WRITE_OIDC_SCOPES;

package/index.esm.js

@@ -7100,20 +7100,30 @@ var MANIFEST_HELP_DATA_FORMATS = new Set([
     'both'
 ]);
 var DATA_HELP_FLAG = '--data-help';
+/**
+ * Default name of the parent command that groups all per-model manifest commands.
+ * Surfaces as `<cli> model <model> <action>` so the top-level `--help` stays focused
+ * on first-class commands instead of dumping every model.
+ */ var DEFAULT_MANIFEST_MODEL_COMMAND_NAME = 'model';
 /**
  * Builds yargs `CommandModule[]` from a generated {@link CliApiManifest}.
  *
- * Groups entries by `model`, emitting one parent command per model and one child action per entry
- * (named `<verb>` or `<verb>-<specifier>`). Each child accepts `--data <json>`, validates the
+ * Returns a single parent command (default name `model`) whose subcommands are the per-model
+ * dispatch commands. Each per-model subcommand has one child action per entry
+ * (named `<verb>` or `<verb>-<specifier>`). Each leaf accepts `--data <json>`, validates the
  * payload against the entry's bound arktype validator (when present), and dispatches via the
  * authenticated CLI context's `callModel` helper. Standalone entries are skipped because they
  * are not dispatched through the `/model/call` endpoint.
  *
+ * Wrapping under `model` keeps the top-level `--help` short — users invoke
+ * `<cli> model --help` to see the full list of available models.
+ *
  * @param manifest - The generated manifest array.
  * @param options - Optional overrides; see {@link BuildManifestCommandsOptions}.
- * @returns The yargs `CommandModule[]` ready to be passed to `runCli({ apiCommands })`.
+ * @returns The yargs `CommandModule[]` ready to be passed to `runCli({ apiCommands })`. Empty
+ *   when the manifest has no callable entries.
  */ function buildManifestCommands(manifest, options) {
-    var _ref, _ref1, _ref2, _ref3;
+    var _ref, _ref1, _ref2, _ref3, _ref4;
     var callable = manifest.filter(function(e) {
         return !SKIPPED_VERBS.has(e.verb);
     });
@@ -7145,38 +7155,55 @@ var DATA_HELP_FLAG = '--data-help';
             }
         }
     }
+    if (byModel.size === 0) {
+        return [];
+    }
     var argv = (_ref = options === null || options === void 0 ? void 0 : options.argv) !== null && _ref !== void 0 ? _ref : process.argv;
     var dataHelpFormat = (_ref1 = options === null || options === void 0 ? void 0 : options.dataHelpFormat) !== null && _ref1 !== void 0 ? _ref1 : detectDataHelpFormat(argv);
     var focusHelp = ((_ref2 = options === null || options === void 0 ? void 0 : options.focusHelpOnDataHelp) !== null && _ref2 !== void 0 ? _ref2 : true) && hasDataHelpFlag(argv) && !hasAllHelpFlag(argv);
     var hideOnFocus = focusHelp ? (_ref3 = options === null || options === void 0 ? void 0 : options.hiddenWhenFocused) !== null && _ref3 !== void 0 ? _ref3 : STANDARD_GLOBAL_OPTION_NAMES : [];
-    var commands = [];
-    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-    try {
-        for(var _iterator1 = _to_consumable_array(byModel.entries()).sort(function(param, param1) {
-            var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
-            return a.localeCompare(b);
-        })[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-            var _step_value = _sliced_to_array(_step1.value, 2), model = _step_value[0], entries = _step_value[1];
-            commands.push(buildModelCommand(model, entries, {
-                dataHelpFormat: dataHelpFormat,
-                hideOnFocus: hideOnFocus
-            }));
-        }
-    } catch (err) {
-        _didIteratorError1 = true;
-        _iteratorError1 = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
-            }
-        } finally{
-            if (_didIteratorError1) {
-                throw _iteratorError1;
+    var modelCommandName = (_ref4 = options === null || options === void 0 ? void 0 : options.modelCommandName) !== null && _ref4 !== void 0 ? _ref4 : DEFAULT_MANIFEST_MODEL_COMMAND_NAME;
+    var sortedModels = _to_consumable_array(byModel.entries()).sort(function(param, param1) {
+        var _param = _sliced_to_array(param, 1), a = _param[0], _param1 = _sliced_to_array(param1, 1), b = _param1[0];
+        return a.localeCompare(b);
+    });
+    var context = {
+        dataHelpFormat: dataHelpFormat,
+        hideOnFocus: hideOnFocus
+    };
+    return [
+        {
+            command: "".concat(modelCommandName, " <model>"),
+            describe: "Call typed model APIs (".concat(byModel.size, " model").concat(byModel.size === 1 ? '' : 's', "). Use `").concat(modelCommandName, " --help` to list them."),
+            builder: function builder(yargs) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = sortedModels[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _step_value = _sliced_to_array(_step.value, 2), model = _step_value[0], entries = _step_value[1];
+                        yargs.command(buildModelCommand(model, entries, context));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                hideGlobalOptions(yargs, hideOnFocus);
+                return yargs.demandCommand(1, 'Please specify a model.');
+            },
+            handler: function handler() {
+                return undefined;
             }
         }
-    }
-    return commands;
+    ];
 }
 /**
  * Returns true if `--data-help` (with or without a value) appears anywhere in
@@ -8081,4 +8108,4 @@ function printPaginatedOutput(input) {
     })();
 }
 
-export { CALL_MODEL_API_PATH, CliError, DEFAULT_CLI_OIDC_SCOPES, DEFAULT_CLI_SECRET_PATTERNS, DEFAULT_MANIFEST_HELP_DATA_FORMAT, DUMP_MERGE_MODES, DUMP_OUTPUT_MODES, MODEL_WRITE_OIDC_SCOPES, MULTIPLE_PAGES_OUTPUT_MODES, PROMPT_CANCELLED_ERROR_CODE, STANDARD_GLOBAL_OPTION_NAMES, applyEnvVarOverrides, buildAuthorizationUrl, buildCliPaths, buildDumpFilePath, buildErrorOutput, buildManifestCommands, callModelOverHttp, callPassthroughCommand, configureCliErrorMapper, configureCliSecretPatterns, configureOutputOptions, createAuthCommand, createAuthMiddleware, createCallModelCommand, createCli, createCliContext, createCliTokenCacheStore, createContextSlot, createDoctorCommand, createEnvCommand, createOutputCommand, createOutputMiddleware, defaultDoctorChecks, detectDataHelpFormat, discoverOidcMetadata, dumpTimestamp, exchangeAuthorizationCode, fetchUserInfo, filterReadOnlyModelScopes, findCliEnvDefault, generateOAuthState, generatePkceMaterial, getCliContext, getOutputOptions, isCliEnvConfigComplete, isTokenExpired, loadCliConfig, maskSecret, mergeCliConfig, mergeCliEnvWithDefault, mergeOutputConfig, openStreamingDump, outputError, outputResult, parsePastedRedirect, pickFields, promptLine, refreshAccessToken, requireCliContext, resolveActiveEnvName, resolveOutputConfig, revokeToken, runCli, runPaginatedList, sanitizeString, saveCliConfig, setCliContext, withCallModelArgs, withEnv, withMultiplePages, withOutput, wrapCommandHandler };
+export { CALL_MODEL_API_PATH, CliError, DEFAULT_CLI_OIDC_SCOPES, DEFAULT_CLI_SECRET_PATTERNS, DEFAULT_MANIFEST_HELP_DATA_FORMAT, DEFAULT_MANIFEST_MODEL_COMMAND_NAME, DUMP_MERGE_MODES, DUMP_OUTPUT_MODES, MODEL_WRITE_OIDC_SCOPES, MULTIPLE_PAGES_OUTPUT_MODES, PROMPT_CANCELLED_ERROR_CODE, STANDARD_GLOBAL_OPTION_NAMES, applyEnvVarOverrides, buildAuthorizationUrl, buildCliPaths, buildDumpFilePath, buildErrorOutput, buildManifestCommands, callModelOverHttp, callPassthroughCommand, configureCliErrorMapper, configureCliSecretPatterns, configureOutputOptions, createAuthCommand, createAuthMiddleware, createCallModelCommand, createCli, createCliContext, createCliTokenCacheStore, createContextSlot, createDoctorCommand, createEnvCommand, createOutputCommand, createOutputMiddleware, defaultDoctorChecks, detectDataHelpFormat, discoverOidcMetadata, dumpTimestamp, exchangeAuthorizationCode, fetchUserInfo, filterReadOnlyModelScopes, findCliEnvDefault, generateOAuthState, generatePkceMaterial, getCliContext, getOutputOptions, isCliEnvConfigComplete, isTokenExpired, loadCliConfig, maskSecret, mergeCliConfig, mergeCliEnvWithDefault, mergeOutputConfig, openStreamingDump, outputError, outputResult, parsePastedRedirect, pickFields, promptLine, refreshAccessToken, requireCliContext, resolveActiveEnvName, resolveOutputConfig, revokeToken, runCli, runPaginatedList, sanitizeString, saveCliConfig, setCliContext, withCallModelArgs, withEnv, withMultiplePages, withOutput, wrapCommandHandler };

package/package.json

@@ -1,18 +1,14 @@
 {
   "name": "@dereekb/dbx-cli",
-  "version": "13.11.0",
+  "version": "13.11.1",
   "sideEffects": false,
-  "peerDependencies": {
-    "@dereekb/firebase": "13.11.0",
-    "@dereekb/nestjs": "13.11.0",
-    "@dereekb/util": "13.11.0",
-    "arktype": "^2.2.0",
-    "yargs": "^18.0.0"
-  },
-  "devDependencies": {
-    "@types/yargs": "^17.0.35"
+  "bin": {
+    "dbx-cli-generate-firebase-api-manifest": "firebase-api-manifest/main.js"
   },
   "exports": {
+    "./firebase-api-manifest": {
+      "default": "./firebase-api-manifest/main.js"
+    },
     "./package.json": "./package.json",
     ".": {
       "module": "./index.esm.js",
@@ -21,6 +17,16 @@
       "default": "./index.cjs.js"
     }
   },
+  "peerDependencies": {
+    "@dereekb/firebase": "13.11.1",
+    "@dereekb/nestjs": "13.11.1",
+    "@dereekb/util": "13.11.1",
+    "arktype": "^2.2.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/yargs": "^17.0.35"
+  },
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
   "types": "./index.d.ts"

package/src/lib/manifest/build-manifest-commands.d.ts

@@ -48,19 +48,36 @@ export interface BuildManifestCommandsOptions {
      * {@link createCli}).
      */
     readonly hiddenWhenFocused?: readonly string[];
+    /**
+     * Name of the parent command that groups all per-model dispatch subcommands.
+     * Defaults to {@link DEFAULT_MANIFEST_MODEL_COMMAND_NAME} (`model`), so the
+     * full invocation reads `<cli> model <model> <action>`.
+     */
+    readonly modelCommandName?: string;
 }
+/**
+ * Default name of the parent command that groups all per-model manifest commands.
+ * Surfaces as `<cli> model <model> <action>` so the top-level `--help` stays focused
+ * on first-class commands instead of dumping every model.
+ */
+export declare const DEFAULT_MANIFEST_MODEL_COMMAND_NAME = "model";
 /**
  * Builds yargs `CommandModule[]` from a generated {@link CliApiManifest}.
  *
- * Groups entries by `model`, emitting one parent command per model and one child action per entry
- * (named `<verb>` or `<verb>-<specifier>`). Each child accepts `--data <json>`, validates the
+ * Returns a single parent command (default name `model`) whose subcommands are the per-model
+ * dispatch commands. Each per-model subcommand has one child action per entry
+ * (named `<verb>` or `<verb>-<specifier>`). Each leaf accepts `--data <json>`, validates the
  * payload against the entry's bound arktype validator (when present), and dispatches via the
  * authenticated CLI context's `callModel` helper. Standalone entries are skipped because they
  * are not dispatched through the `/model/call` endpoint.
  *
+ * Wrapping under `model` keeps the top-level `--help` short — users invoke
+ * `<cli> model --help` to see the full list of available models.
+ *
  * @param manifest - The generated manifest array.
  * @param options - Optional overrides; see {@link BuildManifestCommandsOptions}.
- * @returns The yargs `CommandModule[]` ready to be passed to `runCli({ apiCommands })`.
+ * @returns The yargs `CommandModule[]` ready to be passed to `runCli({ apiCommands })`. Empty
+ *   when the manifest has no callable entries.
  */
 export declare function buildManifestCommands(manifest: CliApiManifest, options?: BuildManifestCommandsOptions): CommandModule[];
 /**

package/src/lib/runner/run.d.ts

@@ -20,6 +20,9 @@ export interface CreateCliInput {
      * App-specific API commands appended after the built-in `call` passthrough.
      *
      * Commands listed here run after the auth middleware, so they have access to the {@link CliContext}.
+     *
+     * For manifest-driven typed model commands, pass the result of `buildManifestCommands(manifest)` —
+     * it returns a single parent `model <model>` command so the top-level `--help` stays focused.
      */
     readonly apiCommands?: CommandModule[];
     /**

package/firebase-api-manifest/src/generate-api-manifest/bind-validators.d.ts

@@ -1,44 +0,0 @@
-/**
- * For a given Params type name (e.g. `SetProfileUsernameParams`), derives the
- * canonical arktype validator identifier (`setProfileUsernameParamsType`) by
- * naming convention and confirms it is exported from the resolved package.
- *
- * Verification is best-effort: we string-search the package's `src/index.ts`
- * and follow `export * from './...';` re-exports recursively until we find
- * the declaration of the validator. The convention everywhere in the codebase
- * is `export const <name>ParamsType = ... as Type<<Name>Params>`.
- */
-/**
- * Derives the canonical arktype validator identifier from a Params type name.
- *
- * `SetProfileUsernameParams` → `setProfileUsernameParamsType`.
- *
- * @param paramsTypeName - PascalCase Params type identifier.
- * @returns The lowerCamelCase validator identifier (or empty string for empty input).
- */
-export declare function deriveValidatorName(paramsTypeName: string): string;
-/**
- * Inputs for {@link isExportedFromPackage}.
- */
-export interface IsExportedInput {
-    readonly packageRoot: string;
-    readonly identifier: string;
-}
-/**
- * Confirms an identifier is exported from `packageRoot/src/index.ts` —
- * directly or via re-export chains.
- *
- * @param input - Package root + identifier to look up.
- * @returns `true` when the identifier is reachable from the barrel.
- */
-export declare function isExportedFromPackage(input: IsExportedInput): boolean;
-/**
- * Walks the `src/lib` tree under a package and returns the absolute file
- * paths of every `.ts` file (used as a fallback when index-chain lookup
- * misses the identifier — some packages rely on flat barrels that don't
- * `export *`).
- *
- * @param packageRoot - Absolute path to the source package's root directory.
- * @returns Absolute paths of every non-spec `.ts` file under `src`.
- */
-export declare function listPackageTsFiles(packageRoot: string): string[];

package/firebase-api-manifest/src/generate-api-manifest/emit.d.ts

@@ -1,29 +0,0 @@
-/**
- * Renders the final manifest TS module — banner + grouped imports + the
- * `<NAMESPACE>` array literal. Formatted with the workspace prettier config
- * so the output matches what `prettier --write` would produce on the
- * committed file.
- *
- * The reusable `CliApiManifest` type is imported from `@dereekb/dbx-cli` so
- * any consuming app gets it from the shared dbx-cli barrel.
- */
-import type { CollectedEntry } from './types';
-/**
- * Inputs for {@link renderManifest}.
- */
-export interface RenderManifestInput {
-    readonly outputFile: string;
-    readonly entries: readonly CollectedEntry[];
-    readonly projectName: string;
-    readonly namespace: string;
-}
-/**
- * Renders the manifest TS source for a CLI app and formats it with the
- * workspace prettier config so the output matches a `prettier --write` of the
- * committed file.
- *
- * @param input - Output file path, collected entries, project name (banner),
- *   and the manifest namespace identifier.
- * @returns Prettier-formatted TypeScript source.
- */
-export declare function renderManifest(input: RenderManifestInput): Promise<string>;

package/firebase-api-manifest/src/generate-api-manifest/extract-crud.d.ts

@@ -1,25 +0,0 @@
-/**
- * Walks `<Group>ModelCrudFunctionsConfig` and `<Group>FunctionTypeMap` type
- * aliases in a `<model>.api.ts` source. Returns one entry per callable leaf,
- * keyed by (model, verb, specifier).
- *
- * Mirrors `extractCrudEntries` from
- * packages/dbx-components-mcp/src/tools/model-api-shared/extract-crud.ts —
- * keep the two in lockstep when the .api.ts convention changes.
- */
-import type { CrudExtraction } from './types';
-/**
- * Inputs for {@link extractCrudEntries}.
- */
-export interface ExtractCrudInput {
-    readonly name: string;
-    readonly text: string;
-}
-/**
- * Extracts CRUD + standalone entries from a `.api.ts` source by walking its
- * `<Group>ModelCrudFunctionsConfig` and `<Group>FunctionTypeMap` aliases.
- *
- * @param source - The source file's name + text.
- * @returns The extracted entries, group name, model keys, and `*Functions` class name.
- */
-export declare function extractCrudEntries(source: ExtractCrudInput): CrudExtraction;

package/firebase-api-manifest/src/generate-api-manifest/find-api-files.d.ts

@@ -1,16 +0,0 @@
-/**
- * Walks a package's `src/lib/**\/*.api.ts` and returns the files that declare
- * an abstract `*Functions` class along with the class name. Used to map a
- * class identifier from `<APP>_FIREBASE_FUNCTIONS_CONFIG` back to the source
- * `*.api.ts`.
- */
-import type { ApiFileMatch } from './types';
-/**
- * Walks `packageRoot/src/lib/**\/*.api.ts` and returns the files that declare
- * an abstract `*Functions` class along with the class name and the
- * extracted CRUD entries.
- *
- * @param packageRoot - Absolute path to the source package's root directory.
- * @returns One {@link ApiFileMatch} per qualifying `.api.ts`.
- */
-export declare function findApiFiles(packageRoot: string): ApiFileMatch[];

package/firebase-api-manifest/src/generate-api-manifest/main.d.ts

@@ -1,46 +0,0 @@
-/**
- * Generates an API manifest TS file for any dbx-components CLI app.
- *
- * Pipeline (build-time, run via `nx run <cli>:generate-api-manifest`):
- *
- *   1. Parse the app's `<APP>_FIREBASE_FUNCTIONS_CONFIG` from the file passed
- *      via --functions-config to enumerate the `*Functions` abstract classes
- *      used by the app, including their source-module specifier
- *      ("@dereekb/firebase", "demo-firebase", "./model", "./development",
- *      ...). The leading-app prefix is matched generically by
- *      `/FIREBASE_FUNCTIONS_CONFIG$/` so any app variable name works.
- *
- *   2. Resolve each module to a source-package root via the workspace's
- *      tsconfig.base.json `paths`.
- *
- *   3. Walk that package's `src/lib/**\/*.api.ts`, run the CRUD-entry walker
- *      on each, and pick the file whose abstract `*Functions` class name
- *      matches the entry's class identifier.
- *
- *   4. For each CRUD entry with a `paramsTypeName`, derive the canonical
- *      arktype validator name (lowercaseFirst + `Type`) and confirm it is
- *      exported from the package's barrel chain. Warn on miss; the entry is
- *      still emitted with `paramsValidator: undefined`. `--strict` makes a
- *      miss fatal.
- *
- *   5. Emit the manifest to the path passed via --output with grouped
- *      per-package imports + the `<NAMESPACE>_API_MANIFEST` array literal.
- *      Skip the write if the file content is byte-identical (preserves mtime
- *      for incremental builds).
- *
- * Flags:
- *   --functions-config=<path>   (required) path to the app's functions.ts.
- *                                Absolute or workspace-relative.
- *   --output=<path>             (required) path to the manifest TS file to write.
- *                                Absolute or workspace-relative.
- *   --project=<name>            Project name shown in the regenerate banner
- *                                (defaults to "<cli>"). Also used to derive
- *                                the manifest namespace (e.g. "demo-cli" ->
- *                                DEMO_CLI_API_MANIFEST).
- *   --only=<model[,model]>      Filter the emitted entries to those models.
- *   --strict                    Exit 1 if any validator is missing.
- *
- * Run from any cwd; workspace-relative paths resolve against `process.cwd()`
- * (Nx invokes with cwd: "{workspaceRoot}").
- */
-export {};

package/firebase-api-manifest/src/generate-api-manifest/parse-functions.d.ts

@@ -1,18 +0,0 @@
-/**
- * Parses the `<APP>_FIREBASE_FUNCTIONS_CONFIG` variable from a CLI app's
- * `functions.ts` and returns the (groupKey, className, importedFromModule)
- * tuple for every entry.
- *
- * We follow the import declaration of the abstract-class identifier to know
- * which package the `*.api.ts` lives in. The variable name is matched
- * generically by `/FIREBASE_FUNCTIONS_CONFIG$/` so any app-prefix works.
- */
-import type { FunctionsGroup } from './types';
-/**
- * Parses the `<APP>_FIREBASE_FUNCTIONS_CONFIG` literal at `functionsTsPath`
- * into one entry per group declared in the config object.
- *
- * @param functionsTsPath - Absolute path to the app's `functions.ts`.
- * @returns One {@link FunctionsGroup} per `<groupKey>: [<Class>, ...]` pair.
- */
-export declare function parseFunctionsConfig(functionsTsPath: string): FunctionsGroup[];

package/firebase-api-manifest/src/generate-api-manifest/resolve-package.d.ts

@@ -1,59 +0,0 @@
-/**
- * Resolves a workspace module specifier (e.g. "@dereekb/firebase",
- * "demo-firebase", "./model", "./development") to a source-package root and
- * canonical import name.
- *
- * Reads the workspace tsconfig.base.json `compilerOptions.paths` to map bare
- * specifiers to their `src/index.ts` entry. Relative specifiers are resolved
- * against the importing file's directory and then walked back up to the
- * nearest `package.json` that owns them.
- */
-import type { PackageRef } from './types';
-/**
- * Inputs accepted by {@link resolveModuleToPackage}.
- */
-export interface ResolveModuleInput {
-    readonly workspaceRoot: string;
-    readonly importingFile: string;
-    readonly moduleSpecifier: string;
-}
-/**
- * Reads `tsconfig.base.json` and returns the `compilerOptions.paths` map
- * (canonical bare specifier → absolute path to its `src/index.ts`).
- *
- * @param workspaceRoot - Workspace root directory.
- * @returns Cached map of canonical specifiers to absolute index paths.
- */
-export declare function loadTsconfigPaths(workspaceRoot: string): Map<string, string>;
-/**
- * Resolves a module specifier to the source-package that owns it.
- *
- * @param input - Workspace root + importing-file location + the specifier.
- * @returns The {@link PackageRef} of the owning package, or `undefined` when unresolved.
- */
-export declare function resolveModuleToPackage(input: ResolveModuleInput): PackageRef | undefined;
-/**
- * Walks up from `startPath` until it finds a directory containing a `package.json`
- * with a `name` field, then returns its package name + root.
- *
- * @param workspaceRoot - Stop walking when this directory is reached.
- * @param startPath - Path to walk up from.
- * @returns The package name + root, or `undefined` if no package.json is found.
- */
-export declare function locatePackageForPath(workspaceRoot: string, startPath: string): PackageRef | undefined;
-/**
- * Returns the workspace-root-relative path with forward slashes for display.
- *
- * @param workspaceRoot - Workspace root directory.
- * @param absolutePath - Absolute path to make relative.
- * @returns The workspace-relative path with forward slashes.
- */
-export declare function relPath(workspaceRoot: string, absolutePath: string): string;
-/**
- * Type-narrowed `isAbsolute` re-export so the generator scripts only depend on
- * `node:path` indirectly through this module.
- *
- * @param value - Path to test.
- * @returns `true` when the path is absolute.
- */
-export declare function isAbsolutePathLike(value: string): boolean;

package/firebase-api-manifest/src/generate-api-manifest/types.d.ts

@@ -1,44 +0,0 @@
-/**
- * Internal types shared between the generator's pipeline stages.
- *
- * The runtime manifest types (`CliApiManifest`, `CliApiManifestEntry`,
- * `CliApiVerb`) live in `packages/dbx-cli/src/lib/manifest/types.ts` and are
- * re-exported from `@dereekb/dbx-cli`. The generator emits TypeScript that
- * imports those runtime types — it does not reference them itself.
- */
-export interface FunctionsGroup {
-    readonly groupKey: string;
-    readonly className: string;
-    readonly importedFromModule: string;
-}
-export interface PackageRef {
-    readonly packageName: string;
-    readonly packageRoot: string;
-}
-export interface CrudEntry {
-    readonly model: string;
-    readonly verb: string;
-    readonly specifier?: string;
-    readonly paramsTypeName?: string;
-    readonly resultTypeName?: string;
-    readonly line: number;
-}
-export interface CrudExtraction {
-    readonly groupName: string | undefined;
-    readonly modelKeys: readonly string[];
-    readonly entries: readonly CrudEntry[];
-    readonly functionsClassName?: string;
-}
-export interface ApiFileMatch {
-    readonly filePath: string;
-    readonly className: string;
-    readonly extraction: CrudExtraction;
-}
-export interface CollectedEntry {
-    readonly entry: CrudEntry & {
-        readonly groupName: string;
-        readonly sourceFile: string;
-    };
-    readonly packageName?: string;
-    readonly validatorName?: string;
-}