@vsrepo/prisma7-adapter 2.0.0-dev → 2.0.0-dev.1

package/dist/parsers/data.parser.js

@@ -12,42 +12,53 @@ function splitByPk(items, pk) {
     }
     return { withPk, withoutPk };
 }
+/** `Relation.onUpdate` of a to-one relation when the config doesn't set one. */
+const DEFAULT_TO_ONE_STRATEGY = "connect";
+/** `Relation.onUpdate` of a to-many relation when the config doesn't set one. */
+const DEFAULT_TO_MANY_STRATEGY = "add";
+/** `Relation.onDisconnect` of a to-one relation when the config doesn't set one. */
+const DEFAULT_DISCONNECT_STRATEGY = "disconnect";
+/**
+ * `update` half of a to-one relation whose related object has its `pk`,
+ * according to the relation's `onUpdate` ({@link ToOneStrategy}).
+ */
+function resolveExistingToOneUpdate(strategy, pk, where, field) {
+    switch (strategy) {
+        case "connect":
+            return { connect: where };
+        case "connectOrCreate":
+            return { connectOrCreate: { where, create: field } };
+        case "upsert":
+            return { upsert: { where, create: field, update: omitKey(field, pk) } };
+    }
+}
 function parseToOneRelation(field, relation) {
+    const updateStrategy = relation.onUpdate ?? DEFAULT_TO_ONE_STRATEGY;
     if (field === null) {
-        if (!relation.nullable) {
-            throw new VSRepoAdapterError(`You cannot provide null for a to-one relation when it is not nullable.`, AdapterErrorCode.INVALID_DATA, null);
-        }
-        if (relation.mode === "oto") {
-            if (relation.restriction === "set") {
-                return { update: { delete: true } };
-            }
-            return { update: { disconnect: true } };
-        }
-        // relation.mode === "mto"
-        return { update: { disconnect: true } };
+        const disconnectStrategy = relation.onDisconnect ?? DEFAULT_DISCONNECT_STRATEGY;
+        return disconnectStrategy === "delete" ? { update: { delete: true } } : { update: { disconnect: true } };
+    }
+    if (relation.fkThere !== undefined) {
+        field = omitKey(field, relation.fkThere);
     }
     const pkValue = field[relation.pk];
     if (pkValue === undefined) {
         return {
             create: { create: field },
-            update: relation.restriction === "add" ? { create: field } : { upsert: { create: field, update: field } },
+            update: updateStrategy === "upsert" ? { upsert: { create: field, update: field } } : { create: field },
         };
     }
-    const connectOrCreate = { where: { [relation.pk]: pkValue }, create: field };
+    const where = { [relation.pk]: pkValue };
     return {
-        create: { connectOrCreate },
-        update: relation.restriction === "add"
-            ? { connectOrCreate }
-            : {
-                upsert: {
-                    where: { [relation.pk]: pkValue },
-                    create: field,
-                    update: omitKey(field, relation.pk),
-                },
-            },
+        create: { connectOrCreate: { where, create: field } },
+        update: resolveExistingToOneUpdate(updateStrategy, relation.pk, where, field),
     };
 }
 function parseToManyRelation(field, relation) {
+    const updateStrategy = relation.onUpdate ?? DEFAULT_TO_MANY_STRATEGY;
+    if (relation.fkThere !== undefined) {
+        field = field.map(f => omitKey(f, relation.fkThere));
+    }
     const { withPk, withoutPk } = splitByPk(field, relation.pk);
     const connectOrCreate = withPk.map(item => ({
         where: { [relation.pk]: item[relation.pk] },
@@ -61,7 +72,7 @@ function parseToManyRelation(field, relation) {
             update: omitKey(item, relation.pk),
         }));
     const create = { create: withoutPk, connectOrCreate };
-    if (relation.restriction === "add") {
+    if (updateStrategy === "add") {
         return {
             create,
             update: relation.mode === "mtm" ? { create: withoutPk, connectOrCreate } : { create: withoutPk, upsert },
@@ -80,9 +91,12 @@ function parseToManyRelation(field, relation) {
             },
     };
 }
-export function parsePrismaWriteData(obj, pkName, relations, omitPkInUpdate = false) {
-    const create = {};
-    const update = {};
+export function parsePrismaWriteData(obj, pkName, relations, omitPkInUpdate = false, allowOmitPkWhenNeeded = false) {
+    let create = {};
+    let update = {};
+    /** Relation fields that hold their FK in this entity, and those FK fields. */
+    const fkHereRelations = [];
+    const keysToOmit = [];
     for (const [key, field] of Object.entries(obj)) {
         if (field === undefined)
             continue;
@@ -93,7 +107,13 @@ export function parsePrismaWriteData(obj, pkName, relations, omitPkInUpdate = fa
                 update[key] = field;
             continue;
         }
+        if (relation === "ignore")
+            continue;
         if (relation.mode === "oto" || relation.mode === "mto") {
+            if (relation.fkHere !== undefined) {
+                fkHereRelations.push(key);
+                keysToOmit.push(relation.fkHere);
+            }
             const parsed = parseToOneRelation(field, relation);
             if (parsed.create !== undefined)
                 create[key] = parsed.create;
@@ -105,5 +125,24 @@ export function parsePrismaWriteData(obj, pkName, relations, omitPkInUpdate = fa
         create[key] = parsed.create;
         update[key] = parsed.update;
     }
+    if (fkHereRelations.length) {
+        if (obj[pkName] !== undefined) {
+            if (!allowOmitPkWhenNeeded) {
+                const fields = fkHereRelations.map(name => `'${name}'`).join(", ");
+                throw new VSRepoAdapterError(`Cannot send the primary key '${pkName}' together with the relation field(s) ${fields}: ` +
+                    `they hold their foreign key in this same entity, and Prisma rejects the primary key ` +
+                    `in a nested write of that kind ("Unknown argument"). ` +
+                    `Either remove '${pkName}' from the payload, or set 'allowOmitPk: true' (in the adapter ` +
+                    `config, or globally through 'setGlobalConfig') so the adapter drops it. Note that, with ` +
+                    `'allowOmitPk', a record that doesn't exist yet is created with a database-generated ` +
+                    `'${pkName}' instead of the one you sent.`, AdapterErrorCode.INVALID_DATA, null);
+            }
+            keysToOmit.push(pkName);
+        }
+        for (const key of keysToOmit) {
+            create = omitKey(create, key);
+            update = omitKey(update, key);
+        }
+    }
     return { create, update };
 }

package/dist/prisma7.adapter.d.ts

@@ -1,6 +1,7 @@
 import { AdapterMethodOptions, AdapterQueryOptions, CountResult, DeepPartial, NumericKeys, RestrictAdapterMethodOptions, SimpleAdapterMethodOptions, VSRepoAdapter, VSRepoTransactionOptions, VSRepoWhere, WithIgnoreConflicts } from "vsrepo";
 import { Prisma7AdapterConfig } from "./types/adapter-config.type.js";
 import { Prisma7ClientLike } from "./types/prisma7-client-like.type.js";
+import { Prisma7GlobalConfig } from "./types/prisma7-global-config.type.js";
 /**
  * `VSRepoAdapter` implementation for Prisma 7.
  *
@@ -15,7 +16,16 @@ export declare class VSRepoPrisma7Adapter<T, K extends Prisma7ClientLike = Prism
     private readonly relations?;
     private readonly logger;
     private readonly provider;
+    /** Whether the primary key may be dropped from a write payload when Prisma can't take it. */
+    private readonly allowOmitPk?;
+    private static globalConfig;
     constructor(prisma: K, config: Prisma7AdapterConfig<T, K>);
+    /**
+     * Sets defaults (`provider`, `logLevel`, `allowOmitPk`) for every adapter
+     * created **after** this call. It replaces the previous global config, and
+     * the config passed to each adapter's constructor takes precedence.
+     */
+    static setGlobalConfig(globalConfig: Prisma7GlobalConfig): void;
     private getPrismaRepository;
     /** Resolves the "read" part of a Prisma arg: select/include/orderBy/pagination. */
     private resolveReadArg;
@@ -89,6 +99,8 @@ export declare class VSRepoPrisma7Adapter<T, K extends Prisma7ClientLike = Prism
     /** Runs `fn` inside a native transaction of the underlying ORM/database. */
     runInTransaction<R>(fn: (tx: any) => Promise<R>, options?: VSRepoTransactionOptions): Promise<R>;
     private execMethod;
+    /** Runs `parsePrismaWriteData` with this adapter's `pkName`, `relations` and `allowOmitPk`. */
+    private parseData;
     /** Fetches a single record matching `where`. */
     findOne(where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T | null>;
     /** Fetches a single record matching `where`, throwing if none is found. */

package/dist/prisma7.adapter.js

@@ -24,6 +24,9 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
     relations;
     logger;
     provider;
+    /** Whether the primary key may be dropped from a write payload when Prisma can't take it. */
+    allowOmitPk;
+    static globalConfig = {};
     constructor(prisma, config) {
         super();
         this.prisma = prisma;
@@ -31,9 +34,18 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
         this.modelName = config.modelName;
         this.pkName = config.pkName;
         this.relations = config.relations;
-        this.provider = resolveProvider(prisma, config.provider);
-        this.logger = new VSLogger(config.logLevel ?? VSLogLevel.WARN, this.constructor.name + "Logger");
-        this.logger.logInfo(`${this.constructor.name} initialized for table '${this.modelName}' (pkName: '${this.pkName}'${this.relations ? `, relations: [${Object.keys(this.relations).join(", ")}]` : ""}, provider: ${this.provider ? `'${this.provider}'` : "<not detected>"})`);
+        this.provider = resolveProvider(prisma, config.provider ?? VSRepoPrisma7Adapter.globalConfig.provider);
+        this.logger = new VSLogger(config.logLevel ?? VSRepoPrisma7Adapter.globalConfig.logLevel ?? VSLogLevel.WARN, this.constructor.name + "Logger");
+        this.allowOmitPk = config.allowOmitPk ?? VSRepoPrisma7Adapter.globalConfig.allowOmitPk;
+        this.logger.logInfo(`${this.constructor.name} initialized for table '${this.modelName}' (pkName: '${this.pkName}'${this.relations ? `, relations: [${Object.keys(this.relations).join(", ")}]` : ""}, provider: ${this.provider ? `'${this.provider}'` : "<not detected>"}${this.allowOmitPk ? ", allowOmitPk: true" : ""})`);
+    }
+    /**
+     * Sets defaults (`provider`, `logLevel`, `allowOmitPk`) for every adapter
+     * created **after** this call. It replaces the previous global config, and
+     * the config passed to each adapter's constructor takes precedence.
+     */
+    static setGlobalConfig(globalConfig) {
+        this.globalConfig = globalConfig;
     }
     getPrismaRepository(db) {
         return db ? db[this.modelName] : this.prisma[this.modelName];
@@ -240,6 +252,10 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
             throw mapPrismaError(error, methodName);
         }
     }
+    /** Runs `parsePrismaWriteData` with this adapter's `pkName`, `relations` and `allowOmitPk`. */
+    parseData(obj, omitPkInUpdate) {
+        return parsePrismaWriteData(obj, this.pkName, this.relations, omitPkInUpdate, this.allowOmitPk);
+    }
     /** Fetches a single record matching `where`. */
     async findOne(where, options) {
         const arg = { ...this.resolveReadArg(options), where: this.parseWhere(where) };
@@ -261,7 +277,7 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
         const pkValue = objAny[this.pkName];
         const readArg = this.resolveReadArg({ select: options?.select, relations: options?.relations });
         const repo = this.getPrismaRepository(options?.db);
-        const { create, update } = parsePrismaWriteData(objAny, this.pkName, this.relations, true);
+        const { create, update } = this.parseData(objAny, true);
         if (pkValue === undefined) {
             const arg = { ...readArg, data: create };
             return this.execMethod(() => repo.create(arg), "save (create)", arg);
@@ -362,7 +378,7 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
     }
     /** Updates a single record matching `where`. */
     async update(where, obj, options) {
-        const { update } = parsePrismaWriteData(obj, this.pkName, this.relations);
+        const { update } = this.parseData(obj);
         const arg = {
             ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
             where: this.parseWhere(where),
@@ -445,7 +461,7 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
     }
     /** Creates a single record. */
     async create(obj, options) {
-        const { create } = parsePrismaWriteData(obj, this.pkName, this.relations);
+        const { create } = this.parseData(obj);
         const arg = {
             ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
             data: create,
@@ -531,8 +547,8 @@ export class VSRepoPrisma7Adapter extends VSRepoAdapter {
     // }
     /** Creates a record if none matches `where`, otherwise updates it. */
     async upsert(where, create, update, options) {
-        const parsedCreate = parsePrismaWriteData(create, this.pkName, this.relations).create;
-        const parsedUpdate = parsePrismaWriteData(update, this.pkName, this.relations).update;
+        const parsedCreate = this.parseData(create).create;
+        const parsedUpdate = this.parseData(update).update;
         const arg = {
             ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
             where: this.parseWhere(where),

package/dist/types/adapter-config.type.d.ts

@@ -30,4 +30,20 @@ export interface Prisma7AdapterConfig<T = any, K extends Prisma7ClientLike = Pri
     provider?: PrismaProvider;
     /** Minimum log level for the adapter's internal `VSLogger`. @default VSLogLevel.WARN */
     logLevel?: VSLogLevel;
+    /**
+     * Lets the adapter drop the primary key from a write payload when it can't
+     * be sent. That happens when the payload has a relation that holds its
+     * foreign key in this same entity (`fkHere`, e.g. `Address.user`): Prisma
+     * doesn't accept the primary key in that kind of nested write. When `false`,
+     * such a payload throws `INVALID_DATA`.
+     *
+     * **Careful:** with this on, `save` with a primary key that doesn't exist
+     * yet creates the record with a database-generated key, not the one you
+     * sent. Only enable it if you really need it and if the database (not your
+     * application) generates the ids. Falls back to the global config
+     * (`setGlobalConfig`) when omitted.
+     *
+     * @default false
+     */
+    allowOmitPk?: boolean;
 }

package/dist/types/adapter-relations.type.d.ts

@@ -1,16 +1,22 @@
 import type { RelationKeys } from "vsrepo";
 import { Relation } from "./relation.type.js";
 /**
- * Relation configuration for entity `T`, used by the `create`/`update`
- * parsers to resolve relation fields according to the v1 behavior (see
- * `Relation`).
+ * Relation configuration for entity `T`, used by the write parsers to resolve
+ * relation fields into Prisma nested writes (see `Relation`).
  *
- * Keyed by the relation fields of `T` (`RelationKeys<T>`). Without this
- * configuration (adapter built without `relations`), relation fields are
- * passed through to Prisma as-is, with no special resolution.
+ * Keyed by the relation fields of `T` (`RelationKeys<T>`). Each value is either:
+ *
+ * - a `Relation` config, whose options depend on its `mode`; or
+ * - `"ignore"`, which leaves the field out of every write (`create`, `update`,
+ *   `save`...). Use it for a relation you load but don't want to persist
+ *   through this entity. Since the relation object is dropped, a scalar FK in
+ *   the payload (e.g. `userId`) is sent as is, together with the primary key.
+ *
+ * Without this configuration (adapter built without `relations`), relation
+ * fields are passed through to Prisma as-is, with no special resolution.
  *
  * @publicApi
  */
 export type AdapterRelations<T> = Partial<{
-    [P in RelationKeys<T>]: Relation<NonNullable<T[P]> extends Array<infer U> ? U : NonNullable<T[P]>>;
+    [P in RelationKeys<T>]: "ignore" | Relation<NonNullable<T[P]> extends Array<infer U> ? U : NonNullable<T[P]>, T>;
 }>;

package/dist/types/prisma7-global-config.type.d.ts

@@ -0,0 +1,17 @@
+import { VSLogLevel } from "vsrepo";
+import { PrismaProvider } from "./prisma-provider.type.js";
+/**
+ * Defaults applied to every adapter instance, set through
+ * `VSRepoPrisma7Adapter.setGlobalConfig`. A field set in an adapter's own
+ * config wins over the global one.
+ *
+ * @publicApi
+ */
+export type Prisma7GlobalConfig = {
+    /** Default `provider` (see `Prisma7AdapterConfig.provider`). */
+    provider?: PrismaProvider;
+    /** Default `logLevel` (see `Prisma7AdapterConfig.logLevel`). */
+    logLevel?: VSLogLevel;
+    /** Default `allowOmitPk` (see `Prisma7AdapterConfig.allowOmitPk`). @default false */
+    allowOmitPk?: boolean;
+};

package/dist/types/prisma7-global-config.type.js

@@ -0,0 +1 @@
+export {};

package/dist/types/relation.type.d.ts

@@ -1,35 +1,123 @@
 /**
- * Configuration of a single relation field.
+ * Cardinality of a relation from the point of view of the entity that owns the
+ * field: `oto` = one-to-one, `mto` = many-to-one, `otm` = one-to-many and
+ * `mtm` = many-to-many.
  *
  * @publicApi
  */
-export interface Relation<T = any> {
+export type RelationMode = "oto" | "mto" | "otm" | "mtm";
+/**
+ * How a to-one relation (`oto`/`mto`) is written on update when the related
+ * object has its `pk`. Pick it through `Relation.onUpdate`.
+ *
+ * - `"connect"` (default) — only connects the record. It never creates nor
+ *   overwrites the related record, so re-sending the one that is already
+ *   connected is a no-op and switching to another record works. Fails with
+ *   Prisma's `P2025` when the record doesn't exist.
+ * - `"connectOrCreate"` — connects the record, creating it when missing.
+ * - `"upsert"` — updates the related record with the fields you sent (everything
+ *   but its `pk`), creating it when missing.
+ *
+ * Without the related `pk` there is nothing to connect to: the record is
+ * created (`"upsert"` still sends its fields as the `update`).
+ *
+ * @publicApi
+ */
+export type ToOneStrategy = "connect" | "connectOrCreate" | "upsert";
+/**
+ * How a to-many relation (`otm`/`mtm`) is written on update. Pick it through
+ * `Relation.onUpdate`.
+ *
+ * - `"add"` (default) — only creates/connects/upserts the items you send.
+ *   Whatever else is already related is left untouched.
+ * - `"set"` — also removes (`otm`: `deleteMany`) or disconnects (`mtm`: `set`)
+ *   every related item that wasn't sent.
+ *
+ * @publicApi
+ */
+export type ToManyStrategy = "add" | "set";
+/**
+ * What sending `null` to a to-one relation does on update. Pick it through
+ * `Relation.onDisconnect`.
+ *
+ * - `"disconnect"` (default) — detaches the related record and keeps it.
+ *   Needs the relation (its FK) to be optional.
+ * - `"delete"` — deletes the related record. It is always opt-in. On an `mto`
+ *   the related record is shared with other rows, so deleting it affects all of them.
+ *
+ * @publicApi
+ */
+export type DisconnectStrategy = "disconnect" | "delete";
+/** Options shared by every relation mode. */
+type RelationBase<T, M extends RelationMode> = {
     /**
      * Cardinality of the relation from the point of view of the entity
-     * that owns the field (`oto` = one-to-one, `mto` = many-to-one,
-     * `otm` = one-to-many, `mtm` = many-to-many).
+     * that owns the field. It decides which of the other options are available.
      */
-    mode: "otm" | "mtm" | "mto" | "oto";
-    /**
-     * How `save`/`update`/`upsert` handle to-many relations
-     * (`otm`/`mtm`) and to-one relations pointing to an already-existing record
-     * (matched by `pk`) — `"add"` only creates/connects the items that were
-     * sent (upsert per item), `"set"` also removes/disconnects whatever wasn't
-     * sent.
-     */
-    restriction: "set" | "add";
+    mode: M;
     /**
      * Name of the field used as the identifier of the related record,
      * used to decide between `create` (no pk in the payload) and
-     * `connectOrCreate`/`upsert` (pk present).
+     * connecting to / upserting an existing record (pk present).
+     */
+    pk: keyof T & string;
+    /**
+     * Name of the scalar foreign key that lives in the **related** entity —
+     * e.g. `userId` in `User.address`, where `Address` holds the FK. The
+     * adapter strips it from the related payload(s) before building the
+     * nested write, since the relation already sets it.
+     */
+    fkThere?: keyof T & string;
+};
+/** Options of the `oto` and `mto` relations. */
+type ToOneOptions<K> = {
+    /**
+     * Name of the scalar foreign key that lives in **this** entity (the one
+     * that owns the relation field) — e.g. `userId` in `Address.user`. Set it
+     * on the owning side of the relation.
+     *
+     * Prisma doesn't accept the scalar FK next to the relation object, so when
+     * the relation is in the payload the adapter drops this field from
+     * `create` and `update`. For the same reason it also can't keep the
+     * entity's primary key: if the payload has one, the write throws
+     * `INVALID_DATA` unless `allowOmitPk` is enabled (see
+     * `Prisma7AdapterConfig.allowOmitPk`).
+     */
+    fkHere?: keyof K & string;
+    /**
+     * How the related record is written on update when the payload has its `pk`.
+     * @default "connect"
+     */
+    onUpdate?: ToOneStrategy;
+    /**
+     * What sending `null` does on update.
+     * @default "disconnect"
      */
-    pk: keyof T;
+    onDisconnect?: DisconnectStrategy;
+};
+/** Options of the `otm` and `mtm` relations. */
+type ToManyOptions = {
     /**
-     * For `oto`/`mto` relations, whether the field accepts being set
-     * to `null`. When `true`, sending `null` on update resolves to `delete`
-     * (`oto` + `restriction: "set"`) or `disconnect` (`oto` + `restriction:
-     * "add"`, and `mto`). When `false`/omitted, sending `null` for a to-one
-     * relation throws a `VSRepoAdapterError` (code `INVALID_DATA`).
+     * How the related items are written on update.
+     * @default "add"
      */
-    nullable?: boolean;
-}
+    onUpdate?: ToManyStrategy;
+};
+/**
+ * Configuration of a single relation field:
+ *
+ * - `oto` and `mto`: `fkHere`, `fkThere`, `onUpdate` ({@link ToOneStrategy}) and
+ *   `onDisconnect` ({@link DisconnectStrategy}).
+ * - `otm` and `mtm`: `fkThere` and `onUpdate` ({@link ToManyStrategy}).
+ *
+ * Set a relation to `"ignore"` in `AdapterRelations` to leave it out of every
+ * write (see `AdapterRelations`).
+ *
+ * @template T Type of the related entity.
+ * @template K Type of the entity that owns the relation field.
+ * @template M Narrows the config to some of the modes (all of them by default).
+ *
+ * @publicApi
+ */
+export type Relation<T = any, K = any, M extends RelationMode = RelationMode> = M extends "oto" | "mto" ? RelationBase<T, M> & ToOneOptions<K> : M extends "otm" | "mtm" ? RelationBase<T, M> & ToManyOptions : never;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vsrepo/prisma7-adapter",
-  "version": "2.0.0-dev",
+  "version": "2.0.0-dev.1",
   "author": {
     "email": "joaodev.azevedo@outlook.com",
     "url": "https://github.com/jaobrabo123",
@@ -15,7 +15,7 @@
     "@prisma/adapter-better-sqlite3": "^7.10.1",
     "@prisma/adapter-mariadb": "^7.10.1",
     "@prisma/adapter-mssql": "^7.10.1",
-    "@prisma/adapter-pg": "^7.10.0",
+    "@prisma/adapter-pg": "^7.10.1",
     "@types/better-sqlite3": "^9.6.0",
     "@types/mssql": "^12.3.0",
     "@types/node": "^26.4.0",
@@ -26,14 +26,14 @@
     "oxlint-tsgolint": "^7.0.2005",
     "pg": "^8.23.0",
     "prettier": "^3.9.10",
-    "prisma": "^7.10.0",
+    "prisma": "^7.10.1",
     "tsx": "^4.23.12",
     "typescript": "^7.0.2",
     "vitest": "^5.0.5"
   },
   "peerDependencies": {
-    "@prisma/client": "^7.10.0",
-    "vsrepo": "^3.0.0-dev.2"
+    "@prisma/client": "^7.10.1",
+    "vsrepo": "^3.0.0-dev.3"
   },
   "exports": {
     ".": {
@@ -78,8 +78,8 @@
     "lint:fix": "oxlint --fix src/ test/",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
-    "format:docs": "prettier --write \"docs/**/*.md\" \"./*.md\"",
-    "format:docs:check": "prettier --check \"docs/**/*.md\" \"./*.md\"",
+    "format:docs": "prettier --write \"./*.md\"",
+    "format:docs:check": "prettier --check \"./*.md\"",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:cov": "vitest run --coverage",