dyna-record 0.0.1

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

@@ -0,0 +1,42 @@
+import { type AttributeMetadata, type AttributeMetadataStorage, type RelationshipMetadataStorage } from ".";
+import type DynaRecord from "../DynaRecord";
+type EntityClass = new (...args: any) => DynaRecord;
+/**
+ * Represents metadata for an entity within the ORM system, encapsulating information about the entity's attributes, relationships, and its associated database table.
+ *
+ * @property {string} tableClassName - The name of the table class instance to which this entity is mapped, providing a link between the entity and its database table.
+ * @property {AttributeMetadataStorage} attributes - A storage mapping for attribute metadata, keyed by entity field names, enabling lookup of attribute configurations.
+ * @property {AttributeMetadataStorage} tableAttributes - A storage mapping for attribute metadata, keyed by table column names (aliases), used for database interactions.
+ * @property {RelationshipMetadataStorage} relationships - A storage for relationship metadata, facilitating the management of entity relationships.
+ * @property {EntityClass} EntityClass - The constructor function of the entity class, allowing instantiation and further metadata enrichment.
+ *
+ * @param {EntityClass} entityClass - The constructor function of the entity class this metadata belongs to.
+ * @param {string} tableClassName - The name of the table class instance that maps to the database table of the entity.
+ */
+declare class EntityMetadata {
+    /**
+     * The name of the table class instance to which this entity belongs
+     */
+    readonly tableClassName: string;
+    /**
+     * Attribute metadata, for looking up attribute metadata by entity key
+     */
+    readonly attributes: AttributeMetadataStorage;
+    /**
+     * Attribute metadata, for looking up attribute metadata by table key
+     */
+    readonly tableAttributes: AttributeMetadataStorage;
+    /**
+     * Relationship metadata. For looking up a relationship by entity key
+     */
+    readonly relationships: RelationshipMetadataStorage;
+    readonly EntityClass: EntityClass;
+    constructor(entityClass: EntityClass, tableClassName: string);
+    /**
+     * Add attribute metadata to an entity
+     * @param attrMeta
+     */
+    addAttribute(attrMeta: AttributeMetadata): void;
+}
+export default EntityMetadata;
+//# sourceMappingURL=EntityMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EntityMetadata.d.ts","sourceRoot":"","sources":["../../../src/metadata/EntityMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EACjC,MAAM,GAAG,CAAC;AACX,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAE5C,KAAK,WAAW,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,UAAU,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,cAAM,cAAc;IAClB;;OAEG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC;;OAEG;IACH,SAAgB,UAAU,EAAE,wBAAwB,CAAC;IACrD;;OAEG;IACH,SAAgB,eAAe,EAAE,wBAAwB,CAAC;IAE1D;;OAEG;IACH,SAAgB,aAAa,EAAE,2BAA2B,CAAC;IAE3D,SAAgB,WAAW,EAAE,WAAW,CAAC;gBAE7B,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM;IAS5D;;;OAGG;IACI,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;CAIvD;AAED,eAAe,cAAc,CAAC"}

package/dist/src/metadata/EntityMetadata.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Represents metadata for an entity within the ORM system, encapsulating information about the entity's attributes, relationships, and its associated database table.
+ *
+ * @property {string} tableClassName - The name of the table class instance to which this entity is mapped, providing a link between the entity and its database table.
+ * @property {AttributeMetadataStorage} attributes - A storage mapping for attribute metadata, keyed by entity field names, enabling lookup of attribute configurations.
+ * @property {AttributeMetadataStorage} tableAttributes - A storage mapping for attribute metadata, keyed by table column names (aliases), used for database interactions.
+ * @property {RelationshipMetadataStorage} relationships - A storage for relationship metadata, facilitating the management of entity relationships.
+ * @property {EntityClass} EntityClass - The constructor function of the entity class, allowing instantiation and further metadata enrichment.
+ *
+ * @param {EntityClass} entityClass - The constructor function of the entity class this metadata belongs to.
+ * @param {string} tableClassName - The name of the table class instance that maps to the database table of the entity.
+ */
+class EntityMetadata {
+    /**
+     * The name of the table class instance to which this entity belongs
+     */
+    tableClassName; //
+    /**
+     * Attribute metadata, for looking up attribute metadata by entity key
+     */
+    attributes;
+    /**
+     * Attribute metadata, for looking up attribute metadata by table key
+     */
+    tableAttributes;
+    /**
+     * Relationship metadata. For looking up a relationship by entity key
+     */
+    relationships;
+    EntityClass;
+    constructor(entityClass, tableClassName) {
+        this.EntityClass = entityClass;
+        this.tableClassName = tableClassName;
+        this.attributes = {};
+        this.tableAttributes = {};
+        this.relationships = {};
+    }
+    /**
+     * Add attribute metadata to an entity
+     * @param attrMeta
+     */
+    addAttribute(attrMeta) {
+        this.attributes[attrMeta.name] = attrMeta;
+        this.tableAttributes[attrMeta.alias] = attrMeta;
+    }
+}
+exports.default = EntityMetadata;

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

@@ -0,0 +1,23 @@
+import type DynaRecord from "../DynaRecord";
+import type { JoinTable } from "../relationships";
+import type { EntityClass } from "../types";
+type Entity = EntityClass<DynaRecord>;
+type ForeignKey = keyof JoinTable<DynaRecord, DynaRecord>;
+/**
+ * Represents the metadata for a join table used in many-to-many relationships within the ORM system. This metadata includes the entity class and the foreign key used in the join table.
+ *
+ * A join table is an intermediary table that connects two entities in a many-to-many relationship, holding foreign keys that reference the partition keys of each entity. `JoinTableMetadata` encapsulates the details of one side of such a relationship, specifically the entity involved and the foreign key within the join table that points to this entity.
+ *
+ * @property {Entity} entity - The entity class that is part of the many-to-many relationship. This entity corresponds to one side of the relationship.
+ * @property {ForeignKey} foreignKey - The foreign key in the join table that references the partition key of the `entity`. This key is crucial for linking records between the associated entities.
+ *
+ * @param {Entity} entity - The entity class involved in the many-to-many relationship.
+ * @param {ForeignKey} foreignKey - The foreign key within the join table that references the entity's partition key.
+ */
+declare class JoinTableMetadata {
+    readonly entity: Entity;
+    readonly foreignKey: ForeignKey;
+    constructor(entity: Entity, foreignKey: ForeignKey);
+}
+export default JoinTableMetadata;
+//# sourceMappingURL=JoinTableMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JoinTableMetadata.d.ts","sourceRoot":"","sources":["../../../src/metadata/JoinTableMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,KAAK,MAAM,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC;AACtC,KAAK,UAAU,GAAG,MAAM,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;AAE1D;;;;;;;;;;GAUG;AAEH,cAAM,iBAAiB;IACrB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,UAAU,EAAE,UAAU,CAAC;gBAE3B,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU;CAInD;AAED,eAAe,iBAAiB,CAAC"}

package/dist/src/metadata/JoinTableMetadata.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Represents the metadata for a join table used in many-to-many relationships within the ORM system. This metadata includes the entity class and the foreign key used in the join table.
+ *
+ * A join table is an intermediary table that connects two entities in a many-to-many relationship, holding foreign keys that reference the partition keys of each entity. `JoinTableMetadata` encapsulates the details of one side of such a relationship, specifically the entity involved and the foreign key within the join table that points to this entity.
+ *
+ * @property {Entity} entity - The entity class that is part of the many-to-many relationship. This entity corresponds to one side of the relationship.
+ * @property {ForeignKey} foreignKey - The foreign key in the join table that references the partition key of the `entity`. This key is crucial for linking records between the associated entities.
+ *
+ * @param {Entity} entity - The entity class involved in the many-to-many relationship.
+ * @param {ForeignKey} foreignKey - The foreign key within the join table that references the entity's partition key.
+ */
+class JoinTableMetadata {
+    entity;
+    foreignKey;
+    constructor(entity, foreignKey) {
+        this.entity = entity;
+        this.foreignKey = foreignKey;
+    }
+}
+exports.default = JoinTableMetadata;

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

@@ -0,0 +1,104 @@
+import type DynaRecord from "../DynaRecord";
+import type { MakeOptional } from "../types";
+import TableMetadata from "./TableMetadata";
+import EntityMetadata from "./EntityMetadata";
+import JoinTableMetadata from "./JoinTableMetadata";
+import type { RelationshipMetadata } from "./relationship-metadata";
+import type { AttributeMetadataStorage, TableMetadataOptions, AttributeMetadataOptions } from "./types";
+/**
+ * Central storage for managing and accessing all metadata related to entities, attributes, relationships, and tables within the ORM.
+ * It provides methods for retrieving and adding metadata for entities and their corresponding tables, handling relationships
+ * and attributes, and ensuring the proper initialization of metadata upon first access.
+ */
+declare class MetadataStorage {
+    #private;
+    /**
+     * Returns entity metadata given an entity name
+     * @param {string} entityName - Name of the entity
+     * @returns Entity metadata
+     */
+    getEntity(entityName: string): EntityMetadata;
+    /**
+     * Returns table metadata given a table name
+     * @param {string} tableName - Name of the table
+     * @returns Table metadata
+     */
+    getTable(tableName: string): TableMetadata;
+    /**
+     * Returns table metadata for an entity given an entity name
+     * @param {string} entityName - Name of the entity
+     * @returns Table metadata
+     */
+    getEntityTable(entityName: string): TableMetadata;
+    /**
+     * Returns JoinTable metadata by name
+     * @param {string} joinTableName - Name of the JoinTable class
+     * @returns joinTableName metadata
+     */
+    getJoinTable(joinTableName: string): JoinTableMetadata[];
+    /**
+     * Returns attribute metadata for attributes defined keyed by entity key
+     * @returns - {@link AttributeMetadataStorage}
+     */
+    getEntityAttributes(entityName: string): AttributeMetadataStorage;
+    /**
+     * Returns attribute metadata for attributes defined keyed by table alias
+     * @param entityName - Name of the Entity class
+     * @returns - {@link AttributeMetadataStorage}
+     */
+    getEntityTableAttributes(entityName: string): AttributeMetadataStorage;
+    /**
+     * Add a table to metadata storage
+     * @param tableClassName
+     * @param options
+     */
+    addTable(tableClassName: string, options: TableMetadataOptions): void;
+    /**
+     * Add an entity to metadata storage
+     * @param entityName
+     * @param tableName
+     */
+    addEntity(entityClass: EntityMetadata["EntityClass"], tableClassName: string): void;
+    /**
+     * Adds a relationship to an Entity's metadata storage
+     * @param entityName
+     * @param options
+     */
+    addEntityRelationship(entityName: string, options: RelationshipMetadata): void;
+    /**
+     * Adds JoinTable metadata to storage
+     * @param joinTableName
+     * @param options
+     */
+    addJoinTable(joinTableName: string, options: JoinTableMetadata): void;
+    /**
+     * Adds an attribute to an Entity's metadata storage
+     * @param entityName
+     * @param options
+     */
+    addEntityAttribute(entityName: string, options: MakeOptional<AttributeMetadataOptions, "alias">): void;
+    /**
+     * Adds the partition key attribute to Table metadata storage
+     * @param entityClass
+     * @param options
+     */
+    addPartitionKeyAttribute(entityClass: DynaRecord, options: Parameters<TableMetadata["addPartitionKeyAttribute"]>[number]): void;
+    /**
+     * Adds the sort key attribute to Table metadata storage
+     * @param entityClass
+     * @param options
+     */
+    addSortKeyAttribute(entityClass: DynaRecord, options: Parameters<TableMetadata["addPartitionKeyAttribute"]>[number]): void;
+    /**
+     * Initialize metadata object
+     */
+    private init;
+    /**
+     * Recursively search prototype chain and return TableMetadata for an entity class if it exists
+     * @param classPrototype
+     * @returns
+     */
+    private getEntityTableMetadata;
+}
+export default MetadataStorage;
+//# sourceMappingURL=MetadataStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataStorage.d.ts","sourceRoot":"","sources":["../../../src/metadata/MetadataStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAE9C,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,KAAK,EACV,wBAAwB,EAIxB,oBAAoB,EAEpB,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,cAAM,eAAe;;IAOnB;;;;OAIG;IACI,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc;IAKpD;;;;OAIG;IACI,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa;IAKjD;;;;OAIG;IACI,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa;IAMxD;;;;OAIG;IACI,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAK/D;;;OAGG;IACI,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,wBAAwB;IAYxE;;;;OAIG;IACI,wBAAwB,CAC7B,UAAU,EAAE,MAAM,GACjB,wBAAwB;IAY3B;;;;OAIG;IACI,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAI5E;;;;OAIG;IACI,SAAS,CACd,WAAW,EAAE,cAAc,CAAC,aAAa,CAAC,EAC1C,cAAc,EAAE,MAAM,GACrB,IAAI;IAOP;;;;OAIG;IACI,qBAAqB,CAC1B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAC5B,IAAI;IAQP;;;;OAIG;IACI,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAa5E;;;;OAIG;IACI,kBAAkB,CACvB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,YAAY,CAAC,wBAAwB,EAAE,OAAO,CAAC,GACvD,IAAI;IAYP;;;;OAIG;IACI,wBAAwB,CAC7B,WAAW,EAAE,UAAU,EACvB,OAAO,EAAE,UAAU,CAAC,aAAa,CAAC,0BAA0B,CAAC,CAAC,CAAC,MAAM,CAAC,GACrE,IAAI;IAQP;;;;OAIG;IACI,mBAAmB,CACxB,WAAW,EAAE,UAAU,EACvB,OAAO,EAAE,UAAU,CAAC,aAAa,CAAC,0BAA0B,CAAC,CAAC,CAAC,MAAM,CAAC,GACrE,IAAI;IAQP;;OAEG;IACH,OAAO,CAAC,IAAI;IAUZ;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;CAa/B;AAED,eAAe,eAAe,CAAC"}

package/dist/src/metadata/MetadataStorage.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TableMetadata_1 = __importDefault(require("./TableMetadata"));
+const EntityMetadata_1 = __importDefault(require("./EntityMetadata"));
+const AttributeMetadata_1 = __importDefault(require("./AttributeMetadata"));
+const JoinTableMetadata_1 = __importDefault(require("./JoinTableMetadata"));
+const utils_1 = require("./relationship-metadata/utils");
+/**
+ * Central storage for managing and accessing all metadata related to entities, attributes, relationships, and tables within the ORM.
+ * It provides methods for retrieving and adding metadata for entities and their corresponding tables, handling relationships
+ * and attributes, and ensuring the proper initialization of metadata upon first access.
+ */
+class MetadataStorage {
+    #tables = {};
+    #entities = {};
+    #joinTables = {};
+    #initialized = false;
+    /**
+     * Returns entity metadata given an entity name
+     * @param {string} entityName - Name of the entity
+     * @returns Entity metadata
+     */
+    getEntity(entityName) {
+        this.init();
+        return this.#entities[entityName];
+    }
+    /**
+     * Returns table metadata given a table name
+     * @param {string} tableName - Name of the table
+     * @returns Table metadata
+     */
+    getTable(tableName) {
+        this.init();
+        return this.#tables[tableName];
+    }
+    /**
+     * Returns table metadata for an entity given an entity name
+     * @param {string} entityName - Name of the entity
+     * @returns Table metadata
+     */
+    getEntityTable(entityName) {
+        this.init();
+        const entityMetadata = this.getEntity(entityName);
+        return this.getTable(entityMetadata.tableClassName);
+    }
+    /**
+     * Returns JoinTable metadata by name
+     * @param {string} joinTableName - Name of the JoinTable class
+     * @returns joinTableName metadata
+     */
+    getJoinTable(joinTableName) {
+        this.init();
+        return this.#joinTables[joinTableName];
+    }
+    /**
+     * Returns attribute metadata for attributes defined keyed by entity key
+     * @returns - {@link AttributeMetadataStorage}
+     */
+    getEntityAttributes(entityName) {
+        const entityMetadata = this.getEntity(entityName);
+        const tableMeta = this.getTable(entityMetadata.tableClassName);
+        return {
+            ...entityMetadata.attributes,
+            ...tableMeta.defaultAttributes,
+            [tableMeta.partitionKeyAttribute.name]: tableMeta.partitionKeyAttribute,
+            [tableMeta.sortKeyAttribute.name]: tableMeta.sortKeyAttribute
+        };
+    }
+    /**
+     * Returns attribute metadata for attributes defined keyed by table alias
+     * @param entityName - Name of the Entity class
+     * @returns - {@link AttributeMetadataStorage}
+     */
+    getEntityTableAttributes(entityName) {
+        const entityMetadata = this.getEntity(entityName);
+        const tableMeta = this.getTable(entityMetadata.tableClassName);
+        return {
+            ...entityMetadata.tableAttributes,
+            ...tableMeta.defaultTableAttributes,
+            [tableMeta.partitionKeyAttribute.alias]: tableMeta.partitionKeyAttribute,
+            [tableMeta.sortKeyAttribute.alias]: tableMeta.sortKeyAttribute
+        };
+    }
+    /**
+     * Add a table to metadata storage
+     * @param tableClassName
+     * @param options
+     */
+    addTable(tableClassName, options) {
+        this.#tables[tableClassName] = new TableMetadata_1.default(options);
+    }
+    /**
+     * Add an entity to metadata storage
+     * @param entityName
+     * @param tableName
+     */
+    addEntity(entityClass, tableClassName) {
+        this.#entities[entityClass.name] = new EntityMetadata_1.default(entityClass, tableClassName);
+    }
+    /**
+     * Adds a relationship to an Entity's metadata storage
+     * @param entityName
+     * @param options
+     */
+    addEntityRelationship(entityName, options) {
+        const entityMetadata = this.#entities[entityName];
+        if (entityMetadata.relationships[options.propertyName] === undefined) {
+            entityMetadata.relationships[options.propertyName] =
+                (0, utils_1.createRelationshipInstance)(options);
+        }
+    }
+    /**
+     * Adds JoinTable metadata to storage
+     * @param joinTableName
+     * @param options
+     */
+    addJoinTable(joinTableName, options) {
+        const metadata = this.#joinTables[joinTableName];
+        if (metadata === undefined) {
+            const meta = new JoinTableMetadata_1.default(options.entity, options.foreignKey);
+            this.#joinTables[joinTableName] = [meta];
+        }
+        else if (this.#joinTables[joinTableName].length === 1) {
+            // There can only be two tables in a join table
+            const meta = new JoinTableMetadata_1.default(options.entity, options.foreignKey);
+            this.#joinTables[joinTableName].push(meta);
+        }
+    }
+    /**
+     * Adds an attribute to an Entity's metadata storage
+     * @param entityName
+     * @param options
+     */
+    addEntityAttribute(entityName, options) {
+        const entityMetadata = this.#entities[entityName];
+        const { defaultAttributes } = this.#tables[entityMetadata.tableClassName];
+        const defaultAttrMeta = defaultAttributes[options.attributeName];
+        // The property is a default field assign it, otherwise instantiate new AttributeMetadata
+        const meta = defaultAttrMeta ?? new AttributeMetadata_1.default(options);
+        entityMetadata.addAttribute(meta);
+    }
+    /**
+     * Adds the partition key attribute to Table metadata storage
+     * @param entityClass
+     * @param options
+     */
+    addPartitionKeyAttribute(entityClass, options) {
+        const tableMetadata = this.getEntityTableMetadata(entityClass);
+        if (tableMetadata !== undefined) {
+            tableMetadata.addPartitionKeyAttribute(options);
+        }
+    }
+    /**
+     * Adds the sort key attribute to Table metadata storage
+     * @param entityClass
+     * @param options
+     */
+    addSortKeyAttribute(entityClass, options) {
+        const tableMetadata = this.getEntityTableMetadata(entityClass);
+        if (tableMetadata !== undefined) {
+            tableMetadata.addSortKeyAttribute(options);
+        }
+    }
+    /**
+     * Initialize metadata object
+     */
+    init() {
+        if (!this.#initialized) {
+            // Initialize all entities once to trigger Attribute decorators and fill metadata object
+            Object.values(this.#entities).forEach(entityMeta => new entityMeta.EntityClass());
+            this.#initialized = true;
+        }
+    }
+    /**
+     * Recursively search prototype chain and return TableMetadata for an entity class if it exists
+     * @param classPrototype
+     * @returns
+     */
+    getEntityTableMetadata(classPrototype) {
+        const protoType = Object.getPrototypeOf(classPrototype);
+        if (protoType === null)
+            return;
+        if (this.#tables[protoType.constructor.name] !== undefined) {
+            return this.#tables[protoType.constructor.name];
+        }
+        else {
+            return this.getEntityTableMetadata(protoType);
+        }
+    }
+}
+exports.default = MetadataStorage;

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

@@ -0,0 +1,53 @@
+import { AttributeMetadata } from ".";
+import type { TableMetadataOptions, DefaultFields, KeysAttributeMetadataOptions } from "./types";
+export declare const defaultTableKeys: {
+    readonly partitionKey: "PK";
+    readonly sortKey: "SK";
+};
+/**
+ * Default fields with default table alias. Can be overwritten through {@link TableMetadataOptions} defaultFields
+ */
+export declare const tableDefaultFields: Record<DefaultFields, {
+    alias: DefaultFields;
+}>;
+/**
+ * Represents the metadata for a table within the ORM framework, encapsulating information such as table name, key attributes, and default field mappings. This class is fundamental for defining how entities are mapped to their underlying database tables, providing a schema-like structure that includes both key configuration and default attribute handling.
+ *
+ * The metadata includes the partition and sort key attributes of the table, which are essential for database operations. It also provides a mechanism to include default attributes and their mappings, supporting common fields like `id`, `type`, `createdAt`, and `updatedAt`, along with their serialization strategies, particularly for date fields.
+ *
+ * @property {string} name - The name of the table.
+ * @property {string} delimiter - A delimiter used in the table's composite keys.
+ * @property {Record<DefaultFields, AttributeMetadata>} defaultAttributes - A record of default attributes for the entity, keyed by entity field names.
+ * @property {Record<string, AttributeMetadata>} defaultTableAttributes - A record of default attributes for the table, keyed by table field aliases.
+ * @property {AttributeMetadata} partitionKeyAttribute - Metadata for the table's partition key attribute.
+ * @property {AttributeMetadata} sortKeyAttribute - Metadata for the table's sort key attribute.
+ *
+ * @param {TableMetadataOptions} options - Configuration options for the table metadata.
+ */
+declare class TableMetadata {
+    readonly name: string;
+    readonly delimiter: string;
+    readonly defaultAttributes: Record<DefaultFields, AttributeMetadata>;
+    readonly defaultTableAttributes: Record<string, AttributeMetadata>;
+    partitionKeyAttribute: AttributeMetadata;
+    sortKeyAttribute: AttributeMetadata;
+    constructor(options: TableMetadataOptions);
+    /**
+     * Creates default attribute metadata. Use {@link tableDefaultFields} unless consuming table decorator specifies overrides
+     * @param options - {@link TableMetadataOptions}
+     * @returns
+     */
+    private buildDefaultAttributesMetadata;
+    /**
+     * Adds the partition key attribute to Table metadata storage
+     * @param options
+     */
+    addPartitionKeyAttribute(options: KeysAttributeMetadataOptions): void;
+    /**
+     * Adds the sort key attribute to Table metadata storage
+     * @param options
+     */
+    addSortKeyAttribute(options: KeysAttributeMetadataOptions): void;
+}
+export default TableMetadata;
+//# sourceMappingURL=TableMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TableMetadata.d.ts","sourceRoot":"","sources":["../../../src/metadata/TableMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,GAAG,CAAC;AAEtC,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EAGb,4BAA4B,EAC7B,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,gBAAgB;;;CAAiD,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CACrC,aAAa,EACb;IAAE,KAAK,EAAE,aAAa,CAAA;CAAE,CAQhB,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,cAAM,aAAa;IACjB,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,iBAAiB,EAAE,MAAM,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAC5E,SAAgB,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACnE,qBAAqB,EAAE,iBAAiB,CAAC;IACzC,gBAAgB,EAAE,iBAAiB,CAAC;gBAE/B,OAAO,EAAE,oBAAoB;IAsBzC;;;;OAIG;IACH,OAAO,CAAC,8BAA8B;IA+BtC;;;OAGG;IACI,wBAAwB,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI;IAK5E;;;OAGG;IACI,mBAAmB,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI;CAIxE;AAED,eAAe,aAAa,CAAC"}

package/dist/src/metadata/TableMetadata.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableDefaultFields = exports.defaultTableKeys = void 0;
+const _1 = require(".");
+const decorators_1 = require("../decorators");
+exports.defaultTableKeys = { partitionKey: "PK", sortKey: "SK" };
+/**
+ * Default fields with default table alias. Can be overwritten through {@link TableMetadataOptions} defaultFields
+ */
+exports.tableDefaultFields = {
+    id: { alias: "id" },
+    type: { alias: "type" },
+    createdAt: { alias: "createdAt" },
+    updatedAt: { alias: "updatedAt" },
+    foreignKey: { alias: "foreignKey" },
+    foreignEntityType: { alias: "foreignEntityType" }
+};
+/**
+ * Represents the metadata for a table within the ORM framework, encapsulating information such as table name, key attributes, and default field mappings. This class is fundamental for defining how entities are mapped to their underlying database tables, providing a schema-like structure that includes both key configuration and default attribute handling.
+ *
+ * The metadata includes the partition and sort key attributes of the table, which are essential for database operations. It also provides a mechanism to include default attributes and their mappings, supporting common fields like `id`, `type`, `createdAt`, and `updatedAt`, along with their serialization strategies, particularly for date fields.
+ *
+ * @property {string} name - The name of the table.
+ * @property {string} delimiter - A delimiter used in the table's composite keys.
+ * @property {Record<DefaultFields, AttributeMetadata>} defaultAttributes - A record of default attributes for the entity, keyed by entity field names.
+ * @property {Record<string, AttributeMetadata>} defaultTableAttributes - A record of default attributes for the table, keyed by table field aliases.
+ * @property {AttributeMetadata} partitionKeyAttribute - Metadata for the table's partition key attribute.
+ * @property {AttributeMetadata} sortKeyAttribute - Metadata for the table's sort key attribute.
+ *
+ * @param {TableMetadataOptions} options - Configuration options for the table metadata.
+ */
+class TableMetadata {
+    name;
+    delimiter;
+    defaultAttributes;
+    defaultTableAttributes;
+    partitionKeyAttribute;
+    sortKeyAttribute;
+    constructor(options) {
+        const defaultAttrMeta = this.buildDefaultAttributesMetadata(options);
+        this.name = options.name;
+        this.delimiter = options.delimiter;
+        this.defaultAttributes = defaultAttrMeta.entityDefaults;
+        this.defaultTableAttributes = defaultAttrMeta.tableDefaults;
+        // Placeholders, these are set later
+        this.partitionKeyAttribute = {
+            name: "",
+            alias: exports.defaultTableKeys.partitionKey,
+            nullable: false,
+            serializers: { toEntityAttribute: () => "", toTableAttribute: () => "" }
+        };
+        this.sortKeyAttribute = {
+            name: "",
+            alias: exports.defaultTableKeys.sortKey,
+            nullable: false,
+            serializers: { toEntityAttribute: () => "", toTableAttribute: () => "" }
+        };
+    }
+    /**
+     * Creates default attribute metadata. Use {@link tableDefaultFields} unless consuming table decorator specifies overrides
+     * @param options - {@link TableMetadataOptions}
+     * @returns
+     */
+    buildDefaultAttributesMetadata(options) {
+        const defaultAttrsMeta = Object.entries(exports.tableDefaultFields);
+        const customDefaults = options.defaultFields ?? {};
+        return defaultAttrsMeta.reduce((acc, [entityKey, tableKeyAlias]) => {
+            const key = entityKey;
+            const { alias } = customDefaults[key] ?? tableKeyAlias;
+            const dateFields = ["createdAt", "updatedAt"];
+            const isDateField = dateFields.includes(entityKey);
+            const meta = {
+                name: entityKey,
+                alias,
+                nullable: false,
+                serializers: isDateField ? decorators_1.dateSerializer : undefined
+            };
+            acc.entityDefaults[entityKey] = meta;
+            acc.tableDefaults[alias] = meta;
+            return acc;
+        }, { entityDefaults: {}, tableDefaults: {} });
+    }
+    /**
+     * Adds the partition key attribute to Table metadata storage
+     * @param options
+     */
+    addPartitionKeyAttribute(options) {
+        const opts = { ...options, nullable: false };
+        this.partitionKeyAttribute = new _1.AttributeMetadata(opts);
+    }
+    /**
+     * Adds the sort key attribute to Table metadata storage
+     * @param options
+     */
+    addSortKeyAttribute(options) {
+        const opts = { ...options, nullable: false };
+        this.sortKeyAttribute = new _1.AttributeMetadata(opts);
+    }
+}
+exports.default = TableMetadata;

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

@@ -0,0 +1,13 @@
+import TableMetadata from "./TableMetadata";
+import EntityMetadata from "./EntityMetadata";
+import AttributeMetadata from "./AttributeMetadata";
+import MetadataStorage from "./MetadataStorage";
+import JoinTableMetadata from "./JoinTableMetadata";
+declare const _default: MetadataStorage;
+export default _default;
+export { TableMetadata, EntityMetadata, AttributeMetadata, JoinTableMetadata };
+export * from "./MetadataStorage";
+export * from "./TableMetadata";
+export * from "./relationship-metadata";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metadata/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAC9C,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAChD,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;;AAEpD,wBAAqC;AACrC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;AAE/E,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,SAAS,CAAC"}

package/dist/src/metadata/index.js

@@ -0,0 +1,34 @@
+"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.JoinTableMetadata = exports.AttributeMetadata = exports.EntityMetadata = exports.TableMetadata = void 0;
+const TableMetadata_1 = __importDefault(require("./TableMetadata"));
+exports.TableMetadata = TableMetadata_1.default;
+const EntityMetadata_1 = __importDefault(require("./EntityMetadata"));
+exports.EntityMetadata = EntityMetadata_1.default;
+const AttributeMetadata_1 = __importDefault(require("./AttributeMetadata"));
+exports.AttributeMetadata = AttributeMetadata_1.default;
+const MetadataStorage_1 = __importDefault(require("./MetadataStorage"));
+const JoinTableMetadata_1 = __importDefault(require("./JoinTableMetadata"));
+exports.JoinTableMetadata = JoinTableMetadata_1.default;
+exports.default = new MetadataStorage_1.default();
+__exportStar(require("./MetadataStorage"), exports);
+__exportStar(require("./TableMetadata"), exports);
+__exportStar(require("./relationship-metadata"), exports);
+__exportStar(require("./types"), exports);