veryfront 0.0.4 → 0.0.6

package/dist/config.js

@@ -0,0 +1,654 @@
+// src/core/config/schema.ts
+import { z } from "zod";
+
+// src/core/errors/veryfront-error.ts
+function createError(error) {
+  return error;
+}
+function toError(veryfrontError) {
+  const error = new Error(veryfrontError.message);
+  error.name = `VeryfrontError[${veryfrontError.type}]`;
+  Object.defineProperty(error, "context", {
+    value: veryfrontError,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+
+// src/core/config/schema.ts
+var corsSchema = z.union([z.boolean(), z.object({ origin: z.string().optional() }).strict()]);
+var veryfrontConfigSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  experimental: z.object({
+    esmLayouts: z.boolean().optional(),
+    precompileMDX: z.boolean().optional()
+  }).partial().optional(),
+  router: z.enum(["app", "pages"]).optional(),
+  defaultLayout: z.string().optional(),
+  theme: z.object({ colors: z.record(z.string()).optional() }).partial().optional(),
+  build: z.object({
+    outDir: z.string().optional(),
+    trailingSlash: z.boolean().optional(),
+    esbuild: z.object({
+      wasmURL: z.string().url().optional(),
+      worker: z.boolean().optional()
+    }).partial().optional()
+  }).partial().optional(),
+  cache: z.object({
+    dir: z.string().optional(),
+    bundleManifest: z.object({
+      type: z.enum(["redis", "kv", "memory"]).optional(),
+      redisUrl: z.string().optional(),
+      keyPrefix: z.string().optional(),
+      ttl: z.number().int().positive().optional(),
+      enabled: z.boolean().optional()
+    }).partial().optional()
+  }).partial().optional(),
+  dev: z.object({
+    port: z.number().int().positive().optional(),
+    host: z.string().optional(),
+    open: z.boolean().optional(),
+    hmr: z.boolean().optional(),
+    components: z.array(z.string()).optional()
+  }).partial().optional(),
+  resolve: z.object({
+    importMap: z.object({
+      imports: z.record(z.string()).optional(),
+      scopes: z.record(z.record(z.string())).optional()
+    }).partial().optional()
+  }).partial().optional(),
+  security: z.object({
+    csp: z.record(z.array(z.string())).optional(),
+    remoteHosts: z.array(z.string().url()).optional(),
+    cors: corsSchema.optional(),
+    coop: z.enum(["same-origin", "same-origin-allow-popups", "unsafe-none"]).optional(),
+    corp: z.enum(["same-origin", "same-site", "cross-origin"]).optional(),
+    coep: z.enum(["require-corp", "unsafe-none"]).optional()
+  }).partial().optional(),
+  middleware: z.object({
+    custom: z.array(z.function()).optional()
+  }).partial().optional(),
+  theming: z.object({
+    brandName: z.string().optional(),
+    logoHtml: z.string().optional()
+  }).partial().optional(),
+  assetPipeline: z.object({
+    images: z.object({
+      enabled: z.boolean().optional(),
+      formats: z.array(z.enum(["webp", "avif", "jpeg", "png"])).optional(),
+      sizes: z.array(z.number().int().positive()).optional(),
+      quality: z.number().int().min(1).max(100).optional(),
+      inputDir: z.string().optional(),
+      outputDir: z.string().optional(),
+      preserveOriginal: z.boolean().optional()
+    }).partial().optional(),
+    css: z.object({
+      enabled: z.boolean().optional(),
+      minify: z.boolean().optional(),
+      autoprefixer: z.boolean().optional(),
+      purge: z.boolean().optional(),
+      criticalCSS: z.boolean().optional(),
+      inputDir: z.string().optional(),
+      outputDir: z.string().optional(),
+      browsers: z.array(z.string()).optional(),
+      purgeContent: z.array(z.string()).optional(),
+      sourceMap: z.boolean().optional()
+    }).partial().optional()
+  }).partial().optional(),
+  observability: z.object({
+    tracing: z.object({
+      enabled: z.boolean().optional(),
+      exporter: z.enum(["jaeger", "zipkin", "otlp", "console"]).optional(),
+      endpoint: z.string().optional(),
+      serviceName: z.string().optional(),
+      sampleRate: z.number().min(0).max(1).optional()
+    }).partial().optional(),
+    metrics: z.object({
+      enabled: z.boolean().optional(),
+      exporter: z.enum(["prometheus", "otlp", "console"]).optional(),
+      endpoint: z.string().optional(),
+      prefix: z.string().optional(),
+      collectInterval: z.number().int().positive().optional()
+    }).partial().optional()
+  }).partial().optional(),
+  fs: z.object({
+    type: z.enum(["local", "veryfront-api", "memory"]).optional(),
+    local: z.object({
+      baseDir: z.string().optional()
+    }).partial().optional(),
+    veryfront: z.object({
+      apiBaseUrl: z.string().url(),
+      apiToken: z.string(),
+      projectSlug: z.string(),
+      cache: z.object({
+        enabled: z.boolean().optional(),
+        ttl: z.number().int().positive().optional(),
+        maxSize: z.number().int().positive().optional()
+      }).partial().optional(),
+      retry: z.object({
+        maxRetries: z.number().int().min(0).optional(),
+        initialDelay: z.number().int().positive().optional(),
+        maxDelay: z.number().int().positive().optional()
+      }).partial().optional()
+    }).partial().optional(),
+    memory: z.object({
+      files: z.record(z.union([z.string(), z.instanceof(Uint8Array)])).optional()
+    }).partial().optional()
+  }).partial().optional()
+}).partial();
+function validateVeryfrontConfig(input) {
+  const parsed = veryfrontConfigSchema.safeParse(input);
+  if (!parsed.success) {
+    const first = parsed.error.issues[0];
+    const path = first?.path?.length ? first.path.join(".") : "<root>";
+    const expected = first?.message || String(first);
+    let hint = "";
+    if (String(path).includes("security.cors")) {
+      hint = " Expected boolean or { origin?: string }.";
+    }
+    const context = {
+      field: path,
+      expected: expected + hint,
+      value: input
+    };
+    throw toError(
+      createError({
+        type: "config",
+        message: `Invalid veryfront.config at ${path}: ${expected}.${hint}`,
+        context
+      })
+    );
+  }
+  return parsed.data;
+}
+function findUnknownTopLevelKeys(input) {
+  const known = /* @__PURE__ */ new Set([
+    "title",
+    "description",
+    "experimental",
+    "router",
+    "defaultLayout",
+    "theme",
+    "build",
+    "cache",
+    "dev",
+    "resolve",
+    "security",
+    "middleware",
+    "theming",
+    "assetPipeline",
+    "observability",
+    "fs"
+  ]);
+  return Object.keys(input).filter((k) => !known.has(k));
+}
+
+// src/core/config/loader.ts
+import { join } from "path";
+
+// src/core/utils/runtime-guards.ts
+function hasDenoRuntime(global) {
+  return typeof global === "object" && global !== null && "Deno" in global && typeof global.Deno?.env?.get === "function";
+}
+function hasNodeProcess(global) {
+  return typeof global === "object" && global !== null && "process" in global && typeof global.process?.env === "object";
+}
+
+// src/core/utils/logger/env.ts
+function getEnvironmentVariable(name) {
+  try {
+    if (typeof Deno !== "undefined" && hasDenoRuntime(globalThis)) {
+      const value = globalThis.Deno?.env.get(name);
+      return value === "" ? void 0 : value;
+    }
+    if (hasNodeProcess(globalThis)) {
+      const value = globalThis.process?.env[name];
+      return value === "" ? void 0 : value;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+
+// src/core/utils/logger/logger.ts
+var cachedLogLevel;
+function resolveLogLevel(force = false) {
+  if (force || cachedLogLevel === void 0) {
+    cachedLogLevel = getDefaultLevel();
+  }
+  return cachedLogLevel;
+}
+var ConsoleLogger = class {
+  constructor(prefix, level = resolveLogLevel()) {
+    this.prefix = prefix;
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(`[${this.prefix}] DEBUG: ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`[${this.prefix}] ${message}`, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(`[${this.prefix}] WARN: ${message}`, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(`[${this.prefix}] ERROR: ${message}`, ...args);
+    }
+  }
+  async time(label, fn) {
+    const start = performance.now();
+    try {
+      const result = await fn();
+      const end = performance.now();
+      this.debug(`${label} completed in ${(end - start).toFixed(2)}ms`);
+      return result;
+    } catch (error) {
+      const end = performance.now();
+      this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, error);
+      throw error;
+    }
+  }
+};
+function parseLogLevel(levelString) {
+  if (!levelString)
+    return void 0;
+  const upper = levelString.toUpperCase();
+  switch (upper) {
+    case "DEBUG":
+      return 0 /* DEBUG */;
+    case "WARN":
+      return 2 /* WARN */;
+    case "ERROR":
+      return 3 /* ERROR */;
+    case "INFO":
+      return 1 /* INFO */;
+    default:
+      return void 0;
+  }
+}
+var getDefaultLevel = () => {
+  const envLevel = getEnvironmentVariable("LOG_LEVEL");
+  const parsedLevel = parseLogLevel(envLevel);
+  if (parsedLevel !== void 0)
+    return parsedLevel;
+  const debugFlag = getEnvironmentVariable("VERYFRONT_DEBUG");
+  if (debugFlag === "1" || debugFlag === "true")
+    return 0 /* DEBUG */;
+  return 1 /* INFO */;
+};
+var trackedLoggers = /* @__PURE__ */ new Set();
+function createLogger(prefix) {
+  const logger2 = new ConsoleLogger(prefix);
+  trackedLoggers.add(logger2);
+  return logger2;
+}
+var cliLogger = createLogger("CLI");
+var serverLogger = createLogger("SERVER");
+var rendererLogger = createLogger("RENDERER");
+var bundlerLogger = createLogger("BUNDLER");
+var agentLogger = createLogger("AGENT");
+var logger = createLogger("VERYFRONT");
+
+// src/core/utils/constants/cdn.ts
+var ESM_CDN_BASE = "https://esm.sh";
+var REACT_VERSION_18_3 = "18.3.1";
+var REACT_DEFAULT_VERSION = REACT_VERSION_18_3;
+function getReactCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react@${version}`;
+}
+function getReactDOMCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react-dom@${version}`;
+}
+function getReactDOMClientCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react-dom@${version}/client`;
+}
+function getReactDOMServerCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react-dom@${version}/server`;
+}
+function getReactJSXRuntimeCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react@${version}/jsx-runtime`;
+}
+function getReactJSXDevRuntimeCDNUrl(version = REACT_DEFAULT_VERSION) {
+  return `${ESM_CDN_BASE}/react@${version}/jsx-dev-runtime`;
+}
+function getReactImportMap(version = REACT_DEFAULT_VERSION) {
+  return {
+    react: getReactCDNUrl(version),
+    "react-dom": getReactDOMCDNUrl(version),
+    "react-dom/client": getReactDOMClientCDNUrl(version),
+    "react-dom/server": getReactDOMServerCDNUrl(version),
+    "react/jsx-runtime": getReactJSXRuntimeCDNUrl(version),
+    "react/jsx-dev-runtime": getReactJSXDevRuntimeCDNUrl(version)
+  };
+}
+
+// src/core/config/loader.ts
+function getDefaultImportMapForConfig() {
+  return { imports: getReactImportMap(REACT_DEFAULT_VERSION) };
+}
+var DEFAULT_CONFIG = {
+  title: "Veryfront App",
+  description: "Built with Veryfront",
+  experimental: {
+    esmLayouts: true
+  },
+  router: void 0,
+  defaultLayout: void 0,
+  theme: {
+    colors: {
+      primary: "#3B82F6"
+    }
+  },
+  build: {
+    outDir: "dist",
+    trailingSlash: false,
+    esbuild: {
+      wasmURL: "https://deno.land/x/esbuild@v0.20.1/esbuild.wasm",
+      worker: false
+    }
+  },
+  cache: {
+    dir: ".veryfront/cache",
+    render: {
+      type: "memory",
+      ttl: void 0,
+      maxEntries: 500,
+      kvPath: void 0,
+      redisUrl: void 0,
+      redisKeyPrefix: void 0
+    }
+  },
+  dev: {
+    port: 3002,
+    host: "localhost",
+    open: false
+  },
+  resolve: {
+    importMap: getDefaultImportMapForConfig()
+  }
+};
+var configCacheByProject = /* @__PURE__ */ new Map();
+function validateCorsConfig(userConfig) {
+  if (!userConfig || typeof userConfig !== "object") {
+    return;
+  }
+  const config = userConfig;
+  const security = config.security;
+  const cors = security?.cors;
+  if (!cors || typeof cors !== "object" || Array.isArray(cors)) {
+    return;
+  }
+  const corsObj = cors;
+  const origin = corsObj.origin;
+  if (origin !== void 0 && typeof origin !== "string") {
+    throw new ConfigValidationError(
+      "security.cors.origin must be a string. Expected boolean or { origin?: string }"
+    );
+  }
+}
+function validateConfigShape(userConfig) {
+  validateVeryfrontConfig(userConfig);
+  const unknown = typeof userConfig === "object" && userConfig ? findUnknownTopLevelKeys(userConfig) : [];
+  if (unknown.length > 0) {
+    serverLogger.warn(`Unknown config keys: ${unknown.join(", ")}. These will be ignored.`);
+  }
+}
+function mergeConfigs(userConfig) {
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    dev: {
+      ...DEFAULT_CONFIG.dev,
+      ...userConfig.dev
+    },
+    theme: {
+      ...DEFAULT_CONFIG.theme,
+      ...userConfig.theme
+    },
+    build: {
+      ...DEFAULT_CONFIG.build,
+      ...userConfig.build
+    },
+    cache: {
+      ...DEFAULT_CONFIG.cache,
+      ...userConfig.cache
+    },
+    resolve: {
+      ...DEFAULT_CONFIG.resolve,
+      ...userConfig.resolve
+    }
+  };
+  if (merged.resolve) {
+    const defaultMap = DEFAULT_CONFIG.resolve?.importMap;
+    const userMap = userConfig.resolve?.importMap;
+    if (defaultMap || userMap) {
+      merged.resolve.importMap = {
+        imports: {
+          ...defaultMap?.imports ?? {},
+          ...userMap?.imports ?? {}
+        },
+        scopes: {
+          ...defaultMap?.scopes ?? {},
+          ...userMap?.scopes ?? {}
+        }
+      };
+    }
+  }
+  return merged;
+}
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigValidationError";
+  }
+};
+async function loadAndMergeConfig(configPath, projectDir) {
+  try {
+    const configUrl = `file://${configPath}?t=${Date.now()}`;
+    const configModule = await import(configUrl);
+    const userConfig = configModule.default || configModule;
+    validateCorsConfig(userConfig);
+    validateConfigShape(userConfig);
+    const merged = mergeConfigs(userConfig);
+    configCacheByProject.set(projectDir, merged);
+    return merged;
+  } catch (error) {
+    if (error instanceof ConfigValidationError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.startsWith("Invalid veryfront.config")) {
+      throw error;
+    }
+    throw error;
+  }
+}
+async function getConfig(projectDir, adapter) {
+  const cached = configCacheByProject.get(projectDir);
+  if (cached)
+    return cached;
+  const configFiles = ["veryfront.config.js", "veryfront.config.ts", "veryfront.config.mjs"];
+  for (const configFile of configFiles) {
+    const configPath = join(projectDir, configFile);
+    const exists = await adapter.fs.exists(configPath);
+    if (!exists)
+      continue;
+    try {
+      const merged = await loadAndMergeConfig(configPath, projectDir);
+      if (merged)
+        return merged;
+    } catch (error) {
+      if (error instanceof ConfigValidationError) {
+        throw error;
+      }
+      if (error instanceof Error && error.message.startsWith("Invalid veryfront.config")) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      serverLogger.warn(`[CONFIG] Failed to load ${configFile}, trying next config file:`, {
+        error: errorMessage
+      });
+      continue;
+    }
+  }
+  const defaultConfig2 = DEFAULT_CONFIG;
+  configCacheByProject.set(projectDir, defaultConfig2);
+  return defaultConfig2;
+}
+function clearConfigCache() {
+  configCacheByProject.clear();
+}
+
+// src/core/config/define-config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/core/config/defaults.ts
+var DEFAULT_DEV_PORT = 3e3;
+var DEFAULT_TIMEOUT_MS = 5e3;
+var SSR_TIMEOUT_MS = 1e4;
+var SANDBOX_TIMEOUT_MS = 5e3;
+var DEFAULT_CACHE_MAX_SIZE = 100;
+var defaultConfig = {
+  server: {
+    port: DEFAULT_DEV_PORT,
+    hostname: "0.0.0.0"
+  },
+  timeouts: {
+    default: DEFAULT_TIMEOUT_MS,
+    api: 3e4,
+    ssr: SSR_TIMEOUT_MS,
+    hmr: 3e4,
+    sandbox: SANDBOX_TIMEOUT_MS
+  },
+  cache: {
+    jit: {
+      maxSize: DEFAULT_CACHE_MAX_SIZE,
+      tempDirPrefix: "vf-bundle-"
+    }
+  },
+  metrics: {
+    ssrBoundaries: [5, 10, 25, 50, 75, 100, 250, 500, 750, 1e3, 2500, 5e3, 7500, 1e4]
+  }
+};
+var DEFAULT_PREFETCH_DELAY_MS = 100;
+var DEFAULT_METRICS_COLLECT_INTERVAL_MS = 6e4;
+var DURATION_HISTOGRAM_BOUNDARIES_MS = [
+  5,
+  10,
+  25,
+  50,
+  75,
+  100,
+  250,
+  500,
+  750,
+  1e3,
+  2500,
+  5e3,
+  7500,
+  1e4
+];
+var SIZE_HISTOGRAM_BOUNDARIES_KB = [
+  1,
+  5,
+  10,
+  25,
+  50,
+  100,
+  250,
+  500,
+  1e3,
+  2500,
+  5e3,
+  1e4
+];
+var DEFAULT_REDIS_SCAN_COUNT = 100;
+var DEFAULT_REDIS_BATCH_DELETE_SIZE = 1e3;
+var PAGE_TRANSITION_DELAY_MS = 150;
+
+// src/core/config/network-defaults.ts
+var LOCALHOST = {
+  IPV4: "127.0.0.1",
+  IPV6: "::1",
+  HOSTNAME: "localhost"
+};
+var HTTP_DEFAULTS = {
+  PORT: 3e3,
+  HOST: "localhost",
+  PROD_HOST: "0.0.0.0"
+};
+var REDIS_DEFAULTS = {
+  URL: "redis://127.0.0.1:6379",
+  PORT: 6379,
+  HOST: "127.0.0.1"
+};
+var DEV_LOCALHOST_ORIGINS = [
+  "http://localhost",
+  "http://127.0.0.1",
+  "https://localhost",
+  "https://127.0.0.1"
+];
+var DEV_LOCALHOST_CSP = {
+  WS: "ws://localhost:* wss://localhost:*",
+  HTTP: "http://localhost"
+};
+var LOCALHOST_URLS = {
+  HTTP: "http://localhost",
+  HTTPS: "https://localhost",
+  HTTP_IPV4: "http://127.0.0.1",
+  HTTPS_IPV4: "https://127.0.0.1"
+};
+function buildLocalhostUrl(port, protocol = "http") {
+  return `${protocol}://${LOCALHOST.HOSTNAME}:${port}`;
+}
+function buildIpv4Url(port, protocol = "http") {
+  return `${protocol}://${LOCALHOST.IPV4}:${port}`;
+}
+export {
+  DEFAULT_CACHE_MAX_SIZE,
+  DEFAULT_DEV_PORT,
+  DEFAULT_METRICS_COLLECT_INTERVAL_MS,
+  DEFAULT_PREFETCH_DELAY_MS,
+  DEFAULT_REDIS_BATCH_DELETE_SIZE,
+  DEFAULT_REDIS_SCAN_COUNT,
+  DEFAULT_TIMEOUT_MS,
+  DEV_LOCALHOST_CSP,
+  DEV_LOCALHOST_ORIGINS,
+  DURATION_HISTOGRAM_BOUNDARIES_MS,
+  HTTP_DEFAULTS,
+  LOCALHOST,
+  LOCALHOST_URLS,
+  PAGE_TRANSITION_DELAY_MS,
+  REDIS_DEFAULTS,
+  SANDBOX_TIMEOUT_MS,
+  SIZE_HISTOGRAM_BOUNDARIES_KB,
+  SSR_TIMEOUT_MS,
+  buildIpv4Url,
+  buildLocalhostUrl,
+  clearConfigCache,
+  defaultConfig,
+  defineConfig,
+  findUnknownTopLevelKeys,
+  getConfig,
+  validateVeryfrontConfig,
+  veryfrontConfigSchema
+};
+//# sourceMappingURL=config.js.map