orchid-orm 1.6.40 → 1.8.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as pqb from 'pqb';
-import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, defaultsKey, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, DefaultColumnTypes, ColumnsShape, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, defaultsKey, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, DefaultColumnTypes, ColumnsShape, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes } from 'pqb';
 import * as orchid_core from 'orchid-core';
 import { StringKey, EmptyObject, ColumnTypesBase, ColumnShapeOutput, SetOptional } from 'orchid-core';
@@ -59,7 +59,10 @@ type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation exte
 
 declare function transaction<T extends {
     $queryBuilder: Db;
-}, Result>(this: T, fn: (db: T) => Promise<Result>): Promise<Result>;
+}, Result>(this: T, fn: () => Promise<Result>): Promise<Result>;
+declare function transaction<T extends {
+    $queryBuilder: Db;
+}, Result>(this: T, options: IsolationLevel | TransactionOptions, fn: () => Promise<Result>): Promise<Result>;
 
 type OrchidORM<T extends TableClasses> = {
     [K in keyof T]: DbTable<T[K]>;
@@ -152,6 +155,8 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
         table: string;
         columns: TableConfig;
         schema?: string | undefined;
+        noPrimaryKey?: boolean | undefined;
+        snakeCase: boolean | undefined;
         columnTypes: ColumnTypesBase extends CT ? {
             timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
@@ -269,8 +274,6 @@ declare const createBaseTable: <CT extends ColumnTypesBase>({ columnTypes, snake
             }) | undefined): {};
             check(check: orchid_core.RawExpression): {};
         } : CT;
-        noPrimaryKey?: boolean | undefined;
-        snakeCase: boolean | undefined;
         setColumns: <T_18 extends ColumnsShape>(fn: (t: ColumnTypesBase extends CT ? {
             timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {

package/dist/index.js

@@ -2,6 +2,7 @@
 
 var pqb = require('pqb');
 var orchidCore = require('orchid-core');
+var node_async_hooks = require('node:async_hooks');
 var path = require('path');
 var fs = require('fs/promises');
 var typescript = require('typescript');
@@ -36,7 +37,7 @@ const createBaseTable = ({
   );
 };
 const create = (columnTypes, snakeCase) => {
-  return class BaseTable {
+  const base = class BaseTable {
     constructor() {
       this.snakeCase = snakeCase;
       this.setColumns = (fn) => {
@@ -93,6 +94,8 @@ const create = (columnTypes, snakeCase) => {
       };
     }
   };
+  base.prototype.columnTypes = columnTypes;
+  return base;
 };
 
 class BelongsToVirtualColumn extends pqb.VirtualColumn {
@@ -161,11 +164,11 @@ const makeBelongsToMethod = (relation, relationName, query) => {
   };
 };
 const nestedInsert$3 = ({ query, primaryKey }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connectOrCreate = data.filter(
       (item) => Boolean(item.connectOrCreate)
     );
-    const t = query.transacting(q);
+    const t = query.clone();
     let connectOrCreated;
     if (connectOrCreate.length) {
       connectOrCreated = await Promise.all(
@@ -229,12 +232,12 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         if (primaryKey in params.set) {
           update[foreignKey] = params.set[primaryKey];
         } else {
-          update[foreignKey] = await query.transacting(q2)._findBy(params.set)._get(primaryKey);
+          update[foreignKey] = await query.findBy(params.set)._get(primaryKey);
         }
       } else if (params.create) {
-        update[foreignKey] = await query.transacting(q2)._get(primaryKey)._create(params.create);
+        update[foreignKey] = await query.get(primaryKey)._create(params.create);
       } else if (params.delete) {
-        const selectQuery = q2.transacting(q2);
+        const selectQuery = q2.clone();
         selectQuery.query.type = void 0;
         idForDelete = await selectQuery._getOptional(foreignKey);
         update[foreignKey] = null;
@@ -256,10 +259,10 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         const data = await handleResult(q2, queryResult);
         const id = data[0][foreignKey];
         if (id !== null) {
-          await query.transacting(q2)._findBy({ [primaryKey]: id })._update(upsert.update);
+          await query.findBy({ [primaryKey]: id })._update(upsert.update);
         } else {
           state.updateLaterPromises.push(
-            query.transacting(q2)._select(primaryKey)._create(upsert.create).then((result) => {
+            query.select(primaryKey)._create(upsert.create).then((result) => {
               state.updateLater[foreignKey] = result[primaryKey];
             })
           );
@@ -267,12 +270,12 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         return data;
       };
     } else if (params.delete || params.update) {
-      q._afterQuery(async (q2, data) => {
+      q._afterQuery(async (_, data) => {
         const id = params.delete ? idForDelete : Array.isArray(data) ? data.length === 0 ? null : {
           in: data.map((item) => item[foreignKey]).filter((id2) => id2 !== null)
         } : data[foreignKey];
         if (id !== void 0 && id !== null) {
-          const t = query.transacting(q2)._findBy({
+          const t = query.findBy({
             [primaryKey]: id
           });
           if (params.delete) {
@@ -464,11 +467,11 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
   };
 };
 const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connect = data.filter(
       (item) => Boolean(item[1].connect || item[1].connectOrCreate)
     );
-    const t = query.transacting(q);
+    const t = query.clone();
     let connected;
     if (connect.length) {
       connected = await Promise.all(
@@ -504,7 +507,7 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
       const key = params.set ? "set" : params.create ? "create" : "upsert";
       throw new Error(`\`${key}\` option is not allowed in a batch update`);
     }
-    const t = query.transacting(q);
+    const t = query.clone();
     const ids = data.map((item) => item[primaryKey]);
     const currentRelationsQuery = t.where({
       [foreignKey]: { in: ids }
@@ -673,11 +676,11 @@ const getWhereForNestedUpdate = (data, params, primaryKey, foreignKey) => {
   return where;
 };
 const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connect = data.filter(
       (item) => Boolean(item[1].connect)
     );
-    const t = query.transacting(q);
+    const t = query.clone();
     if (connect.length) {
       await Promise.all(
         connect.flatMap(
@@ -740,7 +743,7 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
       const key = params.set ? "set" : "create";
       throw new Error(`\`${key}\` option is not allowed in a batch update`);
     }
-    const t = query.transacting(q);
+    const t = query.clone();
     if (params.create) {
       await t._count()._createMany(
         params.create.map((create) => __spreadProps$4(__spreadValues$6({}, create), {
@@ -914,10 +917,10 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
       pqb.pushQueryValue(
         relationQuery,
         "afterCreate",
-        async (q, result) => {
+        async (_, result) => {
           const fromQuery = ref.query.clone();
           fromQuery.query.select = [{ selectAs: { [fk]: pk } }];
-          const createdCount = await subQuery.transacting(q).count()._createFrom(
+          const createdCount = await subQuery.count()._createFrom(
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             fromQuery,
             {
@@ -935,8 +938,8 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     }
   };
 };
-const queryJoinTable = (state, q, data, conditions) => {
-  const t = state.joinTableQuery.transacting(q);
+const queryJoinTable = (state, data, conditions) => {
+  const t = state.joinTableQuery.clone();
   const where = {
     [state.foreignKey]: { in: data.map((item) => item[state.primaryKey]) }
   };
@@ -949,8 +952,10 @@ const queryJoinTable = (state, q, data, conditions) => {
   }
   return t._where(where);
 };
-const queryRelatedTable = (query, q, conditions) => {
-  return query.transacting(q)._where(Array.isArray(conditions) ? { OR: conditions } : conditions);
+const queryRelatedTable = (query, conditions) => {
+  return query.where(
+    Array.isArray(conditions) ? { OR: conditions } : conditions
+  );
 };
 const insertToJoinTable = (state, joinTableTransaction, data, ids) => {
   return joinTableTransaction._count()._createMany(
@@ -970,11 +975,11 @@ const nestedInsert = ({
   associationPrimaryKey,
   associationForeignKey
 }) => {
-  return async (q, data) => {
+  return async (_, data) => {
     const connect = data.filter(
       (item) => Boolean(item[1].connect)
     );
-    const t = relatedTableQuery.transacting(q);
+    const t = relatedTableQuery.clone();
     let connected;
     if (connect.length) {
       connected = await Promise.all(
@@ -1059,7 +1064,7 @@ const nestedInsert = ({
         connectI += len;
       }
     });
-    await joinTableQuery.transacting(q)._count()._createMany(
+    await joinTableQuery.count()._createMany(
       allKeys.flatMap(([selfData, relationKeys]) => {
         const selfKey = selfData[primaryKey];
         return relationKeys.map((relationData) => ({
@@ -1071,10 +1076,10 @@ const nestedInsert = ({
   };
 };
 const nestedUpdate = (state) => {
-  return async (q, data, params) => {
+  return async (_, data, params) => {
     if (params.create) {
-      const ids = await state.relatedTableQuery.transacting(q)._pluck(state.associationPrimaryKey)._createMany(params.create);
-      await state.joinTableQuery.transacting(q)._createMany(
+      const ids = await state.relatedTableQuery.pluck(state.associationPrimaryKey)._createMany(params.create);
+      await state.joinTableQuery.createMany(
         data.flatMap(
           (item) => ids.map((id) => ({
             [state.foreignKey]: item[state.primaryKey],
@@ -1084,11 +1089,11 @@ const nestedUpdate = (state) => {
       );
     }
     if (params.update) {
-      await state.relatedTableQuery.transacting(q)._whereExists(
+      await state.relatedTableQuery.whereExists(
         state.joinTableQuery,
-        (q2) => (
+        (q) => (
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          q2._on(
+          q._on(
             state.associationForeignKeyFull,
             state.associationPrimaryKeyFull
           )._where({
@@ -1103,22 +1108,21 @@ const nestedUpdate = (state) => {
       )._update(params.update.data);
     }
     if (params.disconnect) {
-      await queryJoinTable(state, q, data, params.disconnect)._delete();
+      await queryJoinTable(state, data, params.disconnect)._delete();
     }
     if (params.delete) {
-      const j = queryJoinTable(state, q, data, params.delete);
+      const j = queryJoinTable(state, data, params.delete);
       const ids = await j._pluck(state.associationForeignKey)._delete();
-      await queryRelatedTable(state.relatedTableQuery, q, {
+      await queryRelatedTable(state.relatedTableQuery, {
         [state.associationPrimaryKey]: { in: ids }
       })._delete();
     }
     if (params.set) {
-      const j = queryJoinTable(state, q, data);
+      const j = queryJoinTable(state, data);
       await j._delete();
       delete j.query[pqb.toSqlCacheKey];
       const ids = await queryRelatedTable(
         state.relatedTableQuery,
-        q,
         params.set
       )._pluck(state.associationPrimaryKey);
       await insertToJoinTable(state, j, data, ids);
@@ -1293,25 +1297,11 @@ const makeRelationQuery = (table, definedAs, relationName, data) => {
   });
 };
 
-function transaction(fn) {
-  if (fn.length === 0) {
-    throw new Error("Argument of $transaction callback should be used");
-  }
-  return this.$queryBuilder.transaction((q) => {
-    const orm = {};
-    for (const key in this) {
-      const value = this[key];
-      if (value instanceof pqb.Db) {
-        const table = value.transacting(q);
-        table.baseQuery = table;
-        table.db = orm;
-        orm[key] = table;
-      } else {
-        orm[key] = value;
-      }
-    }
-    return fn(orm);
-  });
+function transaction(fnOrOptions, fn) {
+  return this.$queryBuilder.transaction(
+    fnOrOptions,
+    fn
+  );
 }
 
 var __defProp$4 = Object.defineProperty;
@@ -1364,12 +1354,14 @@ const orchidORM = (_a, tables) => {
     autoPreparedStatements,
     noPrimaryKey
   };
+  const transactionStorage = new node_async_hooks.AsyncLocalStorage();
   const qb = new pqb.Db(
     adapter,
     void 0,
     void 0,
     pqb.anyShape,
     pqb.columnTypes,
+    transactionStorage,
     commonOptions
   );
   qb.queryBuilder = qb;
@@ -1399,6 +1391,7 @@ const orchidORM = (_a, tables) => {
       table.table,
       table.columns.shape,
       table.columnTypes,
+      transactionStorage,
       options2
     );
     dbTable.definedAs = key;
@@ -1624,12 +1617,6 @@ const ts = {
   }
 };
 
-const getImportPath = (from, to) => {
-  const rel = path.relative(path.dirname(from), to).split(path.sep).join(path.posix.sep);
-  const importPath = rel.startsWith("./") || rel.startsWith("../") ? rel : `./${rel}`;
-  return importPath.replace(/\.[tj]s$/, "");
-};
-
 const libraryName = "orchid-orm";
 const importKey = "orchidORM";
 const newFile = (options) => `import { orchidORM } from 'orchid-orm';
@@ -1710,7 +1697,7 @@ const createTable$1 = ({ filePath, tablePath, statements, object, content, space
   const key = orchidCore.toCamelCase(ast.name);
   const value = `${orchidCore.toPascalCase(ast.name)}Table`;
   const changes = new FileChanges(content);
-  const importPath = getImportPath(filePath, tablePath(orchidCore.toCamelCase(ast.name)));
+  const importPath = orchidCore.getImportPath(filePath, tablePath(orchidCore.toCamelCase(ast.name)));
   const existing = Array.from(
     ts.import.iterateWithSource(statements, importPath)
   );
@@ -1740,7 +1727,7 @@ ${spaces}`;
 };
 const dropTable = ({ filePath, tablePath, statements, object, content }, ast) => {
   const changes = new FileChanges(content);
-  const importPath = getImportPath(filePath, tablePath(orchidCore.toCamelCase(ast.name)));
+  const importPath = orchidCore.getImportPath(filePath, tablePath(orchidCore.toCamelCase(ast.name)));
   const tableClassName = `${orchidCore.toPascalCase(ast.name)}Table`;
   const importNames = [];
   for (const node of ts.import.iterateWithSource(statements, importPath)) {
@@ -1806,7 +1793,7 @@ const createTable = async (_a) => {
     "logger"
   ]);
   const tablePath = params.tablePath(orchidCore.toCamelCase(ast.name));
-  const baseTablePath = getImportPath(tablePath, params.baseTablePath);
+  const baseTablePath = orchidCore.getImportPath(tablePath, params.baseTablePath);
   const props = [];
   if (ast.schema) {
     props.push(`schema = ${orchidCore.singleQuote(ast.schema)};`);