orchid-orm 1.38.0 → 1.38.2

package/dist/index.mjs

@@ -11,7 +11,8 @@ function createBaseTable({
   filePath: filePathArg,
   nowSQL,
   exportAs = "BaseTable",
-  language
+  language,
+  autoForeignKeys
 } = {}) {
   var _a;
   const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(makeColumnTypes(schemaConfig)) : columnTypesArg || makeColumnTypes(schemaConfig);
@@ -142,6 +143,7 @@ function createBaseTable({
   applyMixins(base, [QueryHooks]);
   base.prototype.types = columnTypes;
   base.prototype.snakeCase = snakeCase;
+  base.prototype.autoForeignKeys = autoForeignKeys === true ? {} : autoForeignKeys || void 0;
   return base;
 }
 
@@ -252,6 +254,61 @@ const joinQueryChainingHOF = (reverseJoin, joinQuery) => (joiningQuery, baseQuer
     EXISTS: { q: reverseJoin(query, joiningQuery) }
   });
 };
+const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, options) => {
+  var _a;
+  const toTable = to.table;
+  let fkeyOptions = options.foreignKey !== void 0 ? options.foreignKey : tableConfig.autoForeignKeys;
+  if (!fkeyOptions) return;
+  if (fkeyOptions === true) {
+    fkeyOptions = tableConfig.autoForeignKeys || emptyObject;
+  }
+  if (foreignKeys.length === 1) {
+    const column = from.shape[foreignKeys[0]];
+    if (column.data.foreignKeys) {
+      const pkey = primaryKeys[0];
+      for (const fkey of column.data.foreignKeys) {
+        let fkeyTable;
+        let fkeyColumn = fkey.foreignColumns[0];
+        if (typeof fkey.fnOrTable === "string") {
+          fkeyTable = fkey.fnOrTable;
+          fkeyColumn = getColumnKeyFromDbName(to, fkeyColumn);
+        } else {
+          fkeyTable = fkey.fnOrTable().instance().table;
+        }
+        if (toTable === fkeyTable && pkey === fkeyColumn) return;
+      }
+    }
+  }
+  const { constraints } = from.internal.tableData;
+  if (constraints) {
+    const sortedPkeys = [...primaryKeys].sort();
+    const sortedFkeys = [...foreignKeys].sort();
+    for (const { references: refs } of constraints) {
+      if (!refs) continue;
+      if (refs.columns.length === sortedFkeys.length && refs.columns.every((column, i) => column === sortedFkeys[i]) && refs.foreignColumns.length === sortedPkeys.length && (typeof refs.fnOrTable === "string" ? refs.fnOrTable === toTable && refs.foreignColumns.every(
+        (column, i) => getColumnKeyFromDbName(to, column) === sortedPkeys[i]
+      ) : refs.fnOrTable().instance().table === toTable && refs.foreignColumns.every((column, i) => column === sortedPkeys[i])))
+        return;
+    }
+  }
+  ((_a = from.internal.tableData).constraints ?? (_a.constraints = [])).push({
+    references: {
+      columns: foreignKeys,
+      fnOrTable: toTable,
+      foreignColumns: primaryKeys,
+      options: fkeyOptions
+    },
+    dropMode: fkeyOptions.dropMode
+  });
+};
+const getColumnKeyFromDbName = (query, name) => {
+  for (const k in query.shape) {
+    if (query.shape[k].data.name === name) {
+      return k;
+    }
+  }
+  return name;
+};
 
 class BelongsToVirtualColumn extends VirtualColumn {
   constructor(schema, key, state) {
@@ -304,12 +361,20 @@ class BelongsToVirtualColumn extends VirtualColumn {
     this.nestedUpdate(q, set, data, ctx);
   }
 }
-const makeBelongsToMethod = (relation, relationName, query) => {
+const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
   const primaryKeys = relation.options.references;
   const foreignKeys = relation.options.columns;
   const len = primaryKeys.length;
   const state = { query, primaryKeys, foreignKeys, len };
   const makeWhere = relationWhere(len, primaryKeys, foreignKeys);
+  addAutoForeignKey(
+    tableConfig,
+    table,
+    query,
+    primaryKeys,
+    foreignKeys,
+    relation.options
+  );
   const join = (baseQuery, joiningQuery, primaryKeys2, foreignKeys2) => {
     const q = joiningQuery.clone();
     setQueryObjectValue(
@@ -577,7 +642,7 @@ class HasOneVirtualColumn extends VirtualColumn {
     );
   }
 }
-const makeHasOneMethod = (table, relation, relationName, query) => {
+const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
@@ -617,6 +682,14 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
   }
   const primaryKeys = relation.options.columns;
   const foreignKeys = relation.options.references;
+  addAutoForeignKey(
+    tableConfig,
+    query,
+    table,
+    primaryKeys,
+    foreignKeys,
+    relation.options
+  );
   const state = { query, primaryKeys, foreignKeys };
   const len = primaryKeys.length;
   const reversedOn = {};
@@ -827,7 +900,7 @@ class HasManyVirtualColumn extends VirtualColumn {
     );
   }
 }
-const makeHasManyMethod = (table, relation, relationName, query) => {
+const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
     const throughRelation = getThroughRelation(table, through);
@@ -873,6 +946,14 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
   }
   const primaryKeys = relation.options.columns;
   const foreignKeys = relation.options.references;
+  addAutoForeignKey(
+    tableConfig,
+    query,
+    table,
+    primaryKeys,
+    foreignKeys,
+    relation.options
+  );
   const state = { query, primaryKeys, foreignKeys };
   const len = primaryKeys.length;
   const reversedOn = {};
@@ -1135,7 +1216,7 @@ const removeColumnName = (column) => {
   cloned.data = { ...column.data, name: void 0 };
   return cloned;
 };
-const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
+const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relationName, query) => {
   const { options } = relation;
   const primaryKeys = options.columns;
   const foreignKeys = options.references;
@@ -1177,6 +1258,22 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     shape: baseQuery.shape
   };
   const subQuery = Object.create(baseQuery);
+  addAutoForeignKey(
+    tableConfig,
+    subQuery,
+    table,
+    primaryKeys,
+    foreignKeys,
+    relation.options
+  );
+  addAutoForeignKey(
+    tableConfig,
+    subQuery,
+    query,
+    throughPrimaryKeys,
+    throughForeignKeys,
+    relation.options.through
+  );
   const state = {
     relatedTableQuery: query,
     joinTableQuery: subQuery,
@@ -1619,7 +1716,7 @@ const applyRelations = (qb, tables, result) => {
           continue;
         }
       }
-      applyRelation(qb, data, delayedRelations);
+      applyRelation(table, qb, data, delayedRelations);
     }
   }
   if (delayedRelations.size) {
@@ -1655,7 +1752,7 @@ const delayRelation = (delayedRelations, table, relationName, data) => {
     tableRelations[relationName] = [data];
   }
 };
-const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
+const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
   const baseQuery = Object.create(otherDbTable);
   baseQuery.baseQuery = baseQuery;
   const query = (relation.options.scope ? relation.options.scope(baseQuery) : baseQuery).as(relationName);
@@ -1668,13 +1765,14 @@ const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, de
   const { type } = relation;
   let data;
   if (type === "belongsTo") {
-    data = makeBelongsToMethod(relation, relationName, query);
+    data = makeBelongsToMethod(table, dbTable, relation, relationName, query);
   } else if (type === "hasOne") {
-    data = makeHasOneMethod(dbTable, relation, relationName, query);
+    data = makeHasOneMethod(table, dbTable, relation, relationName, query);
   } else if (type === "hasMany") {
-    data = makeHasManyMethod(dbTable, relation, relationName, query);
+    data = makeHasManyMethod(table, dbTable, relation, relationName, query);
   } else if (type === "hasAndBelongsToMany") {
     data = makeHasAndBelongsToManyMethod(
+      table,
       dbTable,
       qb,
       relation,
@@ -1718,7 +1816,7 @@ const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, de
   const tableRelations = delayedRelations.get(dbTable);
   if (!tableRelations) return;
   tableRelations[relationName]?.forEach((data2) => {
-    applyRelation(qb, data2, delayedRelations);
+    applyRelation(table, qb, data2, delayedRelations);
   });
 };