@b9g/platform 0.1.4 → 0.1.6

package/src/config.js

@@ -0,0 +1,517 @@
+/// <reference types="./config.d.ts" />
+// src/config.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { Cache } from "@b9g/cache";
+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}`
+    );
+  }
+};
+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);
+    }
+    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 (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 config = {
+    port: typeof processed.port === "number" ? processed.port : 3e3,
+    host: processed.host || "localhost",
+    workers: typeof processed.workers === "number" ? processed.workers : 1,
+    caches: processed.caches || {},
+    buckets: processed.buckets || {}
+  };
+  return config;
+}
+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 } = options;
+  return async (name) => {
+    const cacheConfig = config ? getCacheConfig(config, name) : {};
+    const provider = String(cacheConfig.provider || "memory");
+    const modulePath = BUILTIN_CACHE_PROVIDERS[provider] || provider;
+    if (modulePath === "@b9g/cache/memory.js") {
+      const { MemoryCache } = await import("@b9g/cache/memory.js");
+      return new MemoryCache(name, {
+        maxEntries: typeof cacheConfig.maxEntries === "number" ? cacheConfig.maxEntries : 1e3
+      });
+    }
+    try {
+      const module = await import(modulePath);
+      const CacheClass = module.default || // Default export
+      module.RedisCache || // Named export for redis
+      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.`
+        );
+      }
+      const { provider: _, ...cacheOptions } = cacheConfig;
+      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 {
+  createBucketFactory,
+  createCacheFactory,
+  getBucketConfig,
+  getCacheConfig,
+  loadConfig,
+  matchPattern,
+  parseConfigExpr,
+  processConfigValue
+};

package/src/cookie-store.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Cookie Store API Implementation
+ * https://cookiestore.spec.whatwg.org/
+ *
+ * Provides asynchronous cookie management for ServiceWorker contexts
+ */
+declare global {
+    interface CookieListItem {
+        domain?: string;
+        path?: string;
+        expires?: number;
+        secure?: boolean;
+        sameSite?: CookieSameSite;
+        partitioned?: boolean;
+    }
+}
+export type CookieSameSite = globalThis.CookieSameSite;
+export type CookieInit = globalThis.CookieInit;
+export type CookieStoreGetOptions = globalThis.CookieStoreGetOptions;
+export type CookieStoreDeleteOptions = globalThis.CookieStoreDeleteOptions;
+export type CookieListItem = globalThis.CookieListItem;
+export type CookieList = CookieListItem[];
+/**
+ * Parse Cookie header value into key-value pairs
+ * Cookie: name=value; name2=value2
+ */
+export declare function parseCookieHeader(cookieHeader: string): Map<string, string>;
+/**
+ * Serialize cookie into Set-Cookie header value
+ */
+export declare function serializeCookie(cookie: CookieInit): string;
+/**
+ * Parse Set-Cookie header into CookieListItem
+ */
+export declare function parseSetCookieHeader(setCookieHeader: string): CookieListItem;
+/**
+ * RequestCookieStore - Cookie Store implementation for ServiceWorker contexts
+ *
+ * This implementation:
+ * - Reads cookies from the incoming Request's Cookie header
+ * - Tracks changes (set/delete operations)
+ * - Exports changes as Set-Cookie headers for the Response
+ *
+ * It follows the Cookie Store API spec but is designed for server-side
+ * request handling rather than browser contexts.
+ */
+export declare class RequestCookieStore extends EventTarget {
+    #private;
+    onchange: ((this: RequestCookieStore, ev: Event) => any) | null;
+    constructor(request?: Request);
+    /**
+     * Get a single cookie by name
+     */
+    get(nameOrOptions: string | CookieStoreGetOptions): Promise<CookieListItem | null>;
+    /**
+     * Get all cookies matching the filter
+     */
+    getAll(nameOrOptions?: string | CookieStoreGetOptions): Promise<CookieList>;
+    /**
+     * Set a cookie
+     */
+    set(nameOrOptions: string | CookieInit, value?: string): Promise<void>;
+    /**
+     * Delete a cookie
+     */
+    delete(nameOrOptions: string | CookieStoreDeleteOptions): Promise<void>;
+    /**
+     * Get Set-Cookie headers for all changes
+     * This should be called when constructing the Response
+     */
+    getSetCookieHeaders(): string[];
+    /**
+     * Check if there are any pending changes
+     */
+    hasChanges(): boolean;
+    /**
+     * Clear all pending changes (for testing/reset)
+     */
+    clearChanges(): void;
+}