orchid-orm 1.6.3 → 1.6.4

package/dist/index.mjs

@@ -363,36 +363,41 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
-    const throughTable = throughRelation.table;
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceQuery = sourceRelation.joinQuery(throughRelation.query, sourceRelation.query).as(relationName);
+    const whereExistsCallback = () => sourceQuery;
     return {
       returns: "one",
       method: (params) => {
         const throughQuery = table[through](params);
-        return query.whereExists(throughTable, () => sourceQuery.merge(throughQuery));
+        return query.whereExists(
+          throughQuery,
+          whereExistsCallback
+        );
       },
       joinQuery(fromQuery, toQuery) {
-        return toQuery.whereExists(throughTable, () => {
-          const as = getQueryAs(toQuery);
-          return throughRelation.joinQuery(fromQuery, throughRelation.query).merge(
-            sourceRelation.joinQuery(
+        return toQuery.whereExists(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          () => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
               throughRelation.query,
               sourceRelation.query.as(as)
-            )
-          );
-        });
+            );
+          }
+        );
       },
       reverseJoin(fromQuery, toQuery) {
-        return fromQuery.whereExists(throughTable, () => {
-          const as = getQueryAs(toQuery);
-          return throughRelation.joinQuery(fromQuery, throughRelation.query).merge(
-            sourceRelation.joinQuery(
+        return fromQuery.whereExists(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          () => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
               throughRelation.query,
               sourceRelation.query.as(as)
-            )
-          );
-        });
+            );
+          }
+        );
       },
       primaryKey: sourceRelation.primaryKey
     };
@@ -550,40 +555,45 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
-    const throughTable = throughRelation.table.as(through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceRelationQuery = sourceRelation.query.as(relationName);
     const sourceQuery = sourceRelation.joinQuery(
       throughRelation.query,
       sourceRelationQuery
     );
+    const whereExistsCallback = () => sourceQuery;
     return {
       returns: "many",
       method: (params) => {
         const throughQuery = table[through](params);
-        return query.whereExists(throughTable, () => sourceQuery.merge(throughQuery));
+        return query.whereExists(
+          throughQuery,
+          whereExistsCallback
+        );
       },
       joinQuery(fromQuery, toQuery) {
-        return toQuery.whereExists(throughTable, () => {
-          const as = getQueryAs(toQuery);
-          return throughRelation.joinQuery(fromQuery, throughRelation.query).merge(
-            sourceRelation.joinQuery(
+        return toQuery.whereExists(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          () => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
               throughRelation.query,
               sourceRelation.query.as(as)
-            )
-          );
-        });
+            );
+          }
+        );
       },
       reverseJoin(fromQuery, toQuery) {
-        return fromQuery.whereExists(throughTable, () => {
-          const as = getQueryAs(toQuery);
-          return throughRelation.joinQuery(fromQuery, throughRelation.query).merge(
-            sourceRelation.joinQuery(
+        return fromQuery.whereExists(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          () => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
               throughRelation.query,
               sourceRelation.query.as(as)
-            )
-          );
-        });
+            );
+          }
+        );
       },
       primaryKey: sourceRelation.primaryKey
     };
@@ -790,6 +800,13 @@ class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
     );
   }
 }
+const removeColumnName = (column) => {
+  if (!column.data.name)
+    return column;
+  const cloned = Object.create(column);
+  cloned.data = __spreadProps$3(__spreadValues$4({}, column.data), { name: void 0 });
+  return cloned;
+};
 const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
   const {
     primaryKey: pk,
@@ -805,8 +822,8 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
   baseQuery.baseQuery = baseQuery;
   baseQuery.table = joinTable;
   baseQuery.shape = {
-    [fk]: table.shape[pk],
-    [afk]: query.shape[apk]
+    [fk]: removeColumnName(table.shape[pk]),
+    [afk]: removeColumnName(query.shape[apk])
   };
   baseQuery.query = __spreadProps$3(__spreadValues$4({}, baseQuery.query), {
     shape: baseQuery.shape
@@ -839,15 +856,19 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       state
     ),
     joinQuery(fromQuery, toQuery) {
-      return toQuery.whereExists(
+      const join = toQuery.whereExists(
         subQuery,
-        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${pk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
+        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${apk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
       );
+      join.query.joinedShapes = __spreadProps$3(__spreadValues$4({}, join.query.joinedShapes), {
+        [fromQuery.query.as || fromQuery.table]: fromQuery.query.shape
+      });
+      return join;
     },
     reverseJoin(fromQuery, toQuery) {
       return fromQuery.whereExists(
         subQuery,
-        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${pk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
+        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${apk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
       );
     },
     primaryKey: pk,
@@ -1211,11 +1232,8 @@ const makeRelationQuery = (table, definedAs, relationName, data) => {
         toTable._take();
       }
       const query = this.isSubQuery ? toTable : toTable._whereExists(
-        this,
-        (q) => data.reverseJoin(
-          q,
-          toTable
-        )
+        this.baseQuery,
+        (q) => data.reverseJoin(this, toTable)
       );
       query.query[relationQueryKey] = {
         relationName,
@@ -1760,7 +1778,7 @@ const createTable = async (_a) => {
   if (ast.schema) {
     props.push(`schema = ${singleQuote(ast.schema)};`);
   }
-  props.push(`table = ${singleQuote(ast.name)};`);
+  props.push(`readonly table = ${singleQuote(ast.name)};`);
   if (ast.noPrimaryKey === "ignore") {
     props.push("noPrimaryKey = true;");
   }