@holo-js/cli 0.2.6 → 0.3.1

package/dist/chunk-AZ6NVJAP.mjs

@@ -0,0 +1,360 @@
+import {
+  COMMAND_FILE_PATTERN,
+  MIGRATION_NAME_PATTERN,
+  isRecord,
+  makeProjectRelativePath,
+  pathExists,
+  readTextFile,
+  toPosixPath
+} from "./chunk-PVVGQSUP.mjs";
+
+// src/project/discovery-helpers.ts
+import { readdir } from "fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "path";
+async function collectFiles(root) {
+  if (!await pathExists(root)) {
+    return [];
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const target = join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(target));
+      continue;
+    }
+    if (entry.isFile() && COMMAND_FILE_PATTERN.test(entry.name)) {
+      files.push(target);
+    }
+  }
+  return files;
+}
+function deriveCommandNameFromPath(commandsRoot, sourcePath) {
+  const relativePath = toPosixPath(relative(commandsRoot, sourcePath));
+  return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(":");
+}
+function deriveJobNameFromPath(jobsRoot, sourcePath) {
+  const relativePath = toPosixPath(relative(jobsRoot, sourcePath));
+  return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(".");
+}
+function deriveDottedNameFromPath(root, sourcePath, emptyMessage) {
+  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
+  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
+  if (!derived) {
+    throw new Error(emptyMessage);
+  }
+  return derived;
+}
+function deriveEventNameFromPath(eventsRoot, sourcePath) {
+  return deriveDottedNameFromPath(eventsRoot, sourcePath, "[Holo Events] Derived event names require a non-empty source path.");
+}
+function deriveListenerIdFromPath(listenersRoot, sourcePath) {
+  return deriveDottedNameFromPath(listenersRoot, sourcePath, "[Holo Events] Derived listener identifiers require a non-empty source path.");
+}
+function deriveBroadcastNameFromPath(root, sourcePath) {
+  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived broadcast names require a non-empty source path.");
+}
+function deriveChannelPatternFromPath(root, sourcePath) {
+  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived channel patterns require a non-empty source path.");
+}
+function resolveDiscoveredJobMetadata(job, sourcePath, derivedName, queueConfig) {
+  const connection = job.connection ?? queueConfig.default;
+  let queue = job.queue;
+  if (!queue) {
+    const configuredConnection = queueConfig.connections[connection];
+    queue = configuredConnection ? configuredConnection.queue : "default";
+  }
+  return {
+    sourcePath,
+    name: derivedName,
+    connection,
+    queue,
+    ...typeof job.tries === "number" ? { tries: job.tries } : {},
+    ...typeof job.backoff !== "undefined" ? { backoff: job.backoff } : {},
+    ...typeof job.timeout === "number" ? { timeout: job.timeout } : {}
+  };
+}
+function isAppCommand(value) {
+  return isRecord(value) && typeof value.description === "string" && typeof value.run === "function";
+}
+function resolveCommandExport(moduleValue) {
+  if (isRecord(moduleValue) && isAppCommand(moduleValue.default)) {
+    return moduleValue.default;
+  }
+  if (isRecord(moduleValue)) {
+    for (const value of Object.values(moduleValue)) {
+      if (isAppCommand(value)) {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeCommandAliases(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = [...new Set(value.map((alias) => alias.trim()).filter(Boolean))];
+  return normalized.length > 0 ? normalized : void 0;
+}
+function assertUniqueEntries(kind, entries) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = seen.get(entry.name);
+    if (existing) {
+      throw new Error(`Discovered duplicate ${kind} "${entry.name}" in "${existing}" and "${entry.sourcePath}".`);
+    }
+    seen.set(entry.name, entry.sourcePath);
+  }
+}
+function assertUniqueCommandTokens(entries) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const token of [entry.name, ...entry.aliases]) {
+      const existing = seen.get(token);
+      if (existing) {
+        throw new Error(`Discovered duplicate command token "${token}" in "${existing}" and "${entry.sourcePath}".`);
+      }
+      seen.set(token, entry.sourcePath);
+    }
+  }
+}
+function resolveRegisteredPath(projectRoot, entry) {
+  return resolve(projectRoot, entry);
+}
+function resolveNamedExport(moduleValue, matcher) {
+  if (!isRecord(moduleValue)) return void 0;
+  if (matcher(moduleValue.default)) return moduleValue.default;
+  for (const value of Object.values(moduleValue)) {
+    if (matcher(value)) return value;
+  }
+  return void 0;
+}
+function resolveNamedExportEntry(moduleValue, matcher) {
+  if (!isRecord(moduleValue)) return void 0;
+  if (matcher(moduleValue.default)) {
+    return { exportName: "default", value: moduleValue.default };
+  }
+  for (const [exportName, value] of Object.entries(moduleValue)) {
+    if (matcher(value)) return { exportName, value };
+  }
+  return void 0;
+}
+function isCliModelReference(value) {
+  return isRecord(value) && isRecord(value.definition) && value.definition.kind === "model" && typeof value.definition.name === "string" && typeof value.prune === "function";
+}
+function isMissingGeneratedSchemaModelError(error) {
+  return error instanceof Error && error.message.includes("is not present in the generated schema registry");
+}
+function isInactiveGeneratedModelModule(value) {
+  return isRecord(value) && value.holoModelPendingSchema === true;
+}
+function isMigrationDefinition(value) {
+  return isRecord(value) && typeof value.up === "function";
+}
+function isSeederDefinition(value) {
+  return isRecord(value) && typeof value.name === "string" && typeof value.run === "function";
+}
+function resolveListenerEventNamesForDiscovery(listener, eventNamesByReference = /* @__PURE__ */ new Map()) {
+  return Object.freeze([...new Set(listener.listensTo.map((reference) => {
+    if (typeof reference === "string") {
+      return reference.trim();
+    }
+    if (typeof reference.name === "string" && reference.name.trim()) {
+      return reference.name.trim();
+    }
+    if (eventNamesByReference.has(reference)) {
+      return eventNamesByReference.get(reference);
+    }
+    throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
+  }))]);
+}
+function resolveAuthorizationTargetName(target) {
+  const modelFacadeTarget = target;
+  if (typeof modelFacadeTarget.definition?.name === "string" && modelFacadeTarget.definition.name.trim()) {
+    return modelFacadeTarget.definition.name.trim();
+  }
+  const namedTarget = target;
+  return typeof namedTarget.name === "string" && namedTarget.name.trim() ? namedTarget.name.trim() : void 0;
+}
+function captureAuthorizationDefinitionNames(definitions) {
+  return new Set(definitions.keys());
+}
+function findAddedAuthorizationDefinitionNames(definitions, existingNames) {
+  return [...definitions.keys()].filter((name) => !existingNames.has(name));
+}
+function unregisterAuthorizationDefinitionNames(authorizationDiscovery, policyNames, abilityNames) {
+  if (typeof authorizationDiscovery.authorizationInternals.unregisterPolicyDefinition !== "function" || typeof authorizationDiscovery.authorizationInternals.unregisterAbilityDefinition !== "function") {
+    authorizationDiscovery.authorizationInternals.resetAuthorizationRuntimeState?.();
+    return;
+  }
+  for (const policyName of policyNames) {
+    authorizationDiscovery.authorizationInternals.unregisterPolicyDefinition(policyName);
+  }
+  for (const abilityName of abilityNames) {
+    authorizationDiscovery.authorizationInternals.unregisterAbilityDefinition(abilityName);
+  }
+}
+function collectImportedBindingsBySource(sourceText) {
+  const bindings = /* @__PURE__ */ new Map();
+  const importPattern = /import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  for (const match of sourceText.matchAll(importPattern)) {
+    const clause = match[1]?.trim();
+    const source = match[2]?.trim();
+    if (!clause || !source) {
+      continue;
+    }
+    const namedMatch = clause.match(/\{([\s\S]+)\}/);
+    const defaultClause = clause.replace(/\{[\s\S]+\}/, "").replace(/,$/, "").trim();
+    if (defaultClause && defaultClause !== "*") {
+      bindings.set(defaultClause, source);
+    }
+    if (namedMatch?.[1]) {
+      for (const specifier of namedMatch[1].split(",")) {
+        const trimmed = specifier.trim();
+        if (!trimmed) {
+          continue;
+        }
+        const [imported, local] = trimmed.split(/\s+as\s+/);
+        const bindingName = (local ?? imported)?.trim();
+        if (bindingName) {
+          bindings.set(bindingName, source);
+        }
+      }
+    }
+  }
+  return bindings;
+}
+function extractListensToItems(sourceText) {
+  const markerIndex = sourceText.indexOf("listensTo");
+  if (markerIndex < 0) {
+    return [];
+  }
+  const colonIndex = sourceText.indexOf(":", markerIndex);
+  if (colonIndex < 0) {
+    return [];
+  }
+  let cursor = colonIndex + 1;
+  while (cursor < sourceText.length && /\s/.test(sourceText[cursor])) {
+    cursor += 1;
+  }
+  const startChar = sourceText[cursor];
+  let depth = 0;
+  let inString;
+  let expression = "";
+  for (; cursor < sourceText.length; cursor += 1) {
+    const char = sourceText[cursor];
+    expression += char;
+    if (inString) {
+      if (char === inString && sourceText[cursor - 1] !== "\\") {
+        inString = void 0;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      inString = char;
+      continue;
+    }
+    if (char === "[" || char === "{" || char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === "]" || char === "}" || char === ")") {
+      depth -= 1;
+      if (depth === 0 && startChar === "[") {
+        break;
+      }
+      continue;
+    }
+    if (depth === 0 && startChar !== "[" && (char === "," || char === "\n" || char === "\r")) {
+      expression = expression.slice(0, -1);
+      break;
+    }
+  }
+  if (startChar !== "[") {
+    const item = expression.trim().replace(/\s+as\s+const$/, "");
+    return item ? [item] : [];
+  }
+  return expression.slice(1, -1).split(",").map((item) => item.trim().replace(/\s+as\s+const$/, "")).filter(Boolean);
+}
+async function resolveListenerEventNamesFromSource(projectRoot, listenerPath, discoveredEventNamesBySourcePath) {
+  const sourceText = await readTextFile(listenerPath) ?? "";
+  const bindingsByName = collectImportedBindingsBySource(sourceText);
+  const discoveredEventNamesByExtensionlessSourcePath = new Map(
+    [...discoveredEventNamesBySourcePath.entries()].map(([sourcePath, eventName]) => {
+      return [sourcePath.replace(/\.[^.]+$/, ""), eventName];
+    })
+  );
+  const resolvedEventNames = [];
+  for (const item of extractListensToItems(sourceText)) {
+    const quoted = item.match(/^['"](.+)['"]$/);
+    if (quoted) {
+      resolvedEventNames.push(quoted[1].trim());
+      continue;
+    }
+    const importSource = bindingsByName.get(item);
+    if (!importSource) {
+      throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
+    }
+    const importedPath = makeProjectRelativePath(projectRoot, resolve(dirname(listenerPath), importSource));
+    const eventName = discoveredEventNamesBySourcePath.get(importedPath) ?? discoveredEventNamesByExtensionlessSourcePath.get(importedPath.replace(/\.[^.]+$/, ""));
+    if (!eventName) {
+      throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
+    }
+    resolvedEventNames.push(eventName);
+  }
+  return Object.freeze([...new Set(resolvedEventNames)]);
+}
+function resolveBroadcastArtifactsPath(config, key) {
+  const configuredPaths = config.paths;
+  return configuredPaths[key] ?? `server/${key}`;
+}
+function inferMigrationNameFromEntry(entry) {
+  const fileName = basename(entry, extname(entry));
+  return validateMigrationName(
+    fileName,
+    `Registered migration "${entry}" must use a timestamped file name matching YYYY_MM_DD_HHMMSS_description.`
+  );
+}
+function validateMigrationName(name, message) {
+  if (!MIGRATION_NAME_PATTERN.test(name)) {
+    throw new Error(
+      message ?? `Migration name "${name}" must match YYYY_MM_DD_HHMMSS_description.`
+    );
+  }
+  return name;
+}
+
+export {
+  collectFiles,
+  deriveCommandNameFromPath,
+  deriveJobNameFromPath,
+  deriveEventNameFromPath,
+  deriveListenerIdFromPath,
+  deriveBroadcastNameFromPath,
+  deriveChannelPatternFromPath,
+  resolveDiscoveredJobMetadata,
+  resolveCommandExport,
+  normalizeCommandAliases,
+  assertUniqueEntries,
+  assertUniqueCommandTokens,
+  resolveRegisteredPath,
+  resolveNamedExport,
+  resolveNamedExportEntry,
+  isCliModelReference,
+  isMissingGeneratedSchemaModelError,
+  isInactiveGeneratedModelModule,
+  isMigrationDefinition,
+  isSeederDefinition,
+  resolveListenerEventNamesForDiscovery,
+  resolveAuthorizationTargetName,
+  captureAuthorizationDefinitionNames,
+  findAddedAuthorizationDefinitionNames,
+  unregisterAuthorizationDefinitionNames,
+  collectImportedBindingsBySource,
+  extractListensToItems,
+  resolveListenerEventNamesFromSource,
+  resolveBroadcastArtifactsPath,
+  inferMigrationNameFromEntry,
+  validateMigrationName
+};

package/dist/chunk-CT23GSEC.mjs

@@ -0,0 +1,156 @@
+import {
+  HOLO_PACKAGE_VERSION,
+  readTextFile,
+  writeTextFile
+} from "./chunk-PVVGQSUP.mjs";
+
+// src/package-json.ts
+import { join } from "path";
+function normalizeDependencyMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([, dependencyVersion]) => typeof dependencyVersion === "string").sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function isWorkspaceDependencyVersion(value) {
+  return typeof value === "string" && value.startsWith("workspace:");
+}
+function assertValidDependencyName(packageName) {
+  if (!/^@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/.test(packageName) && !/^[a-z0-9][a-z0-9._-]*$/.test(packageName)) {
+    throw new Error(`Invalid dependency package name: ${packageName || "(empty)"}.`);
+  }
+}
+function resolveInstalledPackageJsonPath(projectRoot, packageName) {
+  return join(projectRoot, "node_modules", ...packageName.split("/"), "package.json");
+}
+async function resolveInstalledPackageVersion(projectRoot, packageName) {
+  const packageJson = await readTextFile(resolveInstalledPackageJsonPath(projectRoot, packageName));
+  if (!packageJson) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(packageJson);
+    return typeof parsed.version === "string" && parsed.version.trim() ? `^${parsed.version.trim()}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolvePackageVersion(projectRoot, packageName, dependencies, devDependencies) {
+  const currentPackageVersion = dependencies[packageName] ?? devDependencies[packageName];
+  if (typeof currentPackageVersion === "string") {
+    return currentPackageVersion;
+  }
+  const workspaceVersion = Object.entries({
+    ...dependencies,
+    ...devDependencies
+  }).find(([dependencyName, dependencyVersion]) => dependencyName.startsWith("@holo-js/") && isWorkspaceDependencyVersion(dependencyVersion))?.[1];
+  if (packageName.startsWith("@holo-js/")) {
+    return workspaceVersion ?? `^${HOLO_PACKAGE_VERSION}`;
+  }
+  return await resolveInstalledPackageVersion(projectRoot, packageName) ?? "latest";
+}
+function sortDependencyMap(dependencies) {
+  return Object.fromEntries(
+    Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+async function readPackageJsonDependencyState(projectRoot) {
+  const packageJsonPath = join(projectRoot, "package.json");
+  const packageJson = await readTextFile(packageJsonPath);
+  if (!packageJson) {
+    throw new Error(`Missing package.json in ${projectRoot}.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(packageJson);
+  } catch {
+    throw new Error(`Invalid package.json in ${projectRoot}.`);
+  }
+  return {
+    packageJsonPath,
+    parsed,
+    dependencies: normalizeDependencyMap(parsed.dependencies),
+    devDependencies: normalizeDependencyMap(parsed.devDependencies)
+  };
+}
+async function writePackageJsonDependencyState(state) {
+  state.parsed.dependencies = sortDependencyMap(state.dependencies);
+  if (Object.keys(state.devDependencies).length > 0) {
+    state.parsed.devDependencies = sortDependencyMap(state.devDependencies);
+  } else {
+    delete state.parsed.devDependencies;
+  }
+  await writeTextFile(state.packageJsonPath, `${JSON.stringify(state.parsed, null, 2)}
+`);
+}
+async function hasProjectDependency(projectRoot, packageName) {
+  const packageJson = await readTextFile(join(projectRoot, "package.json"));
+  if (!packageJson) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(packageJson);
+    return typeof parsed.dependencies?.[packageName] === "string" || typeof parsed.devDependencies?.[packageName] === "string";
+  } catch {
+    return false;
+  }
+}
+async function upsertProjectDependency(projectRoot, packageName) {
+  assertValidDependencyName(packageName);
+  const state = await readPackageJsonDependencyState(projectRoot);
+  const nextVersion = await resolvePackageVersion(projectRoot, packageName, state.dependencies, state.devDependencies);
+  if (state.dependencies[packageName] === nextVersion && typeof state.devDependencies[packageName] === "undefined") {
+    return false;
+  }
+  state.dependencies[packageName] = nextVersion;
+  delete state.devDependencies[packageName];
+  await writePackageJsonDependencyState(state);
+  return true;
+}
+async function pinProjectDependencyVersions(projectRoot, packageNames) {
+  const state = await readPackageJsonDependencyState(projectRoot);
+  let changed = false;
+  for (const packageName of packageNames) {
+    assertValidDependencyName(packageName);
+    if (packageName.startsWith("@holo-js/")) {
+      continue;
+    }
+    const installedVersion = await resolveInstalledPackageVersion(projectRoot, packageName);
+    if (!installedVersion) {
+      continue;
+    }
+    if (state.dependencies[packageName] === "latest") {
+      state.dependencies[packageName] = installedVersion;
+      changed = true;
+    }
+    if (state.devDependencies[packageName] === "latest") {
+      state.devDependencies[packageName] = installedVersion;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return false;
+  }
+  await writePackageJsonDependencyState(state);
+  return true;
+}
+async function removeProjectDependency(projectRoot, packageName) {
+  assertValidDependencyName(packageName);
+  const state = await readPackageJsonDependencyState(projectRoot);
+  if (typeof state.dependencies[packageName] === "undefined" && typeof state.devDependencies[packageName] === "undefined") {
+    return false;
+  }
+  delete state.dependencies[packageName];
+  delete state.devDependencies[packageName];
+  await writePackageJsonDependencyState(state);
+  return true;
+}
+
+export {
+  hasProjectDependency,
+  upsertProjectDependency,
+  pinProjectDependencyVersions,
+  removeProjectDependency
+};