dyna-record 0.0.1

package/dist/src/decorators/attributes/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateNullableAttribute = exports.DateAttribute = exports.NullableForeignKeyAttribute = exports.ForeignKeyAttribute = exports.SortKeyAttribute = exports.PartitionKeyAttribute = exports.NullableAttribute = exports.Attribute = void 0;
+var Attribute_1 = require("./Attribute");
+Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return __importDefault(Attribute_1).default; } });
+var NullableAttribute_1 = require("./NullableAttribute");
+Object.defineProperty(exports, "NullableAttribute", { enumerable: true, get: function () { return __importDefault(NullableAttribute_1).default; } });
+var PartitionKeyAttribute_1 = require("./PartitionKeyAttribute");
+Object.defineProperty(exports, "PartitionKeyAttribute", { enumerable: true, get: function () { return __importDefault(PartitionKeyAttribute_1).default; } });
+var SortKeyAttribute_1 = require("./SortKeyAttribute");
+Object.defineProperty(exports, "SortKeyAttribute", { enumerable: true, get: function () { return __importDefault(SortKeyAttribute_1).default; } });
+var ForeignKeyAttribute_1 = require("./ForeignKeyAttribute");
+Object.defineProperty(exports, "ForeignKeyAttribute", { enumerable: true, get: function () { return __importDefault(ForeignKeyAttribute_1).default; } });
+var NullableForeignKeyAttribute_1 = require("./NullableForeignKeyAttribute");
+Object.defineProperty(exports, "NullableForeignKeyAttribute", { enumerable: true, get: function () { return __importDefault(NullableForeignKeyAttribute_1).default; } });
+var DateAttribute_1 = require("./DateAttribute");
+Object.defineProperty(exports, "DateAttribute", { enumerable: true, get: function () { return __importDefault(DateAttribute_1).default; } });
+var DateNullableAttribute_1 = require("./DateNullableAttribute");
+Object.defineProperty(exports, "DateNullableAttribute", { enumerable: true, get: function () { return __importDefault(DateNullableAttribute_1).default; } });
+__exportStar(require("./serializers"), exports);

package/dist/src/decorators/attributes/serializers.d.ts

@@ -0,0 +1,13 @@
+import type { NativeScalarAttributeValue } from "@aws-sdk/util-dynamodb";
+/**
+ * Provides serialization and deserialization functions for date attributes when interfacing with a DynamoDB table, enabling the conversion between the table's string-based date representation and JavaScript's `Date` object. DynamoDb dos not support Date types naturally, this utility allows for Date attributes to be serialized to an entity and stored as ISO strings in Dynamo.
+ *
+ * - `toEntityAttribute`: Converts a DynamoDB attribute value to a JavaScript `Date` object.
+ * - `toTableAttribute`: Converts a JavaScript `Date` object to a string representation suitable for DynamoDB storage, specifically using the ISO 8601 format. This ensures that date information is stored in a consistent and queryable format within DynamoDB.
+ *
+ */
+export declare const dateSerializer: {
+    toEntityAttribute: (val: NativeScalarAttributeValue) => number | bigint | boolean | Date | import("@aws-sdk/util-dynamodb").NumberValue | ArrayBuffer | Blob | DataView | null | undefined;
+    toTableAttribute: (val: Date) => string;
+};
+//# sourceMappingURL=serializers.d.ts.map

package/dist/src/decorators/attributes/serializers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializers.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/serializers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;6BACA,0BAA0B;4BAM3B,IAAI;CAC7B,CAAC"}

package/dist/src/decorators/attributes/serializers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateSerializer = void 0;
+/**
+ * Provides serialization and deserialization functions for date attributes when interfacing with a DynamoDB table, enabling the conversion between the table's string-based date representation and JavaScript's `Date` object. DynamoDb dos not support Date types naturally, this utility allows for Date attributes to be serialized to an entity and stored as ISO strings in Dynamo.
+ *
+ * - `toEntityAttribute`: Converts a DynamoDB attribute value to a JavaScript `Date` object.
+ * - `toTableAttribute`: Converts a JavaScript `Date` object to a string representation suitable for DynamoDB storage, specifically using the ISO 8601 format. This ensures that date information is stored in a consistent and queryable format within DynamoDB.
+ *
+ */
+exports.dateSerializer = {
+    toEntityAttribute: (val) => {
+        if (typeof val === "string") {
+            return new Date(val);
+        }
+        return val;
+    },
+    toTableAttribute: (val) => val.toISOString()
+};

package/dist/src/decorators/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Entity } from "./Entity";
+export { default as Table } from "./Table";
+export * from "./relationships";
+export * from "./attributes";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/src/decorators/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = exports.Entity = void 0;
+var Entity_1 = require("./Entity");
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return __importDefault(Entity_1).default; } });
+var Table_1 = require("./Table");
+Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return __importDefault(Table_1).default; } });
+__exportStar(require("./relationships"), exports);
+__exportStar(require("./attributes"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/decorators/relationships/BelongsTo.d.ts

@@ -0,0 +1,34 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass } from "../../types";
+import type { BelongsToField, BelongsToProps } from "./types";
+/**
+ * A decorator for defining a "BelongsTo" relationship between entities in a single-table design using DynaRecord. This relationship indicates that the decorated field is a reference to another entity, effectively establishing a parent-child linkage. The decorator dynamically enforces the presence or optionality of this reference based on the nature of the foreign key, enhancing type safety and relationship integrity within the ORM model.
+ *
+ * The decorator must reference a foreign key defined on the model.
+ *
+ * IMPORTANT - If referenced through a {@link NullableForeignKey} then set the belongs to attribute to optional.
+ *
+ * The decorator takes into consideration whether the relationship is defined by a `NullableForeignKey`, allowing the field to be optional if so, otherwise ensuring it is not optional. This behavior aligns with relational database design principles, where a foreign key can either strictly enforce a relationship or allow for its absence.
+ *
+ * @template T The source entity type, from which the relationship originates.
+ * @template K The target entity type, to which the relationship points.
+ * @template FK The type of the foreign key attribute within the source entity, used to establish the relationship. Must be defined on the model.
+ * @param getTarget A function returning the class (constructor function) of the target entity. This enables late binding and avoids circular dependency issues.
+ * @param props Configuration object for the relationship, including the name of the foreign key attribute.
+ * @returns A class field decorator function that initializes the source entity's class prototype, registering the relationship with the ORM's metadata system. This registration process includes specifying the relationship type as "BelongsTo", along with detailing the target entity and foreign key.
+ *
+ * Usage example:
+ * ```typescript
+ * class Order extends BaseEntity {
+ *   @ForeignKeyProperty({ alias: "UserId" })
+ *   public readonly userId: ForeignKey;
+ *
+ *   @BelongsTo(() => User, { foreignKey: 'userId' })
+ *   public user: User;
+ * }
+ * ```
+ * In this example, `@BelongsTo` decorates the `user` field of the `Order` entity, establishing a "BelongsTo" relationship with the `User` entity via the `userId` foreign key. This decoration signifies that each `Order` instance is related to a specific `User` instance.
+ */
+declare function BelongsTo<T extends DynaRecord, K extends DynaRecord>(getTarget: () => EntityClass<K>, props: BelongsToProps<T>): (_value: undefined, context: ClassFieldDecoratorContext<T, BelongsToField<T, K, typeof props.foreignKey>>) => void;
+export default BelongsTo;
+//# sourceMappingURL=BelongsTo.d.ts.map

package/dist/src/decorators/relationships/BelongsTo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BelongsTo.d.ts","sourceRoot":"","sources":["../../../../src/decorators/relationships/BelongsTo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iBAAS,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EAC3D,SAAS,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,EAC/B,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,YAGd,SAAS,WACR,2BACP,CAAC,EACD,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,MAAM,UAAU,CAAC,CAC9C,UAeJ;AAED,eAAe,SAAS,CAAC"}

package/dist/src/decorators/relationships/BelongsTo.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = __importDefault(require("../../metadata"));
+/**
+ * A decorator for defining a "BelongsTo" relationship between entities in a single-table design using DynaRecord. This relationship indicates that the decorated field is a reference to another entity, effectively establishing a parent-child linkage. The decorator dynamically enforces the presence or optionality of this reference based on the nature of the foreign key, enhancing type safety and relationship integrity within the ORM model.
+ *
+ * The decorator must reference a foreign key defined on the model.
+ *
+ * IMPORTANT - If referenced through a {@link NullableForeignKey} then set the belongs to attribute to optional.
+ *
+ * The decorator takes into consideration whether the relationship is defined by a `NullableForeignKey`, allowing the field to be optional if so, otherwise ensuring it is not optional. This behavior aligns with relational database design principles, where a foreign key can either strictly enforce a relationship or allow for its absence.
+ *
+ * @template T The source entity type, from which the relationship originates.
+ * @template K The target entity type, to which the relationship points.
+ * @template FK The type of the foreign key attribute within the source entity, used to establish the relationship. Must be defined on the model.
+ * @param getTarget A function returning the class (constructor function) of the target entity. This enables late binding and avoids circular dependency issues.
+ * @param props Configuration object for the relationship, including the name of the foreign key attribute.
+ * @returns A class field decorator function that initializes the source entity's class prototype, registering the relationship with the ORM's metadata system. This registration process includes specifying the relationship type as "BelongsTo", along with detailing the target entity and foreign key.
+ *
+ * Usage example:
+ * ```typescript
+ * class Order extends BaseEntity {
+ *   @ForeignKeyProperty({ alias: "UserId" })
+ *   public readonly userId: ForeignKey;
+ *
+ *   @BelongsTo(() => User, { foreignKey: 'userId' })
+ *   public user: User;
+ * }
+ * ```
+ * In this example, `@BelongsTo` decorates the `user` field of the `Order` entity, establishing a "BelongsTo" relationship with the `User` entity via the `userId` foreign key. This decoration signifies that each `Order` instance is related to a specific `User` instance.
+ */
+function BelongsTo(getTarget, props) {
+    return function (_value, context) {
+        if (context.kind === "field") {
+            context.addInitializer(function () {
+                const entity = Object.getPrototypeOf(this);
+                metadata_1.default.addEntityRelationship(entity.constructor.name, {
+                    type: "BelongsTo",
+                    propertyName: context.name,
+                    target: getTarget(),
+                    foreignKey: props.foreignKey
+                });
+            });
+        }
+    };
+}
+exports.default = BelongsTo;

package/dist/src/decorators/relationships/HasAndBelongsToMany.d.ts

@@ -0,0 +1,80 @@
+import { type JoinTable } from "../../relationships";
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass } from "../../types";
+/**
+ * The key on the related Entity which is associated with this Entity
+ */
+type TargetKey<T, U> = {
+    [K in keyof T]: T[K] extends U[] ? K : never;
+}[keyof T];
+/**
+ * Represents a function returning metadata for a join table.
+ * @template J The type of the join table.
+ */
+type ThroughFunction<J extends JoinTable<DynaRecord, DynaRecord>> = () => {
+    /**
+     * The constructor function for the join table.
+     * @param {...any[]} args Constructor arguments for the join table.
+     * @returns {J} An instance of the join table.
+     */
+    joinTable: new (...args: any[]) => J;
+    /**
+     * The key representing the foreign key property of the join table.
+     */
+    foreignKey: keyof J;
+};
+interface HasAndBelongsToManyProps<T extends DynaRecord, K extends DynaRecord, J extends JoinTable<T, K>, L extends JoinTable<K, T>> {
+    /**
+     * The key of the model to add an association to.
+     */
+    targetKey: TargetKey<T, K>;
+    /**
+     * The JoinTable properties this relationship is associated through
+     */
+    through: ThroughFunction<J> | ThroughFunction<L>;
+}
+/**
+ * A decorator for defining a many-to-many relationship between entities in a single-table design ORM system. This relationship is facilitated through a join table, representing the connection between the two entities. The decorator simplifies the management of such relationships by automating the setup and handling of the join table metadata, thereby enabling seamless querying and manipulation of related entities.
+ *
+ * @template T The source entity class the decorator is applied to.
+ * @template K The target entity class that T has a many-to-many relationship with.
+ * @template J The join table entity class that associates T with K.
+ * @template L The join table entity class that associates K with T, allowing for bidirectional relationships.
+ * @param getTarget A function that returns the constructor of the target entity class. This enables lazy evaluation and avoids circular dependency issues.
+ * @param props Configuration options for the many-to-many relationship, including the key on the related entity and the details of the join table (through a "through" function) that facilitates the relationship.
+ * @returns A class field decorator function that, when applied to a field, registers the many-to-many relationship in the ORM's metadata system. This registration includes information about the join table and the relationship's configuration, essential for the ORM to handle related entities correctly.
+ *
+ * Usage example:
+ * ```typescript
+ * class User extends BaseEntity {
+ *   @HasAndBelongsToMany(() => Group, {
+ *     targetKey: 'users',
+ *     through: () => ({
+ *       joinTable: UserGroup,
+ *       foreignKey: 'userId'
+ *     })
+ *   })
+ *   public groups: Group[];
+ * }
+ *
+ * class Group extends BaseEntity {
+ *   @HasAndBelongsToMany(() => User, {
+ *     targetKey: 'groups',
+ *     through: () => ({
+ *       joinTable: UserGroup,
+ *       foreignKey: 'groupId'
+ *     })
+ *   })
+ *   public users: User[];
+ * }
+ *
+ * class AuthorBook extends JoinTable<User, Group> {
+ *    public readonly userId: ForeignKey;
+ *    public readonly groupId: ForeignKey;
+ * }
+ * ```
+ * In this example, `User` entities are related to `Group` entities through a many-to-many relationship, with `UserGroupJoin` serving as the join table. The decorator indicates this relationship, allowing for efficient querying and manipulation of related entities.
+ */
+declare function HasAndBelongsToMany<T extends DynaRecord, K extends DynaRecord, J extends JoinTable<T, K>, L extends JoinTable<K, T>>(getTarget: () => EntityClass<T>, props: HasAndBelongsToManyProps<T, K, J, L>): (_value: undefined, context: ClassFieldDecoratorContext<K, T[]>) => void;
+export default HasAndBelongsToMany;
+//# sourceMappingURL=HasAndBelongsToMany.d.ts.map

package/dist/src/decorators/relationships/HasAndBelongsToMany.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasAndBelongsToMany.d.ts","sourceRoot":"","sources":["../../../../src/decorators/relationships/HasAndBelongsToMany.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;GAEG;AACH,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI;KACpB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK;CAC7C,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;;GAGG;AACH,KAAK,eAAe,CAAC,CAAC,SAAS,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,IAAI,MAAM;IACxE;;;;OAIG;IACH,SAAS,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACrC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC,CAAC;CACrB,CAAC;AAEF,UAAU,wBAAwB,CAChC,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,CAAC,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IAEzB;;OAEG;IACH,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3B;;OAEG;IACH,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,iBAAS,mBAAmB,CAC1B,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EACzB,CAAC,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAEzB,SAAS,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,EAC/B,KAAK,EAAE,wBAAwB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,YAE3B,SAAS,WAAW,2BAA2B,CAAC,EAAE,CAAC,EAAE,CAAC,UAqBvE;AAED,eAAe,mBAAmB,CAAC"}

package/dist/src/decorators/relationships/HasAndBelongsToMany.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = __importDefault(require("../../metadata"));
+/**
+ * A decorator for defining a many-to-many relationship between entities in a single-table design ORM system. This relationship is facilitated through a join table, representing the connection between the two entities. The decorator simplifies the management of such relationships by automating the setup and handling of the join table metadata, thereby enabling seamless querying and manipulation of related entities.
+ *
+ * @template T The source entity class the decorator is applied to.
+ * @template K The target entity class that T has a many-to-many relationship with.
+ * @template J The join table entity class that associates T with K.
+ * @template L The join table entity class that associates K with T, allowing for bidirectional relationships.
+ * @param getTarget A function that returns the constructor of the target entity class. This enables lazy evaluation and avoids circular dependency issues.
+ * @param props Configuration options for the many-to-many relationship, including the key on the related entity and the details of the join table (through a "through" function) that facilitates the relationship.
+ * @returns A class field decorator function that, when applied to a field, registers the many-to-many relationship in the ORM's metadata system. This registration includes information about the join table and the relationship's configuration, essential for the ORM to handle related entities correctly.
+ *
+ * Usage example:
+ * ```typescript
+ * class User extends BaseEntity {
+ *   @HasAndBelongsToMany(() => Group, {
+ *     targetKey: 'users',
+ *     through: () => ({
+ *       joinTable: UserGroup,
+ *       foreignKey: 'userId'
+ *     })
+ *   })
+ *   public groups: Group[];
+ * }
+ *
+ * class Group extends BaseEntity {
+ *   @HasAndBelongsToMany(() => User, {
+ *     targetKey: 'groups',
+ *     through: () => ({
+ *       joinTable: UserGroup,
+ *       foreignKey: 'groupId'
+ *     })
+ *   })
+ *   public users: User[];
+ * }
+ *
+ * class AuthorBook extends JoinTable<User, Group> {
+ *    public readonly userId: ForeignKey;
+ *    public readonly groupId: ForeignKey;
+ * }
+ * ```
+ * In this example, `User` entities are related to `Group` entities through a many-to-many relationship, with `UserGroupJoin` serving as the join table. The decorator indicates this relationship, allowing for efficient querying and manipulation of related entities.
+ */
+function HasAndBelongsToMany(getTarget, props) {
+    return (_value, context) => {
+        if (context.kind === "field") {
+            context.addInitializer(function () {
+                const entity = Object.getPrototypeOf(this);
+                const target = getTarget();
+                const { joinTable, foreignKey } = props.through();
+                metadata_1.default.addEntityRelationship(entity.constructor.name, {
+                    type: "HasAndBelongsToMany",
+                    propertyName: context.name,
+                    target,
+                    joinTableName: joinTable.name
+                });
+                metadata_1.default.addJoinTable(joinTable.name, {
+                    entity: target,
+                    foreignKey: foreignKey
+                });
+            });
+        }
+    };
+}
+exports.default = HasAndBelongsToMany;

package/dist/src/decorators/relationships/HasMany.d.ts

@@ -0,0 +1,35 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass } from "../../types";
+import { type ForeignEntityAttribute } from "../types";
+interface HasManyProps<T extends DynaRecord> {
+    foreignKey: ForeignEntityAttribute<T>;
+}
+/**
+ * A decorator for establishing a one-to-many relationship between entities in a single-table design ORM system. This relationship indicates that a single instance of the entity where this decorator is applied can be associated with multiple instances of another entity. The decorator facilitates the definition and management of such relationships by automatically handling the necessary metadata registration, thereby simplifying the implementation of relational data models.
+ *
+ * @template T The source entity class that has many instances of another entity. This is the entity class to which the decorator is applied.
+ * @template K The target entity class that is related to `T` through a one-to-many relationship.
+ * @param getTarget A function that returns the constructor of the target entity class `T`. This function is crucial for establishing the relationship dynamically and avoids issues related to circular dependencies.
+ * @param props Configuration options for the one-to-many relationship, specifically the foreign key in the target entity that links back to the source entity. This configuration ensures the correct association and navigation between related entities.
+ * @returns A class field decorator function that, when applied to a field of type array of `T`, registers the one-to-many relationship in the ORM's metadata system. This registration is essential for the ORM to recognize and correctly handle the relationship between the source and target entities, facilitating operations such as retrieval and update of related entities.
+ *
+ * Usage example:
+ * ```typescript
+ * class User extends BaseEntity {
+ *   @HasMany(() => Post, { foreignKey: 'userId' })
+ *   public posts: Post[];
+ * }
+ *
+ * class Post extends BaseEntity {
+ *   @ForeignKeyProperty()
+ *   public readonly userId: ForeignKey;
+ *
+ *   @BelongsTo(() => User, { foreignKey: "userId" })
+ *   public readonly user: User;
+ * }
+ * ```
+ * In this example, each `User` entity is associated with multiple `Post` entities through a one-to-many relationship. The `@HasMany` decorator is applied to the `posts` field of the `User` class, indicating that a user can have many posts. The `foreignKey` property specifies the attribute in the `Post` entity that establishes the connection back to the `User` entity, enabling the ORM to manage the relationship effectively.
+ */
+declare function HasMany<T extends DynaRecord, K extends DynaRecord>(getTarget: () => EntityClass<T>, props: HasManyProps<T>): (_value: undefined, context: ClassFieldDecoratorContext<K, T[]>) => void;
+export default HasMany;
+//# sourceMappingURL=HasMany.d.ts.map

package/dist/src/decorators/relationships/HasMany.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasMany.d.ts","sourceRoot":"","sources":["../../../../src/decorators/relationships/HasMany.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,UAAU,YAAY,CAAC,CAAC,SAAS,UAAU;IACzC,UAAU,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,OAAO,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EACzD,SAAS,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,EAC/B,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,YAEN,SAAS,WAAW,2BAA2B,CAAC,EAAE,CAAC,EAAE,CAAC,UAcvE;AAED,eAAe,OAAO,CAAC"}

package/dist/src/decorators/relationships/HasMany.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = __importDefault(require("../../metadata"));
+/**
+ * A decorator for establishing a one-to-many relationship between entities in a single-table design ORM system. This relationship indicates that a single instance of the entity where this decorator is applied can be associated with multiple instances of another entity. The decorator facilitates the definition and management of such relationships by automatically handling the necessary metadata registration, thereby simplifying the implementation of relational data models.
+ *
+ * @template T The source entity class that has many instances of another entity. This is the entity class to which the decorator is applied.
+ * @template K The target entity class that is related to `T` through a one-to-many relationship.
+ * @param getTarget A function that returns the constructor of the target entity class `T`. This function is crucial for establishing the relationship dynamically and avoids issues related to circular dependencies.
+ * @param props Configuration options for the one-to-many relationship, specifically the foreign key in the target entity that links back to the source entity. This configuration ensures the correct association and navigation between related entities.
+ * @returns A class field decorator function that, when applied to a field of type array of `T`, registers the one-to-many relationship in the ORM's metadata system. This registration is essential for the ORM to recognize and correctly handle the relationship between the source and target entities, facilitating operations such as retrieval and update of related entities.
+ *
+ * Usage example:
+ * ```typescript
+ * class User extends BaseEntity {
+ *   @HasMany(() => Post, { foreignKey: 'userId' })
+ *   public posts: Post[];
+ * }
+ *
+ * class Post extends BaseEntity {
+ *   @ForeignKeyProperty()
+ *   public readonly userId: ForeignKey;
+ *
+ *   @BelongsTo(() => User, { foreignKey: "userId" })
+ *   public readonly user: User;
+ * }
+ * ```
+ * In this example, each `User` entity is associated with multiple `Post` entities through a one-to-many relationship. The `@HasMany` decorator is applied to the `posts` field of the `User` class, indicating that a user can have many posts. The `foreignKey` property specifies the attribute in the `Post` entity that establishes the connection back to the `User` entity, enabling the ORM to manage the relationship effectively.
+ */
+function HasMany(getTarget, props) {
+    return (_value, context) => {
+        if (context.kind === "field") {
+            context.addInitializer(function () {
+                const entity = Object.getPrototypeOf(this);
+                metadata_1.default.addEntityRelationship(entity.constructor.name, {
+                    type: "HasMany",
+                    propertyName: context.name,
+                    target: getTarget(),
+                    foreignKey: props.foreignKey
+                });
+            });
+        }
+    };
+}
+exports.default = HasMany;

package/dist/src/decorators/relationships/HasOne.d.ts

@@ -0,0 +1,35 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass, Optional } from "../../types";
+import { type ForeignEntityAttribute } from "../types";
+interface HasOneProps<T extends DynaRecord> {
+    foreignKey: ForeignEntityAttribute<T> & keyof T;
+}
+/**
+ * A decorator for defining a one-to-one relationship between entities in a single-table design ORM system. This relationship implies that an instance of the entity to which this decorator is applied can be associated with at most one instance of another entity. The `HasOne` decorator plays a crucial role in establishing and managing such relationships by automatically registering the necessary metadata, thereby enabling the ORM to recognize and navigate these associations effectively.
+ *
+ * @template T The source entity class that has a one-to-one relationship with another entity. This is the class on which the decorator is applied.
+ * @template K The target entity class that is related to `T` in a one-to-one relationship.
+ * @param getTarget A function returning the constructor of the target entity class `T`. This function is essential for dynamically establishing the relationship, helping to circumvent circular dependency issues.
+ * @param props Configuration options for the one-to-one relationship, particularly the foreign key within the target entity that links it back to the source entity. This setup is critical for accurately linking and managing the entities involved.
+ * @returns A class field decorator function that, when applied to a field, registers the one-to-one relationship in the ORM's metadata system. The registration includes the target entity and the specified foreign key, ensuring that the ORM correctly interprets and maintains the relationship.
+ *
+ * Usage example:
+ * ```typescript
+ * class User extends BaseEntity {
+ *   @HasOne(() => Profile, { foreignKey: 'userId' })
+ *   public profile?: Profile;
+ * }
+ *
+ * class Profile extends BaseEntity {
+ *   @ForeignKeyProperty()
+ *   public readonly userId: ForeignKey;
+ *
+ *   @BelongsTo(() => User, { foreignKey: "userId" })
+ *   public readonly user: User;
+ * }
+ * ```
+ * Here, the `@HasOne` decorator is applied to the `profile` field of the `User` class, establishing a one-to-one relationship between a `User` and a `Profile`. The foreign key (`userId`) in the `Profile` entity points back to the `User` entity, enabling the ORM to manage this relationship by linking a user to at most one profile.
+ */
+declare function HasOne<T extends DynaRecord, K extends DynaRecord>(getTarget: () => EntityClass<T>, props: HasOneProps<T>): (_value: undefined, context: ClassFieldDecoratorContext<K, Optional<T>>) => void;
+export default HasOne;
+//# sourceMappingURL=HasOne.d.ts.map

package/dist/src/decorators/relationships/HasOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasOne.d.ts","sourceRoot":"","sources":["../../../../src/decorators/relationships/HasOne.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAsB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,UAAU,WAAW,CAAC,CAAC,SAAS,UAAU;IACxC,UAAU,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,UAAU,EACxD,SAAS,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC,EAC/B,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,YAGX,SAAS,WACR,2BAA2B,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,UAetD;AAED,eAAe,MAAM,CAAC"}

package/dist/src/decorators/relationships/HasOne.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = __importDefault(require("../../metadata"));
+/**
+ * A decorator for defining a one-to-one relationship between entities in a single-table design ORM system. This relationship implies that an instance of the entity to which this decorator is applied can be associated with at most one instance of another entity. The `HasOne` decorator plays a crucial role in establishing and managing such relationships by automatically registering the necessary metadata, thereby enabling the ORM to recognize and navigate these associations effectively.
+ *
+ * @template T The source entity class that has a one-to-one relationship with another entity. This is the class on which the decorator is applied.
+ * @template K The target entity class that is related to `T` in a one-to-one relationship.
+ * @param getTarget A function returning the constructor of the target entity class `T`. This function is essential for dynamically establishing the relationship, helping to circumvent circular dependency issues.
+ * @param props Configuration options for the one-to-one relationship, particularly the foreign key within the target entity that links it back to the source entity. This setup is critical for accurately linking and managing the entities involved.
+ * @returns A class field decorator function that, when applied to a field, registers the one-to-one relationship in the ORM's metadata system. The registration includes the target entity and the specified foreign key, ensuring that the ORM correctly interprets and maintains the relationship.
+ *
+ * Usage example:
+ * ```typescript
+ * class User extends BaseEntity {
+ *   @HasOne(() => Profile, { foreignKey: 'userId' })
+ *   public profile?: Profile;
+ * }
+ *
+ * class Profile extends BaseEntity {
+ *   @ForeignKeyProperty()
+ *   public readonly userId: ForeignKey;
+ *
+ *   @BelongsTo(() => User, { foreignKey: "userId" })
+ *   public readonly user: User;
+ * }
+ * ```
+ * Here, the `@HasOne` decorator is applied to the `profile` field of the `User` class, establishing a one-to-one relationship between a `User` and a `Profile`. The foreign key (`userId`) in the `Profile` entity points back to the `User` entity, enabling the ORM to manage this relationship by linking a user to at most one profile.
+ */
+function HasOne(getTarget, props) {
+    return function (_value, context) {
+        if (context.kind === "field") {
+            context.addInitializer(function () {
+                const entity = Object.getPrototypeOf(this);
+                metadata_1.default.addEntityRelationship(entity.constructor.name, {
+                    type: "HasOne",
+                    propertyName: context.name,
+                    target: getTarget(),
+                    foreignKey: props.foreignKey
+                });
+            });
+        }
+    };
+}
+exports.default = HasOne;

package/dist/src/decorators/relationships/index.d.ts

@@ -0,0 +1,6 @@
+export { default as HasMany } from "./HasMany";
+export { default as HasOne } from "./HasOne";
+export { default as BelongsTo } from "./BelongsTo";
+export { default as HasAndBelongsToMany } from "./HasAndBelongsToMany";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/decorators/relationships/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/decorators/relationships/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,cAAc,SAAS,CAAC"}

package/dist/src/decorators/relationships/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasAndBelongsToMany = exports.BelongsTo = exports.HasOne = exports.HasMany = void 0;
+var HasMany_1 = require("./HasMany");
+Object.defineProperty(exports, "HasMany", { enumerable: true, get: function () { return __importDefault(HasMany_1).default; } });
+var HasOne_1 = require("./HasOne");
+Object.defineProperty(exports, "HasOne", { enumerable: true, get: function () { return __importDefault(HasOne_1).default; } });
+var BelongsTo_1 = require("./BelongsTo");
+Object.defineProperty(exports, "BelongsTo", { enumerable: true, get: function () { return __importDefault(BelongsTo_1).default; } });
+var HasAndBelongsToMany_1 = require("./HasAndBelongsToMany");
+Object.defineProperty(exports, "HasAndBelongsToMany", { enumerable: true, get: function () { return __importDefault(HasAndBelongsToMany_1).default; } });
+__exportStar(require("./types"), exports);

package/dist/src/decorators/relationships/types.d.ts

@@ -0,0 +1,11 @@
+import type DynaRecord from "../../DynaRecord";
+import type { NullableForeignKey, Optional } from "../../types";
+import type { ForeignEntityAttribute } from "../types";
+export interface BelongsToProps<T extends DynaRecord> {
+    foreignKey: ForeignEntityAttribute<T>;
+}
+/**
+ * If the relationship is linked by a NullableForeignKey then it allows the field to be optional, otherwise it ensures that is is not optional
+ */
+export type BelongsToField<T extends DynaRecord, K extends DynaRecord, FK extends ForeignEntityAttribute<T>> = FK extends keyof T ? T[FK] extends NullableForeignKey ? Optional<K> : K : never;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/decorators/relationships/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/decorators/relationships/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,UAAU;IAClD,UAAU,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,EACpB,EAAE,SAAS,sBAAsB,CAAC,CAAC,CAAC,IAClC,EAAE,SAAS,MAAM,CAAC,GAClB,CAAC,CAAC,EAAE,CAAC,SAAS,kBAAkB,GAC9B,QAAQ,CAAC,CAAC,CAAC,GACX,CAAC,GACH,KAAK,CAAC"}

package/dist/src/decorators/relationships/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });