@twin.org/entity-storage-connector-scylladb 0.0.1-next.2

package/dist/esm/index.mjs

@@ -0,0 +1,864 @@
+import { Guards, Is, StringHelper, GeneralError, BaseError, NotSupportedError } from '@twin.org/core';
+import { EntitySchemaFactory, EntitySchemaHelper, ComparisonOperator, LogicalOperator, SortDirection, EntitySchemaPropertyType } from '@twin.org/entity';
+import { LoggingConnectorFactory } from '@twin.org/logging-models';
+import { Client, types } from 'cassandra-driver';
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Store entities using ScyllaDB.
+ */
+class AbstractScyllaDBConnector {
+    /**
+     * Limit the number of entities when finding.
+     * @internal
+     */
+    static PAGE_SIZE = 40;
+    /**
+     * Runtime name for the class.
+     * @internal
+     */
+    CLASS_NAME;
+    /**
+     * The name of the database table.
+     * @internal
+     */
+    _fullTableName;
+    /**
+     * Configuration to connection to ScyllaDB.
+     * @internal
+     */
+    _config;
+    /**
+     * The logging connector.
+     * @internal
+     */
+    _logging;
+    /**
+     * The schema for the entity.
+     * @internal
+     */
+    _entitySchema;
+    /**
+     * The primary key.
+     * @internal
+     */
+    _primaryKey;
+    /**
+     * Create a new instance of AbstractScyllaDBConnector.
+     * @param options The options for the connector.
+     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
+     * @param options.entitySchema The name of the entity schema.
+     * @param options.config The configuration for the connector.
+     * @param className The name of the derived class.
+     */
+    constructor(options, className) {
+        this.CLASS_NAME = className;
+        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.arrayValue(this.CLASS_NAME, "options.config.hosts", options.config.hosts);
+        Guards.stringValue(this.CLASS_NAME, "options.config.localDataCenter", options.config.localDataCenter);
+        Guards.stringValue(this.CLASS_NAME, "options.config.keyspace", options.config.keyspace);
+        if (Is.stringValue(options.loggingConnectorType)) {
+            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
+        }
+        this._entitySchema = EntitySchemaFactory.get(options.entitySchema);
+        this._primaryKey = EntitySchemaHelper.getPrimaryKey(this._entitySchema);
+        this._config = options.config;
+        this._fullTableName = StringHelper.camelCase(Is.stringValue(options.config.tableName) ? options.config.tableName : options.entitySchema);
+    }
+    /**
+     * Get an entity.
+     * @param id The id of the entity to get.
+     * @param secondaryIndex Get the item using a secondary index.
+     * @returns The object if it can be found or undefined.
+     */
+    async get(id, secondaryIndex) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        let connection;
+        try {
+            const indexField = secondaryIndex ?? this._primaryKey?.property;
+            let sql = `SELECT * FROM "${this._fullTableName}" WHERE "${String(indexField)}"=?`;
+            if (secondaryIndex) {
+                sql += "ALLOW FILTERING";
+            }
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "sql",
+                data: { sql }
+            });
+            connection = await this.openConnection();
+            const result = await this.queryDB(connection, sql, [id]);
+            if (result.rows.length === 1) {
+                return this.convertRowToObject(result.rows[0]);
+            }
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "getFailed", {
+                id
+            }, error);
+        }
+        finally {
+            await this.closeConnection(connection);
+        }
+    }
+    /**
+     * 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) {
+        let connection;
+        try {
+            let returnSize = pageSize ?? AbstractScyllaDBConnector.PAGE_SIZE;
+            let sql = `SELECT * FROM "${this._fullTableName}"`;
+            if (Is.array(properties)) {
+                const fields = [];
+                for (const property of properties) {
+                    fields.push(property.toString());
+                }
+                const selectFields = fields.join(",");
+                sql = sql.replace("*", selectFields);
+            }
+            const conds = [];
+            let conditionQuery = "";
+            // The params to be used to execute the query
+            const params = [];
+            let theConditions = [];
+            if (!Is.undefined(conditions)) {
+                if ("conditions" in conditions) {
+                    theConditions = conditions.conditions;
+                }
+                else {
+                    theConditions.push(conditions);
+                }
+            }
+            // TODO: This code needs refactoring to support conditions for sub properties.
+            for (const cond of theConditions) {
+                const condition = cond;
+                const descriptor = this._entitySchema.properties?.find(p => p.property === condition.property);
+                if (condition.comparison === ComparisonOperator.Includes ||
+                    condition.comparison === ComparisonOperator.NotIncludes) {
+                    const propValue = `'%${condition.value}%'`;
+                    if (condition.comparison === ComparisonOperator.Includes) {
+                        conds.push(`"${condition.property}" LIKE ${propValue}`);
+                    }
+                    else if (condition.comparison === ComparisonOperator.NotIncludes) {
+                        conds.push(`"${condition.property}" NOT LIKE ${propValue}`);
+                    }
+                }
+                else if (condition.comparison === ComparisonOperator.In) {
+                    let value = [];
+                    if (!Is.arrayValue(condition.value)) {
+                        value.push(this.propertyToDbValue(condition.value, descriptor));
+                    }
+                    else {
+                        value = condition.value.map(v => this.propertyToDbValue(v, descriptor));
+                    }
+                    params.push(value);
+                    conds.push(`"${condition.property}" IN ?`);
+                }
+                else {
+                    const propValue = condition.value;
+                    params.push(propValue);
+                    if (condition.comparison === ComparisonOperator.Equals) {
+                        conds.push(`"${condition.property}" = ?`);
+                    }
+                    else if (condition.comparison === ComparisonOperator.NotEquals) {
+                        conds.push(`"${condition.property}" <> ?`);
+                    }
+                    else if (condition.comparison === ComparisonOperator.GreaterThan) {
+                        conds.push(`"${condition.property}" > ?`);
+                    }
+                    else if (condition.comparison === ComparisonOperator.LessThan) {
+                        conds.push(`"${condition.property}" < ?`);
+                    }
+                    else if (condition.comparison === ComparisonOperator.GreaterThanOrEqual) {
+                        conds.push(`"${condition.property}" >= ?`);
+                    }
+                    else if (condition.comparison === ComparisonOperator.LessThanOrEqual) {
+                        conds.push(`"${condition.property}" <= ?`);
+                    }
+                }
+                const operator = conditions.logicalOperator ?? LogicalOperator.And;
+                conditionQuery = `${conds.join(` ${operator} `)}`;
+            }
+            if (conditionQuery.length > 0) {
+                sql += ` WHERE ${conditionQuery}`;
+            }
+            connection = await this.openConnection();
+            // TODO: Only supported one sort property at the moment. This code would need to be revised in a follow-up
+            if (Is.array(sortProperties) && sortProperties.length >= 1) {
+                const sortKey = sortProperties[0].property ?? this._primaryKey.property;
+                const sortDir = sortProperties[0].sortDirection ??
+                    this._entitySchema.properties?.find(e => e.property === sortKey)?.sortDirection;
+                let sqlSortDir = "asc";
+                if (sortDir === SortDirection.Descending) {
+                    sqlSortDir = "desc";
+                }
+                sql += ` ORDER BY "${String(sortKey)}" ${sqlSortDir.toUpperCase()}`;
+                // Disabling paging in order by situations
+                returnSize = 0;
+            }
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "sql",
+                data: { sql }
+            });
+            const result = await this.queryDB(connection, sql, params, cursor, returnSize);
+            const entities = [];
+            for (const row of result.rows) {
+                entities.push(this.convertRowToObject(row));
+            }
+            return {
+                entities,
+                cursor: Is.stringValue(result.pageState) ? result.pageState : undefined
+            };
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "findFailed", { table: this._fullTableName }, error);
+        }
+        finally {
+            await this.closeConnection(connection);
+        }
+    }
+    /**
+     * Open a new database connection.
+     * @param config The config for the connection.
+     * @param skipKeySpace Don't include the keyspace in the connection.
+     * @returns The new connection.
+     * @internal
+     */
+    async openConnection(skipKeySpace = false) {
+        const client = new Client({
+            contactPoints: this._config.hosts,
+            localDataCenter: this._config.localDataCenter,
+            keyspace: skipKeySpace ? undefined : this._config.keyspace
+        });
+        await client.connect();
+        return client;
+    }
+    /**
+     * Close database connection.
+     * @param connection The connection to close.
+     * @internal
+     */
+    async closeConnection(connection) {
+        if (!connection) {
+            return;
+        }
+        return connection.shutdown();
+    }
+    /**
+     * Query the database.
+     * @param connection The connection to query.
+     * @param sql The sql statement to execute.
+     * @param params The params to use when executing the query.
+     * @param state The state to use when it comes to pagination.
+     * @returns The rows.
+     * @internal
+     */
+    async queryDB(connection, sql, params, pageState, pageSize) {
+        return new Promise((resolve, reject) => {
+            const rows = [];
+            connection.eachRow(sql, params, {
+                prepare: true,
+                autoPage: false,
+                fetchSize: pageSize ?? AbstractScyllaDBConnector.PAGE_SIZE,
+                pageState
+            }, (n, row) => {
+                rows.push(row);
+            }, (err, res) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                res.rows = rows;
+                resolve(res);
+            });
+        });
+    }
+    /**
+     * Execute on the database.
+     * @param connection The connection to execute.
+     * @param sql The sql statement to execute.
+     * @internal
+     */
+    async execute(connection, sql, params) {
+        return connection.execute(sql, params, { prepare: true });
+    }
+    /**
+     * Create keyspace if it doesn't exist.
+     * @param connection The connection to perform the query with.
+     * @param keyspaceName The name of the keyspace to create.
+     * @internal
+     */
+    async createKeyspace(connection, keyspaceName) {
+        return this.execute(connection, `CREATE KEYSPACE IF NOT EXISTS "${keyspaceName}"
+            WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1}`);
+    }
+    /**
+     * Format a field from the DB.
+     * @param value The value to convert to original form.
+     * @param fieldDescriptor The descriptor for the field.
+     * @returns The value as a property for the object.
+     * @internal
+     */
+    dbValueToProperty(value, fieldDescriptor) {
+        if (fieldDescriptor.type === "object") {
+            if (value === "null" ||
+                value === "undefined" ||
+                value === "" ||
+                value === null ||
+                value === undefined) {
+                return;
+            }
+        }
+        else if (fieldDescriptor.type === "string" && fieldDescriptor.format === "json") {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                throw new GeneralError(this.CLASS_NAME, "parseJSONFailed", {
+                    name: fieldDescriptor.property,
+                    value
+                });
+            }
+        }
+        else if (fieldDescriptor.format === "uuid") {
+            return value.toString();
+        }
+        return value;
+    }
+    /**
+     * Format a value for the DB. As the driver takes care of conversion from Javascript
+     * @param value The value to format.
+     * @param fieldDescriptor The descriptor for the field
+     * @returns The value after conversion.
+     * @internal
+     */
+    propertyToDbValue(value, fieldDescriptor) {
+        if (fieldDescriptor) {
+            // eslint-disable-next-line no-constant-condition
+            if (fieldDescriptor.type === "string" && fieldDescriptor.format === "json") {
+                return Is.empty(value) ? "null" : this.jsonWrap(value);
+            }
+            else if (fieldDescriptor.format === "uuid") {
+                if (!Is.string(value)) {
+                    return;
+                }
+                return types.Uuid.fromString(value);
+            }
+            return value;
+        }
+    }
+    /**
+     * Convert a row back to an object.
+     * @param row The row to convert.
+     * @returns The row as an object.
+     * @internal
+     */
+    convertRowToObject(row) {
+        const obj = {};
+        for (const field of this._entitySchema.properties ?? []) {
+            const value = row[field.property];
+            if (value) {
+                obj[field.property] = this.dbValueToProperty(value, field);
+            }
+        }
+        return obj;
+    }
+    /**
+     * Wrap a string for DB format.
+     * @param value The value to wrap.
+     * @returns The wrapped string.
+     * @internal
+     */
+    stringWrap(value) {
+        if (value === undefined || value === null) {
+            return "''";
+        }
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    /**
+     * Wrap an object for json in DB format.
+     * @param value The value to wrap.
+     * @returns The wrapped string.
+     * @internal
+     */
+    jsonWrap(value) {
+        let json = JSON.stringify(value);
+        // eslint-disable-next-line no-control-regex
+        json = json.replace(/[\b\0\t\n\r\u001A\\]/g, s => {
+            switch (s) {
+                case "\0":
+                    return String.raw `\0`;
+                case "\n":
+                    return String.raw `\n`;
+                case "\r":
+                    return String.raw `\r`;
+                case "\b":
+                    return String.raw `\b`;
+                case "\t":
+                    return String.raw `\t`;
+                case "\u001A":
+                    return String.raw `\Z`;
+                default:
+                    return `\\${s}`;
+            }
+        });
+        return json;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Store entities using ScyllaDB.
+ */
+class ScyllaDBTableConnector extends AbstractScyllaDBConnector {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "ScyllaDBTableConnector";
+    /**
+     * Create a new instance of ScyllaDBTableConnector.
+     * @param options The options for the connector.
+     * @param options.loggingConnectorType The type of logging connector to use, defaults to "logging".
+     * @param options.entitySchema The name of the entity schema.
+     * @param options.config The configuration for the connector.
+     */
+    constructor(options) {
+        super(options, "ScyllaDBTableConnector");
+    }
+    /**
+     * Bootstrap the component by creating and initializing any resources it needs.
+     * @param nodeLoggingConnectorType The node logging connector type, defaults to "node-logging".
+     * @returns True if the bootstrapping process was successful.
+     */
+    async bootstrap(nodeLoggingConnectorType) {
+        const nodeLogging = LoggingConnectorFactory.getIfExists(nodeLoggingConnectorType ?? "node-logging");
+        nodeLogging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            ts: Date.now(),
+            message: "tableCreating",
+            data: { table: this._fullTableName }
+        });
+        try {
+            let dbConnection = await this.openConnection(true);
+            await this.createKeyspace(dbConnection, this._config.keyspace);
+            // Connection has to be closed and now open a new one with our keyspace
+            await this.closeConnection(dbConnection);
+            dbConnection = await this.openConnection();
+            // Need to find structured properties (declared as type: object)
+            const structuredProperties = this._entitySchema.properties?.filter(property => property.type === EntitySchemaPropertyType.Object ||
+                (property.type === EntitySchemaPropertyType.Array && property.itemTypeRef));
+            // Needs to support objects that may have itemRef other objects (to be done)
+            if (Is.array(structuredProperties)) {
+                for (const strProperty of structuredProperties) {
+                    const subTypeSchemaRef = strProperty.itemTypeRef;
+                    if (!Is.undefined(subTypeSchemaRef)) {
+                        const objSchema = EntitySchemaFactory.get(subTypeSchemaRef);
+                        const typeFields = [];
+                        for (const field of objSchema.properties ?? []) {
+                            typeFields.push(`"${String(field.property)}" ${this.toDbField(field)}`);
+                        }
+                        const sql = `CREATE TYPE IF NOT EXISTS
+																		"${subTypeSchemaRef}" (${typeFields.join(",")})`;
+                        await nodeLogging?.log({
+                            level: "info",
+                            source: this.CLASS_NAME,
+                            ts: Date.now(),
+                            message: "sql",
+                            data: { sql }
+                        });
+                        await this.execute(dbConnection, sql);
+                        await nodeLogging?.log({
+                            level: "info",
+                            source: this.CLASS_NAME,
+                            ts: Date.now(),
+                            message: "typeCreated",
+                            data: { typeName: subTypeSchemaRef }
+                        });
+                    }
+                }
+            }
+            const fields = [];
+            const primaryKeys = [];
+            const secondaryKeys = [];
+            for (const field of this._entitySchema.properties ?? []) {
+                fields.push(`"${String(field.property)}" ${this.toDbField(field)}`);
+                if (field.isPrimary) {
+                    primaryKeys.push(`"${field.property}"`);
+                }
+                if (field.isSecondary) {
+                    secondaryKeys.push(`"${field.property}"`);
+                }
+            }
+            fields.push(`PRIMARY KEY ((${primaryKeys.join(",")})`);
+            if (secondaryKeys.length > 0) {
+                fields.push(`${secondaryKeys.join(",")})`);
+            }
+            else {
+                fields[fields.length - 1] += ")";
+            }
+            const sql = `CREATE TABLE IF NOT EXISTS "${this._fullTableName}" (${fields.join(", ")})`;
+            await nodeLogging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "sql",
+                data: { sql }
+            });
+            await this.execute(dbConnection, sql);
+            await nodeLogging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "tableCreated",
+                data: { table: this._fullTableName }
+            });
+        }
+        catch (err) {
+            if (BaseError.isErrorCode(err, "ResourceInUseException")) {
+                await nodeLogging?.log({
+                    level: "info",
+                    source: this.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "tableExists",
+                    data: { table: this._fullTableName }
+                });
+            }
+            else {
+                await nodeLogging?.log({
+                    level: "error",
+                    source: this.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "tableCreateFailed",
+                    error: err,
+                    data: { table: this._fullTableName }
+                });
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Set an entity.
+     * @param entity The entity to set.
+     */
+    async set(entity) {
+        Guards.object(this.CLASS_NAME, "entity", entity);
+        let connection;
+        const id = entity[this._primaryKey?.property];
+        try {
+            const propNames = this._entitySchema.properties?.map(f => `"${String(f.property)}"`) ?? [];
+            const propValues = [];
+            const preparedValues = [];
+            const entityAsKeyValues = entity;
+            for (const propDesc of this._entitySchema.properties ?? []) {
+                const value = entityAsKeyValues[propDesc.property];
+                propValues.push(this.propertyToDbValue(value, propDesc));
+                preparedValues.push("?");
+            }
+            const sql = `INSERT INTO "${this._fullTableName}" (${propNames.join(",")}) VALUES (${preparedValues.join(",")})`;
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "sql",
+                data: { sql }
+            });
+            connection = await this.openConnection();
+            await this.execute(connection, sql, propValues);
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "entityStorage.setFailed", {
+                id
+            }, error);
+        }
+        finally {
+            await this.closeConnection(connection);
+        }
+    }
+    /**
+     * Delete the entity.
+     * @param id The id of the entity to remove.
+     */
+    async remove(id) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        let connection;
+        const primaryFieldValue = this.propertyToDbValue(id, this._primaryKey);
+        try {
+            const sql = `DELETE FROM "${this._fullTableName}" WHERE "${String(this._primaryKey?.property)}"=?`;
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "entityStorage.sqlRemove",
+                data: { sql }
+            });
+            connection = await this.openConnection();
+            await this.execute(connection, sql, [primaryFieldValue]);
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "removeFailed", {
+                id
+            }, error);
+        }
+        finally {
+            await this.closeConnection(connection);
+        }
+    }
+    /**
+     * Drops table.
+     */
+    async dropTable() {
+        let connection;
+        try {
+            connection = await this.openConnection();
+            await connection.execute(`DROP TABLE IF EXISTS "${this._fullTableName}"`);
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "dropTableFailed", { table: this._fullTableName }, error);
+        }
+        finally {
+            await this.closeConnection(connection);
+        }
+    }
+    /**
+     * Truncates (clear) table.
+     */
+    async truncateTable() {
+        let connection;
+        try {
+            connection = await this.openConnection();
+            await connection.execute(`TRUNCATE TABLE "${this._fullTableName}"`);
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "truncateTableFailed", { table: this._fullTableName }, error);
+        }
+        finally {
+            await this.closeConnection(connection);
+        }
+    }
+    /**
+     * Transform a logical description of a field into a DB field.
+     * @param logicalField The logical field description.
+     * @returns The DB type.
+     * @throws GeneralException if no mapping found.
+     * @internal
+     */
+    toDbField(logicalField) {
+        let dbType;
+        switch (logicalField.type) {
+            case "string":
+                dbType = "TEXT";
+                switch (logicalField.format) {
+                    case "uuid":
+                        dbType = "UUID";
+                        break;
+                    case "date":
+                    case "date-time":
+                        dbType = "TIMESTAMP";
+                        break;
+                }
+                break;
+            case "number":
+                dbType = "DOUBLE";
+                switch (logicalField.format) {
+                    case "float":
+                        dbType = "FLOAT";
+                        break;
+                    case "double":
+                        dbType = "DOUBLE";
+                        break;
+                }
+                break;
+            case "integer":
+                dbType = "INT";
+                switch (logicalField.format) {
+                    case "int8":
+                    case "uint8":
+                        dbType = "TINYINT";
+                        break;
+                    case "int16":
+                    case "uint16":
+                        dbType = "SMALLINT";
+                        break;
+                    case "int32":
+                    case "uint32":
+                        dbType = "INT";
+                        break;
+                    case "int64":
+                    case "uint64":
+                        dbType = "BIGINT";
+                        break;
+                }
+                break;
+            case "boolean":
+                dbType = "BOOLEAN";
+                break;
+            case "object":
+                if (!logicalField.itemTypeRef) {
+                    throw new GeneralError(this.CLASS_NAME, "itemTypeNotDefined", {
+                        type: logicalField.type,
+                        table: this._fullTableName
+                    });
+                }
+                dbType = `frozen<"${logicalField.itemTypeRef}">`;
+                break;
+            case "array":
+                if (!logicalField.itemType && !logicalField.itemTypeRef) {
+                    throw new GeneralError(this.CLASS_NAME, "itemTypeNotDefined", {
+                        type: logicalField.type,
+                        table: this._fullTableName
+                    });
+                }
+                if (logicalField.itemType) {
+                    dbType = `SET<${this.toDbField({
+                        property: logicalField.property,
+                        type: logicalField.itemType
+                    })}>`;
+                }
+                else {
+                    dbType = `SET<frozen<"${logicalField.itemTypeRef}">>`;
+                }
+                break;
+        }
+        return dbType;
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Manage entities using ScyllaDB Views.
+ */
+class ScyllaDBViewConnector extends AbstractScyllaDBConnector {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "ScyllaDBViewConnector";
+    /**
+     * The view descriptor.
+     * @internal
+     */
+    _viewSchema;
+    /**
+     * The name of the database table.
+     * @internal
+     */
+    _originalFullTableName;
+    /**
+     * Create a new instance of ScyllaDBViewConnector.
+     * @param options The options for the connector.
+     * @param options.loggingConnectorType The type of logging connector to use, defaults to "logging".
+     * @param options.entitySchema The name of the entity schema.
+     * @param options.viewSchema The name of the view schema.
+     * @param options.config The configuration for the connector.
+     */
+    constructor(options) {
+        // We need this conversion so that types can match in the superclass and reuse the get method
+        super({
+            loggingConnectorType: options.loggingConnectorType,
+            entitySchema: options.viewSchema,
+            config: options.config
+        }, "ScyllaDBViewConnector");
+        this._viewSchema = EntitySchemaHelper.getSchema(options.viewSchema);
+        // We need the underlying class to use the view name for lookups
+        // so substitute the view name for the entity name
+        // but store the original table name to use when bootstrapping the view
+        this._originalFullTableName = this._fullTableName;
+        this._fullTableName = StringHelper.camelCase(Is.stringValue(options.config.viewName) ? options.config.viewName : options.entitySchema);
+    }
+    /**
+     * Bootstrap the component by creating and initializing any resources it needs.
+     * @param nodeLoggingConnectorType The node logging connector type, defaults to "node-logging".
+     * @returns True if the bootstrapping process was successful.
+     */
+    async bootstrap(nodeLoggingConnectorType) {
+        const nodeLogging = LoggingConnectorFactory.getIfExists(nodeLoggingConnectorType ?? "node-logging");
+        nodeLogging?.log({
+            level: "info",
+            source: this.CLASS_NAME,
+            ts: Date.now(),
+            message: "viewCreating",
+            data: { view: this._fullTableName }
+        });
+        try {
+            const dbConnection = await this.openConnection(true);
+            await this.createKeyspace(dbConnection, this._config.keyspace);
+            const fields = [];
+            const primaryKeys = [];
+            for (const field of this._viewSchema.properties ?? []) {
+                fields.push(`"${String(field.property)}" IS NOT NULL `);
+                if (field.isPrimary) {
+                    primaryKeys.push(field.property);
+                }
+            }
+            fields.push(`PRIMARY KEY (${primaryKeys.join(",")})`);
+            const sql = `CREATE MATERIALIZED VIEW IF NOT EXISTS ${this._config.keyspace}.${this._fullTableName}
+            AS SELECT * FROM ${this._config.keyspace}.${this._originalFullTableName} WHERE
+            ${this._fullTableName} (${fields.join(" AND ")})`;
+            await this.execute(dbConnection, sql);
+            nodeLogging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "viewCreated",
+                data: { view: this._fullTableName }
+            });
+        }
+        catch (err) {
+            if (BaseError.isErrorCode(err, "ResourceInUseException")) {
+                nodeLogging?.log({
+                    level: "info",
+                    source: this.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "viewExists",
+                    data: { view: this._fullTableName }
+                });
+            }
+            else {
+                nodeLogging?.log({
+                    level: "error",
+                    source: this.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "viewCreateFailed",
+                    error: err,
+                    data: { view: this._fullTableName }
+                });
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Set an entity.
+     * @param entity The entity to set.
+     */
+    async set(entity) {
+        throw new NotSupportedError(this.CLASS_NAME, "set", {});
+    }
+    /**
+     * Delete the entity.
+     * @param id The id of the entity to remove.
+     */
+    async remove(id) {
+        throw new NotSupportedError(this.CLASS_NAME, "remove", {});
+    }
+}
+
+export { ScyllaDBTableConnector, ScyllaDBViewConnector };