@tsed/objection 8.0.1 → 8.0.3

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.3",
   "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.3",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
+    "@tsed/schema": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "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.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
+    "@tsed/schema": "8.0.3",
     "knex": ">=0.94.0",
     "objection": ">=2.0.0"
   },

package/readme.md

@@ -1,5 +1,5 @@
 <p style="text-align: center" align="center">
- <a href="https://tsed.io" target="_blank"><img src="https://tsed.io/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
 </p>
 
 <div align="center">
@@ -16,9 +16,9 @@
 </div>
 
 <div align="center">
-  <a href="https://tsed.io/">Website</a>
+  <a href="https://tsed.dev/">Website</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://tsed.io/getting-started/">Getting started</a>
+  <a href="https://tsed.dev/getting-started/">Getting started</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://api.tsed.io/rest/slack/tsedio/tsed">Slack</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
@@ -27,7 +27,7 @@
 
 <hr />
 
-A package of Ts.ED framework. See website: https://tsed.io/tutorials/objection.html
+A package of Ts.ED framework. See website: https://tsed.dev/tutorials/objection.html
 
 ## Feature
 
@@ -78,7 +78,7 @@ class Server {}
 
 ## Contributors
 
-Please read [contributing guidelines here](https://tsed.io/contributing.html)
+Please read [contributing guidelines here](https://tsed.dev/contributing.html)
 
 <a href="https://github.com/tsedio/tsed/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
 

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