orchid-orm 0.0.1

package/dist/index.esm.js

@@ -0,0 +1,1116 @@
+import { getColumnTypes, isQueryReturnsAll, addQueryOn, getQueryAs, toSqlCacheKey, pushQueryValue, NotFoundError, relationQueryKey, Db, Adapter, columnTypes, getClonedQueryData } from 'pqb';
+
+const createModel = (options) => {
+  return class Model {
+    constructor() {
+      this.setColumns = (fn) => {
+        const shape = getColumnTypes(options.columnTypes, fn);
+        return {
+          shape,
+          type: void 0
+        };
+      };
+      this.columnTypes = options.columnTypes;
+    }
+    belongsTo(fn, options2) {
+      return {
+        type: "belongsTo",
+        returns: "one",
+        fn,
+        options: options2
+      };
+    }
+    hasOne(fn, options2) {
+      return {
+        type: "hasOne",
+        returns: "one",
+        fn,
+        options: options2
+      };
+    }
+    hasMany(fn, options2) {
+      return {
+        type: "hasMany",
+        returns: "many",
+        fn,
+        options: options2
+      };
+    }
+    hasAndBelongsToMany(fn, options2) {
+      return {
+        type: "hasAndBelongsToMany",
+        returns: "many",
+        fn,
+        options: options2
+      };
+    }
+  };
+};
+
+const makeBelongsToMethod = (relation, query) => {
+  const { primaryKey, foreignKey } = relation.options;
+  return {
+    returns: "one",
+    method: (params) => {
+      return query.findBy({ [primaryKey]: params[foreignKey] });
+    },
+    nestedInsert: async (q, data) => {
+      const connectOrCreate = data.filter(
+        (item) => Boolean(item.connectOrCreate)
+      );
+      const t = query.transacting(q);
+      let connectOrCreated;
+      if (connectOrCreate.length) {
+        connectOrCreated = await Promise.all(
+          connectOrCreate.map(
+            (item) => t.findBy(item.connectOrCreate.where)._takeOptional()
+          )
+        );
+      } else {
+        connectOrCreated = [];
+      }
+      let connectOrCreatedI = 0;
+      const create = data.filter(
+        (item) => {
+          if (item.connectOrCreate) {
+            return !connectOrCreated[connectOrCreatedI++];
+          } else {
+            return Boolean(item.create);
+          }
+        }
+      );
+      let created;
+      if (create.length) {
+        created = await t.select(primaryKey)._createMany(
+          create.map(
+            (item) => "create" in item ? item.create : item.connectOrCreate.create
+          )
+        );
+      } else {
+        created = [];
+      }
+      const connect = data.filter(
+        (item) => Boolean(item.connect)
+      );
+      let connected;
+      if (connect.length) {
+        connected = await Promise.all(
+          connect.map((item) => t.findBy(item.connect)._take())
+        );
+      } else {
+        connected = [];
+      }
+      let createdI = 0;
+      let connectedI = 0;
+      connectOrCreatedI = 0;
+      return data.map(
+        (item) => item.connectOrCreate ? connectOrCreated[connectOrCreatedI++] || created[createdI++] : item.connect ? connected[connectedI++] : created[createdI++]
+      );
+    },
+    nestedUpdate: (q, update, params, state) => {
+      var _a, _b;
+      if (params.upsert && isQueryReturnsAll(q)) {
+        throw new Error("`upsert` option is not allowed in a batch update");
+      }
+      let idForDelete;
+      q._beforeUpdate(async (q2) => {
+        if (params.disconnect) {
+          update[foreignKey] = null;
+        } else if (params.set) {
+          if (primaryKey in params.set) {
+            update[foreignKey] = params.set[primaryKey];
+          } else {
+            update[foreignKey] = await query.transacting(q2)._findBy(params.set)._get(primaryKey);
+          }
+        } else if (params.create) {
+          update[foreignKey] = await query.transacting(q2)._get(primaryKey)._create(params.create);
+        } else if (params.delete) {
+          const selectQuery = q2.transacting(q2);
+          selectQuery.query.type = void 0;
+          idForDelete = await selectQuery._getOptional(foreignKey);
+          update[foreignKey] = null;
+        }
+      });
+      const { upsert } = params;
+      if (upsert || params.update || params.delete) {
+        if (!((_a = q.query.select) == null ? void 0 : _a.includes("*")) && !((_b = q.query.select) == null ? void 0 : _b.includes(foreignKey))) {
+          q._select(foreignKey);
+        }
+      }
+      if (upsert) {
+        if (!state.updateLater) {
+          state.updateLater = {};
+          state.updateLaterPromises = [];
+        }
+        const { handleResult } = q.query;
+        q.query.handleResult = async (q2, queryResult) => {
+          const data = await handleResult(q2, queryResult);
+          const id = data[0][foreignKey];
+          if (id !== null) {
+            await query.transacting(q2)._findBy({ [primaryKey]: id })._update(upsert.update);
+          } else {
+            state.updateLaterPromises.push(
+              query.transacting(q2)._select(primaryKey)._create(upsert.create).then((result) => {
+                state.updateLater[foreignKey] = result[primaryKey];
+              })
+            );
+          }
+          return data;
+        };
+      } else if (params.delete || params.update) {
+        q._afterQuery(async (q2, 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({
+              [primaryKey]: id
+            });
+            if (params.delete) {
+              await t._delete();
+            } else if (params.update) {
+              await t._update(params.update);
+            }
+          }
+        });
+      }
+      return !params.update && !params.upsert;
+    },
+    joinQuery(fromQuery, toQuery) {
+      return addQueryOn(toQuery, fromQuery, toQuery, primaryKey, foreignKey);
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
+    },
+    primaryKey
+  };
+};
+
+const getThroughRelation = (model, through) => {
+  return model.relations[through];
+};
+const getSourceRelation = (throughRelation, source) => {
+  return throughRelation.model.relations[source];
+};
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const makeHasOneMethod = (model, relation, relationName, query) => {
+  if (relation.options.required) {
+    query._take();
+  } else {
+    query._takeOptional();
+  }
+  if ("through" in relation.options) {
+    const { through, source } = relation.options;
+    const throughRelation = getThroughRelation(model, through);
+    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 = model[through](params);
+        return query.whereExists(
+          throughQuery,
+          whereExistsCallback
+        );
+      },
+      nestedInsert: void 0,
+      nestedUpdate: void 0,
+      joinQuery(fromQuery, toQuery) {
+        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(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          () => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
+              throughRelation.query,
+              sourceRelation.query.as(as)
+            );
+          }
+        );
+      },
+      primaryKey: sourceRelation.primaryKey
+    };
+  }
+  const { primaryKey, foreignKey } = relation.options;
+  const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
+  return {
+    returns: "one",
+    method: (params) => {
+      const values = { [foreignKey]: params[primaryKey] };
+      return query.where(values)._defaults(values);
+    },
+    nestedInsert: async (q, data) => {
+      const connect = data.filter(
+        (item) => Boolean(item[1].connect || item[1].connectOrCreate)
+      );
+      const t = query.transacting(q);
+      let connected;
+      if (connect.length) {
+        connected = await Promise.all(
+          connect.map(([selfData, item]) => {
+            const data2 = { [foreignKey]: selfData[primaryKey] };
+            return "connect" in item ? t.where(item.connect)._updateOrThrow(data2) : t.where(item.connectOrCreate.where)._update(data2);
+          })
+        );
+      } else {
+        connected = [];
+      }
+      let connectedI = 0;
+      const create = data.filter(
+        (item) => {
+          if (item[1].connectOrCreate) {
+            return !connected[connectedI++];
+          }
+          return Boolean(item[1].create);
+        }
+      );
+      if (create.length) {
+        await t._count()._createMany(
+          create.map(([selfData, item]) => __spreadValues$4({
+            [foreignKey]: selfData[primaryKey]
+          }, "create" in item ? item.create : item.connectOrCreate.create))
+        );
+      }
+    },
+    nestedUpdate: async (q, data, params) => {
+      if ((params.set || params.create || params.upsert) && isQueryReturnsAll(q)) {
+        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 ids = data.map((item) => item[primaryKey]);
+      const currentRelationsQuery = t.where({
+        [foreignKey]: { in: ids }
+      });
+      if (params.create || params.disconnect || params.set) {
+        await currentRelationsQuery._update({ [foreignKey]: null });
+        if (params.create) {
+          await t._count()._create(__spreadProps$2(__spreadValues$4({}, params.create), {
+            [foreignKey]: data[0][primaryKey]
+          }));
+        }
+        if (params.set) {
+          await t._where(params.set)._update({ [foreignKey]: data[0][primaryKey] });
+        }
+      } else if (params.update) {
+        await currentRelationsQuery._update(params.update);
+      } else if (params.delete) {
+        await currentRelationsQuery._delete();
+      } else if (params.upsert) {
+        const { update, create } = params.upsert;
+        const updatedIds = await currentRelationsQuery._pluck(foreignKey)._update(update);
+        if (updatedIds.length < ids.length) {
+          await t.createMany(
+            ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$2(__spreadValues$4({}, create), {
+              [foreignKey]: id
+            }))
+          );
+        }
+      }
+    },
+    joinQuery(fromQuery, toQuery) {
+      return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
+    },
+    primaryKey,
+    modifyRelatedQuery(relationQuery) {
+      return (query2) => {
+        const fromQuery = query2.clone();
+        fromQuery.query.select = fromQuerySelect;
+        relationQuery.query.fromQuery = fromQuery;
+      };
+    }
+  };
+};
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const makeHasManyMethod = (model, relation, relationName, query) => {
+  if ("through" in relation.options) {
+    const { through, source } = relation.options;
+    const throughRelation = getThroughRelation(model, 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 = model[through](params);
+        return query.whereExists(
+          throughQuery,
+          whereExistsCallback
+        );
+      },
+      nestedInsert: void 0,
+      nestedUpdate: void 0,
+      joinQuery(fromQuery, toQuery) {
+        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(
+          throughRelation.joinQuery(fromQuery, throughRelation.query),
+          () => {
+            const as = getQueryAs(toQuery);
+            return sourceRelation.joinQuery(
+              throughRelation.query,
+              sourceRelation.query.as(as)
+            );
+          }
+        );
+      },
+      primaryKey: sourceRelation.primaryKey
+    };
+  }
+  const { primaryKey, foreignKey } = relation.options;
+  const fromQuerySelect = [{ selectAs: { [foreignKey]: primaryKey } }];
+  return {
+    returns: "many",
+    method: (params) => {
+      const values = { [foreignKey]: params[primaryKey] };
+      return query.where(values)._defaults(values);
+    },
+    nestedInsert: async (q, data) => {
+      const connect = data.filter(
+        (item) => Boolean(item[1].connect)
+      );
+      const t = query.transacting(q);
+      if (connect.length) {
+        await Promise.all(
+          connect.flatMap(
+            ([selfData, { connect: connect2 }]) => connect2.map(
+              (item) => t.where(item)._updateOrThrow({ [foreignKey]: selfData[primaryKey] })
+            )
+          )
+        );
+      }
+      const connectOrCreate = data.filter(
+        (item) => Boolean(item[1].connectOrCreate)
+      );
+      let connected;
+      if (connectOrCreate.length) {
+        connected = await Promise.all(
+          connectOrCreate.flatMap(
+            ([selfData, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
+              (item) => t.where(item.where)._update({
+                [foreignKey]: selfData[primaryKey]
+              })
+            )
+          )
+        );
+      } else {
+        connected = [];
+      }
+      let connectedI = 0;
+      const create = data.filter(
+        (item) => {
+          if (item[1].connectOrCreate) {
+            const length = item[1].connectOrCreate.length;
+            connectedI += length;
+            for (let i = length; i > 0; i--) {
+              if (connected[connectedI - i] === 0)
+                return true;
+            }
+          }
+          return Boolean(item[1].create);
+        }
+      );
+      connectedI = 0;
+      if (create.length) {
+        await t._createMany(
+          create.flatMap(
+            ([selfData, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => {
+              return [
+                ...create2.map((item) => __spreadValues$3({
+                  [foreignKey]: selfData[primaryKey]
+                }, item)),
+                ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$3({
+                  [foreignKey]: selfData[primaryKey]
+                }, item.create))
+              ];
+            }
+          )
+        );
+      }
+    },
+    nestedUpdate: async (q, data, params) => {
+      var _a;
+      if ((params.set || params.create) && isQueryReturnsAll(q)) {
+        const key = params.set ? "set" : "create";
+        throw new Error(`\`${key}\` option is not allowed in a batch update`);
+      }
+      const t = query.transacting(q);
+      if (params.create) {
+        await t._count()._createMany(
+          params.create.map((create) => __spreadProps$1(__spreadValues$3({}, create), {
+            [foreignKey]: data[0][primaryKey]
+          }))
+        );
+        delete t.query[toSqlCacheKey];
+      }
+      if (params.disconnect || params.set) {
+        await t.where(
+          getWhereForNestedUpdate(
+            data,
+            params.disconnect,
+            primaryKey,
+            foreignKey
+          )
+        )._update({ [foreignKey]: null });
+        if (params.set) {
+          delete t.query[toSqlCacheKey];
+          await t.where(
+            Array.isArray(params.set) ? {
+              OR: params.set
+            } : params.set
+          )._update({ [foreignKey]: data[0][primaryKey] });
+        }
+      }
+      if (params.delete || params.update) {
+        delete t.query[toSqlCacheKey];
+        const q2 = t._where(
+          getWhereForNestedUpdate(
+            data,
+            params.delete || ((_a = params.update) == null ? void 0 : _a.where),
+            primaryKey,
+            foreignKey
+          )
+        );
+        if (params.delete) {
+          await q2._delete();
+        } else if (params.update) {
+          await q2._update(params.update.data);
+        }
+      }
+    },
+    joinQuery(fromQuery, toQuery) {
+      return addQueryOn(toQuery, fromQuery, toQuery, foreignKey, primaryKey);
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
+    },
+    primaryKey,
+    modifyRelatedQuery(relationQuery) {
+      return (query2) => {
+        const fromQuery = query2.clone();
+        fromQuery.query.select = fromQuerySelect;
+        relationQuery.query.fromQuery = fromQuery;
+      };
+    }
+  };
+};
+const getWhereForNestedUpdate = (data, params, primaryKey, foreignKey) => {
+  const where = {
+    [foreignKey]: { in: data.map((item) => item[primaryKey]) }
+  };
+  if (params) {
+    if (Array.isArray(params)) {
+      where.OR = params;
+    } else {
+      Object.assign(where, params);
+    }
+  }
+  return where;
+};
+
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+const makeHasAndBelongsToManyMethod = (model, qb, relation, query) => {
+  const {
+    primaryKey: pk,
+    foreignKey: fk,
+    associationPrimaryKey: apk,
+    associationForeignKey: afk,
+    joinTable
+  } = relation.options;
+  const foreignKeyFull = `${joinTable}.${fk}`;
+  const associationForeignKeyFull = `${joinTable}.${afk}`;
+  const associationPrimaryKeyFull = `${getQueryAs(query)}.${apk}`;
+  const __model = Object.create(qb.__model);
+  __model.__model = __model;
+  __model.table = joinTable;
+  __model.shape = {
+    [fk]: model.shape[pk],
+    [afk]: query.shape[apk]
+  };
+  const subQuery = Object.create(__model);
+  subQuery.query = __spreadValues$2({}, subQuery.query);
+  const state = {
+    relatedTableQuery: query,
+    joinTableQuery: subQuery,
+    primaryKey: pk,
+    foreignKey: fk,
+    associationPrimaryKey: apk,
+    associationForeignKey: afk
+  };
+  return {
+    returns: "many",
+    method(params) {
+      return query.whereExists(
+        subQuery,
+        (q) => q.on(associationForeignKeyFull, associationPrimaryKeyFull).where({
+          [foreignKeyFull]: params[pk]
+        })
+      );
+    },
+    nestedInsert: async (q, data) => {
+      const connect = data.filter(
+        (item) => Boolean(item[1].connect)
+      );
+      const t = query.transacting(q);
+      let connected;
+      if (connect.length) {
+        connected = await Promise.all(
+          connect.flatMap(
+            ([, { connect: connect2 }]) => connect2.map((item) => t.select(apk)._findBy(item)._take())
+          )
+        );
+      } else {
+        connected = [];
+      }
+      const connectOrCreate = data.filter(
+        (item) => Boolean(item[1].connectOrCreate)
+      );
+      let connectOrCreated;
+      if (connectOrCreate.length) {
+        connectOrCreated = await Promise.all(
+          connectOrCreate.flatMap(
+            ([, { connectOrCreate: connectOrCreate2 }]) => connectOrCreate2.map(
+              (item) => t.select(apk)._findBy(item.where)._takeOptional()
+            )
+          )
+        );
+      } else {
+        connectOrCreated = [];
+      }
+      let connectOrCreateI = 0;
+      const create = data.filter(
+        (item) => {
+          if (item[1].connectOrCreate) {
+            const length = item[1].connectOrCreate.length;
+            connectOrCreateI += length;
+            for (let i = length; i > 0; i--) {
+              if (!connectOrCreated[connectOrCreateI - i])
+                return true;
+            }
+          }
+          return Boolean(item[1].create);
+        }
+      );
+      connectOrCreateI = 0;
+      let created;
+      if (create.length) {
+        created = await t.select(apk)._createMany(
+          create.flatMap(([, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => [
+            ...create2,
+            ...connectOrCreate2.filter(() => !connectOrCreated[connectOrCreateI++]).map((item) => item.create)
+          ])
+        );
+      } else {
+        created = [];
+      }
+      const allKeys = data;
+      let createI = 0;
+      let connectI = 0;
+      connectOrCreateI = 0;
+      data.forEach(([, data2], index) => {
+        if (data2.create || data2.connectOrCreate) {
+          if (data2.create) {
+            const len = data2.create.length;
+            allKeys[index][1] = created.slice(createI, createI + len);
+            createI += len;
+          }
+          if (data2.connectOrCreate) {
+            const arr = [];
+            allKeys[index][1] = arr;
+            const len = data2.connectOrCreate.length;
+            for (let i = 0; i < len; i++) {
+              const item = connectOrCreated[connectOrCreateI++];
+              if (item) {
+                arr.push(item);
+              } else {
+                arr.push(created[createI++]);
+              }
+            }
+          }
+        }
+        if (data2.connect) {
+          const len = data2.connect.length;
+          allKeys[index][1] = connected.slice(connectI, connectI + len);
+          connectI += len;
+        }
+      });
+      await subQuery.transacting(q)._count()._createMany(
+        allKeys.flatMap(([selfData, relationKeys]) => {
+          const selfKey = selfData[pk];
+          return relationKeys.map((relationData) => ({
+            [fk]: selfKey,
+            [afk]: relationData[apk]
+          }));
+        })
+      );
+    },
+    nestedUpdate: async (q, data, params) => {
+      if (params.create) {
+        const ids = await query.transacting(q)._pluck(apk)._createMany(params.create);
+        await subQuery.transacting(q)._createMany(
+          data.flatMap(
+            (item) => ids.map((id) => ({
+              [fk]: item[pk],
+              [afk]: id
+            }))
+          )
+        );
+      }
+      if (params.update) {
+        await query.transacting(q)._whereExists(
+          subQuery,
+          (q2) => q2._on(associationForeignKeyFull, associationPrimaryKeyFull)._where({
+            IN: {
+              columns: [foreignKeyFull],
+              values: [data.map((item) => item[pk])]
+            }
+          })
+        )._where(
+          Array.isArray(params.update.where) ? { OR: params.update.where } : params.update.where
+        )._update(params.update.data);
+      }
+      if (params.disconnect) {
+        await queryJoinTable(state, q, data, params.disconnect)._delete();
+      }
+      if (params.delete) {
+        const j = queryJoinTable(state, q, data, params.delete);
+        const ids = await j._pluck(afk)._delete();
+        await queryRelatedTable(query, q, { [apk]: { in: ids } })._delete();
+      }
+      if (params.set) {
+        const j = queryJoinTable(state, q, data);
+        await j._delete();
+        delete j.query[toSqlCacheKey];
+        const ids = await queryRelatedTable(query, q, params.set)._pluck(apk);
+        await insertToJoinTable(state, j, data, ids);
+      }
+    },
+    joinQuery(fromQuery, toQuery) {
+      return toQuery.whereExists(
+        subQuery,
+        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${pk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
+      );
+    },
+    reverseJoin(fromQuery, toQuery) {
+      return fromQuery.whereExists(
+        subQuery,
+        (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${pk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
+      );
+    },
+    primaryKey: pk,
+    modifyRelatedQuery(relationQuery) {
+      const ref = {};
+      pushQueryValue(
+        relationQuery,
+        "afterCreate",
+        async (q, result) => {
+          const fromQuery = ref.query.clone();
+          fromQuery.query.select = [{ selectAs: { [fk]: pk } }];
+          const createdCount = await subQuery.transacting(q).count()._createFrom(
+            fromQuery,
+            {
+              [afk]: result[apk]
+            }
+          );
+          if (createdCount === 0) {
+            throw new NotFoundError();
+          }
+        }
+      );
+      return (q) => {
+        ref.query = q;
+      };
+    }
+  };
+};
+const queryJoinTable = (state, q, data, conditions) => {
+  const t = state.joinTableQuery.transacting(q);
+  const where = {
+    [state.foreignKey]: { in: data.map((item) => item[state.primaryKey]) }
+  };
+  if (conditions) {
+    where[state.associationForeignKey] = {
+      in: state.relatedTableQuery.where(
+        Array.isArray(conditions) ? { OR: conditions } : conditions
+      )._select(state.associationPrimaryKey)
+    };
+  }
+  return t._where(where);
+};
+const queryRelatedTable = (query, q, conditions) => {
+  return query.transacting(q)._where(Array.isArray(conditions) ? { OR: conditions } : conditions);
+};
+const insertToJoinTable = (state, joinTableTransaction, data, ids) => {
+  return joinTableTransaction._count()._createMany(
+    data.flatMap(
+      (item) => ids.map((id) => ({
+        [state.foreignKey]: item[state.primaryKey],
+        [state.associationForeignKey]: id
+      }))
+    )
+  );
+};
+
+const applyRelations = (qb, models, result) => {
+  const modelsEntries = Object.entries(models);
+  const delayedRelations = /* @__PURE__ */ new Map();
+  for (const modelName in models) {
+    const model = models[modelName];
+    if (!("relations" in model) || typeof model.relations !== "object")
+      continue;
+    const dbModel = result[modelName];
+    for (const relationName in model.relations) {
+      const relation = model.relations[relationName];
+      const otherModelClass = relation.fn();
+      const otherModel = modelsEntries.find(
+        (pair) => pair[1] instanceof otherModelClass
+      );
+      if (!otherModel) {
+        throw new Error(`Cannot find model for class ${otherModelClass.name}`);
+      }
+      const otherModelName = otherModel[0];
+      const otherDbModel = result[otherModelName];
+      if (!otherDbModel)
+        throw new Error(`Cannot find model by name ${otherModelName}`);
+      const data = {
+        relationName,
+        relation,
+        dbModel,
+        otherDbModel
+      };
+      const options = relation.options;
+      if (typeof options.through === "string" && typeof options.source === "string") {
+        const throughRelation = getThroughRelation(dbModel, options.through);
+        if (!throughRelation) {
+          delayRelation(delayedRelations, dbModel, options.through, data);
+          continue;
+        }
+        const sourceRelation = getSourceRelation(
+          throughRelation,
+          options.source
+        );
+        if (!sourceRelation) {
+          delayRelation(
+            delayedRelations,
+            throughRelation.model,
+            options.source,
+            data
+          );
+          continue;
+        }
+      }
+      applyRelation(qb, data, delayedRelations);
+    }
+  }
+};
+const delayRelation = (delayedRelations, model, relationName, data) => {
+  let modelRelations = delayedRelations.get(model);
+  if (!modelRelations) {
+    modelRelations = {};
+    delayedRelations.set(model, modelRelations);
+  }
+  if (modelRelations[relationName]) {
+    modelRelations[relationName].push(data);
+  } else {
+    modelRelations[relationName] = [data];
+  }
+};
+const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, delayedRelations) => {
+  var _a;
+  const query = (relation.options.scope ? relation.options.scope(otherDbModel) : otherDbModel).as(relationName);
+  const definedAs = query.definedAs;
+  if (!definedAs) {
+    throw new Error(
+      `Model for table ${query.table} is not attached to db instance`
+    );
+  }
+  const { type } = relation;
+  let data;
+  if (type === "belongsTo") {
+    data = makeBelongsToMethod(relation, query);
+  } else if (type === "hasOne") {
+    data = makeHasOneMethod(dbModel, relation, relationName, query);
+  } else if (type === "hasMany") {
+    data = makeHasManyMethod(dbModel, relation, relationName, query);
+  } else if (type === "hasAndBelongsToMany") {
+    data = makeHasAndBelongsToManyMethod(dbModel, qb, relation, query);
+  } else {
+    throw new Error(`Unknown relation type ${type}`);
+  }
+  if (data.returns === "one") {
+    query._take();
+  }
+  makeRelationQuery(dbModel, definedAs, relationName, data);
+  dbModel.relations[relationName] = {
+    type,
+    key: relationName,
+    model: otherDbModel,
+    query,
+    nestedInsert: data.nestedInsert,
+    nestedUpdate: data.nestedUpdate,
+    joinQuery: data.joinQuery,
+    primaryKey: data.primaryKey,
+    options: relation.options
+  };
+  const modelRelations = delayedRelations.get(dbModel);
+  if (!modelRelations)
+    return;
+  (_a = modelRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
+    applyRelation(qb, data2, delayedRelations);
+  });
+};
+const makeRelationQuery = (model, definedAs, relationName, data) => {
+  Object.defineProperty(model, relationName, {
+    get() {
+      var _a;
+      const toModel = this.db[definedAs].as(relationName);
+      if (data.returns === "one") {
+        toModel._take();
+      }
+      const query = this.isSubQuery ? toModel : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+      query.query[relationQueryKey] = {
+        relationName,
+        sourceQuery: this,
+        relationQuery: toModel,
+        joinQuery: data.joinQuery
+      };
+      const setQuery = (_a = data.modifyRelatedQuery) == null ? void 0 : _a.call(data, query);
+      setQuery == null ? void 0 : setQuery(this);
+      return new Proxy(data.method, {
+        get(_, prop) {
+          return query[prop];
+        }
+      });
+    }
+  });
+};
+
+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 Db) {
+        const model = value.transacting(q);
+        model.__model = model;
+        model.db = orm;
+        orm[key] = model;
+      } else {
+        orm[key] = value;
+      }
+    }
+    return fn(orm);
+  });
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const orchidORM = (_a, models) => {
+  var _b = _a, {
+    log,
+    logger
+  } = _b, options = __objRest(_b, [
+    "log",
+    "logger"
+  ]);
+  const adapter = "adapter" in options ? options.adapter : new Adapter(options);
+  const commonOptions = { log, logger };
+  const qb = new Db(
+    adapter,
+    void 0,
+    void 0,
+    {},
+    columnTypes,
+    commonOptions
+  );
+  qb.queryBuilder = qb;
+  const result = {
+    $transaction: transaction,
+    $adapter: adapter,
+    $queryBuilder: qb,
+    $close: () => adapter.close()
+  };
+  const modelInstances = {};
+  for (const key in models) {
+    if (key[0] === "$") {
+      throw new Error(`Model name must not start with $`);
+    }
+    const model = new models[key]();
+    modelInstances[key] = model;
+    const dbModel = new Db(
+      adapter,
+      qb,
+      model.table,
+      model.columns.shape,
+      model.columnTypes,
+      __spreadProps(__spreadValues$1({}, commonOptions), {
+        schema: model.schema
+      })
+    );
+    dbModel.definedAs = key;
+    dbModel.db = result;
+    result[key] = dbModel;
+  }
+  applyRelations(qb, modelInstances, result);
+  return result;
+};
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const createRepo = (model, methods) => {
+  const queryMethods = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
+  const plainMethods = methods.methods;
+  const repo = (q2) => {
+    const proto = Object.create(q2.__model);
+    proto.__model = proto;
+    const result = Object.create(proto);
+    result.query = getClonedQueryData(q2.query);
+    if (plainMethods) {
+      Object.assign(proto.__model, plainMethods);
+    }
+    for (const key in queryMethods) {
+      const method = queryMethods[key];
+      proto.__model[key] = function(...args) {
+        return method(this, ...args);
+      };
+    }
+    return result;
+  };
+  const q = repo(model);
+  return new Proxy(repo, {
+    get(_, key) {
+      return q[key];
+    }
+  });
+};
+
+export { createModel, createRepo, orchidORM };
+//# sourceMappingURL=index.esm.js.map