code-gen: support multiple 'viaXxx' in the query builder

packages/code-gen/src/generator/sql/query-builder.js

@@ -5,6 +5,7 @@ import { addToData } from "../../generate.js";
 import { upperCaseFirst } from "../../utils.js";
 import { js } from "../tag/tag.js";
 import { getTypeNameForType } from "../types.js";
+import { typeTable } from "./structure.js";
 import { getPrimaryKeyWithType, getQueryEnabledObjects } from "./utils.js";
 
 /**
@@ -397,13 +398,35 @@ if (!isNil(builder.${key}.limit)) {
          }
       `;
 
+    // Note that we need to the xxxIn params first before we can add xxxIn and set it
+    // to a query. The user may have set it to an array or another traverser may have
+    // set a query object already. To get the same guarantees ('AND') we convert
+    // arrays with values to a query part & if a query part exists, add 'INTERSECT'.
+    let sqlCastType = typeTable[type.keys[ownKey].type];
+    if (typeof sqlCastType === "function") {
+      sqlCastType = sqlCastType(type.keys[ownKey].type, false);
+    }
     const traverseJoinPart = js`
          if (builder.via${upperCaseFirst(relationKey)}) {
             builder.where = builder.where ?? {};
 
+            // Prepare ${ownKey}In
+            if (isQueryPart(builder.where.${ownKey}In)) {
+               builder.where.${ownKey}In.append(query\` INTERSECT \`);
+            } else if (Array.isArray(builder.where.${ownKey}In) && builder.where.${ownKey}In.length > 0) {
+               builder.where.${ownKey}In =
+                  query([
+                           "(SELECT value::${sqlCastType} FROM(values (",
+                           ...builder.where.${ownKey}In.map(() => "").join("), ("),
+                           ")) as ids(value)) INTERSECT "
+                        ], ...builder.where.${ownKey}In)
+            } else {
+               builder.where.${ownKey}In = query\`\`;
+            }
+
             ${getLimitOffset(true)}
 
-            builder.where.${ownKey}In = query\`
+            builder.where.${ownKey}In.append(query\`
           SELECT DISTINCT ${otherShortName}."${referencedKey}"
            $\{internalQuery${
              upperCaseFirst(otherSide.name) +
@@ -413,7 +436,7 @@ if (!isNil(builder.${key}.limit)) {
            }(
                builder.via${upperCaseFirst(relationKey)})}
            $\{offsetLimitQb} 
-        \`;
+        \`);
          }
       `;
 

packages/code-gen/src/generator/sql/structure.js

@@ -3,7 +3,7 @@ import { upperCaseFirst } from "../../utils.js";
 import { getQueryEnabledObjects, getSortedKeysForType } from "./utils.js";
 import { getSearchableFields } from "./where-type.js";
 
-const typeTable = {
+export const typeTable = {
   any: "jsonb",
   anyOf: "jsonb",
   array: "jsonb",
@@ -13,16 +13,19 @@ const typeTable = {
   /**
    *
    * @param {CodeGenNumberType} type
+   * @param {boolean} skipPrimary
    * @returns {string}
-   */ number: (type) =>
-    !type.sql?.primary
+   */ number: (type, skipPrimary) =>
+    !type.sql?.primary || skipPrimary
       ? type.validator.floatingPoint
         ? "float"
         : "int"
       : "BIGSERIAL PRIMARY KEY",
   object: "jsonb",
-  string: (type) => (type.sql?.primary ? "varchar PRIMARY KEY" : "varchar"),
-  uuid: (type) => (type.sql?.primary ? "uuid PRIMARY KEY" : "uuid"),
+  string: (type, skipPrimary) =>
+    type.sql?.primary && !skipPrimary ? "varchar PRIMARY KEY" : "varchar",
+  uuid: (type, skipPrimary) =>
+    type.sql?.primary && !skipPrimary ? "uuid PRIMARY KEY" : "uuid",
 };
 
 /**
@@ -77,7 +80,7 @@ function getFields(object) {
 
     let sqlType = typeTable[type.type];
     if (typeof sqlType === "function") {
-      sqlType = sqlType(type);
+      sqlType = sqlType(type, false);
     }
 
     let defaultValue = "";

packages/code-gen/test/sql.test.js

@@ -335,6 +335,23 @@ test("code-gen/e2e/sql", async (t) => {
     t.equal(dbUser.id, user.id);
   });
 
+  t.test("traverse with 'via' and idIn", async (t) => {
+    const [dbUser] = await client
+      .queryUser({
+        where: {
+          idIn: [post.writer],
+        },
+        viaPosts: {
+          where: {
+            id: post.id,
+          },
+        },
+      })
+      .exec(sql);
+
+    t.equal(dbUser.id, user.id);
+  });
+
   t.test("traverse via queryCategory", async (t) => {
     const builder = {
       viaPosts: {