@tsed/objection 8.11.1 → 8.12.0-rc.1

package/src/decorators/manyToMany.spec.ts

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

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

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

@@ -1,23 +0,0 @@
-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) => {
-      store.set(OBJECTION_RELATIONSHIP_KEY, createRelationshipMapping(params, relation, opts));
-    })
-  );
-}

package/src/domain/ColumnOpts.ts

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

package/src/domain/RelationshipOpts.ts

@@ -1,18 +0,0 @@
-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);
-
-export const isModelClassSpecifier = (specifierOrOther: unknown): specifierOrOther is ModelClassSpecifier => {
-  return !!specifierOrOther && (isString(specifierOrOther) || isFunction(specifierOrOther));
-};

package/src/domain/interfaces.ts

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

package/src/index.ts

@@ -1,29 +0,0 @@
-/**
- * @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

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

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

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

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

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

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

@@ -1,29 +0,0 @@
-import {DecoratorParameters, getClass, Metadata} from "@tsed/core";
-import {RelationType} from "objection";
-
-import {isModelClassFactory, RelationshipOpts} from "../domain/RelationshipOpts.js";
-import {createJoinKeys} from "./createJoinKeys.js";
-
-/**
- * @ignore
- */
-export function createRelationshipMapping([target, propertyKey]: DecoratorParameters, relation: RelationType, opts?: RelationshipOpts) {
-  return (targetClass: any) => {
-    opts = opts
-      ? {
-          ...opts,
-          type: isModelClassFactory(opts.type) ? opts.type() : opts.type
-        }
-      : undefined;
-    return {
-      [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

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

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

@@ -1,16 +0,0 @@
-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}), {});
-}

package/vitest.config.mts

@@ -1,21 +0,0 @@
-// @ts-ignore
-import {presets} from "@tsed/vitest/presets";
-import {defineConfig} from "vitest/config";
-
-export default defineConfig(
-  {
-    ...presets,
-    test: {
-      ...presets.test,
-      coverage: {
-        ...presets.test.coverage,
-        thresholds: {
-          statements: 0,
-          branches: 0,
-          functions: 0,
-          lines: 0
-        }
-      }
-    }
-  }
-);