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

package/dist/es/index.js

@@ -0,0 +1,6 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+export * from "./models/IMySqlEntityStorageConnectorConfig.js";
+export * from "./models/IMySqlEntityStorageConnectorConstructorOptions.js";
+export * from "./mysqlEntityStorageConnector.js";
+//# sourceMappingURL=index.js.map

package/dist/es/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,uCAAuC;AACvC,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,kCAAkC,CAAC","sourcesContent":["// Copyright 2024 IOTA Stiftung.\n// SPDX-License-Identifier: Apache-2.0.\nexport * from \"./models/IMySqlEntityStorageConnectorConfig.js\";\nexport * from \"./models/IMySqlEntityStorageConnectorConstructorOptions.js\";\nexport * from \"./mysqlEntityStorageConnector.js\";\n"]}

package/dist/es/models/IMySqlEntityStorageConnectorConfig.js

@@ -0,0 +1,4 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+export {};
+//# sourceMappingURL=IMySqlEntityStorageConnectorConfig.js.map

package/dist/es/models/IMySqlEntityStorageConnectorConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMySqlEntityStorageConnectorConfig.js","sourceRoot":"","sources":["../../../src/models/IMySqlEntityStorageConnectorConfig.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,uCAAuC","sourcesContent":["// Copyright 2024 IOTA Stiftung.\n// SPDX-License-Identifier: Apache-2.0.\n\n/**\n * Configuration for the MySql Entity Storage Connector.\n */\nexport interface IMySqlEntityStorageConnectorConfig {\n\t/**\n\t * The host for the MySql instance.\n\t */\n\thost: string;\n\n\t/**\n\t * The port for the MySql instance.\n\t */\n\tport?: number;\n\n\t/**\n\t * The user for the MySql instance.\n\t */\n\tuser: string;\n\n\t/**\n\t * The password for the MySql instance.\n\t */\n\tpassword: string;\n\n\t/**\n\t * The name of the database to be used.\n\t */\n\tdatabase: string;\n\n\t/**\n\t * The name of the table to be used.\n\t */\n\ttableName: string;\n}\n"]}

package/dist/es/models/IMySqlEntityStorageConnectorConstructorOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IMySqlEntityStorageConnectorConstructorOptions.js.map

package/dist/es/models/IMySqlEntityStorageConnectorConstructorOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMySqlEntityStorageConnectorConstructorOptions.js","sourceRoot":"","sources":["../../../src/models/IMySqlEntityStorageConnectorConstructorOptions.ts"],"names":[],"mappings":"","sourcesContent":["// Copyright 2024 IOTA Stiftung.\n// SPDX-License-Identifier: Apache-2.0.\nimport type { IMySqlEntityStorageConnectorConfig } from \"./IMySqlEntityStorageConnectorConfig.js\";\n\n/**\n * The options for the MySql entity storage connector constructor.\n */\nexport interface IMySqlEntityStorageConnectorConstructorOptions {\n\t/**\n\t * The schema for the entity.\n\t */\n\tentitySchema: string;\n\n\t/**\n\t * The keys to use from the context ids to create partitions.\n\t */\n\tpartitionContextIds?: string[];\n\n\t/**\n\t * The type of logging component to use.\n\t * @default logging\n\t */\n\tloggingComponentType?: string;\n\n\t/**\n\t * The configuration for the connector.\n\t */\n\tconfig: IMySqlEntityStorageConnectorConfig;\n}\n"]}

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

@@ -1,27 +1,42 @@
-import { Guards, ComponentFactory, BaseError, GeneralError, Is, ObjectHelper } from '@twin.org/core';
-import { EntitySchemaFactory, EntitySchemaHelper, EntitySchemaPropertyType, SortDirection, ComparisonOperator, LogicalOperator } from '@twin.org/entity';
-import { createConnection } from 'mysql2/promise';
-
 // 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 { createConnection } from "mysql2/promise";
 /**
  * Class for performing entity storage operations using MySql.
  */
-class MySqlEntityStorageConnector {
+export class MySqlEntityStorageConnector {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "MySqlEntityStorageConnector";
     /**
      * 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
+     */
+    static _PARTITION_KEY = "partitionId";
+    /**
+     * Partition id field value.
+     * @internal
      */
-    CLASS_NAME = "MySqlEntityStorageConnector";
+    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 configuration for the connector.
      * @internal
@@ -32,22 +47,43 @@ class MySqlEntityStorageConnector {
      * @internal
      */
     _connection;
+    /**
+     * The primary key property.
+     * @internal
+     */
+    _primaryKeyProperty;
     /**
      * Create a new instance of MySqlEntityStorageConnector.
      * @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(MySqlEntityStorageConnector.CLASS_NAME, "options", options);
+        Guards.stringValue(MySqlEntityStorageConnector.CLASS_NAME, "options.entitySchema", options.entitySchema);
+        Guards.object(MySqlEntityStorageConnector.CLASS_NAME, "options.config", options.config);
+        Guards.stringValue(MySqlEntityStorageConnector.CLASS_NAME, "options.config.host", options.config.host);
+        Guards.stringValue(MySqlEntityStorageConnector.CLASS_NAME, "options.config.user", options.config.user);
+        Guards.stringValue(MySqlEntityStorageConnector.CLASS_NAME, "options.config.password", options.config.password);
+        Guards.stringValue(MySqlEntityStorageConnector.CLASS_NAME, "options.config.database", options.config.database);
+        Guards.stringValue(MySqlEntityStorageConnector.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;
     }
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className() {
+        return MySqlEntityStorageConnector.CLASS_NAME;
+    }
+    /**
+     * Get the schema for the entities.
+     * @returns The schema for the entities.
+     */
+    getSchema() {
+        return this._entitySchema;
+    }
     /**
      * Initialize the MySql environment.
      * @param nodeLoggingComponentType Optional type of the logging component.
@@ -57,59 +93,72 @@ class MySqlEntityStorageConnector {
         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
-                }
-            });
-            // Create the database if it does not exist
-            await dbConnection.query(`CREATE DATABASE IF NOT EXISTS \`${this._config.database}\``);
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "databaseExists",
-                data: {
-                    database: this._config.database
-                }
-            });
-            await dbConnection.query(`CREATE TABLE IF NOT EXISTS \`${this._config.database}\`.\`${this._config.tableName}\` (${this.mapMySqlProperties(this._entitySchema)})`);
-            await nodeLogging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "tableExists",
-                data: {
-                    table: this._config.tableName
-                }
-            });
+            const databaseExists = await this.databaseExists();
+            if (!databaseExists) {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: MySqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "databaseCreating",
+                    data: {
+                        databaseName: this._config.database
+                    }
+                });
+                await dbConnection.query(`CREATE DATABASE IF NOT EXISTS \`${this._config.database}\``);
+                await this.waitForDatabaseExists();
+            }
+            else {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: MySqlEntityStorageConnector.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: MySqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "tableCreating",
+                    data: {
+                        tableName: this._config.tableName
+                    }
+                });
+                await dbConnection.query(`CREATE TABLE IF NOT EXISTS \`${this._config.database}\`.\`${this._config.tableName}\` (${this.mapMySqlProperties()})`);
+                await this.waitForTableExists();
+            }
+            else {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: MySqlEntityStorageConnector.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "tableExists",
+                    data: {
+                        tableName: this._config.tableName
+                    }
+                });
+            }
         }
         catch (error) {
             await nodeLogging?.log({
                 level: "error",
-                source: this.CLASS_NAME,
+                source: MySqlEntityStorageConnector.CLASS_NAME,
                 ts: Date.now(),
                 message: "databaseCreateFailed",
                 error: BaseError.fromError(error),
                 data: {
-                    database: this._config.database
+                    databaseName: this._config.database
                 }
             });
             return false;
         }
         return true;
     }
-    /**
-     * Get the schema for the entities.
-     * @returns The schema for the entities.
-     */
-    getSchema() {
-        return this._entitySchema;
-    }
     /**
      * Get an entity from MySql.
      * @param id The id of the entity to get, or the index value if secondaryIndex is set.
@@ -118,26 +167,23 @@ class MySqlEntityStorageConnector {
      * @returns The object if it can be found or undefined.
      */
     async get(id, secondaryIndex, conditions) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+        Guards.stringValue(MySqlEntityStorageConnector.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(`\`${MySqlEntityStorageConnector._PARTITION_KEY}\` = ?`);
+            values.push(partitionKey ?? MySqlEntityStorageConnector._PARTITION_KEY_VALUE);
             if (secondaryIndex) {
                 whereClauses.push(`\`${String(secondaryIndex)}\` = ?`);
-                values.push(id);
             }
             else {
-                const primaryKeyProp = this._entitySchema.properties?.find(prop => prop.isPrimary);
-                if (primaryKeyProp) {
-                    whereClauses.push(`\`${String(primaryKeyProp.property)}\` = ?`);
-                }
-                else {
-                    whereClauses.push("`id` = ?");
-                }
-                values.push(id);
+                whereClauses.push(`\`${String(this._primaryKeyProperty.property)}\` = ?`);
             }
-            if (conditions) {
+            values.push(id);
+            if (Is.arrayValue(conditions)) {
                 for (const condition of conditions) {
                     whereClauses.push(`\`${String(condition.property)}\` = ?`);
                     values.push(condition.value);
@@ -145,12 +191,14 @@ class MySqlEntityStorageConnector {
             }
             const query = `SELECT * FROM \`${this._config.database}\`.\`${this._config.tableName}\` WHERE ${whereClauses.join(" AND ")} LIMIT 1`;
             const [rows] = await dbConnection.query(query, values);
-            if (Array.isArray(rows) && rows.length === 1) {
-                return rows[0];
+            if (Is.array(rows) && rows.length === 1) {
+                const item = ObjectHelper.removeEmptyProperties(rows[0], { removeNull: true });
+                ObjectHelper.propertyDelete(item, MySqlEntityStorageConnector._PARTITION_KEY);
+                return item;
             }
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "getFailed", {
+            throw new GeneralError(MySqlEntityStorageConnector.CLASS_NAME, "getFailed", {
                 id
             }, err);
         }
@@ -163,9 +211,11 @@ class MySqlEntityStorageConnector {
      * @returns The id of the entity.
      */
     async set(entity, conditions) {
-        Guards.object(this.CLASS_NAME, "entity", entity);
-        EntitySchemaHelper.validateEntity(entity, this.getSchema());
-        const id = entity["id"];
+        Guards.object(MySqlEntityStorageConnector.CLASS_NAME, "entity", entity);
+        const contextIds = await ContextIdStore.getContextIds();
+        const partitionKey = ContextIdHelper.combinedContextKey(contextIds, this._partitionContextIds);
+        EntitySchemaHelper.validateEntity(entity, this._entitySchema);
+        const id = entity[this._primaryKeyProperty.property];
         try {
             if (Is.arrayValue(conditions)) {
                 const itemData = await this.get(id);
@@ -173,27 +223,36 @@ class MySqlEntityStorageConnector {
                     return;
                 }
             }
-            const columns = Object.keys(entity)
-                .map(key => `\`${key}\``)
-                .join(", ");
-            const values = Object.values(entity);
-            for (const [index, value] of values.entries()) {
-                const property = Object.keys(entity)[index];
-                const schemaProp = this._entitySchema.properties?.find(p => p.property === property);
-                if (schemaProp?.type === EntitySchemaPropertyType.Object ||
-                    schemaProp?.type === EntitySchemaPropertyType.Array) {
-                    values[index] = JSON.stringify(value);
+            const finalEntity = ObjectHelper.clone(entity);
+            const props = [...(this._entitySchema.properties ?? [])];
+            props.unshift({
+                property: MySqlEntityStorageConnector._PARTITION_KEY,
+                type: EntitySchemaPropertyType.String
+            });
+            ObjectHelper.propertySet(finalEntity, MySqlEntityStorageConnector._PARTITION_KEY, partitionKey ?? MySqlEntityStorageConnector._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 (prop.type === EntitySchemaPropertyType.Object ||
+                        prop.type === EntitySchemaPropertyType.Array) {
+                        values.push(JSON.stringify(finalEntity[prop.property]));
+                    }
+                    else {
+                        values.push(finalEntity[prop.property]);
+                    }
                 }
             }
-            const placeholders = values.map(() => "?").join(", ");
+            let sql = `INSERT INTO \`${this._config.database}\`.\`${this._config.tableName}\``;
+            sql += ` (${keys.map(key => `\`${key}\``).join(", ")})`;
+            sql += ` VALUES (${values.map(() => "?").join(", ")})`;
+            sql += ` ON DUPLICATE KEY UPDATE ${keys.map(key => `\`${key}\` = VALUES(\`${key}\`)`).join(", ")};`;
             const dbConnection = await this.createConnection();
-            await dbConnection.query(`INSERT INTO \`${this._config.database}\`.\`${this._config.tableName}\` (${columns}) VALUES (${placeholders}) ON DUPLICATE KEY UPDATE ${columns
-                .split(", ")
-                .map(col => `${col} = VALUES(${col})`)
-                .join(", ")};`, values);
+            await dbConnection.query(sql, values);
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "setFailed", {
+            throw new GeneralError(MySqlEntityStorageConnector.CLASS_NAME, "setFailed", {
                 id
             }, err);
         }
@@ -205,25 +264,31 @@ class MySqlEntityStorageConnector {
      * @returns Nothing.
      */
     async remove(id, conditions) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+        Guards.stringValue(MySqlEntityStorageConnector.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);
+            const itemData = await this.get(id, undefined, conditions);
             if (Is.notEmpty(itemData)) {
-                const values = [id];
-                let whereClauses = [];
+                const values = [];
+                const whereClauses = [];
+                whereClauses.push(`\`${this._primaryKeyProperty.property}\` = ?`);
+                values.push(id);
+                whereClauses.push(`\`${MySqlEntityStorageConnector._PARTITION_KEY}\` = ?`);
+                values.push(partitionKey ?? MySqlEntityStorageConnector._PARTITION_KEY_VALUE);
                 if (Is.arrayValue(conditions)) {
-                    whereClauses = conditions.map(condition => {
+                    whereClauses.push(...conditions.map(condition => {
                         values.push(condition.value);
                         return `\`${String(condition.property)}\` = ?`;
-                    });
+                    }));
                 }
-                const query = `DELETE FROM \`${this._config.database}\`.\`${this._config.tableName}\` WHERE \`id\` = ?${whereClauses.length > 0 ? ` AND ${whereClauses.join(" AND ")}` : ""}`;
+                const query = `DELETE FROM \`${this._config.database}\`.\`${this._config.tableName}\` WHERE ${whereClauses.join(" AND ")}`;
                 await dbConnection.query(query, values);
             }
         }
         catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "removeFailed", {
+            throw new GeneralError(MySqlEntityStorageConnector.CLASS_NAME, "removeFailed", {
                 id
             }, err);
         }
@@ -233,17 +298,19 @@ class MySqlEntityStorageConnector {
      * @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 ?? MySqlEntityStorageConnector._PAGE_SIZE;
+            const returnSize = limit ?? MySqlEntityStorageConnector._DEFAULT_LIMIT;
             let orderByClause = "";
-            if (Array.isArray(sortProperties)) {
+            if (Is.array(sortProperties)) {
                 const orderClauses = [];
                 for (const sortProperty of sortProperties) {
                     const direction = sortProperty.sortDirection === SortDirection.Ascending ? "ASC" : "DESC";
@@ -253,21 +320,39 @@ class MySqlEntityStorageConnector {
             }
             const whereClauses = [];
             const values = [];
-            if (conditions) {
-                this.buildQueryParameters("", conditions, whereClauses, values);
+            const finalConditions = {
+                conditions: [],
+                logicalOperator: LogicalOperator.And
+            };
+            finalConditions.conditions.push({
+                property: MySqlEntityStorageConnector._PARTITION_KEY,
+                comparison: ComparisonOperator.Equals,
+                value: partitionKey ?? MySqlEntityStorageConnector._PARTITION_KEY_VALUE
+            });
+            if (!Is.empty(conditions)) {
+                finalConditions.conditions.push(conditions);
             }
-            const query = `SELECT ${properties ? properties.map(p => `\`${String(p)}\``).join(", ") : "*"} FROM \`${this._config.database}\`.\`${this._config.tableName}\` WHERE ${whereClauses.length > 0 ? whereClauses.join(" AND ") : "1"} ${orderByClause} LIMIT ${returnSize} OFFSET ${cursor ? Number(cursor) : 0}`;
+            this.buildQueryParameters("", finalConditions, whereClauses, values);
+            const startIndex = Coerce.number(cursor) ?? 0;
+            sql = `SELECT ${properties ? properties.map(p => `\`${String(p)}\``).join(", ") : "*"} FROM \`${this._config.database}\`.\`${this._config.tableName}\``;
+            sql += ` WHERE ${whereClauses.join(" AND ")} ${orderByClause}`;
+            sql += ` LIMIT ${returnSize} OFFSET ${startIndex}`;
             const dbConnection = await this.createConnection();
-            const [rows] = (await dbConnection?.query(query, values)) ?? [];
+            const [rows] = (await dbConnection.query(sql, values)) ?? [];
+            const entities = rows;
+            for (let i = 0; i < entities.length; i++) {
+                entities[i] = ObjectHelper.removeEmptyProperties(entities[i], { removeNull: true });
+                ObjectHelper.propertyDelete(entities[i], MySqlEntityStorageConnector._PARTITION_KEY);
+            }
             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(MySqlEntityStorageConnector.CLASS_NAME, "queryFailed", { sql }, err);
         }
     }
     /**
@@ -276,13 +361,105 @@ class MySqlEntityStorageConnector {
      */
     async tableDrop() {
         try {
-            const dbConnection = await this.createConnection();
-            await dbConnection?.query(`DROP TABLE \`${this._config.database}\`.\`${this._config.tableName}\`;`);
+            if (await this.tableExists()) {
+                const dbConnection = await this.createConnection();
+                await dbConnection.query(`DROP TABLE \`${this._config.database}\`.\`${this._config.tableName}\`;`);
+                await this.waitForTableNotExists();
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    /**
+     * Empty the table.
+     * @returns Nothing.
+     */
+    async tableEmpty() {
+        try {
+            if (await this.tableExists()) {
+                const dbConnection = await this.createConnection();
+                await dbConnection.query(`TRUNCATE TABLE \`${this._config.database}\`.\`${this._config.tableName}\`;`);
+            }
         }
         catch {
             // Ignore errors
         }
     }
+    /**
+     * Check if the database exists.
+     * @returns True if the database exists, false otherwise.
+     */
+    async databaseExists() {
+        try {
+            const dbConnection = await this.createConnection();
+            const [rows] = await dbConnection.query("SHOW DATABASES LIKE ?;", [this._config.database]);
+            return Is.arrayValue(rows);
+        }
+        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 [rows] = await dbConnection.query("SHOW TABLES FROM ?? LIKE ?", [
+                this._config.database,
+                this._config.tableName
+            ]);
+            return Is.arrayValue(rows);
+        }
+        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 MySql connection.
@@ -361,7 +538,7 @@ class MySqlEntityStorageConnector {
         prop += comparator.property;
         // prop = prop.replace(/\./g, "->");
         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(() => "?").join(", ");
             return `\`${prop}\` IN (${placeholders})`;
@@ -392,7 +569,7 @@ class MySqlEntityStorageConnector {
         else if (comparator.comparison === ComparisonOperator.Includes) {
             return `JSON_CONTAINS(\`${prop}\`, ?)`;
         }
-        throw new GeneralError(this.CLASS_NAME, "comparisonNotSupported", {
+        throw new GeneralError(MySqlEntityStorageConnector.CLASS_NAME, "comparisonNotSupported", {
             comparison: comparator.comparison
         });
     }
@@ -432,7 +609,9 @@ class MySqlEntityStorageConnector {
         else if (operator === LogicalOperator.Or) {
             return "OR";
         }
-        throw new GeneralError(this.CLASS_NAME, "conditionalNotSupported", { operator });
+        throw new GeneralError(MySqlEntityStorageConnector.CLASS_NAME, "conditionalNotSupported", {
+            operator
+        });
     }
     /**
      * Verify the conditions for the entity.
@@ -444,11 +623,10 @@ class MySqlEntityStorageConnector {
     }
     /**
      * Map entity schema properties to SQL properties.
-     * @param entitySchema The schema of the entity.
      * @returns The SQL properties as a string.
      * @throws GeneralError if the entity properties do not exist.
      */
-    mapMySqlProperties(entitySchema) {
+    mapMySqlProperties() {
         const sqlTypeMap = {
             [EntitySchemaPropertyType.String]: "LONGTEXT",
             [EntitySchemaPropertyType.Number]: "FLOAT",
@@ -457,11 +635,17 @@ class MySqlEntityStorageConnector {
             [EntitySchemaPropertyType.Array]: "JSON",
             [EntitySchemaPropertyType.Boolean]: "TINYINT(1)"
         };
-        if (!entitySchema.properties) {
-            throw new GeneralError(this.CLASS_NAME, "entitySchemaPropertiesUndefined");
+        if (!this._entitySchema.properties) {
+            throw new GeneralError(MySqlEntityStorageConnector.CLASS_NAME, "entitySchemaPropertiesUndefined");
         }
         const primaryKeys = [];
-        const columnDefinitions = entitySchema.properties
+        const props = [...this._entitySchema.properties];
+        props.unshift({
+            property: MySqlEntityStorageConnector._PARTITION_KEY,
+            type: EntitySchemaPropertyType.String,
+            isPrimary: true
+        });
+        const columnDefinitions = props
             .map(prop => {
             let sqlType = sqlTypeMap[prop.type] || "TEXT";
             if (prop.format) {
@@ -529,5 +713,4 @@ class MySqlEntityStorageConnector {
         return columnDefinitions + primaryKeyDefinition;
     }
 }
-
-export { MySqlEntityStorageConnector };
+//# sourceMappingURL=mysqlEntityStorageConnector.js.map