dyna-record 0.0.1

package/dist/src/operations/utils/expressionBuilder.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionBuilder = void 0;
+/**
+ * Builds a dynamo expression given the table attributes
+ * @param tableAttrs The table aliases of the entity attributes
+ * @returns
+ */
+const expressionBuilder = (tableAttrs) => {
+    const sorted = sortAttributesByOperand(tableAttrs);
+    const setExpression = buildUpdateSetExpression(sorted.set);
+    const removeExpression = buildUpdateRemoveExpression(sorted.remove);
+    const hasSetOperation = Object.keys(setExpression.ExpressionAttributeValues).length > 0;
+    return {
+        // If the operation has only REMOVE actions, it will not have expression attribute values
+        ExpressionAttributeValues: hasSetOperation
+            ? setExpression.ExpressionAttributeValues
+            : undefined,
+        ExpressionAttributeNames: {
+            ...setExpression.ExpressionAttributeNames,
+            ...removeExpression.ExpressionAttributeNames
+        },
+        UpdateExpression: [
+            setExpression.UpdateExpression,
+            removeExpression.UpdateExpression
+        ]
+            .filter(expr => expr)
+            .join(" ")
+    };
+};
+exports.expressionBuilder = expressionBuilder;
+/**
+ * Sort attributes based on their operand
+ * @param tableAttrs
+ * @returns
+ */
+const sortAttributesByOperand = (tableAttrs) => {
+    return Object.entries(tableAttrs).reduce((acc, [key, value]) => {
+        const isRemovingAttr = value === null;
+        if (isRemovingAttr) {
+            acc.remove[key] = value;
+        }
+        else {
+            acc.set[key] = value;
+        }
+        return acc;
+    }, {
+        remove: {},
+        set: {}
+    });
+};
+/**
+ * Build the update [SET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html#Expressions.UpdateExpressions.SET) expression
+ * @param tableAttrs
+ * @returns
+ */
+const buildUpdateSetExpression = (tableAttrs) => {
+    const entries = Object.entries(tableAttrs);
+    const action = "SET";
+    return entries.reduce((acc, [key, val], idx) => {
+        const attrName = `#${key}`;
+        const attrVal = `:${key}`;
+        const expression = ` ${attrName} = ${attrVal},`;
+        acc.ExpressionAttributeNames[attrName] = key;
+        acc.ExpressionAttributeValues[attrVal] = val;
+        acc.UpdateExpression = acc.UpdateExpression.concat(expression);
+        // For the first element, add the operand
+        if (idx === 0)
+            acc.UpdateExpression = `${action}${acc.UpdateExpression}`;
+        if (idx === entries.length - 1) {
+            // Remove trailing comma from the expression
+            acc.UpdateExpression = acc.UpdateExpression.slice(0, -1);
+        }
+        return acc;
+    }, {
+        ExpressionAttributeNames: {},
+        ExpressionAttributeValues: {},
+        UpdateExpression: ""
+    });
+};
+/**
+ * Build the update [REMOVE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html#Expressions.UpdateExpressions.REMOVE) expression for removing attributes
+ * @param tableAttrs
+ * @returns
+ */
+const buildUpdateRemoveExpression = (tableAttrs) => {
+    const entries = Object.entries(tableAttrs);
+    const action = "REMOVE";
+    return entries.reduce((acc, [key], idx) => {
+        const attrName = `#${key}`;
+        const expression = ` ${attrName},`;
+        acc.ExpressionAttributeNames[attrName] = key;
+        acc.UpdateExpression = acc.UpdateExpression.concat(expression);
+        // For the first element, add the operand
+        if (idx === 0)
+            acc.UpdateExpression = `${action}${acc.UpdateExpression}`;
+        if (idx === entries.length - 1) {
+            // Remove trailing comma from the expression
+            acc.UpdateExpression = acc.UpdateExpression.slice(0, -1);
+        }
+        return acc;
+    }, {
+        ExpressionAttributeNames: {},
+        UpdateExpression: ""
+    });
+};

package/dist/src/operations/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { default as RelationshipTransactions } from "./RelationshipTransactions";
+export * from "./expressionBuilder";
+export * from "./types";
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACjF,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/src/operations/utils/index.js

@@ -0,0 +1,25 @@
+"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.RelationshipTransactions = void 0;
+var RelationshipTransactions_1 = require("./RelationshipTransactions");
+Object.defineProperty(exports, "RelationshipTransactions", { enumerable: true, get: function () { return __importDefault(RelationshipTransactions_1).default; } });
+__exportStar(require("./expressionBuilder"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/src/operations/utils/types.d.ts

@@ -0,0 +1,21 @@
+import { type UpdateCommandInput } from "@aws-sdk/lib-dynamodb";
+/**
+ * Defines the structure for an update expression using the SET action in DynamoDB, which is used to add new attributes to an item or modify existing attributes. This interface encapsulates the necessary components of an update expression for the [SET](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html#Expressions.UpdateExpressions.SET) action.
+ */
+export interface UpdateSetExpression {
+    UpdateExpression: NonNullable<UpdateCommandInput["UpdateExpression"]>;
+    ExpressionAttributeNames: NonNullable<UpdateCommandInput["ExpressionAttributeNames"]>;
+    ExpressionAttributeValues: NonNullable<UpdateCommandInput["ExpressionAttributeValues"]>;
+}
+/**
+ * Defines the structure for an update expression using the REMOVE action in DynamoDB, which is used to delete attributes from an item. This interface encapsulates the necessary components of an update expression for the [REMOVE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html#Expressions.UpdateExpressions.REMOVE) action, including attribute names and the update expression itself.
+ */
+export interface UpdateRemoveExpression {
+    UpdateExpression: NonNullable<UpdateCommandInput["UpdateExpression"]>;
+    ExpressionAttributeNames: NonNullable<UpdateCommandInput["ExpressionAttributeNames"]>;
+}
+/**
+ * Represents either an update expression for setting new or modifying existing attributes of an item (UpdateSetExpression) or an update expression for removing attributes from an item (UpdateRemoveExpression) in DynamoDB.
+ */
+export type UpdateExpression = UpdateSetExpression | UpdateRemoveExpression;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/operations/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,WAAW,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACtE,wBAAwB,EAAE,WAAW,CACnC,kBAAkB,CAAC,0BAA0B,CAAC,CAC/C,CAAC;IACF,yBAAyB,EAAE,WAAW,CACpC,kBAAkB,CAAC,2BAA2B,CAAC,CAChD,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,EAAE,WAAW,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACtE,wBAAwB,EAAE,WAAW,CACnC,kBAAkB,CAAC,0BAA0B,CAAC,CAC/C,CAAC;CACH;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,GAAG,sBAAsB,CAAC"}

package/dist/src/operations/utils/types.js

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

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

@@ -0,0 +1,19 @@
+import type DynaRecord from "../../DynaRecord";
+import type { RelationshipMetadata } from "../../metadata";
+import type { ForeignKey, Optional, RelationshipMetaObj } from "../../types";
+/**
+ * Creates an object including
+ *  - relationsLookup: Object to look up RelationshipMetadata by Entity name
+ *  - belongsToRelationships: An array of BelongsTo relationships
+ * @param includedRelationships
+ * @returns
+ */
+export declare const buildEntityRelationshipMetaObj: (relationships: RelationshipMetadata[]) => RelationshipMetaObj;
+/**
+ * Extracts a ForeignKey value from an entity instance
+ * @param relMeta - RelationshipMetadata for associated foreignKey
+ * @param entity - instance of DynaRecord
+ * @returns
+ */
+export declare const extractForeignKeyFromEntity: <T extends DynaRecord>(relMeta: RelationshipMetadata, entity?: T | undefined) => Optional<ForeignKey>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/operations/utils/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAK3D,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAG7E;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,kBAC1B,oBAAoB,EAAE,KACpC,mBAaF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,kCAC7B,oBAAoB,6BAE5B,SAAS,UAAU,CAMrB,CAAC"}

package/dist/src/operations/utils/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractForeignKeyFromEntity = exports.buildEntityRelationshipMetaObj = void 0;
+const utils_1 = require("../../metadata/utils");
+const utils_2 = require("../../utils");
+/**
+ * Creates an object including
+ *  - relationsLookup: Object to look up RelationshipMetadata by Entity name
+ *  - belongsToRelationships: An array of BelongsTo relationships
+ * @param includedRelationships
+ * @returns
+ */
+const buildEntityRelationshipMetaObj = (relationships) => {
+    return Object.values(relationships).reduce((acc, rel) => {
+        if ((0, utils_1.isBelongsToRelationship)(rel)) {
+            acc.belongsToRelationships.push(rel);
+        }
+        acc.relationsLookup[rel.target.name] = rel;
+        return acc;
+    }, { relationsLookup: {}, belongsToRelationships: [] });
+};
+exports.buildEntityRelationshipMetaObj = buildEntityRelationshipMetaObj;
+/**
+ * Extracts a ForeignKey value from an entity instance
+ * @param relMeta - RelationshipMetadata for associated foreignKey
+ * @param entity - instance of DynaRecord
+ * @returns
+ */
+const extractForeignKeyFromEntity = (relMeta, entity) => {
+    return entity !== undefined &&
+        (0, utils_1.isRelationshipMetadataWithForeignKey)(relMeta) &&
+        (0, utils_2.isKeyOfObject)(entity, relMeta.foreignKey)
+        ? entity[relMeta.foreignKey]
+        : undefined;
+};
+exports.extractForeignKeyFromEntity = extractForeignKeyFromEntity;

package/dist/src/query-utils/Filters.d.ts

@@ -0,0 +1,10 @@
+import { type RelationshipMetadata } from "../metadata";
+import { type OrFilter } from "./types";
+/**
+ * Builds the filter so that relationships that are included in the query will have their {@link BelongsToLink} included in the query
+ * @param parentClassName
+ * @param includedRelationships
+ * @returns
+ */
+export declare function includedRelationshipsFilter(parentClassName: string, includedRelationships: RelationshipMetadata[]): OrFilter;
+//# sourceMappingURL=Filters.d.ts.map

package/dist/src/query-utils/Filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filters.d.ts","sourceRoot":"","sources":["../../../src/query-utils/Filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAWxC;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,MAAM,EACvB,qBAAqB,EAAE,oBAAoB,EAAE,GAC5C,QAAQ,CAmBV"}

package/dist/src/query-utils/Filters.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includedRelationshipsFilter = void 0;
+const relationships_1 = require("../relationships");
+/**
+ * Builds the filter so that relationships that are included in the query will have their {@link BelongsToLink} included in the query
+ * @param parentClassName
+ * @param includedRelationships
+ * @returns
+ */
+function includedRelationshipsFilter(parentClassName, includedRelationships) {
+    const filters = [{ type: parentClassName }];
+    const includeBelongsToLinks = includedRelationships.some(rel => rel.type === "HasMany" ||
+        rel.type === "HasOne" ||
+        rel.type === "HasAndBelongsToMany");
+    if (includeBelongsToLinks) {
+        const belongsToFilter = {
+            type: relationships_1.BelongsToLink.name,
+            foreignEntityType: includedRelationships.map(rel => rel.target.name)
+        };
+        filters.push(belongsToFilter);
+    }
+    return { $or: filters };
+}
+exports.includedRelationshipsFilter = includedRelationshipsFilter;

package/dist/src/query-utils/QueryBuilder.d.ts

@@ -0,0 +1,90 @@
+import { type QueryCommandInput } from "@aws-sdk/lib-dynamodb";
+import type { QueryCommandProps } from "./types";
+/**
+ * Constructs and formats a DynamoDB query command based on provided key conditions and query options. This class simplifies the creation of complex DynamoDB queries by abstracting the underlying AWS SDK query command structure, particularly handling the construction of key condition expressions, filter expressions, and expression attribute names and values.
+ *
+ * Utilizing metadata about the entity and its attributes, `QueryBuilder` generates the necessary DynamoDB expressions to perform precise queries, including support for conditional operators like '=', 'begins_with', and 'IN', as well as logical 'AND' and 'OR' operations.
+ */
+declare class QueryBuilder {
+    #private;
+    constructor(props: QueryCommandProps);
+    /**
+     * Builds and returns the `QueryCommandInput` for a DynamoDB query operation.
+     * @returns {QueryCommandInput} The configured query command input for AWS SDK.
+     */
+    build(): QueryCommandInput;
+    /**
+     * Build ExpressionAttributeValues
+     * @param keyParams
+     * @param filterParams
+     * @returns
+     */
+    private expressionAttributeValueParams;
+    /**
+     * Build ExpressionAttributeNames
+     * @returns
+     */
+    private expressionAttributeNames;
+    /**
+     * Creates the filters
+     *
+     * Supports 'AND' and 'OR'
+     * Currently only works for '=', 'begins_with' or 'IN' operands
+     * Does not support operations like 'contains' etc yet
+     *
+     * @param filter
+     * @returns
+     */
+    private filterParams;
+    /**
+     * Creates an AND OR filter
+     * @param filter
+     * @returns
+     */
+    private andOrFilter;
+    /**
+     * Creates an AND filter
+     * @param filter
+     * @returns
+     */
+    private andFilter;
+    /**
+     * Creates an AND condition
+     * @param attr
+     * @param value
+     * @returns
+     */
+    private andCondition;
+    /**
+     * Builds an OR filter
+     * @param filter
+     * @returns
+     */
+    private orFilter;
+    /**
+     * Builds an OR condition
+     * @param andFilter \
+     * @returns
+     */
+    private orCondition;
+    /**
+     * Type guard to check if its a BeginsWithFilter
+     * @param filter
+     * @returns
+     */
+    private isBeginsWithFilter;
+    /**
+     * Type guard to check if its a AndOrFilter
+     * @param filter
+     * @returns
+     */
+    private isAndOrFilter;
+    /**
+     * Type guard to check if its a OrFilter
+     * @param filter
+     * @returns
+     */
+    private isOrFilter;
+}
+export default QueryBuilder;
+//# sourceMappingURL=QueryBuilder.d.ts.map

package/dist/src/query-utils/QueryBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryBuilder.d.ts","sourceRoot":"","sources":["../../../src/query-utils/QueryBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAO/D,OAAO,KAAK,EASV,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,cAAM,YAAY;;gBAMJ,KAAK,EAAE,iBAAiB;IAWpC;;;OAGG;IACI,KAAK,IAAI,iBAAiB;IAuBjC;;;;;OAKG;IACH,OAAO,CAAC,8BAA8B;IAetC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAgChC;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;IAWpB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IASnB;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAejB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAyBpB;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAehB;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAanB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAI1B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;OAIG;IACH,OAAO,CAAC,UAAU;CAGnB;AAED,eAAe,YAAY,CAAC"}

package/dist/src/query-utils/QueryBuilder.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = __importDefault(require("../metadata"));
+/**
+ * Constructs and formats a DynamoDB query command based on provided key conditions and query options. This class simplifies the creation of complex DynamoDB queries by abstracting the underlying AWS SDK query command structure, particularly handling the construction of key condition expressions, filter expressions, and expression attribute names and values.
+ *
+ * Utilizing metadata about the entity and its attributes, `QueryBuilder` generates the necessary DynamoDB expressions to perform precise queries, including support for conditional operators like '=', 'begins_with', and 'IN', as well as logical 'AND' and 'OR' operations.
+ */
+class QueryBuilder {
+    #props;
+    #tableMetadata;
+    #attributeMetadata;
+    #attrCounter;
+    constructor(props) {
+        this.#props = props;
+        this.#attrCounter = 0;
+        const entityMetadata = metadata_1.default.getEntity(props.entityClassName);
+        this.#tableMetadata = metadata_1.default.getTable(entityMetadata.tableClassName);
+        this.#attributeMetadata = metadata_1.default.getEntityAttributes(props.entityClassName);
+    }
+    /**
+     * Builds and returns the `QueryCommandInput` for a DynamoDB query operation.
+     * @returns {QueryCommandInput} The configured query command input for AWS SDK.
+     */
+    build() {
+        const { indexName, filter } = this.#props.options ?? {};
+        const filterParams = filter !== undefined ? this.filterParams(filter) : undefined;
+        const keyFilter = this.andFilter(this.#props.key);
+        const hasIndex = indexName !== undefined;
+        const hasFilter = filterParams !== undefined;
+        return {
+            TableName: this.#tableMetadata.name,
+            ...(hasIndex && { IndexName: indexName }),
+            ...(hasFilter && { FilterExpression: filterParams.expression }),
+            KeyConditionExpression: keyFilter.expression,
+            ExpressionAttributeNames: this.expressionAttributeNames(),
+            ExpressionAttributeValues: this.expressionAttributeValueParams(keyFilter, filterParams)
+        };
+    }
+    /**
+     * Build ExpressionAttributeValues
+     * @param keyParams
+     * @param filterParams
+     * @returns
+     */
+    expressionAttributeValueParams(keyParams, filterParams) {
+        const hasFilter = this.#props.options?.filter !== undefined;
+        const valueParams = hasFilter
+            ? { ...keyParams.values, ...filterParams?.values }
+            : keyParams.values;
+        return Object.entries(valueParams).reduce((params, [attrName, value]) => ({ ...params, [`:${attrName}`]: value }), {});
+    }
+    /**
+     * Build ExpressionAttributeNames
+     * @returns
+     */
+    expressionAttributeNames() {
+        const { filter } = this.#props.options ?? {};
+        const accumulator = (obj, key) => {
+            const tableKey = this.#attributeMetadata[key].alias;
+            obj[`#${tableKey}`] = tableKey;
+            return obj;
+        };
+        let expressionAttributeNames = Object.keys(this.#props.key).reduce((acc, key) => accumulator(acc, key), {});
+        if (filter !== undefined) {
+            const { $or: orFilters = [], ...andFilters } = filter;
+            const or = orFilters.reduce((acc, filter) => {
+                Object.keys(filter).forEach(key => accumulator(acc, key));
+                return acc;
+            }, {});
+            const and = Object.keys(andFilters).reduce((acc, key) => accumulator(acc, key), {});
+            expressionAttributeNames = { ...expressionAttributeNames, ...or, ...and };
+        }
+        return expressionAttributeNames;
+    }
+    /**
+     * Creates the filters
+     *
+     * Supports 'AND' and 'OR'
+     * Currently only works for '=', 'begins_with' or 'IN' operands
+     * Does not support operations like 'contains' etc yet
+     *
+     * @param filter
+     * @returns
+     */
+    filterParams(filter) {
+        const isOrFilter = this.isOrFilter(filter);
+        if (isOrFilter) {
+            const isAndOrFilter = this.isAndOrFilter(filter);
+            return isAndOrFilter ? this.andOrFilter(filter) : this.orFilter(filter);
+        }
+        else {
+            return this.andFilter(filter);
+        }
+    }
+    /**
+     * Creates an AND OR filter
+     * @param filter
+     * @returns
+     */
+    andOrFilter(filter) {
+        const { $or: _orFilters, ...andFilters } = filter;
+        const orFilterParams = this.orFilter(filter);
+        const andFilterParams = this.andFilter(andFilters);
+        const expression = `(${orFilterParams.expression}) AND (${andFilterParams.expression})`;
+        const values = { ...orFilterParams.values, ...andFilterParams.values };
+        return { expression, values };
+    }
+    /**
+     * Creates an AND filter
+     * @param filter
+     * @returns
+     */
+    andFilter(filter) {
+        const params = Object.entries(filter).reduce((obj, [attr, value]) => {
+            const { expression, values } = this.andCondition(attr, value);
+            return {
+                expression: obj.expression.concat(expression),
+                values: { ...obj.values, ...values }
+            };
+        }, { expression: "", values: {} });
+        params.expression = params.expression.slice(0, -5); // trim off the trailing " AND "
+        return params;
+    }
+    /**
+     * Creates an AND condition
+     * @param attr
+     * @param value
+     * @returns
+     */
+    andCondition(attr, value) {
+        const tableKey = this.#attributeMetadata[attr].alias;
+        let condition;
+        let values = {};
+        if (Array.isArray(value)) {
+            const mappings = value.reduce((acc, val) => {
+                const attr = `${tableKey}${++this.#attrCounter}`;
+                values[attr] = val;
+                return acc.concat(`:${attr}`);
+            }, []);
+            condition = `#${tableKey} IN (${mappings.join()})`;
+        }
+        else if (this.isBeginsWithFilter(value)) {
+            const attr = `${tableKey}${++this.#attrCounter}`;
+            condition = `begins_with(#${tableKey}, :${attr})`;
+            values = { [`${attr}`]: value.$beginsWith };
+        }
+        else {
+            const attr = `${tableKey}${++this.#attrCounter}`;
+            condition = `#${tableKey} = :${attr}`;
+            values = { [`${attr}`]: value };
+        }
+        return { expression: `${condition} AND `, values };
+    }
+    /**
+     * Builds an OR filter
+     * @param filter
+     * @returns
+     */
+    orFilter(filter) {
+        const orFilter = filter.$or.reduce((filterParams, filter) => {
+            const { expression, values } = this.orCondition(filter);
+            return {
+                expression: filterParams.expression.concat(expression),
+                values: { ...filterParams.values, ...values }
+            };
+        }, { expression: "", values: {} });
+        orFilter.expression = orFilter.expression.slice(0, -4); // trim off the trailing " OR "
+        return orFilter;
+    }
+    /**
+     * Builds an OR condition
+     * @param andFilter \
+     * @returns
+     */
+    orCondition(andFilter) {
+        const andParams = this.filterParams(andFilter);
+        const multipleVals = Object.keys(andParams.values).length > 1;
+        const expression = multipleVals
+            ? `(${andParams.expression}) OR `
+            : `${andParams.expression} OR `;
+        const values = Object.entries(andParams.values).reduce((obj, [key, val]) => ({ ...obj, [key]: val }), {});
+        return { expression, values };
+    }
+    /**
+     * Type guard to check if its a BeginsWithFilter
+     * @param filter
+     * @returns
+     */
+    isBeginsWithFilter(filter) {
+        return filter.$beginsWith !== undefined;
+    }
+    /**
+     * Type guard to check if its a AndOrFilter
+     * @param filter
+     * @returns
+     */
+    isAndOrFilter(filter) {
+        return this.isOrFilter(filter) && Object.keys(filter).length > 1;
+    }
+    /**
+     * Type guard to check if its a OrFilter
+     * @param filter
+     * @returns
+     */
+    isOrFilter(filter) {
+        return filter.$or !== undefined;
+    }
+}
+exports.default = QueryBuilder;

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

@@ -0,0 +1,3 @@
+export { default as QueryBuilder } from "./QueryBuilder";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/query-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,23 @@
+"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.QueryBuilder = void 0;
+var QueryBuilder_1 = require("./QueryBuilder");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return __importDefault(QueryBuilder_1).default; } });
+__exportStar(require("./types"), exports);