@holo-js/config 0.1.9 → 0.2.1

package/dist/index.mjs

@@ -347,19 +347,44 @@ var DEFAULT_QUEUE_CONFIG = Object.freeze({
     })
   })
 });
-function parseInteger(value, fallback, label, options = {}) {
-  if (typeof value === "undefined") {
-    return fallback;
+function parseIntegerCandidate(value, parser) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return Number.NaN;
   }
-  const normalized = typeof value === "number" ? value : Number.parseInt(value, 10);
-  if (!Number.isInteger(normalized)) {
-    throw new Error(`[Holo Queue] ${label} must be an integer.`);
+  if (parser === "parse-int") {
+    return Number.parseInt(value, 10);
+  }
+  if (parser === "digits") {
+    return /^\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) : Number.NaN;
+  }
+  return Number(trimmed);
+}
+function parseScopedInteger(value, fallback, namespace, label, options = {}) {
+  const normalized = typeof value === "undefined" ? fallback : parseIntegerCandidate(value, options.parser ?? "number");
+  if (!Number.isFinite(normalized) || !Number.isInteger(normalized)) {
+    throw new Error(`[${namespace}] ${label} must be an integer.`);
   }
   if (typeof options.minimum === "number" && normalized < options.minimum) {
-    throw new Error(`[Holo Queue] ${label} must be greater than or equal to ${options.minimum}.`);
+    throw new Error(`[${namespace}] ${label} must be greater than or equal to ${options.minimum}.`);
   }
   return normalized;
 }
+function parseScopedOptionalInteger(value, namespace, label, options = {}) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  return parseScopedInteger(value, Number.NaN, namespace, label, options);
+}
+function parseInteger(value, fallback, namespace, label, options = {}) {
+  return parseScopedInteger(value, fallback, namespace, label, {
+    ...options,
+    parser: "parse-int"
+  });
+}
 function normalizeNonEmptyString(value, label) {
   const normalized = value?.trim();
   if (!normalized) {
@@ -367,42 +392,25 @@ function normalizeNonEmptyString(value, label) {
   }
   return normalized;
 }
-function normalizeConnectionName(value, label) {
+function normalizeScopedName(value, namespace, label) {
   const normalized = value?.trim();
   if (!normalized) {
-    throw new Error(`[Holo Queue] ${label} must be a non-empty string.`);
+    throw new Error(`[${namespace}] ${label} must be a non-empty string.`);
   }
   return normalized;
 }
+function normalizeConnectionName(value, namespace, label) {
+  return normalizeScopedName(value, namespace, label);
+}
 function normalizeCacheName(value, label) {
-  const normalized = value?.trim();
-  if (!normalized) {
-    throw new Error(`[Holo Cache] ${label} must be a non-empty string.`);
-  }
-  return normalized;
+  return normalizeScopedName(value, "Holo Cache", label);
 }
 function normalizeCacheOptionalString(value) {
   const normalized = value?.trim();
   return normalized || void 0;
 }
 function parseCacheInteger(value, label, options = {}) {
-  if (typeof value === "undefined") {
-    return void 0;
-  }
-  const normalized = typeof value === "number" ? value : (() => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return Number.NaN;
-    }
-    return Number(trimmed);
-  })();
-  if (!Number.isFinite(normalized) || !Number.isInteger(normalized)) {
-    throw new Error(`[Holo Cache] ${label} must be an integer.`);
-  }
-  if (typeof options.minimum === "number" && normalized < options.minimum) {
-    throw new Error(`[Holo Cache] ${label} must be greater than or equal to ${options.minimum}.`);
-  }
-  return normalized;
+  return parseScopedOptionalInteger(value, "Holo Cache", label, options);
 }
 function resolveCachePrefix(globalPrefix, localPrefix) {
   return normalizeCacheOptionalString(localPrefix) ?? globalPrefix;
@@ -495,30 +503,13 @@ function normalizeQueueName(value) {
   return value?.trim() || DEFAULT_QUEUE_NAME;
 }
 function parseRedisInteger(value, fallback, label, options = {}) {
-  if (typeof value === "undefined") {
-    return fallback;
-  }
-  const normalized = typeof value === "number" ? value : (() => {
-    const trimmed = value.trim();
-    if (!trimmed || !/^\d+$/.test(trimmed)) {
-      return Number.NaN;
-    }
-    return Number.parseInt(trimmed, 10);
-  })();
-  if (!Number.isInteger(normalized)) {
-    throw new Error(`[Holo Redis] ${label} must be an integer.`);
-  }
-  if (typeof options.minimum === "number" && normalized < options.minimum) {
-    throw new Error(`[Holo Redis] ${label} must be greater than or equal to ${options.minimum}.`);
-  }
-  return normalized;
+  return parseScopedInteger(value, fallback, "Holo Redis", label, {
+    ...options,
+    parser: "digits"
+  });
 }
 function normalizeRedisConnectionName(value, label) {
-  const normalized = value?.trim();
-  if (!normalized) {
-    throw new Error(`[Holo Redis] ${label} must be a non-empty string.`);
-  }
-  return normalized;
+  return normalizeScopedName(value, "Holo Redis", label);
 }
 function normalizeOptionalRedisString(value, label) {
   if (typeof value === "undefined") {
@@ -659,27 +650,10 @@ function resolveNormalizedRedisConnection(redisConfig, connectionName, label) {
   return resolved;
 }
 function parseSecurityInteger(value, fallback, label, options = {}) {
-  const normalized = typeof value === "undefined" ? fallback : typeof value === "number" ? value : (() => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-      return Number.NaN;
-    }
-    return Number(trimmed);
-  })();
-  if (!Number.isFinite(normalized) || !Number.isInteger(normalized)) {
-    throw new Error(`[Holo Security] ${label} must be an integer.`);
-  }
-  if (typeof options.minimum === "number" && normalized < options.minimum) {
-    throw new Error(`[Holo Security] ${label} must be greater than or equal to ${options.minimum}.`);
-  }
-  return normalized;
+  return parseScopedInteger(value, fallback, "Holo Security", label, options);
 }
 function normalizeSecurityName(value, label) {
-  const normalized = value?.trim();
-  if (!normalized) {
-    throw new Error(`[Holo Security] ${label} must be a non-empty string.`);
-  }
-  return normalized;
+  return normalizeScopedName(value, "Holo Security", label);
 }
 function normalizeSecurityOptionalString(value) {
   const normalized = value?.trim();
@@ -746,10 +720,10 @@ function normalizeRedisConnection(name, config2, redisConfig) {
     driver: "redis",
     connection: resolvedRedisConnection.name,
     queue: normalizeQueueName(config2.queue),
-    retryAfter: parseInteger(config2.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
+    retryAfter: parseInteger(config2.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, "Holo Queue", `queue connection "${name}" retryAfter`, {
       minimum: 0
     }),
-    blockFor: parseInteger(config2.blockFor, DEFAULT_QUEUE_BLOCK_FOR, `queue connection "${name}" blockFor`, {
+    blockFor: parseInteger(config2.blockFor, DEFAULT_QUEUE_BLOCK_FOR, "Holo Queue", `queue connection "${name}" blockFor`, {
       minimum: 0
     }),
     redis: Object.freeze({
@@ -768,10 +742,10 @@ function normalizeDatabaseConnection(name, config2) {
     name,
     driver: "database",
     queue: normalizeQueueName(config2.queue),
-    retryAfter: parseInteger(config2.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
+    retryAfter: parseInteger(config2.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, "Holo Queue", `queue connection "${name}" retryAfter`, {
       minimum: 0
     }),
-    sleep: parseInteger(config2.sleep, DEFAULT_QUEUE_SLEEP, `queue connection "${name}" sleep`, {
+    sleep: parseInteger(config2.sleep, DEFAULT_QUEUE_SLEEP, "Holo Queue", `queue connection "${name}" sleep`, {
       minimum: 0
     }),
     connection: config2.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
@@ -795,7 +769,7 @@ function normalizeConnections(connections, redisConfig) {
     return DEFAULT_QUEUE_CONFIG.connections;
   }
   const normalizedEntries = Object.entries(connections).map(([name, config2]) => {
-    const normalizedName = normalizeConnectionName(name, "Queue connection name");
+    const normalizedName = normalizeConnectionName(name, "Holo Queue", "Queue connection name");
     return [normalizedName, normalizeConnectionConfig(normalizedName, config2, redisConfig)];
   });
   return Object.freeze(Object.fromEntries(normalizedEntries));
@@ -898,7 +872,7 @@ function normalizeSessionStoreConfig(name, config2, redisConfig) {
 }
 function normalizeSessionConfig(config2 = {}, redisConfig) {
   const stores = !config2.stores || Object.keys(config2.stores).length === 0 ? holoSessionDefaults.stores : Object.freeze(Object.fromEntries(Object.entries(config2.stores).map(([name, store]) => {
-    const normalizedName = normalizeConnectionName(name, "Session store name");
+    const normalizedName = normalizeConnectionName(name, "Holo Session", "Session store name");
     return [normalizedName, normalizeSessionStoreConfig(normalizedName, store, redisConfig)];
   })));
   const configuredDriver = config2.driver?.trim();
@@ -911,12 +885,13 @@ function normalizeSessionConfig(config2 = {}, redisConfig) {
   if (sameSite !== "lax" && sameSite !== "strict" && sameSite !== "none") {
     throw new Error(`[Holo Session] cookie sameSite must be "lax", "strict", or "none".`);
   }
-  const idleTimeout = parseInteger(config2.idleTimeout, DEFAULT_SESSION_IDLE_TIMEOUT, "session idleTimeout", {
+  const idleTimeout = parseInteger(config2.idleTimeout, DEFAULT_SESSION_IDLE_TIMEOUT, "Holo Session", "session idleTimeout", {
     minimum: 0
   });
   const absoluteLifetime = parseInteger(
     config2.absoluteLifetime,
     DEFAULT_SESSION_ABSOLUTE_LIFETIME,
+    "Holo Session",
     "session absoluteLifetime",
     {
       minimum: 0
@@ -925,6 +900,7 @@ function normalizeSessionConfig(config2 = {}, redisConfig) {
   const rememberMeLifetime = parseInteger(
     config2.rememberMeLifetime,
     DEFAULT_SESSION_REMEMBER_ME_LIFETIME,
+    "Holo Session",
     "session rememberMeLifetime",
     {
       minimum: 0
@@ -941,7 +917,7 @@ function normalizeSessionConfig(config2 = {}, redisConfig) {
       httpOnly: cookie.httpOnly ?? true,
       sameSite,
       partitioned: cookie.partitioned ?? false,
-      maxAge: parseInteger(cookie.maxAge, absoluteLifetime, "session cookie maxAge", {
+      maxAge: parseInteger(cookie.maxAge, absoluteLifetime, "Holo Session", "session cookie maxAge", {
         minimum: 0
       })
     }),
@@ -1074,10 +1050,10 @@ function normalizePasswordBroker(name, config2, providers) {
     name,
     provider,
     table: config2.table?.trim() || DEFAULT_AUTH_PASSWORD_RESET_TABLE,
-    expire: parseInteger(config2.expire, DEFAULT_AUTH_PASSWORD_EXPIRE, `auth password broker "${name}" expire`, {
+    expire: parseInteger(config2.expire, DEFAULT_AUTH_PASSWORD_EXPIRE, "Holo Auth", `auth password broker "${name}" expire`, {
       minimum: 0
     }),
-    throttle: parseInteger(config2.throttle, DEFAULT_AUTH_PASSWORD_THROTTLE, `auth password broker "${name}" throttle`, {
+    throttle: parseInteger(config2.throttle, DEFAULT_AUTH_PASSWORD_THROTTLE, "Holo Auth", `auth password broker "${name}" throttle`, {
       minimum: 0
     }),
     route: config2.route?.trim() || DEFAULT_AUTH_PASSWORD_RESET_ROUTE
@@ -1169,7 +1145,7 @@ function normalizeWorkosConfig(config2, guards, providers) {
     return holoAuthDefaults.workos;
   }
   const normalizedEntries = providerEntries.map(([name, providerConfig]) => {
-    const normalizedName = normalizeConnectionName(name, "Auth WorkOS provider name");
+    const normalizedName = normalizeConnectionName(name, "Holo Auth", "Auth WorkOS provider name");
     return [normalizedName, providerConfig];
   });
   if (provider && !normalizedEntries.some(([name]) => name === provider)) {
@@ -1267,7 +1243,7 @@ function normalizeClerkConfig(config2, guards, providers) {
     return holoAuthDefaults.clerk;
   }
   const normalizedEntries = providerEntries.map(([name, providerConfig]) => {
-    const normalizedName = normalizeConnectionName(name, "Auth Clerk provider name");
+    const normalizedName = normalizeConnectionName(name, "Holo Auth", "Auth Clerk provider name");
     return [normalizedName, providerConfig];
   });
   if (provider && !normalizedEntries.some(([name]) => name === provider)) {
@@ -1284,7 +1260,7 @@ function normalizeClerkConfig(config2, guards, providers) {
 }
 function normalizeAuthConfig(config2 = {}, _options = {}) {
   const providers = !config2.providers || Object.keys(config2.providers).length === 0 ? holoAuthDefaults.providers : Object.freeze(Object.fromEntries(Object.entries(config2.providers).map(([name, provider]) => {
-    const normalizedName = normalizeConnectionName(name, "Auth provider name");
+    const normalizedName = normalizeConnectionName(name, "Holo Auth", "Auth provider name");
     return [normalizedName, normalizeAuthProvider(normalizedName, provider)];
   })));
   const guards = !config2.guards || Object.keys(config2.guards).length === 0 ? Object.freeze({
@@ -1294,7 +1270,7 @@ function normalizeAuthConfig(config2 = {}, _options = {}) {
       providers
     )
   }) : Object.freeze(Object.fromEntries(Object.entries(config2.guards).map(([name, guard]) => {
-    const normalizedName = normalizeConnectionName(name, "Auth guard name");
+    const normalizedName = normalizeConnectionName(name, "Holo Auth", "Auth guard name");
     return [normalizedName, normalizeAuthGuard(normalizedName, guard, providers)];
   })));
   const passwords = !config2.passwords || Object.keys(config2.passwords).length === 0 ? Object.freeze({
@@ -1304,7 +1280,7 @@ function normalizeAuthConfig(config2 = {}, _options = {}) {
       providers
     )
   }) : Object.freeze(Object.fromEntries(Object.entries(config2.passwords).map(([name, broker]) => {
-    const normalizedName = normalizeConnectionName(name, "Auth password broker name");
+    const normalizedName = normalizeConnectionName(name, "Holo Auth", "Auth password broker name");
     return [normalizedName, normalizePasswordBroker(normalizedName, broker, providers)];
   })));
   const defaultGuard = config2.defaults?.guard?.trim() || DEFAULT_AUTH_GUARD;
@@ -1316,7 +1292,7 @@ function normalizeAuthConfig(config2 = {}, _options = {}) {
     throw new Error(`[Holo Auth] default password broker "${defaultPasswords}" is not configured.`);
   }
   const social = !config2.social || Object.keys(config2.social).length === 0 ? holoAuthDefaults.social : Object.freeze(Object.fromEntries(Object.entries(config2.social).map(([name, provider]) => {
-    const normalizedName = normalizeConnectionName(name, "Auth social provider name");
+    const normalizedName = normalizeConnectionName(name, "Holo Auth", "Auth social provider name");
     return [normalizedName, normalizeSocialProvider(normalizedName, provider, guards, providers)];
   })));
   const workos = normalizeWorkosConfig(config2.workos, guards, providers);
@@ -1404,15 +1380,16 @@ function normalizeBroadcastConnectionOptions(options, fallbackHost, label) {
     cluster: normalizeOptionalBroadcastString(options?.cluster, `${label} cluster`) ?? void 0
   });
 }
-function normalizeBroadcastWorkerConfig(worker) {
+function normalizeBroadcastWorkerConfig(worker, connectionOptions, configuredConnectionPort) {
   const scaling = worker?.scaling;
-  const publicScheme = normalizeBroadcastScheme(worker?.publicScheme, "https", "Broadcast worker public scheme");
+  const publicScheme = normalizeBroadcastScheme(worker?.publicScheme, connectionOptions?.scheme ?? "https", "Broadcast worker public scheme");
+  const fallbackPort = typeof configuredConnectionPort === "undefined" ? DEFAULT_BROADCAST_WORKER_PORT : normalizeBroadcastPort(configuredConnectionPort, DEFAULT_BROADCAST_WORKER_PORT, "Broadcast worker port");
   if (scaling && scaling.driver !== "redis") {
     throw new Error('[Holo Broadcast] Broadcast worker scaling driver must be "redis".');
   }
   return Object.freeze({
     host: normalizeOptionalBroadcastString(worker?.host, "Broadcast worker host") ?? DEFAULT_BROADCAST_WORKER_HOST,
-    port: normalizeBroadcastPort(worker?.port, DEFAULT_BROADCAST_WORKER_PORT, "Broadcast worker port"),
+    port: normalizeBroadcastPort(worker?.port, fallbackPort, "Broadcast worker port"),
     path: normalizeOptionalBroadcastString(worker?.path, "Broadcast worker path") ?? DEFAULT_BROADCAST_WORKER_PATH,
     publicHost: normalizeOptionalBroadcastString(worker?.publicHost, "Broadcast worker public host") ?? void 0,
     publicPort: typeof worker?.publicPort === "undefined" ? publicScheme === "http" ? DEFAULT_BROADCAST_HTTP_PORT : void 0 : normalizeBroadcastPort(
@@ -1520,10 +1497,14 @@ function normalizeBroadcastConfig(config2 = {}) {
       `[Holo Broadcast] default broadcast connection "${defaultConnection}" is not configured. Available connections: ${Object.keys(normalizedConnections).join(", ")}`
     );
   }
+  const defaultBroadcastConnection = normalizedConnections[defaultConnection];
+  const defaultHoloConnectionOptions = defaultBroadcastConnection && defaultBroadcastConnection.driver === "holo" && "options" in defaultBroadcastConnection ? defaultBroadcastConnection.options : void 0;
+  const configuredDefaultConnection = config2.connections?.[defaultConnection];
+  const configuredDefaultHoloConnectionPort = configuredDefaultConnection?.driver === "holo" ? configuredDefaultConnection.options?.port : void 0;
   return Object.freeze({
     default: defaultConnection,
     connections: Object.freeze(normalizedConnections),
-    worker: normalizeBroadcastWorkerConfig(config2.worker)
+    worker: normalizeBroadcastWorkerConfig(config2.worker, defaultHoloConnectionOptions, configuredDefaultHoloConnectionPort)
   });
 }
 function normalizeOptionalMailString(value, label) {
@@ -1730,15 +1711,12 @@ function getValueAtPath(source, path) {
   return current;
 }
 function createConfigAccessors(configMap) {
-  const useConfig2 = ((path) => {
-    return getValueAtPath(configMap, path);
-  });
-  const config2 = ((path) => {
+  const accessor = ((path) => {
     return getValueAtPath(configMap, path);
   });
   return {
-    useConfig: useConfig2,
-    config: config2
+    useConfig: accessor,
+    config: accessor
   };
 }
 function getRuntimeConfigState() {
@@ -1759,11 +1737,14 @@ function requireConfigRuntime() {
   }
   return runtimeConfigMap;
 }
-function useConfig(path) {
+function getRuntimeConfigValue(path) {
   return getValueAtPath(requireConfigRuntime(), path);
 }
+function useConfig(path) {
+  return getRuntimeConfigValue(path);
+}
 function config(path) {
-  return getValueAtPath(requireConfigRuntime(), path);
+  return getRuntimeConfigValue(path);
 }
 
 // src/env.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/config",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Holo-JS Framework - typed config loading, env layering, and runtime access",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/db": "^0.1.9"
+    "@holo-js/db": "^0.2.1"
   },
   "devDependencies": {
     "tsup": "^8.3.5",