@b9g/platform 0.1.11 → 0.1.13

package/src/config.js

@@ -1,641 +1,29 @@
 /// <reference types="./config.d.ts" />
-import "../chunk-P57PW2II.js";
-
 // src/config.ts
-import { readFileSync } from "fs";
-import { resolve } from "path";
-import { Cache } from "@b9g/cache";
-import { configure } from "@logtape/logtape";
-function getEnv() {
-  if (typeof import.meta !== "undefined" && import.meta.env) {
-    return import.meta.env;
-  }
-  if (typeof process !== "undefined" && process.env) {
-    return process.env;
-  }
-  return {};
-}
-var Tokenizer = class {
-  #input;
-  #pos;
-  constructor(input) {
-    this.#input = input;
-    this.#pos = 0;
-  }
-  #peek() {
-    return this.#input[this.#pos] || "";
-  }
-  #advance() {
-    return this.#input[this.#pos++] || "";
-  }
-  #skipWhitespace() {
-    while (/\s/.test(this.#peek())) {
-      this.#advance();
-    }
-  }
-  next() {
-    this.#skipWhitespace();
-    const start = this.#pos;
-    const ch = this.#peek();
-    if (!ch) {
-      return { type: "EOF" /* EOF */, value: null, start, end: start };
-    }
-    if (ch === '"') {
-      this.#advance();
-      let value = "";
-      while (this.#peek() && this.#peek() !== '"') {
-        if (this.#peek() === "\\") {
-          this.#advance();
-          const next = this.#advance();
-          if (next === "n")
-            value += "\n";
-          else if (next === "t")
-            value += "	";
-          else
-            value += next;
-        } else {
-          value += this.#advance();
-        }
-      }
-      if (this.#peek() !== '"') {
-        throw new Error(`Unterminated string at position ${start}`);
-      }
-      this.#advance();
-      return { type: "STRING" /* STRING */, value, start, end: this.#pos };
-    }
-    if (/\d/.test(ch)) {
-      let value = "";
-      while (/\d/.test(this.#peek())) {
-        value += this.#advance();
-      }
-      return {
-        type: "NUMBER" /* NUMBER */,
-        value: parseInt(value, 10),
-        start,
-        end: this.#pos
-      };
-    }
-    if (ch === "=" && this.#input[this.#pos + 1] === "=" && this.#input[this.#pos + 2] === "=") {
-      this.#pos += 3;
-      return { type: "===" /* EQ_STRICT */, value: "===", start, end: this.#pos };
-    }
-    if (ch === "!" && this.#input[this.#pos + 1] === "=" && this.#input[this.#pos + 2] === "=") {
-      this.#pos += 3;
-      return { type: "!==" /* NE_STRICT */, value: "!==", start, end: this.#pos };
-    }
-    if (ch === "=" && this.#input[this.#pos + 1] === "=") {
-      this.#pos += 2;
-      return { type: "==" /* EQ */, value: "==", start, end: this.#pos };
-    }
-    if (ch === "!" && this.#input[this.#pos + 1] === "=") {
-      this.#pos += 2;
-      return { type: "!=" /* NE */, value: "!=", start, end: this.#pos };
-    }
-    if (ch === "|" && this.#input[this.#pos + 1] === "|") {
-      this.#pos += 2;
-      return { type: "||" /* OR */, value: "||", start, end: this.#pos };
-    }
-    if (ch === "&" && this.#input[this.#pos + 1] === "&") {
-      this.#pos += 2;
-      return { type: "&&" /* AND */, value: "&&", start, end: this.#pos };
-    }
-    if (ch === "?") {
-      this.#advance();
-      return { type: "?" /* QUESTION */, value: "?", start, end: this.#pos };
-    }
-    if (ch === "!") {
-      this.#advance();
-      return { type: "!" /* NOT */, value: "!", start, end: this.#pos };
-    }
-    if (ch === "(") {
-      this.#advance();
-      return { type: "(" /* LPAREN */, value: "(", start, end: this.#pos };
-    }
-    if (ch === ")") {
-      this.#advance();
-      return { type: ")" /* RPAREN */, value: ")", start, end: this.#pos };
-    }
-    if (ch === ":") {
-      const next = this.#input[this.#pos + 1];
-      if (next !== "/" && !/\d/.test(next)) {
-        this.#advance();
-        return { type: ":" /* COLON */, value: ":", start, end: this.#pos };
-      }
-    }
-    if (/\S/.test(ch) && !/[?!()=|&]/.test(ch)) {
-      let value = "";
-      while (/\S/.test(this.#peek()) && !/[?!()=|&]/.test(this.#peek())) {
-        if (this.#peek() === ":") {
-          const next = this.#input[this.#pos + 1];
-          if (next !== "/" && !/\d/.test(next)) {
-            break;
-          }
-        }
-        value += this.#advance();
-      }
-      if (value === "true")
-        return { type: "TRUE" /* TRUE */, value: true, start, end: this.#pos };
-      if (value === "false")
-        return { type: "FALSE" /* FALSE */, value: false, start, end: this.#pos };
-      if (value === "null")
-        return { type: "NULL" /* NULL */, value: null, start, end: this.#pos };
-      if (value === "undefined")
-        return {
-          type: "UNDEFINED" /* UNDEFINED */,
-          value: void 0,
-          start,
-          end: this.#pos
-        };
-      return { type: "IDENTIFIER" /* IDENTIFIER */, value, start, end: this.#pos };
-    }
-    throw new Error(`Unexpected character '${ch}' at position ${start}`);
-  }
-};
-var Parser = class {
-  #tokens;
-  #pos;
-  #env;
-  #strict;
-  constructor(input, env, strict) {
-    const tokenizer = new Tokenizer(input);
-    this.#tokens = [];
-    let token;
-    do {
-      token = tokenizer.next();
-      this.#tokens.push(token);
-    } while (token.type !== "EOF" /* EOF */);
-    this.#pos = 0;
-    this.#env = env;
-    this.#strict = strict;
-  }
-  #peek() {
-    return this.#tokens[this.#pos];
-  }
-  #advance() {
-    return this.#tokens[this.#pos++];
-  }
-  #expect(type) {
-    const token = this.#peek();
-    if (token.type !== type) {
-      throw new Error(
-        `Expected ${type} but got ${token.type} at position ${token.start}`
-      );
-    }
-    return this.#advance();
-  }
-  parse() {
-    const result = this.#parseExpr();
-    this.#expect("EOF" /* EOF */);
-    return result;
-  }
-  // Expr := Ternary
-  #parseExpr() {
-    return this.#parseTernary();
-  }
-  // Ternary := LogicalOr ('?' Expr ':' Expr)?
-  #parseTernary() {
-    let left = this.#parseLogicalOr();
-    if (this.#peek().type === "?" /* QUESTION */) {
-      this.#advance();
-      const trueBranch = this.#parseExpr();
-      this.#expect(":" /* COLON */);
-      const falseBranch = this.#parseExpr();
-      return left ? trueBranch : falseBranch;
-    }
-    return left;
-  }
-  // LogicalOr := LogicalAnd ('||' LogicalAnd)*
-  #parseLogicalOr() {
-    let left = this.#parseLogicalAnd();
-    while (this.#peek().type === "||" /* OR */) {
-      this.#advance();
-      const right = this.#parseLogicalAnd();
-      left = left || right;
-    }
-    return left;
-  }
-  // LogicalAnd := Equality ('&&' Equality)*
-  #parseLogicalAnd() {
-    let left = this.#parseEquality();
-    while (this.#peek().type === "&&" /* AND */) {
-      this.#advance();
-      const right = this.#parseEquality();
-      left = left && right;
-    }
-    return left;
-  }
-  // Equality := Unary (('===' | '!==' | '==' | '!=') Unary)*
-  #parseEquality() {
-    let left = this.#parseUnary();
-    while (true) {
-      const token = this.#peek();
-      if (token.type === "===" /* EQ_STRICT */) {
-        this.#advance();
-        const right = this.#parseUnary();
-        left = left === right;
-      } else if (token.type === "!==" /* NE_STRICT */) {
-        this.#advance();
-        const right = this.#parseUnary();
-        left = left !== right;
-      } else if (token.type === "==" /* EQ */) {
-        this.#advance();
-        const right = this.#parseUnary();
-        left = left == right;
-      } else if (token.type === "!=" /* NE */) {
-        this.#advance();
-        const right = this.#parseUnary();
-        left = left != right;
-      } else {
-        break;
-      }
-    }
-    return left;
-  }
-  // Unary := '!' Unary | Primary
-  #parseUnary() {
-    if (this.#peek().type === "!" /* NOT */) {
-      this.#advance();
-      return !this.#parseUnary();
-    }
-    return this.#parsePrimary();
-  }
-  // Primary := EnvVar | Literal | '(' Expr ')'
-  #parsePrimary() {
-    const token = this.#peek();
-    if (token.type === "(" /* LPAREN */) {
-      this.#advance();
-      const value = this.#parseExpr();
-      this.#expect(")" /* RPAREN */);
-      return value;
-    }
-    if (token.type === "STRING" /* STRING */) {
-      this.#advance();
-      return token.value;
-    }
-    if (token.type === "NUMBER" /* NUMBER */) {
-      this.#advance();
-      return token.value;
-    }
-    if (token.type === "TRUE" /* TRUE */) {
-      this.#advance();
-      return true;
-    }
-    if (token.type === "FALSE" /* FALSE */) {
-      this.#advance();
-      return false;
-    }
-    if (token.type === "NULL" /* NULL */) {
-      this.#advance();
-      return null;
-    }
-    if (token.type === "UNDEFINED" /* UNDEFINED */) {
-      this.#advance();
-      return void 0;
-    }
-    if (token.type === "IDENTIFIER" /* IDENTIFIER */) {
-      this.#advance();
-      const name = token.value;
-      if (/^[A-Z][A-Z0-9_]*$/.test(name)) {
-        const value = this.#env[name];
-        if (this.#strict && value === void 0) {
-          throw new Error(
-            `Undefined environment variable: ${name}
-Fix:
-  1. Set the env var: export ${name}=value
-  2. Add a fallback: ${name} || defaultValue
-  3. Add null check: ${name} == null ? ... : ...
-  4. Use empty string for falsy: export ${name}=""`
-          );
-        }
-        if (typeof value === "string" && /^\d+$/.test(value)) {
-          return parseInt(value, 10);
-        }
-        return value;
-      }
-      return name;
-    }
-    throw new Error(
-      `Unexpected token ${token.type} at position ${token.start}`
-    );
+var ConfigValidationError = class extends Error {
+  constructor(path, issue) {
+    const message = issue === "undefined" ? `Config "${path}" is undefined. Ensure required environment variables are set.` : `Config "${path}" is NaN. Ensure the environment variable contains a valid number.`;
+    super(message);
+    this.path = path;
+    this.issue = issue;
+    this.name = "ConfigValidationError";
   }
 };
-function parseConfigExpr(expr, env = getEnv(), options = {}) {
-  const strict = options.strict !== false;
-  try {
-    const parser = new Parser(expr, env, strict);
-    return parser.parse();
-  } catch (error) {
-    throw new Error(
-      `Invalid config expression: ${expr}
-Error: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function processConfigValue(value, env = getEnv(), options = {}) {
-  if (typeof value === "string") {
-    if (/(\|\||&&|===|!==|==|!=|[?:!]|^[A-Z][A-Z0-9_]*$)/.test(value)) {
-      return parseConfigExpr(value, env, options);
+function validateConfig(config, path = "") {
+  for (const [key, value] of Object.entries(config)) {
+    const fullPath = path ? `${path}.${key}` : key;
+    if (value === void 0) {
+      throw new ConfigValidationError(fullPath, "undefined");
     }
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => processConfigValue(item, env, options));
-  }
-  if (value !== null && typeof value === "object") {
-    const processed = {};
-    for (const [key, val] of Object.entries(value)) {
-      processed[key] = processConfigValue(val, env, options);
-    }
-    return processed;
-  }
-  return value;
-}
-function matchPattern(name, config) {
-  if (config[name]) {
-    return config[name];
-  }
-  const patterns = [];
-  for (const [pattern, cfg] of Object.entries(config)) {
-    if (pattern === "*")
-      continue;
-    if (pattern.endsWith("*")) {
-      const prefix = pattern.slice(0, -1);
-      if (name.startsWith(prefix)) {
-        patterns.push({
-          pattern,
-          config: cfg,
-          prefixLength: prefix.length
-        });
-      }
+    if (typeof value === "number" && Number.isNaN(value)) {
+      throw new ConfigValidationError(fullPath, "NaN");
     }
-  }
-  if (patterns.length > 0) {
-    patterns.sort((a, b) => b.prefixLength - a.prefixLength);
-    return patterns[0].config;
-  }
-  return config["*"];
-}
-function loadConfig(cwd) {
-  const env = getEnv();
-  let rawConfig = {};
-  try {
-    const shovelPath = `${cwd}/shovel.json`;
-    const content = readFileSync(shovelPath, "utf-8");
-    rawConfig = JSON.parse(content);
-  } catch (error) {
-    try {
-      const pkgPath = `${cwd}/package.json`;
-      const content = readFileSync(pkgPath, "utf-8");
-      const pkgJSON = JSON.parse(content);
-      rawConfig = pkgJSON.shovel || {};
-    } catch (error2) {
-    }
-  }
-  const processed = processConfigValue(rawConfig, env, {
-    strict: true
-  });
-  const defaultSinks = [{ provider: "console" }];
-  const config = {
-    platform: processed.platform,
-    port: typeof processed.port === "number" ? processed.port : 3e3,
-    host: processed.host || "localhost",
-    workers: typeof processed.workers === "number" ? processed.workers : 1,
-    logging: {
-      level: processed.logging?.level || "info",
-      sinks: processed.logging?.sinks || defaultSinks,
-      categories: processed.logging?.categories || {}
-    },
-    caches: processed.caches || {},
-    buckets: processed.buckets || {}
-  };
-  return config;
-}
-var SHOVEL_CATEGORIES = [
-  "cli",
-  "watcher",
-  "worker",
-  "single-threaded",
-  "assets",
-  "platform-node",
-  "platform-bun",
-  "platform-cloudflare",
-  "cache",
-  "cache-redis",
-  "router"
-];
-var BUILTIN_SINK_PROVIDERS = {
-  console: { module: "@logtape/logtape", factory: "getConsoleSink" },
-  file: { module: "@logtape/file", factory: "getFileSink" },
-  rotating: { module: "@logtape/file", factory: "getRotatingFileSink" },
-  "stream-file": { module: "@logtape/file", factory: "getStreamFileSink" },
-  otel: { module: "@logtape/otel", factory: "getOpenTelemetrySink" },
-  sentry: { module: "@logtape/sentry", factory: "getSentrySink" },
-  syslog: { module: "@logtape/syslog", factory: "getSyslogSink" },
-  cloudwatch: {
-    module: "@logtape/cloudwatch-logs",
-    factory: "getCloudWatchLogsSink"
-  }
-};
-async function createSink(config, options = {}) {
-  const { provider, ...sinkOptions } = config;
-  if (sinkOptions.path && options.cwd) {
-    sinkOptions.path = resolve(options.cwd, sinkOptions.path);
-  }
-  const builtin = BUILTIN_SINK_PROVIDERS[provider];
-  const modulePath = builtin?.module || provider;
-  const factoryName = builtin?.factory || "default";
-  const module = await import(modulePath);
-  const factory = module[factoryName] || module.default;
-  if (!factory) {
-    throw new Error(
-      `Sink module "${modulePath}" has no export "${factoryName}"`
-    );
-  }
-  return factory(sinkOptions);
-}
-async function configureLogging(loggingConfig, options = {}) {
-  const { level, sinks: defaultSinkConfigs, categories } = loggingConfig;
-  const reset = options.reset !== false;
-  const allSinkConfigs = /* @__PURE__ */ new Map();
-  const sinkNameMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < defaultSinkConfigs.length; i++) {
-    const config = defaultSinkConfigs[i];
-    const name = `sink_${i}`;
-    allSinkConfigs.set(name, config);
-    sinkNameMap.set(config, name);
-  }
-  let sinkIndex = defaultSinkConfigs.length;
-  for (const [_, categoryConfig] of Object.entries(categories)) {
-    if (categoryConfig.sinks) {
-      for (const config of categoryConfig.sinks) {
-        let found = false;
-        for (const [existingConfig, _name] of sinkNameMap) {
-          if (JSON.stringify(existingConfig) === JSON.stringify(config)) {
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          const name = `sink_${sinkIndex++}`;
-          allSinkConfigs.set(name, config);
-          sinkNameMap.set(config, name);
-        }
-      }
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      validateConfig(value, fullPath);
     }
   }
-  const sinks = {};
-  for (const [name, config] of allSinkConfigs) {
-    sinks[name] = await createSink(config, { cwd: options.cwd });
-  }
-  const getSinkNames = (configs) => {
-    return configs.map((config) => {
-      for (const [existingConfig, name] of sinkNameMap) {
-        if (JSON.stringify(existingConfig) === JSON.stringify(config)) {
-          return name;
-        }
-      }
-      return "";
-    }).filter(Boolean);
-  };
-  const defaultSinkNames = getSinkNames(defaultSinkConfigs);
-  const loggers = SHOVEL_CATEGORIES.map((category) => {
-    const categoryConfig = categories[category];
-    const categoryLevel = categoryConfig?.level || level;
-    const categorySinks = categoryConfig?.sinks ? getSinkNames(categoryConfig.sinks) : defaultSinkNames;
-    return {
-      category: [category],
-      level: categoryLevel,
-      sinks: categorySinks
-    };
-  });
-  loggers.push({
-    category: ["logtape", "meta"],
-    level: "warning",
-    sinks: []
-  });
-  await configure({
-    reset,
-    sinks,
-    loggers
-  });
-}
-function getCacheConfig(config, name) {
-  return matchPattern(name, config.caches) || {};
-}
-function getBucketConfig(config, name) {
-  return matchPattern(name, config.buckets) || {};
-}
-var WELL_KNOWN_BUCKET_PATHS = {
-  static: (baseDir) => resolve(baseDir, "../static"),
-  server: (baseDir) => baseDir
-};
-var BUILTIN_BUCKET_PROVIDERS = {
-  node: "@b9g/filesystem/node.js",
-  memory: "@b9g/filesystem/memory.js",
-  s3: "@b9g/filesystem-s3"
-};
-function createBucketFactory(options) {
-  const { baseDir, config } = options;
-  return async (name) => {
-    const bucketConfig = config ? getBucketConfig(config, name) : {};
-    let bucketPath;
-    if (bucketConfig.path) {
-      bucketPath = String(bucketConfig.path);
-    } else if (WELL_KNOWN_BUCKET_PATHS[name]) {
-      bucketPath = WELL_KNOWN_BUCKET_PATHS[name](baseDir);
-    } else {
-      bucketPath = resolve(baseDir, `../${name}`);
-    }
-    const provider = String(bucketConfig.provider || "node");
-    const modulePath = BUILTIN_BUCKET_PROVIDERS[provider] || provider;
-    if (modulePath === "@b9g/filesystem/node.js") {
-      const { NodeBucket } = await import("@b9g/filesystem/node.js");
-      return new NodeBucket(bucketPath);
-    }
-    if (modulePath === "@b9g/filesystem/memory.js") {
-      const { MemoryBucket } = await import("@b9g/filesystem/memory.js");
-      return new MemoryBucket(name);
-    }
-    try {
-      const module = await import(modulePath);
-      const BucketClass = module.default || // Default export
-      module.S3Bucket || // Named export for s3
-      module.Bucket || // Generic Bucket export
-      Object.values(module).find(
-        (v) => typeof v === "function" && v.name?.includes("Bucket")
-      );
-      if (!BucketClass) {
-        throw new Error(
-          `Bucket module "${modulePath}" does not export a valid bucket class. Expected a default export or named export (S3Bucket, Bucket).`
-        );
-      }
-      const { provider: _, path: __, ...bucketOptions } = bucketConfig;
-      return new BucketClass(name, { path: bucketPath, ...bucketOptions });
-    } catch (error) {
-      if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
-        throw new Error(
-          `Bucket provider "${provider}" not found. Make sure the module "${modulePath}" is installed.
-For S3: npm install @b9g/filesystem-s3`
-        );
-      }
-      throw error;
-    }
-  };
-}
-var BUILTIN_CACHE_PROVIDERS = {
-  memory: "@b9g/cache/memory.js",
-  redis: "@b9g/cache-redis"
-};
-function createCacheFactory(options = {}) {
-  const { config, defaultProvider = "memory" } = options;
-  return async (name) => {
-    const cacheConfig = config ? getCacheConfig(config, name) : {};
-    const provider = String(cacheConfig.provider || defaultProvider);
-    if (provider === "cloudflare") {
-      const nativeCaches = globalThis.__cloudflareCaches ?? globalThis.caches;
-      if (!nativeCaches) {
-        throw new Error(
-          "Cloudflare cache provider requires native caches API. This provider only works in Cloudflare Workers environment."
-        );
-      }
-      return nativeCaches.open(name);
-    }
-    const { provider: _, ...cacheOptions } = cacheConfig;
-    const modulePath = BUILTIN_CACHE_PROVIDERS[provider] || provider;
-    try {
-      const module = await import(modulePath);
-      const CacheClass = module.default || // Default export
-      module.RedisCache || // Named export for redis
-      module.MemoryCache || // Named export for memory
-      module.Cache || // Generic Cache export
-      Object.values(module).find(
-        (v) => typeof v === "function" && v.prototype instanceof Cache
-      );
-      if (!CacheClass) {
-        throw new Error(
-          `Cache module "${modulePath}" does not export a valid cache class. Expected a default export or named export (RedisCache, Cache) that extends Cache.`
-        );
-      }
-      return new CacheClass(name, cacheOptions);
-    } catch (error) {
-      if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
-        throw new Error(
-          `Cache provider "${provider}" not found. Make sure the module "${modulePath}" is installed.
-For redis: npm install @b9g/cache-redis`
-        );
-      }
-      throw error;
-    }
-  };
 }
 export {
-  configureLogging,
-  createBucketFactory,
-  createCacheFactory,
-  getBucketConfig,
-  getCacheConfig,
-  loadConfig,
-  matchPattern,
-  parseConfigExpr,
-  processConfigValue
+  ConfigValidationError,
+  validateConfig
 };