@anephenix/objection-relations 0.0.1 → 0.0.2

package/README.md

@@ -3,12 +3,12 @@
 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 +17,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 +29,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 +53,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 +76,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 +84,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 +95,7 @@ Is equivalent to writing:
 ### Has one
 
 ```javascript
-relation({ subject: 'User', relType: 'hasOne', object: 'Setting' });
+or.hasOne('Setting');
 ```
 
 Is equivalent to writing:
@@ -99,7 +103,7 @@ Is equivalent to writing:
 ```javascript
 {
     relation: Model.HasOneRelation,
-    modelClass: Setting,
+    modelClass: 'Setting',
     join: {
         from: 'users.id',
         to: 'settings.user_id'
@@ -110,7 +114,7 @@ Is equivalent to writing:
 ### Has many
 
 ```javascript
-relation({ subject: 'User', relType: 'hasMany', object: 'Address' });
+or.hasMany('Address');
 ```
 
 Is equivalent to writing:
@@ -131,12 +135,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 +167,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 +189,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 +211,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 +229,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:

package/dist/helpers.d.ts

@@ -0,0 +1,15 @@
+import { CommonRelationOrTableOrForeignKeyProps } from './global';
+declare type SubjectProps = CommonRelationOrTableOrForeignKeyProps & {
+    subject: string;
+};
+declare type ObjectProps = CommonRelationOrTableOrForeignKeyProps & {
+    object: string;
+};
+declare type ViaProps = string | undefined;
+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 getModelClass({ object, options }: ObjectProps): string;
+export declare function getViaTable(via: ViaProps): string | null;
+export {};

package/dist/index.d.ts

@@ -1,80 +1,43 @@
-declare type CommonRelationOrTableOrForeignKeyProps = {
-    options?: {
-        subjectTable?: string;
-        objectTable?: string;
-        subjectForeignKey?: string;
-        objectForeignKey?: string;
-    };
-};
-declare type RelationProps = CommonRelationOrTableOrForeignKeyProps & {
+import { OptionsProps } from './global';
+declare type ObjectionRelationProps = {
     subject: string;
-    relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';
-    object: string;
-    via?: string;
-};
-declare type RelationTypeProps = {
-    modelClass: string;
-    from: string;
-    to: string;
+    modelPath: string;
 };
-declare type AdvancedRelationTypeProps = RelationTypeProps & {
-    through: {
-        from: string;
-        to: string;
-    };
-};
-declare type SubjectProps = CommonRelationOrTableOrForeignKeyProps & {
+export declare class ObjectionRelation {
     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;
+    modelPath: string;
+    constructor({ subject, modelPath }: ObjectionRelationProps);
+    belongsTo(object: string, options?: OptionsProps): {
+        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;
+    hasOne(object: string, options?: OptionsProps): {
+        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: {
+    hasMany(object: string, options?: OptionsProps): {
+        relation: import("objection").RelationType;
+        modelClass: string;
+        join: {
             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;
+    hasManyThrough(object: string, via: string, options?: OptionsProps): {
+        relation: import("objection").RelationType;
+        modelClass: string;
+        join: {
+            from: string;
+            to: string;
+        };
     };
-};
+}
 export {};

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

@@ -7,6 +7,65 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 var objection = require('objection');
 var snakeCase = _interopDefault(require('lodash.snakecase'));
 var pluralize = _interopDefault(require('pluralize'));
+var path = require('path');
+
+/*
+    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';
+}
+/*
+    Allows you to define the model path for a model
+*/
+
+function getModelClass({
+  object,
+  options
+}) {
+  return options != null && options.modelPath ? path.join(options.modelPath, object) : object;
+}
+function getViaTable(via) {
+  return via ? pluralize(snakeCase(via)) : null;
+}
 
 // Dependencies
 const {
@@ -93,50 +152,6 @@ function hasManyThroughRelation({
     }
   };
 }
-/*
-    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.
@@ -165,27 +180,30 @@ function relation({
     object,
     options
   });
-  let viaTable;
-  if (via) viaTable = pluralize(snakeCase(via));
+  const modelClass = getModelClass({
+    object,
+    options
+  });
+  const viaTable = getViaTable(via);
 
   switch (relType) {
     case 'hasOne':
       return hasOneRelation({
-        modelClass: object,
+        modelClass,
         from: `${subjectTable}.id`,
         to: `${objectTable}.${subjectForeignKey}`
       });
 
     case 'hasMany':
       return hasManyRelation({
-        modelClass: object,
+        modelClass,
         from: `${subjectTable}.id`,
         to: `${objectTable}.${subjectForeignKey}`
       });
 
     case 'hasManyThrough':
       return hasManyThroughRelation({
-        modelClass: object,
+        modelClass,
         from: `${subjectTable}.id`,
         through: {
           from: `${viaTable}.${subjectForeignKey}`,
@@ -196,7 +214,7 @@ function relation({
 
     case 'belongsTo':
       return belongsRelation({
-        modelClass: object,
+        modelClass,
         from: `${subjectTable}.${objectForeignKey}`,
         to: `${objectTable}.id`
       });
@@ -206,13 +224,69 @@ function relation({
   }
 }
 
-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;
+class ObjectionRelation {
+  constructor({
+    subject,
+    modelPath
+  }) {
+    this.subject = subject;
+    this.modelPath = modelPath;
+  }
+
+  belongsTo(object, options) {
+    if (!options) options = {
+      modelPath: this.modelPath
+    };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'belongsTo',
+      object,
+      options
+    });
+  }
+
+  hasOne(object, options) {
+    if (!options) options = {
+      modelPath: this.modelPath
+    };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'hasOne',
+      object,
+      options
+    });
+  }
+
+  hasMany(object, options) {
+    if (!options) options = {
+      modelPath: this.modelPath
+    };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'hasMany',
+      object,
+      options
+    });
+  }
+
+  hasManyThrough(object, via, options) {
+    if (!options) options = {
+      modelPath: this.modelPath
+    };
+    if (!options.modelPath) options.modelPath = this.modelPath;
+    return relation({
+      subject: this.subject,
+      relType: 'hasManyThrough',
+      object,
+      via,
+      options
+    });
+  }
+
+}
+
+exports.ObjectionRelation = ObjectionRelation;
 //# sourceMappingURL=objection-relations.cjs.development.js.map

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

@@ -1 +1 @@
-{"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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"}
+{"version":3,"file":"objection-relations.cjs.development.js","sources":["../src/helpers.ts","../src/relations.ts","../src/index.ts"],"sourcesContent":["import snakeCase from 'lodash.snakecase';\nimport pluralize from 'pluralize';\nimport { join } from 'path';\nimport { CommonRelationOrTableOrForeignKeyProps } from './global';\n\n// Types\n\ntype SubjectProps = CommonRelationOrTableOrForeignKeyProps & {\n  subject: string;\n};\n\ntype ObjectProps = CommonRelationOrTableOrForeignKeyProps & {\n  object: string;\n};\n\ntype ViaProps = string | undefined;\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\tAllows you to define the model path for a model\n*/\nexport function getModelClass({ object, options }: ObjectProps) {\n  return options?.modelPath ? join(options.modelPath, object) : object;\n}\n\nexport function getViaTable(via: ViaProps) {\n  return via ? pluralize(snakeCase(via)) : null;\n}\n","// Dependencies\nimport { Model } from 'objection';\nimport {\n  RelationTypeProps,\n  CommonRelationOrTableOrForeignKeyProps,\n} from './global';\nimport {\n  getSubjectTable,\n  getSubjectForeignKey,\n  getObjectTable,\n  getObjectForeignKey,\n  getModelClass,\n  getViaTable,\n} from './helpers';\n\nconst {\n  HasOneRelation,\n  BelongsToOneRelation,\n  HasManyRelation,\n  ManyToManyRelation,\n} = Model;\n\n// Types\n\ntype AdvancedRelationTypeProps = RelationTypeProps & {\n  through: {\n    from: string;\n    to: string;\n  };\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  return {\n    relation: BelongsToOneRelation,\n    modelClass,\n    join: { from, to },\n  };\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  return {\n    relation: HasOneRelation,\n    modelClass,\n    join: { from, to },\n  };\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  return {\n    relation: HasManyRelation,\n    modelClass,\n    join: { from, to },\n  };\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({\n  modelClass,\n  from,\n  through,\n  to,\n}: AdvancedRelationTypeProps) {\n  return {\n    relation: ManyToManyRelation,\n    modelClass,\n    join: { from, through, to },\n  };\n}\n\ntype RelationProps = CommonRelationOrTableOrForeignKeyProps & {\n  subject: string;\n  relType: 'hasOne' | 'hasMany' | 'hasManyThrough' | 'belongsTo';\n  object: string;\n  via?: string;\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({\n  subject,\n  relType,\n  object,\n  via,\n  options,\n}: RelationProps) {\n  const subjectTable = getSubjectTable({ subject, options });\n  const objectTable = getObjectTable({ object, options });\n  const subjectForeignKey = getSubjectForeignKey({ subject, options });\n  const objectForeignKey = getObjectForeignKey({ object, options });\n  const modelClass = getModelClass({ object, options });\n  const viaTable = getViaTable(via);\n  switch (relType) {\n    case 'hasOne':\n      return hasOneRelation({\n        modelClass,\n        from: `${subjectTable}.id`,\n        to: `${objectTable}.${subjectForeignKey}`,\n      });\n    case 'hasMany':\n      return hasManyRelation({\n        modelClass,\n        from: `${subjectTable}.id`,\n        to: `${objectTable}.${subjectForeignKey}`,\n      });\n    case 'hasManyThrough':\n      return hasManyThroughRelation({\n        modelClass,\n        from: `${subjectTable}.id`,\n        through: {\n          from: `${viaTable}.${subjectForeignKey}`,\n          to: `${viaTable}.${objectForeignKey}`,\n        },\n        to: `${objectTable}.id`,\n      });\n    case 'belongsTo':\n      return belongsRelation({\n        modelClass,\n        from: `${subjectTable}.${objectForeignKey}`,\n        to: `${objectTable}.id`,\n      });\n    default:\n      throw new Error('No valid relationship type specified');\n  }\n}\n","// Dependencies\nimport { OptionsProps } from './global';\nimport { relation } from './relations';\n\n// Types\n\ntype ObjectionRelationProps = {\n  subject: string;\n  modelPath: string;\n};\n\nexport class ObjectionRelation {\n  subject: string;\n  modelPath: string;\n  constructor({ subject, modelPath }: ObjectionRelationProps) {\n    this.subject = subject;\n    this.modelPath = modelPath;\n  }\n\n  belongsTo(object: string, options?: OptionsProps) {\n    if (!options) options = { modelPath: this.modelPath };\n    if (!options.modelPath) options.modelPath = this.modelPath;\n    return relation({\n      subject: this.subject,\n      relType: 'belongsTo',\n      object,\n      options,\n    });\n  }\n\n  hasOne(object: string, options?: OptionsProps) {\n    if (!options) options = { modelPath: this.modelPath };\n    if (!options.modelPath) options.modelPath = this.modelPath;\n    return relation({\n      subject: this.subject,\n      relType: 'hasOne',\n      object,\n      options,\n    });\n  }\n\n  hasMany(object: string, options?: OptionsProps) {\n    if (!options) options = { modelPath: this.modelPath };\n    if (!options.modelPath) options.modelPath = this.modelPath;\n    return relation({\n      subject: this.subject,\n      relType: 'hasMany',\n      object,\n      options,\n    });\n  }\n\n  hasManyThrough(object: string, via: string, options?: OptionsProps) {\n    if (!options) options = { modelPath: this.modelPath };\n    if (!options.modelPath) options.modelPath = this.modelPath;\n    return relation({\n      subject: this.subject,\n      relType: 'hasManyThrough',\n      object,\n      via,\n      options,\n    });\n  }\n}\n"],"names":["getSubjectTable","subject","options","subjectTable","pluralize","snakeCase","getObjectTable","object","objectTable","getSubjectForeignKey","subjectForeignKey","getObjectForeignKey","objectForeignKey","getModelClass","modelPath","join","getViaTable","via","HasOneRelation","BelongsToOneRelation","HasManyRelation","ManyToManyRelation","Model","belongsRelation","modelClass","from","to","relation","hasOneRelation","hasManyRelation","hasManyThroughRelation","through","relType","viaTable","Error","ObjectionRelation","constructor","belongsTo","hasOne","hasMany","hasManyThrough"],"mappings":"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"}

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

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