dyna-record 0.6.7 → 0.7.1

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

@@ -1,5 +1,5 @@
-import type { ForeignKeyProperty } from "../../types";
-import RelationshipMetadata from "./RelationshipMetadata";
+import type { ForeignKeyProperty } from "../../types.js";
+import RelationshipMetadata from "./RelationshipMetadata.js";
 /**
  * Extends `RelationshipMetadata` to specifically handle "HasMany" relationship metadata within the ORM system.
  *

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

@@ -1 +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,EAAG,SAAS,CAAU;IAC1B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAS;gBAErB,IAAI,EAAE,oBAAoB;CAIvC;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"HasManyRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/HasManyRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,oBAAoB,MAAM,2BAA2B,CAAC;AAE7D;;;;;;;;GAQG;AACH,cAAM,mBAAoB,SAAQ,oBAAoB;IACpD,IAAI,EAAG,SAAS,CAAU;IAC1B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAS;gBAErB,IAAI,EAAE,oBAAoB;CAIvC;AAED,eAAe,mBAAmB,CAAC"}

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

@@ -1,9 +1,4 @@
-"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"));
+import RelationshipMetadata from "./RelationshipMetadata.js";
 /**
  * Extends `RelationshipMetadata` to specifically handle "HasMany" relationship metadata within the ORM system.
  *
@@ -13,7 +8,7 @@ const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata")
  *
  * @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 {
+class HasManyRelationship extends RelationshipMetadata {
     type = "HasMany";
     foreignKey;
     uniDirectional = false;
@@ -22,4 +17,4 @@ class HasManyRelationship extends RelationshipMetadata_1.default {
         Object.assign(this, item);
     }
 }
-exports.default = HasManyRelationship;
+export default HasManyRelationship;

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

@@ -1,5 +1,5 @@
-import type { ForeignKeyProperty } from "../../types";
-import RelationshipMetadata from "./RelationshipMetadata";
+import type { ForeignKeyProperty } from "../../types.js";
+import RelationshipMetadata from "./RelationshipMetadata.js";
 /**
  * Represents the metadata for a "HasOne" relationship metadata in the ORM system,
  *

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

@@ -1 +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,EAAG,QAAQ,CAAU;IACzB,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAIvC;AAED,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"HasOneRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/HasOneRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,oBAAoB,MAAM,2BAA2B,CAAC;AAE7D;;;;;;;GAOG;AACH,cAAM,kBAAmB,SAAQ,oBAAoB;IACnD,IAAI,EAAG,QAAQ,CAAU;IACzB,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAIvC;AAED,eAAe,kBAAkB,CAAC"}

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

@@ -1,9 +1,4 @@
-"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"));
+import RelationshipMetadata from "./RelationshipMetadata.js";
 /**
  * Represents the metadata for a "HasOne" relationship metadata in the ORM system,
  *
@@ -12,7 +7,7 @@ const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata")
  *
  * @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 {
+class HasOneRelationship extends RelationshipMetadata {
     type = "HasOne";
     foreignKey;
     constructor(item) {
@@ -20,4 +15,4 @@ class HasOneRelationship extends RelationshipMetadata_1.default {
         Object.assign(this, item);
     }
 }
-exports.default = HasOneRelationship;
+export default HasOneRelationship;

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

@@ -1,5 +1,5 @@
-import type { ForeignKeyProperty } from "../../types";
-import RelationshipMetadata from "./RelationshipMetadata";
+import type { ForeignKeyProperty } from "../../types.js";
+import RelationshipMetadata from "./RelationshipMetadata.js";
 /**
  * Represents an "Owned By" relationship metadata within the ORM system. These are uni-directional relationships to the parent
  *

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

@@ -1 +1 @@
-{"version":3,"file":"OwnedByRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/OwnedByRelationship.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,EAAG,SAAS,CAAU;IAC1B,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAIvC;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"OwnedByRelationship.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/OwnedByRelationship.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,oBAAoB,MAAM,2BAA2B,CAAC;AAE7D;;;;;;;;GAQG;AACH,cAAM,mBAAoB,SAAQ,oBAAoB;IACpD,IAAI,EAAG,SAAS,CAAU;IAC1B,UAAU,EAAE,kBAAkB,CAAC;gBAEnB,IAAI,EAAE,oBAAoB;CAIvC;AAED,eAAe,mBAAmB,CAAC"}

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

@@ -1,9 +1,4 @@
-"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"));
+import RelationshipMetadata from "./RelationshipMetadata.js";
 /**
  * Represents an "Owned By" relationship metadata within the ORM system. These are uni-directional relationships to the parent
  *
@@ -13,7 +8,7 @@ const RelationshipMetadata_1 = __importDefault(require("./RelationshipMetadata")
  *
  * @param {RelationshipMetadata} item - The initial relationship metadata to be copied into this "Owned By" relationship instance. This facilitates the creation and setup of relationship metadata based on existing configurations.
  */
-class OwnedByRelationship extends RelationshipMetadata_1.default {
+class OwnedByRelationship extends RelationshipMetadata {
     type = "OwnedBy";
     foreignKey;
     constructor(item) {
@@ -21,4 +16,4 @@ class OwnedByRelationship extends RelationshipMetadata_1.default {
         Object.assign(this, item);
     }
 }
-exports.default = OwnedByRelationship;
+export default OwnedByRelationship;

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

@@ -1,5 +1,5 @@
-import type DynaRecord from "../../DynaRecord";
-import type { EntityClass } from "../../types";
+import type DynaRecord from "../../DynaRecord.js";
+import type { EntityClass } from "../../types.js";
 type RelationshipType = "HasMany" | "BelongsTo" | "HasOne" | "HasAndBelongsToMany" | "OwnedBy";
 /**
  * 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.

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

@@ -1 +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,GACrB,SAAS,CAAC;AAEd;;;;;;;;;;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"}
+{"version":3,"file":"RelationshipMetadata.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/RelationshipMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,KAAK,gBAAgB,GACjB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,qBAAqB,GACrB,SAAS,CAAC;AAEd;;;;;;;;;;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

@@ -1,5 +1,3 @@
-"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.
  *
@@ -15,4 +13,4 @@ class RelationshipMetadata {
     target;
     propertyName;
 }
-exports.default = RelationshipMetadata;
+export default RelationshipMetadata;

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

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

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

@@ -1 +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;AACtD,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AAExD,cAAc,SAAS,CAAC;AAExB,OAAO,EACL,qBAAqB,EACrB,+BAA+B,EAC/B,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACpB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/index.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,MAAM,4BAA4B,CAAC;AAC/D,OAAO,+BAA+B,MAAM,sCAAsC,CAAC;AACnF,OAAO,mBAAmB,MAAM,0BAA0B,CAAC;AAC3D,OAAO,kBAAkB,MAAM,yBAAyB,CAAC;AACzD,OAAO,mBAAmB,MAAM,0BAA0B,CAAC;AAE3D,cAAc,YAAY,CAAC;AAE3B,OAAO,EACL,qBAAqB,EACrB,+BAA+B,EAC/B,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACpB,CAAC"}

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

@@ -1,31 +1,7 @@
-"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.OwnedByRelationship = 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;
-const OwnedByRelationship_1 = __importDefault(require("./OwnedByRelationship"));
-exports.OwnedByRelationship = OwnedByRelationship_1.default;
-__exportStar(require("./types"), exports);
+import BelongsToRelationship from "./BelongsToRelationship.js";
+import HasAndBelongsToManyRelationship from "./HasAndBelongsToManyRelationship.js";
+import HasManyRelationship from "./HasManyRelationship.js";
+import HasOneRelationship from "./HasOneRelationship.js";
+import OwnedByRelationship from "./OwnedByRelationship.js";
+export * from "./types.js";
+export { BelongsToRelationship, HasAndBelongsToManyRelationship, HasManyRelationship, HasOneRelationship, OwnedByRelationship };

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

@@ -1,8 +1,8 @@
-import type BelongsToRelationship from "./BelongsToRelationship";
-import type HasAndBelongsToManyRelationship from "./HasAndBelongsToManyRelationship";
-import type HasManyRelationship from "./HasManyRelationship";
-import type HasOneRelationship from "./HasOneRelationship";
-import type OwnedByRelationship from "./OwnedByRelationship";
+import type BelongsToRelationship from "./BelongsToRelationship.js";
+import type HasAndBelongsToManyRelationship from "./HasAndBelongsToManyRelationship.js";
+import type HasManyRelationship from "./HasManyRelationship.js";
+import type HasOneRelationship from "./HasOneRelationship.js";
+import type OwnedByRelationship from "./OwnedByRelationship.js";
 /**
  * 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.
  *

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

@@ -1 +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;AAC3D,OAAO,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,GAC5B,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,GAClB,+BAA+B,GAC/B,mBAAmB,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,mBAAmB,GAAG,kBAAkB,GAAG,+BAA+B,CAC3E,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/metadata/relationship-metadata/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,+BAA+B,MAAM,sCAAsC,CAAC;AACxF,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAEhE;;;;;;;;;GASG;AACH,MAAM,MAAM,oBAAoB,GAC5B,qBAAqB,GACrB,mBAAmB,GACnB,kBAAkB,GAClB,+BAA+B,GAC/B,mBAAmB,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,mBAAmB,GAAG,kBAAkB,GAAG,+BAA+B,CAC3E,CAAC"}

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

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

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

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

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

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

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

@@ -1,28 +1,21 @@
-"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 OwnedByRelationship_1 = __importDefault(require("./OwnedByRelationship"));
-const createRelationshipInstance = (options) => {
+import BelongsToRelationship from "./BelongsToRelationship.js";
+import HasAndBelongsToManyRelationship from "./HasAndBelongsToManyRelationship.js";
+import HasManyRelationship from "./HasManyRelationship.js";
+import HasOneRelationship from "./HasOneRelationship.js";
+import OwnedByRelationship from "./OwnedByRelationship.js";
+export const createRelationshipInstance = (options) => {
     switch (options.type) {
         case "BelongsTo":
-            return new BelongsToRelationship_1.default(options);
+            return new BelongsToRelationship(options);
         case "HasAndBelongsToMany":
-            return new HasAndBelongsToManyRelationship_1.default(options);
+            return new HasAndBelongsToManyRelationship(options);
         case "HasMany":
-            return new HasManyRelationship_1.default(options);
+            return new HasManyRelationship(options);
         case "HasOne":
-            return new HasOneRelationship_1.default(options);
+            return new HasOneRelationship(options);
         case "OwnedBy":
-            return new OwnedByRelationship_1.default(options);
+            return new OwnedByRelationship(options);
         default:
             throw new Error("Invalid relationship type");
     }
 };
-exports.createRelationshipInstance = createRelationshipInstance;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import type { EntityClass } from "../types";
-import type DynaRecord from "../DynaRecord";
-import type { ObjectSchema } from "../decorators/attributes/types";
+import type { EntityClass } from "../types.js";
+import type DynaRecord from "../DynaRecord.js";
+import type { ObjectSchema } from "../decorators/attributes/types.js";
 /**
  * Zod schema that transforms table metadata to a serializable format.
  * This is the main schema used to serialize {@link TableMetadata} instances,

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/metadata/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AA6HnE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQjC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/metadata/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AA6HtE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQjC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/src/metadata/schemas.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableMetadataTransform = void 0;
-const zod_1 = require("zod");
+import { z } from "zod";
 /**
  * Common serialized fields shared by every attribute kind.
  */
 const baseAttributeShape = {
-    name: zod_1.z.string(),
-    alias: zod_1.z.string(),
-    nullable: zod_1.z.boolean()
+    name: z.string(),
+    alias: z.string(),
+    nullable: z.boolean()
 };
-const simpleAttributeShape = (kind) => zod_1.z.object({ ...baseAttributeShape, kind: zod_1.z.literal(kind) });
+const simpleAttributeShape = (kind) => z.object({ ...baseAttributeShape, kind: z.literal(kind) });
 /**
  * Zod schema that transforms attribute metadata to a serializable format.
  *
@@ -23,36 +20,36 @@ const simpleAttributeShape = (kind) => zod_1.z.object({ ...baseAttributeShape, k
  *
  * Non-serializable internals (Zod types, serializers, partial types) are dropped.
  */
-const AttributeMetadataTransform = zod_1.z.discriminatedUnion("kind", [
+const AttributeMetadataTransform = z.discriminatedUnion("kind", [
     simpleAttributeShape("string"),
     simpleAttributeShape("number"),
     simpleAttributeShape("boolean"),
     simpleAttributeShape("date"),
-    zod_1.z
+    z
         .object({
         ...baseAttributeShape,
-        kind: zod_1.z.literal("enum"),
-        enumValues: zod_1.z.array(zod_1.z.string()).nonempty()
+        kind: z.literal("enum"),
+        enumValues: z.array(z.string()).nonempty()
     })
         .transform(({ enumValues, ...rest }) => ({
         ...rest,
         values: enumValues
     })),
-    zod_1.z
+    z
         .object({
         ...baseAttributeShape,
-        kind: zod_1.z.literal("object"),
-        objectSchema: zod_1.z.custom()
+        kind: z.literal("object"),
+        objectSchema: z.custom()
     })
         .transform(({ objectSchema, ...rest }) => ({
         ...rest,
         schema: objectSchema
     })),
-    zod_1.z
+    z
         .object({
         ...baseAttributeShape,
-        kind: zod_1.z.literal("foreignKey"),
-        foreignKeyTarget: zod_1.z.custom()
+        kind: z.literal("foreignKey"),
+        foreignKeyTarget: z.custom()
     })
         .transform(({ foreignKeyTarget, ...rest }) => ({
         ...rest,
@@ -72,14 +69,14 @@ const AttributeMetadataTransform = zod_1.z.discriminatedUnion("kind", [
  *
  * @returns A serialized relationship metadata object with EntityClass references converted to strings
  */
-const RelationshipMetadataTransform = zod_1.z
+const RelationshipMetadataTransform = z
     .object({
-    type: zod_1.z.string(),
-    propertyName: zod_1.z.string(),
-    target: zod_1.z.custom().optional(),
-    foreignKey: zod_1.z.string().optional(),
-    joinTableName: zod_1.z.string().optional(),
-    uniDirectional: zod_1.z.boolean().optional()
+    type: z.string(),
+    propertyName: z.string(),
+    target: z.custom().optional(),
+    foreignKey: z.string().optional(),
+    joinTableName: z.string().optional(),
+    uniDirectional: z.boolean().optional()
 })
     .transform(rel => ({
     type: rel.type,
@@ -103,13 +100,13 @@ const RelationshipMetadataTransform = zod_1.z
  *
  * @returns A serialized entity metadata object with all nested metadata transformed
  */
-const EntityMetadataTransform = zod_1.z
+const EntityMetadataTransform = z
     .object({
-    tableClassName: zod_1.z.string(),
-    attributes: zod_1.z.record(zod_1.z.string(), AttributeMetadataTransform),
-    tableAttributes: zod_1.z.record(zod_1.z.string(), AttributeMetadataTransform),
-    relationships: zod_1.z.record(zod_1.z.string(), RelationshipMetadataTransform),
-    idField: zod_1.z.string().optional()
+    tableClassName: z.string(),
+    attributes: z.record(z.string(), AttributeMetadataTransform),
+    tableAttributes: z.record(z.string(), AttributeMetadataTransform),
+    relationships: z.record(z.string(), RelationshipMetadataTransform),
+    idField: z.string().optional()
 })
     .transform(entity => ({
     tableClassName: entity.tableClassName,
@@ -140,12 +137,12 @@ const EntityMetadataTransform = zod_1.z
  * // Returns a plain object with all EntityClass references converted to strings
  * ```
  */
-exports.TableMetadataTransform = zod_1.z.object({
-    name: zod_1.z.string(),
-    delimiter: zod_1.z.string(),
-    defaultAttributes: zod_1.z.record(zod_1.z.string(), AttributeMetadataTransform),
-    defaultTableAttributes: zod_1.z.record(zod_1.z.string(), AttributeMetadataTransform),
+export const TableMetadataTransform = z.object({
+    name: z.string(),
+    delimiter: z.string(),
+    defaultAttributes: z.record(z.string(), AttributeMetadataTransform),
+    defaultTableAttributes: z.record(z.string(), AttributeMetadataTransform),
     partitionKeyAttribute: AttributeMetadataTransform,
     sortKeyAttribute: AttributeMetadataTransform,
-    entities: zod_1.z.record(zod_1.z.string(), EntityMetadataTransform)
+    entities: z.record(z.string(), EntityMetadataTransform)
 });

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

@@ -1,9 +1,9 @@
 import type { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
-import type { AttributeMetadata, BelongsToRelationship, EntityMetadata, JoinTableMetadata, OwnedByRelationship, RelationshipMetadata, TableMetadata } from ".";
-import type DynaRecord from "../DynaRecord";
-import type { EntityClass, MakeOptional } from "../types";
+import type { AttributeMetadata, BelongsToRelationship, EntityMetadata, JoinTableMetadata, OwnedByRelationship, RelationshipMetadata, TableMetadata } from "./index.js";
+import type DynaRecord from "../DynaRecord.js";
+import type { EntityClass, MakeOptional } from "../types.js";
 import type { ZodType } from "zod";
-import type { ObjectSchema } from "../decorators/attributes/types";
+import type { ObjectSchema } from "../decorators/attributes/types.js";
 /**
  * Represents relationship metadata that includes a foreign key reference to another entity.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/metadata/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/metadata/types.ts"],"names":[],"mappings":"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"}

package/dist/src/metadata/types.js

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

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

@@ -1,8 +1,8 @@
-import type { RelationshipMetadata, HasManyRelationship, BelongsToRelationship, HasOneRelationship, HasAndBelongsToManyRelationship, OwnedByRelationship, ForeignKeyAttributeMetadata } from ".";
-import type DynaRecord from "../DynaRecord";
-import type { BelongsToOrOwnedByRelationship, RelationshipMetadataWithForeignKey } from "./types";
-import type { EntityClass } from "../types";
-import type AttributeMetadata from "./AttributeMetadata";
+import type { RelationshipMetadata, HasManyRelationship, BelongsToRelationship, HasOneRelationship, HasAndBelongsToManyRelationship, OwnedByRelationship, ForeignKeyAttributeMetadata } from "./index.js";
+import type DynaRecord from "../DynaRecord.js";
+import type { BelongsToOrOwnedByRelationship, RelationshipMetadataWithForeignKey } from "./types.js";
+import type { EntityClass } from "../types.js";
+import type AttributeMetadata from "./AttributeMetadata.js";
 /**
  * Type guard to check if the relationship is a HasMany
  */

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

@@ -1 +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,EAC/B,mBAAmB,EACnB,2BAA2B,EAC5B,MAAM,GAAG,CAAC;AACX,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EACV,8BAA8B,EAC9B,kCAAkC,EACnC,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAC3B,oBAAoB,KACxB,GAAG,IAAI,mBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAC7B,oBAAoB,KACxB,GAAG,IAAI,qBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,QAC1B,oBAAoB,KACxB,GAAG,IAAI,kBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,QACvC,oBAAoB,KACxB,GAAG,IAAI,+BAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,QAC3B,oBAAoB,KACxB,GAAG,IAAI,mBAET,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,QAC1C,oBAAoB,KACxB,GAAG,IAAI,kCAET,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,SAClC,iBAAiB,KACtB,IAAI,IAAI,2BAEV,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,CAAC,SAAS,UAAU,UACxD,WAAW,CAAC,CAAC,CAAC,OACjB,8BAA8B,KAClC,OAMF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,CAAC,SAAS,UAAU,UACzD,WAAW,CAAC,CAAC,CAAC,OACjB,8BAA8B,KAClC,OAMF,CAAC"}
+{"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,EAC/B,mBAAmB,EACnB,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EACV,8BAA8B,EAC9B,kCAAkC,EACnC,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,oBAAoB,KACxB,GAAG,IAAI,mBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,oBAAoB,KACxB,GAAG,IAAI,qBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,oBAAoB,KACxB,GAAG,IAAI,kBAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iCAAiC,GAC5C,KAAK,oBAAoB,KACxB,GAAG,IAAI,+BAET,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,oBAAoB,KACxB,GAAG,IAAI,mBAET,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,GAC/C,KAAK,oBAAoB,KACxB,GAAG,IAAI,kCAET,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,GACxC,MAAM,iBAAiB,KACtB,IAAI,IAAI,2BAEV,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,CAAC,SAAS,UAAU,EAChE,QAAQ,WAAW,CAAC,CAAC,CAAC,EACtB,KAAK,8BAA8B,KAClC,OAMF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,CAAC,SAAS,UAAU,EACjE,QAAQ,WAAW,CAAC,CAAC,CAAC,EACtB,KAAK,8BAA8B,KAClC,OAMF,CAAC"}

package/dist/src/metadata/utils.js

@@ -1,73 +1,59 @@
-"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.isForeignKeyAttributeMetadata = exports.isRelationshipMetadataWithForeignKey = exports.isOwnedByRelationship = exports.isHasAndBelongsToManyRelationship = exports.isHasOneRelationship = exports.isBelongsToRelationship = exports.isHasManyRelationship = void 0;
-const _1 = __importDefault(require("./"));
+import Metadata from "./index.js";
 /**
  * Type guard to check if the relationship is a HasMany
  */
-const isHasManyRelationship = (rel) => {
+export const isHasManyRelationship = (rel) => {
     return rel.type === "HasMany" && "foreignKey" in rel;
 };
-exports.isHasManyRelationship = isHasManyRelationship;
 /**
  * Type guard to check if the relationship is a BelongsTo
  */
-const isBelongsToRelationship = (rel) => {
+export const isBelongsToRelationship = (rel) => {
     return rel.type === "BelongsTo" && "foreignKey" in rel;
 };
-exports.isBelongsToRelationship = isBelongsToRelationship;
 /**
  * Type guard to check if the relationship is a HasOne
  */
-const isHasOneRelationship = (rel) => {
+export const isHasOneRelationship = (rel) => {
     return rel.type === "HasOne" && "foreignKey" in rel;
 };
-exports.isHasOneRelationship = isHasOneRelationship;
 /**
  * Type guard to check if the relationship is a HasOne
  */
-const isHasAndBelongsToManyRelationship = (rel) => {
+export const isHasAndBelongsToManyRelationship = (rel) => {
     return rel.type === "HasAndBelongsToMany" && "joinTableName" in rel;
 };
-exports.isHasAndBelongsToManyRelationship = isHasAndBelongsToManyRelationship;
 /**
  * Type guard to check if the relationship is of type OwnedBy
  */
-const isOwnedByRelationship = (rel) => {
+export const isOwnedByRelationship = (rel) => {
     return rel.type === "OwnedBy";
 };
-exports.isOwnedByRelationship = isOwnedByRelationship;
 /**
  * Type guard to check if the relationship metadata includes a foreignKey
  * @param rel
  * @returns
  */
-const isRelationshipMetadataWithForeignKey = (rel) => {
+export const isRelationshipMetadataWithForeignKey = (rel) => {
     return "foreignKey" in rel;
 };
-exports.isRelationshipMetadataWithForeignKey = isRelationshipMetadataWithForeignKey;
 /**
  * Type guard that checks whether attribute metadata represents a foreign key.
  * Returns {@link ForeignKeyAttributeMetadata} with a guaranteed target entity.
  */
-const isForeignKeyAttributeMetadata = (attr) => {
+export const isForeignKeyAttributeMetadata = (attr) => {
     return attr.foreignKeyTarget !== undefined;
 };
-exports.isForeignKeyAttributeMetadata = isForeignKeyAttributeMetadata;
 /**
  * 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);
+export const doesEntityBelongToRelAsHasOne = (Entity, rel) => {
+    const relMetadata = Metadata.getEntity(rel.target.name);
+    return Object.values(relMetadata.relationships).some(rel => isHasOneRelationship(rel) && rel.target === Entity);
 };
-exports.doesEntityBelongToRelAsHasOne = doesEntityBelongToRelAsHasOne;
 /**
  * Returns true if an "Entity" BelongsTo the provided relationship as a HasMany
  * @param Entity
@@ -75,8 +61,7 @@ exports.doesEntityBelongToRelAsHasOne = doesEntityBelongToRelAsHasOne;
  * @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);
+export const doesEntityBelongToRelAsHasMany = (Entity, rel) => {
+    const relMetadata = Metadata.getEntity(rel.target.name);
+    return Object.values(relMetadata.relationships).some(rel => isHasManyRelationship(rel) && rel.target === Entity);
 };
-exports.doesEntityBelongToRelAsHasMany = doesEntityBelongToRelAsHasMany;