feat: add support for convertEmptyStringsToNull

Author: thetutlage

factories/output.ts

@@ -8,17 +8,18 @@
  */
 
 import { EOL } from 'node:os'
+import type { CompilerOptions } from '../src/types.js'
 import { defineInlineErrorMessages } from '../src/scripts/define_error_messages.js'
 import { defineInlineFunctions } from '../src/scripts/define_inline_functions.js'
 
 /**
  * Returns code for the initial output
  */
-export function getInitialOutput() {
+export function getInitialOutput(options?: CompilerOptions) {
   return [
     `async function anonymous(root,meta,refs,errorReporter) {`,
     ...defineInlineErrorMessages().split(EOL),
-    ...defineInlineFunctions().split(EOL),
+    ...defineInlineFunctions(options || { convertEmptyStringsToNull: false }).split(EOL),
     'let out;',
   ]
 }

src/compiler/main.ts

@@ -27,6 +27,7 @@ import type {
   CompilerField,
   CompilerNodes,
   CompilerParent,
+  CompilerOptions,
   ErrorReporterContract,
 } from '../types.js'
 import { TupleNodeCompiler } from './nodes/tuple.js'
@@ -52,21 +53,27 @@ export class Compiler {
    */
   #rootNode: RootNode
 
+  /**
+   * Options to configure the compiler behavior
+   */
+  #options: CompilerOptions
+
   /**
    * Buffer for collection the JS output string
    */
   #buffer: CompilerBuffer = new CompilerBuffer()
 
-  constructor(rootNode: RootNode) {
+  constructor(rootNode: RootNode, options?: CompilerOptions) {
     this.#rootNode = rootNode
+    this.#options = options || { convertEmptyStringsToNull: false }
   }
 
   /**
    * Initiates the JS output
    */
   #initiateJSOutput() {
     this.#buffer.writeStatement(defineInlineErrorMessages())
-    this.#buffer.writeStatement(defineInlineFunctions())
+    this.#buffer.writeStatement(defineInlineFunctions(this.#options))
     this.#buffer.writeStatement('let out;')
   }
 

src/scripts/define_inline_functions.ts

@@ -11,12 +11,13 @@
  * Returns JS fragment for inline function needed by the
  * validation runtime code.
  */
-export function defineInlineFunctions() {
+export function defineInlineFunctions(options: { convertEmptyStringsToNull: boolean }) {
   return `function report(message, ctx) {
   ctx.isValid = false;
   errorReporter.report(message, ctx.fieldPath);
 };
 function defineValue(value, ctx) {
+  ${options.convertEmptyStringsToNull ? `if (value === '') { value = null; }` : ''}
   ctx.value = value;
   ctx.isDefined = value !== undefined && value !== null;
   return ctx;

src/types.ts

@@ -485,3 +485,14 @@ export interface ErrorReporterContract {
    */
   report(message: string, ctx: FieldContext): any
 }
+
+/**
+ * Options accepted by the compiler
+ */
+export type CompilerOptions = {
+  /**
+   * Convert empty string values to null for sake of
+   * normalization
+   */
+  convertEmptyStringsToNull: boolean
+}

tests/integration/compiler/array_node.spec.ts

@@ -693,6 +693,48 @@ test.group('Array node', () => {
       assert.deepEqual(error.messages, ['ref://2 validation failed'])
     }
   })
+
+  test('convert empty string to null', async ({ assert }) => {
+    assert.plan(2)
+
+    const compiler = new Compiler(
+      {
+        type: 'root',
+        schema: {
+          type: 'array',
+          bail: true,
+          fieldName: '*',
+          validations: [],
+          propertyName: '*',
+          allowNull: false,
+          isOptional: false,
+          each: {
+            type: 'literal',
+            allowNull: false,
+            bail: true,
+            isOptional: false,
+            fieldName: '*',
+            propertyName: '*',
+            validations: [],
+          },
+        },
+      },
+      { convertEmptyStringsToNull: true }
+    )
+
+    const data: any = ''
+    const meta = {}
+    const refs = {}
+    const errorReporter = new ErrorReporterFactory().create()
+
+    const fn = compiler.compile()
+    try {
+      await fn(data, meta, refs, errorReporter)
+    } catch (error) {
+      assert.equal(error.message, 'Validation failure')
+      assert.deepEqual(error.messages, ['value is required'])
+    }
+  })
 })
 
 test.group('Array node | optional: true', () => {
@@ -837,6 +879,42 @@ test.group('Array node | optional: true', () => {
       assert.deepEqual(error.messages, ['value is not a valid array'])
     }
   })
+
+  test('convert empty string to null', async ({ assert }) => {
+    const compiler = new Compiler(
+      {
+        type: 'root',
+        schema: {
+          type: 'array',
+          bail: true,
+          fieldName: '*',
+          validations: [],
+          propertyName: '*',
+          allowNull: false,
+          isOptional: true,
+          each: {
+            type: 'literal',
+            allowNull: false,
+            bail: true,
+            isOptional: false,
+            fieldName: '*',
+            propertyName: '*',
+            validations: [],
+          },
+        },
+      },
+      { convertEmptyStringsToNull: true }
+    )
+
+    const data: any = ''
+    const meta = {}
+    const refs = {}
+    const errorReporter = new ErrorReporterFactory().create()
+
+    const fn = compiler.compile()
+    const output = await fn(data, meta, refs, errorReporter)
+    assert.isUndefined(output)
+  })
 })
 
 test.group('Array node | allowNull: true', () => {
@@ -981,4 +1059,40 @@ test.group('Array node | allowNull: true', () => {
       assert.deepEqual(error.messages, ['value is not a valid array'])
     }
   })
+
+  test('convert empty string to null', async ({ assert }) => {
+    const compiler = new Compiler(
+      {
+        type: 'root',
+        schema: {
+          type: 'array',
+          bail: true,
+          fieldName: '*',
+          validations: [],
+          propertyName: '*',
+          allowNull: true,
+          isOptional: false,
+          each: {
+            type: 'literal',
+            allowNull: false,
+            bail: true,
+            isOptional: false,
+            fieldName: '*',
+            propertyName: '*',
+            validations: [],
+          },
+        },
+      },
+      { convertEmptyStringsToNull: true }
+    )
+
+    const data: any = ''
+    const meta = {}
+    const refs = {}
+    const errorReporter = new ErrorReporterFactory().create()
+
+    const fn = compiler.compile()
+    const output = await fn(data, meta, refs, errorReporter)
+    assert.isNull(output)
+  })
 })

tests/integration/compiler/literal_node.spec.ts

@@ -460,6 +460,39 @@ test.group('Literal node', () => {
     const fn = compiler.compile()
     assert.deepEqual(await fn(data, meta, refs, errorReporter), 'VIRK')
   })
+
+  test('convert empty string to null', async ({ assert }) => {
+    assert.plan(2)
+
+    const compiler = new Compiler(
+      {
+        type: 'root',
+        schema: {
+          type: 'literal',
+          bail: true,
+          fieldName: '*',
+          validations: [],
+          propertyName: '*',
+          allowNull: false,
+          isOptional: false,
+        },
+      },
+      { convertEmptyStringsToNull: true }
+    )
+
+    const data = ''
+    const meta = {}
+    const refs = {}
+    const errorReporter = new ErrorReporterFactory().create()
+
+    const fn = compiler.compile()
+    try {
+      await fn(data, meta, refs, errorReporter)
+    } catch (error) {
+      assert.equal(error.message, 'Validation failure')
+      assert.deepEqual(error.messages, ['value is required'])
+    }
+  })
 })
 
 test.group('Literal node | optional: true', () => {
@@ -738,6 +771,33 @@ test.group('Literal node | optional: true', () => {
     const output = await fn(data, meta, refs, errorReporter)
     assert.deepEqual(output, undefined)
   })
+
+  test('convert empty string to null', async ({ assert }) => {
+    const compiler = new Compiler(
+      {
+        type: 'root',
+        schema: {
+          type: 'literal',
+          bail: true,
+          fieldName: '*',
+          validations: [],
+          propertyName: '*',
+          allowNull: false,
+          isOptional: true,
+        },
+      },
+      { convertEmptyStringsToNull: true }
+    )
+
+    const data = ''
+    const meta = {}
+    const refs = {}
+    const errorReporter = new ErrorReporterFactory().create()
+
+    const fn = compiler.compile()
+    const output = await fn(data, meta, refs, errorReporter)
+    assert.isUndefined(output)
+  })
 })
 
 test.group('Literal node | allowNull: true', () => {
@@ -1023,4 +1083,31 @@ test.group('Literal node | allowNull: true', () => {
     const output = await fn(data, meta, refs, errorReporter)
     assert.deepEqual(output, null)
   })
+
+  test('convert empty string to null', async ({ assert }) => {
+    const compiler = new Compiler(
+      {
+        type: 'root',
+        schema: {
+          type: 'literal',
+          bail: true,
+          fieldName: '*',
+          validations: [],
+          propertyName: '*',
+          allowNull: true,
+          isOptional: false,
+        },
+      },
+      { convertEmptyStringsToNull: true }
+    )
+
+    const data = ''
+    const meta = {}
+    const refs = {}
+    const errorReporter = new ErrorReporterFactory().create()
+
+    const fn = compiler.compile()
+    const output = await fn(data, meta, refs, errorReporter)
+    assert.isNull(output)
+  })
 })