orchid-orm 1.3.16 → 1.4.17

package/dist/index.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var pqb = require('pqb');
 
-const createModel = (options) => {
-  return class Model {
+const createBaseTable = (options) => {
+  return class BaseTable {
     constructor() {
       this.setColumns = (fn) => {
         const shape = pqb.getColumnTypes(options.columnTypes, fn);
@@ -243,11 +243,11 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 
-const getThroughRelation = (model, through) => {
-  return model.relations[through];
+const getThroughRelation = (table, through) => {
+  return table.relations[through];
 };
 const getSourceRelation = (throughRelation, source) => {
-  return throughRelation.model.relations[source];
+  return throughRelation.table.relations[source];
 };
 const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKey, nestedInsert) => {
   const value = item[key];
@@ -345,7 +345,7 @@ class HasOneVirtualColumn extends pqb.VirtualColumn {
     );
   }
 }
-const makeHasOneMethod = (model, relation, relationName, query) => {
+const makeHasOneMethod = (table, relation, relationName, query) => {
   if (relation.options.required) {
     query._take();
   } else {
@@ -353,14 +353,14 @@ const makeHasOneMethod = (model, relation, relationName, query) => {
   }
   if ("through" in relation.options) {
     const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, 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);
+        const throughQuery = table[through](params);
         return query.whereExists(
           throughQuery,
           whereExistsCallback
@@ -542,10 +542,10 @@ class HasManyVirtualColumn extends pqb.VirtualColumn {
     );
   }
 }
-const makeHasManyMethod = (model, relation, relationName, query) => {
+const makeHasManyMethod = (table, relation, relationName, query) => {
   if ("through" in relation.options) {
     const { through, source } = relation.options;
-    const throughRelation = getThroughRelation(model, through);
+    const throughRelation = getThroughRelation(table, through);
     const sourceRelation = getSourceRelation(throughRelation, source);
     const sourceRelationQuery = sourceRelation.query.as(relationName);
     const sourceQuery = sourceRelation.joinQuery(
@@ -556,7 +556,7 @@ const makeHasManyMethod = (model, relation, relationName, query) => {
     return {
       returns: "many",
       method: (params) => {
-        const throughQuery = model[through](params);
+        const throughQuery = table[through](params);
         return query.whereExists(
           throughQuery,
           whereExistsCallback
@@ -788,7 +788,7 @@ class HasAndBelongsToManyVirtualColumn extends pqb.VirtualColumn {
     );
   }
 }
-const makeHasAndBelongsToManyMethod = (model, qb, relation, relationName, query) => {
+const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
   const {
     primaryKey: pk,
     foreignKey: fk,
@@ -799,14 +799,14 @@ const makeHasAndBelongsToManyMethod = (model, qb, relation, relationName, query)
   const foreignKeyFull = `${joinTable}.${fk}`;
   const associationForeignKeyFull = `${joinTable}.${afk}`;
   const associationPrimaryKeyFull = `${pqb.getQueryAs(query)}.${apk}`;
-  const __model = Object.create(qb.__model);
-  __model.__model = __model;
-  __model.table = joinTable;
-  __model.shape = {
-    [fk]: model.shape[pk],
+  const __table = Object.create(qb.__table);
+  __table.__table = __table;
+  __table.table = joinTable;
+  __table.shape = {
+    [fk]: table.shape[pk],
     [afk]: query.shape[apk]
   };
-  const subQuery = Object.create(__model);
+  const subQuery = Object.create(__table);
   subQuery.query = __spreadValues$2({}, subQuery.query);
   const state = {
     relatedTableQuery: query,
@@ -1056,38 +1056,40 @@ const nestedUpdate = (state) => {
   };
 };
 
-const applyRelations = (qb, models, result) => {
-  const modelsEntries = Object.entries(models);
+const applyRelations = (qb, tables, result) => {
+  const tableEntries = Object.entries(tables);
   const delayedRelations = /* @__PURE__ */ new Map();
-  for (const modelName in models) {
-    const model = models[modelName];
-    if (!("relations" in model) || typeof model.relations !== "object")
+  for (const name in tables) {
+    const table = tables[name];
+    if (!("relations" in table) || typeof table.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
+    const dbTable = result[name];
+    for (const relationName in table.relations) {
+      const relation = table.relations[relationName];
+      const otherTableClass = relation.fn();
+      const otherTable = tableEntries.find(
+        (pair) => pair[1] instanceof otherTableClass
       );
-      if (!otherModel) {
-        throw new Error(`Cannot find model for class ${otherModelClass.name}`);
+      if (!otherTable) {
+        throw new Error(
+          `Cannot find table class for class ${otherTableClass.name}`
+        );
       }
-      const otherModelName = otherModel[0];
-      const otherDbModel = result[otherModelName];
-      if (!otherDbModel)
-        throw new Error(`Cannot find model by name ${otherModelName}`);
+      const otherTableName = otherTable[0];
+      const otherDbTable = result[otherTableName];
+      if (!otherDbTable)
+        throw new Error(`Cannot find table class by name ${otherTableName}`);
       const data = {
         relationName,
         relation,
-        dbModel,
-        otherDbModel
+        dbTable,
+        otherDbTable
       };
       const options = relation.options;
       if (typeof options.through === "string" && typeof options.source === "string") {
-        const throughRelation = getThroughRelation(dbModel, options.through);
+        const throughRelation = getThroughRelation(dbTable, options.through);
         if (!throughRelation) {
-          delayRelation(delayedRelations, dbModel, options.through, data);
+          delayRelation(delayedRelations, dbTable, options.through, data);
           continue;
         }
         const sourceRelation = getSourceRelation(
@@ -1097,7 +1099,7 @@ const applyRelations = (qb, models, result) => {
         if (!sourceRelation) {
           delayRelation(
             delayedRelations,
-            throughRelation.model,
+            throughRelation.table,
             options.source,
             data
           );
@@ -1112,42 +1114,42 @@ const applyRelations = (qb, models, result) => {
     for (const key in value) {
       for (const item of value[key]) {
         const { relation } = item;
-        if (item.dbModel.relations[item.relationName])
+        if (item.dbTable.relations[item.relationName])
           continue;
-        const as = item.dbModel.definedAs;
+        const as = item.dbTable.definedAs;
         let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
-        const model = result[as];
+        const table = result[as];
         const { through, source } = relation.options;
-        const throughRel = model.relations[through];
+        const throughRel = table.relations[through];
         if (through && !throughRel) {
           message += `: cannot find \`${through}\` relation required by the \`through\` option`;
-        } else if (source && throughRel && !throughRel.model.relations[source]) {
-          message += `: cannot find \`${source}\` relation in \`${throughRel.model.definedAs}\` required by the \`source\` option`;
+        } else if (source && throughRel && !throughRel.table.relations[source]) {
+          message += `: cannot find \`${source}\` relation in \`${throughRel.table.definedAs}\` required by the \`source\` option`;
         }
         throw new Error(message);
       }
     }
   }
 };
-const delayRelation = (delayedRelations, model, relationName, data) => {
-  let modelRelations = delayedRelations.get(model);
-  if (!modelRelations) {
-    modelRelations = {};
-    delayedRelations.set(model, modelRelations);
+const delayRelation = (delayedRelations, table, relationName, data) => {
+  let tableRelations = delayedRelations.get(table);
+  if (!tableRelations) {
+    tableRelations = {};
+    delayedRelations.set(table, tableRelations);
   }
-  if (modelRelations[relationName]) {
-    modelRelations[relationName].push(data);
+  if (tableRelations[relationName]) {
+    tableRelations[relationName].push(data);
   } else {
-    modelRelations[relationName] = [data];
+    tableRelations[relationName] = [data];
   }
 };
-const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, delayedRelations) => {
+const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations) => {
   var _a;
-  const query = (relation.options.scope ? relation.options.scope(otherDbModel) : otherDbModel).as(relationName);
+  const query = (relation.options.scope ? relation.options.scope(otherDbTable) : otherDbTable).as(relationName);
   const definedAs = query.definedAs;
   if (!definedAs) {
     throw new Error(
-      `Model for table ${query.table} is not attached to db instance`
+      `Table class for table ${query.table} is not attached to db instance`
     );
   }
   const { type } = relation;
@@ -1155,12 +1157,12 @@ const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, de
   if (type === "belongsTo") {
     data = makeBelongsToMethod(relation, relationName, query);
   } else if (type === "hasOne") {
-    data = makeHasOneMethod(dbModel, relation, relationName, query);
+    data = makeHasOneMethod(dbTable, relation, relationName, query);
   } else if (type === "hasMany") {
-    data = makeHasManyMethod(dbModel, relation, relationName, query);
+    data = makeHasManyMethod(dbTable, relation, relationName, query);
   } else if (type === "hasAndBelongsToMany") {
     data = makeHasAndBelongsToManyMethod(
-      dbModel,
+      dbTable,
       qb,
       relation,
       relationName,
@@ -1173,38 +1175,38 @@ const applyRelation = (qb, { relationName, relation, dbModel, otherDbModel }, de
     query._take();
   }
   if (data.virtualColumn) {
-    dbModel.shape[relationName] = data.virtualColumn;
+    dbTable.shape[relationName] = data.virtualColumn;
   }
-  makeRelationQuery(dbModel, definedAs, relationName, data);
-  dbModel.relations[relationName] = {
+  makeRelationQuery(dbTable, definedAs, relationName, data);
+  dbTable.relations[relationName] = {
     type,
     key: relationName,
-    model: otherDbModel,
+    table: otherDbTable,
     query,
     joinQuery: data.joinQuery,
     primaryKey: data.primaryKey,
     options: relation.options
   };
-  const modelRelations = delayedRelations.get(dbModel);
-  if (!modelRelations)
+  const tableRelations = delayedRelations.get(dbTable);
+  if (!tableRelations)
     return;
-  (_a = modelRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
+  (_a = tableRelations[relationName]) == null ? void 0 : _a.forEach((data2) => {
     applyRelation(qb, data2, delayedRelations);
   });
 };
-const makeRelationQuery = (model, definedAs, relationName, data) => {
-  Object.defineProperty(model, relationName, {
+const makeRelationQuery = (table, definedAs, relationName, data) => {
+  Object.defineProperty(table, relationName, {
     get() {
       var _a;
-      const toModel = this.db[definedAs].as(relationName);
+      const toTable = this.db[definedAs].as(relationName);
       if (data.returns === "one") {
-        toModel._take();
+        toTable._take();
       }
-      const query = this.isSubQuery ? toModel : toModel._whereExists(data.reverseJoin(this, toModel), (q) => q);
+      const query = this.isSubQuery ? toTable : toTable._whereExists(data.reverseJoin(this, toTable), (q) => q);
       query.query[pqb.relationQueryKey] = {
         relationName,
         sourceQuery: this,
-        relationQuery: toModel,
+        relationQuery: toTable,
         joinQuery: data.joinQuery
       };
       const setQuery = (_a = data.modifyRelatedQuery) == null ? void 0 : _a.call(data, query);
@@ -1227,10 +1229,10 @@ function transaction(fn) {
     for (const key in this) {
       const value = this[key];
       if (value instanceof pqb.Db) {
-        const model = value.transacting(q);
-        model.__model = model;
-        model.db = orm;
-        orm[key] = model;
+        const table = value.transacting(q);
+        table.__table = table;
+        table.db = orm;
+        orm[key] = table;
       } else {
         orm[key] = value;
       }
@@ -1270,7 +1272,7 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-const orchidORM = (_a, models) => {
+const orchidORM = (_a, tables) => {
   var _b = _a, {
     log,
     logger,
@@ -1304,31 +1306,31 @@ const orchidORM = (_a, models) => {
     $queryBuilder: qb,
     $close: () => adapter.close()
   };
-  const modelInstances = {};
-  for (const key in models) {
+  const tableInstances = {};
+  for (const key in tables) {
     if (key[0] === "$") {
-      throw new Error(`Model name must not start with $`);
+      throw new Error(`Table class name must not start with $`);
     }
-    const model = new models[key]();
-    modelInstances[key] = model;
+    const table = new tables[key]();
+    tableInstances[key] = table;
     const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
-      schema: model.schema
+      schema: table.schema
     });
-    if (model.noPrimaryKey)
+    if (table.noPrimaryKey)
       options2.noPrimaryKey = "ignore";
-    const dbModel = new pqb.Db(
+    const dbTable = new pqb.Db(
       adapter,
       qb,
-      model.table,
-      model.columns.shape,
-      model.columnTypes,
+      table.table,
+      table.columns.shape,
+      table.columnTypes,
       options2
     );
-    dbModel.definedAs = key;
-    dbModel.db = result;
-    result[key] = dbModel;
+    dbTable.definedAs = key;
+    dbTable.db = result;
+    result[key] = dbTable;
   }
-  applyRelations(qb, modelInstances, result);
+  applyRelations(qb, tableInstances, result);
   return result;
 };
 
@@ -1348,26 +1350,26 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const createRepo = (model, methods) => {
+const createRepo = (table, 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 proto = Object.create(q2.__table);
+    proto.__table = proto;
     const result = Object.create(proto);
     result.query = pqb.getClonedQueryData(q2.query);
     if (plainMethods) {
-      Object.assign(proto.__model, plainMethods);
+      Object.assign(proto.__table, plainMethods);
     }
     for (const key in queryMethods) {
       const method = queryMethods[key];
-      proto.__model[key] = function(...args) {
+      proto.__table[key] = function(...args) {
         return method(this, ...args);
       };
     }
     return result;
   };
-  const q = repo(model);
+  const q = repo(table);
   return new Proxy(repo, {
     get(_, key) {
       return q[key];
@@ -1375,7 +1377,7 @@ const createRepo = (model, methods) => {
   });
 };
 
-exports.createModel = createModel;
+exports.createBaseTable = createBaseTable;
 exports.createRepo = createRepo;
 exports.orchidORM = orchidORM;
 //# sourceMappingURL=index.js.map