@tsed/objection 8.0.1 → 8.0.3

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}), {});
+}