overtake 0.0.7 → 0.1.1

package/README.md

@@ -14,6 +14,7 @@ Performance benchmark for NodeJS
 - [Features](#features)
 - [Installing](#installing)
 - [Examples](#examples)
+- [Showcase](#showcase)
 - [License](#license)
 
 ## Features
@@ -125,6 +126,15 @@ npx overtake -i "class A{}" -i "function A() {}" -i "A = () => {};" -c 20000
 
 Please take a look at [benchmarks](__benchmarks__) to see more examples
 
+## Showcase
+
+Already measured performance
+
+- [Class vs Function](./overtakes/class-vs-function.md)
+- [Postgres vs MongoDB](./overtakes/postgres-vs-mongo.md)
+- [Array Copy](./overtakes/array-copy.md)
+- [Array Delete Element](./overtakes/array-delete-element.md)
+
 ## License
 
 License [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

package/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S node --no-warnings
 
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import Path from 'path';
-import glob from 'glob';
-import { load, createScript, benchmark, setup, teardown, measure, perform, run, defaultReporter } from './index.js';
+import { glob } from 'glob';
+import { load, createScript, benchmark, setup, teardown, measure, perform, run, defaultReporter, allowedFields } from './index.js';
 import packageJson from './package.json' assert { type: 'json' };
 
 const commands = new Command();
@@ -11,10 +11,23 @@ const commands = new Command();
 commands.name('overtake').description(packageJson.description).version(packageJson.version, '-v, --version');
 
 commands
-  .argument('[files...]', 'file paths or path patterns to search benchmark scripts')
-  .option('-i, --inline [inline]', 'inline code to benchmark', (value, previous) => previous.concat([value]), [])
-  .option('-c, --count [count]', 'perform count for inline code', (v) => parseInt(v))
-  .action(async (patterns, { count = 1, inline }) => {
+  .argument('[files...]', 'File paths or path patterns to search benchmark scripts')
+  .option('-i, --inline [inline]', 'Inline benchmark.', (value, previous) => previous.concat([value]), [])
+  .option('-c, --count [count]', 'Perform count for inline benchmark.', (v) => parseInt(v))
+  .addOption(
+    new Option('-f, --fields [fields]', `Comma separated list of fields to report. Allowed values are: ${allowedFields}.`)
+      .default(['med', 'p95', 'p99', 'sum:total', 'count'])
+      .argParser((fields) =>
+        fields.split(',').filter((field) => {
+          if (!allowedFields.includes(field)) {
+            console.error(`Invalid field name: ${field}. Allowed values are: ${allowedFields.join(', ')}.`);
+            process.exit(1);
+          }
+          return true;
+        }),
+      ),
+  )
+  .action(async (patterns, { count = 1, inline, fields }) => {
     Object.assign(globalThis, { benchmark, setup, teardown, measure, perform });
 
     const foundFiles = await glob(patterns);
@@ -43,7 +56,7 @@ commands
       scripts.push(script);
     }
 
-    await run(scripts, defaultReporter);
+    await run(scripts, defaultReporter, fields);
   });
 
 commands.on('--help', () => {

package/index.js

@@ -6,6 +6,32 @@ const suiteContext = createContext();
 
 export const NOOP = () => {};
 
+export const allowedFields = [
+  'mode',
+  'med',
+  'p1',
+  'p5',
+  'p10',
+  'p20',
+  'p33',
+  'p50',
+  'p66',
+  'p80',
+  'p90',
+  'p95',
+  'p99',
+  'min',
+  'max',
+  'avg',
+  'sum',
+  'count',
+  'setup',
+  'init',
+  'cycles',
+  'teardown',
+  'total',
+];
+
 export const setup = (fn) => {
   suiteContext.getContext().setup = fn;
 };
@@ -57,27 +83,25 @@ const map = {
   measure: '✓ Measure',
 };
 
-export const defaultReporter = async (type, title, test) => {
+export const defaultReporter = async (type, title, test, fields) => {
   console.group(`${map[type]} ${title}`);
   await test({
-    test: defaultReporter,
+    test: (...args) => defaultReporter(...args, fields),
     output: (report) =>
       console.table(
         report.success
           ? {
-              [formatFloat(report.mode)]: {
-                med: formatFloat(report.med),
-                p95: formatFloat(report.p95),
-                p99: formatFloat(report.p99),
-                total: formatFloat(report.sum),
-                count: report.count,
-              },
+              [formatFloat(report.mode)]: fields.reduce((data, field) => {
+                const [key, alias = key] = field.split(':');
+                data[alias] = formatFloat(report[key]);
+                return data;
+              }, {}),
             }
           : {
               error: {
                 reason: report.error,
               },
-            }
+            },
       ),
   });
   console.groupEnd();
@@ -88,31 +112,36 @@ export function formatFloat(value, digits = ACCURACY) {
   return parseFloat(value.toFixed(digits));
 }
 
-export const run = async (scripts, reporter) => {
+export const run = async (scripts, reporter, fields) => {
   for (const script of scripts) {
-    await reporter('script', script.filename, async (scriptTest) => {
-      for (const suite of script.suites) {
-        await scriptTest.test('suite', suite.title, async (suiteTest) => {
-          await suiteContext.contextualize(suite, suite.init);
-          for (const perform of suite.performs) {
-            await suiteTest.test('perform', perform.title, async (performTest) => {
-              for (const measure of suite.measures) {
-                await performTest.test('measure', perform.count + ' ' + measure.title, async (measureTest) => {
-                  const result = await runWorker({
-                    setup: suite.setup,
-                    teardown: suite.teardown,
-                    init: measure.init,
-                    count: perform.count,
-                    args: perform.args,
+    await reporter(
+      'script',
+      script.filename,
+      async (scriptTest) => {
+        for (const suite of script.suites) {
+          await scriptTest.test('suite', suite.title, async (suiteTest) => {
+            await suiteContext.contextualize(suite, suite.init);
+            for (const perform of suite.performs) {
+              await suiteTest.test('perform', perform.title, async (performTest) => {
+                for (const measure of suite.measures) {
+                  await performTest.test('measure', perform.count + ' ' + measure.title, async (measureTest) => {
+                    const result = await runWorker({
+                      setup: suite.setup,
+                      teardown: suite.teardown,
+                      init: measure.init,
+                      count: perform.count,
+                      args: perform.args,
+                    });
+                    measureTest.output(result);
                   });
-                  measureTest.output(result);
-                });
-              }
-            });
-          }
-        });
-      }
-    });
+                }
+              });
+            }
+          });
+        }
+      },
+      fields,
+    );
   }
 };
 

package/overtakes/array-copy.md

@@ -0,0 +1,80 @@
+# Array copy methods
+
+```
+⭐ Script  __benchmarks__/array-copy.js
+  ⇶ Suite  Array copy methods
+    ➤ Perform  10 elements
+      ✓ Measure 500000 slice
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000059 │ 0.000065 │ 0.000105 │ 0.000241 │ 50.160222 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 spread
+        ┌──────────┬──────────┬──────────┬──────────┬──────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │  total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼──────────┼────────┤
+        │ 0.000061 │ 0.000067 │ 0.000087 │ 0.000193 │ 44.70032 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴──────────┴────────┘
+      ✓ Measure 500000 concat
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000061 │ 0.000068 │ 0.000119 │ 0.000234 │ 40.695219 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 Array.from
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000065 │ 0.000072 │ 0.000126 │ 0.000237 │ 50.390629 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 for loop assign
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000066 │ 0.000071 │ 0.000126 │ 0.000287 │ 43.803009 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 for loop push
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000065 │ 0.000072 │ 0.000142 │ 0.000284 │ 43.769935 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+    ➤ Perform  1000 elements
+      ✓ Measure 500000 slice
+        ┌─────────┬──────────┬──────────┬──────────┬────────────┬────────┐
+        │ (index) │   med    │   p95    │   p99    │   total    │ count  │
+        ├─────────┼──────────┼──────────┼──────────┼────────────┼────────┤
+        │ 0.00011 │ 0.000182 │ 0.000371 │ 0.000601 │ 186.871627 │ 500000 │
+        └─────────┴──────────┴──────────┴──────────┴────────────┴────────┘
+      ✓ Measure 500000 spread
+        ┌──────────┬──────────┬──────────┬──────────┬────────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total    │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼────────────┼────────┤
+        │ 0.000113 │ 0.000186 │ 0.000362 │ 0.000577 │ 186.106348 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴────────────┴────────┘
+      ✓ Measure 500000 concat
+        ┌──────────┬──────────┬──────────┬──────────┬────────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total    │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼────────────┼────────┤
+        │ 0.000116 │ 0.000199 │ 0.000445 │ 0.000772 │ 204.249913 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴────────────┴────────┘
+      ✓ Measure 500000 Array.from
+        ┌──────────┬─────────┬──────────┬──────────┬────────────┬────────┐
+        │ (index)  │   med   │   p95    │   p99    │   total    │ count  │
+        ├──────────┼─────────┼──────────┼──────────┼────────────┼────────┤
+        │ 0.000113 │ 0.00019 │ 0.000347 │ 0.000564 │ 190.512575 │ 500000 │
+        └──────────┴─────────┴──────────┴──────────┴────────────┴────────┘
+      ✓ Measure 500000 for loop assign
+        ┌──────────┬──────────┬──────────┬─────────┬────────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99   │   total    │ count  │
+        ├──────────┼──────────┼──────────┼─────────┼────────────┼────────┤
+        │ 0.002016 │ 0.002428 │ 0.003344 │ 0.00437 │ 1477.99805 │ 500000 │
+        └──────────┴──────────┴──────────┴─────────┴────────────┴────────┘
+      ✓ Measure 500000 for loop push
+        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │    total    │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼─────────────┼────────┤
+        │ 0.002343 │ 0.002756 │ 0.003774 │ 0.006158 │ 1687.568837 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴─────────────┴────────┘
+```

package/overtakes/array-delete-element.md

@@ -0,0 +1,44 @@
+# Array delete element
+
+```
+⭐ Script  __benchmarks__/array-delete-element.js
+  ⇶ Suite  Array delete element methods
+    ➤ Perform  10 elements
+      ✓ Measure 500000 splice
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000072 │ 0.000078 │ 0.000121 │ 0.000248 │ 57.628642 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 filter
+        ┌──────────┬──────────┬─────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95   │   p99    │   total   │ count  │
+        ├──────────┼──────────┼─────────┼──────────┼───────────┼────────┤
+        │ 0.000067 │ 0.000077 │ 0.00018 │ 0.000303 │ 51.695539 │ 500000 │
+        └──────────┴──────────┴─────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 for loop
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.000064 │ 0.000074 │ 0.000119 │ 0.000307 │ 44.446428 │ 500000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+    ➤ Perform  1000 elements
+      ✓ Measure 500000 splice
+        ┌─────────┬──────────┬──────────┬──────────┬───────────┬────────┐
+        │ (index) │   med    │   p95    │   p99    │   total   │ count  │
+        ├─────────┼──────────┼──────────┼──────────┼───────────┼────────┤
+        │ 0.00007 │ 0.000076 │ 0.000121 │ 0.000268 │ 54.328497 │ 500000 │
+        └─────────┴──────────┴──────────┴──────────┴───────────┴────────┘
+      ✓ Measure 500000 filter
+        ┌──────────┬──────────┬──────────┬─────────┬────────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99   │   total    │ count  │
+        ├──────────┼──────────┼──────────┼─────────┼────────────┼────────┤
+        │ 0.002064 │ 0.002521 │ 0.003448 │ 0.00804 │ 1571.98239 │ 500000 │
+        └──────────┴──────────┴──────────┴─────────┴────────────┴────────┘
+      ✓ Measure 500000 for loop
+        ┌──────────┬──────────┬──────────┬─────────┬─────────────┬────────┐
+        │ (index)  │   med    │   p95    │   p99   │    total    │ count  │
+        ├──────────┼──────────┼──────────┼─────────┼─────────────┼────────┤
+        │ 0.002166 │ 0.002625 │ 0.003383 │ 0.00448 │ 1578.507514 │ 500000 │
+        └──────────┴──────────┴──────────┴─────────┴─────────────┴────────┘
+```

package/overtakes/async.md

@@ -0,0 +1,25 @@
+# Async functions call performance
+
+```
+⭐ Script  __benchmarks__/async.js
+  ⇶ Suite  Async functions performance
+    ➤ Perform  10000000 calls
+      ✓ Measure 10000000 calls of function that returns Promise.resolve()
+        ┌─────────┬──────────┬──────────┬─────────┬─────────────┬──────────┐
+        │ (index) │ med      │ p95      │ p99     │ total       │ count    │
+        ├─────────┼──────────┼──────────┼─────────┼─────────────┼──────────┤
+        │ 0.00008 │ 0.000093 │ 0.000138 │ 0.00023 │ 1189.475052 │ 10000000 │
+        └─────────┴──────────┴──────────┴─────────┴─────────────┴──────────┘
+      ✓ Measure 10000000 calls of async function that returns await Promise.resolve()
+        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬──────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total       │ count    │
+        ├──────────┼──────────┼──────────┼──────────┼─────────────┼──────────┤
+        │ 0.000108 │ 0.000122 │ 0.000267 │ 0.000389 │ 1735.581918 │ 10000000 │
+        └──────────┴──────────┴──────────┴──────────┴─────────────┴──────────┘
+      ✓ Measure 10000000 calls of async function that returns Promise.resolve()
+        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬──────────┐
+        │ (index)  │ med      │ p95      │ p99      │ total       │ count    │
+        ├──────────┼──────────┼──────────┼──────────┼─────────────┼──────────┤
+        │ 0.000105 │ 0.000125 │ 0.000203 │ 0.000333 │ 1557.773513 │ 10000000 │
+        └──────────┴──────────┴──────────┴──────────┴─────────────┴──────────┘
+```

package/overtakes/class-vs-function.md

@@ -0,0 +1,31 @@
+# Class vs Function
+
+```
+⭐ Script  __benchmarks__/class-vs-function.js
+  ⇶ Suite  Class vs Function
+    ➤ Perform  Instantiation
+      ✓ Measure 1000000 class declarations via "class"
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬─────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │  count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼─────────┤
+        │ 0.000438 │ 0.000496 │ 0.001133 │ 0.001602 │ 684.87052 │ 1000000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴─────────┘
+      ✓ Measure 1000000 instantiations of the declared class via class and test method call
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬─────────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │  count  │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼─────────┤
+        │ 0.000048 │ 0.000054 │ 0.000059 │ 0.000137 │ 61.055298 │ 1000000 │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴─────────┘
+      ✓ Measure 1000000 class declarations via function
+        ┌─────────┬──────────┬─────────┬──────────┬──────────┬─────────┐
+        │ (index) │   med    │   p95   │   p99    │  total   │  count  │
+        ├─────────┼──────────┼─────────┼──────────┼──────────┼─────────┤
+        │ 0.00005 │ 0.000056 │ 0.00007 │ 0.000146 │ 63.94922 │ 1000000 │
+        └─────────┴──────────┴─────────┴──────────┴──────────┴─────────┘
+      ✓ Measure 1000000 instantiations of the declared class via function and test method call
+        ┌──────────┬──────────┬─────────┬──────────┬───────────┬─────────┐
+        │ (index)  │   med    │   p95   │   p99    │   total   │  count  │
+        ├──────────┼──────────┼─────────┼──────────┼───────────┼─────────┤
+        │ 0.000049 │ 0.000056 │ 0.00008 │ 0.000189 │ 78.511849 │ 1000000 │
+        └──────────┴──────────┴─────────┴──────────┴───────────┴─────────┘
+```

package/overtakes/postgres-vs-mongo.md

@@ -0,0 +1,55 @@
+### Postgres vs MongoDB
+
+```
+⭐ Script  __benchmarks__/postgres-vs-mongo.js
+  ⇶ Suite  mongodb vs postgres
+    ➤ Perform  simple test
+      ✓ Measure 1000 postgres inserts
+        ┌──────────┬──────────┬──────────┬─────────┬─────────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99   │    total    │ count │
+        ├──────────┼──────────┼──────────┼─────────┼─────────────┼───────┤
+        │ 2.232527 │ 2.256009 │ 2.917856 │ 5.41444 │ 2408.708534 │ 1000  │
+        └──────────┴──────────┴──────────┴─────────┴─────────────┴───────┘
+      ✓ Measure 1000 mongodb inserts
+        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99    │    total    │ count │
+        ├──────────┼──────────┼──────────┼──────────┼─────────────┼───────┤
+        │ 2.955035 │ 2.981828 │ 5.038826 │ 5.467477 │ 3233.680552 │ 1000  │
+        └──────────┴──────────┴──────────┴──────────┴─────────────┴───────┘
+      ✓ Measure 1000 postgres query data
+        ┌─────────┬──────────┬──────────┬──────────┬────────────┬───────┐
+        │ (index) │   med    │   p95    │   p99    │   total    │ count │
+        ├─────────┼──────────┼──────────┼──────────┼────────────┼───────┤
+        │ 0.28218 │ 0.297544 │ 0.393615 │ 0.561729 │ 308.713494 │ 1000  │
+        └─────────┴──────────┴──────────┴──────────┴────────────┴───────┘
+      ✓ Measure 1000 mongodb query data
+        ┌──────────┬──────────┬──────────┬──────────┬───────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99    │   total   │ count │
+        ├──────────┼──────────┼──────────┼──────────┼───────────┼───────┤
+        │ 0.457289 │ 0.461665 │ 0.693627 │ 0.919116 │ 495.27099 │ 1000  │
+        └──────────┴──────────┴──────────┴──────────┴───────────┴───────┘
+      ✓ Measure 1000 postgres query inserts
+        ┌──────────┬──────────┬──────────┬──────────┬─────────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99    │    total    │ count │
+        ├──────────┼──────────┼──────────┼──────────┼─────────────┼───────┤
+        │ 2.491574 │ 2.500577 │ 3.524734 │ 6.177946 │ 2681.101875 │ 1000  │
+        └──────────┴──────────┴──────────┴──────────┴─────────────┴───────┘
+      ✓ Measure 1000 mongodb query inserts
+        ┌──────────┬──────────┬──────────┬─────────┬─────────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99   │    total    │ count │
+        ├──────────┼──────────┼──────────┼─────────┼─────────────┼───────┤
+        │ 3.946823 │ 3.921073 │ 5.969672 │ 6.26903 │ 3954.008642 │ 1000  │
+        └──────────┴──────────┴──────────┴─────────┴─────────────┴───────┘
+      ✓ Measure 1000 postgres group data
+        ┌──────────┬──────────┬──────────┬──────────┬────────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99    │   total    │ count │
+        ├──────────┼──────────┼──────────┼──────────┼────────────┼───────┤
+        │ 0.287954 │ 0.272375 │ 0.347489 │ 0.494122 │ 279.076014 │ 1000  │
+        └──────────┴──────────┴──────────┴──────────┴────────────┴───────┘
+      ✓ Measure 1000 mongodb group data
+        ┌──────────┬──────────┬──────────┬──────────┬────────────┬───────┐
+        │ (index)  │   med    │   p95    │   p99    │   total    │ count │
+        ├──────────┼──────────┼──────────┼──────────┼────────────┼───────┤
+        │ 0.564809 │ 0.556707 │ 0.666702 │ 0.851308 │ 569.134585 │ 1000  │
+        └──────────┴──────────┴──────────┴──────────┴────────────┴───────┘
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "0.0.7",
+  "version": "0.1.1",
   "description": "NodeJS performance benchmark",
   "main": "index.js",
   "types": "index.d.ts",
@@ -30,16 +30,18 @@
   },
   "homepage": "https://github.com/3axap4eHko/overtake#readme",
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "husky": "^8.0.3",
-    "jest": "^29.5.0",
-    "prettier": "^2.8.4",
-    "pretty-quick": "^3.1.3"
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.12",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "mongodb": "^6.4.0",
+    "pg": "^8.11.3",
+    "prettier": "^3.2.5",
+    "pretty-quick": "^4.0.0"
   },
   "dependencies": {
-    "commander": "^10.0.0",
+    "commander": "^12.0.0",
     "conode": "^0.1.23",
-    "glob": "^9.3.0"
+    "glob": "^10.3.10"
   }
 }