@vsrepo/drizzle-adapter 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -20,7 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  DrizzleAdapter: () => DrizzleAdapter
+  DrizzleAdapter: () => DrizzleAdapter,
+  VSRepoDrizzleAdapter: () => DrizzleAdapter
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -331,16 +332,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;
     }
   }
@@ -893,7 +899,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((0, import_drizzle_orm8.eq)(pkColumn, pkValue)).limit(1);
@@ -931,7 +937,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]);
     }
@@ -963,22 +969,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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(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((0, import_drizzle_orm8.eq)(pkColumn, pkValue));
+      await resolveSetData();
     }
   }
-  if (relation.restriction === "set" && keepPk !== void 0) {
-    await tx.delete(relation.table).where((0, import_drizzle_orm8.and)((0, import_drizzle_orm8.eq)(fkColumn, ownPkValue), (0, import_drizzle_orm8.ne)(pkColumn, keepPk)));
-  }
 }
 async function resolveFkThereFields(tx, entries, ownPkValue) {
   for (const [key, relation, value] of entries) {
@@ -1012,6 +1021,7 @@ var DrizzleAdapter = class extends import_vsrepo10.VSRepoAdapter {
   pk;
   queryKey;
   relations;
+  relationsKeysSet;
   constructor(db, config) {
     super();
     const validated = validateDrizzleAdapterConfig(db, config);
@@ -1022,6 +1032,9 @@ var DrizzleAdapter = class extends import_vsrepo10.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
@@ -1044,7 +1057,7 @@ var DrizzleAdapter = class extends import_vsrepo10.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) {
@@ -1123,6 +1136,21 @@ var DrizzleAdapter = class extends import_vsrepo10.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
@@ -1232,12 +1260,18 @@ var DrizzleAdapter = class extends import_vsrepo10.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((0, import_drizzle_orm9.eq)(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);
@@ -1264,7 +1298,7 @@ var DrizzleAdapter = class extends import_vsrepo10.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(
@@ -1272,7 +1306,7 @@ var DrizzleAdapter = class extends import_vsrepo10.VSRepoAdapter {
           options
         );
         const result = await this.getQueryBuilder(tx).findFirst(readArg);
-        return result ?? created;
+        return result;
       });
     } catch (error) {
       throw mapDrizzleError(error, "create", this.dialect);
@@ -1286,7 +1320,7 @@ var DrizzleAdapter = class extends import_vsrepo10.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);
     }
@@ -1344,42 +1378,53 @@ var DrizzleAdapter = class extends import_vsrepo10.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 import_vsrepo10.VSRepoAdapterError(
-            "'update' found no record matching the given 'where'.",
-            import_vsrepo10.AdapterErrorCode.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((0, import_drizzle_orm9.eq)(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 import_vsrepo10.VSRepoAdapterError(
+          "'update' found no record matching the given 'where'.",
+          import_vsrepo10.AdapterErrorCode.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((0, import_drizzle_orm9.eq)(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;
@@ -1441,15 +1486,15 @@ var DrizzleAdapter = class extends import_vsrepo10.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 });
       });
@@ -1462,7 +1507,11 @@ var DrizzleAdapter = class extends import_vsrepo10.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 import_vsrepo10.VSRepoAdapterError(
@@ -1526,6 +1575,7 @@ var DrizzleAdapter = class extends import_vsrepo10.VSRepoAdapter {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DrizzleAdapter
+  DrizzleAdapter,
+  VSRepoDrizzleAdapter
 });
 //# sourceMappingURL=index.cjs.map