@oakbun/ws 0.1.1 → 2.0.0

package/dist/index.d.ts

@@ -64,6 +64,11 @@ type InferInsertFromSchema<S extends SchemaMap> = {
     [K in keyof S as IsOptionalOnInsert<S[K]> extends true ? K : never]?: S[K] extends Column<infer T> ? T : never;
 };
 type InferInsert<T> = T extends TableDef<any, infer S, any> ? InferInsertFromSchema<S> : T extends SchemaMap ? InferInsertFromSchema<T> : never;
+type InferUpdate<T> = T extends TableDef<infer R, infer S, any> ? Partial<R> & {
+    [K in keyof S as S[K] extends Column<any> ? S[K]['def']['primaryKey'] extends true ? K : never : never]: R[K & keyof R];
+} : T extends SchemaMap ? Partial<{
+    [K in keyof T]: T[K] extends Column<infer C> ? C : never;
+}> : never;
 interface TableHookHandlers<T> {
     beforeInsert?: (data: Partial<T>) => Partial<T> | void | Promise<Partial<T> | void>;
     afterInsert?: (result: T, input: Partial<T>) => void | Promise<void>;
@@ -87,13 +92,66 @@ type InferTableEvents<T, M extends TableEventMap> = (M['afterInsert'] extends st
 } : Record<never, never>) & (M['afterDelete'] extends string ? {
     [_ in M['afterDelete']]: T;
 } : Record<never, never>);
-interface TableDef<T, S extends SchemaMap = SchemaMap, TEvents extends TableEventMap = TableEventMap> {
+type RelationKind = 'belongsTo' | 'hasMany' | 'manyToMany';
+/**
+ * Metadata for a single declared relation.
+ * TForeign captures the foreign table's row type so that WithRelations can
+ * produce concrete types (User, Post[]) rather than unknown.
+ *
+ * `getTable` is a lazy getter to allow circular references between tables.
+ */
+interface RelationMeta<TForeign = unknown> {
+    kind: RelationKind;
+    name: string;
+    getTable: () => TableDef<TForeign, any, any>;
+    /** FK column name — on this table for belongsTo, on foreign table for hasMany */
+    foreignKey: string;
+    /** manyToMany only */
+    pivot?: {
+        table: TableDef<any, any, any>;
+        localKey: string;
+        foreignKey: string;
+    };
+}
+/** All declared relations on a table, keyed by relation name. */
+type RelationsMap = Record<string, RelationMeta<any>>;
+interface BelongsToRelation<TForeign> extends RelationMeta<TForeign> {
+    kind: 'belongsTo';
+}
+interface HasManyRelation<TForeign> extends RelationMeta<TForeign> {
+    kind: 'hasMany';
+}
+/**
+ * Derives the result type of a single loaded relation.
+ * - belongsTo → TForeign | null
+ * - hasMany   → TForeign[]
+ * - manyToMany → never (not supported in Spec B)
+ */
+type InferRelationResult<R> = R extends BelongsToRelation<infer TForeign> ? TForeign | null : R extends HasManyRelation<infer TForeign> ? TForeign[] : never;
+/**
+ * Merges a row type T with the requested relations.
+ * Keys must be keys of the table's relations map.
+ *
+ * @example
+ * type PostWithAuthor = WithRelations<Post, typeof postsTable, 'author'>
+ * // → Post & { author: User | null }
+ */
+type WithRelations<T, TTable extends {
+    relations: RelationsMap;
+}, Keys extends keyof TTable['relations'] & string> = T & {
+    [K in Keys]: InferRelationResult<TTable['relations'][K]>;
+};
+interface TableDef<T, S extends SchemaMap = SchemaMap, TEvents extends TableEventMap = TableEventMap, TRelations extends RelationsMap = RelationsMap> {
     readonly name: string;
     readonly schema: S;
     readonly primaryKey: keyof T & string;
     readonly hooks: TableHookHandlers<T>[];
     readonly events: TEvents;
     readonly _eventMap: InferTableEvents<T, TEvents>;
+    /** Declared relations — concrete typed map so WithRelations can infer foreign types. */
+    readonly relations: TRelations;
+    /** The column used for soft delete, or null if not configured. */
+    readonly softDeleteColumn: (keyof T & string) | null;
 }
 
 interface ModuleHookHandlers<T, TCtx = unknown> {
@@ -168,6 +226,21 @@ declare class HookExecutor {
     private _moduleHandlers;
 }
 
+/**
+ * Phantom-typed wrapper for a subquery SQL fragment.
+ * Col and T are used only at compile time — _phantom is never read at runtime.
+ *
+ * Produced by SelectBuilder.columns(col).subquery().
+ * Accepted by WhereOp IN / NOT IN in place of an array.
+ */
+interface SubqueryResult<Col extends string, T> {
+    readonly _sql: string;
+    readonly _params: BindingValue[];
+    readonly _phantom: {
+        col: Col;
+        type: T;
+    };
+}
 interface JoinClause {
     type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
     table: string;
@@ -175,6 +248,8 @@ interface JoinClause {
 }
 /** SQL dialect — used for ILIKE fallback on non-Postgres adapters. */
 type SqlDialect = 'sqlite' | 'postgres' | 'mysql';
+/** Accepted value for IN / NOT IN — either a plain array or a typed subquery. */
+type InValue<T> = T[] | SubqueryResult<string, T>;
 /** Explicit operator condition for a single column. */
 type WhereOp<T> = {
     op: '=';
@@ -196,10 +271,10 @@ type WhereOp<T> = {
     value: T;
 } | {
     op: 'IN';
-    value: T[];
+    value: InValue<T>;
 } | {
     op: 'NOT IN';
-    value: T[];
+    value: InValue<T>;
 } | {
     op: 'LIKE';
     value: string;
@@ -243,6 +318,7 @@ interface SelectOptions {
     groupBy?: string[];
     aggregates?: AggregateClause[];
     having?: WhereInput<Record<string, unknown>>;
+    distinct?: boolean;
 }
 
 interface QueryLog {
@@ -269,11 +345,12 @@ declare class BoundVelnDB {
     private readonly hooks;
     private readonly ctx;
     private readonly queue?;
+    private readonly dialect;
     /** Per-request query counter — incremented for every query() and execute() call on this instance. */
     _queryCount: number;
     private readonly adapter;
-    constructor(adapter: VelnAdapter, hooks: HookExecutor, ctx: unknown, queue?: RequestEventQueue | undefined, queryLog?: QueryLog);
-    from<T, S extends SchemaMap>(table: TableDef<T, S>): SelectBuilder<T, S>;
+    constructor(adapter: VelnAdapter, hooks: HookExecutor, ctx: unknown, queue?: RequestEventQueue | undefined, queryLog?: QueryLog, dialect?: SqlDialect);
+    from<T, S extends SchemaMap, TRelations extends RelationsMap>(table: TableDef<T, S, any, TRelations>): SelectBuilder<T, S, TRelations>;
     /**
      * Start a JOIN query from the given table name.
      * Returns a JoinBuilder — call .join()/.leftJoin() etc. to add clauses,
@@ -293,22 +370,36 @@ declare class BoundVelnDB {
      * Returns a Map keyed by the foreign-key value; each entry is an array of
      * matching child rows (for one-to-many relations).
      *
-     * @example
-     * const posts = await db.from(postsTable).select()
+     * Two call forms:
+     *
+     * @example — explicit (original)
      * const authorMap = await db.loadRelation(posts, 'authorId', usersTable, 'id')
-     * // → SELECT * FROM "users" WHERE "id" IN (1, 2, 3)
-     * const withAuthors = posts.map(p => ({ ...p, author: authorMap.get(p.authorId)?.[0] ?? null }))
+     *
+     * @example — name-based (reads relation metadata declared on the table)
+     * const authorMap = await db.loadRelation(posts, 'author', postsTable)
      */
     loadRelation<TParent extends Record<string, unknown>, TChild, TFk extends keyof TParent & string, TPk extends keyof TChild & string>(parents: TParent[], foreignKey: TFk, childTable: TableDef<TChild>, primaryKey: TPk): Promise<Map<TParent[TFk], TChild[]>>;
+    loadRelation<TParent extends Record<string, unknown>>(parents: TParent[], relationName: string, sourceTable: TableDef<any>): Promise<Map<unknown, unknown>>;
     /**
      * Convenience variant of loadRelation for belongs-to (many-to-one) relations.
      * Returns Map<fkValue, TChild> — single child per key instead of an array.
      *
-     * @example
+     * Two call forms:
+     *
+     * @example — explicit (original)
      * const authorMap = await db.loadRelationOne(posts, 'authorId', usersTable, 'id')
-     * const author = authorMap.get(post.authorId) ?? null
+     *
+     * @example — name-based
+     * const authorMap = await db.loadRelationOne(posts, 'author', postsTable)
      */
     loadRelationOne<TParent extends Record<string, unknown>, TChild, TFk extends keyof TParent & string, TPk extends keyof TChild & string>(parents: TParent[], foreignKey: TFk, childTable: TableDef<TChild>, primaryKey: TPk): Promise<Map<TParent[TFk], TChild>>;
+    loadRelationOne<TParent extends Record<string, unknown>>(parents: TParent[], relationName: string, sourceTable: TableDef<any>): Promise<Map<unknown, unknown>>;
+    /**
+     * Shared implementation for name-based loadRelation / loadRelationOne.
+     * Reads RelationMeta from sourceTable.relations, validates the kind,
+     * and delegates to the explicit overload.
+     */
+    private _loadRelationByName;
     transaction<T>(fn: (db: BoundVelnDB) => Promise<T>): Promise<TransactionResult<T>>;
     /**
      * Execute raw SQL and return typed rows.
@@ -329,7 +420,7 @@ declare class BoundVelnDB {
         parse: (row: unknown) => T;
     }): Promise<T[]>;
 }
-declare class SelectBuilder<T, S extends SchemaMap> {
+declare class SelectBuilder<T, S extends SchemaMap, TRelations extends RelationsMap = RelationsMap> {
     private readonly adapter;
     private readonly hooks;
     private readonly ctx;
@@ -339,12 +430,39 @@ declare class SelectBuilder<T, S extends SchemaMap> {
     private readonly _options;
     private readonly _rawWhere;
     private readonly _dialect;
-    constructor(adapter: VelnAdapter, hooks: HookExecutor, ctx: unknown, queue: RequestEventQueue | undefined, table: TableDef<T, S>, conditions: WhereInput<T>, _options?: SelectOptions, _rawWhere?: {
+    private readonly _withRelations;
+    private readonly _includeDeleted;
+    constructor(adapter: VelnAdapter, hooks: HookExecutor, ctx: unknown, queue: RequestEventQueue | undefined, table: TableDef<T, S, any, TRelations>, conditions: WhereInput<T>, _options?: SelectOptions, _rawWhere?: {
         sql: string;
         params: BindingValue[];
-    }[], _dialect?: SqlDialect);
+    }[], _dialect?: SqlDialect, _withRelations?: string[], _includeDeleted?: boolean);
     private _cloneWith;
     private _clone;
+    /**
+     * Eager-load relations alongside the main query.
+     * One additional IN-query per relation — never N+1 regardless of row count.
+     *
+     * @example
+     * const posts = await db.from(postsTable).with({ author: true }).select()
+     * posts[0].author  // → User | null  (fully typed)
+     * posts[0].title   // → string       (original fields preserved)
+     */
+    with<Keys extends keyof TRelations & string>(relations: {
+        [K in Keys]: true;
+    }): SelectBuilder<WithRelations<T, {
+        relations: TRelations;
+    }, Keys>, S, TRelations>;
+    /**
+     * Include soft-deleted rows in the query result.
+     * By default, tables with `.withSoftDelete()` automatically exclude rows
+     * where the soft-delete column is not null.
+     *
+     * Has no effect on tables without soft delete configured.
+     *
+     * @example
+     * const allUsers = await db.from(usersTable).withDeleted().select()
+     */
+    withDeleted(): SelectBuilder<T, S, TRelations>;
     /**
      * Add WHERE conditions. Accepts:
      * - Plain equality map:   `.where({ role: 'admin' })`
@@ -354,7 +472,7 @@ declare class SelectBuilder<T, S extends SchemaMap> {
      *
      * Multiple `.where()` calls are combined with AND.
      */
-    where(conditions: WhereInput<T>): SelectBuilder<T, S>;
+    where(conditions: WhereInput<T>): SelectBuilder<T, S, TRelations>;
     /**
      * Append a raw SQL WHERE fragment, combined with AND.
      * Use for conditions the builder cannot express.
@@ -363,31 +481,61 @@ declare class SelectBuilder<T, S extends SchemaMap> {
      * .whereRaw('"score" > "threshold"', [])
      * .whereRaw('"created_at" > ?', ['2024-01-01'])
      */
-    whereRaw(sql: string, params: BindingValue[]): SelectBuilder<T, S>;
+    whereRaw(sql: string, params: BindingValue[]): SelectBuilder<T, S, TRelations>;
+    /**
+     * Apply SELECT DISTINCT — deduplicate rows in the result set.
+     * Combine with `.columns()` to deduplicate on specific columns.
+     *
+     * @example
+     * await db.from(usersTable).columns('name').distinct().select()
+     * // → SELECT DISTINCT "name" FROM "users"
+     */
+    distinct(): SelectBuilder<T, S, TRelations>;
     /** Limit the number of rows returned. Bound as a parameter — never interpolated. */
-    limit(n: number): SelectBuilder<T, S>;
+    limit(n: number): SelectBuilder<T, S, TRelations>;
     /** Skip the first n rows. Bound as a parameter — never interpolated. */
-    offset(n: number): SelectBuilder<T, S>;
+    offset(n: number): SelectBuilder<T, S, TRelations>;
     /** Add an ORDER BY clause. Multiple calls accumulate in order. */
-    orderBy(col: keyof T & string, dir?: 'ASC' | 'DESC'): SelectBuilder<T, S>;
+    orderBy(col: keyof T & string, dir?: 'ASC' | 'DESC'): SelectBuilder<T, S, TRelations>;
     /**
      * Convenience helper for cursor-based pagination.
      * page(1, 10) → LIMIT 10 OFFSET 0
      * page(2, 10) → LIMIT 10 OFFSET 10
      */
-    page(page: number, size: number): SelectBuilder<T, S>;
+    page(page: number, size: number): SelectBuilder<T, S, TRelations>;
     /**
      * Restrict which columns are returned.
-     * SELECT "id", "name" FROM "table" — instead of SELECT *
      *
-     * Return type is narrowed to Pick<T, K> for full type safety.
+     * Single-column form returns a ColumnRestrictedBuilder, enabling .subquery():
+     *   db.from(usersTable).columns('id').subquery()  // → SubqueryResult<'id', number>
+     *
+     * Multi-column form returns a narrowed SelectBuilder:
+     *   db.from(usersTable).columns('id', 'name')  // → SelectBuilder<Pick<User, 'id'|'name'>, ...>
+     */
+    columns<K extends keyof T & string>(col: K): ColumnRestrictedBuilder<K, T[K], S, TRelations>;
+    columns<K extends keyof T & string>(...cols: K[]): SelectBuilder<Pick<T, K>, S, TRelations>;
+    /**
+     * Build SELECT SQL + params without executing the query.
+     * Used internally by ColumnRestrictedBuilder.subquery().
      */
-    columns<K extends keyof T & string>(...cols: K[]): SelectBuilder<Pick<T, K>, S>;
+    /** Internal accessor for ColumnRestrictedBuilder / UnionBuilder — returns the adapter. */
+    _getAdapter(): VelnAdapter;
+    /** Internal accessor for ColumnRestrictedBuilder / UnionBuilder — returns the SQL dialect. */
+    _getDialect(): SqlDialect;
+    /**
+     * Returns the effective WHERE conditions, injecting the soft-delete IS NULL
+     * filter when the table has a soft-delete column and .withDeleted() was not called.
+     */
+    private _effectiveConditions;
+    _buildSelectSQL(): {
+        sql: string;
+        params: BindingValue[];
+    };
     /**
      * Add a GROUP BY clause. Multiple columns are comma-separated.
      * Combine with .aggregate() to get grouped aggregate results.
      */
-    groupBy(...cols: (keyof T & string)[]): SelectBuilder<T, S>;
+    groupBy(...cols: (keyof T & string)[]): SelectBuilder<T, S, TRelations>;
     /**
      * Add a HAVING clause — filters aggregate groups.
      * Uses the same WhereInput system as .where() (supports operators, OR/AND).
@@ -395,7 +543,7 @@ declare class SelectBuilder<T, S extends SchemaMap> {
      * @example
      * .groupBy('role').aggregate({ cnt: { fn: 'COUNT' } }).having({ cnt: { op: '>', value: 1 } })
      */
-    having(conditions: WhereInput<Record<string, unknown>>): SelectBuilder<T, S>;
+    having(conditions: WhereInput<Record<string, unknown>>): SelectBuilder<T, S, TRelations>;
     /**
      * Execute a GROUP BY + aggregate query.
      * Returns typed rows with group-by columns + aggregate aliases.
@@ -426,8 +574,133 @@ declare class SelectBuilder<T, S extends SchemaMap> {
     private _scalarAggregateRaw;
     select(): Promise<T[]>;
     first(): Promise<T | null>;
+    private _executeWith;
+    private _attachBelongsTo;
+    private _attachHasMany;
     update(patch: Partial<T>): Promise<T>;
+    /**
+     * Update multiple rows atomically inside a single transaction.
+     * Each row must include the primary key. beforeUpdate and afterUpdate hooks
+     * run per row. If any row fails, the entire transaction rolls back.
+     *
+     * @example
+     * const updated = await db.from(usersTable).updateMany([
+     *   { id: 1, name: 'Alice Updated' },
+     *   { id: 2, role: 'admin' },
+     * ])
+     */
+    updateMany(rows: InferUpdate<S>[]): Promise<T[]>;
     delete(): Promise<T>;
+    /**
+     * Soft-delete rows by setting the soft-delete column to the current timestamp.
+     * The table must have `.withSoftDelete()` configured — throws otherwise (at execute() time).
+     *
+     * Does NOT call beforeUpdate/afterUpdate hooks.
+     * Without .where(), all rows in the table are soft-deleted.
+     *
+     * @example
+     * await db.from(usersTable).softDelete().where({ id: 1 }).execute()
+     */
+    softDelete(): SoftDeleteBuilder<T, S>;
+    /**
+     * Restore soft-deleted rows by setting the soft-delete column back to null.
+     * The table must have `.withSoftDelete()` configured — throws otherwise (at execute() time).
+     *
+     * @example
+     * await db.from(usersTable).restore().where({ id: 1 }).execute()
+     */
+    restore(): SoftDeleteBuilder<T, S>;
+}
+declare class ColumnRestrictedBuilder<Col extends string, TCol, S extends SchemaMap, TRelations extends RelationsMap> {
+    private readonly _builder;
+    private readonly _col;
+    constructor(_builder: SelectBuilder<unknown, S, TRelations>, _col: Col);
+    where(conditions: WhereInput<Record<string, unknown>>): ColumnRestrictedBuilder<Col, TCol, S, TRelations>;
+    limit(n: number): ColumnRestrictedBuilder<Col, TCol, S, TRelations>;
+    orderBy(col: Col, dir?: 'ASC' | 'DESC'): ColumnRestrictedBuilder<Col, TCol, S, TRelations>;
+    /**
+     * Build the SQL for this query as a subquery fragment.
+     * The result can be used directly in WHERE IN / NOT IN conditions.
+     *
+     * @example
+     * const activeIds = db.from(usersTable).columns('id').where({ active: true }).subquery()
+     * // → SubqueryResult<'id', number>
+     *
+     * const posts = await db.from(postsTable)
+     *   .where({ authorId: { op: 'IN', value: activeIds } })
+     *   .select()
+     */
+    subquery(): SubqueryResult<Col, TCol>;
+    /** Build raw SELECT SQL + params without parentheses (for UNION). */
+    _buildRawSQL(): {
+        sql: string;
+        params: BindingValue[];
+    };
+    /**
+     * Combine this query with another same-type column query via UNION (deduplicates).
+     * Both sides must produce the same column type — enforced at compile time.
+     *
+     * @example
+     * db.from(usersTable).columns('id')
+     *   .union(db.from(adminsTable).columns('id'))
+     *   .select()
+     */
+    union(other: ColumnRestrictedBuilder<string, TCol, SchemaMap, RelationsMap>): UnionBuilder<TCol>;
+    /**
+     * Combine via UNION ALL — keeps duplicate rows.
+     */
+    unionAll(other: ColumnRestrictedBuilder<string, TCol, SchemaMap, RelationsMap>): UnionBuilder<TCol>;
+}
+declare class SoftDeleteBuilder<T, S extends SchemaMap> {
+    private readonly adapter;
+    private readonly table;
+    private readonly _value;
+    private readonly _dialect;
+    private _conditions;
+    constructor(adapter: VelnAdapter, table: TableDef<T, S>, _value: Date | null, _dialect?: SqlDialect);
+    /**
+     * Add WHERE conditions to scope which rows are soft-deleted / restored.
+     * Multiple calls accumulate with AND.
+     * Without .where(), all rows in the table are affected.
+     */
+    where(conditions: WhereInput<T>): this;
+    /**
+     * Execute the soft-delete or restore UPDATE.
+     * Throws if the table has no softDeleteColumn configured.
+     */
+    execute(): Promise<void>;
+}
+declare class UnionBuilder<T> {
+    private readonly _parts;
+    private readonly _kind;
+    private readonly _adapter;
+    private readonly _dialect;
+    private _orderBy?;
+    private _limit?;
+    constructor(_parts: Array<{
+        sql: string;
+        params: BindingValue[];
+    }>, _kind: 'UNION' | 'UNION ALL', _adapter: VelnAdapter, _dialect: SqlDialect);
+    /** Append another UNION (deduplicating) leg. */
+    union(other: ColumnRestrictedBuilder<string, T, SchemaMap, RelationsMap>): UnionBuilder<T>;
+    /** Append another UNION ALL (keep duplicates) leg. */
+    unionAll(other: ColumnRestrictedBuilder<string, T, SchemaMap, RelationsMap>): UnionBuilder<T>;
+    /** Add ORDER BY to the entire UNION result. */
+    orderBy(col: string, dir?: 'ASC' | 'DESC'): UnionBuilder<T>;
+    /** Add LIMIT to the entire UNION result. */
+    limit(n: number): UnionBuilder<T>;
+    /** Execute the UNION query and return typed rows. */
+    select(): Promise<Record<string, T>[]>;
+    /**
+     * Build the UNION as a subquery — wrapped in parentheses.
+     * Usable in WHERE IN / NOT IN conditions.
+     *
+     * @example
+     * const adminOrModIds = db.from(usersTable).columns('id').where({ role: 'admin' })
+     *   .union(db.from(usersTable).columns('id').where({ role: 'mod' }))
+     *   .subquery()
+     */
+    subquery(): SubqueryResult<string, T>;
 }
 declare class InsertBuilder<T, S extends SchemaMap> {
     private readonly adapter;
@@ -435,9 +708,24 @@ declare class InsertBuilder<T, S extends SchemaMap> {
     private readonly ctx;
     private readonly queue;
     private readonly table;
-    constructor(adapter: VelnAdapter, hooks: HookExecutor, ctx: unknown, queue: RequestEventQueue | undefined, table: TableDef<T, S>);
+    private readonly dialect;
+    constructor(adapter: VelnAdapter, hooks: HookExecutor, ctx: unknown, queue: RequestEventQueue | undefined, table: TableDef<T, S>, dialect?: SqlDialect);
     insert(data: InferInsert<S>): Promise<T>;
-    /** Serialize values for SQLite storage. Date → ISO string. */
+    /**
+     * Insert multiple rows in a single SQL statement.
+     * beforeInsert and afterInsert hooks run per row.
+     * Defaults (defaultFn / defaultValue) are applied per row.
+     *
+     * MySQL is not yet supported (no RETURNING *) — throws an informative error.
+     *
+     * @example
+     * const users = await db.into(usersTable).insertMany([
+     *   { name: 'Alice', email: 'alice@example.com' },
+     *   { name: 'Bob',   email: 'bob@example.com' },
+     * ])
+     */
+    insertMany(data: InferInsert<S>[]): Promise<T[]>;
+    /** Serialize values for storage. Date → ISO string. Drops undefined values. */
     private _serializeForInsert;
 }
 declare class JoinBuilder {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oakbun/ws",
-  "version": "0.1.1",
+  "version": "2.0.0",
   "description": "WebSocket plugin for the OakBun framework.",
   "author": "René (SchildW3rk)",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "oakbun": ">=0.1.1",
+    "oakbun": ">=0.3.0",
     "zod": "^3.0.0 || ^4.0.0"
   },
   "devDependencies": {