@vsrepo/drizzle-adapter 0.1.0 → 0.1.1

package/dist/index.d.cts

@@ -86,6 +86,7 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
     private readonly pk;
     private readonly queryKey;
     private readonly relations?;
+    private readonly relationsKeysSet?;
     constructor(db: K, config: DrizzleAdapterConfig<T, K>);
     /**
      * Returns `db.query[queryKey]` (the relational query builder entry for
@@ -130,6 +131,16 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
      * when they're actually used.
      */
     private resolveFindWhere;
+    /**
+     * Fetches the current row matching `where` (or `null` when none exists),
+     * using the same where-resolution path as `update` — the single place
+     * "find the row behind a where" is materialized.
+     *
+     * Internal callers that already fetched a row in their own transaction
+     * (`save`, `upsert`) use this to detect/create, then hand that same row
+     * to `updateCore` as `current`, so the row is only ever read once.
+     */
+    private findCurrentByWhere;
     /**
      * Strips relation fields from a payload — used by `createMany`/`updateMany`/
      * `updateManyReturning`, since batch statements only accept flat column
@@ -161,6 +172,20 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
     deleteMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
     deleteManyReturning(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
     update(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Shared implementation behind `update` — also reached from `save` and
+     * `upsert`, which pass in `current` (the row they already fetched in the
+     * same transaction) so the row is read only once instead of once per
+     * method. The `'update' found no record...` contract applies whenever it
+     * runs without a preloaded row (i.e. when called through the public
+     * `update`), and always as a safety net.
+     *
+     * Invariant: when `current` is provided, it must be the full row read
+     * from the exact `tx` referenced by `options.db` (never from outside a
+     * transaction, and never a pk-only projection — `resolveFkHereFields`
+     * reads the current FK values off it).
+     */
+    private updateCore;
     updateMany(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
     updateManyReturning(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
     count(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number>;
@@ -181,4 +206,12 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
     max(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
 }
 
-export { DrizzleAdapter, type DrizzleAdapterConfig, type DrizzleDbLike, type DrizzleTransactionLike, type SupportedDialects };
+/**
+ * @publicApi
+ */
+type DrizzleOrmTypes<T extends DrizzleDbLike> = {
+    dbClient: T;
+    dbTransaction: Parameters<Parameters<T["transaction"]>[0]>[0];
+};
+
+export { type AdapterRelation, type AdapterRelations, DrizzleAdapter, type DrizzleAdapterConfig, type DrizzleDbLike, type DrizzleOrmTypes, type DrizzleTransactionLike, type SupportedDialects, DrizzleAdapter as VSRepoDrizzleAdapter };

package/dist/index.d.ts

@@ -86,6 +86,7 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
     private readonly pk;
     private readonly queryKey;
     private readonly relations?;
+    private readonly relationsKeysSet?;
     constructor(db: K, config: DrizzleAdapterConfig<T, K>);
     /**
      * Returns `db.query[queryKey]` (the relational query builder entry for
@@ -130,6 +131,16 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
      * when they're actually used.
      */
     private resolveFindWhere;
+    /**
+     * Fetches the current row matching `where` (or `null` when none exists),
+     * using the same where-resolution path as `update` — the single place
+     * "find the row behind a where" is materialized.
+     *
+     * Internal callers that already fetched a row in their own transaction
+     * (`save`, `upsert`) use this to detect/create, then hand that same row
+     * to `updateCore` as `current`, so the row is only ever read once.
+     */
+    private findCurrentByWhere;
     /**
      * Strips relation fields from a payload — used by `createMany`/`updateMany`/
      * `updateManyReturning`, since batch statements only accept flat column
@@ -161,6 +172,20 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
     deleteMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
     deleteManyReturning(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
     update(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Shared implementation behind `update` — also reached from `save` and
+     * `upsert`, which pass in `current` (the row they already fetched in the
+     * same transaction) so the row is read only once instead of once per
+     * method. The `'update' found no record...` contract applies whenever it
+     * runs without a preloaded row (i.e. when called through the public
+     * `update`), and always as a safety net.
+     *
+     * Invariant: when `current` is provided, it must be the full row read
+     * from the exact `tx` referenced by `options.db` (never from outside a
+     * transaction, and never a pk-only projection — `resolveFkHereFields`
+     * reads the current FK values off it).
+     */
+    private updateCore;
     updateMany(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
     updateManyReturning(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
     count(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number>;
@@ -181,4 +206,12 @@ declare class DrizzleAdapter<T, K extends DrizzleDbLike = DrizzleDbLike> extends
     max(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
 }
 
-export { DrizzleAdapter, type DrizzleAdapterConfig, type DrizzleDbLike, type DrizzleTransactionLike, type SupportedDialects };
+/**
+ * @publicApi
+ */
+type DrizzleOrmTypes<T extends DrizzleDbLike> = {
+    dbClient: T;
+    dbTransaction: Parameters<Parameters<T["transaction"]>[0]>[0];
+};
+
+export { type AdapterRelation, type AdapterRelations, DrizzleAdapter, type DrizzleAdapterConfig, type DrizzleDbLike, type DrizzleOrmTypes, type DrizzleTransactionLike, type SupportedDialects, DrizzleAdapter as VSRepoDrizzleAdapter };

package/dist/index.js

@@ -309,16 +309,21 @@ function validateRelations(table, dialect, relations) {
 }
 
 // src/parsers/columns.parser.ts
-function parseColumns(select) {
+function parseColumns(select, relationsKeysSet) {
   const columns = {};
   let withResult;
   for (const [key, value] of Object.entries(select)) {
     if (value === void 0) continue;
-    if (isPlainObject(value)) {
+    if (typeof value !== "boolean") {
       withResult ??= {};
       const nested = parseColumns(value);
       withResult[key] = nested.with ? { columns: nested.columns, with: nested.with } : { columns: nested.columns };
     } else {
+      if (relationsKeysSet?.has(key)) {
+        withResult ??= {};
+        withResult[key] = value;
+        continue;
+      }
       columns[key] = value;
     }
   }
@@ -845,7 +850,7 @@ function mergeEntities(result, obj, relations) {
 }
 
 // src/resolvers/relation-writes.resolver.ts
-import { and as and2, eq as eq2, ne, notInArray as notInArray2 } from "drizzle-orm";
+import { and as and2, eq as eq2, notInArray as notInArray2 } from "drizzle-orm";
 import { AdapterErrorCode as AdapterErrorCode9, VSRepoAdapterError as VSRepoAdapterError9 } from "vsrepo";
 var SKIP = /* @__PURE__ */ Symbol("skip");
 function omitKey(item, key) {
@@ -888,7 +893,7 @@ async function resolveFkHereField(tx, relation, field, currentFkValue) {
   }
   const pkValue = field[relation.relatedPk];
   if (pkValue === void 0) {
-    const [created] = await tx.insert(relation.table).values(field).returning();
+    const [created] = await tx.insert(relation.table).values(field).returning({ [relation.relatedPk]: relation.table[relation.relatedPk] });
     return created[relation.relatedPk];
   }
   const existing = await tx.select({ pk: pkColumn }).from(relation.table).where(eq2(pkColumn, pkValue)).limit(1);
@@ -926,7 +931,7 @@ async function resolveOtmField(tx, relation, items, ownPkValue) {
   const withPk = items.filter((item) => item[relation.relatedPk] !== void 0);
   const connectedIds = [];
   for (const item of withoutPk) {
-    const [insertedRow] = await tx.insert(relation.table).values({ ...item, [relation.fkThere]: ownPkValue }).returning();
+    const [insertedRow] = await tx.insert(relation.table).values({ ...item, [relation.fkThere]: ownPkValue }).returning({ [relation.relatedPk]: relation.table[relation.relatedPk] });
     if (insertedRow?.[relation.relatedPk] !== void 0) {
       connectedIds.push(insertedRow[relation.relatedPk]);
     }
@@ -958,22 +963,25 @@ async function resolveOtoFkThereField(tx, relation, field, ownPkValue) {
     return;
   }
   const pkValue = field[relation.relatedPk];
-  let keepPk = pkValue;
+  const resolveSetData = async () => {
+    const setData = relation.restriction === "set" ? { ...omitKey(field, relation.relatedPk), [relation.fkThere]: ownPkValue } : { [relation.fkThere]: ownPkValue };
+    await tx.update(relation.table).set(setData).where(eq2(pkColumn, pkValue));
+  };
   if (pkValue === void 0) {
-    const [insertedRow] = await tx.insert(relation.table).values({ ...field, [relation.fkThere]: ownPkValue }).returning();
-    keepPk = insertedRow?.[relation.relatedPk];
+    const [otoRel] = await tx.select({ pk: pkColumn }).from(relation.table).where(eq2(fkColumn, ownPkValue)).limit(1);
+    if (!otoRel) {
+      await tx.insert(relation.table).values({ ...field, [relation.fkThere]: ownPkValue });
+    } else {
+      await resolveSetData();
+    }
   } else {
     const existing = await tx.select({ pk: pkColumn }).from(relation.table).where(eq2(pkColumn, pkValue)).limit(1);
     if (existing.length === 0) {
       await tx.insert(relation.table).values({ ...field, [relation.fkThere]: ownPkValue });
     } else {
-      const setData = relation.restriction === "set" ? { ...omitKey(field, relation.relatedPk), [relation.fkThere]: ownPkValue } : { [relation.fkThere]: ownPkValue };
-      await tx.update(relation.table).set(setData).where(eq2(pkColumn, pkValue));
+      await resolveSetData();
     }
   }
-  if (relation.restriction === "set" && keepPk !== void 0) {
-    await tx.delete(relation.table).where(and2(eq2(fkColumn, ownPkValue), ne(pkColumn, keepPk)));
-  }
 }
 async function resolveFkThereFields(tx, entries, ownPkValue) {
   for (const [key, relation, value] of entries) {
@@ -1007,6 +1015,7 @@ var DrizzleAdapter = class extends VSRepoAdapter {
   pk;
   queryKey;
   relations;
+  relationsKeysSet;
   constructor(db, config) {
     super();
     const validated = validateDrizzleAdapterConfig(db, config);
@@ -1017,6 +1026,9 @@ var DrizzleAdapter = class extends VSRepoAdapter {
     const fieldsConfig = resolveFieldsConfig(this.table);
     this.pk = fieldsConfig.pk;
     this.relations = validateRelations(this.table, this.dialect, validated.config.relations);
+    if (this.relations) {
+      this.relationsKeysSet = new Set(Object.keys(this.relations));
+    }
   }
   /**
    * Returns `db.query[queryKey]` (the relational query builder entry for
@@ -1039,7 +1051,7 @@ var DrizzleAdapter = class extends VSRepoAdapter {
     let columns;
     let withArg;
     if (options.select) {
-      const parsedSelect = parseColumns(options.select);
+      const parsedSelect = parseColumns(options.select, this.relationsKeysSet);
       columns = parsedSelect.columns;
       withArg = parsedSelect.with;
     } else if (options.relations) {
@@ -1118,6 +1130,21 @@ var DrizzleAdapter = class extends VSRepoAdapter {
       paginationApplied: opts?.limit !== void 0 || opts?.offset !== void 0
     };
   }
+  /**
+   * Fetches the current row matching `where` (or `null` when none exists),
+   * using the same where-resolution path as `update` — the single place
+   * "find the row behind a where" is materialized.
+   *
+   * Internal callers that already fetched a row in their own transaction
+   * (`save`, `upsert`) use this to detect/create, then hand that same row
+   * to `updateCore` as `current`, so the row is only ever read once.
+   */
+  async findCurrentByWhere(where, opts) {
+    const arg = {
+      where: (await this.resolveFindWhere(where, { db: opts?.db, limit: 1 })).where
+    };
+    return await this.getQueryBuilder(opts?.db).findFirst(arg) ?? null;
+  }
   /**
    * Strips relation fields from a payload — used by `createMany`/`updateMany`/
    * `updateManyReturning`, since batch statements only accept flat column
@@ -1227,12 +1254,18 @@ var DrizzleAdapter = class extends VSRepoAdapter {
         return await this.create(obj, options);
       }
       return await this.runTransactional(options?.db, async (tx) => {
-        const pkColumn = this.table[this.pk];
-        const existing = await tx.select({ pk: pkColumn }).from(this.table).where(eq3(pkColumn, pkValue)).limit(1);
-        if (existing.length === 0) {
+        const current = await this.findCurrentByWhere({ [this.pk]: pkValue }, {
+          db: tx
+        });
+        if (current === null) {
           return this.create(obj, { ...options, db: tx });
         }
-        return this.update({ [this.pk]: pkValue }, obj, { ...options, db: tx });
+        return this.updateCore(
+          { [this.pk]: pkValue },
+          obj,
+          { ...options, db: tx },
+          current
+        );
       });
     } catch (error) {
       throw mapDrizzleError(error, "save", this.dialect);
@@ -1259,7 +1292,7 @@ var DrizzleAdapter = class extends VSRepoAdapter {
           false
         );
         await resolveFkHereFields(tx, fkHereEntries, scalarFields, void 0);
-        const [created] = await tx.insert(this.table).values(scalarFields).returning();
+        const [created] = await tx.insert(this.table).values(scalarFields).returning({ [this.pk]: this.table[this.pk] });
         const ownPkValue = created[this.pk];
         await resolveFkThereFields(tx, fkThereEntries, ownPkValue);
         const readArg = await this.resolveReadArgs(
@@ -1267,7 +1300,7 @@ var DrizzleAdapter = class extends VSRepoAdapter {
           options
         );
         const result = await this.getQueryBuilder(tx).findFirst(readArg);
-        return result ?? created;
+        return result;
       });
     } catch (error) {
       throw mapDrizzleError(error, "create", this.dialect);
@@ -1281,7 +1314,7 @@ var DrizzleAdapter = class extends VSRepoAdapter {
       if (options?.ignoreConflicts) qb = qb.onConflictDoNothing();
       const result = await qb;
       const affected = resolveRawResult(this.dialect, result, true);
-      return { count: affected ?? data.length };
+      return { count: affected };
     } catch (error) {
       throw mapDrizzleError(error, "createMany", this.dialect);
     }
@@ -1339,42 +1372,53 @@ var DrizzleAdapter = class extends VSRepoAdapter {
   }
   async update(where, obj, options) {
     try {
-      return await this.runTransactional(options?.db, async (tx) => {
-        const current = await this.getQueryBuilder(tx).findFirst({
-          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where
-        });
-        if (!current) {
-          throw new VSRepoAdapterError10(
-            "'update' found no record matching the given 'where'.",
-            AdapterErrorCode10.NOT_FOUND,
-            null
-          );
-        }
-        const ownPkValue = current[this.pk];
-        const objAny = obj;
-        const { scalarFields, fkHereEntries, fkThereEntries } = splitWritePayload(
-          objAny,
-          this.relations,
-          this.pk,
-          true
-        );
-        await resolveFkHereFields(tx, fkHereEntries, scalarFields, current);
-        if (Object.keys(scalarFields).length > 0) {
-          const pkColumn = this.table[this.pk];
-          await tx.update(this.table).set(scalarFields).where(eq3(pkColumn, ownPkValue));
-        }
-        await resolveFkThereFields(tx, fkThereEntries, ownPkValue);
-        const readArg = await this.resolveReadArgs(
-          { [this.pk]: ownPkValue },
-          options
-        );
-        const result = await this.getQueryBuilder(tx).findFirst(readArg);
-        return result ?? current;
-      });
+      return await this.updateCore(where, obj, options);
     } catch (error) {
       throw mapDrizzleError(error, "update", this.dialect);
     }
   }
+  /**
+   * Shared implementation behind `update` — also reached from `save` and
+   * `upsert`, which pass in `current` (the row they already fetched in the
+   * same transaction) so the row is read only once instead of once per
+   * method. The `'update' found no record...` contract applies whenever it
+   * runs without a preloaded row (i.e. when called through the public
+   * `update`), and always as a safety net.
+   *
+   * Invariant: when `current` is provided, it must be the full row read
+   * from the exact `tx` referenced by `options.db` (never from outside a
+   * transaction, and never a pk-only projection — `resolveFkHereFields`
+   * reads the current FK values off it).
+   */
+  async updateCore(where, obj, options, current) {
+    return this.runTransactional(options?.db, async (tx) => {
+      const resolved = current ?? await this.findCurrentByWhere(where, { db: tx });
+      if (!resolved) {
+        throw new VSRepoAdapterError10(
+          "'update' found no record matching the given 'where'.",
+          AdapterErrorCode10.NOT_FOUND,
+          null
+        );
+      }
+      const ownPkValue = resolved[this.pk];
+      const objAny = obj;
+      const { scalarFields, fkHereEntries, fkThereEntries } = splitWritePayload(
+        objAny,
+        this.relations,
+        this.pk,
+        true
+      );
+      await resolveFkHereFields(tx, fkHereEntries, scalarFields, resolved);
+      if (Object.keys(scalarFields).length > 0) {
+        const pkColumn = this.table[this.pk];
+        await tx.update(this.table).set(scalarFields).where(eq3(pkColumn, ownPkValue));
+      }
+      await resolveFkThereFields(tx, fkThereEntries, ownPkValue);
+      const readArg = await this.resolveReadArgs({ [this.pk]: ownPkValue }, options);
+      const result = await this.getQueryBuilder(tx).findFirst(readArg);
+      return result;
+    });
+  }
   async updateMany(where, obj, options) {
     try {
       const executor = options?.db ?? this.db;
@@ -1436,15 +1480,15 @@ var DrizzleAdapter = class extends VSRepoAdapter {
   async upsert(where, create, update, options) {
     try {
       return await this.runTransactional(options?.db, async (tx) => {
-        const current = await this.getQueryBuilder(tx).findFirst({
-          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where
-        });
+        const current = await this.findCurrentByWhere(where, { db: tx });
         if (current) {
           const ownPkValue = current[this.pk];
-          return this.update({ [this.pk]: ownPkValue }, update, {
-            ...options,
-            db: tx
-          });
+          return this.updateCore(
+            { [this.pk]: ownPkValue },
+            update,
+            { ...options, db: tx },
+            current
+          );
         }
         return this.create(create, { ...options, db: tx });
       });
@@ -1457,7 +1501,11 @@ var DrizzleAdapter = class extends VSRepoAdapter {
     try {
       return await this.runTransactional(options?.db, async (tx) => {
         const current = await this.getQueryBuilder(tx).findFirst({
-          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where
+          where: (await this.resolveFindWhere(where, { db: tx, limit: 1 })).where,
+          // Only the pk is needed: atomic updates touch a single numeric
+          // column and never resolve relations — a full-row read here
+          // would ship the whole entity back to the client for nothing.
+          columns: { [this.pk]: true }
         });
         if (!current) {
           throw new VSRepoAdapterError10(
@@ -1520,6 +1568,7 @@ var DrizzleAdapter = class extends VSRepoAdapter {
   }
 };
 export {
-  DrizzleAdapter
+  DrizzleAdapter,
+  DrizzleAdapter as VSRepoDrizzleAdapter
 };
 //# sourceMappingURL=index.js.map