dyna-record 0.0.1

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

@@ -0,0 +1,30 @@
+import type DynaRecord from "../DynaRecord";
+import { type EntityAttributes } from "../operations/types";
+import type { NullableForeignKey, ForeignKey, Optional } from "../types";
+/**
+ * Returns attributes on the provided model which are EntityAttributes of type ForeignKey
+ */
+export type ForeignEntityAttribute<T extends DynaRecord> = {
+    [K in keyof T]: T[K] extends ForeignKey ? K : T[K] extends NullableForeignKey ? Optional<K> : never;
+}[keyof EntityAttributes<T>];
+/**
+ * Represents the properties of an attribute that are configurable via the {@link Attribute} decorator.
+ */
+export interface AttributeOptions {
+    /**
+     * An optional alias for the attribute as represented in the database table.
+     *
+     * This alias is used as the column name in the database table corresponding to
+     * the entity. If omitted, the ORM defaults to using the attribute's key as defined
+     * within the entity model. Specifying an alias allows for mapping between the
+     * entity's attribute names in the code and their respective column names in
+     * the database, providing flexibility in naming conventions and supporting
+     * scenarios where column names in the database differ from attribute names in the code.
+     */
+    alias?: string;
+}
+/**
+ * Do not allow ForeignKey or NullableForeignKey types when using the Attribute decorator
+ */
+export type NotForeignKey<T> = T extends ForeignKey | NullableForeignKey ? never : T;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/decorators/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,UAAU,IAAI;KACxD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,UAAU,GACnC,CAAC,GACD,CAAC,CAAC,CAAC,CAAC,SAAS,kBAAkB,GAC7B,QAAQ,CAAC,CAAC,CAAC,GACX,KAAK;CACZ,CAAC,MAAM,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7B;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,GAAG,kBAAkB,GACpE,KAAK,GACL,CAAC,CAAC"}

package/dist/src/decorators/types.js

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

package/dist/src/dynamo-utils/DynamoClient.d.ts

@@ -0,0 +1,34 @@
+import { type QueryCommandInput, type GetCommandInput, type GetCommandOutput, type TransactWriteCommandInput, type TransactWriteCommandOutput, type TransactGetCommandInput } from "@aws-sdk/lib-dynamodb";
+import type { QueryItems, TransactGetItemResponses } from "./types";
+/**
+ * A utility class for interacting with DynamoDB, providing static methods
+ * for common operations such as retrieving, querying, and transacting items.
+ */
+declare class DynamoClient {
+    /**
+     * Retrieves a single item from DynamoDB based on the provided parameters.
+     * @param params The parameters for the GetCommand to DynamoDB.
+     * @returns A Promise resolving to the retrieved item.
+     */
+    static getItem(params: GetCommandInput): Promise<GetCommandOutput["Item"]>;
+    /**
+     * Queries DynamoDB based on the provided parameters and returns the matching items.
+     * @param params The parameters for the QueryCommand to DynamoDB.
+     * @returns A Promise resolving to an array of the queried items.
+     */
+    static query(params: QueryCommandInput): Promise<QueryItems>;
+    /**
+     * Executes a transactional read operation in DynamoDB to get multiple items atomically.
+     * @param params The parameters for the TransactGetCommand to DynamoDB.
+     * @returns A Promise resolving to the responses of the transactional get operation.
+     */
+    static transactGetItems(params: TransactGetCommandInput): Promise<TransactGetItemResponses>;
+    /**
+     * Executes a transactional write operation in DynamoDB to write multiple items atomically.
+     * @param params The parameters for the TransactWriteCommand to DynamoDB.
+     * @returns A Promise resolving to the output of the transactional write operation.
+     */
+    static transactWriteItems(params: TransactWriteCommandInput): Promise<TransactWriteCommandOutput>;
+}
+export default DynamoClient;
+//# sourceMappingURL=DynamoClient.d.ts.map

package/dist/src/dynamo-utils/DynamoClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamoClient.d.ts","sourceRoot":"","sources":["../../../src/dynamo-utils/DynamoClient.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAOpE;;;GAGG;AAEH,cAAM,YAAY;IAChB;;;;OAIG;WACiB,OAAO,CACzB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAMpC;;;;OAIG;WACiB,KAAK,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAMzE;;;;OAIG;WACiB,gBAAgB,CAClC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,wBAAwB,CAAC;IAMpC;;;;OAIG;WACiB,kBAAkB,CACpC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,0BAA0B,CAAC;CAIvC;AAED,eAAe,YAAY,CAAC"}

package/dist/src/dynamo-utils/DynamoClient.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const Logger_1 = __importDefault(require("../Logger"));
+// Initialize the DynamoDB Document Client with a specific AWS region.
+const dynamo = lib_dynamodb_1.DynamoDBDocumentClient.from(new client_dynamodb_1.DynamoDBClient({ region: "us-west-2" }));
+/**
+ * A utility class for interacting with DynamoDB, providing static methods
+ * for common operations such as retrieving, querying, and transacting items.
+ */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class DynamoClient {
+    /**
+     * Retrieves a single item from DynamoDB based on the provided parameters.
+     * @param params The parameters for the GetCommand to DynamoDB.
+     * @returns A Promise resolving to the retrieved item.
+     */
+    static async getItem(params) {
+        Logger_1.default.log("getItem", { params });
+        const response = await dynamo.send(new lib_dynamodb_1.GetCommand(params));
+        return response.Item;
+    }
+    /**
+     * Queries DynamoDB based on the provided parameters and returns the matching items.
+     * @param params The parameters for the QueryCommand to DynamoDB.
+     * @returns A Promise resolving to an array of the queried items.
+     */
+    static async query(params) {
+        Logger_1.default.log("query", { params });
+        const response = await dynamo.send(new lib_dynamodb_1.QueryCommand(params));
+        return response.Items ?? [];
+    }
+    /**
+     * Executes a transactional read operation in DynamoDB to get multiple items atomically.
+     * @param params The parameters for the TransactGetCommand to DynamoDB.
+     * @returns A Promise resolving to the responses of the transactional get operation.
+     */
+    static async transactGetItems(params) {
+        Logger_1.default.log("transactGetItems", { params });
+        const response = await dynamo.send(new lib_dynamodb_1.TransactGetCommand(params));
+        return response.Responses ?? [];
+    }
+    /**
+     * Executes a transactional write operation in DynamoDB to write multiple items atomically.
+     * @param params The parameters for the TransactWriteCommand to DynamoDB.
+     * @returns A Promise resolving to the output of the transactional write operation.
+     */
+    static async transactWriteItems(params) {
+        Logger_1.default.log("transactWriteItems", { params });
+        return await dynamo.send(new lib_dynamodb_1.TransactWriteCommand(params));
+    }
+}
+exports.default = DynamoClient;

package/dist/src/dynamo-utils/TransactGetBuilder.d.ts

@@ -0,0 +1,18 @@
+import type { Get, TransactGetItemResponses } from "./types";
+/**
+ * Build and executes a [TransactGetItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html) request
+ */
+declare class TransactGetBuilder {
+    #private;
+    /**
+     * Execute the transaction
+     */
+    executeTransaction(): Promise<TransactGetItemResponses>;
+    /**
+     * Add a get operation to the transaction
+     * @param item
+     */
+    addGet(item: Get): void;
+}
+export default TransactGetBuilder;
+//# sourceMappingURL=TransactGetBuilder.d.ts.map

package/dist/src/dynamo-utils/TransactGetBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactGetBuilder.d.ts","sourceRoot":"","sources":["../../../src/dynamo-utils/TransactGetBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,wBAAwB,EAAoB,MAAM,SAAS,CAAC;AAK/E;;GAEG;AACH,cAAM,kBAAkB;;IAGtB;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAiB7D;;;OAGG;IACI,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI;CAG/B;AAED,eAAe,kBAAkB,CAAC"}

package/dist/src/dynamo-utils/TransactGetBuilder.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DynamoClient_1 = __importDefault(require("./DynamoClient"));
+const utils_1 = require("../utils");
+// https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html
+const MAX_TRANSACTION_ITEMS = 100;
+/**
+ * Build and executes a [TransactGetItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html) request
+ */
+class TransactGetBuilder {
+    #transactionItems = [];
+    /**
+     * Execute the transaction
+     */
+    async executeTransaction() {
+        const transactionChunks = (0, utils_1.chunkArray)(this.#transactionItems, MAX_TRANSACTION_ITEMS);
+        // Break transaction into chunks of 100 due to Dynamo limit
+        const res = await Promise.all(transactionChunks.map(async (chunk) => await DynamoClient_1.default.transactGetItems({ TransactItems: chunk })));
+        return res.flat();
+    }
+    /**
+     * Add a get operation to the transaction
+     * @param item
+     */
+    addGet(item) {
+        this.#transactionItems.push({ Get: item });
+    }
+}
+exports.default = TransactGetBuilder;

package/dist/src/dynamo-utils/TransactWriteBuilder.d.ts

@@ -0,0 +1,46 @@
+import type { ConditionCheck, Put, Update, Delete } from "./types";
+/**
+ * Build and executes a [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) request
+ */
+declare class TransactionBuilder {
+    #private;
+    /**
+     * Execute the transaction
+     */
+    executeTransaction(): Promise<void>;
+    /**
+     * Add a conditional check to the transaction
+     * @param item
+     */
+    addConditionCheck(item: ConditionCheck, conditionFailedMsg: string): void;
+    /**
+     * Add a put operation to the transaction
+     * @param item
+     */
+    addPut(item: Put, conditionFailedMsg?: string): void;
+    /**
+     * Add an update operation to the transaction
+     * @param item
+     */
+    addUpdate(item: Update, conditionFailedMsg?: string): void;
+    /**
+     * Add a delete operation to the transaction
+     * @param item
+     */
+    addDelete(item: Delete, conditionFailedMsg?: string): void;
+    /**
+     * Track error messages to return if there is a ConditionalCheckFailed exception
+     *
+     * IMPORTANT - Call this before adding the transaction to this.#transactionItems
+     * @param errMsg The custom error message to return if there is a ConditionalCheckFailed exception
+     */
+    private trackErrorMessage;
+    /**
+     * Handle TransactionCanceledException, aggregating errors and applying friendly errors if provided.
+     * @param error
+     * @returns
+     */
+    private buildTransactionCanceledException;
+}
+export default TransactionBuilder;
+//# sourceMappingURL=TransactWriteBuilder.d.ts.map

package/dist/src/dynamo-utils/TransactWriteBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactWriteBuilder.d.ts","sourceRoot":"","sources":["../../../src/dynamo-utils/TransactWriteBuilder.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,cAAc,EACd,GAAG,EACH,MAAM,EACN,MAAM,EACP,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,cAAM,kBAAkB;;IAItB;;OAEG;IACU,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAehD;;;OAGG;IACI,iBAAiB,CACtB,IAAI,EAAE,cAAc,EACpB,kBAAkB,EAAE,MAAM,GACzB,IAAI;IAKP;;;OAGG;IACI,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI;IAK3D;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI;IAKjE;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI;IAKjE;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;OAIG;IACH,OAAO,CAAC,iCAAiC;CA6B1C;AAED,eAAe,kBAAkB,CAAC"}

package/dist/src/dynamo-utils/TransactWriteBuilder.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DynamoClient_1 = __importDefault(require("./DynamoClient"));
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const errors_1 = require("./errors");
+const Logger_1 = __importDefault(require("../Logger"));
+/**
+ * Build and executes a [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) request
+ */
+class TransactionBuilder {
+    #transactionItems = [];
+    #errorMessages = {};
+    /**
+     * Execute the transaction
+     */
+    async executeTransaction() {
+        try {
+            const response = await DynamoClient_1.default.transactWriteItems({
+                TransactItems: this.#transactionItems
+            });
+            Logger_1.default.log("Transaction successful:", response);
+        }
+        catch (error) {
+            if (error instanceof client_dynamodb_1.TransactionCanceledException) {
+                throw this.buildTransactionCanceledException(error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Add a conditional check to the transaction
+     * @param item
+     */
+    addConditionCheck(item, conditionFailedMsg) {
+        this.trackErrorMessage(conditionFailedMsg);
+        this.#transactionItems.push({ ConditionCheck: item });
+    }
+    /**
+     * Add a put operation to the transaction
+     * @param item
+     */
+    addPut(item, conditionFailedMsg) {
+        this.trackErrorMessage(conditionFailedMsg);
+        this.#transactionItems.push({ Put: item });
+    }
+    /**
+     * Add an update operation to the transaction
+     * @param item
+     */
+    addUpdate(item, conditionFailedMsg) {
+        this.trackErrorMessage(conditionFailedMsg);
+        this.#transactionItems.push({ Update: item });
+    }
+    /**
+     * Add a delete operation to the transaction
+     * @param item
+     */
+    addDelete(item, conditionFailedMsg) {
+        this.trackErrorMessage(conditionFailedMsg);
+        this.#transactionItems.push({ Delete: item });
+    }
+    /**
+     * Track error messages to return if there is a ConditionalCheckFailed exception
+     *
+     * IMPORTANT - Call this before adding the transaction to this.#transactionItems
+     * @param errMsg The custom error message to return if there is a ConditionalCheckFailed exception
+     */
+    trackErrorMessage(errMsg) {
+        if (errMsg !== undefined) {
+            this.#errorMessages[this.#transactionItems.length] = errMsg;
+        }
+    }
+    /**
+     * Handle TransactionCanceledException, aggregating errors and applying friendly errors if provided.
+     * @param error
+     * @returns
+     */
+    buildTransactionCanceledException(error) {
+        if (error.CancellationReasons !== undefined) {
+            const reasons = error.CancellationReasons;
+            const conditionFailedErrs = reasons.reduce((errors, reason, idx) => {
+                if (reason.Code === "ConditionalCheckFailed") {
+                    const failure = this.#errorMessages[idx] ?? reason.Message;
+                    const msg = `${reason.Code}: ${failure}`;
+                    errors.push(new errors_1.ConditionalCheckFailedError(msg));
+                }
+                return errors;
+            }, []);
+            if (conditionFailedErrs.length > 0) {
+                Logger_1.default.error(conditionFailedErrs.map(err => err.message));
+                return new errors_1.TransactionWriteFailedError(conditionFailedErrs, "Failed Conditional Checks", { cause: error });
+            }
+        }
+        return error;
+    }
+}
+exports.default = TransactionBuilder;

package/dist/src/dynamo-utils/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Error thrown if a condition within a dynamo operation fails
+ */
+export declare class ConditionalCheckFailedError extends Error {
+    readonly code = "ConditionalCheckFailedError";
+}
+/**
+ * AggregateError thrown if a transaction fails. Check errors for reasons
+ */
+export declare class TransactionWriteFailedError extends AggregateError {
+    readonly code = "TransactionWriteFailedError";
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/dynamo-utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/dynamo-utils/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,SAAgB,IAAI,iCAAiC;CACtD;AAED;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,cAAc;IAC7D,SAAgB,IAAI,iCAAiC;CACtD"}

package/dist/src/dynamo-utils/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionWriteFailedError = exports.ConditionalCheckFailedError = void 0;
+/**
+ * Error thrown if a condition within a dynamo operation fails
+ */
+class ConditionalCheckFailedError extends Error {
+    code = "ConditionalCheckFailedError";
+}
+exports.ConditionalCheckFailedError = ConditionalCheckFailedError;
+/**
+ * AggregateError thrown if a transaction fails. Check errors for reasons
+ */
+class TransactionWriteFailedError extends AggregateError {
+    code = "TransactionWriteFailedError";
+}
+exports.TransactionWriteFailedError = TransactionWriteFailedError;

package/dist/src/dynamo-utils/index.d.ts

@@ -0,0 +1,8 @@
+export { default as TransactWriteBuilder } from "./TransactWriteBuilder";
+export { default as TransactGetBuilder } from "./TransactGetBuilder";
+export { default as DynamoClient } from "./DynamoClient";
+export * from "./TransactWriteBuilder";
+export * from "./TransactGetBuilder";
+export * from "./errors";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/dynamo-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dynamo-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEzD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/src/dynamo-utils/index.js

@@ -0,0 +1,30 @@
+"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.DynamoClient = exports.TransactGetBuilder = exports.TransactWriteBuilder = void 0;
+var TransactWriteBuilder_1 = require("./TransactWriteBuilder");
+Object.defineProperty(exports, "TransactWriteBuilder", { enumerable: true, get: function () { return __importDefault(TransactWriteBuilder_1).default; } });
+var TransactGetBuilder_1 = require("./TransactGetBuilder");
+Object.defineProperty(exports, "TransactGetBuilder", { enumerable: true, get: function () { return __importDefault(TransactGetBuilder_1).default; } });
+var DynamoClient_1 = require("./DynamoClient");
+Object.defineProperty(exports, "DynamoClient", { enumerable: true, get: function () { return __importDefault(DynamoClient_1).default; } });
+__exportStar(require("./TransactWriteBuilder"), exports);
+__exportStar(require("./TransactGetBuilder"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/dynamo-utils/types.d.ts

@@ -0,0 +1,52 @@
+import type { QueryCommandOutput, TransactGetCommandOutput, TransactGetCommandInput, TransactWriteCommandInput } from "@aws-sdk/lib-dynamodb";
+/**
+ * Represents the responses from a `TransactGetItems` operation in DynamoDB.
+ */
+export type TransactGetItemResponses = NonNullable<TransactGetCommandOutput["Responses"]>;
+/**
+ * Represents the items returned from a `Query` operation in DynamoDB.
+ */
+export type QueryItems = NonNullable<QueryCommandOutput["Items"]>;
+/**
+ * Represents a non-nullable version of the `TransactItems` array from the `TransactGetCommandInput` interface. This type ensures that the `TransactItems` array cannot be null, enhancing type safety by enforcing the presence of transaction items in operations that require them. It is commonly used in contexts where a transaction involves multiple actions, and each item in the transaction must be explicitly defined without allowing for null values.
+ *
+ * @type {TransactItems} A type derived from `TransactGetCommandInput["TransactItems"]`, guaranteed to be non-nullable, representing an array of transaction items in a DynamoDB transaction.
+ */
+export type TransactGetItems = NonNullable<TransactGetCommandInput["TransactItems"]>;
+/**
+ * Represents a non-nullable version of the `Get` operation within a `TransactItems` array item. This type is used to enforce the presence and correct structure of a `Get` operation within a transaction item, providing stronger type guarantees and facilitating the use of IntelliSense and compile-time checks in development environments.
+ *
+ * @type {Get} A derived type from `TransactItems[number]["Get"]`, guaranteed to be non-nullable, representing the structure of a `Get` operation in a DynamoDB transaction item.
+ */
+export type Get = NonNullable<TransactGetItems[number]["Get"]>;
+/**
+ * Represents a non-nullable version of the `TransactItems` array from the `TransactWriteCommandInput` interface. This type is crucial for operations that involve multiple write actions within a single transaction in DynamoDB, ensuring that the array of transaction items is always defined and non-null.
+ *
+ * @type {TransactWriteItems} A type derived from `TransactWriteCommandInput["TransactItems"]`, guaranteed to be non-nullable, indicating an array of transaction items for write operations in DynamoDB.
+ */
+export type TransactWriteItems = NonNullable<TransactWriteCommandInput["TransactItems"]>;
+/**
+ * Represents the non-nullable structure of a `ConditionCheck` operation within a transaction item in DynamoDB. This type is essential for transactions that include condition checks to ensure specific prerequisites are met before executing the transaction. It enforces the presence and proper structure of condition check operations within transaction items.
+ *
+ * @type {ConditionCheck} A derived type from `TransactWriteItems[number]["ConditionCheck"]`, guaranteed to be non-nullable, specifying the structure of a `ConditionCheck` operation in a DynamoDB transaction item.
+ */
+export type ConditionCheck = NonNullable<TransactWriteItems[number]["ConditionCheck"]>;
+/**
+ * Represents the non-nullable structure of a `Put` operation within a transaction item in DynamoDB. This type ensures that `Put` operations, which create or overwrite items in a table, are always present and correctly structured within transaction items, enhancing type safety and clarity in DynamoDB transactions.
+ *
+ * @type {Put} A derived type from `TransactWriteItems[number]["Put"]`, guaranteed to be non-nullable, detailing the structure of a `Put` operation in a DynamoDB transaction item.
+ */
+export type Put = NonNullable<TransactWriteItems[number]["Put"]>;
+/**
+ * Represents the non-nullable structure of an `Update` operation within a transaction item in DynamoDB. This type is used to enforce the presence and correct structure of `Update` operations, which modify existing items in a table, within transaction items. It contributes to clearer and safer transaction definitions in DynamoDB operations.
+ *
+ * @type {Update} A derived type from `TransactWriteItems[number]["Update"]`, guaranteed to be non-nullable, outlining the structure of an `Update` operation in a DynamoDB transaction item.
+ */
+export type Update = NonNullable<TransactWriteItems[number]["Update"]>;
+/**
+ * Represents the non-nullable structure of a `Delete` operation within a transaction item in DynamoDB. This type ensures that `Delete` operations, which remove items from a table, are always present and correctly structured within transaction items, providing stronger guarantees about transaction item configurations.
+ *
+ * @type {Delete} A derived type from `TransactWriteItems[number]["Delete"]`, guaranteed to be non-nullable, specifying the structure of a `Delete` operation in a DynamoDB transaction item.
+ */
+export type Delete = NonNullable<TransactWriteItems[number]["Delete"]>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/dynamo-utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/dynamo-utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,EACvB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,WAAW,CAChD,wBAAwB,CAAC,WAAW,CAAC,CACtC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC;AAElE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CACxC,uBAAuB,CAAC,eAAe,CAAC,CACzC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,GAAG,GAAG,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAC1C,yBAAyB,CAAC,eAAe,CAAC,CAC3C,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,CACtC,kBAAkB,CAAC,MAAM,CAAC,CAAC,gBAAgB,CAAC,CAC7C,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,GAAG,GAAG,WAAW,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAEjE;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,WAAW,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvE;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,WAAW,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC"}

package/dist/src/dynamo-utils/types.js

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

package/dist/src/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Represents an error indicating a violation of a null constraint within the ORM system. This error is typically thrown when an operation attempts to set a non-nullable attribute to `null`, which would violate the data integrity rules of the database schema.
+ */
+export declare class NullConstraintViolationError extends Error {
+    readonly code = "NullConstraintViolationError";
+}
+/**
+ * Represents an error indicating that a requested entity or item could not be found within the database. This error is thrown during operations that expect to find and return a specific item, but the item does not exist in the database.
+ */
+export declare class NotFoundError extends Error {
+    readonly code = "NotFoundError";
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,SAAgB,IAAI,kCAAkC;CACvD;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAgB,IAAI,mBAAmB;CACxC"}

package/dist/src/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.NullConstraintViolationError = void 0;
+/**
+ * Represents an error indicating a violation of a null constraint within the ORM system. This error is typically thrown when an operation attempts to set a non-nullable attribute to `null`, which would violate the data integrity rules of the database schema.
+ */
+class NullConstraintViolationError extends Error {
+    code = "NullConstraintViolationError";
+}
+exports.NullConstraintViolationError = NullConstraintViolationError;
+/**
+ * Represents an error indicating that a requested entity or item could not be found within the database. This error is thrown during operations that expect to find and return a specific item, but the item does not exist in the database.
+ */
+class NotFoundError extends Error {
+    code = "NotFoundError";
+}
+exports.NotFoundError = NotFoundError;

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+import DynaRecord from "./DynaRecord";
+export default DynaRecord;
+export * from "./types";
+export * from "./decorators";
+export * from "./errors";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AAEtC,eAAe,UAAU,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,24 @@
+"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 });
+const DynaRecord_1 = __importDefault(require("./DynaRecord"));
+exports.default = DynaRecord_1.default;
+__exportStar(require("./types"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./errors"), exports);

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

@@ -0,0 +1,22 @@
+import type { AttributeMetadataOptions, Serializers } from "./types";
+/**
+ * Represents the metadata for an attribute of an entity, including its name, alias (if any), nullability, and serialization strategies.
+ *
+ * Serialization strategies are essential for attributes whose types do not natively exist in DynamoDB, such as `Date` objects, enabling custom conversion between the entity representation and the database representation. These strategies ensure that the ORM can seamlessly handle a wide range of attribute types beyond those natively supported by DynamoDB.
+ *
+ * @property {string} name - The name of the attribute as defined on the entity. This serves as the primary identifier for the attribute within the ORM.
+ * @property {string} alias - The name of the attribute as defined in the database table. If not provided, it defaults to the name of the attribute. This alias is used for database operations to map the attribute to its corresponding database column.
+ * @property {boolean} nullable - Indicates whether the attribute can be `null`, defining the attribute's nullability constraint within the database.
+ * @property {Serializers | undefined} serializers - Optional serialization strategies for converting the attribute between its database representation and its entity representation. This is particularly useful for custom data types not natively supported by DynamoDB.
+ *
+ * @param {AttributeMetadataOptions} options - Configuration options for the attribute metadata, including the attribute's name, optional alias, nullability, and serialization strategies.
+ */
+declare class AttributeMetadata {
+    readonly name: string;
+    readonly alias: string;
+    readonly nullable: boolean;
+    readonly serializers?: Serializers;
+    constructor(options: AttributeMetadataOptions);
+}
+export default AttributeMetadata;
+//# sourceMappingURL=AttributeMetadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeMetadata.d.ts","sourceRoot":"","sources":["../../../src/metadata/AttributeMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,cAAM,iBAAiB;IACrB,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,SAAgB,QAAQ,EAAE,OAAO,CAAC;IAClC,SAAgB,WAAW,CAAC,EAAE,WAAW,CAAC;gBAE9B,OAAO,EAAE,wBAAwB;CAM9C;AAED,eAAe,iBAAiB,CAAC"}

package/dist/src/metadata/AttributeMetadata.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Represents the metadata for an attribute of an entity, including its name, alias (if any), nullability, and serialization strategies.
+ *
+ * Serialization strategies are essential for attributes whose types do not natively exist in DynamoDB, such as `Date` objects, enabling custom conversion between the entity representation and the database representation. These strategies ensure that the ORM can seamlessly handle a wide range of attribute types beyond those natively supported by DynamoDB.
+ *
+ * @property {string} name - The name of the attribute as defined on the entity. This serves as the primary identifier for the attribute within the ORM.
+ * @property {string} alias - The name of the attribute as defined in the database table. If not provided, it defaults to the name of the attribute. This alias is used for database operations to map the attribute to its corresponding database column.
+ * @property {boolean} nullable - Indicates whether the attribute can be `null`, defining the attribute's nullability constraint within the database.
+ * @property {Serializers | undefined} serializers - Optional serialization strategies for converting the attribute between its database representation and its entity representation. This is particularly useful for custom data types not natively supported by DynamoDB.
+ *
+ * @param {AttributeMetadataOptions} options - Configuration options for the attribute metadata, including the attribute's name, optional alias, nullability, and serialization strategies.
+ */
+class AttributeMetadata {
+    name;
+    alias;
+    nullable;
+    serializers;
+    constructor(options) {
+        this.name = options.attributeName;
+        this.alias = options.alias ?? options.attributeName;
+        this.nullable = options.nullable;
+        this.serializers = options.serializers;
+    }
+}
+exports.default = AttributeMetadata;