@anephenix/objection-relations 0.0.1 → 0.0.3

package/README.md

@@ -1,14 +1,16 @@
 # objection-relations
 
+[![Node.js CI](https://github.com/anephenix/objection-relations/actions/workflows/node.js.yml/badge.svg)](https://github.com/anephenix/objection-relations/actions/workflows/node.js.yml) [![Maintainability](https://api.codeclimate.com/v1/badges/33642d97558a57dc7c1d/maintainability)](https://codeclimate.com/github/anephenix/objection-relations/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/33642d97558a57dc7c1d/test_coverage)](https://codeclimate.com/github/anephenix/objection-relations/test_coverage)
+
 A relations helper for Objection.js. This provides a convenient way to define
 relations in the `relationMappings` function on an Objection.js model.
 
-For example, say you have a table called "Persons" with this relation mapping:
+For example, say you have a table called "Users" with this relation mapping:
 
 ```javascript
-class Person extends Model {
+class User extends Model {
   static get tableName() {
-    return 'persons';
+    return 'users';
   }
 
   static get relationMappings() {
@@ -17,8 +19,8 @@ class Person extends Model {
         relation: Model.HasManyRelation,
         modelClass: Address,
         join: {
-          from: 'persons.id',
-          to: 'addresses.person_id',
+          from: 'users.id',
+          to: 'addresses.user_id',
         },
       },
     };
@@ -29,20 +31,20 @@ class Person extends Model {
 You can use the objection-relations helper module to write the instead:
 
 ```javascript
-import { relation } from '@anephenix/objection-relations';
+import { ObjectionRelation } from '@anephenix/objection-relations';
 
-class Person extends Model {
+class User extends Model {
   static get tableName() {
-    return 'persons';
+    return 'users';
   }
 
   static get relationMappings() {
+    const or = new ObjectionRelation({
+      subject: this.name,
+      modelPath: __dirname,
+    });
     return {
-      addresses: relation({
-        subject: 'Person',
-        relType: 'hasMany',
-        object: 'Address',
-      }),
+      addresses: or.hasMany('Address'),
     };
   }
 }
@@ -53,7 +55,11 @@ The helper function will do the following:
 - Setup the relation type from Objection.js (hasOne, hasMany, hasMnayThrough, belongsTo)
 - Define the join table based on the properties of the subject and object
   models, if they follow a particular pattern (tables for models are named in
-  plural format, and foreign keys use a singular format).
+  plural format, and foreign keys use a singular format). e.g.
+
+| Model | table name | foreign key |
+| ----- | ---------- | ----------- |
+| User  | users      | user_id     |
 
 ## Dependencies
 
@@ -72,7 +78,7 @@ You can setup different kinds of database table relationships like this:
 ### Belongs to
 
 ```javascript
-relation({ subject: 'Post', relType: 'belongsTo', object: 'User' });
+or.belongsTo('Role');
 ```
 
 Is equivalent to writing:
@@ -80,10 +86,10 @@ Is equivalent to writing:
 ```javascript
 {
     relation: Model.BelongsToOneRelation,
-    modelClass: User,
+    modelClass: 'Role',
     join: {
-        from: 'posts.user_id',
-        to: 'users.id'
+        from: 'users.role_id',
+        to: 'roles.id'
     }
 }
 ```
@@ -91,7 +97,7 @@ Is equivalent to writing:
 ### Has one
 
 ```javascript
-relation({ subject: 'User', relType: 'hasOne', object: 'Setting' });
+or.hasOne('Setting');
 ```
 
 Is equivalent to writing:
@@ -99,7 +105,7 @@ Is equivalent to writing:
 ```javascript
 {
     relation: Model.HasOneRelation,
-    modelClass: Setting,
+    modelClass: 'Setting',
     join: {
         from: 'users.id',
         to: 'settings.user_id'
@@ -110,7 +116,7 @@ Is equivalent to writing:
 ### Has many
 
 ```javascript
-relation({ subject: 'User', relType: 'hasMany', object: 'Address' });
+or.hasMany('Address');
 ```
 
 Is equivalent to writing:
@@ -131,12 +137,7 @@ Is equivalent to writing:
 For relationships defined through a join table, you can write this:
 
 ```javascript
-relation({
-  subject: 'User',
-  relType: 'hasManyThrough',
-  object: 'Company',
-  via: 'Employment',
-});
+or.hasManyThrough('Company', 'Employment');
 ```
 
 This is equivalent to:
@@ -168,12 +169,7 @@ Say a `User` model has many addresses, but the database table is called
 'account_users', you can write this code:
 
 ```javascript
-relation({
-  subject: 'User',
-  relType: 'hasMany',
-  object: 'Address',
-  options: { subjectTable: 'account_users' },
-});
+or.hasMany('Address', { subjectTable: 'account_users' });
 ```
 
 Which is equivalent to writing:
@@ -195,12 +191,7 @@ The same applies for the object table. Say for example the `Address` model has
 the database table 'shipping_addresses', you could write this:
 
 ```javascript
-relation({
-  subject: 'User',
-  relType: 'hasMany',
-  object: 'Address',
-  options: { objectTable: 'shipping_addresses' },
-});
+or.hasMany('Address', { objectTable: 'shipping_addresses' });
 ```
 
 Which is equivalent to writing:
@@ -222,12 +213,7 @@ If you find that the foreign key is not a singular form of the related model,
 then you can pass a foreign key for the subject like this:
 
 ```javascript
-relation({
-  subject: 'User',
-  relType: 'hasMany',
-  object: 'Address',
-  options: { subjectForeignKey: 'account_user_id' },
-});
+or.hasMany('Address', { subjectForeignKey: 'account_user_id' });
 ```
 
 Which is equivalent to writing:
@@ -245,15 +231,10 @@ Which is equivalent to writing:
 
 ### ObjectForeignKey
 
-You can pass a custom foreign key for the object like this:
+You can pass a custom foreign key for the object (Like a Post model) like this:
 
 ```javascript
-relation({
-  subject: 'Post',
-  relType: 'belongsTo',
-  object: 'User',
-  options: { objectForeignKey: 'author_id' },
-});
+or.belongsTo('User', { objectForeignKey: 'author_id' });
 ```
 
 Is equivalent to writing:
@@ -277,4 +258,4 @@ npm t
 
 ## Licence and credits
 
-©2022 Anephenix OÜ. Objection-relations is licenced under the MIT Licence.
+©2025 Anephenix OÜ. Objection-relations is licenced under the MIT Licence.

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -17,25 +17,27 @@
   },
   "devDependencies": {
     "@size-limit/preset-small-lib": "^7.0.8",
-    "@types/jest": "^27.4.0",
+    "@types/jest": "^29.5.14",
     "@types/lodash.snakecase": "^4.1.6",
-    "@types/pluralize": "^0.0.29",
-    "husky": "^7.0.4",
+    "@types/pluralize": "^0.0.33",
+    "husky": "^9.1.7",
     "npm-upgrade": "^3.1.0",
     "size-limit": "^7.0.8",
     "tsdx": "^0.14.1",
-    "tslib": "^1.14.1",
-    "typescript": "^4.5.5"
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.3"
   },
   "author": "Paul Jensen <paul@anephenix.com>",
   "scripts": {
-    "start": "tsdx watch --target node",
+    "analyze": "size-limit --why",
     "build": "tsdx build --target node",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
-    "prepare": "tsdx build --target node",
+    "lint": "tsdx lint --fix",
+    "prepare-patch-release": "npm run update-changelog && git add CHANGELOG.md && git commit -m \"Updated changelog\" && npm version patch",
+    "publish-patch-release": "npm run prepare-patch-release && git push origin main && git push --tags",
     "size": "size-limit",
-    "analyze": "size-limit --why"
+    "start": "tsdx watch --target node",
+    "test": "tsdx test --collectCoverage",
+    "update-changelog": "node scripts/update-changelog.js"
   },
   "husky": {
     "hooks": {

package/src/global.d.ts

@@ -0,0 +1,17 @@
+export type OptionsProps = {
+  subjectTable?: string;
+  objectTable?: string;
+  subjectForeignKey?: string;
+  objectForeignKey?: string;
+  modelPath?: string;
+};
+
+type CommonRelationOrTableOrForeignKeyProps = {
+  options?: OptionsProps;
+};
+
+type RelationTypeProps = {
+  modelClass: string;
+  from: string;
+  to: string;
+};

package/src/helpers.ts

@@ -0,0 +1,59 @@
+import snakeCase from 'lodash.snakecase';
+import pluralize from 'pluralize';
+import { join } from 'path';
+import { CommonRelationOrTableOrForeignKeyProps } from './global';
+
+// Types
+
+type SubjectProps = CommonRelationOrTableOrForeignKeyProps & {
+  subject: string;
+};
+
+type ObjectProps = CommonRelationOrTableOrForeignKeyProps & {
+  object: string;
+};
+
+type ViaProps = string | undefined;
+
+/*
+    Gets the SQL table for the subject, either from the options object or the
+    plural version of the subject model.
+*/
+export function getSubjectTable({ subject, options }: SubjectProps) {
+  return options?.subjectTable || pluralize(snakeCase(subject));
+}
+
+/*
+    Gets the SQL table for the object, either from the options object or the
+    plural version of the object model.
+*/
+export function getObjectTable({ object, options }: ObjectProps) {
+  return options?.objectTable || pluralize(snakeCase(object));
+}
+
+/*
+    Gets the SQL foreign key for the subject, either from the options object 
+    or the snake case of the subject model.
+*/
+export function getSubjectForeignKey({ subject, options }: SubjectProps) {
+  return options?.subjectForeignKey || snakeCase(subject) + '_id';
+}
+
+/*
+    Gets the SQL foreign key for the object, either from the options object 
+    or the snake case of the object model.
+*/
+export function getObjectForeignKey({ object, options }: ObjectProps) {
+  return options?.objectForeignKey || snakeCase(object) + '_id';
+}
+
+/*
+	Allows you to define the model path for a model
+*/
+export function getModelClass({ object, options }: ObjectProps) {
+  return options?.modelPath ? join(options.modelPath, object) : object;
+}
+
+export function getViaTable(via: ViaProps) {
+  return via ? pluralize(snakeCase(via)) : null;
+}

package/src/index.ts

@@ -1,172 +1,64 @@
 // Dependencies
-import { Model } from 'objection';
-const {
-	HasOneRelation,
-	BelongsToOneRelation,
-	HasManyRelation,
-	ManyToManyRelation,
-} = Model;
-import snakeCase from 'lodash.snakecase';
-import pluralize from 'pluralize';
+import { OptionsProps } from './global';
+import { relation } from './relations';
 
-type CommonRelationOrTableOrForeignKeyProps = {
-    options?: {
-        subjectTable?: string;
-        objectTable?: string;
-        subjectForeignKey?: string;
-        objectForeignKey?: string;
-    }
-}
-
-type RelationProps = CommonRelationOrTableOrForeignKeyProps & {
-    subject: string;
-    relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';
-    object: string;
-    via?: string;
-}
-
-type RelationTypeProps = {
-    modelClass: string;
-    from: string;
-    to: string;
-};
-
-type AdvancedRelationTypeProps = RelationTypeProps & {
-    through: {
-        from: string;
-        to: string;
-    };
-}
-
-type SubjectProps = CommonRelationOrTableOrForeignKeyProps & {
-    subject: string;
-}
-
-type ObjectProps = CommonRelationOrTableOrForeignKeyProps & {
-    object: string;
-}
-
-/*
-    Defines a relationship where a record in one model can belong to a record in
-    another model.
-*/
-export function belongsRelation({ modelClass, from, to }:RelationTypeProps) {
-	return {
-		relation: BelongsToOneRelation,
-		modelClass,
-		join: { from, to },
-	};
-};
-
-/*
-	Defines a relationship where a record in one model can own a record in another
-	model.
-*/
-export function hasOneRelation({ modelClass, from, to }:RelationTypeProps) {
-	return {
-		relation: HasOneRelation,
-		modelClass,
-		join: { from, to },
-	};
-};
+// Types
 
-/*
-	Defines a relationship where a record in one model can own many records in
-	another model.
-*/
-export function hasManyRelation({ modelClass, from, to }:RelationTypeProps) {
-	return {
-		relation: HasManyRelation,
-        modelClass,
-		join: { from, to },
-	};
+type ObjectionRelationProps = {
+  subject: string;
+  modelPath: string;
 };
 
-/*
-	Defines a relationship where a record in one model can own many records in
-	another model, via a join table
-*/
-export function hasManyThroughRelation({ modelClass, from, through, to }:AdvancedRelationTypeProps) {
-	return {
-		relation: ManyToManyRelation,
-        modelClass,
-		join: { from, through, to },
-	};
-};
+export class ObjectionRelation {
+  subject: string;
+  modelPath: string;
+  constructor({ subject, modelPath }: ObjectionRelationProps) {
+    this.subject = subject;
+    this.modelPath = modelPath;
+  }
 
-/*
-    Gets the SQL table for the subject, either from the options object or the
-    plural version of the subject model.
-*/
-export function getSubjectTable({ subject, options }:SubjectProps) {
-    return options?.subjectTable || pluralize(snakeCase(subject));
-}
+  belongsTo(object: string, options?: OptionsProps) {
+    if (!options) options = { modelPath: this.modelPath };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'belongsTo',
+      object,
+      options,
+    });
+  }
 
-/*
-    Gets the SQL table for the object, either from the options object or the
-    plural version of the object model.
-*/
-export function getObjectTable({ object, options }:ObjectProps) { 
-    return options?.objectTable || pluralize(snakeCase(object));
-}
+  hasOne(object: string, options?: OptionsProps) {
+    if (!options) options = { modelPath: this.modelPath };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'hasOne',
+      object,
+      options,
+    });
+  }
 
-/*
-    Gets the SQL foreign key for the subject, either from the options object 
-    or the snake case of the subject model.
-*/
-export function getSubjectForeignKey({ subject, options }:SubjectProps) {
-    return options?.subjectForeignKey || snakeCase(subject) + '_id';
-}
+  hasMany(object: string, options?: OptionsProps) {
+    if (!options) options = { modelPath: this.modelPath };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'hasMany',
+      object,
+      options,
+    });
+  }
 
-/*
-    Gets the SQL foreign key for the object, either from the options object 
-    or the snake case of the object model.
-*/
-export function getObjectForeignKey({ object, options }:ObjectProps) {
-    return options?.objectForeignKey || snakeCase(object) + '_id';
+  hasManyThrough(object: string, via: string, options?: OptionsProps) {
+    if (!options) options = { modelPath: this.modelPath };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'hasManyThrough',
+      object,
+      via,
+      options,
+    });
+  }
 }
-
-/*
-	Defines a relationship by passing the subject, the predicate, and the object,
-	along with an optional via model.
-*/
-export function relation({subject, relType, object, via, options}:RelationProps) {
-	const subjectTable = getSubjectTable({subject, options});
-	const objectTable = getObjectTable({object, options});
-	const subjectForeignKey = getSubjectForeignKey({subject, options});
-	const objectForeignKey = getObjectForeignKey({object, options});
-	let viaTable;
-	if (via) viaTable = pluralize(snakeCase(via));
-	switch (relType) {
-		case 'hasOne':
-			return hasOneRelation({
-                modelClass: object,
-				from: `${subjectTable}.id`,
-				to: `${objectTable}.${subjectForeignKey}`
-            });
-		case 'hasMany':
-			return hasManyRelation({
-				modelClass: object,
-				from: `${subjectTable}.id`,
-				to: `${objectTable}.${subjectForeignKey}`
-			});
-		case 'hasManyThrough':
-			return hasManyThroughRelation({
-				modelClass: object,
-				from: `${subjectTable}.id`,
-				through: {
-					from: `${viaTable}.${subjectForeignKey}`,
-					to: `${viaTable}.${objectForeignKey}`,
-				},
-				to: `${objectTable}.id`
-            });
-		case 'belongsTo':
-			return belongsRelation({
-				modelClass: object,
-				from: `${subjectTable}.${objectForeignKey}`,
-				to: `${objectTable}.id`
-            });
-		default:
-			throw new Error('No valid relationship type specified');
-	}
-};

package/src/relations.ts

@@ -0,0 +1,141 @@
+// Dependencies
+import { Model } from 'objection';
+import {
+  RelationTypeProps,
+  CommonRelationOrTableOrForeignKeyProps,
+} from './global';
+import {
+  getSubjectTable,
+  getSubjectForeignKey,
+  getObjectTable,
+  getObjectForeignKey,
+  getModelClass,
+  getViaTable,
+} from './helpers';
+
+const {
+  HasOneRelation,
+  BelongsToOneRelation,
+  HasManyRelation,
+  ManyToManyRelation,
+} = Model;
+
+// Types
+
+type AdvancedRelationTypeProps = RelationTypeProps & {
+  through: {
+    from: string;
+    to: string;
+  };
+};
+
+/*
+    Defines a relationship where a record in one model can belong to a record in
+    another model.
+*/
+export function belongsRelation({ modelClass, from, to }: RelationTypeProps) {
+  return {
+    relation: BelongsToOneRelation,
+    modelClass,
+    join: { from, to },
+  };
+}
+
+/*
+	Defines a relationship where a record in one model can own a record in another
+	model.
+*/
+export function hasOneRelation({ modelClass, from, to }: RelationTypeProps) {
+  return {
+    relation: HasOneRelation,
+    modelClass,
+    join: { from, to },
+  };
+}
+
+/*
+	Defines a relationship where a record in one model can own many records in
+	another model.
+*/
+export function hasManyRelation({ modelClass, from, to }: RelationTypeProps) {
+  return {
+    relation: HasManyRelation,
+    modelClass,
+    join: { from, to },
+  };
+}
+
+/*
+	Defines a relationship where a record in one model can own many records in
+	another model, via a join table
+*/
+export function hasManyThroughRelation({
+  modelClass,
+  from,
+  through,
+  to,
+}: AdvancedRelationTypeProps) {
+  return {
+    relation: ManyToManyRelation,
+    modelClass,
+    join: { from, through, to },
+  };
+}
+
+type RelationProps = CommonRelationOrTableOrForeignKeyProps & {
+  subject: string;
+  relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';
+  object: string;
+  via?: string;
+};
+
+/*
+	Defines a relationship by passing the subject, the predicate, and the object,
+	along with an optional via model.
+*/
+export function relation({
+  subject,
+  relType,
+  object,
+  via,
+  options,
+}: RelationProps) {
+  const subjectTable = getSubjectTable({ subject, options });
+  const objectTable = getObjectTable({ object, options });
+  const subjectForeignKey = getSubjectForeignKey({ subject, options });
+  const objectForeignKey = getObjectForeignKey({ object, options });
+  const modelClass = getModelClass({ object, options });
+  const viaTable = getViaTable(via);
+  switch (relType) {
+    case 'hasOne':
+      return hasOneRelation({
+        modelClass,
+        from: `${subjectTable}.id`,
+        to: `${objectTable}.${subjectForeignKey}`,
+      });
+    case 'hasMany':
+      return hasManyRelation({
+        modelClass,
+        from: `${subjectTable}.id`,
+        to: `${objectTable}.${subjectForeignKey}`,
+      });
+    case 'hasManyThrough':
+      return hasManyThroughRelation({
+        modelClass,
+        from: `${subjectTable}.id`,
+        through: {
+          from: `${viaTable}.${subjectForeignKey}`,
+          to: `${viaTable}.${objectForeignKey}`,
+        },
+        to: `${objectTable}.id`,
+      });
+    case 'belongsTo':
+      return belongsRelation({
+        modelClass,
+        from: `${subjectTable}.${objectForeignKey}`,
+        to: `${objectTable}.id`,
+      });
+    default:
+      throw new Error('No valid relationship type specified');
+  }
+}

package/dist/index.d.ts

@@ -1,80 +0,0 @@
-declare type CommonRelationOrTableOrForeignKeyProps = {
-    options?: {
-        subjectTable?: string;
-        objectTable?: string;
-        subjectForeignKey?: string;
-        objectForeignKey?: string;
-    };
-};
-declare type RelationProps = CommonRelationOrTableOrForeignKeyProps & {
-    subject: string;
-    relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';
-    object: string;
-    via?: string;
-};
-declare type RelationTypeProps = {
-    modelClass: string;
-    from: string;
-    to: string;
-};
-declare type AdvancedRelationTypeProps = RelationTypeProps & {
-    through: {
-        from: string;
-        to: string;
-    };
-};
-declare type SubjectProps = CommonRelationOrTableOrForeignKeyProps & {
-    subject: string;
-};
-declare type ObjectProps = CommonRelationOrTableOrForeignKeyProps & {
-    object: string;
-};
-export declare function belongsRelation({ modelClass, from, to }: RelationTypeProps): {
-    relation: import("objection").RelationType;
-    modelClass: string;
-    join: {
-        from: string;
-        to: string;
-    };
-};
-export declare function hasOneRelation({ modelClass, from, to }: RelationTypeProps): {
-    relation: import("objection").RelationType;
-    modelClass: string;
-    join: {
-        from: string;
-        to: string;
-    };
-};
-export declare function hasManyRelation({ modelClass, from, to }: RelationTypeProps): {
-    relation: import("objection").RelationType;
-    modelClass: string;
-    join: {
-        from: string;
-        to: string;
-    };
-};
-export declare function hasManyThroughRelation({ modelClass, from, through, to }: AdvancedRelationTypeProps): {
-    relation: import("objection").RelationType;
-    modelClass: string;
-    join: {
-        from: string;
-        through: {
-            from: string;
-            to: string;
-        };
-        to: string;
-    };
-};
-export declare function getSubjectTable({ subject, options }: SubjectProps): string;
-export declare function getObjectTable({ object, options }: ObjectProps): string;
-export declare function getSubjectForeignKey({ subject, options }: SubjectProps): string;
-export declare function getObjectForeignKey({ object, options }: ObjectProps): string;
-export declare function relation({ subject, relType, object, via, options }: RelationProps): {
-    relation: import("objection").RelationType;
-    modelClass: string;
-    join: {
-        from: string;
-        to: string;
-    };
-};
-export {};

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./objection-relations.cjs.production.min.js')
-} else {
-  module.exports = require('./objection-relations.cjs.development.js')
-}

package/dist/objection-relations.cjs.development.js

@@ -1,218 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var objection = require('objection');
-var snakeCase = _interopDefault(require('lodash.snakecase'));
-var pluralize = _interopDefault(require('pluralize'));
-
-// Dependencies
-const {
-  HasOneRelation,
-  BelongsToOneRelation,
-  HasManyRelation,
-  ManyToManyRelation
-} = objection.Model;
-/*
-    Defines a relationship where a record in one model can belong to a record in
-    another model.
-*/
-
-function belongsRelation({
-  modelClass,
-  from,
-  to
-}) {
-  return {
-    relation: BelongsToOneRelation,
-    modelClass,
-    join: {
-      from,
-      to
-    }
-  };
-}
-/*
-    Defines a relationship where a record in one model can own a record in another
-    model.
-*/
-
-function hasOneRelation({
-  modelClass,
-  from,
-  to
-}) {
-  return {
-    relation: HasOneRelation,
-    modelClass,
-    join: {
-      from,
-      to
-    }
-  };
-}
-/*
-    Defines a relationship where a record in one model can own many records in
-    another model.
-*/
-
-function hasManyRelation({
-  modelClass,
-  from,
-  to
-}) {
-  return {
-    relation: HasManyRelation,
-    modelClass,
-    join: {
-      from,
-      to
-    }
-  };
-}
-/*
-    Defines a relationship where a record in one model can own many records in
-    another model, via a join table
-*/
-
-function hasManyThroughRelation({
-  modelClass,
-  from,
-  through,
-  to
-}) {
-  return {
-    relation: ManyToManyRelation,
-    modelClass,
-    join: {
-      from,
-      through,
-      to
-    }
-  };
-}
-/*
-    Gets the SQL table for the subject, either from the options object or the
-    plural version of the subject model.
-*/
-
-function getSubjectTable({
-  subject,
-  options
-}) {
-  return (options == null ? void 0 : options.subjectTable) || pluralize(snakeCase(subject));
-}
-/*
-    Gets the SQL table for the object, either from the options object or the
-    plural version of the object model.
-*/
-
-function getObjectTable({
-  object,
-  options
-}) {
-  return (options == null ? void 0 : options.objectTable) || pluralize(snakeCase(object));
-}
-/*
-    Gets the SQL foreign key for the subject, either from the options object
-    or the snake case of the subject model.
-*/
-
-function getSubjectForeignKey({
-  subject,
-  options
-}) {
-  return (options == null ? void 0 : options.subjectForeignKey) || snakeCase(subject) + '_id';
-}
-/*
-    Gets the SQL foreign key for the object, either from the options object
-    or the snake case of the object model.
-*/
-
-function getObjectForeignKey({
-  object,
-  options
-}) {
-  return (options == null ? void 0 : options.objectForeignKey) || snakeCase(object) + '_id';
-}
-/*
-    Defines a relationship by passing the subject, the predicate, and the object,
-    along with an optional via model.
-*/
-
-function relation({
-  subject,
-  relType,
-  object,
-  via,
-  options
-}) {
-  const subjectTable = getSubjectTable({
-    subject,
-    options
-  });
-  const objectTable = getObjectTable({
-    object,
-    options
-  });
-  const subjectForeignKey = getSubjectForeignKey({
-    subject,
-    options
-  });
-  const objectForeignKey = getObjectForeignKey({
-    object,
-    options
-  });
-  let viaTable;
-  if (via) viaTable = pluralize(snakeCase(via));
-
-  switch (relType) {
-    case 'hasOne':
-      return hasOneRelation({
-        modelClass: object,
-        from: `${subjectTable}.id`,
-        to: `${objectTable}.${subjectForeignKey}`
-      });
-
-    case 'hasMany':
-      return hasManyRelation({
-        modelClass: object,
-        from: `${subjectTable}.id`,
-        to: `${objectTable}.${subjectForeignKey}`
-      });
-
-    case 'hasManyThrough':
-      return hasManyThroughRelation({
-        modelClass: object,
-        from: `${subjectTable}.id`,
-        through: {
-          from: `${viaTable}.${subjectForeignKey}`,
-          to: `${viaTable}.${objectForeignKey}`
-        },
-        to: `${objectTable}.id`
-      });
-
-    case 'belongsTo':
-      return belongsRelation({
-        modelClass: object,
-        from: `${subjectTable}.${objectForeignKey}`,
-        to: `${objectTable}.id`
-      });
-
-    default:
-      throw new Error('No valid relationship type specified');
-  }
-}
-
-exports.belongsRelation = belongsRelation;
-exports.getObjectForeignKey = getObjectForeignKey;
-exports.getObjectTable = getObjectTable;
-exports.getSubjectForeignKey = getSubjectForeignKey;
-exports.getSubjectTable = getSubjectTable;
-exports.hasManyRelation = hasManyRelation;
-exports.hasManyThroughRelation = hasManyThroughRelation;
-exports.hasOneRelation = hasOneRelation;
-exports.relation = relation;
-//# sourceMappingURL=objection-relations.cjs.development.js.map

package/dist/objection-relations.cjs.development.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objection-relations.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["// Dependencies\nimport { Model } from 'objection';\nconst {\n\tHasOneRelation,\n\tBelongsToOneRelation,\n\tHasManyRelation,\n\tManyToManyRelation,\n} = Model;\nimport snakeCase from 'lodash.snakecase';\nimport pluralize from 'pluralize';\n\ntype CommonRelationOrTableOrForeignKeyProps = {\n    options?: {\n        subjectTable?: string;\n        objectTable?: string;\n        subjectForeignKey?: string;\n        objectForeignKey?: string;\n    }\n}\n\ntype RelationProps = CommonRelationOrTableOrForeignKeyProps & {\n    subject: string;\n    relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';\n    object: string;\n    via?: string;\n}\n\ntype RelationTypeProps = {\n    modelClass: string;\n    from: string;\n    to: string;\n};\n\ntype AdvancedRelationTypeProps = RelationTypeProps & {\n    through: {\n        from: string;\n        to: string;\n    };\n}\n\ntype SubjectProps = CommonRelationOrTableOrForeignKeyProps & {\n    subject: string;\n}\n\ntype ObjectProps = CommonRelationOrTableOrForeignKeyProps & {\n    object: string;\n}\n\n/*\n    Defines a relationship where a record in one model can belong to a record in\n    another model.\n*/\nexport function belongsRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: BelongsToOneRelation,\n\t\tmodelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own a record in another\n\tmodel.\n*/\nexport function hasOneRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: HasOneRelation,\n\t\tmodelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own many records in\n\tanother model.\n*/\nexport function hasManyRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: HasManyRelation,\n        modelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own many records in\n\tanother model, via a join table\n*/\nexport function hasManyThroughRelation({ modelClass, from, through, to }:AdvancedRelationTypeProps) {\n\treturn {\n\t\trelation: ManyToManyRelation,\n        modelClass,\n\t\tjoin: { from, through, to },\n\t};\n};\n\n/*\n    Gets the SQL table for the subject, either from the options object or the\n    plural version of the subject model.\n*/\nexport function getSubjectTable({ subject, options }:SubjectProps) {\n    return options?.subjectTable || pluralize(snakeCase(subject));\n}\n\n/*\n    Gets the SQL table for the object, either from the options object or the\n    plural version of the object model.\n*/\nexport function getObjectTable({ object, options }:ObjectProps) { \n    return options?.objectTable || pluralize(snakeCase(object));\n}\n\n/*\n    Gets the SQL foreign key for the subject, either from the options object \n    or the snake case of the subject model.\n*/\nexport function getSubjectForeignKey({ subject, options }:SubjectProps) {\n    return options?.subjectForeignKey || snakeCase(subject) + '_id';\n}\n\n/*\n    Gets the SQL foreign key for the object, either from the options object \n    or the snake case of the object model.\n*/\nexport function getObjectForeignKey({ object, options }:ObjectProps) {\n    return options?.objectForeignKey || snakeCase(object) + '_id';\n}\n\n/*\n\tDefines a relationship by passing the subject, the predicate, and the object,\n\talong with an optional via model.\n*/\nexport function relation({subject, relType, object, via, options}:RelationProps) {\n\tconst subjectTable = getSubjectTable({subject, options});\n\tconst objectTable = getObjectTable({object, options});\n\tconst subjectForeignKey = getSubjectForeignKey({subject, options});\n\tconst objectForeignKey = getObjectForeignKey({object, options});\n\tlet viaTable;\n\tif (via) viaTable = pluralize(snakeCase(via));\n\tswitch (relType) {\n\t\tcase 'hasOne':\n\t\t\treturn hasOneRelation({\n                modelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tto: `${objectTable}.${subjectForeignKey}`\n            });\n\t\tcase 'hasMany':\n\t\t\treturn hasManyRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tto: `${objectTable}.${subjectForeignKey}`\n\t\t\t});\n\t\tcase 'hasManyThrough':\n\t\t\treturn hasManyThroughRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tthrough: {\n\t\t\t\t\tfrom: `${viaTable}.${subjectForeignKey}`,\n\t\t\t\t\tto: `${viaTable}.${objectForeignKey}`,\n\t\t\t\t},\n\t\t\t\tto: `${objectTable}.id`\n            });\n\t\tcase 'belongsTo':\n\t\t\treturn belongsRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.${objectForeignKey}`,\n\t\t\t\tto: `${objectTable}.id`\n            });\n\t\tdefault:\n\t\t\tthrow new Error('No valid relationship type specified');\n\t}\n};"],"names":["HasOneRelation","BelongsToOneRelation","HasManyRelation","ManyToManyRelation","Model","belongsRelation","modelClass","from","to","relation","join","hasOneRelation","hasManyRelation","hasManyThroughRelation","through","getSubjectTable","subject","options","subjectTable","pluralize","snakeCase","getObjectTable","object","objectTable","getSubjectForeignKey","subjectForeignKey","getObjectForeignKey","objectForeignKey","relType","via","viaTable","Error"],"mappings":"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"}

package/dist/objection-relations.cjs.production.min.js

@@ -1,2 +0,0 @@
-"use strict";function o(o){return o&&"object"==typeof o&&"default"in o?o.default:o}Object.defineProperty(exports,"__esModule",{value:!0});var e=require("objection"),t=o(require("lodash.snakecase")),n=o(require("pluralize"));const{HasOneRelation:r,BelongsToOneRelation:s,HasManyRelation:i,ManyToManyRelation:l}=e.Model;function a({modelClass:o,from:e,to:t}){return{relation:s,modelClass:o,join:{from:e,to:t}}}function u({modelClass:o,from:e,to:t}){return{relation:r,modelClass:o,join:{from:e,to:t}}}function c({modelClass:o,from:e,to:t}){return{relation:i,modelClass:o,join:{from:e,to:t}}}function d({modelClass:o,from:e,through:t,to:n}){return{relation:l,modelClass:o,join:{from:e,through:t,to:n}}}function f({subject:o,options:e}){return(null==e?void 0:e.subjectTable)||n(t(o))}function b({object:o,options:e}){return(null==e?void 0:e.objectTable)||n(t(o))}function p({subject:o,options:e}){return(null==e?void 0:e.subjectForeignKey)||t(o)+"_id"}function j({object:o,options:e}){return(null==e?void 0:e.objectForeignKey)||t(o)+"_id"}exports.belongsRelation=a,exports.getObjectForeignKey=j,exports.getObjectTable=b,exports.getSubjectForeignKey=p,exports.getSubjectTable=f,exports.hasManyRelation=c,exports.hasManyThroughRelation=d,exports.hasOneRelation=u,exports.relation=function({subject:o,relType:e,object:r,via:s,options:i}){const l=f({subject:o,options:i}),m=b({object:r,options:i}),h=p({subject:o,options:i}),g=j({object:r,options:i});let y;switch(s&&(y=n(t(s))),e){case"hasOne":return u({modelClass:r,from:l+".id",to:`${m}.${h}`});case"hasMany":return c({modelClass:r,from:l+".id",to:`${m}.${h}`});case"hasManyThrough":return d({modelClass:r,from:l+".id",through:{from:`${y}.${h}`,to:`${y}.${g}`},to:m+".id"});case"belongsTo":return a({modelClass:r,from:`${l}.${g}`,to:m+".id"});default:throw new Error("No valid relationship type specified")}};
-//# sourceMappingURL=objection-relations.cjs.production.min.js.map

package/dist/objection-relations.cjs.production.min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objection-relations.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["// Dependencies\nimport { Model } from 'objection';\nconst {\n\tHasOneRelation,\n\tBelongsToOneRelation,\n\tHasManyRelation,\n\tManyToManyRelation,\n} = Model;\nimport snakeCase from 'lodash.snakecase';\nimport pluralize from 'pluralize';\n\ntype CommonRelationOrTableOrForeignKeyProps = {\n    options?: {\n        subjectTable?: string;\n        objectTable?: string;\n        subjectForeignKey?: string;\n        objectForeignKey?: string;\n    }\n}\n\ntype RelationProps = CommonRelationOrTableOrForeignKeyProps & {\n    subject: string;\n    relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';\n    object: string;\n    via?: string;\n}\n\ntype RelationTypeProps = {\n    modelClass: string;\n    from: string;\n    to: string;\n};\n\ntype AdvancedRelationTypeProps = RelationTypeProps & {\n    through: {\n        from: string;\n        to: string;\n    };\n}\n\ntype SubjectProps = CommonRelationOrTableOrForeignKeyProps & {\n    subject: string;\n}\n\ntype ObjectProps = CommonRelationOrTableOrForeignKeyProps & {\n    object: string;\n}\n\n/*\n    Defines a relationship where a record in one model can belong to a record in\n    another model.\n*/\nexport function belongsRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: BelongsToOneRelation,\n\t\tmodelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own a record in another\n\tmodel.\n*/\nexport function hasOneRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: HasOneRelation,\n\t\tmodelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own many records in\n\tanother model.\n*/\nexport function hasManyRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: HasManyRelation,\n        modelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own many records in\n\tanother model, via a join table\n*/\nexport function hasManyThroughRelation({ modelClass, from, through, to }:AdvancedRelationTypeProps) {\n\treturn {\n\t\trelation: ManyToManyRelation,\n        modelClass,\n\t\tjoin: { from, through, to },\n\t};\n};\n\n/*\n    Gets the SQL table for the subject, either from the options object or the\n    plural version of the subject model.\n*/\nexport function getSubjectTable({ subject, options }:SubjectProps) {\n    return options?.subjectTable || pluralize(snakeCase(subject));\n}\n\n/*\n    Gets the SQL table for the object, either from the options object or the\n    plural version of the object model.\n*/\nexport function getObjectTable({ object, options }:ObjectProps) { \n    return options?.objectTable || pluralize(snakeCase(object));\n}\n\n/*\n    Gets the SQL foreign key for the subject, either from the options object \n    or the snake case of the subject model.\n*/\nexport function getSubjectForeignKey({ subject, options }:SubjectProps) {\n    return options?.subjectForeignKey || snakeCase(subject) + '_id';\n}\n\n/*\n    Gets the SQL foreign key for the object, either from the options object \n    or the snake case of the object model.\n*/\nexport function getObjectForeignKey({ object, options }:ObjectProps) {\n    return options?.objectForeignKey || snakeCase(object) + '_id';\n}\n\n/*\n\tDefines a relationship by passing the subject, the predicate, and the object,\n\talong with an optional via model.\n*/\nexport function relation({subject, relType, object, via, options}:RelationProps) {\n\tconst subjectTable = getSubjectTable({subject, options});\n\tconst objectTable = getObjectTable({object, options});\n\tconst subjectForeignKey = getSubjectForeignKey({subject, options});\n\tconst objectForeignKey = getObjectForeignKey({object, options});\n\tlet viaTable;\n\tif (via) viaTable = pluralize(snakeCase(via));\n\tswitch (relType) {\n\t\tcase 'hasOne':\n\t\t\treturn hasOneRelation({\n                modelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tto: `${objectTable}.${subjectForeignKey}`\n            });\n\t\tcase 'hasMany':\n\t\t\treturn hasManyRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tto: `${objectTable}.${subjectForeignKey}`\n\t\t\t});\n\t\tcase 'hasManyThrough':\n\t\t\treturn hasManyThroughRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tthrough: {\n\t\t\t\t\tfrom: `${viaTable}.${subjectForeignKey}`,\n\t\t\t\t\tto: `${viaTable}.${objectForeignKey}`,\n\t\t\t\t},\n\t\t\t\tto: `${objectTable}.id`\n            });\n\t\tcase 'belongsTo':\n\t\t\treturn belongsRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.${objectForeignKey}`,\n\t\t\t\tto: `${objectTable}.id`\n            });\n\t\tdefault:\n\t\t\tthrow new Error('No valid relationship type specified');\n\t}\n};"],"names":["HasOneRelation","BelongsToOneRelation","HasManyRelation","ManyToManyRelation","Model","belongsRelation","modelClass","from","to","relation","join","hasOneRelation","hasManyRelation","hasManyThroughRelation","through","getSubjectTable","subject","options","subjectTable","pluralize","snakeCase","getObjectTable","object","objectTable","getSubjectForeignKey","subjectForeignKey","getObjectForeignKey","objectForeignKey","relType","via","viaTable","Error"],"mappings":"gOAEA,MAAMA,eACLA,EADKC,qBAELA,EAFKC,gBAGLA,EAHKC,mBAILA,GACGC,iBA6CYC,GAAgBC,WAAEA,EAAFC,KAAcA,EAAdC,GAAoBA,UAC5C,CACNC,SAAUR,EACVK,WAAAA,EACAI,KAAM,CAAEH,KAAAA,EAAMC,GAAAA,aAQAG,GAAeL,WAAEA,EAAFC,KAAcA,EAAdC,GAAoBA,UAC3C,CACNC,SAAUT,EACVM,WAAAA,EACAI,KAAM,CAAEH,KAAAA,EAAMC,GAAAA,aAQAI,GAAgBN,WAAEA,EAAFC,KAAcA,EAAdC,GAAoBA,UAC5C,CACNC,SAAUP,EACJI,WAAAA,EACNI,KAAM,CAAEH,KAAAA,EAAMC,GAAAA,aAQAK,GAAuBP,WAAEA,EAAFC,KAAcA,EAAdO,QAAoBA,EAApBN,GAA6BA,UAC5D,CACNC,SAAUN,EACJG,WAAAA,EACNI,KAAM,CAAEH,KAAAA,EAAMO,QAAAA,EAASN,GAAAA,aAQTO,GAAgBC,QAAEA,EAAFC,QAAWA,iBAChCA,SAAAA,EAASC,eAAgBC,EAAUC,EAAUJ,aAOxCK,GAAeC,OAAEA,EAAFL,QAAUA,iBAC9BA,SAAAA,EAASM,cAAeJ,EAAUC,EAAUE,aAOvCE,GAAqBR,QAAEA,EAAFC,QAAWA,iBACrCA,SAAAA,EAASQ,oBAAqBL,EAAUJ,GAAW,eAO9CU,GAAoBJ,OAAEA,EAAFL,QAAUA,iBACnCA,SAAAA,EAASU,mBAAoBP,EAAUE,GAAU,+PAOnCN,QAACA,EAADY,QAAUA,EAAVN,OAAmBA,EAAnBO,IAA2BA,EAA3BZ,QAAgCA,UAClDC,EAAeH,EAAgB,CAACC,QAAAA,EAASC,QAAAA,IACzCM,EAAcF,EAAe,CAACC,OAAAA,EAAQL,QAAAA,IACtCQ,EAAoBD,EAAqB,CAACR,QAAAA,EAASC,QAAAA,IACnDU,EAAmBD,EAAoB,CAACJ,OAAAA,EAAQL,QAAAA,QAClDa,SACAD,IAAKC,EAAWX,EAAUC,EAAUS,KAChCD,OACF,gBACGjB,EAAe,CACTL,WAAYgB,EACxBf,KAASW,QACTV,MAAOe,KAAeE,UAEnB,iBACGb,EAAgB,CACtBN,WAAYgB,EACZf,KAASW,QACTV,MAAOe,KAAeE,UAEnB,wBACGZ,EAAuB,CAC7BP,WAAYgB,EACZf,KAASW,QACTJ,QAAS,CACRP,QAASuB,KAAYL,IACrBjB,MAAOsB,KAAYH,KAEpBnB,GAAOe,cAEJ,mBACGlB,EAAgB,CACtBC,WAAYgB,EACZf,QAASW,KAAgBS,IACzBnB,GAAOe,wBAGF,IAAIQ,MAAM"}

package/dist/objection-relations.esm.js

@@ -1,204 +0,0 @@
-import { Model } from 'objection';
-import snakeCase from 'lodash.snakecase';
-import pluralize from 'pluralize';
-
-// Dependencies
-const {
-  HasOneRelation,
-  BelongsToOneRelation,
-  HasManyRelation,
-  ManyToManyRelation
-} = Model;
-/*
-    Defines a relationship where a record in one model can belong to a record in
-    another model.
-*/
-
-function belongsRelation({
-  modelClass,
-  from,
-  to
-}) {
-  return {
-    relation: BelongsToOneRelation,
-    modelClass,
-    join: {
-      from,
-      to
-    }
-  };
-}
-/*
-    Defines a relationship where a record in one model can own a record in another
-    model.
-*/
-
-function hasOneRelation({
-  modelClass,
-  from,
-  to
-}) {
-  return {
-    relation: HasOneRelation,
-    modelClass,
-    join: {
-      from,
-      to
-    }
-  };
-}
-/*
-    Defines a relationship where a record in one model can own many records in
-    another model.
-*/
-
-function hasManyRelation({
-  modelClass,
-  from,
-  to
-}) {
-  return {
-    relation: HasManyRelation,
-    modelClass,
-    join: {
-      from,
-      to
-    }
-  };
-}
-/*
-    Defines a relationship where a record in one model can own many records in
-    another model, via a join table
-*/
-
-function hasManyThroughRelation({
-  modelClass,
-  from,
-  through,
-  to
-}) {
-  return {
-    relation: ManyToManyRelation,
-    modelClass,
-    join: {
-      from,
-      through,
-      to
-    }
-  };
-}
-/*
-    Gets the SQL table for the subject, either from the options object or the
-    plural version of the subject model.
-*/
-
-function getSubjectTable({
-  subject,
-  options
-}) {
-  return (options == null ? void 0 : options.subjectTable) || pluralize(snakeCase(subject));
-}
-/*
-    Gets the SQL table for the object, either from the options object or the
-    plural version of the object model.
-*/
-
-function getObjectTable({
-  object,
-  options
-}) {
-  return (options == null ? void 0 : options.objectTable) || pluralize(snakeCase(object));
-}
-/*
-    Gets the SQL foreign key for the subject, either from the options object
-    or the snake case of the subject model.
-*/
-
-function getSubjectForeignKey({
-  subject,
-  options
-}) {
-  return (options == null ? void 0 : options.subjectForeignKey) || snakeCase(subject) + '_id';
-}
-/*
-    Gets the SQL foreign key for the object, either from the options object
-    or the snake case of the object model.
-*/
-
-function getObjectForeignKey({
-  object,
-  options
-}) {
-  return (options == null ? void 0 : options.objectForeignKey) || snakeCase(object) + '_id';
-}
-/*
-    Defines a relationship by passing the subject, the predicate, and the object,
-    along with an optional via model.
-*/
-
-function relation({
-  subject,
-  relType,
-  object,
-  via,
-  options
-}) {
-  const subjectTable = getSubjectTable({
-    subject,
-    options
-  });
-  const objectTable = getObjectTable({
-    object,
-    options
-  });
-  const subjectForeignKey = getSubjectForeignKey({
-    subject,
-    options
-  });
-  const objectForeignKey = getObjectForeignKey({
-    object,
-    options
-  });
-  let viaTable;
-  if (via) viaTable = pluralize(snakeCase(via));
-
-  switch (relType) {
-    case 'hasOne':
-      return hasOneRelation({
-        modelClass: object,
-        from: `${subjectTable}.id`,
-        to: `${objectTable}.${subjectForeignKey}`
-      });
-
-    case 'hasMany':
-      return hasManyRelation({
-        modelClass: object,
-        from: `${subjectTable}.id`,
-        to: `${objectTable}.${subjectForeignKey}`
-      });
-
-    case 'hasManyThrough':
-      return hasManyThroughRelation({
-        modelClass: object,
-        from: `${subjectTable}.id`,
-        through: {
-          from: `${viaTable}.${subjectForeignKey}`,
-          to: `${viaTable}.${objectForeignKey}`
-        },
-        to: `${objectTable}.id`
-      });
-
-    case 'belongsTo':
-      return belongsRelation({
-        modelClass: object,
-        from: `${subjectTable}.${objectForeignKey}`,
-        to: `${objectTable}.id`
-      });
-
-    default:
-      throw new Error('No valid relationship type specified');
-  }
-}
-
-export { belongsRelation, getObjectForeignKey, getObjectTable, getSubjectForeignKey, getSubjectTable, hasManyRelation, hasManyThroughRelation, hasOneRelation, relation };
-//# sourceMappingURL=objection-relations.esm.js.map

package/dist/objection-relations.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objection-relations.esm.js","sources":["../src/index.ts"],"sourcesContent":["// Dependencies\nimport { Model } from 'objection';\nconst {\n\tHasOneRelation,\n\tBelongsToOneRelation,\n\tHasManyRelation,\n\tManyToManyRelation,\n} = Model;\nimport snakeCase from 'lodash.snakecase';\nimport pluralize from 'pluralize';\n\ntype CommonRelationOrTableOrForeignKeyProps = {\n    options?: {\n        subjectTable?: string;\n        objectTable?: string;\n        subjectForeignKey?: string;\n        objectForeignKey?: string;\n    }\n}\n\ntype RelationProps = CommonRelationOrTableOrForeignKeyProps & {\n    subject: string;\n    relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';\n    object: string;\n    via?: string;\n}\n\ntype RelationTypeProps = {\n    modelClass: string;\n    from: string;\n    to: string;\n};\n\ntype AdvancedRelationTypeProps = RelationTypeProps & {\n    through: {\n        from: string;\n        to: string;\n    };\n}\n\ntype SubjectProps = CommonRelationOrTableOrForeignKeyProps & {\n    subject: string;\n}\n\ntype ObjectProps = CommonRelationOrTableOrForeignKeyProps & {\n    object: string;\n}\n\n/*\n    Defines a relationship where a record in one model can belong to a record in\n    another model.\n*/\nexport function belongsRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: BelongsToOneRelation,\n\t\tmodelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own a record in another\n\tmodel.\n*/\nexport function hasOneRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: HasOneRelation,\n\t\tmodelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own many records in\n\tanother model.\n*/\nexport function hasManyRelation({ modelClass, from, to }:RelationTypeProps) {\n\treturn {\n\t\trelation: HasManyRelation,\n        modelClass,\n\t\tjoin: { from, to },\n\t};\n};\n\n/*\n\tDefines a relationship where a record in one model can own many records in\n\tanother model, via a join table\n*/\nexport function hasManyThroughRelation({ modelClass, from, through, to }:AdvancedRelationTypeProps) {\n\treturn {\n\t\trelation: ManyToManyRelation,\n        modelClass,\n\t\tjoin: { from, through, to },\n\t};\n};\n\n/*\n    Gets the SQL table for the subject, either from the options object or the\n    plural version of the subject model.\n*/\nexport function getSubjectTable({ subject, options }:SubjectProps) {\n    return options?.subjectTable || pluralize(snakeCase(subject));\n}\n\n/*\n    Gets the SQL table for the object, either from the options object or the\n    plural version of the object model.\n*/\nexport function getObjectTable({ object, options }:ObjectProps) { \n    return options?.objectTable || pluralize(snakeCase(object));\n}\n\n/*\n    Gets the SQL foreign key for the subject, either from the options object \n    or the snake case of the subject model.\n*/\nexport function getSubjectForeignKey({ subject, options }:SubjectProps) {\n    return options?.subjectForeignKey || snakeCase(subject) + '_id';\n}\n\n/*\n    Gets the SQL foreign key for the object, either from the options object \n    or the snake case of the object model.\n*/\nexport function getObjectForeignKey({ object, options }:ObjectProps) {\n    return options?.objectForeignKey || snakeCase(object) + '_id';\n}\n\n/*\n\tDefines a relationship by passing the subject, the predicate, and the object,\n\talong with an optional via model.\n*/\nexport function relation({subject, relType, object, via, options}:RelationProps) {\n\tconst subjectTable = getSubjectTable({subject, options});\n\tconst objectTable = getObjectTable({object, options});\n\tconst subjectForeignKey = getSubjectForeignKey({subject, options});\n\tconst objectForeignKey = getObjectForeignKey({object, options});\n\tlet viaTable;\n\tif (via) viaTable = pluralize(snakeCase(via));\n\tswitch (relType) {\n\t\tcase 'hasOne':\n\t\t\treturn hasOneRelation({\n                modelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tto: `${objectTable}.${subjectForeignKey}`\n            });\n\t\tcase 'hasMany':\n\t\t\treturn hasManyRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tto: `${objectTable}.${subjectForeignKey}`\n\t\t\t});\n\t\tcase 'hasManyThrough':\n\t\t\treturn hasManyThroughRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.id`,\n\t\t\t\tthrough: {\n\t\t\t\t\tfrom: `${viaTable}.${subjectForeignKey}`,\n\t\t\t\t\tto: `${viaTable}.${objectForeignKey}`,\n\t\t\t\t},\n\t\t\t\tto: `${objectTable}.id`\n            });\n\t\tcase 'belongsTo':\n\t\t\treturn belongsRelation({\n\t\t\t\tmodelClass: object,\n\t\t\t\tfrom: `${subjectTable}.${objectForeignKey}`,\n\t\t\t\tto: `${objectTable}.id`\n            });\n\t\tdefault:\n\t\t\tthrow new Error('No valid relationship type specified');\n\t}\n};"],"names":["HasOneRelation","BelongsToOneRelation","HasManyRelation","ManyToManyRelation","Model","belongsRelation","modelClass","from","to","relation","join","hasOneRelation","hasManyRelation","hasManyThroughRelation","through","getSubjectTable","subject","options","subjectTable","pluralize","snakeCase","getObjectTable","object","objectTable","getSubjectForeignKey","subjectForeignKey","getObjectForeignKey","objectForeignKey","relType","via","viaTable","Error"],"mappings":"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"}