dyna-record 0.0.20 → 0.1.1

package/README.md

@@ -134,49 +134,35 @@ class Course extends MyTable {
 
 ### Attributes
 
-For [natively supported data types](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes), define attributes using the [@Attribute](https://dyna-record.com/functions/Attribute.html) or [@NullableAttribute](https://dyna-record.com/functions/NullableAttribute.html) decorators. This decorator maps class properties to DynamoDB table attributes.
+Use the attribute decorators below to define attributes on a model. The decorator maps class properties to DynamoDB table attributes.
+
+- Attribute decorators
+
+  - [@StringAttribute](https://dyna-record.com/functions/StringAttribute.html)
+  - [@NumberAttribute](https://dyna-record.com/functions/NumberAttribute.html)
+  - [@BooleanAttribute](https://dyna-record.com/functions/BooleanAttribute.html)
+  - [@DateAttribute](https://dyna-record.com/functions/DateAttribute.html)
 
 - The [alias](https://dyna-record.com/interfaces/AttributeOptions.html#alias) option allows you to specify the attribute name as it appears in the DynamoDB table, different from your class property name.
 - Set nullable attributes as optional for optimal type safety
 - Attempting to remove a non-nullable attribute will result in a [NullConstrainViolationError](https://dyna-record.com/classes/NullConstraintViolationError.html)
 
 ```typescript
-import { Entity, Attribute, NullableAttribute } from "dyna-record";
+import { Entity, Attribute } from "dyna-record";
 
 @Entity
 class Student extends MyTable {
-  @Attribute({ alias: "Username" }) // Sets alias if field in Dynamo is different then on the model
+  @StringAttribute({ alias: "Username" }) // Sets alias if field in Dynamo is different then on the model
   public username: string;
 
-  @Attribute() // Dynamo field and entity field are the same
+  @StringAttribute() // Dynamo field and entity field are the same
   public email: string;
 
-  @NullableAttribute()
+  @NumberAttribute({ nullable: true })
   public someAttribute?: number; // Mark as optional
 }
 ```
 
-### Date Attributes
-
-Dates are not natively supported in Dynamo. To define a date attribute use [@DateAttribute](https://dyna-record.com/functions/DateAttribute.html) or [@NullableDateAttribute](https://dyna-record.com/functions/DateNullableAttribute.html) decorators. dyna-record will save the values as ISO strings in Dynamo, but serialize them as JS date objects on the entity instance
-
-- The [alias](https://dyna-record.com/interfaces/AttributeOptions.html#alias) option allows you to specify the attribute name as it appears in the DynamoDB table, different from your class property name.
-- Set nullable attributes as optional for optimal type safety
-- Attempting to remove a non-nullable attribute will result in a [NullConstrainViolationError](https://dyna-record.com/classes/NullConstraintViolationError.html)
-
-```typescript
-import { Entity, DateAttribute, NullableDateAttribute } from "dyna-record";
-
-@Entity
-class Student extends MyTable {
-  @DateAttribute()
-  public readonly signUpDate: Date;
-
-  @NullableDateAttribute({ alias: "LastLogin" })
-  public readonly lastLogin?: Date; // Set as optional
-}
-```
-
 ### Foreign Keys
 
 Define foreign keys in order to support [@BelongsTo](https://dyna-record.com/functions/BelongsTo.html) relationships. A foreign key is required for [@HasOne](https://dyna-record.com/functions/HasOne.html) and [@HasMany](https://dyna-record.com/functions/HasMany.html) relationships.
@@ -190,7 +176,6 @@ import {
   Entity,
   ForeignKeyAttribute,
   ForeignKey,
-  NullableForeignKeyAttribute,
   NullableForeignKey,
   BelongsTo
 } from "dyna-record";
@@ -206,7 +191,7 @@ class Assignment extends MyTable {
 
 @Entity
 class Course extends MyTable {
-  @NullableForeignKeyAttribute()
+  @ForeignKeyAttribute({ nullable: true })
   public readonly teacherId?: NullableForeignKey; // Set as optional
 
   @BelongsTo(() => Teacher, { foreignKey: "teacherId" })
@@ -220,8 +205,7 @@ Dyna-Record supports defining relationships between entities such as [@HasOne](h
 
 A relationship can be defined as nullable or non-nullable. Non-nullable relationships will be enforced via transactions and violations will result in [NullConstraintViolationError](https://dyna-record.com/classes/NullConstraintViolationError.html)
 
-- [@ForeignKeyAttribute](https://dyna-record.com/functions/ForeignKeyAttribute.html) is used to define a foreign key that links to another entity and is not nullable.
-- [@NullableForeignKeyAttribute](https://dyna-record.com/functions/NullableForeignKeyAttribute.html) is used to define a foreign key that links to another entity and is nullable.
+- [@ForeignKeyAttribute](https://dyna-record.com/functions/ForeignKeyAttribute.html) is used to define a foreign key that links to another entity
 - Relationship decorators ([@HasOne](#hasone), [@HasMany](#hasmany), [@BelongsTo](https://dyna-record.com/functions/BelongsTo.html), [@HasAndBelongsToMany](#hasandbelongstomany)) define how entities relate to each other.
 
 #### HasOne
@@ -260,13 +244,7 @@ class Grade extends MyTable {
 [Docs](https://dyna-record.com/functions/HasMany.html)
 
 ```typescript
-import {
-  Entity,
-  NullableForeignKeyAttribute,
-  NullableForeignKey,
-  BelongsTo,
-  HasMany
-} from "dyna-record";
+import { Entity, NullableForeignKey, BelongsTo, HasMany } from "dyna-record";
 
 @Entity
 class Teacher extends MyTable {
@@ -277,8 +255,8 @@ class Teacher extends MyTable {
 
 @Entity
 class Course extends MyTable {
-  @NullableForeignKeyAttribute()
-  public readonly teacherId?: NullableForeignKey;
+  @ForeignKeyAttribute({ nullable: true })
+  public readonly teacherId?: NullableForeignKey; // Mark as optional
 
   // 'teacherId' Must be defined on self as ForeignKey or NullableForeignKey
   @BelongsTo(() => Teacher, { foreignKey: "teacherId" })

package/dist/src/DynaRecord.d.ts

@@ -171,7 +171,7 @@ declare abstract class DynaRecord implements DynaRecordBase {
      * Update an entity. If foreign keys are included in the attribute then:
      *   - BelongsToLinks will be created accordingly
      *   - If the entity already had a foreign key relationship, then those BelongsToLinks will be deleted
-     *     - If the foreign key is not nullable then a {@link NullConstraintViolationError} is thrown. See {@link NullableForeignKeyAttribute}
+     *     - If the foreign key is not nullable then a {@link NullConstraintViolationError} is thrown.
      *   - Validation errors will be thrown if the attribute being removed is not nullable
      * @param id - The id of the entity to update
      * @param attributes - Attributes to update

package/dist/src/DynaRecord.js

@@ -96,8 +96,8 @@ let DynaRecord = (() => {
     return class DynaRecord {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _id_decorators = [(0, decorators_1.Attribute)({ alias: metadata_1.tableDefaultFields.id.alias })];
-            _type_decorators = [(0, decorators_1.Attribute)({ alias: metadata_1.tableDefaultFields.type.alias })];
+            _id_decorators = [(0, decorators_1.StringAttribute)({ alias: metadata_1.tableDefaultFields.id.alias })];
+            _type_decorators = [(0, decorators_1.StringAttribute)({ alias: metadata_1.tableDefaultFields.type.alias })];
             _createdAt_decorators = [(0, decorators_1.DateAttribute)({ alias: metadata_1.tableDefaultFields.createdAt.alias })];
             _updatedAt_decorators = [(0, decorators_1.DateAttribute)({ alias: metadata_1.tableDefaultFields.updatedAt.alias })];
             __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _instanceExtraInitializers);
@@ -163,7 +163,7 @@ let DynaRecord = (() => {
          * Update an entity. If foreign keys are included in the attribute then:
          *   - BelongsToLinks will be created accordingly
          *   - If the entity already had a foreign key relationship, then those BelongsToLinks will be deleted
-         *     - If the foreign key is not nullable then a {@link NullConstraintViolationError} is thrown. See {@link NullableForeignKeyAttribute}
+         *     - If the foreign key is not nullable then a {@link NullConstraintViolationError} is thrown.
          *   - Validation errors will be thrown if the attribute being removed is not nullable
          * @param id - The id of the entity to update
          * @param attributes - Attributes to update

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

@@ -0,0 +1,28 @@
+import type DynaRecord from "../../DynaRecord";
+import type { AttributeDecoratorContext, AttributeOptions } from "../types";
+/**
+ * A decorator for marking class fields as boolean attributes within the context of a single-table design entity
+ *
+ * Can be set to nullable via decorator props
+ *
+ * @template T The class type that the decorator is applied to, ensuring type safety and integration within specific class instances.
+ * @template K A type constraint extending `boolean`, ensuring that the decorator is only applied to class fields specifically intended to represent booleans.
+ * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default.
+ * @returns A class field decorator function that operates within the class field's context. It configures the field as a boolean attribute and defines how it should be serialized and deserialized to/from DynamoDB.
+ *
+ * Usage example:
+ * ```typescript
+ * class MyEntity extends MyTable {
+ *   @BooleanAttribute({ alias: 'MyField' })
+ *   public myField: boolean;
+ *
+ *   @BooleanAttribute({ alias: 'MyNullableField', nullable: true })
+ *   public myField?: boolean; // Set to Optional
+ * }
+ * ```
+ *
+ * Here, `@BooleanAttribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
+ */
+declare function BooleanAttribute<T extends DynaRecord, K extends boolean, P extends AttributeOptions>(props?: P): (_value: undefined, context: AttributeDecoratorContext<T, K, P>) => void;
+export default BooleanAttribute;
+//# sourceMappingURL=BooleanAttribute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/BooleanAttribute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iBAAS,gBAAgB,CACvB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,OAAO,EACjB,CAAC,SAAS,gBAAgB,EAC1B,KAAK,CAAC,EAAE,CAAC,YAEC,SAAS,WACR,0BAA0B,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,UAe9C;AAED,eAAe,gBAAgB,CAAC"}

package/dist/src/decorators/attributes/{NullableAttribute.js → BooleanAttribute.js}

@@ -3,39 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
 const metadata_1 = __importDefault(require("../../metadata"));
 /**
- * Similar to '@Attribute' but specific to Dates since Dates are not native types to dynamo
+ * A decorator for marking class fields as boolean attributes within the context of a single-table design entity
  *
- * IMPORTANT - For optimal type safety mark the class field property as optional
+ * Can be set to nullable via decorator props
  *
  * @template T The class type that the decorator is applied to, ensuring type safety and integration within specific class instances.
- * @template K A type constraint extending `Date`, ensuring that the decorator is only applied to class fields specifically intended to represent dates.
- * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `true` by default, indicating that the date attribute can be empty.
- * @returns A class field decorator function that operates within the class field's context. It configures the field as a date attribute and defines how it should be serialized and deserialized to/from DynamoDB.
+ * @template K A type constraint extending `boolean`, ensuring that the decorator is only applied to class fields specifically intended to represent booleans.
+ * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default.
+ * @returns A class field decorator function that operates within the class field's context. It configures the field as a boolean attribute and defines how it should be serialized and deserialized to/from DynamoDB.
  *
  * Usage example:
  * ```typescript
  * class MyEntity extends MyTable {
- *   @NullableAttribute({ alias: 'MyField' })
- *   public myField?: string; // Set to Optional
+ *   @BooleanAttribute({ alias: 'MyField' })
+ *   public myField: boolean;
+ *
+ *   @BooleanAttribute({ alias: 'MyNullableField', nullable: true })
+ *   public myField?: boolean; // Set to Optional
  * }
  * ```
  *
- * Here, `@Attribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
+ * Here, `@BooleanAttribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
  */
-function NullableAttribute(props) {
+function BooleanAttribute(props) {
     return function (_value, context) {
         if (context.kind === "field") {
             context.addInitializer(function () {
                 const entity = Object.getPrototypeOf(this);
                 metadata_1.default.addEntityAttribute(entity.constructor.name, {
                     attributeName: context.name.toString(),
-                    nullable: true,
+                    nullable: props?.nullable,
+                    type: zod_1.z.boolean(),
                     ...props
                 });
             });
         }
     };
 }
-exports.default = NullableAttribute;
+exports.default = BooleanAttribute;

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

@@ -1,13 +1,15 @@
 import type DynaRecord from "../../DynaRecord";
-import type { AttributeOptions } from "../types";
+import type { AttributeDecoratorContext, AttributeOptions } from "../types";
 /**
- * Similar to '@Attribute' but specific to Dates since Dates are not native types to dynamo
+ * A decorator for marking class fields as date attributes within the context of a single-table design entity
  *
- * Does not allow property to be optional.
+ * Because dates are not natively supported data types in dynamo, they will be converted to iso string's within dynamo, and serialized to date objects on the entity class
+ *
+ * Can be set to nullable via decorator props
  *
  * @template T The class type that the decorator is applied to, ensuring type safety and integration within specific class instances.
  * @template K A type constraint extending `Date`, ensuring that the decorator is only applied to class fields specifically intended to represent dates.
- * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default; the attribute must not be empty.
+ * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default.
  * @returns A class field decorator function that operates within the class field's context. It configures the field as a date attribute and defines how it should be serialized and deserialized to/from DynamoDB.
  *
  * Usage example:
@@ -15,11 +17,14 @@ import type { AttributeOptions } from "../types";
  * class MyEntity extends MyTable {
  *   @DateAttribute({ alias: 'MyField' })
  *   public myField: Date;
+ *
+ *   @DateAttribute({ alias: 'MyNullableField', nullable: true })
+ *   public myField?: Date; // Set to Optional
  * }
  * ```
  *
- * Here, `@Attribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
+ * Here, `@DateAttribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
  */
-declare function DateAttribute<T extends DynaRecord, K extends Date>(props?: AttributeOptions): (_value: undefined, context: ClassFieldDecoratorContext<T, K>) => void;
+declare function DateAttribute<T extends DynaRecord, K extends Date, P extends AttributeOptions>(props?: P): (_value: undefined, context: AttributeDecoratorContext<T, K, P>) => void;
 export default DateAttribute;
 //# sourceMappingURL=DateAttribute.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DateAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/DateAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iBAAS,aAAa,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,IAAI,EACzD,KAAK,CAAC,EAAE,gBAAgB,YAGd,SAAS,WACR,2BAA2B,CAAC,EAAE,CAAC,CAAC,UAe5C;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"DateAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/DateAttribute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iBAAS,aAAa,CACpB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,IAAI,EACd,CAAC,SAAS,gBAAgB,EAC1B,KAAK,CAAC,EAAE,CAAC,YAEC,SAAS,WACR,0BAA0B,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,UAgB9C;AAED,eAAe,aAAa,CAAC"}

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

@@ -3,16 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
 const metadata_1 = __importDefault(require("../../metadata"));
 const serializers_1 = require("./serializers");
 /**
- * Similar to '@Attribute' but specific to Dates since Dates are not native types to dynamo
+ * A decorator for marking class fields as date attributes within the context of a single-table design entity
  *
- * Does not allow property to be optional.
+ * Because dates are not natively supported data types in dynamo, they will be converted to iso string's within dynamo, and serialized to date objects on the entity class
+ *
+ * Can be set to nullable via decorator props
  *
  * @template T The class type that the decorator is applied to, ensuring type safety and integration within specific class instances.
  * @template K A type constraint extending `Date`, ensuring that the decorator is only applied to class fields specifically intended to represent dates.
- * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default; the attribute must not be empty.
+ * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default.
  * @returns A class field decorator function that operates within the class field's context. It configures the field as a date attribute and defines how it should be serialized and deserialized to/from DynamoDB.
  *
  * Usage example:
@@ -20,10 +23,13 @@ const serializers_1 = require("./serializers");
  * class MyEntity extends MyTable {
  *   @DateAttribute({ alias: 'MyField' })
  *   public myField: Date;
+ *
+ *   @DateAttribute({ alias: 'MyNullableField', nullable: true })
+ *   public myField?: Date; // Set to Optional
  * }
  * ```
  *
- * Here, `@Attribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
+ * Here, `@DateAttribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
  */
 function DateAttribute(props) {
     return function (_value, context) {
@@ -32,8 +38,9 @@ function DateAttribute(props) {
                 const entity = Object.getPrototypeOf(this);
                 metadata_1.default.addEntityAttribute(entity.constructor.name, {
                     attributeName: context.name.toString(),
-                    nullable: false,
+                    nullable: props?.nullable,
                     serializers: serializers_1.dateSerializer,
+                    type: zod_1.z.date(),
                     ...props
                 });
             });

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

@@ -1,6 +1,6 @@
 import type DynaRecord from "../../DynaRecord";
-import type { ForeignKey } from "../../types";
-import type { AttributeOptions } from "../types";
+import type { ForeignKey, NullableForeignKey } from "../../types";
+import type { AttributeDecoratorContext, AttributeOptions } from "../types";
 /**
  * A decorator for annotating class fields as foreign keys within the context of a single-table design entity, aimed at establishing and managing relationships between different entities in a relational manner. This decorator enables the clear and explicit declaration of foreign key relationships, contributing to the ORM's ability to navigate and resolve these associations efficiently.
  *
@@ -16,15 +16,21 @@ import type { AttributeOptions } from "../types";
  * ```typescript
  * class Order extends BaseEntity {
  *   @ForeignKeyAttribute({ alias: 'UserID' })
- *   public userId: ForeignKey; // Foreign key to the User entity. Cannot be optional. See NullableForeignKeyAttribute otherwise
+ *   public userId: ForeignKey; // Foreign key to the User entity. Cannot be optional.
  *
  *   @BelongsTo(() => User, { foreignKey: "userId" })
  *   public readonly user: User; // Cannot be optional
+ *
+ *   @ForeignKeyAttribute({ alias: 'ProfileId', nullable: true })
+ *   public profileId?: NullableForeignKey; // Set to optional. Nullable foreign key to another entity (e.g., UserProfile)
+ *
+ *   @BelongsTo(() => Profile, { foreignKey: "profileId" })
+ *   public readonly profile?: Profile; // Set to optional because its linked via a NullableForeignKey
  * }
  * ```
  *
  * Here, `@ForeignKeyAttribute` decorates `userId` of `Order`, designating it as a foreign key that references the `User` entity. This decoration not only clarifies the nature of the relationship but also empowers the ORM to enforce relational integrity and facilitate entity association operations.
  */
-declare function ForeignKeyAttribute<T extends DynaRecord>(props?: AttributeOptions): (_value: undefined, context: ClassFieldDecoratorContext<T, ForeignKey>) => void;
+declare function ForeignKeyAttribute<T extends DynaRecord, P extends AttributeOptions>(props?: P): (_value: undefined, context: AttributeDecoratorContext<T, P["nullable"] extends true ? NullableForeignKey : ForeignKey, P>) => void;
 export default ForeignKeyAttribute;
 //# sourceMappingURL=ForeignKeyAttribute.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ForeignKeyAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/ForeignKeyAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,mBAAmB,CAAC,CAAC,SAAS,UAAU,EAAE,KAAK,CAAC,EAAE,gBAAgB,YAE/D,SAAS,WACR,2BAA2B,CAAC,EAAE,UAAU,CAAC,UAcrD;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"ForeignKeyAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/ForeignKeyAttribute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iBAAS,mBAAmB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,gBAAgB,EAC3E,KAAK,CAAC,EAAE,CAAC,YAGC,SAAS,WACR,0BACP,CAAC,EACD,CAAC,CAAC,UAAU,CAAC,SAAS,IAAI,GAAG,kBAAkB,GAAG,UAAU,EAC5D,CAAC,CACF,UAeJ;AAED,eAAe,mBAAmB,CAAC"}

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
 const metadata_1 = __importDefault(require("../../metadata"));
 /**
  * A decorator for annotating class fields as foreign keys within the context of a single-table design entity, aimed at establishing and managing relationships between different entities in a relational manner. This decorator enables the clear and explicit declaration of foreign key relationships, contributing to the ORM's ability to navigate and resolve these associations efficiently.
@@ -19,10 +20,16 @@ const metadata_1 = __importDefault(require("../../metadata"));
  * ```typescript
  * class Order extends BaseEntity {
  *   @ForeignKeyAttribute({ alias: 'UserID' })
- *   public userId: ForeignKey; // Foreign key to the User entity. Cannot be optional. See NullableForeignKeyAttribute otherwise
+ *   public userId: ForeignKey; // Foreign key to the User entity. Cannot be optional.
  *
  *   @BelongsTo(() => User, { foreignKey: "userId" })
  *   public readonly user: User; // Cannot be optional
+ *
+ *   @ForeignKeyAttribute({ alias: 'ProfileId', nullable: true })
+ *   public profileId?: NullableForeignKey; // Set to optional. Nullable foreign key to another entity (e.g., UserProfile)
+ *
+ *   @BelongsTo(() => Profile, { foreignKey: "profileId" })
+ *   public readonly profile?: Profile; // Set to optional because its linked via a NullableForeignKey
  * }
  * ```
  *
@@ -35,7 +42,8 @@ function ForeignKeyAttribute(props) {
                 const entity = Object.getPrototypeOf(this);
                 metadata_1.default.addEntityAttribute(entity.constructor.name, {
                     attributeName: context.name.toString(),
-                    nullable: false,
+                    nullable: props?.nullable,
+                    type: zod_1.z.string(),
                     ...props
                 });
             });

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

@@ -0,0 +1,28 @@
+import type DynaRecord from "../../DynaRecord";
+import type { AttributeDecoratorContext, AttributeOptions } from "../types";
+/**
+ * A decorator for marking class fields as number attributes within the context of a single-table design entity
+ *
+ * Can be set to nullable via decorator props
+ *
+ * @template T The class type that the decorator is applied to, ensuring type safety and integration within specific class instances.
+ * @template K A type constraint extending `number`, ensuring that the decorator is only applied to class fields specifically intended to represent numbers.
+ * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default.
+ * @returns A class field decorator function that operates within the class field's context. It configures the field as a number attribute and defines how it should be serialized and deserialized to/from DynamoDB.
+ *
+ * Usage example:
+ * ```typescript
+ * class MyEntity extends MyTable {
+ *   @NumberAttribute({ alias: 'MyField' })
+ *   public myField: number;
+ *
+ *   @NumberAttribute({ alias: 'MyNullableField', nullable: true })
+ *   public myField?: number; // Set to Optional
+ * }
+ * ```
+ *
+ * Here, `@NumberAttribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
+ */
+declare function NumberAttribute<T extends DynaRecord, K extends number, P extends AttributeOptions>(props?: P): (_value: undefined, context: AttributeDecoratorContext<T, K, P>) => void;
+export default NumberAttribute;
+//# sourceMappingURL=NumberAttribute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NumberAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/NumberAttribute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iBAAS,eAAe,CACtB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,gBAAgB,EAC1B,KAAK,CAAC,EAAE,CAAC,YAEC,SAAS,WACR,0BAA0B,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,UAe9C;AAED,eAAe,eAAe,CAAC"}

package/dist/src/decorators/attributes/{DateNullableAttribute.js → NumberAttribute.js}

@@ -3,41 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
 const metadata_1 = __importDefault(require("../../metadata"));
-const serializers_1 = require("./serializers");
 /**
- * Similar to '@Attribute' but specific to Dates since Dates are not native types to dynamo
+ * A decorator for marking class fields as number attributes within the context of a single-table design entity
  *
- * IMPORTANT - For optimal type safety mark the class field property as optional
+ * Can be set to nullable via decorator props
  *
  * @template T The class type that the decorator is applied to, ensuring type safety and integration within specific class instances.
- * @template K A type constraint extending `Date`, ensuring that the decorator is only applied to class fields specifically intended to represent dates.
- * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default, indicating that the date attribute must not be empty.
- * @returns A class field decorator function that operates within the class field's context. It configures the field as a date attribute and defines how it should be serialized and deserialized to/from DynamoDB.
+ * @template K A type constraint extending `number`, ensuring that the decorator is only applied to class fields specifically intended to represent numbers.
+ * @param props An {@link AttributeOptions} object providing configuration options for the attribute, such as its `alias` which allows the attribute to be referred to by an alternative name in the database context. The `nullable` property is also set to `false` by default.
+ * @returns A class field decorator function that operates within the class field's context. It configures the field as a number attribute and defines how it should be serialized and deserialized to/from DynamoDB.
  *
  * Usage example:
  * ```typescript
  * class MyEntity extends MyTable {
- *   @DateNullableAttribute({ alias: 'MyField' })
- *   public myField?: Date; // Set to Optional
+ *   @NumberAttribute({ alias: 'MyField' })
+ *   public myField: number;
+ *
+ *   @NumberAttribute({ alias: 'MyNullableField', nullable: true })
+ *   public myField?: number; // Set to Optional
  * }
  * ```
  *
- * Here, `@Attribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
+ * Here, `@NumberAttribute` decorates `myField` of `MyEntity`, marking it as an entity attribute with an alias 'MyField' for ORM purposes.
  */
-function DateNullableAttribute(props) {
+function NumberAttribute(props) {
     return function (_value, context) {
         if (context.kind === "field") {
             context.addInitializer(function () {
                 const entity = Object.getPrototypeOf(this);
                 metadata_1.default.addEntityAttribute(entity.constructor.name, {
                     attributeName: context.name.toString(),
-                    nullable: true,
-                    serializers: serializers_1.dateSerializer,
+                    nullable: props?.nullable,
+                    type: zod_1.z.number(),
                     ...props
                 });
             });
         }
     };
 }
-exports.default = DateNullableAttribute;
+exports.default = NumberAttribute;

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

@@ -1,12 +1,12 @@
 import type DynaRecord from "../../DynaRecord";
 import { type PartitionKey } from "../../types";
-import type { AttributeOptions } from "../types";
+import type { NonNullAttributeOptions } from "../types";
 /**
  * A decorator for designating the field for the partition key on the dynamo table.
  *
  * @template T The entity to which the decorator is applied.
  * @template K The type constraint ensuring the field is suitable to be a partition key.
- * @param props An optional object of {@link AttributeOptions}, providing additional configuration for the partition key attribute, such as custom metadata.
+ * @param props An optional object of {@link NonNullAttributeOptions}, providing additional configuration for the partition key attribute, such as custom metadata.
  * @returns A class field decorator function that targets and initializes the class's prototype to register the partition key with the ORM's metadata system.
  *
  * Usage example:
@@ -19,6 +19,6 @@ import type { AttributeOptions } from "../types";
  *
  * In this example, `@PartitionKeyAttribute` decorates the `pk` field of `User`, marking it as the entity's partition key.
  */
-declare function PartitionKeyAttribute<T extends DynaRecord, K extends PartitionKey>(props?: AttributeOptions): (_value: undefined, context: ClassFieldDecoratorContext<T, K>) => void;
+declare function PartitionKeyAttribute<T extends DynaRecord, K extends PartitionKey>(props?: NonNullAttributeOptions): (_value: undefined, context: ClassFieldDecoratorContext<T, K>) => void;
 export default PartitionKeyAttribute;
 //# sourceMappingURL=PartitionKeyAttribute.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PartitionKeyAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/PartitionKeyAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,qBAAqB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,YAAY,EACzE,KAAK,CAAC,EAAE,gBAAgB,YAGd,SAAS,WACR,2BAA2B,CAAC,EAAE,CAAC,CAAC,UAa5C;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"PartitionKeyAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/PartitionKeyAttribute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,qBAAqB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,YAAY,EACzE,KAAK,CAAC,EAAE,uBAAuB,YAGrB,SAAS,WACR,2BAA2B,CAAC,EAAE,CAAC,CAAC,UAc5C;AAED,eAAe,qBAAqB,CAAC"}

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

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
 const metadata_1 = __importDefault(require("../../metadata"));
 /**
  * A decorator for designating the field for the partition key on the dynamo table.
  *
  * @template T The entity to which the decorator is applied.
  * @template K The type constraint ensuring the field is suitable to be a partition key.
- * @param props An optional object of {@link AttributeOptions}, providing additional configuration for the partition key attribute, such as custom metadata.
+ * @param props An optional object of {@link NonNullAttributeOptions}, providing additional configuration for the partition key attribute, such as custom metadata.
  * @returns A class field decorator function that targets and initializes the class's prototype to register the partition key with the ORM's metadata system.
  *
  * Usage example:
@@ -29,6 +30,7 @@ function PartitionKeyAttribute(props) {
                 const entity = Object.getPrototypeOf(this);
                 metadata_1.default.addPartitionKeyAttribute(entity, {
                     attributeName: context.name.toString(),
+                    type: zod_1.z.string(),
                     ...props
                 });
             });

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

@@ -1,12 +1,12 @@
 import type DynaRecord from "../../DynaRecord";
 import { type SortKey } from "../../types";
-import type { AttributeOptions } from "../types";
+import type { NonNullAttributeOptions } from "../types";
 /**
  * A decorator for designating the field for the sort key on the dynamo table.
  *
  * @template T The entity to which the decorator is applied.
  * @template K The type constraint ensuring the field is suitable to be a partition key.
- * @param props An optional object of {@link AttributeOptions}, providing additional configuration for the sort key attribute, such as custom metadata.
+ * @param props An optional object of {@link NonNullAttributeOptions}, providing additional configuration for the sort key attribute, such as custom metadata.
  * @returns A class field decorator function that targets and initializes the class's prototype to register the sort key with the ORM's metadata system.
  *
  * Usage example:
@@ -19,6 +19,6 @@ import type { AttributeOptions } from "../types";
  *
  * In this example, `@SortKeyAttribute` decorates the `sk` field of `User`, marking it as the entity's sort key.
  */
-declare function SortKeyAttribute<T extends DynaRecord, K extends SortKey>(props?: AttributeOptions): (_value: undefined, context: ClassFieldDecoratorContext<T, K>) => void;
+declare function SortKeyAttribute<T extends DynaRecord, K extends SortKey>(props?: NonNullAttributeOptions): (_value: undefined, context: ClassFieldDecoratorContext<T, K>) => void;
 export default SortKeyAttribute;
 //# sourceMappingURL=SortKeyAttribute.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SortKeyAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/SortKeyAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO,EAC/D,KAAK,CAAC,EAAE,gBAAgB,YAGd,SAAS,WACR,2BAA2B,CAAC,EAAE,CAAC,CAAC,UAa5C;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"SortKeyAttribute.d.ts","sourceRoot":"","sources":["../../../../src/decorators/attributes/SortKeyAttribute.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,iBAAS,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO,EAC/D,KAAK,CAAC,EAAE,uBAAuB,YAGrB,SAAS,WACR,2BAA2B,CAAC,EAAE,CAAC,CAAC,UAc5C;AAED,eAAe,gBAAgB,CAAC"}

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

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
 const metadata_1 = __importDefault(require("../../metadata"));
 /**
  * A decorator for designating the field for the sort key on the dynamo table.
  *
  * @template T The entity to which the decorator is applied.
  * @template K The type constraint ensuring the field is suitable to be a partition key.
- * @param props An optional object of {@link AttributeOptions}, providing additional configuration for the sort key attribute, such as custom metadata.
+ * @param props An optional object of {@link NonNullAttributeOptions}, providing additional configuration for the sort key attribute, such as custom metadata.
  * @returns A class field decorator function that targets and initializes the class's prototype to register the sort key with the ORM's metadata system.
  *
  * Usage example:
@@ -29,6 +30,7 @@ function SortKeyAttribute(props) {
                 const entity = Object.getPrototypeOf(this);
                 metadata_1.default.addSortKeyAttribute(entity, {
                     attributeName: context.name.toString(),
+                    type: zod_1.z.string(),
                     ...props
                 });
             });