mutano 3.2.1 → 3.4.0

package/README.md

@@ -115,22 +115,19 @@ export type UpdateableUser = Updateable<User>;
   password: string,
   database: string,
   schema?: string, // PostgreSQL only
-  ssl?: { ca, cert, key },
-  overrideTypes?: Record<string, string>
+  ssl?: { ca, cert, key }
 }
 
 // SQLite
 {
   type: 'sqlite',
-  path: string,
-  overrideTypes?: Record<string, string>
+  path: string
 }
 
 // Prisma
 {
   type: 'prisma',
-  path: string,
-  overrideTypes?: Record<string, string>
+  path: string
 }
 ```
 
@@ -180,6 +177,41 @@ export type UpdateableUser = Updateable<User>;
 | `camelCase` | Convert to camelCase |
 | `dryRun` | Return content without writing files |
 | `magicComments` | Enable @zod/@ts/@kysely comments (Obs.: no SQLite support) |
+| `inflection` | Transform model names: `'singular'`, `'plural'`, or `'none'` (default) |
+| `overrideTypes` | Override types globally per destination (see below) |
+| `overrideColumns` | Override specific columns per table (see below) |
+
+### Inflection
+
+Transform table/view names to singular or plural form in generated types:
+
+```typescript
+// Singular inflection - "users" table becomes "User" type
+await generate({
+  origin: { /* ... */ },
+  destinations: [{ type: 'zod' }],
+  inflection: 'singular'
+})
+
+// Plural inflection - "user" table becomes "Users" type
+await generate({
+  origin: { /* ... */ },
+  destinations: [{ type: 'ts' }],
+  inflection: 'plural'
+})
+```
+
+**Examples:**
+
+| Table Name | `inflection: 'singular'` | `inflection: 'plural'` | `inflection: 'none'` |
+|------------|-------------------------|----------------------|---------------------|
+| `users` | `UserType` | `UsersType` | `UsersType` |
+| `companies` | `CompanyType` | `CompaniesType` | `CompaniesType` |
+| `people` | `PersonType` | `PeopleType` | `PeopleType` |
+| `categories` | `CategoryType` | `CategoriesType` | `CategoriesType` |
+| `user_accounts` | `UserAccountType` | `UserAccountsType` | `UserAccountsType` |
+
+Works with all output types (Zod, TypeScript, Kysely) and combines with `camelCase` option.
 
 ## Magic Comments
 
@@ -274,24 +306,103 @@ Generated types will only include: `id`, `email`, `name`, and `metadata`
 
 ## Type Overrides
 
-Override default types globally in your origin config:
+Override default types globally. Define destination-specific overrides for each output type:
 
 ```typescript
 {
   origin: {
     type: 'mysql',
     // ... connection config
-    overrideTypes: {
+  },
+  overrideTypes: {
+    zod: {
       json: 'z.record(z.string())',
       text: 'z.string().max(1000)',
       decimal: 'z.number().positive()'
+    },
+    ts: {
+      json: 'Record<string, string>',
+      text: 'string',
+      decimal: 'number'
+    },
+    kysely: {
+      json: 'Json',
+      text: 'string',
+      decimal: 'Decimal'
     }
   }
 }
 ```
 
+**Single destination with multiple outputs:**
+
+```typescript
+{
+  origin: {
+    type: 'postgres',
+    // ...
+  },
+  destinations: [
+    { type: 'zod', folder: './zod' },
+    { type: 'ts', folder: './types' },
+    { type: 'kysely', outFile: './db.ts' }
+  ],
+  overrideTypes: {
+    zod: { jsonb: 'z.record(z.string())' },
+    ts: { jsonb: 'Record<string, string>' },
+    kysely: { jsonb: 'Json' }
+  }
+}
+```
+
 **Common Overrides:**
 - **MySQL**: `json`, `text`, `decimal`, `enum`
 - **PostgreSQL**: `jsonb`, `uuid`, `text`, `numeric`
 - **SQLite**: `json`, `text`, `real`
-- **Prisma**: `Json`, `String`, `Decimal`
+- **Prisma**: `Json`, `String`, `Decimal`
+
+### Override Columns
+
+Override specific columns from specific tables. Takes priority over magic comments:
+
+```typescript
+{
+  origin: {
+    type: 'mysql',
+    // ... connection config
+  },
+  destinations: [
+    { type: 'zod', folder: './zod' },
+    { type: 'ts', folder: './types' },
+    { type: 'kysely', outFile: './db.ts' }
+  ],
+  overrideColumns: {
+    zod: {
+      users: {
+        email: 'z.string().email()',
+        metadata: 'z.record(z.unknown())'
+      },
+      posts: {
+        content: 'z.string().max(10000)'
+      }
+    },
+    ts: {
+      users: {
+        email: 'EmailAddress',
+        metadata: 'Record<string, unknown>'
+      }
+    },
+    kysely: {
+      users: {
+        metadata: 'CustomJsonType'
+      }
+    }
+  }
+}
+```
+
+**Priority order** (highest to lowest):
+1. `overrideColumns` - Specific column overrides
+2. Magic comments (`@zod`, `@ts`, `@kysely`) - Column-level comments
+3. `overrideTypes` - Global type overrides
+4. Default type mappings

package/dist/main.d.ts

@@ -40,9 +40,6 @@ interface Config {
     origin: {
         type: 'prisma';
         path: string;
-        overrideTypes?: {
-            [k in PrismaValidTypes]?: string;
-        };
     } | {
         type: 'mysql';
         host: string;
@@ -50,9 +47,6 @@ interface Config {
         user: string;
         password: string;
         database: string;
-        overrideTypes?: {
-            [k in MySQLValidTypes]?: string;
-        };
         ssl?: Record<string, any>;
     } | {
         type: 'postgres';
@@ -62,16 +56,10 @@ interface Config {
         password: string;
         database: string;
         schema?: string;
-        overrideTypes?: {
-            [k in PostgresValidTypes]?: string;
-        };
         ssl?: Record<string, any>;
     } | {
         type: 'sqlite';
         path: string;
-        overrideTypes?: {
-            [k in SQLiteValidTypes]?: string;
-        };
     };
     destinations: Destination[];
     tables?: string[];
@@ -82,8 +70,19 @@ interface Config {
     silent?: boolean;
     dryRun?: boolean;
     magicComments?: boolean;
+    overrideTypes?: {
+        zod?: Record<string, string>;
+        ts?: Record<string, string>;
+        kysely?: Record<string, string>;
+    };
+    overrideColumns?: {
+        zod?: Record<string, Record<string, string>>;
+        ts?: Record<string, Record<string, string>>;
+        kysely?: Record<string, Record<string, string>>;
+    };
     includeViews?: boolean;
     enumDeclarations?: Record<string, string[]>;
+    inflection?: 'singular' | 'plural' | 'none';
 }
 interface GenerateContentParams {
     table: string;
@@ -103,10 +102,6 @@ interface GenerateViewContentParams {
     enumDeclarations: Record<string, string[]>;
     defaultZodHeader: (version: 3 | 4) => string;
 }
-type MySQLValidTypes = 'tinyint' | 'smallint' | 'mediumint' | 'int' | 'bigint' | 'decimal' | 'float' | 'double' | 'bit' | 'char' | 'varchar' | 'binary' | 'varbinary' | 'tinyblob' | 'blob' | 'mediumblob' | 'longblob' | 'tinytext' | 'text' | 'mediumtext' | 'longtext' | 'enum' | 'set' | 'date' | 'time' | 'datetime' | 'timestamp' | 'year' | 'json';
-type PostgresValidTypes = 'smallint' | 'integer' | 'bigint' | 'decimal' | 'numeric' | 'real' | 'double precision' | 'smallserial' | 'serial' | 'bigserial' | 'money' | 'character varying' | 'varchar' | 'character' | 'char' | 'text' | 'bytea' | 'timestamp' | 'timestamp with time zone' | 'timestamp without time zone' | 'date' | 'time' | 'time with time zone' | 'time without time zone' | 'interval' | 'boolean' | 'enum' | 'point' | 'line' | 'lseg' | 'box' | 'path' | 'polygon' | 'circle' | 'cidr' | 'inet' | 'macaddr' | 'bit' | 'bit varying' | 'uuid' | 'xml' | 'json' | 'jsonb' | 'int4range' | 'int8range' | 'numrange' | 'tsrange' | 'tstzrange' | 'daterange' | 'name' | 'citext';
-type SQLiteValidTypes = 'integer' | 'real' | 'text' | 'blob' | 'numeric' | 'boolean' | 'date' | 'datetime' | 'character' | 'varchar' | 'varying character' | 'nchar' | 'native character' | 'nvarchar' | 'clob' | 'double' | 'double precision' | 'float' | 'int' | 'int2' | 'int8' | 'bigint' | 'unsigned big int' | 'mediumint' | 'tinyint' | 'smallint' | 'decimal' | 'json';
-type PrismaValidTypes = 'String' | 'Boolean' | 'Int' | 'BigInt' | 'Float' | 'Decimal' | 'DateTime' | 'Json' | 'Bytes' | 'Unsupported';
 
 /**
  * Constants and default headers for code generation
@@ -156,16 +151,12 @@ type OperationType = 'table' | 'insertable' | 'updateable' | 'selectable';
 /**
  * Generate the appropriate type for a database field
  */
-declare function getType(op: OperationType, desc: Desc, config: Config, destination: Destination): string;
+declare function getType(op: OperationType, desc: Desc, config: Config, destination: Destination, entityName?: string): string;
 
 /**
  * Mutano - Database schema to TypeScript/Zod/Kysely converter
- * Refactored for better maintainability and modularity
  */
 
-/**
- * Main generate function - orchestrates the entire schema generation process
- */
 declare function generate(config: Config): Promise<Record<string, string>>;
 
 export { defaultKyselyHeader, defaultZodHeader, extractKyselyExpression, extractTSExpression, extractTypeExpression, extractZodExpression, generate, generateContent, generateViewContent, getType };

package/dist/main.js

@@ -2,6 +2,7 @@ import * as path from 'node:path';
 import camelCase from 'camelcase';
 import { writeFile } from 'node:fs/promises';
 import { ensureDir } from 'fs-extra/esm';
+import pluralize from 'pluralize';
 import knex from 'knex';
 import { readFileSync } from 'node:fs';
 import { createPrismaSchemaBuilder } from '@mrleebo/prisma-ast';
@@ -48,6 +49,16 @@ function createEntityList(tables, views) {
   return allEntities.sort((a, b) => a.name.localeCompare(b.name));
 }
 
+function applyInflection(name, inflection) {
+  if (inflection === "singular") {
+    return pluralize.singular(name);
+  }
+  if (inflection === "plural") {
+    return pluralize.plural(name);
+  }
+  return name;
+}
+
 const dateTypes = {
   mysql: ["date", "datetime", "timestamp"],
   postgres: [
@@ -207,7 +218,7 @@ const hasTableIgnoreDirective = (comment) => {
   return comment.includes("@@ignore");
 };
 
-function getType(op, desc, config, destination) {
+function getType(op, desc, config, destination, entityName) {
   const { Default, Extra, Null, Type, Comment, EnumOptions } = desc;
   const schemaType = config.origin.type;
   const type = schemaType === "prisma" ? Type : Type.toLowerCase();
@@ -218,28 +229,18 @@ function getType(op, desc, config, destination) {
   const isKyselyDestination = destination.type === "kysely";
   const isZodDestination = destination.type === "zod";
   const typeMappings = getTypeMappings(schemaType);
-  if (isTsDestination || isKyselyDestination) {
-    const isJsonField = isJsonType(type);
-    if (isKyselyDestination && isJsonField) {
-      if (config.magicComments) {
-        const kyselyOverrideType = extractKyselyExpression(Comment);
-        if (kyselyOverrideType) {
-          return kyselyOverrideType;
-        }
-      }
+  const destKey = isZodDestination ? "zod" : isTsDestination ? "ts" : "kysely";
+  if (entityName && config.overrideColumns) {
+    const destOverrides = config.overrideColumns[destKey];
+    if (destOverrides && destOverrides[entityName] && destOverrides[entityName][desc.Field]) {
+      const columnOverride = destOverrides[entityName][desc.Field];
       const shouldBeNullable = isNull || ["insertable", "updateable"].includes(op) && (hasDefaultValue || isGenerated) || op === "updateable" && !isNull && !hasDefaultValue;
-      return shouldBeNullable ? "Json | null" : "Json";
-    }
-    if (isKyselyDestination && config.magicComments) {
-      const kyselyOverrideType = extractKyselyExpression(Comment);
-      if (kyselyOverrideType) {
-        return kyselyOverrideType;
-      }
-    }
-    if ((isTsDestination || isKyselyDestination) && config.magicComments) {
-      const tsOverrideType = extractTSExpression(Comment);
-      if (tsOverrideType) {
-        return tsOverrideType;
+      if (isZodDestination) {
+        const nullishOption = destination.nullish;
+        const nullableMethod = nullishOption && op !== "selectable" ? "nullish" : "nullable";
+        return shouldBeNullable ? `${columnOverride}.${nullableMethod}()` : columnOverride;
+      } else {
+        return shouldBeNullable ? `${columnOverride} | null` : columnOverride;
       }
     }
   }
@@ -249,9 +250,24 @@ function getType(op, desc, config, destination) {
       return zodOverrideType;
     }
   }
-  const overrideTypes = config.origin.overrideTypes;
-  if (overrideTypes && overrideTypes[Type]) {
-    const overrideType = overrideTypes[Type];
+  if (isTsDestination && config.magicComments) {
+    const tsOverrideType = extractTSExpression(Comment);
+    if (tsOverrideType) {
+      return tsOverrideType;
+    }
+  }
+  if (isKyselyDestination && config.magicComments) {
+    const kyselyOverrideType = extractKyselyExpression(Comment);
+    if (kyselyOverrideType) {
+      return kyselyOverrideType;
+    }
+    const tsOverrideType = extractTSExpression(Comment);
+    if (tsOverrideType) {
+      return tsOverrideType;
+    }
+  }
+  const overrideType = config.overrideTypes?.[destKey]?.[Type];
+  if (overrideType) {
     const shouldBeNullable = isNull || ["insertable", "updateable"].includes(op) && (hasDefaultValue || isGenerated) || op === "updateable" && !isNull && !hasDefaultValue;
     if (isZodDestination) {
       const nullishOption = destination.nullish;
@@ -261,6 +277,13 @@ function getType(op, desc, config, destination) {
       return shouldBeNullable ? `${overrideType} | null` : overrideType;
     }
   }
+  if (isTsDestination || isKyselyDestination) {
+    const isJsonField = isJsonType(type);
+    if (isKyselyDestination && isJsonField) {
+      const shouldBeNullable = isNull || ["insertable", "updateable"].includes(op) && (hasDefaultValue || isGenerated) || op === "updateable" && !isNull && !hasDefaultValue;
+      return shouldBeNullable ? "Json | null" : "Json";
+    }
+  }
   const enumTypesForSchema = typeMappings.enumTypes[schemaType] || [];
   const isEnum = enumTypesForSchema.includes(type);
   const isPrismaEnum = schemaType === "prisma" && config.enumDeclarations && config.enumDeclarations[type];
@@ -472,8 +495,9 @@ function generateViewContent({
   defaultZodHeader
 }) {
   let content = "";
+  const inflectedView = applyInflection(view, config.inflection);
   if (destination.type === "kysely") {
-    const pascalView = camelCase(view, { pascalCase: true });
+    const pascalView = camelCase(inflectedView, { pascalCase: true });
     content += `// Kysely type definitions for ${view} (view)
 
 `;
@@ -483,7 +507,7 @@ function generateViewContent({
 `;
     for (const desc of describes) {
       const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-      const fieldType = getType("selectable", desc, config, destination);
+      const fieldType = getType("selectable", desc, config, destination, view);
       content += `  ${fieldName}: ${fieldType};
 `;
     }
@@ -493,14 +517,14 @@ function generateViewContent({
     content += `export type Selectable${pascalView}View = Selectable<${pascalView}View>;
 `;
   } else if (destination.type === "ts") {
-    const pascalView = camelCase(view, { pascalCase: true });
+    const pascalView = camelCase(inflectedView, { pascalCase: true });
     content += `// TypeScript interface for ${view} (view - read-only)
 `;
     content += `export interface ${pascalView}View {
 `;
     for (const desc of describes) {
       const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-      const fieldType = getType("selectable", desc, config, destination);
+      const fieldType = getType("selectable", desc, config, destination, view);
       content += `  ${fieldName}: ${fieldType};
 `;
     }
@@ -518,12 +542,12 @@ function generateViewContent({
 `;
     for (const desc of describes) {
       const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-      const fieldType = getType("selectable", desc, config, destination);
+      const fieldType = getType("selectable", desc, config, destination, view);
       content += `  ${fieldName}: ${fieldType},
 `;
     }
     content += "})\n\n";
-    const pascalView = camelCase(view, { pascalCase: true });
+    const pascalView = camelCase(inflectedView, { pascalCase: true });
     content += `export type ${camelCase(`${pascalView}ViewType`, {
       pascalCase: true
     })} = z.infer<typeof ${snakeView}_view>
@@ -577,7 +601,8 @@ function generateTypeScriptContent({
   isCamelCase
 }) {
   let content = "";
-  const pascalTable = camelCase(table, { pascalCase: true });
+  const inflectedTable = applyInflection(table, config.inflection);
+  const pascalTable = camelCase(inflectedTable, { pascalCase: true });
   content += `// TypeScript interfaces for ${table}
 
 `;
@@ -585,7 +610,7 @@ function generateTypeScriptContent({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("table", desc, config, destination);
+    const fieldType = getType("table", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType};
 `;
   }
@@ -594,7 +619,7 @@ function generateTypeScriptContent({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("insertable", desc, config, destination);
+    const fieldType = getType("insertable", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType};
 `;
   }
@@ -603,7 +628,7 @@ function generateTypeScriptContent({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("updateable", desc, config, destination);
+    const fieldType = getType("updateable", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType};
 `;
   }
@@ -612,7 +637,7 @@ function generateTypeScriptContent({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("selectable", desc, config, destination);
+    const fieldType = getType("selectable", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType};
 `;
   }
@@ -627,7 +652,8 @@ function generateKyselyContent({
   isCamelCase
 }) {
   let content = "";
-  const pascalTable = camelCase(table, { pascalCase: true });
+  const inflectedTable = applyInflection(table, config.inflection);
+  const pascalTable = camelCase(inflectedTable, { pascalCase: true });
   content += `// Kysely type definitions for ${table}
 
 `;
@@ -637,7 +663,7 @@ function generateKyselyContent({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    let fieldType = getType("table", desc, config, destination);
+    let fieldType = getType("table", desc, config, destination, table);
     const hasMagicComment = config.magicComments && (desc.Comment.includes("@kysely(") || desc.Comment.includes("@ts("));
     if (!hasMagicComment) {
       const isAutoIncrement = desc.Extra.toLowerCase().includes("auto_increment");
@@ -676,11 +702,12 @@ function generateZodContent({
     content += header;
   }
   const snakeTable = toSnakeCase(table);
+  const inflectedTable = applyInflection(table, config.inflection);
   content += `export const ${snakeTable} = z.object({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("table", desc, config, destination);
+    const fieldType = getType("table", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType},
 `;
   }
@@ -693,7 +720,7 @@ function generateZodContent({
       continue;
     }
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("insertable", desc, config, destination);
+    const fieldType = getType("insertable", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType},
 `;
   }
@@ -706,7 +733,7 @@ function generateZodContent({
       continue;
     }
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("updateable", desc, config, destination);
+    const fieldType = getType("updateable", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType},
 `;
   }
@@ -715,18 +742,19 @@ function generateZodContent({
 `;
   for (const desc of describes) {
     const fieldName = isCamelCase ? camelCase(desc.Field) : desc.Field;
-    const fieldType = getType("selectable", desc, config, destination);
+    const fieldType = getType("selectable", desc, config, destination, table);
     content += `  ${fieldName}: ${fieldType},
 `;
   }
   content += "})\n\n";
-  content += `export type ${camelCase(`${table}Type`, { pascalCase: true })} = z.infer<typeof ${snakeTable}>
+  const pascalInflectedTableType = camelCase(`${inflectedTable}Type`, { pascalCase: true });
+  content += `export type ${pascalInflectedTableType} = z.infer<typeof ${snakeTable}>
 `;
-  content += `export type Insertable${camelCase(`${table}Type`, { pascalCase: true })} = z.infer<typeof insertable_${snakeTable}>
+  content += `export type Insertable${pascalInflectedTableType} = z.infer<typeof insertable_${snakeTable}>
 `;
-  content += `export type Updateable${camelCase(`${table}Type`, { pascalCase: true })} = z.infer<typeof updateable_${snakeTable}>
+  content += `export type Updateable${pascalInflectedTableType} = z.infer<typeof updateable_${snakeTable}>
 `;
-  content += `export type Selectable${camelCase(`${table}Type`, { pascalCase: true })} = z.infer<typeof selectable_${snakeTable}>
+  content += `export type Selectable${pascalInflectedTableType} = z.infer<typeof selectable_${snakeTable}>
 `;
   return content;
 }
@@ -1156,8 +1184,9 @@ export interface ${schemaName} {
 `;
       const sortedTableEntries = tableContents.map(({ table, content }) => {
         const isView = content.includes("(view");
-        const pascalTable = camelCase(table, { pascalCase: true }) + (isView ? "View" : "");
-        const tableKey = isCamelCase ? camelCase(table) : table;
+        const inflectedTable = applyInflection(table, config.inflection);
+        const pascalTable = camelCase(inflectedTable, { pascalCase: true }) + (isView ? "View" : "");
+        const tableKey = isCamelCase ? camelCase(inflectedTable) : inflectedTable;
         return { tableKey, pascalTable, isView };
       }).sort((a, b) => a.tableKey.localeCompare(b.tableKey));
       for (const { tableKey, pascalTable } of sortedTableEntries) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mutano",
   "type": "module",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "Converts Prisma/MySQL/PostgreSQL/SQLite schemas to Zod/TS/Kysely interfaces",
   "author": "Alisson Cavalcante Agiani <thelinuxlich@gmail.com>",
   "license": "MIT",
@@ -16,20 +16,22 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@mrleebo/prisma-ast": "^0.13.0",
+    "@mrleebo/prisma-ast": "^0.13.1",
     "@types/fs-extra": "^11.0.4",
-    "@types/pg": "^8.15.5",
-    "camelcase": "^8.0.0",
-    "fs-extra": "^11.3.2",
+    "@types/pg": "^8.16.0",
+    "@types/pluralize": "^0.0.33",
+    "camelcase": "^9.0.0",
+    "fs-extra": "^11.3.3",
     "knex": "^3.1.0",
-    "mysql2": "^3.14.4",
-    "pg": "^8.16.3",
+    "mysql2": "^3.16.3",
+    "pg": "^8.18.0",
+    "pluralize": "^8.0.0",
     "sqlite3": "^5.1.7"
   },
   "devDependencies": {
-    "@electric-sql/pglite": "^0.3.8",
-    "pkgroll": "^2.15.4",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "@electric-sql/pglite": "^0.3.15",
+    "pkgroll": "^2.23.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   }
 }