@anephenix/objection-relations 0.0.19 → 0.0.21

package/dist/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { CommonRelationOrTableOrForeignKeyProps, ModelType } from "./global.js";
+type SubjectProps = CommonRelationOrTableOrForeignKeyProps & {
+    subject: string;
+};
+type ObjectProps = CommonRelationOrTableOrForeignKeyProps & {
+    object: ModelType;
+};
+type ViaProps = string | undefined;
+export declare function isModel(object: ModelType): boolean;
+export declare function getSubjectTable({ subject, options }: SubjectProps): string;
+export declare function getObjectTable({ object, options }: ObjectProps): any;
+export declare function getSubjectForeignKey({ subject, options }: SubjectProps): string;
+export declare function getObjectForeignKey({ object, options }: ObjectProps): string;
+export declare function getModelClass({ object, options }: ObjectProps): any;
+export declare function getViaTable(via: ViaProps): string | null;
+export {};

package/dist/helpers.js

@@ -0,0 +1,61 @@
+import { join } from "node:path";
+import snakeCase from "lodash.snakecase";
+import pluralize from "pluralize";
+/*
+    We use this function to detect if the object is
+    an Objection.js model or a string.
+*/
+export function isModel(object) {
+    return (typeof object === "function" &&
+        object?.tableName !== undefined &&
+        object?.name !== 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 }) {
+    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 }) {
+    // If the object is already a Model class, return the table name
+    if (isModel(object))
+        return object.tableName;
+    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 }) {
+    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 }) {
+    if (isModel(object)) {
+        const modelName = object.name;
+        return options?.objectForeignKey || `${snakeCase(modelName)}_id`;
+    }
+    return options?.objectForeignKey || `${snakeCase(object)}_id`;
+}
+/*
+    Allows you to define the model path for a model
+*/
+export function getModelClass({ object, options }) {
+    // If the object is already a Model class, return it
+    if (isModel(object))
+        return object;
+    return options?.modelPath
+        ? join(options.modelPath, object)
+        : object;
+}
+export function getViaTable(via) {
+    return via ? pluralize(snakeCase(via)) : null;
+}

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import type { ModelType, OptionsProps } from "./global.js";
+type ObjectionRelationProps = {
+    subject: string;
+    modelPath: string;
+};
+export declare class ObjectionRelation {
+    subject: string;
+    modelPath: string;
+    constructor({ subject, modelPath }: ObjectionRelationProps);
+    belongsTo(object: ModelType, options?: OptionsProps): {
+        relation: import("objection").RelationType;
+        modelClass: any;
+        join: {
+            from: string;
+            to: string;
+        };
+    };
+    hasOne(object: ModelType, options?: OptionsProps): {
+        relation: import("objection").RelationType;
+        modelClass: any;
+        join: {
+            from: string;
+            to: string;
+        };
+    };
+    hasMany(object: ModelType, options?: OptionsProps): {
+        relation: import("objection").RelationType;
+        modelClass: any;
+        join: {
+            from: string;
+            to: string;
+        };
+    };
+    hasManyThrough(object: ModelType, via: string, options?: OptionsProps): {
+        relation: import("objection").RelationType;
+        modelClass: any;
+        join: {
+            from: string;
+            to: string;
+        };
+    };
+}
+export {};

package/dist/index.js

@@ -0,0 +1,58 @@
+import { relation } from "./relations.js";
+export class ObjectionRelation {
+    subject;
+    modelPath;
+    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,
+        });
+    }
+}

package/dist/relations.d.ts

@@ -0,0 +1,58 @@
+import type { CommonRelationOrTableOrForeignKeyProps, ModelType, RelationTypeProps } from "./global.js";
+export type AdvancedRelationTypeProps = RelationTypeProps & {
+    through: {
+        from: string;
+        to: string;
+    };
+};
+export declare function belongsRelation({ modelClass, from, to }: RelationTypeProps): {
+    relation: import("objection").RelationType;
+    modelClass: any;
+    join: {
+        from: string;
+        to: string;
+    };
+};
+export declare function hasOneRelation({ modelClass, from, to }: RelationTypeProps): {
+    relation: import("objection").RelationType;
+    modelClass: any;
+    join: {
+        from: string;
+        to: string;
+    };
+};
+export declare function hasManyRelation({ modelClass, from, to }: RelationTypeProps): {
+    relation: import("objection").RelationType;
+    modelClass: any;
+    join: {
+        from: string;
+        to: string;
+    };
+};
+export declare function hasManyThroughRelation({ modelClass, from, through, to, }: AdvancedRelationTypeProps): {
+    relation: import("objection").RelationType;
+    modelClass: any;
+    join: {
+        from: string;
+        through: {
+            from: string;
+            to: string;
+        };
+        to: string;
+    };
+};
+type RelationProps = CommonRelationOrTableOrForeignKeyProps & {
+    subject: string;
+    relType: "hasOne" | "hasMany" | "hasManyThrough" | "belongsTo";
+    object: ModelType;
+    via?: string;
+};
+export declare function relation({ subject, relType, object, via, options, }: RelationProps): {
+    relation: import("objection").RelationType;
+    modelClass: any;
+    join: {
+        from: string;
+        to: string;
+    };
+};
+export {};

package/dist/relations.js

@@ -0,0 +1,92 @@
+// Dependencies
+import { Model } from "objection";
+import { getModelClass, getObjectForeignKey, getObjectTable, getSubjectForeignKey, getSubjectTable, getViaTable, } from "./helpers.js";
+const { HasOneRelation, BelongsToOneRelation, HasManyRelation, ManyToManyRelation, } = Model;
+/*
+    Defines a relationship where a record in one model can belong to a record in
+    another model.
+*/
+export 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.
+*/
+export 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.
+*/
+export 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
+*/
+export function hasManyThroughRelation({ modelClass, from, through, to, }) {
+    return {
+        relation: ManyToManyRelation,
+        modelClass,
+        join: { from, through, to },
+    };
+}
+/*
+    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, }) {
+    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/package.json

@@ -1,14 +1,19 @@
 {
 	"name": "@anephenix/objection-relations",
-	"version": "0.0.19",
+	"version": "0.0.21",
 	"license": "MIT",
 	"type": "module",
+	"main": "./dist/index.js",
 	"exports": {
 		".": {
+			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
-			"require": "./dist/index.js"
+			"default": "./dist/index.js"
 		}
 	},
+	"engines": {
+		"node": ">=16"
+	},
 	"types": "./dist/index.d.ts",
 	"files": [
 		"dist",