dyna-record 0.0.1

package/dist/src/metadata/relationship-metadata/BelongsToRelationship.d.ts

@@ -0,0 +1,18 @@
+import type { ForeignKeyProperty } from "../../types";
+import RelationshipMetadata from "./RelationshipMetadata";
+/**
+ * Represents a "Belongs To" relationship metadata within the ORM system.
+ *
+ * @extends {RelationshipMetadata} Inherits the base functionality and properties of `RelationshipMetadata`.
+ * @property {"BelongsTo"} type - The type of the relationship, statically set to "BelongsTo" to signify the nature of the relationship.
+ * @property {ForeignKeyProperty} foreignKey - The attribute representing the foreign key in the relationship. This specifies the field in the entity that links to another entity, serving as the cornerstone for relationship queries and operations.
+ *
+ * @param {RelationshipMetadata} item - The initial relationship metadata to be copied into this "Belongs To" relationship instance. This allows for easy creation and setup of relationship metadata based on existing configurations.
+ */
+declare class BelongsToRelationship extends RelationshipMetadata {
+    type: "BelongsTo";
+    foreignKey: ForeignKeyProperty;
+    constructor(item: RelationshipMetadata);
+}
+export default BelongsToRelationship;
+//# sourceMappingURL=BelongsToRelationship.d.ts.map

package/dist/src/metadata/relationship-metadata/BelongsToRelationship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BelongsToRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/BelongsToRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAE1D;;;;;;;;GAQG;AACH,cAAM,qBAAsB,SAAQ,oBAAoB;IACtD,IAAI,EAAE,WAAW,CAAe;IAChC,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAMvC;AAED,eAAe,qBAAqB,CAAC"}

package/dist/src/metadata/relationship-metadata/BelongsToRelationship.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata"));
+/**
+ * Represents a "Belongs To" relationship metadata within the ORM system.
+ *
+ * @extends {RelationshipMetadata} Inherits the base functionality and properties of `RelationshipMetadata`.
+ * @property {"BelongsTo"} type - The type of the relationship, statically set to "BelongsTo" to signify the nature of the relationship.
+ * @property {ForeignKeyProperty} foreignKey - The attribute representing the foreign key in the relationship. This specifies the field in the entity that links to another entity, serving as the cornerstone for relationship queries and operations.
+ *
+ * @param {RelationshipMetadata} item - The initial relationship metadata to be copied into this "Belongs To" relationship instance. This allows for easy creation and setup of relationship metadata based on existing configurations.
+ */
+class BelongsToRelationship extends RelationshipMetadata_1.default {
+    type = "BelongsTo";
+    foreignKey;
+    constructor(item) {
+        super();
+        if (item !== undefined) {
+            Object.assign(this, item);
+        }
+    }
+}
+exports.default = BelongsToRelationship;

package/dist/src/metadata/relationship-metadata/HasAndBelongsToManyRelationship.d.ts

@@ -0,0 +1,16 @@
+import RelationshipMetadata from "./RelationshipMetadata";
+/**
+ * Represents the metadata for a "HasAndBelongsToMany" relationship metadata within the ORM system.
+ *
+ * @property {"HasAndBelongsToMany"} type - A literal string indicating the type of the relationship as "HasAndBelongsToMany". This helps in distinguishing between different types of relationships within the ORM.
+ * @property {string} joinTableName - The name of the join table used to facilitate the many-to-many relationship between entities. This table contains the foreign keys that link the related entities together.
+ *
+ * @param {RelationshipMetadata} item - An instance of `RelationshipMetadata` containing the initial settings for the relationship. This can include properties like `joinTableName`, which are specific to many-to-many relationships.
+ */
+declare class HasAndBelongsToManyRelationship extends RelationshipMetadata {
+    type: "HasAndBelongsToMany";
+    joinTableName: string;
+    constructor(item: RelationshipMetadata);
+}
+export default HasAndBelongsToManyRelationship;
+//# sourceMappingURL=HasAndBelongsToManyRelationship.d.ts.map

package/dist/src/metadata/relationship-metadata/HasAndBelongsToManyRelationship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasAndBelongsToManyRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/HasAndBelongsToManyRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAE1D;;;;;;;GAOG;AACH,cAAM,+BAAgC,SAAQ,oBAAoB;IAChE,IAAI,EAAE,qBAAqB,CAAyB;IACpD,aAAa,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,oBAAoB;CAMvC;AAED,eAAe,+BAA+B,CAAC"}

package/dist/src/metadata/relationship-metadata/HasAndBelongsToManyRelationship.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata"));
+/**
+ * Represents the metadata for a "HasAndBelongsToMany" relationship metadata within the ORM system.
+ *
+ * @property {"HasAndBelongsToMany"} type - A literal string indicating the type of the relationship as "HasAndBelongsToMany". This helps in distinguishing between different types of relationships within the ORM.
+ * @property {string} joinTableName - The name of the join table used to facilitate the many-to-many relationship between entities. This table contains the foreign keys that link the related entities together.
+ *
+ * @param {RelationshipMetadata} item - An instance of `RelationshipMetadata` containing the initial settings for the relationship. This can include properties like `joinTableName`, which are specific to many-to-many relationships.
+ */
+class HasAndBelongsToManyRelationship extends RelationshipMetadata_1.default {
+    type = "HasAndBelongsToMany";
+    joinTableName;
+    constructor(item) {
+        super();
+        if (item !== undefined) {
+            Object.assign(this, item);
+        }
+    }
+}
+exports.default = HasAndBelongsToManyRelationship;

package/dist/src/metadata/relationship-metadata/HasManyRelationship.d.ts

@@ -0,0 +1,18 @@
+import type { ForeignKeyProperty } from "../../types";
+import RelationshipMetadata from "./RelationshipMetadata";
+/**
+ * Extends `RelationshipMetadata` to specifically handle "HasMany" relationship metadata within the ORM system.
+ *
+ *
+ * @property {"HasMany"} type - A literal string that explicitly defines the type of relationship as "HasMany". This classification helps the ORM to apply the correct logic for relationship handling.
+ * @property {ForeignKeyProperty} foreignKey - The attribute in the associated entity that serves as a foreign key, linking back to the partition key of the owning entity. This key is essential for maintaining the integrity of the "HasMany" relationship.
+ *
+ * @param {RelationshipMetadata} item - An existing set of relationship metadata that should be applied to the newly created `HasManyRelationship` instance. This parameter allows for the inheritance and augmentation of relationship properties.
+ */
+declare class HasManyRelationship extends RelationshipMetadata {
+    type: "HasMany";
+    foreignKey: ForeignKeyProperty;
+    constructor(item: RelationshipMetadata);
+}
+export default HasManyRelationship;
+//# sourceMappingURL=HasManyRelationship.d.ts.map

package/dist/src/metadata/relationship-metadata/HasManyRelationship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasManyRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/HasManyRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAE1D;;;;;;;;GAQG;AACH,cAAM,mBAAoB,SAAQ,oBAAoB;IACpD,IAAI,EAAE,SAAS,CAAa;IAC5B,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAMvC;AAED,eAAe,mBAAmB,CAAC"}

package/dist/src/metadata/relationship-metadata/HasManyRelationship.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata"));
+/**
+ * Extends `RelationshipMetadata` to specifically handle "HasMany" relationship metadata within the ORM system.
+ *
+ *
+ * @property {"HasMany"} type - A literal string that explicitly defines the type of relationship as "HasMany". This classification helps the ORM to apply the correct logic for relationship handling.
+ * @property {ForeignKeyProperty} foreignKey - The attribute in the associated entity that serves as a foreign key, linking back to the partition key of the owning entity. This key is essential for maintaining the integrity of the "HasMany" relationship.
+ *
+ * @param {RelationshipMetadata} item - An existing set of relationship metadata that should be applied to the newly created `HasManyRelationship` instance. This parameter allows for the inheritance and augmentation of relationship properties.
+ */
+class HasManyRelationship extends RelationshipMetadata_1.default {
+    type = "HasMany";
+    foreignKey;
+    constructor(item) {
+        super();
+        if (item !== undefined) {
+            Object.assign(this, item);
+        }
+    }
+}
+exports.default = HasManyRelationship;

package/dist/src/metadata/relationship-metadata/HasOneRelationship.d.ts

@@ -0,0 +1,17 @@
+import type { ForeignKeyProperty } from "../../types";
+import RelationshipMetadata from "./RelationshipMetadata";
+/**
+ * Represents the metadata for a "HasOne" relationship metadata in the ORM system,
+ *
+ * @property {"HasOne"} type - A literal string identifying the type of relationship as "HasOne". This classification enables the ORM to apply appropriate handling logic specific to "HasOne" relationships.
+ * @property {ForeignKeyProperty} foreignKey - The attribute in the associated entity that functions as a foreign key, establishing a link back to the partition key of the owning entity. This key is vital for maintaining the relationship's integrity and navigability.
+ *
+ * @param {RelationshipMetadata} item - An instance of `RelationshipMetadata` containing the initial settings for the relationship. This can include the `foreignKey` and other properties relevant to establishing a "HasOne" relationship.
+ */
+declare class HasOneRelationship extends RelationshipMetadata {
+    type: "HasOne";
+    foreignKey: ForeignKeyProperty;
+    constructor(item: RelationshipMetadata);
+}
+export default HasOneRelationship;
+//# sourceMappingURL=HasOneRelationship.d.ts.map

package/dist/src/metadata/relationship-metadata/HasOneRelationship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasOneRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/HasOneRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAE1D;;;;;;;GAOG;AACH,cAAM,kBAAmB,SAAQ,oBAAoB;IACnD,IAAI,EAAE,QAAQ,CAAY;IAC1B,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAMvC;AAED,eAAe,kBAAkB,CAAC"}

package/dist/src/metadata/relationship-metadata/HasOneRelationship.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata"));
+/**
+ * Represents the metadata for a "HasOne" relationship metadata in the ORM system,
+ *
+ * @property {"HasOne"} type - A literal string identifying the type of relationship as "HasOne". This classification enables the ORM to apply appropriate handling logic specific to "HasOne" relationships.
+ * @property {ForeignKeyProperty} foreignKey - The attribute in the associated entity that functions as a foreign key, establishing a link back to the partition key of the owning entity. This key is vital for maintaining the relationship's integrity and navigability.
+ *
+ * @param {RelationshipMetadata} item - An instance of `RelationshipMetadata` containing the initial settings for the relationship. This can include the `foreignKey` and other properties relevant to establishing a "HasOne" relationship.
+ */
+class HasOneRelationship extends RelationshipMetadata_1.default {
+    type = "HasOne";
+    foreignKey;
+    constructor(item) {
+        super();
+        if (item !== undefined) {
+            Object.assign(this, item);
+        }
+    }
+}
+exports.default = HasOneRelationship;

package/dist/src/metadata/relationship-metadata/RelationshipMetadata.d.ts

@@ -0,0 +1,21 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass } from "../../types";
+type RelationshipType = "HasMany" | "BelongsTo" | "HasOne" | "HasAndBelongsToMany";
+/**
+ * Serves as the base class for defining metadata related to various types of relationships within the ORM system, such as "HasMany", "BelongsTo", "HasOne", and "HasAndBelongsToMany". This abstract class provides a common structure for relationship metadata, encapsulating the relationship type, target entity, and property name.
+ *
+ * Each subclass of `RelationshipMetadata` specifies a concrete type of relationship, leveraging this base class to ensure consistency and reusability across different relationship types. The metadata captured here is essential for the ORM to accurately manage and navigate relationships between entities, enabling operations like query construction, relationship traversal, and data integrity enforcement.
+ *
+ * @property {RelationshipType} type - An abstract property that must be defined by subclasses, indicating the specific type of relationship ("HasMany", "BelongsTo", "HasOne", "HasAndBelongsToMany").
+ * @property {EntityClass<DynaRecord>} target - The entity class that is the target of the relationship. This specifies the class of the entity on the "other side" of the relationship.
+ * @property {keyof DynaRecord} propertyName - The property name on the source entity that holds or references the related entity or entities. This name is used within the source entity's class definition to access the related entity.
+ *
+ * Note: This class is abstract and cannot be instantiated directly. Instead, it should be extended by specific relationship metadata classes that define concrete types of relationships.
+ */
+declare abstract class RelationshipMetadata {
+    abstract type: RelationshipType;
+    target: EntityClass<DynaRecord>;
+    propertyName: keyof DynaRecord;
+}
+export default RelationshipMetadata;
+//# sourceMappingURL=RelationshipMetadata.d.ts.map

package/dist/src/metadata/relationship-metadata/RelationshipMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelationshipMetadata.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/RelationshipMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,KAAK,gBAAgB,GACjB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,qBAAqB,CAAC;AAE1B;;;;;;;;;;GAUG;AACH,uBAAe,oBAAoB;IACjC,SAAgB,IAAI,EAAE,gBAAgB,CAAC;IAChC,MAAM,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,UAAU,CAAC;CACvC;AAED,eAAe,oBAAoB,CAAC"}

package/dist/src/metadata/relationship-metadata/RelationshipMetadata.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Serves as the base class for defining metadata related to various types of relationships within the ORM system, such as "HasMany", "BelongsTo", "HasOne", and "HasAndBelongsToMany". This abstract class provides a common structure for relationship metadata, encapsulating the relationship type, target entity, and property name.
+ *
+ * Each subclass of `RelationshipMetadata` specifies a concrete type of relationship, leveraging this base class to ensure consistency and reusability across different relationship types. The metadata captured here is essential for the ORM to accurately manage and navigate relationships between entities, enabling operations like query construction, relationship traversal, and data integrity enforcement.
+ *
+ * @property {RelationshipType} type - An abstract property that must be defined by subclasses, indicating the specific type of relationship ("HasMany", "BelongsTo", "HasOne", "HasAndBelongsToMany").
+ * @property {EntityClass<DynaRecord>} target - The entity class that is the target of the relationship. This specifies the class of the entity on the "other side" of the relationship.
+ * @property {keyof DynaRecord} propertyName - The property name on the source entity that holds or references the related entity or entities. This name is used within the source entity's class definition to access the related entity.
+ *
+ * Note: This class is abstract and cannot be instantiated directly. Instead, it should be extended by specific relationship metadata classes that define concrete types of relationships.
+ */
+class RelationshipMetadata {
+    target;
+    propertyName;
+}
+exports.default = RelationshipMetadata;

package/dist/src/metadata/relationship-metadata/index.d.ts

@@ -0,0 +1,7 @@
+import BelongsToRelationship from "./BelongsToRelationship";
+import HasAndBelongsToManyRelationship from "./HasAndBelongsToManyRelationship";
+import HasManyRelationship from "./HasManyRelationship";
+import HasOneRelationship from "./HasOneRelationship";
+export * from "./types";
+export { BelongsToRelationship, HasAndBelongsToManyRelationship, HasManyRelationship, HasOneRelationship };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/metadata/relationship-metadata/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/index.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,OAAO,+BAA+B,MAAM,mCAAmC,CAAC;AAChF,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,kBAAkB,MAAM,sBAAsB,CAAC;AAEtD,cAAc,SAAS,CAAC;AAExB,OAAO,EACL,qBAAqB,EACrB,+BAA+B,EAC/B,mBAAmB,EACnB,kBAAkB,EACnB,CAAC"}

package/dist/src/metadata/relationship-metadata/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.HasOneRelationship = exports.HasManyRelationship = exports.HasAndBelongsToManyRelationship = exports.BelongsToRelationship = void 0;
+const BelongsToRelationship_1 = __importDefault(require("./BelongsToRelationship"));
+exports.BelongsToRelationship = BelongsToRelationship_1.default;
+const HasAndBelongsToManyRelationship_1 = __importDefault(require("./HasAndBelongsToManyRelationship"));
+exports.HasAndBelongsToManyRelationship = HasAndBelongsToManyRelationship_1.default;
+const HasManyRelationship_1 = __importDefault(require("./HasManyRelationship"));
+exports.HasManyRelationship = HasManyRelationship_1.default;
+const HasOneRelationship_1 = __importDefault(require("./HasOneRelationship"));
+exports.HasOneRelationship = HasOneRelationship_1.default;
+__exportStar(require("./types"), exports);

package/dist/src/metadata/relationship-metadata/types.d.ts

@@ -0,0 +1,16 @@
+import type BelongsToRelationship from "./BelongsToRelationship";
+import type HasAndBelongsToManyRelationship from "./HasAndBelongsToManyRelationship";
+import type HasManyRelationship from "./HasManyRelationship";
+import type HasOneRelationship from "./HasOneRelationship";
+/**
+ * A union type that encompasses all possible relationship metadata classes within the ORM system. This type is used to represent the metadata for various types of relationships that can exist between entities, such as "BelongsTo", "HasMany", "HasOne", and "HasAndBelongsToMany" relationships.
+ *
+ * Each variant in the union corresponds to a specific relationship type, with its own set of properties and behaviors that define how entities are related to each other. This type enables the ORM to handle relationship metadata in a generic manner while still allowing for the specific characteristics of each relationship type to be accessed and utilized.
+ *
+ * - `BelongsToRelationship`: Represents a "BelongsTo" relationship, indicating that the entity has a foreign key pointing to another entity.
+ * - `HasManyRelationship`: Represents a "HasMany" relationship, indicating that the entity can be associated with multiple instances of another entity.
+ * - `HasOneRelationship`: Represents a "HasOne" relationship, indicating that the entity is associated with at most one instance of another entity.
+ * - `HasAndBelongsToManyRelationship`: Represents a "HasAndBelongsToMany" relationship, facilitated by a join table, indicating that the entity can have many-to-many associations with another entity.
+ */
+export type RelationshipMetadata = BelongsToRelationship | HasManyRelationship | HasOneRelationship | HasAndBelongsToManyRelationship;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/metadata/relationship-metadata/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,qBAAqB,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,+BAA+B,MAAM,mCAAmC,CAAC;AACrF,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,kBAAkB,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,GAC5B,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,GAClB,+BAA+B,CAAC"}

package/dist/src/metadata/relationship-metadata/types.js

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

package/dist/src/metadata/relationship-metadata/utils.d.ts

@@ -0,0 +1,3 @@
+import type { RelationshipMetadata } from "./types";
+export declare const createRelationshipInstance: (options: RelationshipMetadata) => RelationshipMetadata;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/metadata/relationship-metadata/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,0BAA0B,YAC5B,oBAAoB,KAC5B,oBAaF,CAAC"}

package/dist/src/metadata/relationship-metadata/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelationshipInstance = void 0;
+const BelongsToRelationship_1 = __importDefault(require("./BelongsToRelationship"));
+const HasAndBelongsToManyRelationship_1 = __importDefault(require("./HasAndBelongsToManyRelationship"));
+const HasManyRelationship_1 = __importDefault(require("./HasManyRelationship"));
+const HasOneRelationship_1 = __importDefault(require("./HasOneRelationship"));
+const createRelationshipInstance = (options) => {
+    switch (options.type) {
+        case "BelongsTo":
+            return new BelongsToRelationship_1.default(options);
+        case "HasAndBelongsToMany":
+            return new HasAndBelongsToManyRelationship_1.default(options);
+        case "HasMany":
+            return new HasManyRelationship_1.default(options);
+        case "HasOne":
+            return new HasOneRelationship_1.default(options);
+        default:
+            throw new Error("Invalid relationship type");
+    }
+};
+exports.createRelationshipInstance = createRelationshipInstance;

package/dist/src/metadata/types.d.ts

@@ -0,0 +1,90 @@
+import type { NativeScalarAttributeValue } from "@aws-sdk/util-dynamodb";
+import type { AttributeMetadata, EntityMetadata, JoinTableMetadata, RelationshipMetadata, TableMetadata } from ".";
+import type DynaRecord from "../DynaRecord";
+import type { BelongsToLink } from "../relationships";
+import type { MakeOptional } from "../types";
+/**
+ * Represents relationship metadata that includes a foreign key reference to another entity.
+ */
+export type RelationshipMetadataWithForeignKey = Extract<RelationshipMetadata, {
+    foreignKey: keyof DynaRecord;
+}>;
+/**
+ * A record mapping string keys to `AttributeMetadata`, used for storing metadata about entity attributes and looking up by entity attribute name.
+ */
+export type AttributeMetadataStorage = Record<string, AttributeMetadata>;
+/**
+ * A record mapping string keys to `RelationshipMetadata`, used for storing metadata about entity relationships and looking up by entity attribute name.
+ */
+export type RelationshipMetadataStorage = Record<string, RelationshipMetadata>;
+/**
+ * A record mapping string keys to `TableMetadata`, used for storing metadata about tables associated with entities and looking up table class name.
+ */
+export type TableMetadataStorage = Record<string, TableMetadata>;
+/**
+ * A record mapping string keys to `EntityMetadata`, used for storing metadata about entities and looking up by entity class name.
+ */
+export type EntityMetadataStorage = Record<string, EntityMetadata>;
+/**
+ * A record mapping string keys to an array of `JoinTableMetadata`, used for storing metadata about join tables in relationships and looking up by join table class name.
+ */
+export type JoinTableMetadataStorage = Record<string, JoinTableMetadata[]>;
+/**
+ * Specifies the default date fields commonly used in entities: `createdAt` and `updatedAt`.
+ */
+export type DefaultDateFields = "createdAt" | "updatedAt";
+/**
+ * Specifies the default fields used in entities, including fields from `DynaRecord` or `BelongsToLink`.
+ */
+export type DefaultFields = keyof DynaRecord | keyof BelongsToLink;
+/**
+ * Defines the structure for default fields within a table, mapping field names to their `AttributeMetadata` aliases.
+ */
+export type TableDefaultFields = Record<DefaultFields, Pick<AttributeMetadata, "alias">>;
+/**
+ * Options for configuring table metadata, including the table name, delimiter, and default fields.
+ */
+export type TableMetadataOptions = Pick<TableMetadata, "name" | "delimiter"> & {
+    defaultFields?: Partial<TableDefaultFields>;
+};
+/**
+ * Options for configuring keys in attribute metadata, making all properties except `nullable` optional, including `alias`.
+ */
+export type KeysAttributeMetadataOptions = MakeOptional<Omit<AttributeMetadataOptions, "nullable">, "alias">;
+/**
+ * Function that takes a attribute from a Dynamo table item, and serialize it to a non-Dynamo native type (EX: Date)
+ */
+export type EntitySerializer = (param: NativeScalarAttributeValue) => any;
+/**
+ * Function that takes a attribute from an Entity which is not a native Dynamo type and serializes it a type that is supported by Dynamo
+ */
+export type TableSerializer = (param: any) => NativeScalarAttributeValue;
+/**
+ * Functions for serializing attribute types that are not native to Dynamo from table item -> entity and entity -> table item
+ * EX: See DateAttribute decorator
+ */
+export interface Serializers {
+    /**
+     * Function to serialize a Dynamo table item attribute to Entity attribute. Used when the type defined on the entity is not a native type to Dynamo (EX: Date)
+     */
+    toEntityAttribute: EntitySerializer;
+    /**
+     * Function to serialize an Entity attribute to an attribute type that Dynamo supports. (EX: Date->string)
+     */
+    toTableAttribute: TableSerializer;
+}
+/**
+ * Defines the options for configuring attribute metadata within the ORM system. This interface specifies the settings used to describe and manage an attribute's representation and behavior in both the entity model and the underlying database schema, particularly focusing on attributes' names, aliases, nullability, and serialization strategies.
+ *
+ * @property {string} attributeName - The name of the attribute as defined in the entity. This is the primary identifier for the attribute within the ORM and is used in entity operations.
+ * @property {string} [alias] - An optional alias for the attribute that represents its name within the database. This is used for mapping the attribute to its corresponding column in the database table. If not specified, the `attributeName` is used as the column name.
+ * @property {boolean} nullable - Indicates whether the attribute is allowed to have null values. This property is crucial for enforcing data integrity and validation rules at the database level.
+ * @property {Serializers} [serializers] - Optional custom serialization strategies for the attribute. These strategies define how to convert the attribute's value between its representation in the entity and its representation in the database. This is particularly useful for handling complex data types or custom transformations.
+ */
+export interface AttributeMetadataOptions {
+    attributeName: string;
+    alias?: string;
+    nullable: boolean;
+    serializers?: Serializers;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/metadata/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/metadata/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACd,MAAM,GAAG,CAAC;AACX,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;GAEG;AACH,MAAM,MAAM,kCAAkC,GAAG,OAAO,CACtD,oBAAoB,EACpB;IAAE,UAAU,EAAE,MAAM,UAAU,CAAA;CAAE,CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,WAAW,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,UAAU,GAAG,MAAM,aAAa,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CACrC,aAAa,EACb,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,WAAW,CAAC,GAAG;IAC7E,aAAa,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAC7C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,YAAY,CACrD,IAAI,CAAC,wBAAwB,EAAE,UAAU,CAAC,EAC1C,OAAO,CACR,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,0BAA0B,KAAK,GAAG,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,0BAA0B,CAAC;AAEzE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,iBAAiB,EAAE,gBAAgB,CAAC;IACpC;;OAEG;IACH,gBAAgB,EAAE,eAAe,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B"}

package/dist/src/metadata/types.js

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

package/dist/src/metadata/utils.d.ts

@@ -0,0 +1,42 @@
+import type { RelationshipMetadata, HasManyRelationship, BelongsToRelationship, HasOneRelationship, HasAndBelongsToManyRelationship } from ".";
+import type DynaRecord from "../DynaRecord";
+import type { RelationshipMetadataWithForeignKey } from "./types";
+import type { EntityClass } from "../types";
+/**
+ * Type guard to check if the relationship is a HasMany
+ */
+export declare const isHasManyRelationship: (rel: RelationshipMetadata) => rel is HasManyRelationship;
+/**
+ * Type guard to check if the relationship is a BelongsTo
+ */
+export declare const isBelongsToRelationship: (rel: RelationshipMetadata) => rel is BelongsToRelationship;
+/**
+ * Type guard to check if the relationship is a HasOne
+ */
+export declare const isHasOneRelationship: (rel: RelationshipMetadata) => rel is HasOneRelationship;
+/**
+ * Type guard to check if the relationship is a HasOne
+ */
+export declare const isHasAndBelongsToManyRelationship: (rel: RelationshipMetadata) => rel is HasAndBelongsToManyRelationship;
+/**
+ * Type guard to check if the relationship metadata includes a foreignKey
+ * @param rel
+ * @returns
+ */
+export declare const isRelationshipMetadataWithForeignKey: (rel: RelationshipMetadata) => rel is RelationshipMetadataWithForeignKey;
+/**
+ * Returns true if an "Entity" BelongsTo the provided relationship as a HasOne
+ * @param Entity
+ * @param rel
+ * @returns
+ */
+export declare const doesEntityBelongToRelAsHasOne: <T extends DynaRecord>(Entity: EntityClass<T>, rel: BelongsToRelationship) => boolean;
+/**
+ * Returns true if an "Entity" BelongsTo the provided relationship as a HasMany
+ * @param Entity
+ * @param rel
+ * @param foreignKey
+ * @returns
+ */
+export declare const doesEntityBelongToRelAsHasMany: <T extends DynaRecord>(Entity: EntityClass<T>, rel: BelongsToRelationship) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/metadata/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/metadata/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,+BAA+B,EAChC,MAAM,GAAG,CAAC;AACX,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAC3B,oBAAoB,+BAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAC7B,oBAAoB,iCAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAC1B,oBAAoB,8BAG1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,QACvC,oBAAoB,2CAG1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,QAC1C,oBAAoB,8CAG1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,sDAEnC,qBAAqB,KACzB,OAMF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,sDAEpC,qBAAqB,KACzB,OAMF,CAAC"}

package/dist/src/metadata/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doesEntityBelongToRelAsHasMany = exports.doesEntityBelongToRelAsHasOne = exports.isRelationshipMetadataWithForeignKey = exports.isHasAndBelongsToManyRelationship = exports.isHasOneRelationship = exports.isBelongsToRelationship = exports.isHasManyRelationship = void 0;
+const _1 = __importDefault(require("./"));
+/**
+ * Type guard to check if the relationship is a HasMany
+ */
+const isHasManyRelationship = (rel) => {
+    return rel.type === "HasMany" && rel.foreignKey !== undefined;
+};
+exports.isHasManyRelationship = isHasManyRelationship;
+/**
+ * Type guard to check if the relationship is a BelongsTo
+ */
+const isBelongsToRelationship = (rel) => {
+    return rel.type === "BelongsTo" && rel.foreignKey !== undefined;
+};
+exports.isBelongsToRelationship = isBelongsToRelationship;
+/**
+ * Type guard to check if the relationship is a HasOne
+ */
+const isHasOneRelationship = (rel) => {
+    return rel.type === "HasOne" && rel.foreignKey !== undefined;
+};
+exports.isHasOneRelationship = isHasOneRelationship;
+/**
+ * Type guard to check if the relationship is a HasOne
+ */
+const isHasAndBelongsToManyRelationship = (rel) => {
+    return rel.type === "HasAndBelongsToMany" && rel.joinTableName !== undefined;
+};
+exports.isHasAndBelongsToManyRelationship = isHasAndBelongsToManyRelationship;
+/**
+ * Type guard to check if the relationship metadata includes a foreignKey
+ * @param rel
+ * @returns
+ */
+const isRelationshipMetadataWithForeignKey = (rel) => {
+    return "foreignKey" in rel;
+};
+exports.isRelationshipMetadataWithForeignKey = isRelationshipMetadataWithForeignKey;
+/**
+ * Returns true if an "Entity" BelongsTo the provided relationship as a HasOne
+ * @param Entity
+ * @param rel
+ * @returns
+ */
+const doesEntityBelongToRelAsHasOne = (Entity, rel) => {
+    const relMetadata = _1.default.getEntity(rel.target.name);
+    return Object.values(relMetadata.relationships).some(rel => (0, exports.isHasOneRelationship)(rel) && rel.target === Entity);
+};
+exports.doesEntityBelongToRelAsHasOne = doesEntityBelongToRelAsHasOne;
+/**
+ * Returns true if an "Entity" BelongsTo the provided relationship as a HasMany
+ * @param Entity
+ * @param rel
+ * @param foreignKey
+ * @returns
+ */
+const doesEntityBelongToRelAsHasMany = (Entity, rel) => {
+    const relMetadata = _1.default.getEntity(rel.target.name);
+    return Object.values(relMetadata.relationships).some(rel => (0, exports.isHasManyRelationship)(rel) && rel.target === Entity);
+};
+exports.doesEntityBelongToRelAsHasMany = doesEntityBelongToRelAsHasMany;

package/dist/src/operations/Create/Create.d.ts

@@ -0,0 +1,39 @@
+import type DynaRecord from "../../DynaRecord";
+import type { EntityClass } from "../../types";
+import OperationBase from "../OperationBase";
+import type { CreateOptions } from "./types";
+/**
+ * Represents the operation for creating a new entity in the database, including handling its attributes and any related entities' associations. It will handle de-normalizing data to support relationships
+ *
+ * It encapsulates the logic required to translate entity attributes to a format suitable for DynamoDB, execute the creation transaction, and manage any relationships defined by the entity, such as "BelongsTo" or "HasMany" links.
+ *
+ * @template T - The type of the entity being created, extending `DynaRecord`.
+ */
+declare class Create<T extends DynaRecord> extends OperationBase<T> {
+    #private;
+    constructor(Entity: EntityClass<T>);
+    /**
+     * Create an entity transaction, including relationship transactions (EX: Creating BelongsToLinks for HasMany, checking existence of relationships, etc)
+     * @param attributes
+     * @returns
+     */
+    run(attributes: CreateOptions<T>): Promise<T>;
+    /**
+     * Builds the entity attributes
+     * @param attributes
+     * @returns
+     */
+    private buildEntityData;
+    /**
+     * Build the transaction for the parent entity Create item request
+     * @param tableItem
+     */
+    private buildPutItemTransaction;
+    /**
+     * Build transaction items for associations
+     * @param entityData
+     */
+    private buildRelationshipTransactions;
+}
+export default Create;
+//# sourceMappingURL=Create.d.ts.map

package/dist/src/operations/Create/Create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Create.d.ts","sourceRoot":"","sources":["../../../../src/operations/Create/Create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,aAAa,CAAC;AAGhE,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;GAMG;AACH,cAAM,MAAM,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;;gBAG7C,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAKlC;;;;OAIG;IACU,GAAG,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAa1D;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAsBvB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;OAGG;YACW,6BAA6B;CAU5C;AAED,eAAe,MAAM,CAAC"}