[sveltekit] Refactor form data entry converter

Author: x0k

.changeset/real-flowers-bathe.md

@@ -0,0 +1,5 @@
+---
+"@sjsf/sveltekit": major
+---
+
+Refactor form data entry converter

packages/sveltekit/src/lib/server/convert-form-data-entries.test.ts renamed to packages/sveltekit/src/lib/server/convert-form-data-entry.test.ts

@@ -1,13 +1,12 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import type { Schema } from '@sjsf/form/core';
+import type { RPath, Schema } from '@sjsf/form/core';
 import { createMerger } from '@sjsf/form/mergers/modern';
 import { createFormValidator } from '@sjsf/ajv8-validator';
 
 import {
-  createFormDataEntriesConverter,
+  createFormDataEntryConverter,
   type FormDataConverterOptions
-} from './convert-form-data-entries.js';
-import type { Entries } from './entry.js';
+} from './convert-form-data-entry.js';
 
 const defaultOptions: FormDataConverterOptions = {
   validator: createFormValidator(),
@@ -16,7 +15,7 @@ const defaultOptions: FormDataConverterOptions = {
   rootUiSchema: {}
 };
 
-const convert = createFormDataEntriesConverter(defaultOptions);
+const convert = createFormDataEntryConverter(defaultOptions);
 
 describe('convertFormDataEntries', async () => {
   let c: AbortController;
@@ -32,45 +31,48 @@ describe('convertFormDataEntries', async () => {
           type: ['string', 'null']
         },
         uiSchema: {},
-        entries: []
+        path: [],
+        value: undefined
       })
     ).toBeNull();
   });
   it('Should convert boolean', async () => {
     const schema: Schema = { title: 'A boolean', type: 'boolean', default: false };
-    const entries: Entries<string> = [['root.fixedNoToolbar.1', 'on']];
-    await expect(convert(c.signal, { schema, uiSchema: {}, entries })).resolves.toEqual(true);
+    await expect(
+      convert(c.signal, { schema, uiSchema: {}, path: ['fixedNoToolbar', 1], value: 'on' })
+    ).resolves.toEqual(true);
   });
   it('Should convert number', async () => {
     const schema: Schema = { title: 'A number', type: 'number', default: 42 };
-    const entries: Entries<string> = [['root.fixedNoToolbar.0', '42']];
-    await expect(convert(c.signal, { schema, uiSchema: {}, entries })).resolves.toEqual(42);
+    await expect(
+      convert(c.signal, { schema, uiSchema: {}, path: ['fixedNoToolbar', 0], value: '42' })
+    ).resolves.toEqual(42);
   });
   it('Should convert enum value', async () => {
     const schema: Schema = {
       type: 'string',
       enum: ['foo', 'bar', 'baz']
     };
-    const entries: Entries<string> = [['root', 'bar']];
-    await expect(convert(c.signal, { schema, uiSchema: {}, entries })).resolves.toEqual('bar');
+    await expect(
+      convert(c.signal, { schema, uiSchema: {}, path: [], value: 'bar' })
+    ).resolves.toEqual('bar');
   });
   it('Should return correct value from enum of string numbers', async () => {
     const schema: Schema = {
       type: 'string',
       enum: ['1', '2', '3']
     };
+    const path: RPath = [];
     // First, the value is treated as an index
-    await expect(
-      convert(c.signal, { schema, uiSchema: {}, entries: [['root', '0']] })
-    ).resolves.toEqual('1');
+    await expect(convert(c.signal, { schema, uiSchema: {}, path, value: '0' })).resolves.toEqual(
+      '1'
+    );
     // Then we check if there is a value in the enumeration
-    await expect(
-      convert(c.signal, { schema, uiSchema: {}, entries: [['root', '3']] })
-    ).resolves.toEqual('3');
+    await expect(convert(c.signal, { schema, uiSchema: {}, path, value: '3' })).resolves.toEqual(
+      '3'
+    );
     // If nothing fits, it's an error
-    await expect(
-      convert(c.signal, { schema, uiSchema: {}, entries: [['root', '4']] })
-    ).rejects.toThrow();
+    await expect(convert(c.signal, { schema, uiSchema: {}, path, value: '4' })).rejects.toThrow();
   });
   it('Should return correct value from anyOf', async () => {
     const schema: Schema = {
@@ -94,8 +96,9 @@ describe('convertFormDataEntries', async () => {
         }
       ]
     };
-    const entries: Entries<string> = [['root.currentColor', '1']];
-    await expect(convert(c.signal, { schema, uiSchema: {}, entries })).resolves.toEqual('#00ff00');
+    await expect(
+      convert(c.signal, { schema, uiSchema: {}, path: ['currentColor'], value: '1' })
+    ).resolves.toEqual('#00ff00');
   });
   it('Should return correct value from oneOf', async () => {
     const schema: Schema = {
@@ -106,12 +109,14 @@ describe('convertFormDataEntries', async () => {
         { title: 'Disable', const: false }
       ]
     };
-    const entries: Entries<string> = [['root.toggleMask', '0']];
-    await expect(convert(c.signal, { schema, uiSchema: {}, entries })).resolves.toEqual(true);
+    await expect(
+      convert(c.signal, { schema, uiSchema: {}, path: ['toggleMask'], value: '0' })
+    ).resolves.toEqual(true);
   });
   it('Should return correct value from enum', async () => {
     const schema: Schema = { type: 'string', enum: ['foo', 'bar', 'fuzz', 'qux'] };
-    const entries: Entries<string> = [['root.multipleChoicesList', '1']];
-    await expect(convert(c.signal, { schema, uiSchema: {}, entries })).resolves.toEqual('bar');
+    await expect(
+      convert(c.signal, { schema, uiSchema: {}, path: ['multipleChoicesList'], value: '1' })
+    ).resolves.toEqual('bar');
   });
 });

packages/sveltekit/src/lib/server/convert-form-data-entries.ts renamed to packages/sveltekit/src/lib/server/convert-form-data-entry.ts

@@ -10,12 +10,10 @@ import {
 } from '@sjsf/form/core';
 import { DEFAULT_BOOLEAN_ENUM, type FieldValue, type Schema, type UiSchemaRoot } from '@sjsf/form';
 
-import type { EntriesConverter, EntriesConverterOptions } from './entry.js';
+import type { EntryConverter, EntryConverterOptions } from './entry.js';
 
 export type UnknownEntryConverter = (
-  key: string,
-  value: string,
-  options: EntriesConverterOptions<FormDataEntryValue>
+  options: EntryConverterOptions<FormDataEntryValue>
 ) => Promise<FieldValue> | FieldValue;
 export interface FormDataConverterOptions {
   validator: Validator;
@@ -27,27 +25,26 @@ export interface FormDataConverterOptions {
 
 const DEFAULT_BOOLEAN_ENUM_KEYS_SET = new Set(Object.keys(DEFAULT_BOOLEAN_ENUM));
 
-export function createFormDataEntriesConverter({
+export function createFormDataEntryConverter({
   validator,
   merger,
   rootSchema,
   rootUiSchema,
   convertUnknownEntry
-}: FormDataConverterOptions): EntriesConverter<FormDataEntryValue> {
+}: FormDataConverterOptions): EntryConverter<FormDataEntryValue> {
   return async (signal, options) => {
-    const { entries, schema, uiSchema } = options;
+    const { value, schema, uiSchema } = options;
     if (typeof schema === 'boolean') {
-      return schema ? (entries[0]?.[1] as FieldValue) : undefined;
+      return schema ? (value as FieldValue) : undefined;
     }
     const typeOrTypes = typeOfSchema(schema);
     const type = Array.isArray(typeOrTypes) ? pickSchemaType(typeOrTypes) : typeOrTypes;
-    if (entries.length === 0) {
+    if (value === undefined) {
       if (type === 'boolean') {
         return false;
       }
       return isNullableSchemaType(typeOrTypes) ? null : undefined;
     }
-    const value = entries[0][1];
     if (value instanceof File) {
       if (value.name === '' && value.size === 0) {
         return undefined;
@@ -84,7 +81,7 @@ export function createFormDataEntriesConverter({
       throw new Error(`Value "${value}" does not match the schema: ${JSON.stringify(schema)}`);
     }
     if (type === 'unknown' && convertUnknownEntry) {
-      return await convertUnknownEntry(entries[0][0], value, options);
+      return await convertUnknownEntry(options);
     }
     switch (type) {
       case 'string':

packages/sveltekit/src/lib/server/entry.ts

@@ -1,18 +1,19 @@
 import type { MaybePromise } from '@sjsf/form/lib/types';
-import type { SchemaDefinition, SchemaValue } from '@sjsf/form/core';
+import type { RPath, SchemaDefinition, SchemaValue } from '@sjsf/form/core';
 import type { UiSchema } from '@sjsf/form';
 
 export type Entry<T> = [key: string, value: T];
 
 export type Entries<T> = Entry<T>[];
 
-export interface EntriesConverterOptions<T> {
+export interface EntryConverterOptions<T> {
   schema: SchemaDefinition;
   uiSchema: UiSchema;
-  entries: Entries<T>;
+  path: RPath;
+  value: T | undefined;
 }
 
-export type EntriesConverter<T> = (
+export type EntryConverter<T> = (
   signal: AbortSignal,
-  options: EntriesConverterOptions<T>
+  options: EntryConverterOptions<T>
 ) => MaybePromise<SchemaValue | undefined>;

packages/sveltekit/src/lib/server/index.ts

@@ -1,5 +1,5 @@
 export * from './entry.js';
 export * from './server.js';
-export * from './convert-form-data-entries.js';
+export * from './convert-form-data-entry.js';
 export * from './schema-value-parser.js';
 export * from './id-prefix-parser.js';

packages/sveltekit/src/lib/server/schema-value-parser.test.ts

@@ -5,7 +5,7 @@ import { createFormValidator } from '@sjsf/ajv8-validator';
 
 import type { Entries } from './entry.js';
 import { parseSchemaValue, type SchemaValueParserOptions } from './schema-value-parser.js';
-import { createFormDataEntriesConverter } from './convert-form-data-entries.js';
+import { createFormDataEntryConverter } from './convert-form-data-entry.js';
 
 const opts = ({
   schema = {},
@@ -17,7 +17,7 @@ const opts = ({
   idPseudoSeparator = '::',
   validator = createFormValidator(),
   merger = createMerger(),
-  convertEntries = createFormDataEntriesConverter({
+  convertEntry: convertEntry = createFormDataEntryConverter({
     merger,
     validator,
     rootSchema: schema,
@@ -35,7 +35,7 @@ const opts = ({
   idPseudoSeparator,
   validator,
   merger,
-  convertEntries
+  convertEntry: convertEntry
 });
 
 describe('parseSchemaValue', async () => {