fastify-ata 0.2.9 → 0.2.11

package/README.md

@@ -1,6 +1,6 @@
 # fastify-ata
 
-Fastify plugin for [ata-validator](https://ata-validator.com) — JSON Schema validation powered by simdjson.
+Fastify plugin for [ata-validator](https://ata-validator.com) - JSON Schema validation powered by simdjson.
 
 Drop-in replacement for Fastify's default ajv validator. Standard Schema V1 compatible.
 
@@ -49,9 +49,41 @@ fastify.register(fastifyAta, {
 })
 ```
 
+## Standalone Mode (Pre-compiled)
+
+Drop-in replacement for `@fastify/ajv-compiler/standalone`. Same API.
+
+```js
+const StandaloneValidator = require('fastify-ata/standalone')
+
+// Build phase (once) - compile schemas to JS files
+const app = fastify({
+  schemaController: { compilersFactory: {
+    buildValidator: StandaloneValidator({
+      readMode: false,
+      storeFunction(routeOpts, code) {
+        fs.writeFileSync(generateFileName(routeOpts), code)
+      }
+    })
+  }}
+})
+
+// Read phase (every startup) - load pre-compiled, near-zero compile time
+const app = fastify({
+  schemaController: { compilersFactory: {
+    buildValidator: StandaloneValidator({
+      readMode: true,
+      restoreFunction(routeOpts) {
+        return require(generateFileName(routeOpts))
+      }
+    })
+  }}
+})
+```
+
 ## Standard Schema V1
 
-ata-validator natively implements [Standard Schema V1](https://github.com/standard-schema/standard-schema) — the emerging standard for TypeScript-first schema libraries.
+ata-validator natively implements [Standard Schema V1](https://github.com/standard-schema/standard-schema) - the emerging standard for TypeScript-first schema libraries.
 
 ```js
 const { Validator } = require('ata-validator')
@@ -91,16 +123,18 @@ Works with Fastify v5's Standard Schema support, tRPC, TanStack Form, Drizzle OR
 | **Serverless cold start** (50 schemas) | 7.7ms | 96ms | **12.5x faster** |
 | **ReDoS protection** (catastrophic pattern) | 0.3ms | 765ms | **immune** |
 | **Batch NDJSON** (10K items, multi-core) | 13.4M/sec | 5.1M/sec | **2.6x faster** |
-| **validate(obj)** valid (isolated) | 76M ops/sec | 8M ops/sec | **9.5x faster** |
-| **validate(obj)** invalid (isolated) | 34M ops/sec | 8M ops/sec | **4.3x faster** |
+| **validate(obj)** valid (isolated) | 68M ops/sec | 8M ops/sec | **8.5x faster** |
+| **validate(obj)** invalid (isolated) | 17M ops/sec | 8M ops/sec | **2.1x faster** |
+| **validateJSON(str)** valid | 3.0M ops/sec | 1.9M ops/sec | **1.6x faster** |
+| **Fastify startup** (500 routes) | 46ms | 77ms (standalone) | **1.7x faster** |
 | **Schema compilation** | 113K ops/sec | 818 ops/sec | **138x faster** |
 
 ### Things only ata can do
 
-- **RE2 regex engine** — linear-time guaranteed, immune to ReDoS attacks
-- **Multi-core parallel validation** — NDJSON batch at 12.5M items/sec
-- **Standard Schema V1** — native support, ajv doesn't have it
-- **138x faster compilation** — serverless cold starts, dynamic schemas
+- **RE2 regex engine** - linear-time guaranteed, immune to ReDoS attacks
+- **Multi-core parallel validation** - NDJSON batch at 12.5M items/sec
+- **Standard Schema V1** - native support, ajv doesn't have it
+- **138x faster compilation** - serverless cold starts, dynamic schemas
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-ata",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Fastify plugin for ata-validator — beats ajv on every valid-path benchmark. 2.7x faster validate(obj), 151x faster compilation, simdjson + multi-core.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/ata-core/fastify-ata#readme",
   "dependencies": {
-    "ata-validator": "^0.4.9",
+    "ata-validator": "^0.4.10",
     "fastify-plugin": "^5.1.0",
     "sanitize-filename": "^1.6.4"
   },

package/standalone.js

@@ -0,0 +1,94 @@
+'use strict'
+
+const { Validator } = require('ata-validator')
+
+// Fastify schemaController compatible standalone compiler.
+// Same API as @fastify/ajv-compiler/standalone — drop-in replacement.
+//
+// WRITE mode (build phase):
+//   const { StandaloneValidator } = require('fastify-ata/standalone')
+//   buildValidator: StandaloneValidator({
+//     readMode: false,
+//     storeFunction(routeOpts, code) { fs.writeFileSync(fileName, code) }
+//   })
+//
+// READ mode (startup):
+//   buildValidator: StandaloneValidator({
+//     readMode: true,
+//     restoreFunction(routeOpts) { return require(fileName) }
+//   })
+
+function StandaloneValidator(options = { readMode: true }) {
+  if (options.readMode === true && !options.restoreFunction) {
+    throw new Error('You must provide a restoreFunction when readMode is true')
+  }
+  if (options.readMode !== true && !options.storeFunction) {
+    throw new Error('You must provide a storeFunction when readMode is false')
+  }
+
+  if (options.readMode === true) {
+    // READ MODE: load pre-compiled validator from file
+    return function wrapper() {
+      return function buildValidatorFunction(opts) {
+        const mod = options.restoreFunction(opts)
+        // mod is either a function (standalone) or { boolFn, hybridFactory, errFn }
+        if (typeof mod === 'function') {
+          // Direct function — just wrap for Fastify
+          return wrapValidator(mod)
+        }
+        // Module from toStandalone() — restore via fromStandalone
+        if (mod.boolFn || mod.hybridFactory) {
+          const v = Validator.fromStandalone(mod, opts.schema)
+          return wrapValidator((data) => v.validate(data))
+        }
+        // Fallback: compile fresh
+        const v = new Validator(opts.schema)
+        return wrapValidator((data) => v.validate(data))
+      }
+    }
+  }
+
+  // WRITE MODE: compile schema, generate standalone code, store to file
+  return function wrapper() {
+    return function buildValidatorFunction(opts) {
+      const v = new Validator(opts.schema)
+      const standalone = v.toStandalone()
+
+      if (standalone) {
+        options.storeFunction(opts, standalone)
+      }
+
+      return wrapValidator((data) => v.validate(data))
+    }
+  }
+}
+
+function wrapValidator(validateFn) {
+  // Fastify expects: return true on valid, return false on invalid.
+  // On invalid, validate.errors must contain ajv-compatible error objects.
+  function validate(data) {
+    const result = validateFn(data)
+    if (result && result.valid !== undefined) {
+      if (result.valid) {
+        validate.errors = null
+        return true
+      }
+      validate.errors = result.errors.map(e => ({
+        message: e.message,
+        instancePath: e.path || '',
+        schemaPath: '',
+        keyword: e.code || 'validation',
+        params: {},
+      }))
+      return false
+    }
+    // Boolean result
+    if (result) { validate.errors = null; return true }
+    validate.errors = [{ message: 'validation failed', instancePath: '', schemaPath: '', keyword: 'validation', params: {} }]
+    return false
+  }
+  validate.errors = null
+  return validate
+}
+
+module.exports = StandaloneValidator