orchid-orm 1.10.5 → 1.11.0

package/LICENSE

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as pqb from 'pqb';
-import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, BeforeHookKey, BeforeHook, AfterHookKey, AfterHook, DefaultColumnTypes, ColumnsShape, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, DefaultColumnTypes, QueryData, QueryBase, ColumnsShape, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes, testTransaction } from 'pqb';
 import * as orchid_core from 'orchid-core';
-import { StringKey, EmptyObject, ColumnTypesBase, ColumnShapeOutput } from 'orchid-core';
+import { StringKey, EmptyObject, ColumnTypesBase, ColumnsShapeBase, ColumnShapeOutput } from 'orchid-core';
 
 interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
@@ -148,19 +148,12 @@ type ScopeFn<Related extends TableClass, Scope extends Query> = (q: DbTable<Rela
 type Table = {
     table: string;
     columns: ColumnsConfig;
-    hooks?: TableHooks;
     schema?: string;
     columnTypes: ColumnTypesBase;
     noPrimaryKey?: boolean;
     filePath: string;
 };
 type TableType<T extends Pick<Table, 'columns'>> = T['columns']['type'];
-type TableHooks = {
-    [K in BeforeHookKey]?: BeforeHook;
-} & {
-    [K in AfterHookKey]?: AfterHook;
-};
-declare const addTableHooks: (table: Query, hooks: TableHooks) => void;
 declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnTypeCreator>>({ columnTypes, snakeCase, filePath, nowSQL, exportAs, }?: {
     columnTypes?: CT | ((t: DefaultColumnTypes) => CT) | undefined;
     snakeCase?: boolean | undefined;
@@ -224,7 +217,7 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
                 (sql: TemplateStringsArray, ...values: unknown[]): orchid_core.RawExpression;
                 (sql: string): orchid_core.RawExpression;
                 (values: Record<string, unknown>, sql: string): orchid_core.RawExpression;
-                (values: Record<string, unknown>): (sql_0: TemplateStringsArray, ...sql_1: unknown[]) => orchid_core.RawExpression;
+                (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => orchid_core.RawExpression;
             };
             smallint(): pqb.SmallIntColumn;
             integer(): pqb.IntegerColumn;
@@ -322,10 +315,11 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
             }) | undefined): {};
             check(check: orchid_core.RawExpression): {};
         } : CT;
+        query: QueryData;
         filePath: string;
-        callbacks?: TableHooks | undefined;
-        setHooks(callbacks: TableHooks): TableHooks;
-        setColumns<T_20 extends ColumnsShape>(fn: (t: Record<string, orchid_core.AnyColumnTypeCreator> extends CT ? {
+        result: ColumnsShapeBase;
+        clone<T_20 extends QueryBase>(this: T_20): T_20;
+        setColumns<T_21 extends ColumnsShape>(fn: (t: Record<string, orchid_core.AnyColumnTypeCreator> extends CT ? {
             timestamps<T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
                     timestamp(): T;
@@ -375,7 +369,7 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
                 (sql: TemplateStringsArray, ...values: unknown[]): orchid_core.RawExpression;
                 (sql: string): orchid_core.RawExpression;
                 (values: Record<string, unknown>, sql: string): orchid_core.RawExpression;
-                (values: Record<string, unknown>): (sql_0: TemplateStringsArray, ...sql_1: unknown[]) => orchid_core.RawExpression;
+                (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => orchid_core.RawExpression;
             };
             smallint(): pqb.SmallIntColumn;
             integer(): pqb.IntegerColumn;
@@ -444,9 +438,9 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
                 nativeEnum: <T_11 extends orchid_core.EnumLike>(givenEnum: T_11) => orchid_core.JSONNativeEnum<T_11>;
                 nullable: <T_12 extends orchid_core.JSONTypeAny>(type: T_12) => orchid_core.JSONNullable<T_12>;
                 nullish: <T_13 extends orchid_core.JSONTypeAny>(type: T_13) => orchid_core.JSONNullish<T_13>;
-                object: <T_14 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_14) => orchid_core.JSONObject<T_14, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_21 extends object ? { [k in keyof T_21]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_24 extends object ? { [k in keyof T_24]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
+                object: <T_14 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_14) => orchid_core.JSONObject<T_14, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_22 extends object ? { [k in keyof T_22]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_25 extends object ? { [k in keyof T_25]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
-                } extends infer T_22 extends object ? { [k_2 in keyof T_22]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_23 extends object ? { [k in keyof T_23]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
+                } extends infer T_23 extends object ? { [k_2 in keyof T_23]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_24 extends object ? { [k in keyof T_24]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
                     [k: string]: Catchall["type"];
                 })[k_2]; } : never>;
                 optional: <T_19 extends orchid_core.JSONTypeAny>(type: T_19) => orchid_core.JSONOptional<T_19>;
@@ -472,9 +466,9 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
                 dropMode?: pqb.DropMode | undefined;
             }) | undefined): {};
             check(check: orchid_core.RawExpression): {};
-        } : CT) => T_20): {
-            shape: T_20;
-            type: ColumnShapeOutput<T_20>;
+        } : CT) => T_21): {
+            shape: T_21;
+            type: ColumnShapeOutput<T_21>;
         };
         belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends {
             primaryKey: keyof InstanceType<Related>["columns"]["shape"];
@@ -531,11 +525,28 @@ declare const createBaseTable: <CT extends Record<string, orchid_core.AnyColumnT
             fn: () => Related_3;
             options: Options_3;
         };
+        beforeQuery: BeforeHookMethod;
+        afterQuery: AfterHookMethod;
+        beforeCreate: BeforeHookMethod;
+        afterCreate: AfterSelectableHookMethod;
+        afterCreateCommit: AfterSelectableHookMethod;
+        beforeUpdate: BeforeHookMethod;
+        afterUpdate: AfterSelectableHookMethod;
+        afterUpdateCommit: AfterSelectableHookMethod;
+        beforeSave: BeforeHookMethod;
+        afterSave: AfterSelectableHookMethod;
+        afterSaveCommit: AfterSelectableHookMethod;
+        beforeDelete: BeforeHookMethod;
+        afterDelete: AfterSelectableHookMethod;
+        afterDeleteCommit: AfterSelectableHookMethod;
     };
     filePath: string;
     nowSQL: string | undefined;
     exportAs: string;
 };
+type BeforeHookMethod = <T extends Table>(cb: QueryBeforeHook) => T;
+type AfterHookMethod = <T extends Table>(cb: QueryAfterHook) => T;
+type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns']['shape'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']['shape']>) => T;
 
 type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
 type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;
@@ -556,4 +567,4 @@ type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapMethods<T
 }>(q: Q) => Q & Mapped) & T & Mapped;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
 
-export { DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, Table, TableClass, TableClasses, TableHooks, TableToDb, TableType, addTableHooks, createBaseTable, createRepo, orchidORM };
+export { DbTable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Repo, Table, TableClass, TableClasses, TableToDb, TableType, createBaseTable, createRepo, orchidORM };

package/dist/index.js

@@ -4,15 +4,6 @@ var pqb = require('pqb');
 var orchidCore = require('orchid-core');
 var node_async_hooks = require('node:async_hooks');
 
-const addTableHooks = (table, hooks) => {
-  for (const key in hooks) {
-    pqb.addQueryHook(
-      table.baseQuery,
-      key,
-      hooks[key]
-    );
-  }
-};
 const createBaseTable = ({
   columnTypes,
   snakeCase,
@@ -40,10 +31,11 @@ const create = (columnTypes, filePath, snakeCase, nowSQL, exportAs = "BaseTable"
   const base = (_a = class {
     constructor() {
       this.snakeCase = snakeCase;
+      this.query = {};
       this.columnTypes = columnTypes;
     }
-    setHooks(callbacks) {
-      return callbacks;
+    clone() {
+      return this;
     }
     setColumns(fn) {
       if (!this.filePath) {
@@ -106,6 +98,7 @@ const create = (columnTypes, filePath, snakeCase, nowSQL, exportAs = "BaseTable"
       };
     }
   }, _a.filePath = filePath, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a);
+  orchidCore.applyMixins(base, [pqb.QueryHooks]);
   base.prototype.columnTypes = columnTypes;
   return base;
 };
@@ -225,9 +218,9 @@ const nestedInsert$3 = ({ query, primaryKey }) => {
     let createdI = 0;
     let connectedI = 0;
     connectOrCreatedI = 0;
-    return data.map(
-      (item) => item.connectOrCreate ? connectOrCreated[connectOrCreatedI++] || created[createdI++] : item.connect ? connected[connectedI++] : created[createdI++]
-    );
+    return data.map((item) => {
+      return item.connectOrCreate ? connectOrCreated[connectOrCreatedI++] || created[createdI++] : item.connect ? connected[connectedI++] : created[createdI++];
+    });
   };
 };
 const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
@@ -236,7 +229,7 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
     if (params.upsert && pqb.isQueryReturnsAll(q)) {
       throw new Error("`upsert` option is not allowed in a batch update");
     }
-    let idForDelete;
+    let idsForDelete;
     q._beforeUpdate(async (q2) => {
       if (params.disconnect) {
         update[foreignKey] = null;
@@ -251,7 +244,7 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
       } else if (params.delete) {
         const selectQuery = q2.clone();
         selectQuery.query.type = void 0;
-        idForDelete = await selectQuery._getOptional(foreignKey);
+        idsForDelete = await selectQuery._pluck(foreignKey);
         update[foreignKey] = null;
       }
     });
@@ -274,12 +267,12 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         }
       });
     } else if (params.delete || params.update) {
-      q._afterQuery(async (_, data) => {
-        const id = params.delete ? idForDelete : Array.isArray(data) ? data.length === 0 ? null : {
+      q._afterUpdate([], async (data) => {
+        const id = params.delete ? { in: idsForDelete } : 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.findBy({
+          const t = query.where({
             [primaryKey]: id
           });
           if (params.delete) {
@@ -313,22 +306,20 @@ const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKey, nested
     return;
   }
   q.query.wrapInTransaction = true;
-  ctx.returnTypeAll = true;
-  ctx.requiredReturning[primaryKey] = true;
   const relationData = [values];
   store.hasRelation[key] = relationData;
-  pqb.pushQueryValue(q, "afterCreate", async (q2) => {
-    const { resultAll } = ctx;
-    return nestedInsert(
+  q._afterCreate(
+    [primaryKey],
+    (rows, q2) => nestedInsert(
       q2,
       relationData.map(([rowIndex2, data]) => [
-        resultAll[rowIndex2],
+        rows[rowIndex2],
         data
       ])
-    );
-  });
+    )
+  );
 };
-const hasRelationHandleUpdate = (q, ctx, set, key, primaryKey, nestedUpdate) => {
+const hasRelationHandleUpdate = (q, set, key, primaryKey, nestedUpdate) => {
   var _a, _b;
   const value = set[key];
   if (!value.set && !("upsert" in value) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0))
@@ -337,11 +328,10 @@ const hasRelationHandleUpdate = (q, ctx, set, key, primaryKey, nestedUpdate) =>
     q._select(primaryKey);
   }
   q.query.wrapInTransaction = true;
-  ctx.returnTypeAll = true;
-  pqb.pushQueryValue(q, "afterUpdate", (q2) => {
+  q._afterUpdate(q.primaryKeys, (rows, q2) => {
     return nestedUpdate(
       q2,
-      ctx.resultAll,
+      rows,
       value
     );
   });
@@ -385,10 +375,14 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
       this.nestedInsert
     );
   }
-  update(q, ctx, set) {
+  update(q, _, set) {
+    const params = set[this.key];
+    if ((params.set || params.create || params.upsert) && pqb.isQueryReturnsAll(q)) {
+      const key = params.set ? "set" : params.create ? "create" : "upsert";
+      throw new Error(`\`${key}\` option is not allowed in a batch update`);
+    }
     hasRelationHandleUpdate(
       q,
-      ctx,
       set,
       this.key,
       this.state.primaryKey,
@@ -501,11 +495,7 @@ const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
-  return async (q, data, params) => {
-    if ((params.set || params.create || params.upsert) && pqb.isQueryReturnsAll(q)) {
-      const key = params.set ? "set" : params.create ? "create" : "upsert";
-      throw new Error(`\`${key}\` option is not allowed in a batch update`);
-    }
+  return async (_, data, params) => {
     const t = query.clone();
     const ids = data.map((item) => item[primaryKey]);
     const currentRelationsQuery = t.where({
@@ -578,10 +568,14 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
       this.nestedInsert
     );
   }
-  update(q, ctx, set) {
+  update(q, _, set) {
+    const params = set[this.key];
+    if ((params.set || params.create) && pqb.isQueryReturnsAll(q)) {
+      const key = params.set ? "set" : "create";
+      throw new Error(`\`${key}\` option is not allowed in a batch update`);
+    }
     hasRelationHandleUpdate(
       q,
-      ctx,
       set,
       this.key,
       this.state.primaryKey,
@@ -737,12 +731,8 @@ const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
-  return async (q, data, params) => {
+  return async (_, data, params) => {
     var _a;
-    if ((params.set || params.create) && pqb.isQueryReturnsAll(q)) {
-      const key = params.set ? "set" : "create";
-      throw new Error(`\`${key}\` option is not allowed in a batch update`);
-    }
     const t = query.clone();
     if (params.create) {
       await t._count()._createMany(
@@ -772,7 +762,7 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
     }
     if (params.delete || params.update) {
       delete t.query[pqb.toSqlCacheKey];
-      const q2 = t._where(
+      const q = t._where(
         getWhereForNestedUpdate(
           data,
           params.delete || ((_a = params.update) == null ? void 0 : _a.where),
@@ -781,9 +771,9 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
         )
       );
       if (params.delete) {
-        await q2._delete();
+        await q._delete();
       } else if (params.update) {
-        await q2._update(params.update.data);
+        await q._update(params.update.data);
       }
     }
   };
@@ -827,10 +817,9 @@ class HasAndBelongsToManyVirtualColumn extends pqb.VirtualColumn {
       this.nestedInsert
     );
   }
-  update(q, ctx, set) {
+  update(q, _, set) {
     hasRelationHandleUpdate(
       q,
-      ctx,
       set,
       this.key,
       this.state.primaryKey,
@@ -910,24 +899,26 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     primaryKey: pk,
     modifyRelatedQuery(relationQuery) {
       const ref = {};
-      pqb.pushQueryValue(
-        relationQuery,
-        "afterCreate",
-        async (_, result) => {
-          const fromQuery = ref.query.clone();
-          fromQuery.query.select = [{ selectAs: { [fk]: pk } }];
-          const createdCount = await subQuery.count()._createFrom(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            fromQuery,
-            {
-              [afk]: result[apk]
-            }
+      relationQuery._afterCreate([], async (result) => {
+        if (result.length > 1) {
+          throw new pqb.OrchidOrmInternalError(
+            relationQuery,
+            "Creating multiple `hasAndBelongsToMany` records is not yet supported"
           );
-          if (createdCount === 0) {
-            throw new pqb.NotFoundError(fromQuery);
+        }
+        const fromQuery = ref.query.clone();
+        fromQuery.query.select = [{ selectAs: { [fk]: pk } }];
+        const createdCount = await subQuery.count()._createFrom(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          fromQuery,
+          {
+            [afk]: result[0][apk]
           }
+        );
+        if (createdCount === 0) {
+          throw new pqb.NotFoundError(fromQuery);
         }
-      );
+      });
       return (q) => {
         ref.query = q;
       };
@@ -1438,11 +1429,16 @@ const orchidORM = (_a, tables) => {
     dbTable.db = result;
     dbTable.filePath = table.filePath;
     dbTable.name = table.constructor.name;
-    if (table.hooks)
-      addTableHooks(dbTable, table.hooks);
     result[key] = dbTable;
   }
   applyRelations(qb, tableInstances, result);
+  for (const key in tables) {
+    const table = tableInstances[key];
+    if (table.init) {
+      table.init(result);
+      Object.assign(result[key].baseQuery.query, table.query);
+    }
+  }
   return result;
 };
 
@@ -1505,7 +1501,6 @@ Object.defineProperty(exports, 'testTransaction', {
   enumerable: true,
   get: function () { return pqb.testTransaction; }
 });
-exports.addTableHooks = addTableHooks;
 exports.createBaseTable = createBaseTable;
 exports.createRepo = createRepo;
 exports.orchidORM = orchidORM;