@tsed/objection 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/objection",
   "description": "Objection.js package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -25,13 +26,13 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/ajv": "8.0.1",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/ajv": "8.0.2",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/json-mapper": "8.0.2",
+    "@tsed/schema": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "eslint": "9.12.0",
     "knex": "^3.1.0",
     "objection": "^2.2.18",
@@ -40,11 +41,11 @@
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/ajv": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/schema": "8.0.1",
+    "@tsed/ajv": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/json-mapper": "8.0.2",
+    "@tsed/schema": "8.0.2",
     "knex": ">=0.94.0",
     "objection": ">=2.0.0"
   },

package/src/components/createBooleanColumn.spec.ts

@@ -0,0 +1,20 @@
+import {Property} from "@tsed/schema";
+
+import {createTableStub} from "../../test/helpers/knex/table.js";
+import {Entity} from "../decorators/entity.js";
+import {createColumns} from "../utils/createColumns.js";
+
+describe("createBooleanColumn", () => {
+  it("should create table from a given class", () => {
+    @Entity("users")
+    class User {
+      @Property()
+      activated: boolean;
+    }
+
+    const table = createTableStub();
+    createColumns(table, User);
+
+    expect(table.boolean).toHaveBeenCalledWith("activated");
+  });
+});

package/src/components/createBooleanColumn.ts

@@ -0,0 +1,12 @@
+import type {Knex} from "knex";
+
+import {ColumnTypesContainer} from "../services/ColumnTypesContainer.js";
+import {ColumnCtx} from "../utils/getColumnCtx.js";
+/**
+ * @ignore
+ */
+export function createBooleanColumn(table: Knex.TableBuilder, {entity}: ColumnCtx) {
+  table.boolean(entity.propertyName);
+}
+
+ColumnTypesContainer.set("boolean", createBooleanColumn);

package/src/components/createIdColumn.spec.ts

@@ -0,0 +1,45 @@
+import {createTableStub} from "../../test/helpers/knex/table.js";
+import {Entity} from "../decorators/entity.js";
+import {IdColumn} from "../decorators/idColumn.js";
+import {createColumns} from "../utils/createColumns.js";
+
+describe("createIdColumn", () => {
+  it("should create table from a given class (bigIncrements)", () => {
+    @Entity("users")
+    class User {
+      @IdColumn("bigIncrements")
+      id: number;
+    }
+
+    const table = createTableStub();
+    createColumns(table, User);
+
+    expect(table.bigIncrements).toHaveBeenCalledWith("id");
+  });
+
+  it("should create table from a given class (increments)", () => {
+    @Entity("users")
+    class User {
+      @IdColumn("increments")
+      id: number;
+    }
+
+    const table = createTableStub();
+    createColumns(table, User);
+
+    expect(table.increments).toHaveBeenCalledWith("id");
+  });
+
+  it("should create table from a given class (uuid)", () => {
+    @Entity("users")
+    class User {
+      @IdColumn("uuid")
+      id: string;
+    }
+
+    const table = createTableStub();
+    createColumns(table, User);
+
+    expect(table.uuid).toHaveBeenCalledWith("id");
+  });
+});

package/src/components/createIdColumn.ts

@@ -0,0 +1,23 @@
+import {randomUUID} from "crypto";
+import type {Knex} from "knex";
+
+import {ColumnTypesContainer} from "../services/ColumnTypesContainer.js";
+import {ColumnCtx} from "../utils/getColumnCtx.js";
+
+/**
+ * @ignore
+ */
+export function createIdColumn(table: Knex.TableBuilder, {entity, options}: ColumnCtx) {
+  switch (options.type) {
+    case "bigIncrements":
+      table.bigIncrements(entity.propertyName).primary();
+      break;
+    case "increments":
+      table.increments(entity.propertyName).primary();
+      break;
+    case "uuid":
+      table.uuid(entity.propertyName).primary().defaultTo(randomUUID());
+  }
+}
+
+ColumnTypesContainer.set("idColumn", createIdColumn);

package/src/components/createNumberColumn.spec.ts

@@ -0,0 +1,34 @@
+import {Property} from "@tsed/schema";
+
+import {createTableStub} from "../../test/helpers/knex/table.js";
+import {Decimal} from "../decorators/decimal.js";
+import {Entity} from "../decorators/entity.js";
+import {createColumns} from "../utils/createColumns.js";
+
+describe("createNumberColumn", () => {
+  it("should create table from a given class (default)", async () => {
+    @Entity("users")
+    class User {
+      @Property()
+      prop: number;
+    }
+
+    const table = createTableStub();
+    await createColumns(table, User);
+
+    expect(table.decimal).toHaveBeenCalledWith("prop", undefined, undefined);
+  });
+
+  it("should create table from a given class (decimal)", async () => {
+    @Entity("users")
+    class User {
+      @Decimal({scale: 1, precision: 12})
+      prop: number;
+    }
+
+    const table = createTableStub();
+    await createColumns(table, User);
+
+    expect(table.decimal).toHaveBeenCalledWith("prop", 12, 1);
+  });
+});

package/src/components/createNumberColumn.ts

@@ -0,0 +1,13 @@
+import type {Knex} from "knex";
+
+import {ColumnTypesContainer} from "../services/ColumnTypesContainer.js";
+import {ColumnCtx} from "../utils/getColumnCtx.js";
+
+/**
+ * @ignore
+ */
+export function createNumberColumn(table: Knex.TableBuilder, {entity, options}: ColumnCtx) {
+  table.decimal(entity.propertyName, options.precision, options.scale);
+}
+
+ColumnTypesContainer.set("number", createNumberColumn);

package/src/components/createStringColumn.spec.ts

@@ -0,0 +1,34 @@
+import {MaxLength, Property} from "@tsed/schema";
+
+import {createTableStub} from "../../test/helpers/knex/table.js";
+import {Entity} from "../decorators/entity.js";
+import {createColumns} from "../utils/createColumns.js";
+
+describe("createNumberColumn", () => {
+  it("should create table from a given class (with maxLength)", async () => {
+    @Entity("users")
+    class User {
+      @Property()
+      @MaxLength(200)
+      prop: string;
+    }
+
+    const table = createTableStub();
+    await createColumns(table, User);
+
+    expect(table.string).toHaveBeenCalledWith("prop", 200);
+  });
+
+  it("should create table from a given class (without maxLength)", async () => {
+    @Entity("users")
+    class User {
+      @Property()
+      prop: string;
+    }
+
+    const table = createTableStub();
+    await createColumns(table, User);
+
+    expect(table.string).toHaveBeenCalledWith("prop", undefined);
+  });
+});

package/src/components/createStringColumn.ts

@@ -0,0 +1,13 @@
+import type {Knex} from "knex";
+
+import {ColumnTypesContainer} from "../services/ColumnTypesContainer.js";
+import {ColumnCtx} from "../utils/getColumnCtx.js";
+
+/**
+ * @ignore
+ */
+export function createStringColumn(table: Knex.TableBuilder, {entity, schema}: ColumnCtx) {
+  table.string(entity.propertyName, schema.maxLength);
+}
+
+ColumnTypesContainer.set("string", createStringColumn);

package/src/decorators/belongsToOne.spec.ts

@@ -0,0 +1,60 @@
+import {Model} from "objection";
+
+import {BelongsToOne} from "./belongsToOne.js";
+import {Entity} from "./entity.js";
+import {IdColumn} from "./idColumn.js";
+
+describe("@BelongsToOne", () => {
+  it("should set metadata", () => {
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+    }
+
+    @Entity("movie")
+    class Movie extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+      @BelongsToOne()
+      user?: User;
+    }
+    expect(Movie.relationMappings).toEqual({
+      user: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: User,
+        join: {
+          from: "movie.userId",
+          to: "user.id"
+        }
+      }
+    });
+  });
+  it("should set custom relationship path", () => {
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+    }
+    @Entity("movie")
+    class Movie extends Model {
+      @IdColumn()
+      id!: string;
+      ownerId!: string;
+      @BelongsToOne({from: "ownerId", to: "userId"})
+      user?: User;
+    }
+    expect(Movie.relationMappings).toEqual({
+      user: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: User,
+        join: {
+          from: "movie.ownerId",
+          to: "user.userId"
+        }
+      }
+    });
+  });
+});

package/src/decorators/belongsToOne.ts

@@ -0,0 +1,14 @@
+import {Model} from "objection";
+
+import {RelationshipOptsWithoutThrough} from "../domain/RelationshipOpts.js";
+import {RelatesTo} from "./relatesTo.js";
+
+/**
+ *
+ * @param opts
+ * @decorator
+ * @objection
+ */
+export function BelongsToOne(opts?: RelationshipOptsWithoutThrough): PropertyDecorator {
+  return RelatesTo(Model.BelongsToOneRelation, opts);
+}

package/src/decorators/columnOptions.ts

@@ -0,0 +1,13 @@
+import {StoreSet} from "@tsed/core";
+
+import type {ColumnOpts} from "../domain/ColumnOpts.js";
+
+/**
+ *
+ * @param options
+ * @decorator
+ * @objection
+ */
+export function ColumnOptions(options: Partial<ColumnOpts>): PropertyDecorator {
+  return StoreSet("objection", options) as any;
+}

package/src/decorators/decimal.spec.ts

@@ -0,0 +1,52 @@
+import {Store} from "@tsed/core";
+import {getJsonSchema} from "@tsed/schema";
+
+import {Decimal} from "./decimal.js";
+
+describe("@Decimal", () => {
+  it("should set metadata", () => {
+    class MyModel {
+      @Decimal({scale: 1, precision: 12})
+      prop: number;
+    }
+
+    expect(getJsonSchema(MyModel)).toEqual({
+      properties: {
+        prop: {
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+    expect(Store.from(MyModel, "prop").get("objection")).toEqual({
+      columnType: "number",
+      options: {
+        precision: 12,
+        scale: 1,
+        type: "decimal"
+      }
+    });
+  });
+
+  it("should set metadata (without options)", () => {
+    class MyModel {
+      @Decimal()
+      prop: number;
+    }
+
+    expect(getJsonSchema(MyModel)).toEqual({
+      properties: {
+        prop: {
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+    expect(Store.from(MyModel, "prop").get("objection")).toEqual({
+      columnType: "number",
+      options: {
+        type: "decimal"
+      }
+    });
+  });
+});

package/src/decorators/decimal.ts

@@ -0,0 +1,35 @@
+import {StoreSet, useDecorators} from "@tsed/core";
+import {Property} from "@tsed/schema";
+
+import {ColumnOptions} from "./columnOptions.js";
+
+export interface DecimalOptions {
+  precision?: number | null;
+  scale?: number;
+}
+
+/**
+ *
+ * @param options
+ * @decorator
+ * @objection
+ */
+export function Decimal(options: DecimalOptions = {}) {
+  return useDecorators(
+    Property(),
+    ColumnOptions({
+      columnType: "number",
+      options: {
+        type: "decimal",
+        ...options
+      }
+    }),
+    StoreSet("objection", {
+      columnType: "number",
+      options: {
+        type: "decimal",
+        ...options
+      }
+    })
+  );
+}

package/src/decorators/entity.spec.ts

@@ -0,0 +1,24 @@
+import {Entity} from "./entity.js";
+
+describe("@Entity", () => {
+  it("should set metadata", () => {
+    @Entity("models")
+    class MyModel {}
+
+    expect((MyModel as any).jsonSchema).toEqual({
+      type: "object"
+    });
+    expect((MyModel as any).tableName).toEqual("models");
+  });
+
+  it("should throw metadata when the tableName is empty", () => {
+    let actualError: any;
+    try {
+      @Entity("")
+      class MyModel {}
+    } catch (er) {
+      actualError = er;
+    }
+    expect(actualError.message).toEqual("Please provide a table name");
+  });
+});

package/src/decorators/entity.ts

@@ -0,0 +1,29 @@
+import {Type} from "@tsed/core";
+import {getJsonSchema} from "@tsed/schema";
+
+import {defineStaticGetter} from "../utils/defineStaticGetter.js";
+import {getJsonEntityRelationships} from "../utils/getJsonEntityRelationships.js";
+
+/**
+ *
+ * @param tableName
+ * @decorator
+ * @objection
+ */
+export function Entity(tableName: string): ClassDecorator {
+  if (!tableName) {
+    throw new Error("Please provide a table name");
+  }
+
+  return (target: any) => {
+    const originalRelationMappings = target["relationMappings"];
+    defineStaticGetter(target, "tableName", () => tableName);
+    defineStaticGetter(target, "jsonSchema", () => getJsonSchema(target));
+    defineStaticGetter(target, "relationMappings", () => originalRelationMappings || getJsonEntityRelationships(target));
+    return target;
+  };
+}
+
+export interface EntityMethods<T> extends Type<T> {
+  readonly tableName: string;
+}

package/src/decorators/hasMany.spec.ts

@@ -0,0 +1,60 @@
+import {Model} from "objection";
+
+import {Entity} from "./entity.js";
+import {HasMany} from "./hasMany.js";
+import {IdColumn} from "./idColumn.js";
+
+describe("@HasMany", () => {
+  it("should set metadata", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      userId?: string;
+    }
+
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      @HasMany(Pet)
+      pets?: Pet[];
+    }
+    expect(User.relationMappings).toEqual({
+      pets: {
+        relation: Model.HasManyRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.id",
+          to: "pet.userId"
+        }
+      }
+    });
+  });
+  it("should set custom relationship path", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      ownerId?: string;
+    }
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+      @HasMany(Pet, {from: "userId", to: "ownerId"})
+      pets?: Pet[];
+    }
+    expect(User.relationMappings).toEqual({
+      pets: {
+        relation: Model.HasManyRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.userId",
+          to: "pet.ownerId"
+        }
+      }
+    });
+  });
+});

package/src/decorators/hasMany.ts

@@ -0,0 +1,14 @@
+import {Model, ModelClassSpecifier} from "objection";
+
+import {RelationshipOptsWithThrough} from "../domain/RelationshipOpts.js";
+import {RelatesTo} from "./relatesTo.js";
+
+/**
+ *
+ * @param opts
+ * @decorator
+ * @objection
+ */
+export function HasMany(type: ModelClassSpecifier, opts?: RelationshipOptsWithThrough): PropertyDecorator {
+  return RelatesTo(Model.HasManyRelation, {...opts, type});
+}

package/src/decorators/hasOne.spec.ts

@@ -0,0 +1,60 @@
+import {Model} from "objection";
+
+import {Entity} from "./entity.js";
+import {HasOne} from "./hasOne.js";
+import {IdColumn} from "./idColumn.js";
+
+describe("@HasOne", () => {
+  it("should set metadata", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      userId?: string;
+    }
+
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      @HasOne()
+      pet?: Pet;
+    }
+    expect(User.relationMappings).toEqual({
+      pet: {
+        relation: Model.HasOneRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.id",
+          to: "pet.userId"
+        }
+      }
+    });
+  });
+  it("should set custom relationship path", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      ownerId?: string;
+    }
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+      @HasOne({from: "userId", to: "ownerId"})
+      pet?: Pet;
+    }
+    expect(User.relationMappings).toEqual({
+      pet: {
+        relation: Model.HasOneRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.userId",
+          to: "pet.ownerId"
+        }
+      }
+    });
+  });
+});

package/src/decorators/hasOne.ts

@@ -0,0 +1,14 @@
+import {Model} from "objection";
+
+import {RelationshipOptsWithoutThrough} from "../domain/RelationshipOpts.js";
+import {RelatesTo} from "./relatesTo.js";
+
+/**
+ *
+ * @param opts
+ * @decorator
+ * @objection
+ */
+export function HasOne(opts?: RelationshipOptsWithoutThrough): PropertyDecorator {
+  return RelatesTo(Model.HasOneRelation, opts);
+}

package/src/decorators/hasOneThroughRelation.spec.ts

@@ -0,0 +1,72 @@
+import {Model} from "objection";
+
+import {Entity} from "./entity.js";
+import {HasOneThroughRelation} from "./hasOneThroughRelation.js";
+import {IdColumn} from "./idColumn.js";
+
+describe("@HasOneThroughRelation", () => {
+  it("should set metadata", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      userId?: string;
+    }
+
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      @HasOneThroughRelation()
+      pet?: Pet;
+    }
+    expect(User.relationMappings).toEqual({
+      pet: {
+        relation: Model.HasOneThroughRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.id",
+          through: {
+            from: "user_pet.userId",
+            to: "user_pet.petId"
+          },
+          to: "pet.id"
+        }
+      }
+    });
+  });
+  it("should set custom relationship path", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      petId?: string;
+    }
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+      @HasOneThroughRelation({
+        from: "userId",
+        through: {from: "user_pet.ownerId", to: "user_pet.petId"},
+        to: "petId"
+      })
+      pet?: Pet;
+    }
+    expect(User.relationMappings).toEqual({
+      pet: {
+        relation: Model.HasOneThroughRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.userId",
+          through: {
+            from: "user_pet.ownerId",
+            to: "user_pet.petId"
+          },
+          to: "pet.petId"
+        }
+      }
+    });
+  });
+});

package/src/decorators/hasOneThroughRelation.ts

@@ -0,0 +1,14 @@
+import {Model} from "objection";
+
+import {RelationshipOptsWithoutThrough, RelationshipOptsWithThrough} from "../domain/RelationshipOpts.js";
+import {RelatesTo} from "./relatesTo.js";
+
+/**
+ *
+ * @param opts
+ * @decorator
+ * @objection
+ */
+export function HasOneThroughRelation(opts?: RelationshipOptsWithThrough): PropertyDecorator {
+  return RelatesTo(Model.HasOneThroughRelation, opts);
+}

package/src/decorators/idColumn.spec.ts

@@ -0,0 +1,31 @@
+import {Store} from "@tsed/core";
+import {getJsonSchema} from "@tsed/schema";
+import {Model} from "objection";
+
+import {IdColumn} from "./idColumn.js";
+
+describe("@IdColumn", () => {
+  it("should set metadata", () => {
+    class MyModel extends Model {
+      @IdColumn()
+      id: number;
+    }
+
+    expect(getJsonSchema(MyModel)).toEqual({
+      properties: {
+        id: {
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+    expect(Store.from(MyModel, "id").get("objection")).toEqual({
+      columnType: "idColumn",
+      options: {
+        type: "increments"
+      }
+    });
+
+    expect(MyModel.idColumn).toEqual("id");
+  });
+});

package/src/decorators/idColumn.ts

@@ -0,0 +1,26 @@
+import {useDecorators} from "@tsed/core";
+import {Property} from "@tsed/schema";
+
+import {defineStaticGetter} from "../utils/defineStaticGetter.js";
+import {ColumnOptions} from "./columnOptions.js";
+
+/**
+ *
+ * @param type
+ * @decorator
+ * @objection
+ */
+export function IdColumn(type: "uuid" | "increments" | "bigIncrements" = "increments"): PropertyDecorator {
+  return useDecorators(
+    Property(),
+    ColumnOptions({
+      columnType: "idColumn",
+      options: {
+        type
+      }
+    }),
+    (target: any, propertyKey: string) => {
+      defineStaticGetter(target, "idColumn", () => propertyKey);
+    }
+  );
+}

package/src/decorators/manyToMany.spec.ts

@@ -0,0 +1,72 @@
+import {Model} from "objection";
+
+import {Entity} from "./entity.js";
+import {IdColumn} from "./idColumn.js";
+import {ManyToMany} from "./manyToMany.js";
+
+describe("@ManyToMany", () => {
+  it("should set metadata", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      userId?: string;
+    }
+
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      @ManyToMany(Pet)
+      pets?: Pet[];
+    }
+    expect(User.relationMappings).toEqual({
+      pets: {
+        relation: Model.ManyToManyRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.id",
+          through: {
+            from: "user_pet.userId",
+            to: "user_pet.petId"
+          },
+          to: "pet.id"
+        }
+      }
+    });
+  });
+  it("should set custom relationship path", () => {
+    @Entity("pet")
+    class Pet extends Model {
+      @IdColumn()
+      id!: string;
+      petId?: string;
+    }
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+      @ManyToMany(Pet, {
+        from: "userId",
+        through: {from: "user_pet.ownerId", to: "user_pet.petId"},
+        to: "petId"
+      })
+      pets?: Pet[];
+    }
+    expect(User.relationMappings).toEqual({
+      pets: {
+        relation: Model.ManyToManyRelation,
+        modelClass: Pet,
+        join: {
+          from: "user.userId",
+          through: {
+            from: "user_pet.ownerId",
+            to: "user_pet.petId"
+          },
+          to: "pet.petId"
+        }
+      }
+    });
+  });
+});

package/src/decorators/manyToMany.ts

@@ -0,0 +1,14 @@
+import {Model, ModelClassSpecifier} from "objection";
+
+import {RelationshipOptsWithThrough} from "../domain/RelationshipOpts.js";
+import {RelatesTo} from "./relatesTo.js";
+
+/**
+ *
+ * @param opts
+ * @decorator
+ * @objection
+ */
+export function ManyToMany(type: ModelClassSpecifier, opts?: RelationshipOptsWithThrough): PropertyDecorator {
+  return RelatesTo(Model.ManyToManyRelation, {...opts, type});
+}

package/src/decorators/relatesTo.spec.ts

@@ -0,0 +1,34 @@
+import {Model} from "objection";
+
+import {Entity} from "./entity.js";
+import {IdColumn} from "./idColumn.js";
+import {RelatesTo} from "./relatesTo.js";
+
+describe("@RelatesTo", () => {
+  it("should set metadata", () => {
+    @Entity("user")
+    class User extends Model {
+      @IdColumn()
+      id!: string;
+    }
+
+    @Entity("movie")
+    class Movie extends Model {
+      @IdColumn()
+      id!: string;
+      userId!: string;
+      @RelatesTo(Model.BelongsToOneRelation)
+      user?: User;
+    }
+    expect(Movie.relationMappings).toEqual({
+      user: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: User,
+        join: {
+          from: "movie.userId",
+          to: "user.id"
+        }
+      }
+    });
+  });
+});

package/src/decorators/relatesTo.ts

@@ -0,0 +1,26 @@
+import {StoreFn, useDecorators} from "@tsed/core";
+import {CollectionOf, Property} from "@tsed/schema";
+import {RelationType} from "objection";
+
+import {isModelClassFactory, RelationshipOpts} from "../domain/RelationshipOpts.js";
+import {createRelationshipMapping} from "../utils/createRelationshipMapping.js";
+import {OBJECTION_RELATIONSHIP_KEY} from "../utils/getJsonEntityRelationships.js";
+
+/**
+ *
+ * @param relation
+ * @param opts
+ * @decorator
+ * @objection
+ */
+export function RelatesTo(relation: RelationType, opts?: RelationshipOpts): PropertyDecorator {
+  return useDecorators(
+    opts?.type ? CollectionOf(opts.type) : Property(),
+    StoreFn((store, params) => {
+      if (opts && isModelClassFactory(opts.type)) {
+        opts.type = opts.type();
+      }
+      store.set(OBJECTION_RELATIONSHIP_KEY, createRelationshipMapping(params, relation, opts));
+    })
+  );
+}

package/src/domain/ColumnOpts.ts

@@ -0,0 +1,4 @@
+export interface ColumnOpts {
+  columnType: "idColumn" | "string" | "number" | "boolean";
+  options: any;
+}

package/src/domain/RelationshipOpts.ts

@@ -0,0 +1,14 @@
+import {isFunction, isString} from "@tsed/core";
+import {ModelClassFactory, ModelClassSpecifier, RelationJoin, RelationMapping} from "objection";
+
+export type RelationshipOptsWithThrough = Partial<RelationJoin> & Omit<RelationMapping<any>, "relation" | "join" | "modelClass">;
+
+export type RelationshipOptsWithoutThrough = Omit<RelationshipOptsWithThrough, "through">;
+
+export type RelationshipOpts = (RelationshipOptsWithThrough | RelationshipOptsWithoutThrough) & {type?: ModelClassSpecifier};
+
+export const isRelationshipOptsWithThrough = (opts?: RelationshipOpts): opts is RelationshipOptsWithThrough =>
+  opts !== undefined && (<RelationshipOptsWithThrough>opts).through !== undefined;
+
+export const isModelClassFactory = (type?: ModelClassSpecifier): type is ModelClassFactory =>
+  type !== undefined && !isString(type) && isFunction(type) && !("prototype" in type);

package/src/domain/interfaces.ts

@@ -0,0 +1,9 @@
+import {Knex} from "knex";
+
+declare global {
+  namespace TsED {
+    interface Configuration {
+      knex: Knex.Config;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./components/createBooleanColumn.js";
+export * from "./components/createIdColumn.js";
+export * from "./components/createNumberColumn.js";
+export * from "./components/createStringColumn.js";
+export * from "./decorators/belongsToOne.js";
+export * from "./decorators/columnOptions.js";
+export * from "./decorators/decimal.js";
+export * from "./decorators/entity.js";
+export * from "./decorators/hasMany.js";
+export * from "./decorators/hasOne.js";
+export * from "./decorators/hasOneThroughRelation.js";
+export * from "./decorators/idColumn.js";
+export * from "./decorators/manyToMany.js";
+export * from "./decorators/relatesTo.js";
+export * from "./domain/ColumnOpts.js";
+export * from "./domain/interfaces.js";
+export * from "./domain/RelationshipOpts.js";
+export * from "./services/ColumnTypesContainer.js";
+export * from "./services/ObjectionConnection.js";
+export * from "./utils/connect.js";
+export * from "./utils/createColumns.js";
+export * from "./utils/createJoinKeys.js";
+export * from "./utils/createRelationshipMapping.js";
+export * from "./utils/defineStaticGetter.js";
+export * from "./utils/getColumnCtx.js";
+export * from "./utils/getJsonEntityRelationships.js";

package/src/services/ColumnTypesContainer.ts

@@ -0,0 +1,8 @@
+import type {Knex} from "knex";
+
+import {ColumnCtx} from "../utils/getColumnCtx.js";
+
+/**
+ * @ignore
+ */
+export const ColumnTypesContainer: Map<string, (table: Knex.TableBuilder, ctx: ColumnCtx) => void> = new Map();

package/src/services/ObjectionConnection.ts

@@ -0,0 +1,26 @@
+import {Configuration, registerProvider} from "@tsed/di";
+import type {Knex} from "knex";
+
+import {createConnection} from "../utils/connect.js";
+
+export const OBJECTION_CONNECTION = Symbol.for("DEFAULT_CONNECTION");
+export type OBJECTION_CONNECTION = Knex<any, unknown[]>;
+
+registerProvider({
+  token: OBJECTION_CONNECTION,
+  deps: [Configuration],
+  useAsyncFactory(configuration: Configuration) {
+    const connectionOptions = configuration.get<Knex.Config>("knex")!;
+
+    if (connectionOptions) {
+      try {
+        return createConnection(connectionOptions);
+      } catch (er) {
+        // istanbul ignore next
+        console.error(er);
+      }
+    }
+
+    return Promise.resolve({});
+  }
+});

package/src/utils/connect.ts

@@ -0,0 +1,9 @@
+import knex, {Knex} from "knex";
+import {Model} from "objection";
+
+export function createConnection(connectionOptions: Knex.Config): Knex {
+  const connection = knex(connectionOptions);
+  Model.knex(connection);
+
+  return connection;
+}

package/src/utils/createColumns.spec.ts

@@ -0,0 +1,79 @@
+import {catchError} from "@tsed/core";
+import {MaxLength, Property} from "@tsed/schema";
+
+import {createTableStub} from "../../test/helpers/knex/table.js";
+import {Decimal} from "../decorators/decimal.js";
+import {Entity} from "../decorators/entity.js";
+import {IdColumn} from "../decorators/idColumn.js";
+import {createColumns} from "./createColumns.js";
+
+describe("createTable", () => {
+  it("should create table from a given class (columns doesn't exists)", () => {
+    @Entity("users")
+    class User {
+      @IdColumn()
+      id: number;
+
+      @Property()
+      @MaxLength(200)
+      name: string;
+
+      @Property()
+      age: number;
+
+      @Decimal({scale: 1, precision: 12})
+      score: number;
+
+      @Property()
+      active: boolean;
+    }
+
+    const table = createTableStub();
+
+    createColumns(table, User);
+
+    expect(table.increments).toHaveBeenCalledWith("id");
+    expect(table.primary).toHaveBeenCalledWith();
+    expect(table.string).toHaveBeenCalledWith("name", 200);
+    expect(table.decimal).toHaveBeenCalledWith("age", undefined, undefined);
+    expect(table.decimal).toHaveBeenCalledWith("score", 12, 1);
+    expect(table.boolean).toHaveBeenCalledWith("active");
+  });
+  it("should create table from a given class (columns exists)", () => {
+    @Entity("users")
+    class User {
+      @IdColumn()
+      id: number;
+
+      @Property()
+      @MaxLength(200)
+      name: string;
+
+      @Property()
+      age: number;
+
+      @Decimal({scale: 1, precision: 12})
+      score: number;
+
+      @Property()
+      active: boolean;
+    }
+
+    const table = createTableStub();
+
+    createColumns(table, User);
+  });
+
+  it("should throw error when type isn't supported", () => {
+    @Entity("users")
+    class User {
+      @Property()
+      date: any;
+    }
+
+    const table = createTableStub();
+    const error = catchError(() => createColumns(table, User));
+
+    expect(error).toBe("Column type object isn't supported. Add function to ColumnTypesContainer to map the column with Knex");
+  });
+});

package/src/utils/createColumns.ts

@@ -0,0 +1,39 @@
+import "../components/createBooleanColumn.js";
+import "../components/createIdColumn.js";
+import "../components/createNumberColumn.js";
+import "../components/createStringColumn.js";
+
+import {getProperties, JsonEntityStore} from "@tsed/schema";
+import {Knex} from "knex";
+
+import {ColumnTypesContainer} from "../services/ColumnTypesContainer.js";
+import {getColumnCtx} from "./getColumnCtx.js";
+
+/**
+ * @ignore
+ */
+export function createColumn(table: Knex.TableBuilder, entity: JsonEntityStore) {
+  const ctx = getColumnCtx(entity);
+
+  if (!ColumnTypesContainer.has(ctx.columnType)) {
+    throw `Column type ${ctx.columnType} isn't supported. Add function to ColumnTypesContainer to map the column with Knex`;
+  }
+
+  ColumnTypesContainer.get(ctx.columnType)!(table, ctx);
+}
+
+/**
+ * @ignore
+ */
+export function getColumns(model: any) {
+  return [...getProperties(model, {withIgnoredProps: true, objection: true, groups: false}).values()];
+}
+
+/**
+ * @ignore
+ */
+export function createColumns(table: Knex.TableBuilder, model: any) {
+  getColumns(model).map((entity) => {
+    createColumn(table, entity);
+  });
+}

package/src/utils/createJoinKeys.ts

@@ -0,0 +1,38 @@
+import {Metadata} from "@tsed/core";
+import {Model, RelationType} from "objection";
+
+import {isRelationshipOptsWithThrough, RelationshipOpts} from "../domain/RelationshipOpts.js";
+
+/**
+ * @ignore
+ */
+export function createJoinKeys(targetClass: any, targetSuper: any, propertyKey: string, relation: RelationType, opts?: RelationshipOpts) {
+  const FOREIGN_MODEL = opts?.type || Metadata.getType(targetSuper, propertyKey);
+  const SOURCE_MODEL_KEY = `${targetClass.tableName}.${opts?.from || targetClass.idColumn}`;
+  const FOREIGN_MODEL_KEY = `${FOREIGN_MODEL.tableName}.${opts?.to || FOREIGN_MODEL.idColumn}`;
+
+  switch (relation) {
+    case Model.HasManyRelation:
+    case Model.HasOneRelation:
+      return {
+        from: SOURCE_MODEL_KEY,
+        to: `${FOREIGN_MODEL.tableName}.${opts?.to || targetClass.tableName + "Id"}`
+      };
+    case Model.ManyToManyRelation:
+    case Model.HasOneThroughRelation:
+      return {
+        from: SOURCE_MODEL_KEY,
+        through: (isRelationshipOptsWithThrough(opts) && opts.through) || {
+          from: `${targetClass.tableName}_${FOREIGN_MODEL.tableName}.${targetClass.tableName}Id`,
+          to: `${targetClass.tableName}_${FOREIGN_MODEL.tableName}.${FOREIGN_MODEL.tableName}Id`
+        },
+        to: FOREIGN_MODEL_KEY
+      };
+    case Model.BelongsToOneRelation:
+    default:
+      return {
+        from: `${targetClass.tableName}.${opts?.from || propertyKey + "Id"}`,
+        to: FOREIGN_MODEL_KEY
+      };
+  }
+}

package/src/utils/createRelationshipMapping.ts

@@ -0,0 +1,21 @@
+import {DecoratorParameters, getClass, Metadata} from "@tsed/core";
+import {RelationType} from "objection";
+
+import {RelationshipOpts} from "../domain/RelationshipOpts.js";
+import {createJoinKeys} from "./createJoinKeys.js";
+
+/**
+ * @ignore
+ */
+export function createRelationshipMapping([target, propertyKey]: DecoratorParameters, relation: RelationType, opts?: RelationshipOpts) {
+  return (targetClass: any) => ({
+    [propertyKey]: {
+      relation,
+      modelClass: opts?.type || Metadata.getType(target, propertyKey),
+      join: createJoinKeys(targetClass, target, String(propertyKey), relation, opts),
+      modify: opts?.modify,
+      filter: opts?.filter,
+      beforeInsert: opts?.beforeInsert
+    }
+  });
+}

package/src/utils/defineStaticGetter.ts

@@ -0,0 +1,10 @@
+import {classOf} from "@tsed/core";
+
+/**
+ * @ignore
+ */
+export function defineStaticGetter(target: any, propertyKey: string, fn: any) {
+  return Object.defineProperty(classOf(target), propertyKey, {
+    get: fn
+  });
+}

package/src/utils/getColumnCtx.ts

@@ -0,0 +1,21 @@
+import {JsonEntityStore} from "@tsed/schema";
+
+import {ColumnOpts} from "../domain/ColumnOpts.js";
+
+/**
+ * @ignore
+ */
+export interface ColumnCtx extends ColumnOpts {
+  entity: JsonEntityStore;
+  schema: any;
+}
+
+/**
+ * @ignore
+ */
+export function getColumnCtx(entity: JsonEntityStore): ColumnCtx {
+  const schema = entity.schema.toJSON();
+  const {columnType = schema.type, options = {}} = entity.store.get<Partial<ColumnOpts>>("objection", {});
+
+  return {entity, columnType, options, schema};
+}

package/src/utils/getJsonEntityRelationships.ts

@@ -0,0 +1,16 @@
+import {getColumns} from "./createColumns.js";
+
+/**
+ * @ignore
+ */
+export const OBJECTION_RELATIONSHIP_KEY = "objectionRelationship";
+
+/**
+ * @ignore
+ */
+export function getJsonEntityRelationships(target: any) {
+  return getColumns(target)
+    .filter((col) => col.store.get(OBJECTION_RELATIONSHIP_KEY))
+    .map((col) => col.store.get(OBJECTION_RELATIONSHIP_KEY)(target))
+    .reduce((dict, col) => ({...dict, ...col}), {});
+}