@kaiko.io/rescript-deser 6.0.0 → 7.0.0-alpha.1

package/src/Deser.res

@@ -26,7 +26,7 @@ exception TypeError(string)
 module type Deserializer = {
   type t
   let name: string
-  let fromJSON: Js.Json.t => result<t, string>
+  let fromJSON: JSON.t => result<t, string>
   let checkFieldsSanity: unit => result<unit, string>
 }
 
@@ -39,11 +39,11 @@ module Field = {
     | Float
     | Boolean
     | Array(t)
-    /// These SHOULD strings in ISO format, but we only validate the string
-    /// can be represented in Js.Date without spewing NaN all over the place;
-    /// Js.Date.fromString("xxx") returns an object that is mostly unusable.
+    // These SHOULD strings in ISO format, but we only validate the string
+    // can be represented in Js.Date without spewing NaN all over the place;
+    // Js.Date.fromString("xxx") returns an object that is mostly unusable.
     ///
-    /// We also allow floats and then use Js.Date.fromFloat.
+    // We also allow floats and then use Date.fromTime
     | Date
     | Datetime // alias of Date
 
@@ -51,17 +51,17 @@ module Field = {
     | Object(array<(string, t)>)
     | Optional(t)
     | OptionalWithDefault(t, FieldValue.t)
-    /// An arbitrary mapping from names to other arbitrary fields.  The
-    /// difference with Object, is that you don't know the names of the
-    /// expected entries.
+    // An arbitrary mapping from names to other arbitrary fields.  The
+    // difference with Object, is that you don't know the names of the
+    // expected entries.
     | Mapping(t)
 
     | Deserializer(module(Deserializer))
 
-    /// A specialized Array of deserialized items that ignores unparsable
-    /// items and returns the valid collection.  This saves the user from
-    /// writing 'Array(DefaultWhenInvalid(Optional(Deserializer(module(M)))))'
-    /// and then post-process the list of items with 'Array.keepSome'
+    // A specialized Array of deserialized items that ignores unparsable
+    // items and returns the valid collection.  This saves the user from
+    // writing 'Array(DefaultWhenInvalid(Optional(Deserializer(module(M)))))'
+    // and then post-process the list of items with 'Array.keepSome'
     | Collection(module(Deserializer))
     | DefaultWhenInvalid(t, FieldValue.t)
 
@@ -135,20 +135,20 @@ module Field = {
     | DefaultWhenInvalid(t, _) => `Protected ${t->toString}`
     }
 
-  let _taggedToString = (tagged: Js.Json.tagged_t) => {
+  let _taggedToString = (tagged: JSON.t) => {
     switch tagged {
-    | Js.Json.JSONFalse => "Boolean(false)"
-    | Js.Json.JSONTrue => "Boolean(true)"
-    | Js.Json.JSONNull => "Null"
-    | Js.Json.JSONString(text) => `String("${text}")`
-    | Js.Json.JSONNumber(number) => `Number(${number->Float.toString})`
-    | Js.Json.JSONObject(obj) => `Object(${obj->Js.Json.stringifyAny->Option.getOr("...")})`
-    | Js.Json.JSONArray(array) => `Array(${array->Js.Json.stringifyAny->Option.getOr("...")})`
+    | Boolean(false) => "Boolean(false)"
+    | Boolean(true) => "Boolean(true)"
+    | Null => "Null"
+    | String(text) => `String("${text}")`
+    | Number(number) => `Number(${number->Float.toString})`
+    | Object(obj) => `Object(${obj->JSON.stringifyAny->Option.getOr("...")})`
+    | Array(array) => `Array(${array->JSON.stringifyAny->Option.getOr("...")})`
     }
   }
 
   let rec extractValue = (
-    values: Dict.t<Js.Json.t>,
+    values: Dict.t<JSON.t>,
     field: string,
     shape: t,
     self: t,
@@ -157,28 +157,30 @@ module Field = {
     | Some(value) => value->fromUntagged(shape, self)
     | None =>
       switch shape {
-      | DefaultWhenInvalid(_, _) => Js.Json.null->fromUntagged(shape, self)
-      | Optional(_) => Js.Json.null->fromUntagged(shape, self)
+      | DefaultWhenInvalid(_, _) => JSON.Null->fromUntagged(shape, self)
+      | Optional(_) => JSON.Null->fromUntagged(shape, self)
       | OptionalWithDefault(_, default) => default
       | _ => raise(TypeError(`Missing non-optional field '${field}'`))
       }
     }
   }
-  and fromUntagged = (untagged: Js.Json.t, shape: t, self: t): FieldValue.t => {
-    switch (shape, untagged->Js.Json.classify) {
+  and fromUntagged: (JSON.t, t, t) => FieldValue.t = (untagged, shape, self) => {
+    switch (shape, untagged) {
     | (Any, _) => untagged->FieldValue.any
-    | (Literal(expected), Js.Json.JSONString(text)) =>
-      if text == expected {
-        FieldValue.string(text)
-      } else {
-        raise(TypeError(`Expecting literal ${expected}, got ${text}`))
-      }
-    | (String, Js.Json.JSONString(text)) => FieldValue.string(text)
-    | (Int, Js.Json.JSONNumber(number)) => FieldValue.int(number->Float.toInt)
-    | (Float, Js.Json.JSONNumber(number)) => FieldValue.float(number)
-    | (Boolean, Js.Json.JSONTrue) => FieldValue.boolean(true)
-    | (Boolean, Js.Json.JSONFalse) => FieldValue.boolean(false)
-    | (Tuple(bases), Js.Json.JSONArray(items)) => {
+
+    | (Literal(expected), String(text)) if text == expected => FieldValue.string(text)
+    | (Literal(expected), String(text)) =>
+      raise(TypeError(`Expecting literal ${expected}, got ${text}`))
+
+    | (String, String(text)) => FieldValue.string(text)
+
+    | (Int, Number(number)) => FieldValue.int(number->Float.toInt)
+
+    | (Float, Number(number)) => FieldValue.float(number)
+
+    | (Boolean, Boolean(v)) => FieldValue.boolean(v)
+
+    | (Tuple(bases), Array(items)) => {
         let lenbases = bases->Array.length
         let lenitems = items->Array.length
         if lenbases == lenitems {
@@ -191,52 +193,56 @@ module Field = {
         }
       }
 
-    | (Datetime, Js.Json.JSONString(s))
-    | (Date, Js.Json.JSONString(s)) => {
-        let r = Js.Date.fromString(s)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${s}`))
-        }
-        r->FieldValue.any
+    | (Datetime | Date, String(s)) =>
+      let r = Date.fromString(s)
+      if r->Date.getDate->Int.toFloat->Float.isNaN {
+        raise(TypeError(`Invalid date ${s}`))
       }
+      r->FieldValue.any
 
-    | (Datetime, Js.Json.JSONNumber(f))
-    | (Date, Js.Json.JSONNumber(f)) => {
-        let r = Js.Date.fromFloat(f)
-        if r->Js.Date.getDate->Js.Float.isNaN {
-          raise(TypeError(`Invalid date ${f->Js.Float.toString}`))
-        }
-        r->FieldValue.any
+    | (Datetime | Date, Number(f)) =>
+      let r = Date.fromTime(f)
+      if r->Date.getDate->Int.toFloat->Float.isNaN {
+        raise(TypeError(`Invalid date ${f->Float.toString}`))
       }
+      r->FieldValue.any
 
-    | (Array(shape), Js.Json.JSONArray(items)) =>
+    | (Array(shape), Array(items)) =>
       FieldValue.array(items->Array.map(item => item->fromUntagged(shape, self)))
-    | (Mapping(f), Js.Json.JSONObject(values)) =>
+
+    | (Mapping(f), Object(values)) =>
       values->Dict.mapValues(v => v->fromUntagged(f, self))->FieldValue.mapping
-    | (Object(fields), Js.Json.JSONObject(values)) =>
-      FieldValue.object(
-        fields
-        ->Array.map(((field, shape)) => {
-          let value = switch extractValue(values, field, shape, self) {
-          | value => value
-          | exception TypeError(msg) => raise(TypeError(`Field "${field}": ${msg}`))
-          }
-          (field, value)
-        })
-        ->Dict.fromArray,
-      )
 
-    | (OptionalWithDefault(_, value), Js.Json.JSONNull) => value
+    | (Object(fields), Object(values)) =>
+      fields
+      ->Array.map(((field, shape)) => {
+        let value = switch extractValue(values, field, shape, self) {
+        | value => value
+        | exception TypeError(msg) => raise(TypeError(`Field "${field}": ${msg}`))
+        }
+        (field, value)
+      })
+      ->Dict.fromArray
+      ->FieldValue.object
+
+    | (OptionalWithDefault(_, value), Null) => value
     | (OptionalWithDefault(shape, _), _) => untagged->fromUntagged(shape, self)
-    | (Optional(_), Js.Json.JSONNull) => FieldValue.null
+    | (Optional(_), Null) => FieldValue.null
     | (Optional(shape), _) => untagged->fromUntagged(shape, self)
     | (Morphism(shape, f), _) => untagged->fromUntagged(shape, self)->f->FieldValue.any
 
-    | (Collection(m), Js.Json.JSONArray(items)) => {
+    | (Collection(m), Array(items)) => {
         module M = unpack(m: Deserializer)
         items
         ->Array.map(M.fromJSON)
-        ->Array.filter(x => x->Result.isOk)
+        ->Array.filterMap(x =>
+          switch x {
+          | Ok(v) => Some(v)
+          | Error(msg) =>
+            Console.warn3(__MODULE__, "Could not deserialize value in the collection", msg)
+            None
+          }
+        )
         ->Array.map(FieldValue.any)
         ->FieldValue.array
       }
@@ -253,7 +259,7 @@ module Field = {
       switch untagged->fromUntagged(t, self) {
       | res => res
       | exception TypeError(msg) => {
-          Js.Console.warn2("Detected and ignore (with default): ", msg)
+          Console.warn2("Detected and ignore (with default): ", msg)
           default
         }
       }
@@ -296,8 +302,8 @@ module Field = {
       )
       ->Result.map(_ => ())
 
-    /// Mappings and arrays can be empty, so their payloads are
-    /// automatically optional.
+    // Mappings and arrays can be empty, so their payloads are
+    // automatically optional.
     | (Mapping(field), _) | (Array(field), _) => checkFieldsSanity(name, field, true)
 
     | (Tuple(fields), optional) =>
@@ -335,8 +341,8 @@ module MakeDeserializer = (S: Serializable): (Deserializer with type t = S.t) =>
   ")
   let checkFieldsSanity = () => Field.checkFieldsSanity(name, fields, false)
 
-  @doc("Parse a `Js.Json.t` into `result<t, string>`")
-  let fromJSON = (json: Js.Json.t): result<t, _> => {
+  @doc("Parse a `'a` into `result<t, string>`")
+  let fromJSON: JSON.t => result<t, _> = json => {
     switch json->Field.fromUntagged(fields, fields) {
     | res => Ok(res->_toNativeType)
     | exception TypeError(e) => Error(e)

package/tests/index.res

@@ -4,7 +4,7 @@ open RescriptCore
 module Appointment = {
   type t = {
     note: string,
-    date: Js.Date.t,
+    date: Date.t,
     extra: option<string>,
   }
   module Deserializer = Deser.MakeDeserializer({
@@ -21,7 +21,7 @@ module_("Basic deserializer", _ => {
       %raw(`{"note": "Bicentennial doctor's appointment", "date": "2100-01-01"}`),
       {
         note: "Bicentennial doctor's appointment",
-        date: Js.Date.fromString("2100-01-01"),
+        date: Date.fromString("2100-01-01"),
         extra: None,
       },
     ),
@@ -33,7 +33,7 @@ module_("Basic deserializer", _ => {
     }`),
       {
         note: "Bicentennial doctor's appointment",
-        date: Js.Date.fromString("2100-01-01"),
+        date: Date.fromString("2100-01-01"),
         extra: Some("Don't take your stop-aging pills the night before the appointment"),
       },
     ),
@@ -43,10 +43,10 @@ module_("Basic deserializer", _ => {
     qunit->expect(valid->Array.length)
     valid->Array.forEach(
       ((data, expected)) => {
-        Js.Console.log2("Running sample", data)
+        Console.log2("Running sample", data)
         switch Appointment.Deserializer.fromJSON(data) {
         | Ok(result) => qunit->deepEqual(result, expected, "result == expected")
-        | Error(msg) => Js.Console.error(msg)
+        | Error(msg) => Console.error(msg)
         }
       },
     )
@@ -63,11 +63,11 @@ module_("Basic deserializer", _ => {
     qunit->expect(invalid->Array.length)
     invalid->Array.forEach(
       ((message, data)) => {
-        Js.Console.log3("Running sample", message, data)
+        Console.log3("Running sample", message, data)
         switch Appointment.Deserializer.fromJSON(data) {
-        | Ok(result) => Js.Console.error2("Invalid being accepted: ", result)
+        | Ok(result) => Console.error2("Invalid being accepted: ", result)
         | Error(msg) => {
-            Js.Console.log2("Correctly detected:", msg)
+            Console.log2("Correctly detected:", msg)
             qunit->ok(true, true)
           }
         }
@@ -147,10 +147,10 @@ module_("Recursive deserializer", _ => {
     qunit->expect(valid->Array.length)
     valid->Array.forEach(
       ((data, expected)) => {
-        Js.Console.log2("Running sample", data)
+        Console.log2("Running sample", data)
         switch TrivialTree.Deserializer.fromJSON(data) {
         | Ok(result) => qunit->deepEqual(result, expected, "result == expected")
-        | Error(msg) => Js.Console.error(msg)
+        | Error(msg) => Console.error(msg)
         }
       },
     )

package/tests/run-tests.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+/**
+ * Automated test runner for rescript-deser using Playwright
+ *
+ * This script starts a Vite dev server, runs QUnit tests in a headless browser,
+ * and reports the results to the console.
+ */
+
+const { chromium } = require('@playwright/test');
+const { spawn } = require('child_process');
+const http = require('http');
+
+const TEST_PORT = process.env.TEST_PORT || 4370;
+const TEST_URL = `http://localhost:${TEST_PORT}`;
+const STARTUP_TIMEOUT = 30000; // 30 seconds for server startup
+const TEST_TIMEOUT = 120000; // 2 minutes for all tests to complete
+
+async function waitForServer(url, timeout) {
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+        try {
+            await new Promise((resolve, reject) => {
+                const req = http.get(url, (res) => {
+                    resolve();
+                });
+                req.on('error', reject);
+                req.setTimeout(1000);
+            });
+            return true;
+        } catch (err) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    }
+
+    throw new Error(`Server did not start within ${timeout}ms`);
+}
+
+async function runTests() {
+    let viteProcess = null;
+    let browser = null;
+    let exitCode = 1;
+
+    try {
+        // Start Vite dev server
+        console.log(`Starting Vite server on port ${TEST_PORT}...`);
+        viteProcess = spawn('npx', ['vite', '--port', String(TEST_PORT), '--strictPort'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env }
+        });
+
+        // Capture server output for debugging
+        viteProcess.stdout.on('data', (data) => {
+            if (process.env.DEBUG) {
+                console.log('[vite]', data.toString());
+            }
+        });
+
+        viteProcess.stderr.on('data', (data) => {
+            if (process.env.DEBUG) {
+                console.error('[vite error]', data.toString());
+            }
+        });
+
+        // Wait for server to be ready
+        console.log('Waiting for server to start...');
+        await waitForServer(TEST_URL, STARTUP_TIMEOUT);
+        console.log('Server is ready!');
+
+        // Launch browser
+        console.log('Launching browser...');
+        browser = await chromium.launch({
+            headless: true,
+        });
+
+        const context = await browser.newContext();
+        const page = await context.newPage();
+
+        // Set up console message handling to show test output
+        page.on('console', msg => {
+            const type = msg.type();
+            if (process.env.DEBUG) {
+                console.log(`[browser ${type}]`, msg.text());
+            }
+        });
+
+        // Navigate to test page
+        console.log(`Navigating to ${TEST_URL}...`);
+        await page.goto(TEST_URL, { waitUntil: 'networkidle' });
+
+        // Wait for QUnit to complete and get results
+        console.log('Running tests...\n');
+        const results = await page.waitForFunction(
+            () => {
+                if (typeof QUnit !== 'undefined' && QUnit.config && QUnit.config.stats) {
+                    const done = QUnit.config.current === null || QUnit.config.current === undefined;
+                    if (done) {
+                        return {
+                            passed: QUnit.config.stats.all - QUnit.config.stats.bad,
+                            failed: QUnit.config.stats.bad,
+                            total: QUnit.config.stats.all,
+                            runtime: QUnit.config.stats.runtime
+                        };
+                    }
+                }
+                return false;
+            },
+            { timeout: TEST_TIMEOUT }
+        );
+
+        const testResults = await results.jsonValue();
+
+        // Print results
+        console.log('========================================');
+        console.log('           Test Results');
+        console.log('========================================');
+        console.log(`Total:   ${testResults.total}`);
+        console.log(`Passed:  ${testResults.passed} ✓`);
+        console.log(`Failed:  ${testResults.failed} ${testResults.failed > 0 ? '✗' : ''}`);
+        console.log(`Runtime: ${testResults.runtime}ms`);
+        console.log('========================================');
+
+        if (testResults.failed > 0) {
+            // Get detailed failure information
+            const failures = await page.evaluate(() => {
+                const failedTests = [];
+                const testItems = document.querySelectorAll('#qunit-tests > li.fail');
+
+                testItems.forEach(item => {
+                    const testName = item.querySelector('.test-name')?.textContent || 'Unknown test';
+                    const moduleName = item.querySelector('.module-name')?.textContent || '';
+                    const assertions = [];
+
+                    item.querySelectorAll('.fail').forEach(assertion => {
+                        const message = assertion.querySelector('.test-message')?.textContent || '';
+                        const expected = assertion.querySelector('.test-expected')?.textContent || '';
+                        const actual = assertion.querySelector('.test-actual')?.textContent || '';
+
+                        assertions.push({ message, expected, actual });
+                    });
+
+                    failedTests.push({ module: moduleName, test: testName, assertions });
+                });
+
+                return failedTests;
+            });
+
+            console.log('\nFailed Tests:');
+            failures.forEach((failure, index) => {
+                console.log(`\n${index + 1}. ${failure.module ? failure.module + ' > ' : ''}${failure.test}`);
+                failure.assertions.forEach(assertion => {
+                    if (assertion.message) console.log(`   ${assertion.message}`);
+                    if (assertion.expected) console.log(`   Expected: ${assertion.expected}`);
+                    if (assertion.actual) console.log(`   Actual: ${assertion.actual}`);
+                });
+            });
+
+            exitCode = 1;
+        } else {
+            console.log('\n✓ All tests passed!');
+            exitCode = 0;
+        }
+
+    } catch (error) {
+        console.error('\n✗ Test run failed:');
+        console.error(error.message);
+        exitCode = 1;
+    } finally {
+        // Cleanup
+        if (browser) {
+            await browser.close();
+        }
+
+        if (viteProcess) {
+            viteProcess.kill('SIGTERM');
+            // Give it a moment to shut down gracefully
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            if (!viteProcess.killed) {
+                viteProcess.kill('SIGKILL');
+            }
+        }
+    }
+
+    process.exit(exitCode);
+}
+
+// Run the tests
+runTests().catch(err => {
+    console.error('Unexpected error:', err);
+    process.exit(1);
+});