@twin.org/entity-storage-connector-postgresql 0.0.2-next.9 → 0.0.3-next.1

package/dist/{esm/index.mjs → es/postgreSqlEntityStorageConnector.js}

@@ -1,27 +1,47 @@
-import { Guards, ComponentFactory, BaseError, GeneralError, Is, ObjectHelper } from '@twin.org/core';
-import { EntitySchemaFactory, EntitySchemaHelper, EntitySchemaPropertyType, SortDirection, ComparisonOperator, LogicalOperator } from '@twin.org/entity';
-import postgres from 'postgres';
-
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+import { ContextIdHelper, ContextIdStore } from "@twin.org/context";
+import { BaseError, Coerce, ComponentFactory, GeneralError, Guards, Is, ObjectHelper } from "@twin.org/core";
+import { ComparisonOperator, EntitySchemaFactory, EntitySchemaHelper, EntitySchemaPropertyType, LogicalOperator, SortDirection } from "@twin.org/entity";
+import postgres from "postgres";
 /**
  * Class for performing entity storage operations using ql.
  */
-class PostgreSqlEntityStorageConnector {
+export class PostgreSqlEntityStorageConnector {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "PostgreSqlEntityStorageConnector";
     /**
      * Limit the number of entities when finding.
      * @internal
      */
-    static _PAGE_SIZE = 40;
+    static _DEFAULT_LIMIT = 40;
     /**
-     * Runtime name for the class.
+     * Partition id field name.
+     * @internal
      */
-    CLASS_NAME = "PostgreSqlEntityStorageConnector";
+    static _PARTITION_KEY = "partitionId";
+    /**
+     * Partition id field value.
+     * @internal
+     */
+    static _PARTITION_KEY_VALUE = "root";
     /**
      * The schema for the entity.
      * @internal
      */
     _entitySchema;
+    /**
+     * The keys to use from the context ids to create partitions.
+     * @internal
+     */
+    _partitionContextIds;
+    /**
+     * The primary key property.
+     * @internal
+     */
+    _primaryKeyProperty;
     /**
      * The configuration for the connector.
      * @internal
@@ -37,15 +57,17 @@ class PostgreSqlEntityStorageConnector {
      * @param options The options for the connector.
      */
     constructor(options) {
-        Guards.object(this.CLASS_NAME, "options", options);
-        Guards.stringValue(this.CLASS_NAME, "options.entitySchema", options.entitySchema);
-        Guards.object(this.CLASS_NAME, "options.config", options.config);
-        Guards.stringValue(this.CLASS_NAME, "options.config.host", options.config.host);
-        Guards.stringValue(this.CLASS_NAME, "options.config.user", options.config.user);
-        Guards.stringValue(this.CLASS_NAME, "options.config.password", options.config.password);
-        Guards.stringValue(this.CLASS_NAME, "options.config.database", options.config.database);
-        Guards.stringValue(this.CLASS_NAME, "options.config.tableName", options.config.tableName);
+        Guards.object(PostgreSqlEntityStorageConnector.CLASS_NAME, "options", options);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.entitySchema", options.entitySchema);
+        Guards.object(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.config", options.config);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.config.host", options.config.host);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.config.user", options.config.user);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.config.password", options.config.password);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.config.database", options.config.database);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "options.config.tableName", options.config.tableName);
         this._entitySchema = EntitySchemaFactory.get(options.entitySchema);
+        this._partitionContextIds = options.partitionContextIds;
+        this._primaryKeyProperty = EntitySchemaHelper.getPrimaryKey(this._entitySchema);
         this._config = options.config;
     }
     /**
@@ -57,59 +79,80 @@ class PostgreSqlEntityStorageConnector {
         const nodeLogging = ComponentFactory.getIfExists(nodeLoggingComponentType);
         try {
             const dbConnection = await this.createConnection();
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "databaseCreating",
-                data: {
-                    database: this._config.database
-                }
-            });
-            const res = await dbConnection.unsafe(`SELECT datname FROM pg_catalog.pg_database WHERE datname = '${this._config.database}'`);
-            if (res.length === 0) {
+            const databaseExists = await this.databaseExists();
+            if (!databaseExists) {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: PostgreSqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "databaseCreating",
+                    data: {
+                        databaseName: this._config.database
+                    }
+                });
                 await dbConnection.unsafe(`CREATE DATABASE "${this._config.database}";`);
+                await this.waitForDatabaseExists();
             }
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "databaseExists",
-                data: {
-                    database: this._config.database
-                }
-            });
-            const tableExistsQuery = `SELECT to_regclass('${this._config.tableName}')`;
-            const tableExistsResult = await dbConnection.unsafe(tableExistsQuery);
-            if (!tableExistsResult[0].to_regclass) {
-                const createTableQuery = `CREATE TABLE IF NOT EXISTS ${this._config.tableName} (${this.mapPostgreSqlProperties(this._entitySchema)})`;
+            else {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: PostgreSqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "databaseExists",
+                    data: {
+                        databaseName: this._config.database
+                    }
+                });
+            }
+            const tableExists = await this.tableExists();
+            if (!tableExists) {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: PostgreSqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "tableCreating",
+                    data: {
+                        tableName: this._config.tableName
+                    }
+                });
+                const createTableQuery = `CREATE TABLE ${this._config.tableName} (${this.mapPostgreSqlProperties(this._entitySchema)})`;
                 await dbConnection.unsafe(createTableQuery);
+                await this.waitForTableExists();
+            }
+            else {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: PostgreSqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "tableExists",
+                    data: {
+                        tableName: this._config.tableName
+                    }
+                });
             }
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "tableExists",
-                data: {
-                    table: this._config.tableName
-                }
-            });
         }
         catch (error) {
             await nodeLogging?.log({
                 level: "error",
-                source: this.CLASS_NAME,
+                source: PostgreSqlEntityStorageConnector.CLASS_NAME,
                 ts: Date.now(),
                 message: "databaseCreateFailed",
                 error: BaseError.fromError(error),
                 data: {
-                    database: this._config.database
+                    databaseName: this._config.database
                 }
             });
             return false;
         }
         return true;
     }
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className() {
+        return PostgreSqlEntityStorageConnector.CLASS_NAME;
+    }
     /**
      * Get the schema for the entities.
      * @returns The schema for the entities.
@@ -125,21 +168,24 @@ class PostgreSqlEntityStorageConnector {
      * @returns The object if it can be found or undefined.
      */
     async get(id, secondaryIndex, conditions) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "id", id);
+        const contextIds = await ContextIdStore.getContextIds();
+        const partitionKey = ContextIdHelper.combinedContextKey(contextIds, this._partitionContextIds);
         try {
             const dbConnection = await this.createConnection();
             const whereClauses = [];
             const values = [];
+            whereClauses.push(`"${PostgreSqlEntityStorageConnector._PARTITION_KEY}" = $1`);
+            values.push(partitionKey ?? PostgreSqlEntityStorageConnector._PARTITION_KEY_VALUE);
             if (secondaryIndex) {
-                whereClauses.push(`"${String(secondaryIndex)}" = $1`);
+                whereClauses.push(`"${String(secondaryIndex)}" = $2`);
                 values.push(id);
             }
             else {
-                const primaryKey = EntitySchemaHelper.getPrimaryKey(this.getSchema());
-                whereClauses.push(`"${primaryKey.property}" = $1`);
+                whereClauses.push(`"${this._primaryKeyProperty.property}" = $2`);
                 values.push(id);
             }
-            if (conditions) {
+            if (Is.arrayValue(conditions)) {
                 for (const condition of conditions) {
                     whereClauses.push(`"${String(condition.property)}" = $${values.length + 1}`);
                     values.push(condition.value);
@@ -147,7 +193,7 @@ class PostgreSqlEntityStorageConnector {
             }
             const query = `SELECT * FROM "${this._config.tableName}" WHERE ${whereClauses.join(" AND ")} LIMIT 1`;
             const rows = await dbConnection.unsafe(query, values);
-            if (Array.isArray(rows) && rows.length === 1) {
+            if (Is.array(rows) && rows.length === 1) {
                 if (this._entitySchema.properties) {
                     for (const prop of this._entitySchema.properties) {
                         const row = rows[0];
@@ -165,11 +211,13 @@ class PostgreSqlEntityStorageConnector {
                         }
                     }
                 }
-                return rows[0];
+                const entity = ObjectHelper.removeEmptyProperties(rows[0], { removeNull: true });
+                ObjectHelper.propertyDelete(entity, PostgreSqlEntityStorageConnector._PARTITION_KEY);
+                return entity;
             }
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "getFailed", {
+            throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "getFailed", {
                 id
             }, err);
         }
@@ -182,10 +230,11 @@ class PostgreSqlEntityStorageConnector {
      * @returns The id of the entity.
      */
     async set(entity, conditions) {
-        Guards.object(this.CLASS_NAME, "entity", entity);
+        Guards.object(PostgreSqlEntityStorageConnector.CLASS_NAME, "entity", entity);
+        const contextIds = await ContextIdStore.getContextIds();
+        const partitionKey = ContextIdHelper.combinedContextKey(contextIds, this._partitionContextIds);
         EntitySchemaHelper.validateEntity(entity, this.getSchema());
-        const primaryKey = EntitySchemaHelper.getPrimaryKey(this.getSchema());
-        const id = entity[primaryKey.property];
+        const id = entity[this._primaryKeyProperty.property];
         try {
             if (Is.arrayValue(conditions)) {
                 const itemData = await this.get(id);
@@ -193,20 +242,37 @@ class PostgreSqlEntityStorageConnector {
                     return;
                 }
             }
-            const columns = Object.keys(entity)
-                .map(key => `"${key}"`)
-                .join(", ");
-            // eslint-disable-next-line no-confusing-arrow
-            const values = Object.values(entity).map(value => value === undefined ? null : value);
-            const placeholders = values.map((_, index) => `$${index + 1}`).join(", ");
+            const finalEntity = ObjectHelper.clone(entity);
+            const props = [...(this._entitySchema.properties ?? [])];
+            props.unshift({
+                property: PostgreSqlEntityStorageConnector._PARTITION_KEY,
+                type: EntitySchemaPropertyType.String
+            });
+            ObjectHelper.propertySet(finalEntity, PostgreSqlEntityStorageConnector._PARTITION_KEY, partitionKey ?? PostgreSqlEntityStorageConnector._PARTITION_KEY_VALUE);
+            ObjectHelper.propertySet(finalEntity, PostgreSqlEntityStorageConnector._PARTITION_KEY, partitionKey ?? PostgreSqlEntityStorageConnector._PARTITION_KEY_VALUE);
+            const keys = [];
+            const values = [];
+            for (const prop of props) {
+                if (!(Is.empty(finalEntity[prop.property]) && (prop.optional ?? false))) {
+                    keys.push(prop.property);
+                    if (finalEntity[prop.property] === undefined) {
+                        values.push(null);
+                    }
+                    else {
+                        values.push(finalEntity[prop.property]);
+                    }
+                }
+            }
+            let sql = `INSERT INTO "${this._config.tableName}"`;
+            sql += ` (${keys.map(key => `"${key}"`).join(", ")})`;
+            sql += ` VALUES (${values.map((_, i) => `$${i + 1}`).join(", ")})`;
+            sql += ` ON CONFLICT ("${PostgreSqlEntityStorageConnector._PARTITION_KEY}", "${this._primaryKeyProperty.property}")`;
+            sql += ` DO UPDATE SET ${keys.map(key => `"${key}" = EXCLUDED."${key}"`).join(", ")};`;
             const dbConnection = await this.createConnection();
-            await dbConnection.unsafe(`INSERT INTO "${this._config.tableName}" (${columns}) VALUES (${placeholders}) ON CONFLICT ("${primaryKey.property}") DO UPDATE SET ${columns
-                .split(", ")
-                .map(col => `${col} = EXCLUDED.${col}`)
-                .join(", ")};`, values);
+            await dbConnection.unsafe(sql, values);
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "setFailed", {
+            throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "setFailed", {
                 id
             }, err);
         }
@@ -218,26 +284,31 @@ class PostgreSqlEntityStorageConnector {
      * @returns Nothing.
      */
     async remove(id, conditions) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+        Guards.stringValue(PostgreSqlEntityStorageConnector.CLASS_NAME, "id", id);
+        const contextIds = await ContextIdStore.getContextIds();
+        const partitionKey = ContextIdHelper.combinedContextKey(contextIds, this._partitionContextIds);
         try {
             const dbConnection = await this.createConnection();
             const itemData = await this.get(id);
             if (Is.notEmpty(itemData)) {
-                const values = [id];
-                let whereClauses = [];
+                const values = [];
+                const whereClauses = [];
+                whereClauses.push(`"${this._primaryKeyProperty.property}" = $${values.length + 1}`);
+                values.push(id);
+                whereClauses.push(`"${PostgreSqlEntityStorageConnector._PARTITION_KEY}" = $${values.length + 1}`);
+                values.push(partitionKey ?? PostgreSqlEntityStorageConnector._PARTITION_KEY_VALUE);
                 if (Is.arrayValue(conditions)) {
-                    whereClauses = conditions.map(condition => {
+                    whereClauses.push(...conditions.map(condition => {
                         values.push(condition.value);
                         return `"${String(condition.property)}" = $${values.length}`;
-                    });
+                    }));
                 }
-                const primaryKey = EntitySchemaHelper.getPrimaryKey(this.getSchema());
-                const query = `DELETE FROM "${this._config.tableName}" WHERE "${primaryKey.property}" = $1${whereClauses.length > 0 ? ` AND ${whereClauses.join(" AND ")}` : ""}`;
+                const query = `DELETE FROM "${this._config.tableName}" WHERE ${whereClauses.join(" AND ")}`;
                 await dbConnection.unsafe(query, values);
             }
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "removeFailed", {
+            throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "removeFailed", {
                 id
             }, err);
         }
@@ -247,17 +318,19 @@ class PostgreSqlEntityStorageConnector {
      * @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 cursor The cursor to request the next chunk of entities.
+     * @param limit 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) {
-        const sql = "";
+    async query(conditions, sortProperties, properties, cursor, limit) {
+        const contextIds = await ContextIdStore.getContextIds();
+        const partitionKey = ContextIdHelper.combinedContextKey(contextIds, this._partitionContextIds);
+        let sql = "";
         try {
-            const returnSize = pageSize ?? PostgreSqlEntityStorageConnector._PAGE_SIZE;
+            const returnSize = limit ?? PostgreSqlEntityStorageConnector._DEFAULT_LIMIT;
             let orderByClause = "";
-            if (Array.isArray(sortProperties)) {
+            if (Is.arrayValue(sortProperties)) {
                 const orderClauses = [];
                 for (const sortProperty of sortProperties) {
                     const direction = sortProperty.sortDirection === SortDirection.Ascending ? "ASC" : "DESC";
@@ -267,12 +340,25 @@ class PostgreSqlEntityStorageConnector {
             }
             const whereClauses = [];
             const values = [];
-            if (conditions) {
-                this.buildQueryParameters("", conditions, whereClauses, values);
+            const finalConditions = {
+                conditions: [],
+                logicalOperator: LogicalOperator.And
+            };
+            finalConditions.conditions.push({
+                property: PostgreSqlEntityStorageConnector._PARTITION_KEY,
+                comparison: ComparisonOperator.Equals,
+                value: partitionKey ?? PostgreSqlEntityStorageConnector._PARTITION_KEY_VALUE
+            });
+            if (!Is.empty(conditions)) {
+                finalConditions.conditions.push(conditions);
             }
-            const query = `SELECT ${properties ? properties.map(p => `"${String(p)}"`).join(", ") : "*"} FROM "${this._config.tableName}" ${whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : ""} ${orderByClause} LIMIT ${returnSize} OFFSET ${cursor ? Number(cursor) : 0}::integer`;
+            this.buildQueryParameters("", finalConditions, whereClauses, values, 1);
+            const startIndex = Coerce.number(cursor) ?? 0;
+            sql = `SELECT ${properties ? properties.map(p => `"${String(p)}"`).join(", ") : "*"} FROM "${this._config.tableName}"`;
+            sql += ` WHERE ${whereClauses.join(" AND ")}`;
+            sql += ` ${orderByClause} LIMIT ${returnSize} OFFSET ${startIndex}`;
             const dbConnection = await this.createConnection();
-            const rows = await dbConnection.unsafe(query, values);
+            const rows = await dbConnection.unsafe(sql, values);
             if (this._entitySchema.properties) {
                 for (const row of rows) {
                     for (const prop of this._entitySchema.properties) {
@@ -280,7 +366,7 @@ class PostgreSqlEntityStorageConnector {
                         propColumn = propColumn.toLowerCase();
                         if ((prop.type === EntitySchemaPropertyType.Object ||
                             prop.type === EntitySchemaPropertyType.Array) &&
-                            typeof row[propColumn] === "string") {
+                            Is.string(row[propColumn])) {
                             const rowValue = JSON.parse(row[propColumn]);
                             delete row[propColumn];
                             row[prop.property] = rowValue;
@@ -291,15 +377,20 @@ class PostgreSqlEntityStorageConnector {
                     }
                 }
             }
+            const entities = rows;
+            for (let i = 0; i < entities.length; i++) {
+                ObjectHelper.propertyDelete(entities[i], PostgreSqlEntityStorageConnector._PARTITION_KEY);
+                entities[i] = ObjectHelper.removeEmptyProperties(entities[i], { removeNull: true });
+            }
             return {
-                entities: rows,
-                cursor: Array.isArray(rows) && rows.length === returnSize
-                    ? String((cursor ? Number(cursor) : 0) + returnSize)
+                entities,
+                cursor: Is.array(rows) && rows.length === returnSize
+                    ? Coerce.string(startIndex + returnSize)
                     : undefined
             };
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "queryFailed", { sql }, err);
+            throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "queryFailed", { sql }, err);
         }
     }
     /**
@@ -308,25 +399,101 @@ class PostgreSqlEntityStorageConnector {
      */
     async tableDrop() {
         try {
+            const tableExists = await this.tableExists();
+            if (!tableExists) {
+                return;
+            }
             const dbConnection = await this.createConnection();
             await dbConnection.unsafe(`DROP TABLE ${this._config.tableName};`);
+            await this.waitForTableNotExists();
         }
         catch {
             // Ignore errors
         }
     }
+    /**
+     * Check if the database exists.
+     * @returns True if the database exists, false otherwise.
+     * @internal
+     */
+    async databaseExists() {
+        try {
+            const dbConnection = await this.createConnection();
+            const res = await dbConnection.unsafe(`SELECT datname FROM pg_catalog.pg_database WHERE datname = '${this._config.database}'`);
+            return res.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Wait for a database to exist.
+     * @returns Nothing.
+     * @internal
+     */
+    async waitForDatabaseExists() {
+        for (let attempt = 0; attempt < 20; attempt++) {
+            const databaseExists = await this.databaseExists();
+            if (databaseExists) {
+                break;
+            }
+            await new Promise(resolve => setTimeout(resolve, 250));
+        }
+    }
+    /**
+     * Check if the table exists.
+     * @returns True if the table exists, false otherwise.
+     * @internal
+     */
+    async tableExists() {
+        try {
+            const dbConnection = await this.createConnection();
+            const tableExistsQuery = `SELECT to_regclass('${this._config.tableName}')`;
+            const tableExistsResult = await dbConnection.unsafe(tableExistsQuery);
+            return tableExistsResult[0].to_regclass !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Wait for a table to exist.
+     * @returns Nothing.
+     * @internal
+     */
+    async waitForTableExists() {
+        for (let attempt = 0; attempt < 20; attempt++) {
+            const tableExists = await this.tableExists();
+            if (tableExists) {
+                break;
+            }
+            await new Promise(resolve => setTimeout(resolve, 250));
+        }
+    }
+    /**
+     * Wait for a table to not exist.
+     * @returns Nothing.
+     * @internal
+     */
+    async waitForTableNotExists() {
+        for (let attempt = 0; attempt < 20; attempt++) {
+            const tableExists = await this.tableExists();
+            if (!tableExists) {
+                break;
+            }
+            await new Promise(resolve => setTimeout(resolve, 250));
+        }
+    }
     /**
      * Create a new DB connection.
      * @returns The PostgreSql connection.
      * @internal
      */
     async createConnection() {
-        if (this._connection) {
-            return this._connection;
+        if (Is.empty(this._connection)) {
+            this._connection = postgres(this.createConnectionConfig());
         }
-        const newConnection = await postgres(this.createConnectionConfig());
-        this._connection = newConnection;
-        return newConnection;
+        return this._connection;
     }
     /**
      * Create a new DB connection configuration.
@@ -347,9 +514,10 @@ class PostgreSqlEntityStorageConnector {
      * @param condition The conditions to create the query from.
      * @param whereClauses The where clauses to use in the query.
      * @param values The values to use in the query.
+     * @param valueIndex The current value index.
      * @internal
      */
-    buildQueryParameters(objectPath, condition, whereClauses, values) {
+    buildQueryParameters(objectPath, condition, whereClauses, values, valueIndex) {
         if (Is.undefined(condition)) {
             return;
         }
@@ -360,8 +528,9 @@ class PostgreSqlEntityStorageConnector {
             const joinConditions = condition.conditions.map(c => {
                 const subWhereClauses = [];
                 const subValues = [];
-                this.buildQueryParameters(objectPath, c, subWhereClauses, subValues);
+                this.buildQueryParameters(objectPath, c, subWhereClauses, subValues, valueIndex);
                 values.push(...subValues);
+                valueIndex += subValues.length;
                 return subWhereClauses.join(" AND ");
             });
             const logicalOperator = this.mapConditionalOperator(condition.logicalOperator);
@@ -372,7 +541,7 @@ class PostgreSqlEntityStorageConnector {
             return;
         }
         const schemaProp = this._entitySchema.properties?.find(p => p.property === condition.property);
-        const comparison = this.mapComparisonOperator(objectPath, condition, schemaProp?.type, values);
+        const comparison = this.mapComparisonOperator(objectPath, condition, schemaProp?.type, values, valueIndex);
         whereClauses.push(comparison);
     }
     /**
@@ -381,22 +550,21 @@ class PostgreSqlEntityStorageConnector {
      * @param comparator The operator to map.
      * @param type The type of the property.
      * @param values The values to use in the query.
+     * @param valueIndex The current value index.
      * @returns The comparison expression.
      * @throws GeneralError if the comparison operator is not supported.
      * @internal
      */
-    mapComparisonOperator(objectPath, comparator, type, values) {
+    mapComparisonOperator(objectPath, comparator, type, values, valueIndex) {
         let prop = objectPath;
         if (prop.length > 0) {
             prop += ".";
         }
         prop += comparator.property;
         if (comparator.comparison === ComparisonOperator.In) {
-            const inValues = Array.isArray(comparator.value) ? comparator.value : [comparator.value];
+            const inValues = Is.array(comparator.value) ? comparator.value : [comparator.value];
             values.push(...inValues.map(val => this.propertyToDbValue(val, type)));
-            const placeholders = inValues
-                .map((_, index) => `$${values.length - inValues.length + index + 1}`)
-                .join(", ");
+            const placeholders = inValues.map((_, index) => `$${valueIndex + index}`).join(", ");
             return `"${prop}" IN (${placeholders})`;
         }
         const dbValue = this.propertyToDbValue(comparator.value, type);
@@ -407,30 +575,30 @@ class PostgreSqlEntityStorageConnector {
                 .slice(1)
                 .map((p, i, arr) => (i === arr.length - 1 ? `->> '${p}'` : `-> '${p}'`))
                 .join("");
-            return `("${comparator.property.split(".")[0]}"::jsonb ${jsonPath}) = $${values.length}`;
+            return `("${comparator.property.split(".")[0]}"::jsonb ${jsonPath}) = $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.Equals) {
-            return `"${prop}" = $${values.length}`;
+            return `"${prop}" = $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.NotEquals) {
-            return `"${prop}" <> $${values.length}`;
+            return `"${prop}" <> $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.GreaterThan) {
-            return `"${prop}" > $${values.length}`;
+            return `"${prop}" > $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.LessThan) {
-            return `"${prop}" < $${values.length}`;
+            return `"${prop}" < $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.GreaterThanOrEqual) {
-            return `"${prop}" >= $${values.length}`;
+            return `"${prop}" >= $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.LessThanOrEqual) {
-            return `"${prop}" <= $${values.length}`;
+            return `"${prop}" <= $${valueIndex}`;
         }
         else if (comparator.comparison === ComparisonOperator.Includes) {
-            return `EXISTS (SELECT 1 FROM jsonb_array_elements("${prop}") elem WHERE elem @> $${values.length}::jsonb)`;
+            return `EXISTS (SELECT 1 FROM jsonb_array_elements("${prop}") elem WHERE elem @> $${valueIndex}::jsonb)`;
         }
-        throw new GeneralError(this.CLASS_NAME, "comparisonNotSupported", {
+        throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "comparisonNotSupported", {
             comparison: comparator.comparison
         });
     }
@@ -473,7 +641,9 @@ class PostgreSqlEntityStorageConnector {
         else if (operator === LogicalOperator.Or) {
             return "OR";
         }
-        throw new GeneralError(this.CLASS_NAME, "conditionalNotSupported", { operator });
+        throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "conditionalNotSupported", {
+            operator
+        });
     }
     /**
      * Verify the conditions for the entity.
@@ -499,10 +669,17 @@ class PostgreSqlEntityStorageConnector {
             [EntitySchemaPropertyType.Boolean]: "BOOLEAN"
         };
         if (!entitySchema.properties) {
-            throw new GeneralError(this.CLASS_NAME, "entitySchemaPropertiesUndefined");
+            throw new GeneralError(PostgreSqlEntityStorageConnector.CLASS_NAME, "entitySchemaPropertiesUndefined");
         }
         const primaryKeys = [];
-        const columnDefinitions = entitySchema.properties
+        const props = [...entitySchema.properties];
+        props.unshift({
+            property: PostgreSqlEntityStorageConnector._PARTITION_KEY,
+            type: EntitySchemaPropertyType.String,
+            optional: false,
+            isPrimary: true
+        });
+        const columnDefinitions = props
             .map(prop => {
             const sqlType = sqlTypeMap[prop.type] || "TEXT";
             const columnName = String(prop.property);
@@ -513,9 +690,8 @@ class PostgreSqlEntityStorageConnector {
             return `"${columnName}" ${sqlType}${nullable}`;
         })
             .join(", ");
-        const primaryKeyDefinition = primaryKeys.length > 0 ? `, PRIMARY KEY (${primaryKeys.join(", ")})` : "";
+        const primaryKeyDefinition = primaryKeys.length > 0 ? `, PRIMARY KEY ("${primaryKeys.join('", "')}")` : "";
         return columnDefinitions + primaryKeyDefinition;
     }
 }
-
-export { PostgreSqlEntityStorageConnector };
+//# sourceMappingURL=postgreSqlEntityStorageConnector.js.map