@holo-js/cli 0.2.5 → 0.3.0

package/dist/chunk-TRYHX5S4.mjs

@@ -0,0 +1,360 @@
+import {
+  COMMAND_FILE_PATTERN,
+  MIGRATION_NAME_PATTERN,
+  isRecord,
+  makeProjectRelativePath,
+  pathExists,
+  readTextFile,
+  toPosixPath
+} from "./chunk-YACY2572.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-XBOVM6LO.mjs

@@ -0,0 +1,41 @@
+// src/database-drivers.ts
+import { createRequire } from "module";
+import { join } from "path";
+import { pathToFileURL } from "url";
+import { registerDatabaseDriverFactory } from "@holo-js/db";
+async function loadProjectDatabaseDrivers(projectRoot, config) {
+  const packageByDriver = {
+    sqlite: { packageName: "@holo-js/db-sqlite", factoryExport: "sqliteDatabaseDriverFactory" },
+    postgres: { packageName: "@holo-js/db-postgres", factoryExport: "postgresDatabaseDriverFactory" },
+    mysql: { packageName: "@holo-js/db-mysql", factoryExport: "mysqlDatabaseDriverFactory" }
+  };
+  const connections = Object.values(config?.connections ?? { default: "./data/database.sqlite" });
+  const drivers = /* @__PURE__ */ new Set();
+  for (const connection of connections) {
+    const driver = (() => {
+      if (typeof connection === "string") {
+        if (connection.startsWith("postgres://") || connection.startsWith("postgresql://")) return "postgres";
+        if (connection.startsWith("mysql://") || connection.startsWith("mysql2://")) return "mysql";
+        return "sqlite";
+      }
+      return connection.driver ?? "sqlite";
+    })();
+    if (!(driver in packageByDriver)) throw new Error(`Unsupported Holo database driver "${driver}".`);
+    drivers.add(driver);
+  }
+  const require2 = createRequire(join(projectRoot, "package.json"));
+  const factories = [];
+  for (const driver of drivers) {
+    const { packageName, factoryExport } = packageByDriver[driver];
+    const module = await import(pathToFileURL(require2.resolve(packageName)).href);
+    const factory = module[factoryExport];
+    if (!factory) throw new Error(`Database driver package ${packageName} does not export ${factoryExport}.`);
+    registerDatabaseDriverFactory(factory);
+    factories.push(factory);
+  }
+  return factories;
+}
+
+export {
+  loadProjectDatabaseDrivers
+};