@anephenix/objection-relations 0.0.14 → 0.0.18

package/README.md

@@ -61,6 +61,32 @@ The helper function will do the following:
 | ----- | ---------- | ----------- |
 | User  | users      | user_id     |
 
+*NOTE*
+
+For TypeScript files to resolve correctly in Objection.js, use the model directly instead of the name as a string:
+
+```typescript
+import { ObjectionRelation } from '@anephenix/objection-relations';
+import Address from './Address';
+
+class User extends Model {
+  static get tableName() {
+    return 'users';
+  }
+
+  static get relationMappings() {
+    const or = new ObjectionRelation({
+      subject: this.name,
+      modelPath: __dirname,
+    });
+    return {
+      // This changes from 'Address' to Address
+      addresses: or.hasMany(Address),
+    };
+  }
+}
+```
+
 ## Dependencies
 
 - Node.js

package/package.json

@@ -1,12 +1,18 @@
 {
-	"version": "0.0.14",
+	"version": "0.0.18",
 	"license": "MIT",
 	"main": "dist/index.js",
 	"type": "module",
-	"typings": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"require": "./dist/index.js"
+		}
+	},
+	"types": "./dist/index.d.ts",
 	"files": [
 		"dist",
-		"src"
+		"README.md"
 	],
 	"engines": {
 		"node": ">=10"
@@ -19,7 +25,7 @@
 	"devDependencies": {
 		"@biomejs/biome": "2.2.5",
 		"@types/lodash.snakecase": "^4.1.9",
-		"@types/node": "^24.6.2",
+		"@types/node": "^24.7.0",
 		"@types/pluralize": "^0.0.33",
 		"@vitest/coverage-v8": "^3.2.4",
 		"globals": "^16.4.0",
@@ -40,6 +46,9 @@
 		"size": "size-limit",
 		"start": "tsdx watch --target node",
 		"test": "NODE_ENV=test vitest --run",
+		"test:build:commonjs": "node e2e/test-commonjs.cjs",
+		"test:build:esm": "node e2e/test-esm.js",
+		"test:e2e": "npm run build && npm run test:build:commonjs && npm run test:build:esm",
 		"update-changelog": "node --experimental-strip-types scripts/update-changelog.ts",
 		"prepare": "husky"
 	},

package/src/global.d.ts

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

package/src/helpers.ts

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

package/src/index.ts

@@ -1,64 +0,0 @@
-// Dependencies
-import type { OptionsProps } from "./global";
-import { relation } from "./relations";
-
-// Types
-
-type ObjectionRelationProps = {
-	subject: string;
-	modelPath: string;
-};
-
-export class ObjectionRelation {
-	subject: string;
-	modelPath: string;
-	constructor({ subject, modelPath }: ObjectionRelationProps) {
-		this.subject = subject;
-		this.modelPath = modelPath;
-	}
-
-	belongsTo(object: string, options?: OptionsProps) {
-		if (!options) options = { modelPath: this.modelPath };
-		if (!options.modelPath) options.modelPath = this.modelPath;
-		return relation({
-			subject: this.subject,
-			relType: "belongsTo",
-			object,
-			options,
-		});
-	}
-
-	hasOne(object: string, options?: OptionsProps) {
-		if (!options) options = { modelPath: this.modelPath };
-		if (!options.modelPath) options.modelPath = this.modelPath;
-		return relation({
-			subject: this.subject,
-			relType: "hasOne",
-			object,
-			options,
-		});
-	}
-
-	hasMany(object: string, options?: OptionsProps) {
-		if (!options) options = { modelPath: this.modelPath };
-		if (!options.modelPath) options.modelPath = this.modelPath;
-		return relation({
-			subject: this.subject,
-			relType: "hasMany",
-			object,
-			options,
-		});
-	}
-
-	hasManyThrough(object: string, via: string, options?: OptionsProps) {
-		if (!options) options = { modelPath: this.modelPath };
-		if (!options.modelPath) options.modelPath = this.modelPath;
-		return relation({
-			subject: this.subject,
-			relType: "hasManyThrough",
-			object,
-			via,
-			options,
-		});
-	}
-}

package/src/relations.ts

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