@twin.org/entity-storage-connector-dynamodb 0.0.2-next.9 → 0.0.3-next.2

package/dist/cjs/index.cjs

@@ -1,751 +0,0 @@
-'use strict';
-
-var clientDynamodb = require('@aws-sdk/client-dynamodb');
-var libDynamodb = require('@aws-sdk/lib-dynamodb');
-var utilDynamodb = require('@aws-sdk/util-dynamodb');
-var core = require('@twin.org/core');
-var entity = require('@twin.org/entity');
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing entity storage operations using Dynamo DB.
- */
-class DynamoDbEntityStorageConnector {
-    /**
-     * Limit the number of entities when finding.
-     * @internal
-     */
-    static _PAGE_SIZE = 40;
-    /**
-     * Partition id field name.
-     * @internal
-     */
-    static _PARTITION_ID_NAME = "partitionId";
-    /**
-     * Partition id field value.
-     * @internal
-     */
-    static _PARTITION_ID_VALUE = "1";
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "DynamoDbEntityStorageConnector";
-    /**
-     * The schema for the entity.
-     * @internal
-     */
-    _entitySchema;
-    /**
-     * The primary key.
-     * @internal
-     */
-    _primaryKey;
-    /**
-     * The configuration for the connector.
-     * @internal
-     */
-    _config;
-    /**
-     * Create a new instance of DynamoDbEntityStorageConnector.
-     * @param options The options for the connector.
-     */
-    constructor(options) {
-        core.Guards.object(this.CLASS_NAME, "options", options);
-        core.Guards.stringValue(this.CLASS_NAME, "options.entitySchema", options.entitySchema);
-        core.Guards.object(this.CLASS_NAME, "options.config", options.config);
-        options.config.authMode ??= "credentials";
-        if (options.config.authMode === "credentials") {
-            core.Guards.stringValue(this.CLASS_NAME, "options.config.accessKeyId", options.config.accessKeyId);
-            core.Guards.stringValue(this.CLASS_NAME, "options.config.secretAccessKey", options.config.secretAccessKey);
-        }
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.region", options.config.region);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.tableName", options.config.tableName);
-        this._entitySchema = entity.EntitySchemaFactory.get(options.entitySchema);
-        this._primaryKey = entity.EntitySchemaHelper.getPrimaryKey(this._entitySchema);
-        this._config = options.config;
-        this._config.endpoint = core.Is.stringValue(this._config.endpoint)
-            ? this._config.endpoint
-            : undefined;
-    }
-    /**
-     * Bootstrap the component by creating and initializing any resources it needs.
-     * @param nodeLoggingComponentType The node logging component type.
-     * @returns True if the bootstrapping process was successful.
-     */
-    async bootstrap(nodeLoggingComponentType) {
-        const nodeLogging = core.ComponentFactory.getIfExists(nodeLoggingComponentType);
-        if (!(await this.tableExists(this._config.tableName))) {
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "tableCreating",
-                data: {
-                    tableName: this._config.tableName
-                }
-            });
-            try {
-                const dbConnection = this.createConnection();
-                const tableParams = {
-                    AttributeDefinitions: [],
-                    KeySchema: [],
-                    ProvisionedThroughput: {
-                        ReadCapacityUnits: 1,
-                        WriteCapacityUnits: 1
-                    },
-                    TableName: this._config.tableName
-                };
-                // We always add a partition key to the table as a non optional hash key
-                // is always required when querying using sort parameters
-                tableParams.AttributeDefinitions?.push({
-                    AttributeName: DynamoDbEntityStorageConnector._PARTITION_ID_NAME,
-                    AttributeType: "S"
-                });
-                tableParams.KeySchema?.push({
-                    AttributeName: DynamoDbEntityStorageConnector._PARTITION_ID_NAME,
-                    KeyType: "HASH"
-                });
-                const gsi = [];
-                if (core.Is.arrayValue(this._entitySchema.properties)) {
-                    for (const prop of this._entitySchema.properties) {
-                        if (prop.isPrimary) {
-                            tableParams.AttributeDefinitions?.push({
-                                AttributeName: prop.property,
-                                AttributeType: prop.type === "integer" || prop.type === "number" ? "N" : "S"
-                            });
-                            tableParams.KeySchema?.push({
-                                AttributeName: prop.property,
-                                KeyType: "RANGE"
-                            });
-                        }
-                        else if (core.Is.stringValue(prop.sortDirection) || prop.isSecondary) {
-                            // You can only query and sort items if you have a secondary index
-                            // defined for the property
-                            tableParams.AttributeDefinitions?.push({
-                                AttributeName: prop.property,
-                                AttributeType: prop.type === "integer" || prop.type === "number" ? "N" : "S"
-                            });
-                            gsi.push({
-                                IndexName: `${prop.property}Index`,
-                                KeySchema: [
-                                    {
-                                        AttributeName: DynamoDbEntityStorageConnector._PARTITION_ID_NAME,
-                                        KeyType: "HASH"
-                                    },
-                                    {
-                                        AttributeName: prop.property,
-                                        KeyType: "RANGE"
-                                    }
-                                ],
-                                Projection: {
-                                    ProjectionType: "ALL"
-                                },
-                                ProvisionedThroughput: {
-                                    ReadCapacityUnits: 1,
-                                    WriteCapacityUnits: 1
-                                }
-                            });
-                        }
-                    }
-                }
-                if (gsi.length > 0) {
-                    tableParams.GlobalSecondaryIndexes = gsi;
-                }
-                await dbConnection.createTable(tableParams);
-                // Wait for table to exist
-                await clientDynamodb.waitUntilTableExists({
-                    client: dbConnection,
-                    maxWaitTime: 60000
-                }, {
-                    TableName: this._config.tableName
-                });
-                await nodeLogging?.log({
-                    level: "info",
-                    source: this.CLASS_NAME,
-                    ts: Date.now(),
-                    message: "tableCreated",
-                    data: {
-                        tableName: this._config.tableName
-                    }
-                });
-            }
-            catch (err) {
-                if (core.BaseError.isErrorCode(err, "ResourceInUseException")) {
-                    await nodeLogging?.log({
-                        level: "info",
-                        source: this.CLASS_NAME,
-                        ts: Date.now(),
-                        message: "tableExists",
-                        data: {
-                            tableName: this._config.tableName
-                        }
-                    });
-                }
-                else {
-                    await nodeLogging?.log({
-                        level: "error",
-                        source: this.CLASS_NAME,
-                        ts: Date.now(),
-                        message: "tableCreateFailed",
-                        error: core.BaseError.fromError(err),
-                        data: {
-                            tableName: this._config.tableName
-                        }
-                    });
-                }
-                return false;
-            }
-        }
-        else {
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "tableExists",
-                data: {
-                    tableName: this._config.tableName
-                }
-            });
-        }
-        return true;
-    }
-    /**
-     * Get the schema for the entities.
-     * @returns The schema for the entities.
-     */
-    getSchema() {
-        return this._entitySchema;
-    }
-    /**
-     * Get an entity.
-     * @param id The id of the entity to get, or the index value if secondaryIndex is set.
-     * @param secondaryIndex Get the item using a secondary index.
-     * @param conditions The optional conditions to match for the entities.
-     * @returns The object if it can be found or undefined.
-     */
-    async get(id, secondaryIndex, conditions) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
-        try {
-            const docClient = this.createDocClient();
-            if (core.Is.empty(secondaryIndex) && core.Is.empty(conditions)) {
-                const getCommand = new libDynamodb.GetCommand({
-                    TableName: this._config.tableName,
-                    Key: {
-                        [DynamoDbEntityStorageConnector._PARTITION_ID_NAME]: DynamoDbEntityStorageConnector._PARTITION_ID_VALUE,
-                        [this._primaryKey.property]: id
-                    }
-                });
-                const response = await docClient.send(getCommand);
-                delete response.Item?.[DynamoDbEntityStorageConnector._PARTITION_ID_NAME];
-                return response.Item;
-            }
-            const finalConditions = {
-                conditions: []
-            };
-            if (core.Is.stringValue(secondaryIndex)) {
-                finalConditions.conditions.push({
-                    property: secondaryIndex,
-                    comparison: entity.ComparisonOperator.Equals,
-                    value: id
-                });
-            }
-            if (core.Is.arrayValue(conditions)) {
-                for (const c of conditions) {
-                    finalConditions.conditions.push({
-                        property: c.property,
-                        comparison: entity.ComparisonOperator.Equals,
-                        value: c.value
-                    });
-                }
-            }
-            const queryResult = await this.internalQuery(finalConditions, undefined, undefined, undefined, 1, secondaryIndex);
-            return queryResult.entities[0];
-        }
-        catch (err) {
-            if (core.BaseError.isErrorCode(err, "ResourceNotFoundException")) {
-                throw new core.GeneralError(this.CLASS_NAME, "tableDoesNotExist", {
-                    table: this._config.tableName
-                }, err);
-            }
-            throw new core.GeneralError(this.CLASS_NAME, "getFailed", {
-                id
-            }, err);
-        }
-    }
-    /**
-     * Set an entity.
-     * @param entity The entity to set.
-     * @param conditions The optional conditions to match for the entities.
-     * @returns The id of the entity.
-     */
-    async set(entity$1, conditions) {
-        core.Guards.object(this.CLASS_NAME, "entity", entity$1);
-        entity.EntitySchemaHelper.validateEntity(entity$1, this.getSchema());
-        const id = entity$1[this._primaryKey.property];
-        try {
-            const docClient = this.createDocClient();
-            const { conditionExpression, attributeNames, attributeValues } = this.buildConditionExpression(conditions);
-            const putCommand = new libDynamodb.PutCommand({
-                TableName: this._config.tableName,
-                Item: {
-                    [DynamoDbEntityStorageConnector._PARTITION_ID_NAME]: DynamoDbEntityStorageConnector._PARTITION_ID_VALUE,
-                    ...entity$1
-                },
-                // Only set the condition expression if we have conditions to match
-                // and the primary key exists, otherwise we are creating a new object
-                ConditionExpression: core.Is.stringValue(conditionExpression)
-                    ? `(attribute_exists(${this._primaryKey.property}) AND ${conditionExpression}) OR attribute_not_exists(${this._primaryKey.property})`
-                    : undefined,
-                ExpressionAttributeNames: attributeNames,
-                ExpressionAttributeValues: attributeValues
-            });
-            await docClient.send(putCommand);
-        }
-        catch (err) {
-            if (core.BaseError.isErrorName(err, "ConditionalCheckFailedException")) {
-                return;
-            }
-            if (core.BaseError.isErrorCode(err, "ResourceNotFoundException")) {
-                throw new core.GeneralError(this.CLASS_NAME, "tableDoesNotExist", {
-                    tableName: this._config.tableName
-                }, err);
-            }
-            throw new core.GeneralError(this.CLASS_NAME, "setFailed", {
-                id
-            }, err);
-        }
-    }
-    /**
-     * Remove the entity.
-     * @param id The id of the entity to remove.
-     * @param conditions The optional conditions to match for the entities.
-     * @returns Nothing.
-     */
-    async remove(id, conditions) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
-        try {
-            const docClient = this.createDocClient();
-            const { conditionExpression, attributeNames, attributeValues } = this.buildConditionExpression(conditions);
-            const deleteCommand = new libDynamodb.DeleteCommand({
-                TableName: this._config.tableName,
-                Key: {
-                    [DynamoDbEntityStorageConnector._PARTITION_ID_NAME]: DynamoDbEntityStorageConnector._PARTITION_ID_VALUE,
-                    [this._primaryKey.property]: id
-                },
-                ConditionExpression: conditionExpression,
-                ExpressionAttributeNames: attributeNames,
-                ExpressionAttributeValues: attributeValues
-            });
-            await docClient.send(deleteCommand);
-        }
-        catch (err) {
-            if (core.BaseError.isErrorName(err, "ConditionalCheckFailedException")) {
-                return;
-            }
-            if (core.BaseError.isErrorCode(err, "ResourceNotFoundException")) {
-                throw new core.GeneralError(this.CLASS_NAME, "tableDoesNotExist", {
-                    table: this._config.tableName
-                }, err);
-            }
-            throw new core.GeneralError(this.CLASS_NAME, "removeFailed", {
-                id
-            }, err);
-        }
-    }
-    /**
-     * Find all the entities which match the conditions.
-     * @param conditions The conditions to match for the entities.
-     * @param sortProperties The optional sort order.
-     * @param properties The optional properties to return, defaults to all.
-     * @param cursor The cursor to request the next page of entities.
-     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
-     * @returns All the entities for the storage matching the conditions,
-     * and a cursor which can be used to request more entities.
-     */
-    async query(conditions, sortProperties, properties, cursor, pageSize) {
-        return this.internalQuery(conditions, sortProperties, properties, cursor, pageSize);
-    }
-    /**
-     * Delete the table.
-     * @returns Nothing.
-     */
-    async tableDelete() {
-        try {
-            const dbConnection = this.createConnection();
-            await dbConnection.deleteTable({ TableName: this._config.tableName });
-        }
-        catch { }
-    }
-    /**
-     * Create the parameters for a query.
-     * @param objectPath The path for the nested object.
-     * @param condition The conditions to create the query from.
-     * @param attributeNames The attribute names to use in the query.
-     * @param attributeValues The attribute values to use in the query.
-     * @returns The condition clause.
-     * @internal
-     */
-    buildQueryParameters(objectPath, condition, attributeNames, attributeValues, secondaryIndex) {
-        // If no conditions are defined then return empty string
-        if (core.Is.undefined(condition)) {
-            return {
-                keyCondition: "",
-                filterCondition: ""
-            };
-        }
-        if ("conditions" in condition) {
-            if (condition.conditions.length === 0) {
-                return {
-                    keyCondition: "",
-                    filterCondition: ""
-                };
-            }
-            // It's a group of comparisons, so check the individual items and combine with the logical operator
-            const joinConditions = condition.conditions.map(c => this.buildQueryParameters(objectPath, c, attributeNames, attributeValues, secondaryIndex));
-            const logicalOperator = this.mapConditionalOperator(condition.logicalOperator);
-            const keyCondition = joinConditions
-                .filter(j => j.keyCondition.length > 0)
-                .map(j => j.keyCondition)
-                .join(` ${logicalOperator} `);
-            const filterCondition = joinConditions
-                .filter(j => j.filterCondition.length > 0)
-                .map(j => j.filterCondition)
-                .join(` ${logicalOperator} `);
-            return {
-                keyCondition: core.Is.stringValue(keyCondition) ? ` (${keyCondition}) ` : "",
-                filterCondition: core.Is.stringValue(filterCondition) ? ` (${filterCondition}) ` : ""
-            };
-        }
-        const schemaProp = this._entitySchema.properties?.find(p => p.property === condition.property);
-        // It's a single value so just create the property comparison for the condition
-        const comparison = this.mapComparisonOperator(objectPath, condition, schemaProp?.type, attributeNames, attributeValues);
-        const isKey = schemaProp?.isPrimary ?? (schemaProp?.isSecondary && schemaProp?.property === secondaryIndex);
-        return {
-            keyCondition: isKey ? comparison : "",
-            filterCondition: !isKey ? comparison : ""
-        };
-    }
-    /**
-     * Map the framework comparison operators to those in DynamoDB.
-     * @param objectPath The prefix to use for the condition.
-     * @param comparator The operator to map.
-     * @param type The type of the property.
-     * @param attributeNames The attribute names to use in the query.
-     * @param attributeValues The attribute values to use in the query.
-     * @returns The comparison expression.
-     * @throws GeneralError if the comparison operator is not supported.
-     * @internal
-     */
-    mapComparisonOperator(objectPath, comparator, type, attributeNames, attributeValues) {
-        let prop = objectPath;
-        if (prop.length > 0) {
-            prop += ".";
-        }
-        prop += comparator.property;
-        let attributeName = this.populateAttributeNames(prop, attributeNames);
-        if (core.Is.empty(comparator.value)) {
-            if (comparator.comparison === entity.ComparisonOperator.Equals) {
-                return `attribute_not_exists(${attributeName})`;
-            }
-            else if (comparator.comparison === entity.ComparisonOperator.NotEquals) {
-                return `attribute_exists(${attributeName})`;
-            }
-        }
-        let propName = `:${attributeName.replace(/\./g, "").replace(/#/g, "")}`;
-        if (core.Is.array(comparator.value)) {
-            const dbValues = comparator.value.map(v => this.propertyToDbValue(v, type));
-            const arrAttributeNames = [];
-            for (let i = 0; i < dbValues.length; i++) {
-                const arrAttributeName = `${propName}${i}`;
-                attributeValues[arrAttributeName] = dbValues[i];
-                arrAttributeNames.push(arrAttributeName);
-            }
-            propName = attributeName;
-            attributeName = `(${arrAttributeNames.join(", ")})`;
-        }
-        else {
-            attributeValues[propName] = this.propertyToDbValue(comparator.value, type);
-        }
-        if (comparator.comparison === entity.ComparisonOperator.Equals) {
-            return `${attributeName} = ${propName}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.NotEquals) {
-            return `${attributeName} <> ${propName}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.GreaterThan) {
-            return `${attributeName} > ${propName}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.LessThan) {
-            return `${attributeName} < ${propName}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.GreaterThanOrEqual) {
-            return `${attributeName} >= ${propName}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.LessThanOrEqual) {
-            return `${attributeName} <= ${propName}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.Includes) {
-            return `contains(${attributeName}, ${propName})`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.NotIncludes) {
-            return `notContains(${attributeName}, ${propName})`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.In) {
-            return `${propName} IN ${attributeName}`;
-        }
-        throw new core.GeneralError(this.CLASS_NAME, "comparisonNotSupported", {
-            comparison: comparator.comparison
-        });
-    }
-    /**
-     * Create a unique name for the attribute.
-     * @param name The name to create a unique name for.
-     * @param attributeNames The attribute names to use in the query.
-     * @returns The unique name.
-     * @internal
-     */
-    populateAttributeNames(name, attributeNames) {
-        const parts = name.split(".");
-        const attributeNameParts = [];
-        for (const part of parts) {
-            const hashPart = `#${part}`;
-            if (core.Is.empty(attributeNames[hashPart])) {
-                attributeNames[hashPart] = part;
-            }
-            attributeNameParts.push(hashPart);
-        }
-        return attributeNameParts.join(".");
-    }
-    /**
-     * Map the framework conditional operators to those in DynamoDB.
-     * @param operator The operator to map.
-     * @returns The conditional operator.
-     * @throws GeneralError if the conditional operator is not supported.
-     * @internal
-     */
-    mapConditionalOperator(operator) {
-        if ((operator ?? entity.LogicalOperator.And) === entity.LogicalOperator.And) {
-            return "AND";
-        }
-        else if (operator === entity.LogicalOperator.Or) {
-            return "OR";
-        }
-        throw new core.GeneralError(this.CLASS_NAME, "conditionalNotSupported", { operator });
-    }
-    /**
-     * Format a value to insert into DB.
-     * @param value The value to format.
-     * @param type The type for the property.
-     * @returns The value after conversion.
-     * @internal
-     */
-    propertyToDbValue(value, type) {
-        if (core.Is.object(value)) {
-            const map = {};
-            for (const key in value) {
-                map[key] = this.propertyToDbValue(value[key]);
-            }
-            return {
-                M: map
-            };
-        }
-        if (type === "integer" || type === "number") {
-            return { N: core.Coerce.string(value) ?? "" };
-        }
-        else if (type === "boolean") {
-            return { BOOL: core.Coerce.boolean(value) ?? false };
-        }
-        return { S: core.Coerce.string(value) ?? "" };
-    }
-    /**
-     * Create a doc client connection.
-     * @returns The dynamo db document client.
-     * @internal
-     */
-    createDocClient() {
-        return libDynamodb.DynamoDBDocumentClient.from(new clientDynamodb.DynamoDB({
-            apiVersion: "2012-10-08",
-            ...this.createConnectionConfig()
-        }), {
-            marshallOptions: {
-                removeUndefinedValues: true
-            }
-        });
-    }
-    /**
-     * Create a new DB connection.
-     * @returns The Dynamo DB connection.
-     * @internal
-     */
-    createConnection() {
-        return new clientDynamodb.DynamoDB(this.createConnectionConfig());
-    }
-    /**
-     * Create a new DB connection configuration.
-     * @returns The Dynamo DB connection configuration.
-     * @internal
-     */
-    createConnectionConfig() {
-        if (core.Is.stringValue(this._config.secretAccessKey) &&
-            core.Is.stringValue(this._config.accessKeyId) &&
-            this._config.authMode === "credentials") {
-            return {
-                credentials: {
-                    accessKeyId: this._config.accessKeyId,
-                    secretAccessKey: this._config.secretAccessKey
-                },
-                endpoint: this._config.endpoint,
-                region: this._config.region
-            };
-        }
-        return {
-            endpoint: this._config.endpoint,
-            region: this._config.region
-        };
-    }
-    /**
-     * Check if the table exists.
-     * @param tableName The table to check.
-     * @returns True if the table exists.
-     * @internal
-     */
-    async tableExists(tableName) {
-        try {
-            const dbConnection = this.createConnection();
-            await dbConnection.describeTable({ TableName: tableName });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Find all the entities which match the conditions.
-     * @param conditions The conditions to match for the entities.
-     * @param sortProperties The optional sort order.
-     * @param properties The optional properties to return, defaults to all.
-     * @param cursor The cursor to request the next page of entities.
-     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
-     * @param secondaryIndex The secondary index to use for the query.
-     * @returns All the entities for the storage matching the conditions,
-     * and a cursor which can be used to request more entities.
-     * @internal
-     */
-    async internalQuery(conditions, sortProperties, properties, cursor, pageSize, secondaryIndex) {
-        try {
-            const returnSize = pageSize ?? DynamoDbEntityStorageConnector._PAGE_SIZE;
-            let indexName = core.Is.stringValue(secondaryIndex)
-                ? `${secondaryIndex}Index`
-                : undefined;
-            // If we have a sortable property defined in the descriptor then we must use
-            // the secondary index for the query
-            let scanAscending = true;
-            if (core.Is.arrayValue(sortProperties)) {
-                if (sortProperties.length > 1) {
-                    throw new core.GeneralError(this.CLASS_NAME, "sortSingle");
-                }
-                for (const sortProperty of sortProperties) {
-                    const propertySchema = this._entitySchema.properties?.find(e => e.property === sortProperty.property);
-                    if (core.Is.undefined(propertySchema) ||
-                        (!propertySchema.isPrimary &&
-                            !propertySchema.isSecondary &&
-                            core.Is.empty(propertySchema.sortDirection))) {
-                        throw new core.GeneralError(this.CLASS_NAME, "sortNotIndexed", {
-                            property: sortProperty.property
-                        });
-                    }
-                    indexName = propertySchema.isPrimary
-                        ? undefined
-                        : `${sortProperty.property}Index`;
-                    scanAscending = sortProperty.sortDirection === entity.SortDirection.Ascending;
-                }
-            }
-            const attributeNames = { "#partitionId": "partitionId" };
-            const attributeValues = {
-                [`:${DynamoDbEntityStorageConnector._PARTITION_ID_NAME}`]: {
-                    S: DynamoDbEntityStorageConnector._PARTITION_ID_VALUE
-                }
-            };
-            const expressions = this.buildQueryParameters("", conditions, attributeNames, attributeValues, secondaryIndex);
-            let keyExpression = "#partitionId = :partitionId";
-            if (expressions.keyCondition.length > 0) {
-                keyExpression += ` AND ${expressions.keyCondition}`;
-            }
-            const query = new clientDynamodb.QueryCommand({
-                TableName: this._config.tableName,
-                IndexName: indexName,
-                KeyConditionExpression: keyExpression,
-                FilterExpression: core.Is.stringValue(expressions.filterCondition)
-                    ? expressions.filterCondition
-                    : undefined,
-                ExpressionAttributeNames: attributeNames,
-                ExpressionAttributeValues: attributeValues,
-                ProjectionExpression: properties?.map(p => p).join(", "),
-                Limit: returnSize,
-                ScanIndexForward: scanAscending,
-                ExclusiveStartKey: core.Is.empty(cursor)
-                    ? undefined
-                    : core.ObjectHelper.fromBytes(core.Converter.base64ToBytes(cursor))
-            });
-            const connection = this.createDocClient();
-            const results = await connection.send(query);
-            let entities = [];
-            if (core.Is.arrayValue(results.Items)) {
-                entities = results.Items.map(item => {
-                    const unmarshalled = utilDynamodb.unmarshall(item);
-                    delete unmarshalled[DynamoDbEntityStorageConnector._PARTITION_ID_NAME];
-                    return unmarshalled;
-                });
-            }
-            return {
-                entities,
-                cursor: core.Is.empty(results.LastEvaluatedKey)
-                    ? undefined
-                    : core.Converter.bytesToBase64(core.ObjectHelper.toBytes(results.LastEvaluatedKey))
-            };
-        }
-        catch (err) {
-            if (core.BaseError.isErrorCode(err, "ResourceNotFoundException")) {
-                throw new core.GeneralError(this.CLASS_NAME, "tableDoesNotExist", {
-                    table: this._config.tableName
-                }, err);
-            }
-            throw new core.GeneralError(this.CLASS_NAME, "queryFailed", undefined, err);
-        }
-    }
-    /**
-     * Build the condition expression for the query.
-     * @param conditions The conditions to build the expression from.
-     * @returns The condition expression.
-     * @throws GeneralError if the property is not found in the schema.
-     * @internal
-     */
-    buildConditionExpression(conditions) {
-        let conditionExpression;
-        let attributeNames;
-        let attributeValues;
-        if (core.Is.arrayValue(conditions)) {
-            const expressions = [];
-            for (const c of conditions) {
-                const schemaProp = this._entitySchema.properties?.find(p => p.property === c.property);
-                if (core.Is.undefined(schemaProp)) {
-                    throw new core.GeneralError(this.CLASS_NAME, "propertyNotFound", {
-                        property: c.property
-                    });
-                }
-                const attributeName = `#${c.property}`;
-                const attributeValueName = `:${c.property}`;
-                attributeNames ??= {};
-                attributeValues ??= {};
-                attributeNames[attributeName] = c.property;
-                attributeValues[attributeValueName] = c.value;
-                expressions.push(`${attributeName} = ${attributeValueName}`);
-            }
-            conditionExpression = expressions.join(" AND ");
-        }
-        return { conditionExpression, attributeNames, attributeValues };
-    }
-}
-
-exports.DynamoDbEntityStorageConnector = DynamoDbEntityStorageConnector;