dyna-record 0.0.1

package/dist/src/utils.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeAssign = exports.isString = exports.isPropertyKey = exports.chunkArray = exports.isBelongsToLinkDynamoItem = exports.isKeyOfObject = exports.isKeyOfEntity = exports.tableItemToBelongsToLink = exports.tableItemToEntity = exports.entityToTableItem = void 0;
+const metadata_1 = __importDefault(require("./metadata"));
+const relationships_1 = require("./relationships");
+/**
+ * Convert an entity to its aliased table item fields to for dynamo interactions
+ * @param entityClassName
+ * @param entityData
+ * @returns
+ */
+const entityToTableItem = (EntityClass, entityData) => {
+    const attributesMeta = metadata_1.default.getEntityAttributes(EntityClass.name);
+    return Object.entries(entityData).reduce((acc, [key, val]) => {
+        const attrMeta = attributesMeta[key];
+        if (attrMeta !== undefined) {
+            const { alias, serializers } = attrMeta;
+            // If the attribute has a custom serializer, serialize it
+            const value = serializers === undefined ? val : serializers.toTableAttribute(val);
+            acc[alias] = value;
+        }
+        return acc;
+    }, {});
+};
+exports.entityToTableItem = entityToTableItem;
+/**
+ * Serialize a table item to its associated Entity class, using the class attribute property names
+ * @param EntityClass
+ * @param tableItem
+ * @returns
+ */
+const tableItemToEntity = (EntityClass, tableItem) => {
+    const tableAttributes = metadata_1.default.getEntityTableAttributes(EntityClass.name);
+    const entity = new EntityClass();
+    Object.keys(tableItem).forEach(attrName => {
+        const attrMeta = tableAttributes[attrName];
+        if (attrMeta !== undefined) {
+            const { name: entityKey, serializers } = attrMeta;
+            if ((0, exports.isKeyOfEntity)(entity, entityKey)) {
+                const rawVal = tableItem[attrName];
+                const val = serializers?.toEntityAttribute === undefined
+                    ? rawVal
+                    : serializers?.toEntityAttribute(rawVal);
+                (0, exports.safeAssign)(entity, entityKey, val);
+            }
+        }
+    });
+    return entity;
+};
+exports.tableItemToEntity = tableItemToEntity;
+/**
+ * Serialize a dynamo table item response to a BelongsToLink
+ * @param tableMeta - Table metadata
+ * @param tableItem - Table item from dynamo response
+ * @returns - { @link BelongsToLink }
+ */
+const tableItemToBelongsToLink = (tableMeta, tableItem) => {
+    const link = new relationships_1.BelongsToLink();
+    const belongsToLinkAttrs = {
+        ...{
+            [tableMeta.partitionKeyAttribute.alias]: tableMeta.partitionKeyAttribute
+        },
+        ...{ [tableMeta.sortKeyAttribute.alias]: tableMeta.sortKeyAttribute },
+        ...tableMeta.defaultTableAttributes
+    };
+    Object.keys(tableItem).forEach(attrName => {
+        const attrMeta = belongsToLinkAttrs[attrName];
+        if (attrMeta !== undefined) {
+            const { name: entityKey, serializers } = attrMeta;
+            const rawVal = tableItem[attrName];
+            const val = serializers?.toEntityAttribute === undefined
+                ? rawVal
+                : serializers?.toEntityAttribute(rawVal);
+            (0, exports.safeAssign)(link, entityKey, val);
+        }
+    });
+    return link;
+};
+exports.tableItemToBelongsToLink = tableItemToBelongsToLink;
+/**
+ * Type guard to check if the key is defined on the entity
+ */
+const isKeyOfEntity = (entity, key) => {
+    return key in entity;
+};
+exports.isKeyOfEntity = isKeyOfEntity;
+/**
+ * Type guard to check if the key is a defined property on the entity
+ * @param entity
+ * @param key
+ * @returns
+ */
+const isKeyOfObject = (entity, key) => {
+    return key in entity;
+};
+exports.isKeyOfObject = isKeyOfObject;
+/**
+ * Type guard to check if the DynamoTableItem is a BelongsToLink
+ * @param res DynamoTableItem
+ * @returns boolean
+ */
+const isBelongsToLinkDynamoItem = (res, tableMeta) => {
+    return res[tableMeta.defaultAttributes.type.alias] === relationships_1.BelongsToLink.name;
+};
+exports.isBelongsToLinkDynamoItem = isBelongsToLinkDynamoItem;
+/**
+ * Break an array into chunks
+ * @param array
+ * @param size
+ * @returns Array split into chunks of given  size
+ */
+const chunkArray = (array, size) => {
+    return Array.from({ length: Math.ceil(array.length / size) }, (_, index) => array.slice(index * size, (index + 1) * size));
+};
+exports.chunkArray = chunkArray;
+/**
+ * Checks if a value is a valid property key (string, number, or symbol).
+ *
+ * @param value The value to be checked. This can be of any type.
+ * @returns `true` if the value is a `string`, `number`, or `symbol` (i.e., a valid property key); otherwise, `false`.
+ *
+ * @example
+ * Logger.log(isPropertyKey('test')); // true
+ * Logger.log(isPropertyKey(123)); // true
+ * Logger.log(isPropertyKey(Symbol('sym'))); // true
+ * Logger.log(isPropertyKey({})); // false
+ */
+const isPropertyKey = (value) => {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "symbol");
+};
+exports.isPropertyKey = isPropertyKey;
+/**
+ * Checks if the given value is a string.
+ *
+ * @param value - The value to check. This can be any type as the function is meant to validate if it's a string.
+ * @returns `true` if `value` is a string; otherwise, `false`.
+ */
+const isString = (value) => {
+    return typeof value === "string";
+};
+exports.isString = isString;
+/**
+ * Safely assigns a value to a property of an object.
+ * It's useful for dynamically assigning properties to objects where the property names might be known but the types could vary.
+ *
+ * @template TObject - The object type to which the property belongs.
+ * @template TKey - The type of the keys of `TObject`
+ * @template TValue - The  value to be assigned.
+ *
+ * @param {TObject} object - The target object to which the property will be assigned.
+ * @param {TKey} key - The property name under which the value should be assigned. Must be a key of `TObject`.
+ * @param {TValue} value - The value to assign to the property on the object.
+ *
+ * @returns {void} - This function does not return a value; it performs the assignment operation directly on the passed object.
+ *
+ * @example
+ * let entity = { id: "123" };
+ * safeAssign(entity, "name", "Jane Doe");
+ */
+const safeAssign = (object, key, value) => {
+    object[key] = value;
+};
+exports.safeAssign = safeAssign;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "dyna-record",
+  "version": "0.0.1",
+  "description": "Typescript Object Relational Mapper (ORM) for Dynamo",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "test": "jest",
+    "eslint": "npx eslint . --ext .ts",
+    "eslint-fix": "npx eslint . --ext .ts --fix",
+    "prettier": "npx prettier . --write",
+    "docs": "npx typedoc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dsdavis4/dyna-record.git"
+  },
+  "author": "dsdavis4",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dsdavis4/dyna-record/issues"
+  },
+  "homepage": "https://github.com/dsdavis4/dyna-record#readme",
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.502.0",
+    "@aws-sdk/lib-dynamodb": "^3.502.0",
+    "@aws-sdk/util-dynamodb": "^3.509.0",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@aws-sdk/types": "^3.502.0",
+    "@tsconfig/recommended": "^1.0.3",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.16",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-standard-with-typescript": "^43.0.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.1.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.25.12",
+    "typedoc-plugin-missing-exports": "^2.2.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "npm": ">=10.0.0",
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/**/*"
+  ]
+}