hanzio 1.2.0 → 2.0.0

package/dist/src/secrets/vite.js

@@ -1,41 +1,8 @@
-// src/secrets/errors.ts
-class SecretLoadError extends Error {
-  code;
-  operation;
-  status;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "SecretLoadError";
-    this.code = code;
-    this.operation = details.operation;
-    this.status = details.status;
-  }
-}
-
-// src/secrets/vite.ts
-function getViteDefine(secretSet, options = {}) {
-  const values = secretSet.secrets();
-  const keys = options.publicKeys ?? Object.keys(values);
-  if (!options.publicKeys && keys.some((key) => !key.startsWith("VITE_"))) {
-    throw new SecretLoadError("CONFIGURATION", "Vite secret sets must contain only VITE_ keys, or provide an explicit publicKeys list.");
-  }
-  for (const key of keys) {
-    if (!Object.hasOwn(values, key) || !/^[A-Za-z_$][\w$]*$/.test(key)) {
-      throw new SecretLoadError("CONFIGURATION", "Vite publicKeys must reference configured keys with valid JavaScript identifiers.");
-    }
-    if (["MODE", "BASE_URL", "PROD", "DEV", "SSR"].includes(key)) {
-      throw new SecretLoadError("CONFIGURATION", "Vite built-in environment constants cannot be overridden by secrets.");
-    }
-  }
-  return Object.fromEntries(keys.map((key) => [`import.meta.env.${key}`, JSON.stringify(values[key])]));
-}
-function viteSecretSetPlugin(secretSet, options = {}) {
-  return {
-    name: "hanzio-secret-set",
-    config: () => ({ define: getViteDefine(secretSet, options) })
-  };
-}
+import {
+  getViteDefine2,
+  viteSecretSetPlugin2
+} from "../../index-181e6vfw.js";
 export {
-  getViteDefine,
-  viteSecretSetPlugin
+  getViteDefine2 as getViteDefine,
+  viteSecretSetPlugin2 as viteSecretSetPlugin
 };

package/dist/src/secrets/worker.js

@@ -1,275 +1,12 @@
-// src/secrets/errors.ts
-class SecretLoadError extends Error {
-  code;
-  operation;
-  status;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "SecretLoadError";
-    this.code = code;
-    this.operation = details.operation;
-    this.status = details.status;
-  }
-}
-
-// src/secrets/deadline.ts
-async function withSecretDeadline(options, operation) {
-  const timeoutMs = options.timeoutMs ?? 30000;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
-    throw new SecretLoadError("CONFIGURATION", "Secret timeoutMs must be a positive finite timer duration.");
-  }
-  const controller = new AbortController;
-  const cancel = () => controller.abort(new SecretLoadError("ABORTED", "Secret loading was cancelled."));
-  if (options.signal?.aborted) {
-    cancel();
-  } else {
-    options.signal?.addEventListener("abort", cancel, { once: true });
-  }
-  const timer = setTimeout(() => controller.abort(new SecretLoadError("TIMEOUT", `Secret loading timed out after ${timeoutMs}ms.`)), timeoutMs);
-  let rejectOnAbort = () => {};
-  try {
-    const aborted = new Promise((_, reject) => {
-      rejectOnAbort = () => reject(controller.signal.reason);
-      controller.signal.addEventListener("abort", rejectOnAbort, { once: true });
-    });
-    if (controller.signal.aborted) {
-      throw controller.signal.reason;
-    }
-    return await Promise.race([operation(controller.signal), aborted]);
-  } finally {
-    clearTimeout(timer);
-    options.signal?.removeEventListener("abort", cancel);
-    controller.signal.removeEventListener("abort", rejectOnAbort);
-  }
-}
-
-// src/secrets/environment.ts
-function getProcessEnvironment() {
-  return typeof process === "undefined" ? undefined : process.env;
-}
-function resolveSecretEnvironment(option, env) {
-  const explicit = typeof option === "function" ? option() : option;
-  if (typeof explicit === "object" && explicit !== null) {
-    if (typeof explicit.slug !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(explicit.slug)) {
-      throw new SecretLoadError("CONFIGURATION", "Custom secret environment requires a valid slug.");
-    }
-    return explicit.slug;
-  }
-  const selected = explicit ?? env?.SECRETS_ENV;
-  if (selected !== undefined) {
-    if (selected === "production" || selected === "prod") {
-      return "prod";
-    }
-    if (selected === "development" || selected === "dev") {
-      return "dev";
-    }
-    if (selected === "staging") {
-      return "staging";
-    }
-    throw new SecretLoadError("CONFIGURATION", "Invalid secret environment. Use dev, staging, prod, or an explicit { slug } option.");
-  }
-  if (env?.NODE_ENV === "production" || env?.NODE_ENV === "prod") {
-    return "prod";
-  }
-  if (env?.NODE_ENV === "staging") {
-    return "staging";
-  }
-  return "dev";
-}
-
-// src/secrets/core.ts
-var registryKey = Symbol.for("hanzio.secrets.environmentWrites.v1");
-var shared = globalThis;
-var environmentWrites = shared[registryKey] ?? new WeakMap;
-shared[registryKey] = environmentWrites;
-var defaultLogger = {
-  info: (message, attrs) => console.log(`${message} environment=${attrs.environment} count=${attrs.count} source=${attrs.source} durationMs=${attrs.durationMs}`, { sources: attrs.sources }),
-  error: (message, attrs) => console.error(message, attrs)
-};
-function readOverrides(keys, env) {
-  if (!env) {
-    return {};
-  }
-  const writes = environmentWrites.get(env);
-  return Object.fromEntries(keys.flatMap((key) => {
-    const value = Object.hasOwn(env, key) ? env[key] : undefined;
-    if (writes?.has(key)) {
-      if (writes.get(key) === value) {
-        return [];
-      }
-      writes.delete(key);
-    }
-    return value ? [[key, value]] : [];
-  }));
-}
-async function defineSecretSet(keys, options, environmentVariables) {
-  const keySet = [...new Set(keys)];
-  const environment = resolveSecretEnvironment(options.environment, environmentVariables);
-  const logger = options.logger === false ? undefined : options.logger ?? defaultLogger;
-  let cached;
-  let parsed;
-  let sources;
-  let inFlight;
-  const log = (level, message, attributes) => {
-    try {
-      logger?.[level](message, attributes);
-    } catch {}
-  };
-  const loadSnapshot = async (request, signal) => {
-    const local = readOverrides(keySet, environmentVariables);
-    const missing = keySet.filter((key) => !Object.hasOwn(local, key));
-    let loaderSource = options.loader.source ?? "custom loader";
-    let loaded = {};
-    if (missing.length) {
-      try {
-        loaded = await options.loader({
-          keys: missing,
-          environment,
-          signal,
-          timeoutMs: request.timeoutMs ?? options.timeoutMs ?? 30000,
-          reportSource: (source) => {
-            loaderSource = source;
-          }
-        });
-      } catch (error) {
-        if (error instanceof SecretLoadError) {
-          throw error;
-        }
-        throw new SecretLoadError("LOADER", "Secret loader failed.");
-      }
-    }
-    const overrides = readOverrides(keySet, environmentVariables);
-    const next = Object.fromEntries(keySet.map((key) => {
-      if (Object.hasOwn(overrides, key)) {
-        return [key, overrides[key]];
-      }
-      if (Object.hasOwn(loaded, key)) {
-        return [key, loaded[key]];
-      }
-      return [key, undefined];
-    }));
-    const missingKeys = keySet.filter((key) => typeof next[key] !== "string" || !next[key]);
-    if (missingKeys.length) {
-      throw new SecretLoadError("MISSING_SECRETS", `Missing secrets: ${missingKeys.join(", ")}`);
-    }
-    let nextParsed;
-    try {
-      nextParsed = options.schema ? await options.schema.parseAsync({ ...next }) : { ...next };
-      nextParsed = structuredClone(nextParsed);
-    } catch {
-      throw new SecretLoadError("VALIDATION", "Secret schema validation failed. Check the configured schema; values are omitted.");
-    }
-    signal.throwIfAborted();
-    const nextSources = Object.fromEntries(keySet.map((key) => [
-      key,
-      Object.hasOwn(overrides, key) ? "process.env" : loaderSource
-    ]));
-    if (options.writeToProcessEnv !== false && environmentVariables) {
-      let writes = environmentWrites.get(environmentVariables);
-      if (!writes) {
-        writes = new Map;
-        environmentWrites.set(environmentVariables, writes);
-      }
-      for (const key of keySet) {
-        if (Object.hasOwn(overrides, key)) {
-          continue;
-        }
-        environmentVariables[key] = next[key];
-        writes.set(key, next[key]);
-      }
-    }
-    cached = next;
-    parsed = nextParsed;
-    sources = nextSources;
-  };
-  const load = (request = {}) => {
-    if (inFlight) {
-      return inFlight;
-    }
-    inFlight = (async () => {
-      const start = Date.now();
-      try {
-        await withSecretDeadline({
-          timeoutMs: request.timeoutMs ?? options.timeoutMs,
-          signal: request.signal ?? options.signal
-        }, (signal) => loadSnapshot(request, signal));
-        const sourceCounts = new Map;
-        for (const key of keySet) {
-          const source = sources[key];
-          sourceCounts.set(source, (sourceCounts.get(source) ?? 0) + 1);
-        }
-        const counts = Object.fromEntries(sourceCounts);
-        log("info", "Loaded secrets", {
-          environment,
-          count: keySet.length,
-          durationMs: Date.now() - start,
-          source: Object.keys(counts).join(" + ") || "none",
-          sources: counts
-        });
-      } catch (error) {
-        const safe = error instanceof SecretLoadError ? error : new SecretLoadError("LOADER", "Secret loading failed.");
-        log("error", "Secret loading failed", {
-          environment,
-          count: keySet.length,
-          durationMs: Date.now() - start,
-          code: safe.code
-        });
-        throw safe;
-      }
-    })().finally(() => {
-      inFlight = undefined;
-    });
-    return inFlight;
-  };
-  const secretSet = {
-    secret(key) {
-      if (!Object.hasOwn(cached, key)) {
-        throw new SecretLoadError("MISSING_SECRETS", `Secret ${key} not found`);
-      }
-      return cached[key];
-    },
-    secrets: () => ({ ...cached }),
-    parsed: () => structuredClone(parsed),
-    sources: () => ({ ...sources }),
-    async reload(request) {
-      await load(request);
-      return secretSet;
-    }
-  };
-  await load();
-  return secretSet;
-}
-// src/secrets/worker-loader.ts
-function cloudflareWorkerEnvLoader(workerEnv) {
-  const loader = async (ctx) => {
-    const out = Object.create(null);
-    for (const key of ctx.keys) {
-      const str = workerBindingToString(Object.hasOwn(workerEnv, key) ? workerEnv[key] : undefined);
-      if (str !== undefined) {
-        out[key] = str;
-      }
-    }
-    return out;
-  };
-  return Object.assign(loader, { source: "Cloudflare Worker bindings" });
-}
-function workerBindingToString(value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value === "string") {
-    return value === "" ? undefined : value;
-  }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (typeof value === "object") {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
+import {
+  defineSecretSet2,
+  cloudflareWorkerEnvLoader2
+} from "../../index-wjyb9bsd.js";
+import {
+  SecretLoadError2
+} from "../../index-srt06xd2.js";
 export {
-  SecretLoadError,
-  cloudflareWorkerEnvLoader,
-  defineSecretSet
+  SecretLoadError2 as SecretLoadError,
+  cloudflareWorkerEnvLoader2 as cloudflareWorkerEnvLoader,
+  defineSecretSet2 as defineSecretSet
 };