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

package/dist/cjs/index.cjs

@@ -1,523 +0,0 @@
-'use strict';
-
-var core = require('@twin.org/core');
-var entity = require('@twin.org/entity');
-var postgres = require('postgres');
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for performing entity storage operations using ql.
- */
-class PostgreSqlEntityStorageConnector {
-    /**
-     * Limit the number of entities when finding.
-     * @internal
-     */
-    static _PAGE_SIZE = 40;
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "PostgreSqlEntityStorageConnector";
-    /**
-     * The schema for the entity.
-     * @internal
-     */
-    _entitySchema;
-    /**
-     * The configuration for the connector.
-     * @internal
-     */
-    _config;
-    /**
-     * The configuration for the connector.
-     * @internal
-     */
-    _connection;
-    /**
-     * Create a new instance of PostgreSqlEntityStorageConnector.
-     * @param options The options for the connector.
-     */
-    constructor(options) {
-        core.Guards.object(this.CLASS_NAME, "options", options);
-        core.Guards.stringValue(this.CLASS_NAME, "options.entitySchema", options.entitySchema);
-        core.Guards.object(this.CLASS_NAME, "options.config", options.config);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.host", options.config.host);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.user", options.config.user);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.password", options.config.password);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.database", options.config.database);
-        core.Guards.stringValue(this.CLASS_NAME, "options.config.tableName", options.config.tableName);
-        this._entitySchema = entity.EntitySchemaFactory.get(options.entitySchema);
-        this._config = options.config;
-    }
-    /**
-     * Initialize the PostgreSql environment.
-     * @param nodeLoggingComponentType Optional type of the logging component.
-     * @returns A promise that resolves to a boolean indicating success.
-     */
-    async bootstrap(nodeLoggingComponentType) {
-        const nodeLogging = core.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) {
-                await dbConnection.unsafe(`CREATE DATABASE "${this._config.database}";`);
-            }
-            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)})`;
-                await dbConnection.unsafe(createTableQuery);
-            }
-            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,
-                ts: Date.now(),
-                message: "databaseCreateFailed",
-                error: core.BaseError.fromError(error),
-                data: {
-                    database: 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 PostgreSql.
-     * @param id The id of the entity to get, or the index value if secondaryIndex is set.
-     * @param secondaryIndex Get the item using a secondary index.
-     * @param conditions The optional conditions to match for the entities.
-     * @returns The object if it can be found or undefined.
-     */
-    async get(id, secondaryIndex, conditions) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
-        try {
-            const dbConnection = await this.createConnection();
-            const whereClauses = [];
-            const values = [];
-            if (secondaryIndex) {
-                whereClauses.push(`"${String(secondaryIndex)}" = $1`);
-                values.push(id);
-            }
-            else {
-                const primaryKey = entity.EntitySchemaHelper.getPrimaryKey(this.getSchema());
-                whereClauses.push(`"${primaryKey.property}" = $1`);
-                values.push(id);
-            }
-            if (conditions) {
-                for (const condition of conditions) {
-                    whereClauses.push(`"${String(condition.property)}" = $${values.length + 1}`);
-                    values.push(condition.value);
-                }
-            }
-            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 (this._entitySchema.properties) {
-                    for (const prop of this._entitySchema.properties) {
-                        const row = rows[0];
-                        let propColumn = prop.property;
-                        propColumn = propColumn.toLowerCase();
-                        if ((prop.type === entity.EntitySchemaPropertyType.Object ||
-                            prop.type === entity.EntitySchemaPropertyType.Array) &&
-                            typeof row[propColumn] === "string") {
-                            const rowValue = JSON.parse(rows[0][propColumn]);
-                            delete rows[0][propColumn];
-                            rows[0][prop.property] = rowValue;
-                        }
-                        if (row[propColumn] === null) {
-                            rows[0][prop.property] = undefined;
-                        }
-                    }
-                }
-                return rows[0];
-            }
-        }
-        catch (err) {
-            throw new core.GeneralError(this.CLASS_NAME, "getFailed", {
-                id
-            }, err);
-        }
-        return undefined;
-    }
-    /**
-     * Set an entity.
-     * @param entity The entity to set.
-     * @param conditions The optional conditions to match for the entities.
-     * @returns The id of the entity.
-     */
-    async set(entity$1, conditions) {
-        core.Guards.object(this.CLASS_NAME, "entity", entity$1);
-        entity.EntitySchemaHelper.validateEntity(entity$1, this.getSchema());
-        const primaryKey = entity.EntitySchemaHelper.getPrimaryKey(this.getSchema());
-        const id = entity$1[primaryKey.property];
-        try {
-            if (core.Is.arrayValue(conditions)) {
-                const itemData = await this.get(id);
-                if (core.Is.notEmpty(itemData) && !this.verifyConditions(conditions, itemData)) {
-                    return;
-                }
-            }
-            const columns = Object.keys(entity$1)
-                .map(key => `"${key}"`)
-                .join(", ");
-            // eslint-disable-next-line no-confusing-arrow
-            const values = Object.values(entity$1).map(value => value === undefined ? null : value);
-            const placeholders = values.map((_, index) => `$${index + 1}`).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);
-        }
-        catch (err) {
-            throw new core.GeneralError(this.CLASS_NAME, "setFailed", {
-                id
-            }, err);
-        }
-    }
-    /**
-     * Remove the entity.
-     * @param id The id of the entity to remove.
-     * @param conditions The optional conditions to match for the entities.
-     * @returns Nothing.
-     */
-    async remove(id, conditions) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
-        try {
-            const dbConnection = await this.createConnection();
-            const itemData = await this.get(id);
-            if (core.Is.notEmpty(itemData)) {
-                const values = [id];
-                let whereClauses = [];
-                if (core.Is.arrayValue(conditions)) {
-                    whereClauses = conditions.map(condition => {
-                        values.push(condition.value);
-                        return `"${String(condition.property)}" = $${values.length}`;
-                    });
-                }
-                const primaryKey = entity.EntitySchemaHelper.getPrimaryKey(this.getSchema());
-                const query = `DELETE FROM "${this._config.tableName}" WHERE "${primaryKey.property}" = $1${whereClauses.length > 0 ? ` AND ${whereClauses.join(" AND ")}` : ""}`;
-                await dbConnection.unsafe(query, values);
-            }
-        }
-        catch (err) {
-            throw new core.GeneralError(this.CLASS_NAME, "removeFailed", {
-                id
-            }, err);
-        }
-    }
-    /**
-     * Find all the entities which match the conditions.
-     * @param conditions The conditions to match for the entities.
-     * @param sortProperties The optional sort order.
-     * @param properties The optional properties to return, defaults to all.
-     * @param cursor The cursor to request the next page of entities.
-     * @param pageSize The suggested number of entities to return in each chunk, in some scenarios can return a different amount.
-     * @returns All the entities for the storage matching the conditions,
-     * and a cursor which can be used to request more entities.
-     */
-    async query(conditions, sortProperties, properties, cursor, pageSize) {
-        const sql = "";
-        try {
-            const returnSize = pageSize ?? PostgreSqlEntityStorageConnector._PAGE_SIZE;
-            let orderByClause = "";
-            if (Array.isArray(sortProperties)) {
-                const orderClauses = [];
-                for (const sortProperty of sortProperties) {
-                    const direction = sortProperty.sortDirection === entity.SortDirection.Ascending ? "ASC" : "DESC";
-                    orderClauses.push(`"${String(sortProperty.property)}" ${direction}`);
-                }
-                orderByClause = `ORDER BY ${orderClauses.join(", ")}`;
-            }
-            const whereClauses = [];
-            const values = [];
-            if (conditions) {
-                this.buildQueryParameters("", conditions, whereClauses, values);
-            }
-            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`;
-            const dbConnection = await this.createConnection();
-            const rows = await dbConnection.unsafe(query, values);
-            if (this._entitySchema.properties) {
-                for (const row of rows) {
-                    for (const prop of this._entitySchema.properties) {
-                        let propColumn = prop.property;
-                        propColumn = propColumn.toLowerCase();
-                        if ((prop.type === entity.EntitySchemaPropertyType.Object ||
-                            prop.type === entity.EntitySchemaPropertyType.Array) &&
-                            typeof row[propColumn] === "string") {
-                            const rowValue = JSON.parse(row[propColumn]);
-                            delete row[propColumn];
-                            row[prop.property] = rowValue;
-                        }
-                        if (row[propColumn] === null) {
-                            row[prop.property] = undefined;
-                        }
-                    }
-                }
-            }
-            return {
-                entities: rows,
-                cursor: Array.isArray(rows) && rows.length === returnSize
-                    ? String((cursor ? Number(cursor) : 0) + returnSize)
-                    : undefined
-            };
-        }
-        catch (err) {
-            throw new core.GeneralError(this.CLASS_NAME, "queryFailed", { sql }, err);
-        }
-    }
-    /**
-     * Drop the table.
-     * @returns Nothing.
-     */
-    async tableDrop() {
-        try {
-            const dbConnection = await this.createConnection();
-            await dbConnection.unsafe(`DROP TABLE ${this._config.tableName};`);
-        }
-        catch {
-            // Ignore errors
-        }
-    }
-    /**
-     * Create a new DB connection.
-     * @returns The PostgreSql connection.
-     * @internal
-     */
-    async createConnection() {
-        if (this._connection) {
-            return this._connection;
-        }
-        const newConnection = await postgres(this.createConnectionConfig());
-        this._connection = newConnection;
-        return newConnection;
-    }
-    /**
-     * Create a new DB connection configuration.
-     * @returns The PostgreSql connection configuration.
-     * @internal
-     */
-    createConnectionConfig() {
-        return {
-            host: this._config.host,
-            port: this._config.port ?? 5432,
-            user: this._config.user,
-            password: this._config.password
-        };
-    }
-    /**
-     * Create an SQL condition clause.
-     * @param objectPath The path for the nested object.
-     * @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.
-     * @internal
-     */
-    buildQueryParameters(objectPath, condition, whereClauses, values) {
-        if (core.Is.undefined(condition)) {
-            return;
-        }
-        if ("conditions" in condition) {
-            if (condition.conditions.length === 0) {
-                return;
-            }
-            const joinConditions = condition.conditions.map(c => {
-                const subWhereClauses = [];
-                const subValues = [];
-                this.buildQueryParameters(objectPath, c, subWhereClauses, subValues);
-                values.push(...subValues);
-                return subWhereClauses.join(" AND ");
-            });
-            const logicalOperator = this.mapConditionalOperator(condition.logicalOperator);
-            const queryClause = joinConditions.filter(j => j.length > 0).join(` ${logicalOperator} `);
-            if (queryClause.length > 0) {
-                whereClauses.push(`(${queryClause})`);
-            }
-            return;
-        }
-        const schemaProp = this._entitySchema.properties?.find(p => p.property === condition.property);
-        const comparison = this.mapComparisonOperator(objectPath, condition, schemaProp?.type, values);
-        whereClauses.push(comparison);
-    }
-    /**
-     * Map the framework comparison operators to those in MySQL.
-     * @param objectPath The prefix to use for the condition.
-     * @param comparator The operator to map.
-     * @param type The type of the property.
-     * @param values The values to use in the query.
-     * @returns The comparison expression.
-     * @throws GeneralError if the comparison operator is not supported.
-     * @internal
-     */
-    mapComparisonOperator(objectPath, comparator, type, values) {
-        let prop = objectPath;
-        if (prop.length > 0) {
-            prop += ".";
-        }
-        prop += comparator.property;
-        if (comparator.comparison === entity.ComparisonOperator.In) {
-            const inValues = Array.isArray(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(", ");
-            return `"${prop}" IN (${placeholders})`;
-        }
-        const dbValue = this.propertyToDbValue(comparator.value, type);
-        values.push(dbValue);
-        if (comparator.property.split(".").length > 1) {
-            const jsonPath = comparator.property
-                .split(".")
-                .slice(1)
-                .map((p, i, arr) => (i === arr.length - 1 ? `->> '${p}'` : `-> '${p}'`))
-                .join("");
-            return `("${comparator.property.split(".")[0]}"::jsonb ${jsonPath}) = $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.Equals) {
-            return `"${prop}" = $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.NotEquals) {
-            return `"${prop}" <> $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.GreaterThan) {
-            return `"${prop}" > $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.LessThan) {
-            return `"${prop}" < $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.GreaterThanOrEqual) {
-            return `"${prop}" >= $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.LessThanOrEqual) {
-            return `"${prop}" <= $${values.length}`;
-        }
-        else if (comparator.comparison === entity.ComparisonOperator.Includes) {
-            return `EXISTS (SELECT 1 FROM jsonb_array_elements("${prop}") elem WHERE elem @> $${values.length}::jsonb)`;
-        }
-        throw new core.GeneralError(this.CLASS_NAME, "comparisonNotSupported", {
-            comparison: comparator.comparison
-        });
-    }
-    /**
-     * Format a value to insert into DB.
-     * @param value The value to format.
-     * @param type The type for the property.
-     * @returns The value after conversion.
-     * @internal
-     */
-    propertyToDbValue(value, type) {
-        if (type === "string") {
-            return String(value);
-        }
-        else if (type === "number") {
-            return Number(value);
-        }
-        else if (type === "boolean") {
-            return Boolean(value);
-        }
-        else if (type === "array") {
-            return value;
-        }
-        if (core.Is.object(value)) {
-            return JSON.stringify(value);
-        }
-        return value;
-    }
-    /**
-     * Map the framework conditional operators to those in MySQL.
-     * @param operator The operator to map.
-     * @returns The conditional operator.
-     * @throws GeneralError if the conditional operator is not supported.
-     * @internal
-     */
-    mapConditionalOperator(operator) {
-        if ((operator ?? entity.LogicalOperator.And) === entity.LogicalOperator.And) {
-            return "AND";
-        }
-        else if (operator === entity.LogicalOperator.Or) {
-            return "OR";
-        }
-        throw new core.GeneralError(this.CLASS_NAME, "conditionalNotSupported", { operator });
-    }
-    /**
-     * Verify the conditions for the entity.
-     * @param conditions The conditions to verify.
-     * @internal
-     */
-    verifyConditions(conditions, obj) {
-        return conditions.every(condition => core.ObjectHelper.propertyGet(obj, condition.property) === condition.value);
-    }
-    /**
-     * 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.
-     */
-    mapPostgreSqlProperties(entitySchema) {
-        const sqlTypeMap = {
-            [entity.EntitySchemaPropertyType.String]: "TEXT",
-            [entity.EntitySchemaPropertyType.Number]: "REAL",
-            [entity.EntitySchemaPropertyType.Integer]: "INTEGER",
-            [entity.EntitySchemaPropertyType.Object]: "JSONB",
-            [entity.EntitySchemaPropertyType.Array]: "JSONB",
-            [entity.EntitySchemaPropertyType.Boolean]: "BOOLEAN"
-        };
-        if (!entitySchema.properties) {
-            throw new core.GeneralError(this.CLASS_NAME, "entitySchemaPropertiesUndefined");
-        }
-        const primaryKeys = [];
-        const columnDefinitions = entitySchema.properties
-            .map(prop => {
-            const sqlType = sqlTypeMap[prop.type] || "TEXT";
-            const columnName = String(prop.property);
-            const nullable = prop.optional ? " NULL" : " NOT NULL";
-            if (prop.isPrimary) {
-                primaryKeys.push(columnName);
-            }
-            return `"${columnName}" ${sqlType}${nullable}`;
-        })
-            .join(", ");
-        const primaryKeyDefinition = primaryKeys.length > 0 ? `, PRIMARY KEY (${primaryKeys.join(", ")})` : "";
-        return columnDefinitions + primaryKeyDefinition;
-    }
-}
-
-exports.PostgreSqlEntityStorageConnector = PostgreSqlEntityStorageConnector;