@anephenix/objection-relations 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Anephenix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,280 @@
+# objection-relations
+
+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:
+
+```javascript
+class Person extends Model {
+  static get tableName() {
+    return 'persons';
+  }
+
+  static get relationMappings() {
+    return {
+      addresses: {
+        relation: Model.HasManyRelation,
+        modelClass: Address,
+        join: {
+          from: 'persons.id',
+          to: 'addresses.person_id',
+        },
+      },
+    };
+  }
+}
+```
+
+You can use the objection-relations helper module to write the instead:
+
+```javascript
+import { relation } from '@anephenix/objection-relations';
+
+class Person extends Model {
+  static get tableName() {
+    return 'persons';
+  }
+
+  static get relationMappings() {
+    return {
+      addresses: relation({
+        subject: 'Person',
+        relType: 'hasMany',
+        object: 'Address',
+      }),
+    };
+  }
+}
+```
+
+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).
+
+## Dependencies
+
+- Node.js
+
+## Install
+
+```shell
+npm i @anephenix/objection-relations
+```
+
+## Usage
+
+You can setup different kinds of database table relationships like this:
+
+### Belongs to
+
+```javascript
+relation({ subject: 'Post', relType: 'belongsTo', object: 'User' });
+```
+
+Is equivalent to writing:
+
+```javascript
+{
+    relation: Model.BelongsToOneRelation,
+    modelClass: User,
+    join: {
+        from: 'posts.user_id',
+        to: 'users.id'
+    }
+}
+```
+
+### Has one
+
+```javascript
+relation({ subject: 'User', relType: 'hasOne', object: 'Setting' });
+```
+
+Is equivalent to writing:
+
+```javascript
+{
+    relation: Model.HasOneRelation,
+    modelClass: Setting,
+    join: {
+        from: 'users.id',
+        to: 'settings.user_id'
+    }
+}
+```
+
+### Has many
+
+```javascript
+relation({ subject: 'User', relType: 'hasMany', object: 'Address' });
+```
+
+Is equivalent to writing:
+
+```javascript
+{
+    relation: Model.HasManyRelation,
+    modelClass: Address,
+    join: {
+        from: 'users.id',
+        to: 'addresses.user_id'
+    }
+}
+```
+
+### Has many through
+
+For relationships defined through a join table, you can write this:
+
+```javascript
+relation({
+  subject: 'User',
+  relType: 'hasManyThrough',
+  object: 'Company',
+  via: 'Employment',
+});
+```
+
+This is equivalent to:
+
+```javascript
+{
+    relation: Model.ManyToManyRelation,
+    modelClass: Company,
+    join: {
+        from: 'users.id',
+        through: {
+            from: 'employments.user_id',
+            to: 'employments.company_id'
+        },
+        to: 'companies.id'
+    }
+}
+```
+
+## Advanced usage
+
+There might be cases where the name of the database tables and foreign keys are
+following a different pattern from plural database tables and singular foreign
+keys. In such cases you can define them in the options, like this:
+
+### SubjectTable
+
+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' },
+});
+```
+
+Which is equivalent to writing:
+
+```javascript
+{
+    relation: Model.HasManyRelation,
+    modelClass: Address,
+    join: {
+        from: 'account_users.id',
+        to: 'addresses.user_id'
+    }
+}
+```
+
+### ObjectTable
+
+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' },
+});
+```
+
+Which is equivalent to writing:
+
+```javascript
+{
+    relation: Model.HasManyRelation,
+    modelClass: Address,
+    join: {
+        from: 'users.id',
+        to: 'shipping_addresses.user_id'
+    }
+}
+```
+
+### SubjectForeignKey
+
+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' },
+});
+```
+
+Which is equivalent to writing:
+
+```javascript
+{
+    relation: Model.HasManyRelation,
+    modelClass: Address,
+    join: {
+        from: 'users.id',
+        to: 'addresses.account_user_id'
+    }
+}
+```
+
+### ObjectForeignKey
+
+You can pass a custom foreign key for the object like this:
+
+```javascript
+relation({
+  subject: 'Post',
+  relType: 'belongsTo',
+  object: 'User',
+  options: { objectForeignKey: 'author_id' },
+});
+```
+
+Is equivalent to writing:
+
+```javascript
+{
+    relation: Model.BelongsToOneRelation,
+    modelClass: User,
+    join: {
+        from: 'posts.author_id',
+        to: 'users.id'
+    }
+}
+```
+
+## Tests
+
+```shell
+npm t
+```
+
+## Licence and credits
+
+©2022 Anephenix OÜ. Objection-relations is licenced under the MIT Licence.

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,8 @@
+
+'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

@@ -0,0 +1,218 @@
+'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

@@ -0,0 +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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"}

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

@@ -0,0 +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")}};
+//# sourceMappingURL=objection-relations.cjs.production.min.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,204 @@
+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

@@ -0,0 +1 @@
+{"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":";;;;AAAA;AAEA,MAAM;AACLA,EAAAA,cADK;AAELC,EAAAA,oBAFK;AAGLC,EAAAA,eAHK;AAILC,EAAAA;AAJK,IAKFC,KALJ;AA8CA;;;;;SAIgBC,gBAAgB;AAAEC,EAAAA,UAAF;AAAcC,EAAAA,IAAd;AAAoBC,EAAAA;AAApB;AAC/B,SAAO;AACNC,IAAAA,QAAQ,EAAER,oBADJ;AAENK,IAAAA,UAFM;AAGNI,IAAAA,IAAI,EAAE;AAAEH,MAAAA,IAAF;AAAQC,MAAAA;AAAR;AAHA,GAAP;AAKA;AAED;;;;;SAIgBG,eAAe;AAAEL,EAAAA,UAAF;AAAcC,EAAAA,IAAd;AAAoBC,EAAAA;AAApB;AAC9B,SAAO;AACNC,IAAAA,QAAQ,EAAET,cADJ;AAENM,IAAAA,UAFM;AAGNI,IAAAA,IAAI,EAAE;AAAEH,MAAAA,IAAF;AAAQC,MAAAA;AAAR;AAHA,GAAP;AAKA;AAED;;;;;SAIgBI,gBAAgB;AAAEN,EAAAA,UAAF;AAAcC,EAAAA,IAAd;AAAoBC,EAAAA;AAApB;AAC/B,SAAO;AACNC,IAAAA,QAAQ,EAAEP,eADJ;AAEAI,IAAAA,UAFA;AAGNI,IAAAA,IAAI,EAAE;AAAEH,MAAAA,IAAF;AAAQC,MAAAA;AAAR;AAHA,GAAP;AAKA;AAED;;;;;SAIgBK,uBAAuB;AAAEP,EAAAA,UAAF;AAAcC,EAAAA,IAAd;AAAoBO,EAAAA,OAApB;AAA6BN,EAAAA;AAA7B;AACtC,SAAO;AACNC,IAAAA,QAAQ,EAAEN,kBADJ;AAEAG,IAAAA,UAFA;AAGNI,IAAAA,IAAI,EAAE;AAAEH,MAAAA,IAAF;AAAQO,MAAAA,OAAR;AAAiBN,MAAAA;AAAjB;AAHA,GAAP;AAKA;AAED;;;;;SAIgBO,gBAAgB;AAAEC,EAAAA,OAAF;AAAWC,EAAAA;AAAX;AAC5B,SAAO,CAAAA,OAAO,QAAP,YAAAA,OAAO,CAAEC,YAAT,KAAyBC,SAAS,CAACC,SAAS,CAACJ,OAAD,CAAV,CAAzC;AACH;AAED;;;;;SAIgBK,eAAe;AAAEC,EAAAA,MAAF;AAAUL,EAAAA;AAAV;AAC3B,SAAO,CAAAA,OAAO,QAAP,YAAAA,OAAO,CAAEM,WAAT,KAAwBJ,SAAS,CAACC,SAAS,CAACE,MAAD,CAAV,CAAxC;AACH;AAED;;;;;SAIgBE,qBAAqB;AAAER,EAAAA,OAAF;AAAWC,EAAAA;AAAX;AACjC,SAAO,CAAAA,OAAO,QAAP,YAAAA,OAAO,CAAEQ,iBAAT,KAA8BL,SAAS,CAACJ,OAAD,CAAT,GAAqB,KAA1D;AACH;AAED;;;;;SAIgBU,oBAAoB;AAAEJ,EAAAA,MAAF;AAAUL,EAAAA;AAAV;AAChC,SAAO,CAAAA,OAAO,QAAP,YAAAA,OAAO,CAAEU,gBAAT,KAA6BP,SAAS,CAACE,MAAD,CAAT,GAAoB,KAAxD;AACH;AAED;;;;;SAIgBb,SAAS;AAACO,EAAAA,OAAD;AAAUY,EAAAA,OAAV;AAAmBN,EAAAA,MAAnB;AAA2BO,EAAAA,GAA3B;AAAgCZ,EAAAA;AAAhC;AACxB,QAAMC,YAAY,GAAGH,eAAe,CAAC;AAACC,IAAAA,OAAD;AAAUC,IAAAA;AAAV,GAAD,CAApC;AACA,QAAMM,WAAW,GAAGF,cAAc,CAAC;AAACC,IAAAA,MAAD;AAASL,IAAAA;AAAT,GAAD,CAAlC;AACA,QAAMQ,iBAAiB,GAAGD,oBAAoB,CAAC;AAACR,IAAAA,OAAD;AAAUC,IAAAA;AAAV,GAAD,CAA9C;AACA,QAAMU,gBAAgB,GAAGD,mBAAmB,CAAC;AAACJ,IAAAA,MAAD;AAASL,IAAAA;AAAT,GAAD,CAA5C;AACA,MAAIa,QAAJ;AACA,MAAID,GAAJ,EAASC,QAAQ,GAAGX,SAAS,CAACC,SAAS,CAACS,GAAD,CAAV,CAApB;;AACT,UAAQD,OAAR;AACC,SAAK,QAAL;AACC,aAAOjB,cAAc,CAAC;AACTL,QAAAA,UAAU,EAAEgB,MADH;AAErBf,QAAAA,IAAI,KAAKW,iBAFY;AAGrBV,QAAAA,EAAE,KAAKe,eAAeE;AAHD,OAAD,CAArB;;AAKD,SAAK,SAAL;AACC,aAAOb,eAAe,CAAC;AACtBN,QAAAA,UAAU,EAAEgB,MADU;AAEtBf,QAAAA,IAAI,KAAKW,iBAFa;AAGtBV,QAAAA,EAAE,KAAKe,eAAeE;AAHA,OAAD,CAAtB;;AAKD,SAAK,gBAAL;AACC,aAAOZ,sBAAsB,CAAC;AAC7BP,QAAAA,UAAU,EAAEgB,MADiB;AAE7Bf,QAAAA,IAAI,KAAKW,iBAFoB;AAG7BJ,QAAAA,OAAO,EAAE;AACRP,UAAAA,IAAI,KAAKuB,YAAYL,mBADb;AAERjB,UAAAA,EAAE,KAAKsB,YAAYH;AAFX,SAHoB;AAO7BnB,QAAAA,EAAE,KAAKe;AAPsB,OAAD,CAA7B;;AASD,SAAK,WAAL;AACC,aAAOlB,eAAe,CAAC;AACtBC,QAAAA,UAAU,EAAEgB,MADU;AAEtBf,QAAAA,IAAI,KAAKW,gBAAgBS,kBAFH;AAGtBnB,QAAAA,EAAE,KAAKe;AAHe,OAAD,CAAtB;;AAKD;AACC,YAAM,IAAIQ,KAAJ,CAAU,sCAAV,CAAN;AA9BF;AAgCA;;;;"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "version": "0.0.1",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=10"
+  },
+  "dependencies": {
+    "lodash.snakecase": "^4.1.1",
+    "objection": "^3.0.1",
+    "pluralize": "^8.0.0"
+  },
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^7.0.8",
+    "@types/jest": "^27.4.0",
+    "@types/lodash.snakecase": "^4.1.6",
+    "@types/pluralize": "^0.0.29",
+    "husky": "^7.0.4",
+    "npm-upgrade": "^3.1.0",
+    "size-limit": "^7.0.8",
+    "tsdx": "^0.14.1",
+    "tslib": "^1.14.1",
+    "typescript": "^4.5.5"
+  },
+  "author": "Paul Jensen <paul@anephenix.com>",
+  "scripts": {
+    "start": "tsdx watch --target node",
+    "build": "tsdx build --target node",
+    "test": "tsdx test",
+    "lint": "tsdx lint",
+    "prepare": "tsdx build --target node",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "tsdx lint && tsdx test"
+    }
+  },
+  "name": "@anephenix/objection-relations",
+  "module": "dist/objection-relations.esm.js",
+  "prettier": {
+    "printWidth": 80,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "size-limit": [
+    {
+      "path": "dist/objection-relations.cjs.production.min.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/objection-relations.esm.js",
+      "limit": "10 KB"
+    }
+  ]
+}

package/src/index.ts

@@ -0,0 +1,172 @@
+// Dependencies
+import { Model } from 'objection';
+const {
+	HasOneRelation,
+	BelongsToOneRelation,
+	HasManyRelation,
+	ManyToManyRelation,
+} = Model;
+import snakeCase from 'lodash.snakecase';
+import pluralize from 'pluralize';
+
+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 },
+	};
+};
+
+/*
+	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 },
+	};
+};
+
+/*
+    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';
+}
+
+/*
+	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');
+	}
+};