orchid-orm 1.38.0 → 1.38.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Query, SelectableFromShape, CreateMethodsNames, CreateData, CreateBelongsToData, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, UpdateData, WhereArg, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromResult, AdapterOptions, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, QueryData, TableDataFn, DbTableOptionScopes, RawSQL, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
+import { Query, TableData, SelectableFromShape, CreateMethodsNames, CreateData, CreateBelongsToData, AddQueryDefaults, RelationConfigBase, SetQueryReturnsOne, SetQueryReturnsOneOptional, UpdateData, WhereArg, JoinQueryMethod, DeleteMethodsNames, Db, IsolationLevel, TransactionOptions, Adapter, FromArg, FromResult, AdapterOptions, DbSharedOptions, RelationsBase, ShapeColumnPrimaryKeys, ShapeUniqueColumns, TableDataItemsUniqueColumns, TableDataItemsUniqueColumnTuples, UniqueConstraints, TableDataItemsUniqueConstraints, ComputedColumnsFromOptions, MapTableScopesOption, TableDataItem, ComputedOptionsFactory, QueryData, TableDataFn, DbTableOptionScopes, RawSQL, DynamicRawSQL, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery } from 'pqb';
 export * from 'pqb';
 import { ColumnsShapeBase, EmptyObject, MaybeArray, RecordUnknown, ShallowSimplify, ColumnShapeOutput, DefaultSelectColumns, ColumnShapeInput, ColumnShapeInputPartial, IsQuery, CoreQueryScopes, ColumnSchemaConfig, StaticSQLArgs, QueryColumn, DynamicSQLArg, QueryColumns, QueryReturnType } from 'orchid-core';
 export * from 'orchid-core';
@@ -10,6 +10,7 @@ interface RelationCommonOptions<Related extends TableClass = TableClass, Scope e
 interface RelationRefsOptions<Column extends PropertyKey = string, Ref extends PropertyKey = string> {
     columns: Column[];
     references: Ref[];
+    foreignKey?: boolean | TableData.References.Options;
 }
 interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
     through: Through;
@@ -294,10 +295,12 @@ interface HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsS
     required?: boolean;
     columns: (keyof Columns)[];
     references: string[];
+    foreignKey?: boolean | TableData.References.Options;
     through: {
         table: string;
         columns: string[];
         references: (keyof InstanceType<Related>['columns']['shape'])[];
+        foreignKey?: boolean | TableData.References.Options;
     };
 }
 type HasAndBelongsToManyParams<T extends RelationConfigSelf, Relation extends HasAndBelongsToMany> = {
@@ -453,6 +456,7 @@ interface ORMTableInput {
     scopes?: RecordUnknown;
     readonly softDelete?: true | string;
     comment?: string;
+    autoForeignKeys?: TableData.References.BaseOptions;
 }
 type Queryable<T extends ORMTableInput> = ShallowSimplify<{
     [K in keyof T['columns']['shape']]?: T['columns']['shape'][K]['queryType'];
@@ -679,7 +683,7 @@ interface BaseTableClass<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
      */
     updateSchema: SchemaConfig['updateSchema'];
 }
-declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ schemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, }?: {
+declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ schemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, autoForeignKeys, }?: {
     schemaConfig?: SchemaConfig;
     columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
     snakeCase?: boolean;
@@ -687,6 +691,7 @@ declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = Defau
     nowSQL?: string;
     exportAs?: string;
     language?: string;
+    autoForeignKeys?: boolean | TableData.References.BaseOptions;
 }): BaseTableClass<SchemaConfig, ColumnTypes>;
 
 type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;

package/dist/index.js

@@ -11,7 +11,8 @@ function createBaseTable({
   filePath: filePathArg,
   nowSQL,
   exportAs = "BaseTable",
-  language
+  language,
+  autoForeignKeys
 } = {}) {
   var _a;
   const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(pqb.makeColumnTypes(schemaConfig)) : columnTypesArg || pqb.makeColumnTypes(schemaConfig);
@@ -142,6 +143,7 @@ function createBaseTable({
   orchidCore.applyMixins(base, [pqb.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 || orchidCore.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 pqb.VirtualColumn {
   constructor(schema, key, state) {
@@ -304,12 +361,20 @@ class BelongsToVirtualColumn extends pqb.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();
     pqb.setQueryObjectValue(
@@ -577,7 +642,7 @@ class HasOneVirtualColumn extends pqb.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 pqb.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);
   });
 };