@jondotsoy/configs 0.1.0

package/dist/configs.js

@@ -0,0 +1,847 @@
+// src/utils/store.ts
+class Store {
+  value;
+  subscribers = new Set;
+  cleanups = new Map;
+  mountListeners = new Set;
+  unmountListeners = new Set;
+  constructor(initial) {
+    this.value = initial;
+  }
+  get() {
+    return this.value;
+  }
+  set(next) {
+    this.value = next;
+    for (const subscriber of this.subscribers) {
+      this.runSubscriber(subscriber, this.value);
+    }
+  }
+  subscribe(subscriber) {
+    this.addSubscriber(subscriber);
+    this.runSubscriber(subscriber, this.value);
+    return () => this.removeSubscriber(subscriber);
+  }
+  listen(subscriber) {
+    this.addSubscriber(subscriber);
+    return () => this.removeSubscriber(subscriber);
+  }
+  runSubscriber(subscriber, value) {
+    const cleanup = subscriber(value);
+    if (typeof cleanup === "function")
+      this.cleanups.set(subscriber, cleanup);
+  }
+  onMount(listener) {
+    this.mountListeners.add(listener);
+    return () => {
+      this.mountListeners.delete(listener);
+    };
+  }
+  onUnmount(listener) {
+    this.unmountListeners.add(listener);
+    return () => {
+      this.unmountListeners.delete(listener);
+    };
+  }
+  addSubscriber(subscriber) {
+    const wasEmpty = this.subscribers.size === 0;
+    if (wasEmpty) {
+      for (const listener of this.mountListeners)
+        listener();
+    }
+    this.subscribers.add(subscriber);
+  }
+  removeSubscriber(subscriber) {
+    if (!this.subscribers.delete(subscriber))
+      return;
+    const cleanup = this.cleanups.get(subscriber);
+    this.cleanups.delete(subscriber);
+    cleanup?.();
+    if (this.subscribers.size === 0) {
+      for (const listener of this.unmountListeners)
+        listener();
+    }
+  }
+  static onMount(store, callback) {
+    let cleanup;
+    const unsubMount = store.onMount(() => {
+      cleanup = callback();
+    });
+    const unsubUnmount = store.onUnmount(() => {
+      cleanup?.();
+      cleanup = undefined;
+    });
+    return () => {
+      cleanup?.();
+      cleanup = undefined;
+      unsubMount();
+      unsubUnmount();
+    };
+  }
+}
+function create(initial) {
+  return new Store(initial);
+}
+function computed(source, selector) {
+  const result = new Store(selector(source.get()));
+  Store.onMount(result, () => {
+    return source.subscribe((value) => {
+      result.set(selector(value));
+    });
+  });
+  return result;
+}
+var store = { create, computed, onMount: Store.onMount };
+
+// src/sources/source.ts
+class Source {
+  underlying;
+  store = new Store(null);
+  closed = false;
+  closePromise;
+  startPromise;
+  constructor(underlying) {
+    this.underlying = underlying;
+    const control = {
+      set: (value) => {
+        if (this.closed)
+          return;
+        const next = this.underlying.reduce ? this.underlying.reduce(value, this.store.get()) : value;
+        this.store.set(next);
+      },
+      close: () => {
+        this.close();
+      }
+    };
+    this.startPromise = Promise.resolve().then(() => underlying.start(control)).then(() => {
+      return;
+    });
+    this.startPromise.catch(() => {});
+  }
+  async open() {
+    await this.startPromise;
+    return this.store;
+  }
+  close() {
+    if (!this.closePromise) {
+      this.closed = true;
+      this.closePromise = Promise.resolve(this.underlying.close?.()).then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    }
+    return this.closePromise;
+  }
+}
+
+// src/sources/env.ts
+var mapKey = {
+  snakeCase(options = {}) {
+    const separator = options.separator ?? "_";
+    return (key) => key.toLowerCase().split(separator);
+  },
+  identity() {
+    return (key) => [key];
+  },
+  camelCase() {
+    return (key) => [key.toLowerCase().replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase())];
+  },
+  lookup(table, fallback = (key) => [key]) {
+    return (key) => table[key] ?? fallback(key);
+  }
+};
+function setPath(target, path, value) {
+  let node = target;
+  for (const segment of path.slice(0, -1)) {
+    const next = node[segment];
+    if (typeof next !== "object" || next === null) {
+      node[segment] = {};
+    }
+    node = node[segment];
+  }
+  node[path[path.length - 1]] = value;
+}
+function envSource(options = {}) {
+  const env = options.env ?? process.env;
+  const { prefix, suffix } = options;
+  const mapKey2 = options.mapKey ?? ((key) => [key]);
+  return new Source({
+    start(control) {
+      const tree = {};
+      for (const [key, value] of Object.entries(env)) {
+        if (value === undefined)
+          continue;
+        if (prefix !== undefined && !key.startsWith(prefix))
+          continue;
+        if (suffix !== undefined && !key.endsWith(suffix))
+          continue;
+        const trimmedKey = key.slice(prefix !== undefined ? prefix.length : 0, suffix !== undefined ? key.length - suffix.length : key.length);
+        setPath(tree, mapKey2(trimmedKey), value);
+      }
+      control.set(tree);
+      control.close();
+    }
+  });
+}
+
+// src/sources/fetch.ts
+async function download(url, init) {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    throw new Error(`fetchSource: received ${response.status} ${response.statusText} from "${url}"`);
+  }
+  return response;
+}
+function fetchSource(options) {
+  const { url, method = "GET", headers, attempts = 1 } = options;
+  return new Source({
+    async start(control) {
+      let response;
+      let lastError;
+      for (let attempt = 0;attempt < Math.max(1, attempts); attempt++) {
+        try {
+          response = await download(url, { method, headers });
+          break;
+        } catch (error) {
+          lastError = error;
+        }
+      }
+      if (!response) {
+        console.error(`fetchSource: failed to fetch "${url}" after ${attempts} attempt(s)`, lastError);
+        control.close();
+        return;
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const text = await response.text();
+      let data;
+      try {
+        data = JSON.parse(text);
+      } catch (error) {
+        console.error(`fetchSource: response body from "${url}" is not valid JSON (content-type: "${contentType}")`, error);
+        control.close();
+        return;
+      }
+      control.set(data);
+      control.close();
+    }
+  });
+}
+
+// src/sources/sse.ts
+function isPatch(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractData(rawEvent) {
+  const dataLines = rawEvent.split(`
+`).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, ""));
+  return dataLines.length > 0 ? dataLines.join(`
+`) : null;
+}
+async function readEvents(body, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf(`
+
+`)) !== -1) {
+        onEvent(buffer.slice(0, boundary));
+        buffer = buffer.slice(boundary + 2);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function sseSource(options) {
+  const { url, method = "GET", headers } = options;
+  const abortController = new AbortController;
+  return new Source({
+    async start(control) {
+      let response;
+      try {
+        response = await fetch(url, { method, headers, signal: abortController.signal });
+      } catch (error) {
+        if (!abortController.signal.aborted) {
+          console.error(`sseSource: failed to connect to "${url}"`, error);
+        }
+        control.close();
+        return;
+      }
+      if (!response.ok || !response.body) {
+        console.error(`sseSource: received ${response.status} ${response.statusText} from "${url}"`);
+        control.close();
+        return;
+      }
+      await new Promise((resolveFirstMessage) => {
+        let settled = false;
+        const settle = () => {
+          if (settled)
+            return;
+          settled = true;
+          resolveFirstMessage();
+        };
+        readEvents(response.body, (rawEvent) => {
+          const raw = extractData(rawEvent);
+          if (raw === null || raw.trim() === "")
+            return;
+          let parsed;
+          try {
+            parsed = JSON.parse(raw);
+          } catch (error) {
+            console.error(`sseSource: message from "${url}" is not valid JSON`, error);
+            return;
+          }
+          if (!isPatch(parsed)) {
+            console.error(`sseSource: message from "${url}" did not parse to a JSON object`, parsed);
+            return;
+          }
+          control.set(parsed);
+          settle();
+        }).catch((error) => {
+          if (!abortController.signal.aborted) {
+            console.error(`sseSource: connection to "${url}" ended with an error`, error);
+          }
+        }).finally(() => {
+          control.close();
+          settle();
+        });
+      });
+    },
+    reduce: (patch, previous) => ({
+      ...previous ?? {},
+      ...patch
+    }),
+    close() {
+      abortController.abort();
+    }
+  });
+}
+
+// src/sources/file.ts
+import { watch } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+// src/utils/dotenv.ts
+var QUOTES = ['"', "'", "`"];
+function extractQuoted(value, quote) {
+  let i = 1;
+  while (i < value.length) {
+    const char = value[i];
+    if (char === "\\" && i + 1 < value.length) {
+      i += 2;
+      continue;
+    }
+    if (char === quote)
+      return value.slice(1, i);
+    i++;
+  }
+  return;
+}
+function unescapeQuoted(content, quote) {
+  if (quote !== '"')
+    return content;
+  return content.replace(/\\n/g, `
+`).replace(/\\r/g, "\r");
+}
+function stripInlineComment(value) {
+  const match = value.match(/(^|\s)#/);
+  if (!match)
+    return value;
+  return value.slice(0, match.index).trimEnd();
+}
+function parseLine(line) {
+  const eq = line.indexOf("=");
+  if (eq === -1)
+    return;
+  const key = line.slice(0, eq).trim();
+  const rawValue = line.slice(eq + 1).trim();
+  if (rawValue.length >= 2 && QUOTES.includes(rawValue[0])) {
+    const quote = rawValue[0];
+    const quoted = extractQuoted(rawValue, quote);
+    if (quoted !== undefined)
+      return [key, unescapeQuoted(quoted, quote)];
+  }
+  return [key, stripInlineComment(rawValue)];
+}
+function parse(text) {
+  const result = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#"))
+      continue;
+    const parsed = parseLine(line);
+    if (!parsed)
+      continue;
+    const [key, value] = parsed;
+    result[key] = value;
+  }
+  return result;
+}
+var DotEnv = { parse };
+
+// src/sources/file.ts
+function detectFormat(path) {
+  const pathname = path instanceof URL ? path.pathname : path;
+  if (pathname.endsWith(".json"))
+    return "json";
+  if (pathname.endsWith(".env"))
+    return "env";
+  return;
+}
+function parseFile(format, text) {
+  switch (format) {
+    case "json":
+      return JSON.parse(text);
+    case "env":
+      return DotEnv.parse(text);
+  }
+}
+function selectTreePath(data, treePath) {
+  let node = data;
+  for (const key of treePath) {
+    if (typeof node !== "object" || node === null)
+      return;
+    node = node[key];
+  }
+  return node;
+}
+function fileSource(path, options = {}) {
+  const shouldWatch = options.watch ?? true;
+  const treePath = options.treePath ?? [];
+  let watcher;
+  return new Source({
+    async start(control) {
+      const format = detectFormat(path);
+      if (!format) {
+        console.error(`fileSource: unrecognized file extension for "${path}"`);
+        control.close();
+        return;
+      }
+      async function readOnce() {
+        let text;
+        try {
+          text = await readFile(path, "utf8");
+        } catch (error) {
+          console.error(`fileSource: failed to read "${path}"`, error);
+          return false;
+        }
+        let parsed;
+        try {
+          parsed = parseFile(format, text);
+        } catch (error) {
+          console.error(`fileSource: failed to parse "${path}" as ${format}`, error);
+          return false;
+        }
+        const selected = selectTreePath(parsed, treePath);
+        if (selected === undefined) {
+          console.error(`fileSource: treePath [${treePath.map((k) => JSON.stringify(k)).join(", ")}] did not resolve to anything in "${path}"`);
+          control.set({});
+          return true;
+        }
+        control.set(selected);
+        return true;
+      }
+      await readOnce();
+      if (!shouldWatch) {
+        control.close();
+        return;
+      }
+      watcher = watch(path, { persistent: false }, () => {
+        readOnce();
+      });
+    },
+    close() {
+      watcher?.close();
+    }
+  });
+}
+
+// src/sources/literal.ts
+function literalSource(value) {
+  return new Source({
+    start(control) {
+      control.set(value);
+      control.close();
+    }
+  });
+}
+
+// src/errors.ts
+class ConfigError extends Error {
+}
+
+// src/config.types.ts
+function readNestedValue(data, path) {
+  let node = data;
+  for (const key of path) {
+    if (node === null || typeof node !== "object")
+      return;
+    node = node[key];
+  }
+  return node;
+}
+function typeMismatch(field, value, path) {
+  throw new ConfigError(`Expected ${field.type} at "${path.join(".")}", got ${JSON.stringify(value)}`);
+}
+function validate(field, value, path) {
+  if (typeof value !== field.type) {
+    typeMismatch(field, value, path);
+  }
+  if (field.type === "string" && field.pattern && !field.pattern.test(value)) {
+    throw new ConfigError(`Value at "${path.join(".")}" does not match pattern ${field.pattern}`);
+  }
+}
+function coerce(field, raw, path) {
+  let value = raw;
+  if (field.type === "number" && typeof value !== "number") {
+    const num = Number(value);
+    if (typeof value !== "string" || value.trim() === "" || Number.isNaN(num)) {
+      typeMismatch(field, raw, path);
+    }
+    value = num;
+  } else if (field.type === "boolean" && typeof value !== "boolean") {
+    if (value === "true" || value === "1")
+      value = true;
+    else if (value === "false" || value === "0")
+      value = false;
+    else
+      typeMismatch(field, raw, path);
+  } else if (field.type === "string" && typeof value !== "string") {
+    typeMismatch(field, raw, path);
+  }
+  validate(field, value, path);
+  return value;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!deepEqual(a[key], b[key]))
+      return false;
+  }
+  return true;
+}
+
+class ConfigField extends Store {
+  set() {
+    throw new ConfigError("Cannot set a config field: config values are read-only");
+  }
+  _update(value) {
+    super.set(value);
+  }
+}
+var stateOf = new WeakMap;
+function isEmbeddedNode(value) {
+  return typeof value === "object" && value !== null && stateOf.has(value);
+}
+function collectEmbeddedStates(shape) {
+  const result = [];
+  for (const key of Object.keys(shape)) {
+    const state = stateOf.get(shape[key]);
+    if (state)
+      result.push(state);
+  }
+  return result;
+}
+
+class ConfigNodeState {
+  shape;
+  basePath;
+  ownSources;
+  ownsResolution;
+  closableSources;
+  rootStores;
+  fields = new Map;
+  children = new Map;
+  snapshotStore;
+  readyPromise;
+  constructor(shape, rootStores, basePath, ownSources, ownsResolution, closableSources) {
+    this.shape = shape;
+    this.basePath = basePath;
+    this.ownSources = ownSources;
+    this.ownsResolution = ownsResolution;
+    this.closableSources = closableSources;
+    this.rootStores = rootStores;
+    const embeddedReady = collectEmbeddedStates(shape).map((state) => state.readyPromise);
+    if (ownsResolution) {
+      const opened = Promise.all(ownSources.map((source) => source.open())).then((stores) => {
+        this.rootStores = stores;
+        this.wireLiveUpdates();
+      });
+      this.readyPromise = Promise.all([opened, ...embeddedReady]).then(() => {
+        return;
+      });
+    } else {
+      this.wireLiveUpdates();
+      this.readyPromise = Promise.all(embeddedReady).then(() => {
+        return;
+      });
+    }
+  }
+  wireLiveUpdates() {
+    for (const rootStore of this.rootStores) {
+      rootStore.listen(() => this.refreshFields());
+    }
+  }
+  resolveField(field, path) {
+    for (const rootStore of this.rootStores) {
+      const raw = readNestedValue(rootStore.get(), path);
+      if (raw !== undefined && raw !== null) {
+        return coerce(field, raw, path);
+      }
+    }
+    return field.default !== undefined ? field.default : null;
+  }
+  refreshFields() {
+    for (const [key, field] of this.fields) {
+      const schema = this.shape[key];
+      if (schema.readonly)
+        continue;
+      const path = [...this.basePath, key];
+      const next = this.resolveField(schema, path);
+      if (next !== field.get())
+        field._update(next);
+    }
+    this.refreshSnapshot();
+  }
+  refreshSnapshot() {
+    if (!this.snapshotStore)
+      return;
+    const next = this.get();
+    if (!deepEqual(next, this.snapshotStore.get()))
+      this.snapshotStore.set(next);
+  }
+  fieldFor(key) {
+    let field = this.fields.get(key);
+    if (!field) {
+      const schema = this.shape[key];
+      const path = [...this.basePath, key];
+      field = new ConfigField(this.resolveField(schema, path));
+      this.fields.set(key, field);
+    }
+    return field;
+  }
+  childNode(key) {
+    const cached = this.children.get(key);
+    if (cached)
+      return cached;
+    const node = this.shape[key];
+    const embeddedState = stateOf.get(node);
+    if (!embeddedState) {
+      throw new ConfigError(`"${key}" is not a nested config group`);
+    }
+    let result;
+    if (embeddedState.ownsResolution) {
+      result = node;
+    } else {
+      const childState = new ConfigNodeState(embeddedState.shape, this.rootStores, [...this.basePath, key], [], false, this.closableSources);
+      result = wrapNode(new ConfigNode(childState));
+    }
+    this.children.set(key, result);
+    return result;
+  }
+  get() {
+    const out = {};
+    for (const key of Object.keys(this.shape)) {
+      const node = this.shape[key];
+      if (isEmbeddedNode(node)) {
+        out[key] = this.childNode(key).get();
+      } else {
+        out[key] = this.fieldFor(key).get();
+      }
+    }
+    return out;
+  }
+  set(key) {
+    const node = this.shape[key];
+    if (!node)
+      throw new ConfigError(`Unknown field "${key}"`);
+    throw new ConfigError(`Cannot set "${[...this.basePath, key].join(".")}": config values are read-only`);
+  }
+  ensureSnapshotStore() {
+    if (!this.snapshotStore)
+      this.snapshotStore = new Store(this.get());
+    return this.snapshotStore;
+  }
+  subscribe(subscriber) {
+    return this.ensureSnapshotStore().subscribe(subscriber);
+  }
+  listen(subscriber) {
+    return this.ensureSnapshotStore().listen(subscriber);
+  }
+  async close() {
+    await Promise.all([
+      ...this.closableSources.map((source) => source.close()),
+      ...collectEmbeddedStates(this.shape).map((state) => state.close())
+    ]);
+  }
+}
+function wrapNode(instance) {
+  const state = instance._state;
+  const proxy = new Proxy(instance, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && Object.prototype.hasOwnProperty.call(state.shape, prop)) {
+        const node = state.shape[prop];
+        return isEmbeddedNode(node) ? state.childNode(prop) : state.fieldFor(prop);
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  stateOf.set(proxy, state);
+  return proxy;
+}
+
+class ConfigNodeCore {
+  _state;
+  constructor(_state) {
+    this._state = _state;
+  }
+  get shape() {
+    return this._state.shape;
+  }
+  get() {
+    return this._state.get();
+  }
+  set(key, _value) {
+    this._state.set(key);
+  }
+  subscribe(subscriber) {
+    return this._state.subscribe(subscriber);
+  }
+  listen(subscriber) {
+    return this._state.listen(subscriber);
+  }
+  close() {
+    return this._state.close();
+  }
+  [Symbol.asyncDispose]() {
+    return this.close();
+  }
+}
+
+class ConfigNodeResolved extends ConfigNodeCore {
+}
+
+class ConfigNode extends ConfigNodeCore {
+  static [Symbol.hasInstance](instance) {
+    return instance instanceof ConfigNodeCore;
+  }
+  then(onfulfilled, onrejected) {
+    return this._state.readyPromise.then(() => wrapNode(new ConfigNodeResolved(this._state))).then(onfulfilled, onrejected);
+  }
+}
+function createConfigNode(shape, options) {
+  const ownSources = options?.sources ?? [];
+  const ownsResolution = options !== undefined;
+  const state = new ConfigNodeState(shape, [], [], ownSources, ownsResolution, ownSources);
+  return wrapNode(new ConfigNode(state));
+}
+// src/utils/data-types.ts
+function assertPrimitive(value, target) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    throw new ConfigError(`DataTypes.${target}.from: cannot convert ${typeof value} to ${target}`);
+  }
+}
+var numberType = {
+  from(value) {
+    assertPrimitive(value, "number");
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "boolean")
+      return value ? 1 : 0;
+    const num = Number(value);
+    if (value.trim() === "" || Number.isNaN(num)) {
+      throw new ConfigError(`DataTypes.number.from: cannot convert ${JSON.stringify(value)} to number`);
+    }
+    return num;
+  }
+};
+var stringType = {
+  from(value) {
+    if (value instanceof URL)
+      return value.toString();
+    assertPrimitive(value, "string");
+    return String(value);
+  }
+};
+var booleanType = {
+  from(value) {
+    assertPrimitive(value, "boolean");
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number") {
+      if (value === 1)
+        return true;
+      if (value === 0)
+        return false;
+      throw new ConfigError(`DataTypes.boolean.from: cannot convert ${value} to boolean`);
+    }
+    if (value === "true" || value === "1")
+      return true;
+    if (value === "false" || value === "0")
+      return false;
+    throw new ConfigError(`DataTypes.boolean.from: cannot convert ${JSON.stringify(value)} to boolean`);
+  }
+};
+var listType = {
+  from(value) {
+    if (Array.isArray(value))
+      return value.map((item) => stringType.from(item));
+    if (typeof value === "string")
+      return value.split(",").map((item) => item.trim());
+    throw new ConfigError(`DataTypes.list.from: cannot convert ${typeof value} to list`);
+  }
+};
+var dataTypesRegistry = {
+  number: numberType,
+  string: stringType,
+  boolean: booleanType,
+  list: listType
+};
+function factory(type) {
+  if (type === "number" || type === "string" || type === "boolean" || type === "list") {
+    return dataTypesRegistry[type];
+  }
+  throw new ConfigError(`DataTypes.factory: unknown type "${type}"`);
+}
+var DataTypes = {
+  ...dataTypesRegistry,
+  factory
+};
+
+// src/configs.ts
+var configs = {
+  create: createConfigNode
+};
+var configs_default = configs;
+export {
+  sseSource,
+  mapKey,
+  literalSource,
+  fileSource,
+  fetchSource,
+  envSource,
+  configs_default as default,
+  configs,
+  Store,
+  Source,
+  DotEnv,
+  DataTypes,
+  ConfigNodeResolved,
+  ConfigNode,
+  ConfigError
+};