nuxt-safe-runtime-config 0.0.11 → 0.0.13

package/README.md

@@ -18,7 +18,7 @@ Validate Nuxt runtime config at build time using <b>Zod</b>, <b>Valibot</b>, <b>
     <img src="https://img.shields.io/github/license/onmax/nuxt-safe-runtime-config.svg" alt="License" />
   </a>
   <a href="https://nuxt.com">
-    <img src="https://img.shields.io/badge/Nuxt-3.0-00DC82.svg" alt="Nuxt" />
+    <img src="https://img.shields.io/badge/Nuxt-3.0+-00DC82.svg" alt="Nuxt" />
   </a>
 
   <p align="center">
@@ -30,15 +30,15 @@ Validate Nuxt runtime config at build time using <b>Zod</b>, <b>Valibot</b>, <b>
 
 ## Features
 
-- 🔒 &nbsp;Validate runtime config at build time with **Zod**, **Valibot**, **ArkType**, and more
-- 🚀 &nbsp;Works with any [Standard Schema](https://standardschema.dev/) compatible library
-- 🛠 &nbsp;Only runs during dev/build/generate phases
-- ⚡ &nbsp;Zero runtime overhead - validation happens at build time only
-- 📝 &nbsp;Does not modify your runtime config or types - only validates them
+- 🔒 **Build-time validation** with Zod, Valibot, ArkType, or any [Standard Schema](https://standardschema.dev/) library
+- 🚀 **Runtime validation** (opt-in) validates config when the server starts
+- ✨ **Auto-generated types** — `useSafeRuntimeConfig()` is fully typed without manual generics
+- 🛠 **ESLint plugin** warns when using `useRuntimeConfig()` instead of the type-safe composable
+- ⚡ **Zero runtime overhead** by default — validation happens at build time only
 
 ## Quick Setup
 
-Install the module to your Nuxt application with one command:
+Install the module:
 
 ```bash
 npx nuxi module add nuxt-safe-runtime-config
@@ -46,15 +46,9 @@ npx nuxi module add nuxt-safe-runtime-config
 
 ## Usage
 
-1. Add the module to your `nuxt.config.ts`:
+### 1. Define your schema
 
-```typescript
-export default defineNuxtConfig({
-  modules: ['nuxt-safe-runtime-config']
-})
-```
-
-2. Define your runtime config schema using **Valibot**, **Zod**, **ArkType**, or any other Standard Schema compatible library:
+Use Zod, Valibot, ArkType, or any Standard Schema compatible library:
 
 <details>
 <summary>With Valibot</summary>
@@ -113,13 +107,12 @@ const runtimeConfigSchema = type({
 
 </details>
 
-3. Configure your Nuxt app:
+### 2. Configure in nuxt.config.ts
 
 ```typescript
 export default defineNuxtConfig({
   modules: ['nuxt-safe-runtime-config'],
 
-  // Your regular runtime config
   runtimeConfig: {
     databaseUrl: process.env.DATABASE_URL || 'postgresql://localhost:5432/mydb',
     secretKey: process.env.SECRET_KEY || 'default-secret-key',
@@ -130,45 +123,124 @@ export default defineNuxtConfig({
     },
   },
 
-  // Add your schema for validation
   safeRuntimeConfig: {
     $schema: runtimeConfigSchema,
   },
 })
 ```
 
-The module validates your runtime config **after environment variables are merged** during:
+### 3. Use the type-safe composable
+
+Access your validated config with full type safety — types are auto-generated from your schema:
+
+```vue
+<script setup lang="ts">
+const config = useSafeRuntimeConfig()
+// config.public.apiBase is typed as string
+// config.secretKey is typed as string
+</script>
+```
+
+## Configuration Options
+
+| Option              | Type                            | Default           | Description                                |
+| ------------------- | ------------------------------- | ----------------- | ------------------------------------------ |
+| `$schema`           | `StandardSchemaV1`              | —                 | Your validation schema (required)          |
+| `validateAtBuild`   | `boolean`                       | `true`            | Validate during dev/build                  |
+| `validateAtRuntime` | `boolean`                       | `false`           | Validate when server starts                |
+| `onBuildError`      | `'throw' \| 'warn' \| 'ignore'` | `'throw'`         | How to handle build validation errors      |
+| `onRuntimeError`    | `'throw' \| 'warn' \| 'ignore'` | `'throw'`         | How to handle runtime validation errors    |
+| `logSuccess`        | `boolean`                       | `true`            | Log successful validation                  |
+| `logFallback`       | `boolean`                       | `true`            | Log when using JSON Schema fallback        |
+| `jsonSchemaTarget`  | `string`                        | `'draft-2020-12'` | JSON Schema version for runtime validation |
+
+## Runtime Validation
+
+By default, validation only runs at build time. Enable runtime validation to catch environment variable issues when the server starts:
+
+```ts
+export default defineNuxtConfig({
+  safeRuntimeConfig: {
+    $schema: runtimeConfigSchema,
+    validateAtRuntime: true,
+  },
+})
+```
+
+Runtime validation uses [@cfworker/json-schema](https://github.com/cfworker/cfworker/tree/main/packages/json-schema) to validate the config after environment variables are merged. This lightweight validator (~8KB) works on all runtimes including edge (Cloudflare Workers, Vercel Edge, Netlify Edge). It catches issues like:
+
+- Environment variables with wrong types (e.g., `NUXT_PORT=abc` when expecting a number)
+- Missing required environment variables in production
+- Invalid values that pass build-time checks but fail at runtime
+
+## ESLint Integration
+
+The module includes an ESLint plugin that warns when using `useRuntimeConfig()` instead of `useSafeRuntimeConfig()`.
+
+### With @nuxt/eslint (Automatic)
 
-- `nuxi dev` (development mode)
-- `nuxi build`
-- `nuxi generate`
+If you use [@nuxt/eslint](https://eslint.nuxt.com), the rule is auto-registered. No configuration needed.
 
-This means validation happens at **runtime initialization**, after all `NUXT_*` environment variables from `.env` files have been merged into your runtime config. If validation fails, the build process will stop with detailed error messages.
+### Manual Setup
 
-## Important Notes
+Add to your `eslint.config.mjs`:
 
-**This module only validates your runtime config - it does not modify it.** Your native `runtimeConfig` remains unchanged, and no TypeScript types are modified. The module simply ensures that your runtime configuration matches your schema at build time, helping you catch configuration errors early in the development process.
+```javascript
+import safeRuntimeConfig from 'nuxt-safe-runtime-config/eslint'
+
+export default [
+  safeRuntimeConfig.configs.recommended,
+  // ... your other configs
+]
+```
+
+Or configure manually:
+
+```javascript
+import safeRuntimeConfig from 'nuxt-safe-runtime-config/eslint'
+
+export default [
+  {
+    plugins: { 'safe-runtime-config': safeRuntimeConfig },
+    rules: { 'safe-runtime-config/prefer-safe-runtime-config': 'warn' },
+  },
+]
+```
+
+The rule includes auto-fix support — run `eslint --fix` to automatically replace `useRuntimeConfig()` calls.
+
+## Type Safety
+
+Types are auto-generated at build time from your schema's JSON Schema representation. The `useSafeRuntimeConfig()` composable returns a fully typed object — no manual generics needed:
+
+```ts
+const config = useSafeRuntimeConfig()
+// config is fully typed based on your schema
+```
+
+Generated types are stored in `.nuxt/types/safe-runtime-config.d.ts` and automatically included in your project.
 
 ## Error Messages
 
-When validation fails, you'll see detailed error messages like:
+When validation fails, you see detailed error messages:
 
 ```
-Safe Runtime Config: Validation failed!
-  1. databaseUrl: This field is required
-  2. public.apiBase: Expected string, received undefined
-  3. port: Expected number, received string
+[safe-runtime-config] Validation failed!
+  1. databaseUrl: Invalid type: Expected string but received undefined
+  2. public.apiBase: Invalid type: Expected string but received undefined
+  3. port: Invalid type: Expected number but received string
 ```
 
-The module will stop the build process until all validation errors are resolved.
+The module stops the build process until all validation errors are resolved.
 
 ## Why This Module?
 
-I wanted to use **Valibot** for runtime config validation, but Nuxt doesn't currently support Standard Schema. While Nuxt has its own schema validation system, it's primarily designed for module authors and broader Nuxt configuration.
-
-This module focuses specifically on **runtime config validation** using the Standard Schema specification, allowing you to use your preferred validation library (Valibot, Zod, ArkType, etc.).
+Nuxt's built-in schema validation is designed for module authors and broader configuration. This module focuses specifically on **runtime config validation** using Standard Schema, allowing you to:
 
-The goal is to eventually make Standard Schema a first-class citizen in Nuxt. If this module gains enough adoption, I plan to create a PR to add `standardSchema` support to Nuxt core.
+- Use your preferred validation library (Valibot, Zod, ArkType)
+- Catch configuration errors at build time
+- Optionally validate at runtime for environment variable issues
+- Get full type safety in your components
 
 ## Contribution
 

package/dist/eslint.d.cts

@@ -0,0 +1,2 @@
+export * from "/home/runner/work/nuxt-safe-runtime-config/nuxt-safe-runtime-config/src/eslint/index.js";
+export { default } from "/home/runner/work/nuxt-safe-runtime-config/nuxt-safe-runtime-config/src/eslint/index.js";

package/dist/eslint.d.mts

@@ -0,0 +1,30 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'prefer-safe-runtime-config': _typescript_eslint_utils_ts_eslint.RuleModule<"preferSafe", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    };
+};
+
+declare const configs: {
+    recommended: {
+        plugins: {
+            'safe-runtime-config': {
+                meta: {
+                    name: string;
+                };
+                rules: {
+                    'prefer-safe-runtime-config': _typescript_eslint_utils_ts_eslint.RuleModule<"preferSafe", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+                };
+            };
+        };
+        rules: {
+            'safe-runtime-config/prefer-safe-runtime-config': string;
+        };
+    };
+};
+
+export { configs, plugin as default };

package/dist/eslint.d.ts

@@ -0,0 +1,30 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'prefer-safe-runtime-config': _typescript_eslint_utils_ts_eslint.RuleModule<"preferSafe", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    };
+};
+
+declare const configs: {
+    recommended: {
+        plugins: {
+            'safe-runtime-config': {
+                meta: {
+                    name: string;
+                };
+                rules: {
+                    'prefer-safe-runtime-config': _typescript_eslint_utils_ts_eslint.RuleModule<"preferSafe", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+                };
+            };
+        };
+        rules: {
+            'safe-runtime-config/prefer-safe-runtime-config': string;
+        };
+    };
+};
+
+export { configs, plugin as default };

package/dist/eslint.mjs

@@ -0,0 +1,38 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/onmax/nuxt-safe-runtime-config#${name}`);
+const preferSafeRuntimeConfig = createRule({
+  name: "prefer-safe-runtime-config",
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer useSafeRuntimeConfig() over useRuntimeConfig()" },
+    schema: [],
+    messages: { preferSafe: "Use useSafeRuntimeConfig() for type-safe runtime config" },
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    CallExpression(node) {
+      if (node.callee.type === "Identifier" && node.callee.name === "useRuntimeConfig") {
+        context.report({
+          node,
+          messageId: "preferSafe",
+          fix: (fixer) => fixer.replaceText(node.callee, "useSafeRuntimeConfig")
+        });
+      }
+    }
+  })
+});
+
+const plugin = {
+  meta: { name: "nuxt-safe-runtime-config" },
+  rules: { "prefer-safe-runtime-config": preferSafeRuntimeConfig }
+};
+const configs = {
+  recommended: {
+    plugins: { "safe-runtime-config": plugin },
+    rules: { "safe-runtime-config/prefer-safe-runtime-config": "warn" }
+  }
+};
+
+export { configs, plugin as default };

package/dist/module.d.cts

@@ -0,0 +1,2 @@
+export * from "/home/runner/work/nuxt-safe-runtime-config/nuxt-safe-runtime-config/src/module.js";
+export { default } from "/home/runner/work/nuxt-safe-runtime-config/nuxt-safe-runtime-config/src/module.js";

package/dist/module.d.mts

@@ -1,10 +1,34 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
 
+type ErrorBehavior = 'throw' | 'warn' | 'ignore';
 interface ModuleOptions {
     $schema: StandardSchemaV1;
+    validateAtBuild: boolean;
+    validateAtRuntime: boolean;
+    jsonSchemaTarget?: StandardJSONSchemaV1.Target;
+    onBuildError?: ErrorBehavior;
+    onRuntimeError?: ErrorBehavior;
+    logSuccess?: boolean;
+    logFallback?: boolean;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        'eslint:config:addons': (addons: Array<{
+            name: string;
+            getConfigs: () => {
+                imports?: Array<{
+                    from: string;
+                    name: string;
+                    as: string;
+                }>;
+                configs?: string[];
+            };
+        }>) => void;
+    }
+}
+
 export { _default as default };
-export type { ModuleOptions };
+export type { ErrorBehavior, ModuleOptions };

package/dist/module.d.ts

@@ -0,0 +1,34 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
+
+type ErrorBehavior = 'throw' | 'warn' | 'ignore';
+interface ModuleOptions {
+    $schema: StandardSchemaV1;
+    validateAtBuild: boolean;
+    validateAtRuntime: boolean;
+    jsonSchemaTarget?: StandardJSONSchemaV1.Target;
+    onBuildError?: ErrorBehavior;
+    onRuntimeError?: ErrorBehavior;
+    logSuccess?: boolean;
+    logFallback?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        'eslint:config:addons': (addons: Array<{
+            name: string;
+            getConfigs: () => {
+                imports?: Array<{
+                    from: string;
+                    name: string;
+                    as: string;
+                }>;
+                configs?: string[];
+            };
+        }>) => void;
+    }
+}
+
+export { _default as default };
+export type { ErrorBehavior, ModuleOptions };

package/dist/module.json

@@ -1,7 +1,10 @@
 {
   "name": "nuxt-safe-runtime-config",
   "configKey": "safeRuntimeConfig",
-  "version": "0.0.11",
+  "compatibility": {
+    "nuxt": ">=3.0.0"
+  },
+  "version": "0.0.13",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "3.5.0"

package/dist/module.mjs

@@ -1,41 +1,255 @@
-import { defineNuxtModule } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addTypeTemplate, addTemplate, addImportsDir } from '@nuxt/kit';
+import { toJsonSchema } from '@standard-community/standard-json';
 
+function jsonSchemaToTs(schema, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  if ("$ref" in schema) {
+    return "unknown";
+  }
+  if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
+    const types = schema.anyOf.map((s) => jsonSchemaToTs(s, indent));
+    return types.join(" | ");
+  }
+  if ("oneOf" in schema && Array.isArray(schema.oneOf)) {
+    const types = schema.oneOf.map((s) => jsonSchemaToTs(s, indent));
+    return types.join(" | ");
+  }
+  if ("allOf" in schema && Array.isArray(schema.allOf)) {
+    const types = schema.allOf.map((s) => jsonSchemaToTs(s, indent));
+    return types.join(" & ");
+  }
+  if ("const" in schema) {
+    return JSON.stringify(schema.const);
+  }
+  if ("enum" in schema && Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  const type = schema.type;
+  if (type === "string") {
+    return "string";
+  }
+  if (type === "number" || type === "integer") {
+    return "number";
+  }
+  if (type === "boolean") {
+    return "boolean";
+  }
+  if (type === "null") {
+    return "null";
+  }
+  if (type === "array") {
+    const items = schema.items;
+    if (items) {
+      return `${jsonSchemaToTs(items, indent)}[]`;
+    }
+    return "unknown[]";
+  }
+  if (type === "object" || "properties" in schema) {
+    const properties = schema.properties;
+    const required = schema.required || [];
+    const additionalProperties = schema.additionalProperties;
+    if (!properties || Object.keys(properties).length === 0) {
+      if (additionalProperties === false) {
+        return "Record<string, never>";
+      }
+      if (typeof additionalProperties === "object") {
+        return `Record<string, ${jsonSchemaToTs(additionalProperties, indent)}>`;
+      }
+      return "Record<string, unknown>";
+    }
+    const lines = ["{"];
+    const propIndent = "  ".repeat(indent + 1);
+    for (const [key, propSchema] of Object.entries(properties)) {
+      const isRequired = required.includes(key);
+      const optional = isRequired ? "" : "?";
+      const safeKey = /^[\w$]+$/.test(key) && !/^\d/.test(key) ? key : JSON.stringify(key);
+      const propType = jsonSchemaToTs(propSchema, indent + 1);
+      lines.push(`${propIndent}${safeKey}${optional}: ${propType}`);
+    }
+    lines.push(`${spaces}}`);
+    return lines.join("\n");
+  }
+  if (Array.isArray(type)) {
+    const types = type.map((t) => {
+      switch (t) {
+        case "null":
+          return "null";
+        case "string":
+          return "string";
+        case "number":
+        case "integer":
+          return "number";
+        case "boolean":
+          return "boolean";
+        case "array":
+          return "unknown[]";
+        case "object":
+          return "Record<string, unknown>";
+        default:
+          return "unknown";
+      }
+    });
+    return types.join(" | ");
+  }
+  return "unknown";
+}
+function generateTypeDeclaration(schema) {
+  const tsType = jsonSchemaToTs(schema);
+  return `// Auto-generated by nuxt-safe-runtime-config
+// Do not edit manually
+
+export type SafeRuntimeConfig = ${tsType}
+
+declare module '#imports' {
+  export function useSafeRuntimeConfig(): SafeRuntimeConfig
+}
+
+declare module '#app' {
+  export function useSafeRuntimeConfig(): SafeRuntimeConfig
+}
+
+export {}
+`;
+}
+
+const logger = useLogger("safe-runtime-config");
 const module = defineNuxtModule({
   meta: {
     name: "nuxt-safe-runtime-config",
-    configKey: "safeRuntimeConfig"
+    configKey: "safeRuntimeConfig",
+    compatibility: { nuxt: ">=3.0.0" }
   },
   defaults: {
-    $schema: void 0
+    $schema: void 0,
+    validateAtBuild: true,
+    validateAtRuntime: false,
+    jsonSchemaTarget: "draft-2020-12",
+    onBuildError: "throw",
+    onRuntimeError: "throw",
+    logSuccess: true,
+    logFallback: true
   },
-  setup(options, nuxt) {
+  async setup(options, nuxt) {
     if (!options.$schema)
       return;
     const schema = options.$schema;
-    nuxt.hook("ready", async () => {
-      if (nuxt.options._prepare)
-        return;
-      await validateRuntimeConfig(nuxt.options.nitro.runtimeConfig, schema);
+    const resolver = createResolver(import.meta.url);
+    const jsonSchema = await getJSONSchema(schema, options.jsonSchemaTarget, options.logFallback);
+    addTypeTemplate({
+      filename: "types/safe-runtime-config.d.ts",
+      getContents: () => generateTypeDeclaration(jsonSchema)
     });
-    nuxt.hook("build:done", async () => {
-      await validateRuntimeConfig(nuxt.options.nitro.runtimeConfig, schema);
+    if (options.validateAtBuild) {
+      const validateOpts = { onError: options.onBuildError, logSuccess: options.logSuccess };
+      nuxt.hook("ready", async () => {
+        if (nuxt.options._prepare)
+          return;
+        await validateRuntimeConfig(nuxt.options.nitro.runtimeConfig, schema, validateOpts);
+      });
+      nuxt.hook("build:done", async () => {
+        await validateRuntimeConfig(nuxt.options.nitro.runtimeConfig, schema, validateOpts);
+      });
+    }
+    if (options.validateAtRuntime) {
+      addTemplate({
+        filename: "safe-runtime-config/schema.json",
+        write: true,
+        getContents: () => JSON.stringify(jsonSchema)
+      });
+      const schemaUri = jsonSchema.$schema;
+      const draft = schemaUri?.includes("2020-12") ? "2020-12" : schemaUri?.includes("2019-09") ? "2019-09" : schemaUri?.includes("draft-07") ? "7" : "2020-12";
+      const pluginPath = addTemplate({
+        filename: "safe-runtime-config/validate-plugin.ts",
+        write: true,
+        getContents: () => `
+import { Validator } from '@cfworker/json-schema'
+import { useRuntimeConfig } from '#imports'
+import { consola } from 'consola'
+
+const logger = consola.withTag('safe-runtime-config')
+const schema = ${JSON.stringify(jsonSchema)}
+const options = ${JSON.stringify({ onError: options.onRuntimeError, logSuccess: options.logSuccess })}
+
+export default defineNitroPlugin(() => {
+  const config = useRuntimeConfig()
+  const validator = new Validator(schema, '${draft}')
+  const result = validator.validate(config)
+
+  if (!result.valid) {
+    const errors = result.errors.map(e => \`\${e.instanceLocation}: \${e.error}\`).join(', ')
+    const msg = \`Runtime validation failed: \${errors}\`
+
+    if (options.onError === 'throw') {
+      logger.error(msg)
+      throw new Error(msg)
+    } else if (options.onError === 'warn') {
+      logger.warn(msg)
+    }
+  } else if (options.logSuccess) {
+    logger.success('Runtime config validated (server start)')
+  }
+})
+`
+      });
+      nuxt.hook("nitro:config", (nitroConfig) => {
+        nitroConfig.plugins = nitroConfig.plugins || [];
+        nitroConfig.plugins.push(pluginPath.dst);
+      });
+    }
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    nuxt.hook("eslint:config:addons", (addons) => {
+      addons.push({
+        name: "nuxt-safe-runtime-config",
+        getConfigs: () => ({
+          imports: [{ from: "nuxt-safe-runtime-config/eslint", name: "default", as: "safeRuntimeConfig" }],
+          configs: [`safeRuntimeConfig.configs.recommended`]
+        })
+      });
     });
   }
 });
-async function validateRuntimeConfig(config, schema) {
+function hasNativeJSONSchema(schema) {
+  return typeof schema?.["~standard"]?.jsonSchema?.output === "function";
+}
+async function getJSONSchema(schema, target = "draft-2020-12", logFallback = true) {
+  if (hasNativeJSONSchema(schema)) {
+    try {
+      return schema["~standard"].jsonSchema.output({ target });
+    } catch {
+      if (logFallback)
+        logger.warn(`Native JSON Schema failed for target "${target}", using fallback`);
+    }
+  }
+  if (logFallback)
+    logger.warn("Schema does not support native JSON Schema, using @standard-community/standard-json fallback");
+  return await toJsonSchema(schema);
+}
+async function validateRuntimeConfig(config, schema, opts) {
   if (!isStandardSchema(schema)) {
-    console.error("Safe Runtime Config: Schema is not Standard Schema compatible");
-    throw new Error("Invalid schema format");
+    const msg = "Schema is not Standard Schema compatible";
+    if (opts.onError === "throw") {
+      logger.error(msg);
+      throw new Error("Invalid schema format");
+    } else if (opts.onError === "warn") {
+      logger.warn(msg);
+    }
+    return;
   }
   const result = await schema["~standard"].validate(config);
   if ("issues" in result && result.issues && result.issues.length > 0) {
-    console.error("Safe Runtime Config: Validation failed!");
-    result.issues.forEach((issue, index) => {
-      console.error(`  ${index + 1}. ${formatIssue(issue)}`);
-    });
-    throw new Error("Runtime config validation failed");
+    const errorLines = result.issues.map((issue, index) => `  ${index + 1}. ${formatIssue(issue)}`);
+    if (opts.onError === "throw") {
+      logger.error(`Validation failed!
+${errorLines.join("\n")}`);
+      throw new Error("Runtime config validation failed");
+    } else if (opts.onError === "warn") {
+      logger.warn(`Validation failed!
+${errorLines.join("\n")}`);
+    }
+    return;
   }
-  console.log("\u2713 Validated Runtime Config");
+  if (opts.logSuccess)
+    logger.success("Validated Runtime Config");
 }
 function isStandardSchema(schema) {
   return schema && typeof schema === "object" && "~standard" in schema && typeof schema["~standard"] === "object" && typeof schema["~standard"].validate === "function";

package/dist/types.d.mts

@@ -1,3 +1,13 @@
-export { default } from './module.mjs'
+import type { ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+declare module '#app' {
+  interface RuntimeNuxtHooks extends ModuleRuntimeHooks {}
+}
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+  interface RuntimeConfig extends ModuleRuntimeConfig {}
+  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
+}
+
+export * from "./module.mjs"

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "nuxt-safe-runtime-config",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.13",
+  "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0",
   "description": "Validate Nuxt runtime config with Standard Schema at build time",
   "author": {
     "name": "onmax"
@@ -20,64 +21,75 @@
     "build-time"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/types.d.mts",
-      "import": "./dist/module.mjs"
-    }
+    ".": { "types": "./dist/types.d.mts", "import": "./dist/module.mjs" },
+    "./eslint": { "types": "./dist/eslint.d.mts", "import": "./dist/eslint.mjs" }
   },
   "main": "./dist/module.mjs",
   "typesVersions": {
     "*": {
-      ".": [
-        "./dist/types.d.mts"
-      ]
+      ".": ["./dist/types.d.mts"],
+      "eslint": ["./dist/eslint.d.mts"]
     }
   },
   "files": [
     "dist"
   ],
-  "dependencies": {
-    "@nuxt/kit": "^3.17.4",
-    "@standard-schema/spec": "^1.0.0"
-  },
-  "devDependencies": {
-    "@antfu/eslint-config": "^4.13.3",
-    "@antfu/ni": "^25.0.0",
-    "@nuxt/devtools": "^2.4.1",
-    "@nuxt/eslint": "^1.4.1",
-    "@nuxt/eslint-config": "^1.4.1",
-    "@nuxt/module-builder": "^1.0.1",
-    "@nuxt/schema": "^3.17.4",
-    "@nuxt/test-utils": "^3.19.1",
-    "@types/node": "latest",
-    "bumpp": "^10.1.1",
-    "changelogen": "^0.6.1",
-    "eslint": "^9.28.0",
-    "eslint-plugin-format": "^1.0.1",
-    "lint-staged": "^16.1.0",
-    "nuxt": "^3.17.4",
-    "simple-git-hooks": "^2.13.0",
-    "typescript": "~5.8.3",
-    "valibot": "^1.1.0",
-    "vitest": "^3.2.0",
-    "vue-tsc": "^2.2.10"
-  },
-  "simple-git-hooks": {
-    "pre-commit": "pnpm lint-staged"
-  },
-  "lint-staged": {
-    "*": "eslint --fix"
-  },
   "scripts": {
+    "prepack": "nuxt-module-build build && unbuild",
     "dev": "nuxi dev playground",
     "dev:build": "nuxi build playground",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground && pnpm -C test/fixtures/validation-failure prepare && pnpm -C test/fixtures/validation-success prepare",
-    "release": "nr lint && nr typecheck && nr test && nr prepack && bumpp && pnpm publish",
+    "dev:prepare": "nuxt-module-build build --stub && nuxi prepare playground",
+    "release": "bumpp && git push --follow-tags",
     "typecheck": "nuxt typecheck && pnpm -C playground typecheck",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "vitest run",
     "test:watch": "vitest watch",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": { "optional": true }
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "catalog:",
+    "@nuxt/kit": "catalog:",
+    "@standard-community/standard-json": "catalog:",
+    "@standard-schema/spec": "catalog:",
+    "consola": "catalog:"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "catalog:",
+    "@antfu/ni": "catalog:",
+    "@nuxt/devtools": "catalog:",
+    "@nuxt/eslint": "catalog:",
+    "@nuxt/eslint-config": "catalog:",
+    "@nuxt/module-builder": "catalog:",
+    "@nuxt/schema": "catalog:",
+    "@nuxt/test-utils": "catalog:",
+    "@types/node": "catalog:",
+    "@typescript-eslint/parser": "catalog:",
+    "@typescript-eslint/rule-tester": "catalog:",
+    "@typescript-eslint/utils": "catalog:",
+    "bumpp": "catalog:",
+    "changelogen": "catalog:",
+    "eslint": "catalog:",
+    "eslint-plugin-format": "catalog:",
+    "lint-staged": "catalog:",
+    "nuxt": "catalog:",
+    "simple-git-hooks": "catalog:",
+    "typescript": "catalog:",
+    "unbuild": "catalog:",
+    "valibot": "catalog:",
+    "vitest": "catalog:",
+    "vue-tsc": "catalog:"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
   }
-}
+}